public class CosmosContext : DbContext
    {
        public CosmosContext(DbContextOptions<CosmosContext> options) 
          : base(options) { }

        public DbSet<MyData> MyData { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.HasDefaultContainer("MyDataStore");

            modelBuilder.Entity<MyData>()
                .ToContainer("MyDataItems");

            modelBuilder.Entity<MyData>()
                .HasPartitionKey(o => o.PartitionKey);

            modelBuilder.Entity<MyData>()
                .Property(d => d.ETag)
                .IsETagConcurrency();
        }
    }

public class MyData
{
	public string Id { get; set; }
	public string PartitionKey { get; set; }
	public string Name { get; set; }
	public string Description { get; set; }
	public string ETag { get; set; }
}

public class MyDataService
{
	private CosmosContext _cosmosContext;

	public MyDataService(CosmosContext cosmosContext)
	{
		_cosmosContext = cosmosContext;
	}

	public void EnsureCreated()
	{
		_cosmosContext.Database.EnsureCreated();
	}

	public async Task CreateAsync(MyData myData)
	{
		await _cosmosContext.MyData.AddAsync(myData);
		await _cosmosContext.SaveChangesAsync(false);
	}

	public async Task<MyData> Get(string id)
	{
		return await _cosmosContext.MyData.FirstAsync(d => d.Id == id);
	}

	public async Task<IList<MyData>> NameContains(string name)
	{
		return await _cosmosContext.MyData
			.Where(d => d.Name.Contains(name)).ToListAsync();
	}
}

public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<CosmosContext>(options =>
            {
                options.UseCosmos(
                   "AccountEndpoint=https://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==",
                    databaseName: "MyDataDb"
               );
            });

            services.AddScoped<MyDataService>();
            services.AddRazorPages();
        }

using AspNetCoreCosmos.DataAccess;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Threading.Tasks;
using Xunit;

namespace AspNetCoreCosmos.DbTests
{
    public class MyDataTests : IAsyncLifetime
    {
        private ServiceProvider _serviceProvider;

        public ServiceProvider ServiceProvider { get; set; }

        [Fact]
        public async Task MyDataCreateAsync()
        {
            using (var scope = _serviceProvider.CreateScope())
            {
                // Arrange
                var myData = new MyData
                {
                    Id = Guid.NewGuid().ToString(),
                    PartitionKey = "Test",
                    Name = "testData",
                    Description = "test description"
                };

                var myDataService = scope.ServiceProvider.GetService<MyDataService>();
                myDataService.EnsureCreated();

                // Act
                await myDataService.CreateAsync(myData);
                var first = await myDataService.Get(myData.Id);

                // Arrange
                Assert.Equal(myData.Id, first.Id);
            }
        }

        public Task InitializeAsync()
        {
            var serviceCollection = new ServiceCollection();
            serviceCollection.AddDbContext<CosmosContext>(options =>
            {
                options.UseCosmos(
                   "AccountEndpoint=https://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==",
                    databaseName: "MyDataDb"
               );
            });

            serviceCollection.AddScoped<MyDataService>();

            _serviceProvider = serviceCollection.BuildServiceProvider();

            return Task.CompletedTask;
        }

        public Task DisposeAsync()
        {
            return Task.CompletedTask;
        }
    }
}

trigger:
- main

variables:
  solution: '**/*.sln'
  buildPlatform: 'Any CPU'
  buildConfiguration: 'Release'
  vmImage: 'windows-latest'

stages:
- stage: Build
  displayName: Build .NET sln
  pool:
      vmImage: $(vmImage)
  jobs:
  - job: Build
    displayName: Build
    pool:
      vmImage: $(vmImage)
    steps:
    - task: NuGetToolInstaller@1

    - task: NuGetCommand@2
      inputs:
        restoreSolution: '$(solution)'

    - task: VSBuild@1
      inputs:
        solution: '$(solution)'
        msbuildArgs: '/p:DeployOnBuild=true /p:WebPublishMethod=Package /p:PackageAsSingleFile=true /p:SkipInvalidConfigurations=true /p:DesktopBuildPackageLocation="$(build.artifactStagingDirectory)\WebApp.zip" /p:DeployIisAppPath="Default Web Site"'
        platform: '$(buildPlatform)'
        configuration: '$(buildConfiguration)'

    - task: VSTest@2
      inputs:
        platform: '$(buildPlatform)'
        configuration: '$(buildConfiguration)'

- stage: IntegrationTests
  displayName: Integration Tests
  dependsOn: Build
  pool:
      vmImage: $(vmImage)
  jobs:
  - job: intgrationtests
    displayName: Run integration tests
    steps:
    - task: DotNetCoreCLI@2
      displayName: Restore
      inputs:
        command: 'restore'

    - task: PowerShell@2
      displayName: 'Starting Cosmos Emulator'
      inputs:
        targetType: 'inline'
        workingDirectory: $(Pipeline.Workspace)
        script: |
           Write-Host "Starting CosmosDB Emulator"
           Import-Module "C:/Program Files/Azure Cosmos DB Emulator/PSModules/Microsoft.Azure.CosmosDB.Emulator"
           Start-CosmosDbEmulator

    - task: DotNetCoreCLI@2
      displayName: "Cosmos Database Tests"
      inputs:
        command: test
        projects: "**/*.DbTests.csproj"