.Net: [MEVD] Test cleanup pack (#13307)

This is an (almost) entirely test-only cleanup (I plan to do a bit more
later).

* Remove BasicQueryTests, rename BasicFilterTests to FilterTests and
move out to the root
* BasicFilterTests and BasicQueryTests both run the same filter
scenarios, the former via SearchAsync and the latter via filtering
GetAsync. Although in theory, some filter query construct could work in
one but not in the other, in practice no such example exists in the 12
providers we have (all databases use the same filter language/engine for
both APIs. So we had needless duplication for all the various test
exceptions/customizations, which had to be overridden in exactly the
same way in both test suites.
* At least for now, decided to remove BasicQueryTests as it adds
maintenance burden without any real coverage; coverage (included missing
coverage) specifically for filtered GetAsync was added separately (e.g.
we weren't testing ordering, skip/take with filtered get).
* If we do want to add back support for all query constructs (I'd want
to have a good reason to do so), I'd do that within FilterTests: just
like each scenario already exercises both static and dynamic models, it
could run GetAsync as well.
* Renamed CollectionConformanceTests to CollecitonManagementTests and
moved it out to the root.
* In general, this PR removes "Conformance" from the test type names.
* Big cleanup/refactor of all the so-called CRUD tests.
* We now have a ModelTests folder with a test suite for each different
model; BasicModelTests covers Get/Upsert/Delete (and their batching
variants) for the basic scenario (strongly-typed model with data
properties and a single vector property). Alongside that we have
DynamicModelTests, NoDataModelTests, NoVectorModelTests (I'll be added
MultipleVectorsModelTests).
* These tests no longer use random GUIDs for the collection name
(difficult to debug, the collection never gets cleaned up if the test
crashes/is stopped in the middle), but rather has fixed names per test
suite.
* The collection is created once per test suite, but cleared and
reseeded between each test run, providing full isolation (previously we
had no isolation, and documented each record in the seed data as
belonging to this scenario or that - which is brittle).
    * Many other small improvements and cleanup.

Part of #12507

Author: roji

.gitignore

@@ -415,6 +415,9 @@ FodyWeavers.xsd
 *.iml
 *.iws
 
+# VS Code
+.vscode/
+
 .env
 certs/
 launchSettings.json

dotnet/src/VectorData/CosmosNoSql/CosmosNoSqlCollection.cs

@@ -322,6 +322,8 @@ await this._database
     /// <inheritdoc />
     public override async Task<TRecord?> GetAsync(TKey key, RecordRetrievalOptions? options = null, CancellationToken cancellationToken = default)
     {
+        Verify.NotNull(key);
+
         return await this.GetAsync([key], options, cancellationToken)
             .FirstOrDefaultAsync(cancellationToken)
             .ConfigureAwait(false);
@@ -343,11 +345,17 @@ public override async IAsyncEnumerable<TRecord> GetAsync(
             throw new NotSupportedException(VectorDataStrings.IncludeVectorsNotSupportedWithEmbeddingGeneration);
         }
 
+        var compositeKeys = GetCompositeKeys(keys).ToList();
+        if (compositeKeys.Count == 0)
+        {
+            yield break;
+        }
+
         var queryDefinition = CosmosNoSqlCollectionQueryBuilder.BuildSelectQuery(
             this._model,
             this._model.KeyProperty.StorageName,
             this._partitionKeyProperty.StorageName,
-            GetCompositeKeys(keys).ToList(),
+            compositeKeys,
             includeVectors);
 
         await foreach (var jsonObject in this.GetItemsAsync<JsonObject>(queryDefinition, OperationName, cancellationToken).ConfigureAwait(false))

dotnet/src/VectorData/Redis/RedisJsonCollection.cs

@@ -289,6 +289,11 @@ public override async IAsyncEnumerable<TRecord> GetAsync(IEnumerable<TKey> keys,
         };
 #pragma warning restore CA1851 // Possible multiple enumerations of 'IEnumerable' collection
 
+        if (keysList.Count == 0)
+        {
+            yield break;
+        }
+
         // Create Options
         var maybePrefixedKeys = keysList.Select(key => this.PrefixKeyIfNeeded(key));
         var redisKeys = maybePrefixedKeys.Select(x => new RedisKey(x)).ToArray();
@@ -392,6 +397,11 @@ public override async Task UpsertAsync(IEnumerable<TRecord> records, Cancellatio
             redisRecords.Add((maybePrefixedKey, redisJsonRecord.Key, redisJsonRecord.SerializedRecord));
         }
 
+        if (redisRecords.Count == 0)
+        {
+            return;
+        }
+
         // Upsert.
         var keyPathValues = redisRecords.Select(x => new KeyPathValue(x.maybePrefixedKey, "$", x.serializedRecord)).ToArray();
         await this.RunOperationAsync(

dotnet/test/VectorData/AzureAISearch.ConformanceTests/AzureAISearchAllSupportedTypesTests.cs

@@ -0,0 +1,106 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using AzureAISearch.ConformanceTests.Support;
+using Microsoft.Extensions.VectorData;
+using VectorData.ConformanceTests.Xunit;
+using Xunit;
+
+namespace AzureAISearch.ConformanceTests;
+
+public class AzureAISearchAllSupportedTypesTests(AzureAISearchFixture fixture) : IClassFixture<AzureAISearchFixture>
+{
+    [ConditionalFact]
+    public async Task AllTypesBatchGetAsync()
+    {
+        var collection = fixture.TestStore.DefaultVectorStore.GetCollection<string, AzureAISearchAllTypes>("all-types", AzureAISearchAllTypes.GetRecordDefinition());
+        await collection.EnsureCollectionExistsAsync();
+
+        List<AzureAISearchAllTypes> records =
+        [
+            new()
+            {
+                Id = "all-types-1",
+                BoolProperty = true,
+                NullableBoolProperty = false,
+                StringProperty = "string prop 1",
+                NullableStringProperty = "nullable prop 1",
+                IntProperty = 1,
+                NullableIntProperty = 10,
+                LongProperty = 100L,
+                NullableLongProperty = 1000L,
+                FloatProperty = 10.5f,
+                NullableFloatProperty = 100.5f,
+                DoubleProperty = 23.75d,
+                NullableDoubleProperty = 233.75d,
+                DateTimeOffsetProperty = DateTimeOffset.UtcNow,
+                NullableDateTimeOffsetProperty = DateTimeOffset.UtcNow,
+                StringArray = ["one", "two"],
+                StringList = ["eleven", "twelve"],
+                BoolArray = [true, false],
+                BoolList = [true, false],
+                IntArray = [1, 2],
+                IntList = [11, 12],
+                LongArray = [100L, 200L],
+                LongList = [1100L, 1200L],
+                FloatArray = [1.5f, 2.5f],
+                FloatList = [11.5f, 12.5f],
+                DoubleArray = [1.5d, 2.5d],
+                DoubleList = [11.5d, 12.5d],
+                DateTimeOffsetArray = [DateTimeOffset.UtcNow, DateTimeOffset.UtcNow],
+                DateTimeOffsetList = [DateTimeOffset.UtcNow, DateTimeOffset.UtcNow],
+                Embedding = new ReadOnlyMemory<float>([1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 7.5f, 8.5f])
+            },
+            new()
+            {
+                Id = "all-types-2",
+                BoolProperty = false,
+                NullableBoolProperty = null,
+                StringProperty = "string prop 2",
+                NullableStringProperty = null,
+                IntProperty = 2,
+                NullableIntProperty = null,
+                LongProperty = 200L,
+                NullableLongProperty = null,
+                FloatProperty = 20.5f,
+                NullableFloatProperty = null,
+                DoubleProperty = 43.75,
+                NullableDoubleProperty = null,
+                Embedding = ReadOnlyMemory<float>.Empty,
+                // From https://learn.microsoft.com/en-us/rest/api/searchservice/supported-data-types:
+                // "All of the above types are nullable, except for collections of primitive and complex types, for example, Collection(Edm.String)"
+                // So for collections, we can't use nulls.
+                StringArray = [],
+                StringList = [],
+                BoolArray = [],
+                BoolList = [],
+                IntArray = [],
+                IntList = [],
+                LongArray = [],
+                LongList = [],
+                FloatArray = [],
+                FloatList = [],
+                DoubleArray = [],
+                DoubleList = [],
+                DateTimeOffsetArray = [],
+                DateTimeOffsetList = [],
+            }
+        ];
+
+        try
+        {
+            await collection.UpsertAsync(records);
+
+            var allTypes = await collection.GetAsync(records.Select(r => r.Id), new RecordRetrievalOptions { IncludeVectors = true }).ToListAsync();
+
+            var allTypes1 = allTypes.Single(x => x.Id == records[0].Id);
+            var allTypes2 = allTypes.Single(x => x.Id == records[1].Id);
+
+            records[0].AssertEqual(allTypes1);
+            records[1].AssertEqual(allTypes2);
+        }
+        finally
+        {
+            await collection.EnsureCollectionDeletedAsync();
+        }
+    }
+}

dotnet/test/VectorData/AzureAISearch.ConformanceTests/AzureAISearchCollectionManagementTests.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using AzureAISearch.ConformanceTests.Support;
+using VectorData.ConformanceTests;
+using Xunit;
+
+namespace AzureAISearch.ConformanceTests;
+
+public class AzureAISearchCollectionManagementTests(AzureAISearchFixture fixture)
+    : CollectionManagementTests<string>(fixture), IClassFixture<AzureAISearchFixture>
+{
+    // Azure AI search only supports lowercase letters, digits or dashes.
+    public override string CollectionName => "collection-tests";
+}

dotnet/test/VectorData/AzureAISearch.ConformanceTests/Filter/AzureAISearchBasicFilterTests.cs renamed to dotnet/test/VectorData/AzureAISearch.ConformanceTests/AzureAISearchFilterTests.cs

@@ -1,20 +1,20 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using AzureAISearch.ConformanceTests.Support;
-using VectorData.ConformanceTests.Filter;
+using VectorData.ConformanceTests;
 using VectorData.ConformanceTests.Support;
 using Xunit;
 
-namespace AzureAISearch.ConformanceTests.Filter;
+namespace AzureAISearch.ConformanceTests;
 
-public class AzureAISearchBasicFilterTests(AzureAISearchBasicFilterTests.Fixture fixture)
-    : BasicFilterTests<string>(fixture), IClassFixture<AzureAISearchBasicFilterTests.Fixture>
+public class AzureAISearchFilterTests(AzureAISearchFilterTests.Fixture fixture)
+    : FilterTests<string>(fixture), IClassFixture<AzureAISearchFilterTests.Fixture>
 {
     // Azure AI Search only supports search.in() over strings
     public override Task Contains_over_inline_int_array()
         => Assert.ThrowsAsync<NotSupportedException>(() => base.Contains_over_inline_int_array());
 
-    public new class Fixture : BasicFilterTests<string>.Fixture
+    public new class Fixture : FilterTests<string>.Fixture
     {
         public override TestStore TestStore => AzureAISearchTestStore.Instance;