[Internal] Binary Encoding: Adds emulator tests with binary encoding.

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosDatabaseTests.cs

@@ -606,7 +606,84 @@ public async Task DatabaseQueryIterator()
                     await database.DeleteAsync(cancellationToken: this.cancellationToken);
                 }
             }
-        }
+        }
+
+        [TestMethod]
+        [DataRow(true, DisplayName = "Database creation and deletion with binary encoding enabled.")]
+        [DataRow(false, DisplayName = "Database creation and deletion with binary encoding disabled.")]
+        public async Task DatabaseCreationDeletionWithBinaryEncodingTest(bool binaryEncodingEnabled)
+        {
+            string databaseId = Guid.NewGuid().ToString();
+            string originalBinaryEncodingValue = Environment.GetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled);
+
+            try
+            {
+                // Enable or disable binary encoding as requested
+                if (binaryEncodingEnabled)
+                {
+                    Environment.SetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled, "True");
+                }
+                else
+                {
+                    Environment.SetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled, null);
+                }
+
+                // Create the database using the existing client and pattern
+                DatabaseResponse createResponse = await this.GetClient().CreateDatabaseAsync(databaseId);
+                Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
+                Assert.IsNotNull(createResponse.Database);
+                Assert.IsNotNull(createResponse.Resource);
+                Assert.AreEqual(databaseId, createResponse.Resource.Id);
+
+                // Validate the database was created
+                Database createdDatabase = this.GetClient().GetDatabase(databaseId);
+                DatabaseResponse readResponse = await createdDatabase.ReadAsync();
+                Assert.AreEqual(HttpStatusCode.OK, readResponse.StatusCode);
+                Assert.IsNotNull(readResponse.Resource);
+                Assert.AreEqual(databaseId, readResponse.Resource.Id);
+
+                // Create a container to verify item operations under binary encoding
+                string containerId = Guid.NewGuid().ToString();
+                ContainerResponse containerResponse = await createdDatabase.CreateContainerAsync(new ContainerProperties(containerId, "/pk"));
+                Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
+
+                Container container = createdDatabase.GetContainer(containerId);
+                ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
+                ItemResponse<ToDoActivity> itemResponse = await container.CreateItemAsync(testItem, new PartitionKey(testItem.pk));
+                Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
+
+                // Delete the database
+                DatabaseResponse deleteDbResponse = await createdDatabase.DeleteAsync();
+                Assert.AreEqual(HttpStatusCode.NoContent, deleteDbResponse.StatusCode);
+
+                // Validate that the database no longer exists
+                try
+                {
+                    await createdDatabase.ReadAsync();
+                    Assert.Fail("Expected a NotFound exception after deleting the database.");
+                }
+                catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
+                {
+                    // Expected exception
+                }
+            }
+            finally
+            {
+                // Restore the original binary encoding environment variable value
+                Environment.SetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled, originalBinaryEncodingValue);
+
+                // Clean up if something fails before deletion
+                try
+                {
+                    Database databaseToCleanup = this.GetClient().GetDatabase(databaseId);
+                    await databaseToCleanup.DeleteAsync();
+                }
+                catch
+                {
+                    // Ignore exceptions in cleanup
+                }
+            }
+        }
 
         private Task<DatabaseResponse> CreateDatabaseHelper()
         {

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosItemTests.cs

@@ -668,6 +668,67 @@ public async Task NonPartitionKeyLookupCacheTest(bool binaryEncodingEnabledInCli
             {
                 Environment.SetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled, null);
             }
+        }
+
+        [TestMethod]
+        [DataRow(true, DisplayName = "Container creation and deletion with binary encoding enabled.")]
+        [DataRow(false, DisplayName = "Container creation and deletion with binary encoding disabled.")]
+        public async Task ContainerCreationDeletionTest(bool binaryEncodingEnabledInClient)
+        {
+            string containerId = Guid.NewGuid().ToString();
+            try
+            {
+                if (binaryEncodingEnabledInClient)
+                {
+                    Environment.SetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled, "True");
+                }
+
+                // Create the container
+                string partitionKeyPath = "/pk";
+                ContainerProperties containerProperties = new ContainerProperties(containerId, partitionKeyPath);
+                ContainerResponse createResponse = await this.database.CreateContainerAsync(containerProperties);
+                Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
+                Assert.IsNotNull(createResponse.Container);
+
+                // Perform a read operation to verify the container exists
+                Container readContainer = this.database.GetContainer(containerId);
+                ContainerResponse readResponse = await readContainer.ReadContainerAsync();
+                Assert.AreEqual(HttpStatusCode.OK, readResponse.StatusCode);
+                Assert.IsNotNull(readResponse.Resource);
+
+                ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
+                Cosmos.PartitionKey? partitionKey = testItem.pk != null ? new Cosmos.PartitionKey(testItem.pk) : (Cosmos.PartitionKey?)null;
+                ItemResponse<ToDoActivity> itemResponse = await readContainer.CreateItemAsync(testItem, partitionKey);
+                Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
+
+                // Delete the container
+                ContainerResponse deleteResponse = await readContainer.DeleteContainerAsync();
+                Assert.AreEqual(HttpStatusCode.NoContent, deleteResponse.StatusCode);
+
+                // Attempt to read the container again to ensure it was deleted
+                try
+                {
+                    await readContainer.ReadContainerAsync();
+                    Assert.Fail("Expected a NotFound exception after deleting the container.");
+                }
+                catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
+                {
+                    Assert.IsNotNull(ex);
+                }
+            }
+            finally
+            {
+                Environment.SetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled, null);
+                try
+                {
+                    Container container = this.database.GetContainer(containerId);
+                    await container.DeleteContainerAsync();
+                }
+                catch
+                {
+                    // Ignore exceptions in cleanup
+                }
+            }
         }
 
         [TestMethod]