chore: import upstream snapshot with attribution

dotnet/test/VectorData/Weaviate.ConformanceTests/ModelTests/WeaviateBasicModelTests.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.ModelTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests.ModelTests;
+
+public class WeaviateBasicModelTests_NamedVectors(WeaviateBasicModelTests_NamedVectors.Fixture fixture)
+    : BasicModelTests<Guid>(fixture), IClassFixture<WeaviateBasicModelTests_NamedVectors.Fixture>
+{
+    public new class Fixture : BasicModelTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}
+
+public class WeaviateBasicModelTests_UnnamedVectors(WeaviateBasicModelTests_UnnamedVectors.Fixture fixture)
+    : BasicModelTests<Guid>(fixture), IClassFixture<WeaviateBasicModelTests_UnnamedVectors.Fixture>
+{
+    public new class Fixture : BasicModelTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.UnnamedVectorInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/ModelTests/WeaviateDynamicModelTests.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.ModelTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests.ModelTests;
+
+public class WeaviateDynamicModelTests_NamedVectors(WeaviateDynamicModelTests_NamedVectors.Fixture fixture)
+    : DynamicModelTests<Guid>(fixture), IClassFixture<WeaviateDynamicModelTests_NamedVectors.Fixture>
+{
+    public new class Fixture : DynamicModelTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}
+
+public class WeaviateDynamicModelTests_UnnamedVectors(WeaviateDynamicModelTests_UnnamedVectors.Fixture fixture)
+    : DynamicModelTests<Guid>(fixture), IClassFixture<WeaviateDynamicModelTests_UnnamedVectors.Fixture>
+{
+    public new class Fixture : DynamicModelTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.UnnamedVectorInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/ModelTests/WeaviateMultiVectorModelTests.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.ModelTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests.ModelTests;
+
+public class WeaviateMultiVectorModelTests(WeaviateMultiVectorModelTests.Fixture fixture)
+    : MultiVectorModelTests<Guid>(fixture), IClassFixture<WeaviateMultiVectorModelTests.Fixture>
+{
+    public new class Fixture : MultiVectorModelTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/ModelTests/WeaviateNoDataModelTests.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.ModelTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests.ModelTests;
+
+public class WeaviateNoDataModelTests_NamedVectors(WeaviateNoDataModelTests_NamedVectors.Fixture fixture)
+    : NoDataModelTests<Guid>(fixture), IClassFixture<WeaviateNoDataModelTests_NamedVectors.Fixture>
+{
+    public new class Fixture : NoDataModelTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+
+        /// <summary>
+        /// Weaviate collections must start with an uppercase letter.
+        /// </summary>
+        protected override string CollectionNameBase => "NoDataNamedCollection";
+    }
+}
+
+public class WeaviateNoDataModelTests_UnnamedVector(WeaviateNoDataModelTests_UnnamedVector.Fixture fixture)
+    : NoDataModelTests<Guid>(fixture), IClassFixture<WeaviateNoDataModelTests_UnnamedVector.Fixture>
+{
+    public new class Fixture : NoDataModelTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.UnnamedVectorInstance;
+
+        /// <summary>
+        /// Weaviate collections must start with an uppercase letter.
+        /// </summary>
+        protected override string CollectionNameBase => "NoDataUnnamedCollection";
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/ModelTests/WeaviateNoVectorModelTests.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.ModelTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests.ModelTests;
+
+public class WeaviateNoVectorModelTests(WeaviateNoVectorModelTests.Fixture fixture)
+    : NoVectorModelTests<Guid>(fixture), IClassFixture<WeaviateNoVectorModelTests.Fixture>
+{
+    public new class Fixture : NoVectorModelTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/Properties/AssemblyInfo.cs

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.Xunit;
+
+[assembly: DisableTests(Skip = "Weaviate tests are failing on the build server with connection reset errors, but passing locally.")]

dotnet/test/VectorData/Weaviate.ConformanceTests/Support/TestContainer/WeaviateBuilder.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Docker.DotNet.Models;
+using DotNet.Testcontainers.Builders;
+using DotNet.Testcontainers.Configurations;
+
+namespace Weaviate.ConformanceTests.Support.TestContainer;
+
+public sealed class WeaviateBuilder : ContainerBuilder<WeaviateBuilder, WeaviateContainer, WeaviateConfiguration>
+{
+    public const string WeaviateImage = "semitechnologies/weaviate:1.28.12";
+    public const ushort WeaviateHttpPort = 8080;
+    public const ushort WeaviateGrpcPort = 50051;
+
+    public WeaviateBuilder() : this(new WeaviateConfiguration()) => this.DockerResourceConfiguration = this.Init().DockerResourceConfiguration;
+
+    private WeaviateBuilder(WeaviateConfiguration dockerResourceConfiguration) : base(dockerResourceConfiguration)
+        => this.DockerResourceConfiguration = dockerResourceConfiguration;
+
+    public override WeaviateContainer Build()
+    {
+        this.Validate();
+        return new WeaviateContainer(this.DockerResourceConfiguration);
+    }
+
+    protected override WeaviateBuilder Init()
+        => base.Init()
+            .WithImage(WeaviateImage)
+            .WithPortBinding(WeaviateHttpPort, true)
+            .WithPortBinding(WeaviateGrpcPort, true)
+            .WithEnvironment("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", "true")
+            .WithEnvironment("PERSISTENCE_DATA_PATH", "/var/lib/weaviate")
+            .WithWaitStrategy(Wait.ForUnixContainer()
+                .UntilInternalTcpPortIsAvailable(WeaviateHttpPort)
+                .UntilInternalTcpPortIsAvailable(WeaviateGrpcPort)
+                .UntilHttpRequestIsSucceeded(r => r.ForPath("/v1/.well-known/ready").ForPort(WeaviateHttpPort)));
+
+    protected override WeaviateBuilder Clone(IResourceConfiguration<CreateContainerParameters> resourceConfiguration)
+        => this.Merge(this.DockerResourceConfiguration, new WeaviateConfiguration(resourceConfiguration));
+
+    protected override WeaviateBuilder Merge(WeaviateConfiguration oldValue, WeaviateConfiguration newValue)
+        => new(new WeaviateConfiguration(oldValue, newValue));
+
+    protected override WeaviateConfiguration DockerResourceConfiguration { get; }
+
+    protected override WeaviateBuilder Clone(IContainerConfiguration resourceConfiguration)
+        => this.Merge(this.DockerResourceConfiguration, new WeaviateConfiguration(resourceConfiguration));
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/Support/TestContainer/WeaviateConfiguration.cs

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Docker.DotNet.Models;
+using DotNet.Testcontainers.Configurations;
+
+namespace Weaviate.ConformanceTests.Support.TestContainer;
+
+public sealed class WeaviateConfiguration : ContainerConfiguration
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WeaviateConfiguration" /> class.
+    /// </summary>
+    public WeaviateConfiguration()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WeaviateConfiguration" /> class.
+    /// </summary>
+    /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+    public WeaviateConfiguration(IResourceConfiguration<CreateContainerParameters> resourceConfiguration)
+        : base(resourceConfiguration)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WeaviateConfiguration" /> class.
+    /// </summary>
+    /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+    public WeaviateConfiguration(IContainerConfiguration resourceConfiguration)
+        : base(resourceConfiguration)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WeaviateConfiguration" /> class.
+    /// </summary>
+    /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+    public WeaviateConfiguration(WeaviateConfiguration resourceConfiguration)
+        : this(new WeaviateConfiguration(), resourceConfiguration)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WeaviateConfiguration" /> class.
+    /// </summary>
+    /// <param name="oldValue">The old Docker resource configuration.</param>
+    /// <param name="newValue">The new Docker resource configuration.</param>
+    public WeaviateConfiguration(WeaviateConfiguration oldValue, WeaviateConfiguration newValue)
+        : base(oldValue, newValue)
+    {
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/Support/TestContainer/WeaviateContainer.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using DotNet.Testcontainers.Containers;
+
+namespace Weaviate.ConformanceTests.Support.TestContainer;
+
+public class WeaviateContainer(WeaviateConfiguration configuration) : DockerContainer(configuration);

dotnet/test/VectorData/Weaviate.ConformanceTests/Support/WeaviateTestStore.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#if NET472
+using System.Net.Http;
+#endif
+using Microsoft.SemanticKernel.Connectors.Weaviate;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support.TestContainer;
+
+namespace Weaviate.ConformanceTests.Support;
+
+#pragma warning restore CA2213 // Disposable fields should be disposed
+
+public sealed class WeaviateTestStore : TestStore
+{
+    public static WeaviateTestStore NamedVectorsInstance { get; } = new(hasNamedVectors: true);
+    public static WeaviateTestStore UnnamedVectorInstance { get; } = new(hasNamedVectors: false);
+
+    public override string DefaultDistanceFunction => Microsoft.Extensions.VectorData.DistanceFunction.CosineDistance;
+
+    private readonly WeaviateContainer _container = new WeaviateBuilder().Build();
+    private readonly bool _hasNamedVectors;
+    public HttpClient? _httpClient { get; private set; }
+
+    public HttpClient Client => this._httpClient ?? throw new InvalidOperationException("Not initialized");
+
+    public WeaviateVectorStore GetVectorStore(WeaviateVectorStoreOptions options)
+        => new(this.Client, options);
+
+    private WeaviateTestStore(bool hasNamedVectors) => this._hasNamedVectors = hasNamedVectors;
+
+    protected override async Task StartAsync()
+    {
+        await this._container.StartAsync();
+        this._httpClient = new HttpClient { BaseAddress = new Uri($"http://localhost:{this._container.GetMappedPublicPort(WeaviateBuilder.WeaviateHttpPort)}/v1/") };
+        this.DefaultVectorStore = new WeaviateVectorStore(this._httpClient, new() { HasNamedVectors = this._hasNamedVectors });
+    }
+
+    protected override Task StopAsync()
+        => this._container.StopAsync();
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/TypeTests/WeaviateDataTypeTests.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.Support;
+using VectorData.ConformanceTests.TypeTests;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests.TypeTests;
+
+public class WeaviateDataTypeTests(WeaviateDataTypeTests.Fixture fixture)
+    : DataTypeTests<Guid, DataTypeTests<Guid>.DefaultRecord>(fixture), IClassFixture<WeaviateDataTypeTests.Fixture>
+{
+    public override Task String_array()
+        => this.Test<string[]>(
+            "StringArray",
+            ["foo", "bar"],
+            ["foo", "baz"],
+            isFilterable: false); // TODO: We don't currently support filtering on arrays
+
+    public new class Fixture : DataTypeTests<Guid, DataTypeTests<Guid>.DefaultRecord>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+
+        // TODO: Weaviate requires special indexing for filtering on nulls, see #10358
+        public override bool IsNullFilteringSupported => false;
+
+        public override Type[] UnsupportedDefaultTypes { get; } =
+        [
+#if NET
+            typeof(TimeOnly)
+#endif
+        ];
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/TypeTests/WeaviateEmbeddingTypeTests.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.Support;
+using VectorData.ConformanceTests.TypeTests;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+#pragma warning disable CA2000 // Dispose objects before losing scope
+
+namespace Weaviate.ConformanceTests.TypeTests;
+
+public class WeaviateEmbeddingTypeTests(WeaviateEmbeddingTypeTests.Fixture fixture)
+    : EmbeddingTypeTests<Guid>(fixture), IClassFixture<WeaviateEmbeddingTypeTests.Fixture>
+{
+    public new class Fixture : EmbeddingTypeTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/TypeTests/WeaviateKeyTypeTests.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests.Support;
+using VectorData.ConformanceTests.TypeTests;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests.TypeTests;
+
+public class WeaviateKeyTypeTests(WeaviateKeyTypeTests.Fixture fixture)
+    : KeyTypeTests(fixture), IClassFixture<WeaviateKeyTypeTests.Fixture>
+{
+    public new class Fixture : KeyTypeTests.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/Weaviate.ConformanceTests.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net10.0;net472</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsTestProject>true</IsTestProject>
+    <IsPackable>false</IsPackable>
+    <RootNamespace>Weaviate.ConformanceTests</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="Testcontainers" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\src\VectorData\Weaviate\Weaviate.csproj" />
+    <ProjectReference Include="..\VectorData.ConformanceTests\VectorData.ConformanceTests.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/test/VectorData/Weaviate.ConformanceTests/WeaviateCollectionManagementTests.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests;
+
+public class WeaviateCollectionManagementTests_NamedVectors(WeaviateCollectionManagementTests_NamedVectors.Fixture fixture)
+    : CollectionManagementTests<Guid>(fixture), IClassFixture<WeaviateCollectionManagementTests_NamedVectors.Fixture>
+{
+    public class Fixture : VectorStoreFixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}
+
+public class WeaviateCollectionManagementTests_UnnamedVector(WeaviateCollectionManagementTests_UnnamedVector.Fixture fixture)
+    : CollectionManagementTests<Guid>(fixture), IClassFixture<WeaviateCollectionManagementTests_UnnamedVector.Fixture>
+{
+    public class Fixture : VectorStoreFixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.UnnamedVectorInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/WeaviateDependencyInjectionTests.cs

@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.SemanticKernel.Connectors.Weaviate;
+using VectorData.ConformanceTests;
+using Xunit;
+
+namespace Weaviate.ConformanceTests;
+
+public class WeaviateDependencyInjectionTests
+    : DependencyInjectionTests<WeaviateVectorStore, WeaviateCollection<Guid, DependencyInjectionTests<Guid>.Record>, Guid, DependencyInjectionTests<Guid>.Record>
+{
+    private static readonly Uri s_endpoint = new("http://localhost");
+    private const string ApiKey = "Fake API Key";
+
+    protected override string CollectionName => "Uppercase";
+
+    protected override void PopulateConfiguration(ConfigurationManager configuration, object? serviceKey = null)
+        => configuration.AddInMemoryCollection(
+        [
+            new(CreateConfigKey("Weaviate", serviceKey, "Endpoint"), "http://localhost"),
+            new(CreateConfigKey("Weaviate", serviceKey, "ApiKey"), ApiKey),
+        ]);
+
+    private static Uri EndpointProvider(IServiceProvider sp, object? serviceKey = null)
+        => new(sp.GetRequiredService<IConfiguration>().GetRequiredSection(CreateConfigKey("Weaviate", serviceKey, "Endpoint")).Value!);
+
+    private static string ApiKeyProvider(IServiceProvider sp, object? serviceKey = null)
+        => sp.GetRequiredService<IConfiguration>().GetRequiredSection(CreateConfigKey("Weaviate", serviceKey, "ApiKey")).Value!;
+
+    public override IEnumerable<Func<IServiceCollection, object?, string, ServiceLifetime, IServiceCollection>> CollectionDelegates
+    {
+        get
+        {
+            yield return (services, serviceKey, name, lifetime) => serviceKey is null
+                ? services
+                    .AddSingleton<WeaviateCollectionOptions>(sp => new WeaviateCollectionOptions() { Endpoint = EndpointProvider(sp), ApiKey = ApiKeyProvider(sp) })
+                    .AddWeaviateCollection<Record>(name, lifetime: lifetime)
+                : services
+                    .AddSingleton<WeaviateCollectionOptions>(sp => new WeaviateCollectionOptions() { Endpoint = EndpointProvider(sp, serviceKey), ApiKey = ApiKeyProvider(sp, serviceKey) })
+                    .AddKeyedWeaviateCollection<Record>(serviceKey, name, lifetime: lifetime);
+
+            yield return (services, serviceKey, name, lifetime) => serviceKey is null
+                ? services.AddWeaviateCollection<Record>(name, s_endpoint, ApiKey, lifetime: lifetime)
+                : services.AddKeyedWeaviateCollection<Record>(serviceKey, name, s_endpoint, ApiKey, lifetime: lifetime);
+
+            yield return (services, serviceKey, name, lifetime) =>
+                services.AddKeyedWeaviateCollection<Record>(serviceKey, name, s_endpoint, ApiKey, lifetime: lifetime);
+        }
+    }
+
+    public override IEnumerable<Func<IServiceCollection, object?, ServiceLifetime, IServiceCollection>> StoreDelegates
+    {
+        get
+        {
+            yield return (services, serviceKey, lifetime) => serviceKey is null
+                ? services.AddWeaviateVectorStore(s_endpoint, ApiKey, lifetime: lifetime)
+                : services.AddKeyedWeaviateVectorStore(serviceKey, s_endpoint, ApiKey, lifetime: lifetime);
+
+            yield return (services, serviceKey, lifetime) => serviceKey is null
+                ? services
+                    .AddSingleton<WeaviateVectorStoreOptions>(sp => new WeaviateVectorStoreOptions() { Endpoint = EndpointProvider(sp), ApiKey = ApiKeyProvider(sp) })
+                    .AddWeaviateVectorStore(lifetime: lifetime)
+                : services
+                    .AddSingleton<WeaviateVectorStoreOptions>(sp => new WeaviateVectorStoreOptions() { Endpoint = EndpointProvider(sp, serviceKey), ApiKey = ApiKeyProvider(sp, serviceKey) })
+                    .AddKeyedWeaviateVectorStore(serviceKey, lifetime: lifetime);
+        }
+    }
+
+    [Fact]
+    public void EndpointCantBeNull()
+    {
+        IServiceCollection services = new ServiceCollection();
+
+        Assert.Throws<ArgumentNullException>(() => services.AddWeaviateVectorStore(endpoint: null!, apiKey: ApiKey));
+        Assert.Throws<ArgumentNullException>(() => services.AddKeyedWeaviateVectorStore(serviceKey: "notNull", endpoint: null!, apiKey: ApiKey));
+        Assert.Throws<ArgumentNullException>(() => services.AddWeaviateCollection<Record>(
+            name: "notNull", endpoint: null!, apiKey: ApiKey));
+        Assert.Throws<ArgumentNullException>(() => services.AddKeyedWeaviateCollection<Record>(
+            serviceKey: "notNull", name: "notNull", endpoint: null!, apiKey: ApiKey));
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/WeaviateDistanceFunctionTests.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests;
+
+public class WeaviateDistanceFunctionTests(WeaviateDistanceFunctionTests.Fixture fixture)
+    : DistanceFunctionTests<Guid>(fixture), IClassFixture<WeaviateDistanceFunctionTests.Fixture>
+{
+    public override Task CosineSimilarity() => Assert.ThrowsAsync<NotSupportedException>(base.CosineSimilarity);
+    public override Task DotProductSimilarity() => Assert.ThrowsAsync<NotSupportedException>(base.DotProductSimilarity);
+    public override Task EuclideanDistance() => Assert.ThrowsAsync<NotSupportedException>(base.EuclideanDistance);
+
+    public new class Fixture() : DistanceFunctionTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/WeaviateEmbeddingGenerationTests.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.VectorData;
+using VectorData.ConformanceTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests;
+
+public class WeaviateEmbeddingGenerationTests(WeaviateEmbeddingGenerationTests.StringVectorFixture fixture, WeaviateEmbeddingGenerationTests.RomOfFloatVectorFixture romOfFloatVectorFixture)
+    : EmbeddingGenerationTests<Guid>(fixture, romOfFloatVectorFixture), IClassFixture<WeaviateEmbeddingGenerationTests.StringVectorFixture>, IClassFixture<WeaviateEmbeddingGenerationTests.RomOfFloatVectorFixture>
+{
+    public new class StringVectorFixture : EmbeddingGenerationTests<Guid>.StringVectorFixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+
+        public override VectorStore CreateVectorStore(IEmbeddingGenerator? embeddingGenerator)
+            => WeaviateTestStore.NamedVectorsInstance.GetVectorStore(new() { EmbeddingGenerator = embeddingGenerator });
+
+        public override Func<IServiceCollection, IServiceCollection>[] DependencyInjectionStoreRegistrationDelegates =>
+        [
+            services => services
+                .AddSingleton(WeaviateTestStore.NamedVectorsInstance.Client)
+                .AddWeaviateVectorStore()
+        ];
+
+        public override Func<IServiceCollection, IServiceCollection>[] DependencyInjectionCollectionRegistrationDelegates =>
+        [
+            services => services
+                .AddSingleton(WeaviateTestStore.NamedVectorsInstance.Client)
+                .AddWeaviateCollection<RecordWithAttributes>(this.CollectionName)
+        ];
+    }
+
+    public new class RomOfFloatVectorFixture : EmbeddingGenerationTests<Guid>.RomOfFloatVectorFixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+
+        public override VectorStore CreateVectorStore(IEmbeddingGenerator? embeddingGenerator)
+            => WeaviateTestStore.NamedVectorsInstance.GetVectorStore(new() { EmbeddingGenerator = embeddingGenerator });
+
+        public override Func<IServiceCollection, IServiceCollection>[] DependencyInjectionStoreRegistrationDelegates =>
+        [
+            services => services
+                .AddSingleton(WeaviateTestStore.NamedVectorsInstance.Client)
+                .AddWeaviateVectorStore()
+        ];
+
+        public override Func<IServiceCollection, IServiceCollection>[] DependencyInjectionCollectionRegistrationDelegates =>
+        [
+            services => services
+                .AddSingleton(WeaviateTestStore.NamedVectorsInstance.Client)
+                .AddWeaviateCollection<RecordWithAttributes>(this.CollectionName)
+        ];
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/WeaviateFilterTests.cs

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Extensions.VectorData;
+using VectorData.ConformanceTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests;
+
+public class WeaviateFilterTests(WeaviateFilterTests.Fixture fixture)
+    : FilterTests<Guid>(fixture), IClassFixture<WeaviateFilterTests.Fixture>
+{
+    #region Filter by null
+
+    // Null-state indexing needs to be set up, but that's not supported yet (#10358).
+    // We could interact with Weaviate directly (not via the abstraction) to do this.
+
+    public override Task Equal_with_null_reference_type()
+        => Assert.ThrowsAsync<VectorStoreException>(base.Equal_with_null_reference_type);
+
+    public override Task Equal_with_null_captured()
+        => Assert.ThrowsAsync<VectorStoreException>(base.Equal_with_null_captured);
+
+    public override Task NotEqual_with_null_captured()
+        => Assert.ThrowsAsync<VectorStoreException>(base.NotEqual_with_null_captured);
+
+    public override Task NotEqual_with_null_reference_type()
+        => Assert.ThrowsAsync<VectorStoreException>(base.NotEqual_with_null_reference_type);
+
+    public override Task Equal_int_property_with_null_nullable_int()
+        => Assert.ThrowsAsync<VectorStoreException>(base.Equal_int_property_with_null_nullable_int);
+
+    #endregion
+
+    #region Not
+
+    // Weaviate currently doesn't support NOT (https://github.com/weaviate/weaviate/issues/3683)
+    public override Task Not_over_And()
+        => Assert.ThrowsAsync<NotSupportedException>(base.Not_over_And);
+
+    public override Task Not_over_Or()
+        => Assert.ThrowsAsync<NotSupportedException>(base.Not_over_Or);
+
+    #endregion
+
+    #region Unsupported Contains scenarios
+
+    public override Task Contains_over_captured_string_array()
+        => Assert.ThrowsAsync<NotSupportedException>(base.Contains_over_captured_string_array);
+
+    public override Task Contains_over_inline_int_array()
+        => Assert.ThrowsAsync<NotSupportedException>(base.Contains_over_inline_int_array);
+
+    public override Task Contains_over_inline_string_array()
+        => Assert.ThrowsAsync<NotSupportedException>(base.Contains_over_inline_int_array);
+
+    public override Task Contains_over_inline_string_array_with_weird_chars()
+        => Assert.ThrowsAsync<NotSupportedException>(base.Contains_over_inline_string_array_with_weird_chars);
+
+    #endregion
+
+    public new class Fixture : FilterTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/WeaviateHybridSearchTests.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests;
+using VectorData.ConformanceTests.Support;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests;
+
+public class WeaviateHybridSearchTests_NamedVectors(
+    WeaviateHybridSearchTests_NamedVectors.VectorAndStringFixture vectorAndStringFixture,
+    WeaviateHybridSearchTests_NamedVectors.MultiTextFixture multiTextFixture)
+    : HybridSearchTests<Guid>(vectorAndStringFixture, multiTextFixture),
+        IClassFixture<WeaviateHybridSearchTests_NamedVectors.VectorAndStringFixture>,
+        IClassFixture<WeaviateHybridSearchTests_NamedVectors.MultiTextFixture>
+{
+    public new class VectorAndStringFixture : HybridSearchTests<Guid>.VectorAndStringFixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+
+    public new class MultiTextFixture : HybridSearchTests<Guid>.MultiTextFixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}
+
+public class WeaviateHybridSearchTests_UnnamedVector(
+    WeaviateHybridSearchTests_UnnamedVector.VectorAndStringFixture vectorAndStringFixture,
+    WeaviateHybridSearchTests_UnnamedVector.MultiTextFixture multiTextFixture)
+    : HybridSearchTests<Guid>(vectorAndStringFixture, multiTextFixture),
+        IClassFixture<WeaviateHybridSearchTests_UnnamedVector.VectorAndStringFixture>,
+        IClassFixture<WeaviateHybridSearchTests_UnnamedVector.MultiTextFixture>
+{
+    public new class VectorAndStringFixture : HybridSearchTests<Guid>.VectorAndStringFixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.UnnamedVectorInstance;
+    }
+
+    public new class MultiTextFixture : HybridSearchTests<Guid>.MultiTextFixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.UnnamedVectorInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/WeaviateIndexKindTests.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Extensions.VectorData;
+using VectorData.ConformanceTests;
+using VectorData.ConformanceTests.Support;
+using VectorData.ConformanceTests.Xunit;
+using Weaviate.ConformanceTests.Support;
+using Xunit;
+
+namespace Weaviate.ConformanceTests;
+
+public class WeaviateIndexKindTests(WeaviateIndexKindTests.Fixture fixture)
+    : IndexKindTests<Guid>(fixture), IClassFixture<WeaviateIndexKindTests.Fixture>
+{
+    [ConditionalFact]
+    public virtual Task Hnsw()
+        => this.Test(IndexKind.Hnsw);
+
+    [ConditionalFact]
+    public virtual Task Dynamic()
+        => this.Test(IndexKind.Dynamic);
+
+    public new class Fixture() : IndexKindTests<Guid>.Fixture
+    {
+        public override TestStore TestStore => WeaviateTestStore.NamedVectorsInstance;
+    }
+}

dotnet/test/VectorData/Weaviate.ConformanceTests/WeaviateTestSuiteImplementationTests.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using VectorData.ConformanceTests;
+
+namespace Weaviate.ConformanceTests;
+
+public class WeaviateTestSuiteImplementationTests : TestSuiteImplementationTests;