Allow cosmos tests to run in parallel

test/EFCore.Cosmos.FunctionalTests/Properties/TestAssemblyCondition.cs

@@ -5,5 +5,7 @@
 
 [assembly: CosmosDbConfiguredCondition]
 
-// Waiting on Task causes deadlocks when run in parallel
-[assembly: CollectionBehavior(DisableTestParallelization = true)]
+// Emulator could experience performance degradation with more than 10 concurrent containers,
+// some tests might create multiple containers
+// https://learn.microsoft.com/en-us/azure/cosmos-db/emulator#differences-between-the-emulator-and-cloud-service
+[assembly: CollectionBehavior(MaxParallelThreads = 4)]

test/EFCore.Cosmos.FunctionalTests/TestUtilities/CosmosTestStore.cs

@@ -19,6 +19,8 @@ namespace Microsoft.EntityFrameworkCore.TestUtilities;
 
 public class CosmosTestStore : TestStore
 {
+    private static List<string>? _createdDatabases = [];
+    private static readonly SemaphoreSlim _collectionsSemaphore = new(1);
     private readonly TestStoreContext _storeContext;
     private readonly string? _dataFilePath;
     private readonly Action<CosmosDbContextOptionsBuilder> _configureCosmos;
@@ -75,9 +77,19 @@ private CosmosTestStore(
     }
 
     private static string CreateName(string name)
-        => TestEnvironment.IsEmulator || name == "Northwind" || name == "Northwind2" || name == "Northwind3"
-            ? name
-            : name + _runId;
+    {
+        if (TestEnvironment.IsEmulator)
+        {
+            return "EF-" + Guid.NewGuid().ToString();
+        }
+
+        if (name == "Northwind" || name == "Northwind2" || name == "Northwind3")
+        {
+            return name;
+        }
+
+        return name + _runId;
+    }
 
     public string ConnectionUri { get; }
     public string AuthToken { get; }
@@ -108,6 +120,7 @@ public static async ValueTask<bool> IsConnectionAvailableAsync()
             {
                 _connectionSemaphore.Release();
             }
+
         }
 
         return _connectionAvailable.Value;
@@ -120,6 +133,25 @@ private static async Task<bool> TryConnectAsync()
         {
             testStore = await CreateInitializedAsync("NonExistent").ConfigureAwait(false);
 
+            if (TestEnvironment.IsEmulator)
+            {
+                var client = testStore.CreateDefaultContext().Database.GetCosmosClient();
+                using var iterator = client.GetDatabaseQueryIterator<DatabaseProperties>();
+
+                while (iterator.HasMoreResults)
+                {
+                    var response = await iterator.ReadNextAsync();
+
+                    foreach (var db in response.Where(x => x.Id.StartsWith("EF-") && !_createdDatabases!.Contains(x.Id)))
+                    {
+                        await client.GetDatabase(db.Id).DeleteAsync();
+                    }
+                }
+
+                _createdDatabases = null;
+            }
+
+
             return true;
         }
         catch (AggregateException aggregate)
@@ -179,13 +211,33 @@ protected override async Task InitializeAsync(Func<DbContext> createContext, Fun
         }
     }
 
+    private async Task<bool> ContextEnsureCreated(DbContext context)
+    {
+        var aquired = false;
+        if (TestEnvironment.IsEmulator)
+        {
+            aquired = await _collectionsSemaphore.WaitAsync(60_000);
+        }
+        try
+        {
+            return await context.Database.EnsureCreatedAsync().ConfigureAwait(false);
+        }
+        finally
+        {
+            if (aquired)
+            {
+                _collectionsSemaphore.Release();
+            }
+        }
+    }
+
     private async Task CreateFromFile(DbContext context)
     {
         if (await EnsureCreatedAsync(context).ConfigureAwait(false))
         {
             if (!TestEnvironment.UseTokenCredential)
             {
-                await context.Database.EnsureCreatedAsync().ConfigureAwait(false);
+                await ContextEnsureCreated(context).ConfigureAwait(false);
             }
             else
             {
@@ -267,7 +319,13 @@ public async Task<bool> EnsureCreatedAsync(DbContext context, CancellationToken
         if (!TestEnvironment.UseTokenCredential)
         {
             var cosmosClientWrapper = context.GetService<ICosmosClientWrapper>();
-            return await cosmosClientWrapper.CreateDatabaseIfNotExistsAsync(null, cancellationToken).ConfigureAwait(false);
+            var r = await cosmosClientWrapper.CreateDatabaseIfNotExistsAsync(null, cancellationToken).ConfigureAwait(false);
+            if (r)
+            {
+                _createdDatabases?.Add(Name);
+            }
+
+            return r;
         }
 
         var databaseAccount = await GetDBAccount(cancellationToken).ConfigureAwait(false);
@@ -293,7 +351,8 @@ public async Task<bool> EnsureCreatedAsync(DbContext context, CancellationToken
         {
             sqlDatabaseCreateUpdateContent.Options = new CosmosDBCreateUpdateConfig
             {
-                Throughput = modelThroughput.Throughput, AutoscaleMaxThroughput = modelThroughput.AutoscaleMaxThroughput
+                Throughput = modelThroughput.Throughput,
+                AutoscaleMaxThroughput = modelThroughput.AutoscaleMaxThroughput
             };
         }
 
@@ -349,7 +408,8 @@ public override async Task CleanAsync(DbContext context, bool createTables = tru
 
             if (!TestEnvironment.UseTokenCredential)
             {
-                created = await context.Database.EnsureCreatedAsync().ConfigureAwait(false);
+                created = await ContextEnsureCreated(context).ConfigureAwait(false);
+
                 if (!created)
                 {
                     await SeedAsync(context).ConfigureAwait(false);
@@ -406,7 +466,8 @@ private async Task CreateContainersAsync(DbContext context)
             {
                 content.Options = new CosmosDBCreateUpdateConfig
                 {
-                    AutoscaleMaxThroughput = container.Throughput.AutoscaleMaxThroughput, Throughput = container.Throughput.Throughput
+                    AutoscaleMaxThroughput = container.Throughput.AutoscaleMaxThroughput,
+                    Throughput = container.Throughput.Throughput
                 };
             }
 

test/EFCore.Specification.Tests/Query/Translations/Temporal/DateTimeTranslationsTestBase.cs

@@ -86,11 +86,11 @@ public virtual Task subtract_and_TotalDays()
         return AssertQuery(ss => ss.Set<BasicTypesEntity>().Where(o => (o.DateTime - date).TotalDays > 365));
     }
 
-    [ConditionalFact]
+    [ConditionalFact(Skip = "Locale")]
     public virtual Task Parse_with_constant()
         => AssertQuery(ss => ss.Set<BasicTypesEntity>().Where(o => o.DateTime == DateTime.Parse("5/4/1998 15:30:10 PM")));
 
-    [ConditionalFact]
+    [ConditionalFact(Skip = "Locale")]
     public virtual Task Parse_with_parameter()
     {
         var date = "5/4/1998 15:30:10 PM";