public async void Should_insert_an_entity()
            {
                // Arrange
                const string partitionName = "InsertAsync";
                const string rowKey        = "MyKey";
                const string expectedValue = "SomeValue";
                var          entity        = new SomeTestEntity
                {
                    PartitionKey = partitionName,
                    RowKey       = rowKey,
                    SomeProp     = expectedValue
                };

                var persistedEntity = await RepositoryUnderTest.ReadOneAsync(partitionName, rowKey);

                if (persistedEntity != null)
                {
                    await RepositoryUnderTest.DeleteOneAsync(partitionName, rowKey);
                }

                // Act
                var result = await RepositoryUnderTest.InsertAsync(entity);

                // Assert
                Assert.NotNull(result);
                var dbResult = await RepositoryUnderTest.ReadOneAsync(partitionName, rowKey);

                Assert.NotNull(dbResult);
                Assert.Equal(expectedValue, dbResult.SomeProp);
            }
            public async void Should_delete_a_partition()
            {
                // Arrange
                const string partitionName = "DeletePartitionAsync";
                var          entity1       = new SomeTestEntity
                {
                    PartitionKey = partitionName,
                    RowKey       = "MyKey1"
                };
                var entity2 = new SomeTestEntity
                {
                    PartitionKey = partitionName,
                    RowKey       = "MyKey2"
                };
                await RepositoryUnderTest.InsertOrReplaceAsync(entity1);

                await RepositoryUnderTest.InsertOrReplaceAsync(entity2);

                // Act
                var result = await RepositoryUnderTest.DeletePartitionAsync(partitionName);

                // Assert
                Assert.NotNull(result);
                Assert.Equal(2, result.Count());
                var dbResult = await RepositoryUnderTest.ReadPartitionAsync(partitionName);

                Assert.NotNull(dbResult);
                Assert.Equal(0, dbResult.Count());
            }
            public async void Should_insert_or_replace_an_entity()
            {
                // Arrange
                const string partitionName = "InsertOrReplaceAsync";
                const string rowKey        = "MyKey";
                var          entity        = new SomeTestEntity
                {
                    PartitionKey = partitionName,
                    RowKey       = rowKey
                };

                // Act
                var result = await RepositoryUnderTest.InsertOrReplaceAsync(entity);

                // Assert
                Assert.NotNull(result);
            }
            public async void Should_delete_an_entity()
            {
                // Arrange
                const string partitionName = "DeleteOneAsync";
                const string rowKey        = "MyKey";
                var          entity        = new SomeTestEntity
                {
                    PartitionKey = partitionName,
                    RowKey       = rowKey
                };
                await RepositoryUnderTest.InsertOrReplaceAsync(entity);

                // Act
                var result = await RepositoryUnderTest.DeleteOneAsync(partitionName, rowKey);

                // Assert
                Assert.NotNull(result);
                var dbResult = await RepositoryUnderTest.ReadOneAsync(partitionName, rowKey);

                Assert.Null(dbResult);
            }
            public async void Should_return_an_entity()
            {
                // Arrange
                const string partitionName = "ReadOneAsync";
                const string rowKey        = "MyKey";
                const string expectedValue = "SomeValue";
                var          entity        = new SomeTestEntity
                {
                    PartitionKey = partitionName,
                    RowKey       = rowKey,
                    SomeProp     = expectedValue
                };
                await RepositoryUnderTest.InsertOrReplaceAsync(entity);

                // Act
                var result = await RepositoryUnderTest.ReadOneAsync(partitionName, rowKey);

                // Assert
                Assert.NotNull(result);
                Assert.Equal(partitionName, result.PartitionKey);
                Assert.Equal(rowKey, result.RowKey);
                Assert.Equal(expectedValue, result.SomeProp);
            }