[SM-394] Secrets Manager (#2164)

Long lived feature branch for Secrets Manager Co-authored-by: Thomas Avery <43214426+Thomas-Avery@users.noreply.github.com> Co-authored-by: cd-bitwarden <106776772+cd-bitwarden@users.noreply.github.com> Co-authored-by: CarleyDiaz-Bitwarden <103955722+CarleyDiaz-Bitwarden@users.noreply.github.com> Co-authored-by: Thomas Avery <tavery@bitwarden.com> Co-authored-by: Colton Hurst <colton@coltonhurst.com>
2025-06-30 07:36:14 -05:00 · 2023-01-13 15:02:53 +01:00
parent 09e524c9a2
commit 1f0fc43278
188 changed files with 21346 additions and 329 deletions
--- a/test/Api.IntegrationTest/Controllers/AccountsControllerTests.cs
+++ b/test/Api.IntegrationTest/Controllers/AccountsControllerTests.cs
--- a/test/Api.IntegrationTest/Controllers/ProjectsControllerTest.cs
+++ b/test/Api.IntegrationTest/Controllers/ProjectsControllerTest.cs
@ -0,0 +1,181 @@
+using System.Net.Http.Headers;
+using System.Text.Json;
+using Bit.Api.IntegrationTest.Factories;
+using Bit.Api.IntegrationTest.Helpers;
+using Bit.Api.SecretManagerFeatures.Models.Request;
+using Bit.Core.Entities;
+using Bit.Core.Repositories;
+using Bit.Test.Common.Helpers;
+using Xunit;
+
+namespace Bit.Api.IntegrationTest.Controllers;
+
+public class ProjectsControllerTest : IClassFixture<ApiApplicationFactory>, IAsyncLifetime
+{
+    private readonly string _mockEncryptedString =
+        "2.3Uk+WNBIoU5xzmVFNcoWzz==|1MsPIYuRfdOHfu/0uY6H2Q==|/98sp4wb6pHP1VTZ9JcNCYgQjEUMFPlqJgCwRk1YXKg=";
+
+    private readonly HttpClient _client;
+    private readonly ApiApplicationFactory _factory;
+    private readonly IProjectRepository _projectRepository;
+    private Organization _organization = null!;
+
+    public ProjectsControllerTest(ApiApplicationFactory factory)
+    {
+        _factory = factory;
+        _client = _factory.CreateClient();
+        _projectRepository = _factory.GetService<IProjectRepository>();
+    }
+
+    public async Task InitializeAsync()
+    {
+        var ownerEmail = $"integration-test{Guid.NewGuid()}@bitwarden.com";
+        var tokens = await _factory.LoginWithNewAccount(ownerEmail);
+        var (organization, _) = await OrganizationTestHelpers.SignUpAsync(_factory, ownerEmail: ownerEmail, billingEmail: ownerEmail);
+        _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokens.Token);
+        _organization = organization;
+    }
+
+    public Task DisposeAsync()
+    {
+        _client.Dispose();
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public async Task CreateProject()
+    {
+        var request = new ProjectCreateRequestModel()
+        {
+            Name = _mockEncryptedString
+        };
+
+        var response = await _client.PostAsJsonAsync($"/organizations/{_organization.Id}/projects", request);
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<Project>();
+
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, result!.Name);
+        AssertHelper.AssertRecent(result.RevisionDate);
+        AssertHelper.AssertRecent(result.CreationDate);
+        Assert.Null(result.DeletedDate);
+
+        var createdProject = await _projectRepository.GetByIdAsync(result.Id);
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, createdProject.Name);
+        AssertHelper.AssertRecent(createdProject.RevisionDate);
+        AssertHelper.AssertRecent(createdProject.CreationDate);
+        Assert.Null(createdProject.DeletedDate);
+    }
+
+    [Fact]
+    public async Task UpdateProject()
+    {
+        var initialProject = await _projectRepository.CreateAsync(new Project
+        {
+            OrganizationId = _organization.Id,
+            Name = _mockEncryptedString
+        });
+
+        var mockEncryptedString2 = "2.3Uk+WNBIoU5xzmVFNcoWzz==|1MsPIYuRfdOHfu/0uY6H2Q==|/98xy4wb6pHP1VTZ9JcNCYgQjEUMFPlqJgCwRk1YXKg=";
+
+        var request = new ProjectUpdateRequestModel()
+        {
+            Name = mockEncryptedString2
+        };
+
+        var response = await _client.PutAsJsonAsync($"/projects/{initialProject.Id}", request);
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<Project>();
+        Assert.NotEqual(initialProject.Name, result!.Name);
+        AssertHelper.AssertRecent(result.RevisionDate);
+        Assert.NotEqual(initialProject.RevisionDate, result.RevisionDate);
+        Assert.Null(result.DeletedDate);
+
+        var updatedProject = await _projectRepository.GetByIdAsync(result.Id);
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, updatedProject.Name);
+        AssertHelper.AssertRecent(updatedProject.RevisionDate);
+        AssertHelper.AssertRecent(updatedProject.CreationDate);
+        Assert.Null(updatedProject.DeletedDate);
+        Assert.NotEqual(initialProject.Name, updatedProject.Name);
+        Assert.NotEqual(initialProject.RevisionDate, updatedProject.RevisionDate);
+    }
+
+    [Fact]
+    public async Task GetProject()
+    {
+        var createdProject = await _projectRepository.CreateAsync(new Project
+        {
+            OrganizationId = _organization.Id,
+            Name = _mockEncryptedString
+        });
+
+        var response = await _client.GetAsync($"/projects/{createdProject.Id}");
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<Project>();
+        Assert.Equal(createdProject.Name, result!.Name);
+        Assert.Equal(createdProject.RevisionDate, result.RevisionDate);
+        Assert.Equal(createdProject.CreationDate, result.CreationDate);
+        Assert.Null(result.DeletedDate);
+    }
+
+    [Fact]
+    public async Task GetProjectsByOrganization()
+    {
+        var projectsToCreate = 3;
+        var projectIds = new List<Guid>();
+        for (var i = 0; i < projectsToCreate; i++)
+        {
+            var project = await _projectRepository.CreateAsync(new Project
+            {
+                OrganizationId = _organization.Id,
+                Name = _mockEncryptedString
+            });
+            projectIds.Add(project.Id);
+        }
+
+        var response = await _client.GetAsync($"/organizations/{_organization.Id}/projects");
+        response.EnsureSuccessStatusCode();
+        var content = await response.Content.ReadAsStringAsync();
+
+        var jsonResult = JsonDocument.Parse(content);
+
+        Assert.NotEmpty(jsonResult.RootElement.GetProperty("data").EnumerateArray());
+        Assert.Equal(projectIds.Count(), jsonResult.RootElement.GetProperty("data").EnumerateArray().Count());
+    }
+
+    [Fact]
+    public async Task DeleteProjects()
+    {
+        var projectsToDelete = 3;
+        var projectIds = new List<Guid>();
+        for (var i = 0; i < projectsToDelete; i++)
+        {
+            var project = await _projectRepository.CreateAsync(new Project
+            {
+                OrganizationId = _organization.Id,
+                Name = _mockEncryptedString,
+            });
+            projectIds.Add(project.Id);
+        }
+
+        var response = await _client.PostAsync("/projects/delete", JsonContent.Create(projectIds));
+        response.EnsureSuccessStatusCode();
+
+        var content = await response.Content.ReadAsStringAsync();
+        Assert.NotEmpty(content);
+
+        var jsonResult = JsonDocument.Parse(content);
+        var index = 0;
+        foreach (var element in jsonResult.RootElement.GetProperty("data").EnumerateArray())
+        {
+            Assert.Equal(projectIds[index].ToString(), element.GetProperty("id").ToString());
+            Assert.Empty(element.GetProperty("error").ToString());
+            index++;
+        }
+
+        var projects = await _projectRepository.GetManyByIds(projectIds);
+        Assert.Empty(projects);
+    }
+}
--- a/test/Api.IntegrationTest/Controllers/SecretsControllerTest.cs
+++ b/test/Api.IntegrationTest/Controllers/SecretsControllerTest.cs
@ -0,0 +1,237 @@
+using System.Net.Http.Headers;
+using System.Text.Json;
+using Bit.Api.IntegrationTest.Factories;
+using Bit.Api.IntegrationTest.Helpers;
+using Bit.Api.SecretManagerFeatures.Models.Request;
+using Bit.Core.Entities;
+using Bit.Core.Repositories;
+using Bit.Test.Common.Helpers;
+using Xunit;
+
+namespace Bit.Api.IntegrationTest.Controllers;
+
+public class SecretsControllerTest : IClassFixture<ApiApplicationFactory>, IAsyncLifetime
+{
+    private readonly string _mockEncryptedString =
+        "2.3Uk+WNBIoU5xzmVFNcoWzz==|1MsPIYuRfdOHfu/0uY6H2Q==|/98sp4wb6pHP1VTZ9JcNCYgQjEUMFPlqJgCwRk1YXKg=";
+
+    private readonly HttpClient _client;
+    private readonly ApiApplicationFactory _factory;
+    private readonly ISecretRepository _secretRepository;
+    private readonly IProjectRepository _projectRepository;
+    private Organization _organization = null!;
+
+    public SecretsControllerTest(ApiApplicationFactory factory)
+    {
+        _factory = factory;
+        _client = _factory.CreateClient();
+        _secretRepository = _factory.GetService<ISecretRepository>();
+        _projectRepository = _factory.GetService<IProjectRepository>();
+    }
+
+    public async Task InitializeAsync()
+    {
+        var ownerEmail = $"integration-test{Guid.NewGuid()}@bitwarden.com";
+        var tokens = await _factory.LoginWithNewAccount(ownerEmail);
+        var (organization, _) = await OrganizationTestHelpers.SignUpAsync(_factory, ownerEmail: ownerEmail, billingEmail: ownerEmail);
+        _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokens.Token);
+        _organization = organization;
+    }
+
+    public Task DisposeAsync()
+    {
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public async Task CreateSecret()
+    {
+        var request = new SecretCreateRequestModel()
+        {
+            Key = _mockEncryptedString,
+            Value = _mockEncryptedString,
+            Note = _mockEncryptedString
+        };
+
+        var response = await _client.PostAsJsonAsync($"/organizations/{_organization.Id}/secrets", request);
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<Secret>();
+
+        Assert.NotNull(result);
+        Assert.Equal(request.Key, result!.Key);
+        Assert.Equal(request.Value, result.Value);
+        Assert.Equal(request.Note, result.Note);
+        AssertHelper.AssertRecent(result.RevisionDate);
+        AssertHelper.AssertRecent(result.CreationDate);
+        Assert.Null(result.DeletedDate);
+
+        var createdSecret = await _secretRepository.GetByIdAsync(result.Id);
+        Assert.NotNull(result);
+        Assert.Equal(request.Key, createdSecret.Key);
+        Assert.Equal(request.Value, createdSecret.Value);
+        Assert.Equal(request.Note, createdSecret.Note);
+        AssertHelper.AssertRecent(createdSecret.RevisionDate);
+        AssertHelper.AssertRecent(createdSecret.CreationDate);
+        Assert.Null(createdSecret.DeletedDate);
+    }
+
+    [Fact]
+    public async Task CreateSecretWithProject()
+    {
+        var project = await _projectRepository.CreateAsync(new Project()
+        {
+            Id = new Guid(),
+            OrganizationId = _organization.Id,
+            Name = _mockEncryptedString
+        });
+        var projectIds = new[] { project.Id };
+        var secretRequest = new SecretCreateRequestModel()
+        {
+            Key = _mockEncryptedString,
+            Value = _mockEncryptedString,
+            Note = _mockEncryptedString,
+            ProjectIds = projectIds,
+        };
+        var secretResponse = await _client.PostAsJsonAsync($"/organizations/{_organization.Id}/secrets", secretRequest);
+        secretResponse.EnsureSuccessStatusCode();
+        var secretResult = await secretResponse.Content.ReadFromJsonAsync<Secret>();
+
+        var secret = (await _secretRepository.GetManyByProjectIdAsync(project.Id)).First();
+
+        Assert.NotNull(secretResult);
+        Assert.Equal(secret.Id, secretResult!.Id);
+        Assert.Equal(secret.OrganizationId, secretResult.OrganizationId);
+        Assert.Equal(secret.Key, secretResult.Key);
+        Assert.Equal(secret.Value, secretResult.Value);
+        Assert.Equal(secret.Note, secretResult.Note);
+        Assert.Equal(secret.CreationDate, secretResult.CreationDate);
+        Assert.Equal(secret.RevisionDate, secretResult.RevisionDate);
+    }
+
+    [Fact]
+    public async Task UpdateSecret()
+    {
+        var initialSecret = await _secretRepository.CreateAsync(new Secret
+        {
+            OrganizationId = _organization.Id,
+            Key = _mockEncryptedString,
+            Value = _mockEncryptedString,
+            Note = _mockEncryptedString
+        });
+
+        var request = new SecretUpdateRequestModel()
+        {
+            Key = _mockEncryptedString,
+            Value = "2.3Uk+WNBIoU5xzmVFNcoWzz==|1MsPIYuRfdOHfu/0uY6H2Q==|/98xy4wb6pHP1VTZ9JcNCYgQjEUMFPlqJgCwRk1YXKg=",
+            Note = _mockEncryptedString
+        };
+
+        var response = await _client.PutAsJsonAsync($"/secrets/{initialSecret.Id}", request);
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<Secret>();
+        Assert.Equal(request.Key, result!.Key);
+        Assert.Equal(request.Value, result.Value);
+        Assert.NotEqual(initialSecret.Value, result.Value);
+        Assert.Equal(request.Note, result.Note);
+        AssertHelper.AssertRecent(result.RevisionDate);
+        Assert.NotEqual(initialSecret.RevisionDate, result.RevisionDate);
+        Assert.Null(result.DeletedDate);
+
+        var updatedSecret = await _secretRepository.GetByIdAsync(result.Id);
+        Assert.NotNull(result);
+        Assert.Equal(request.Key, updatedSecret.Key);
+        Assert.Equal(request.Value, updatedSecret.Value);
+        Assert.Equal(request.Note, updatedSecret.Note);
+        AssertHelper.AssertRecent(updatedSecret.RevisionDate);
+        AssertHelper.AssertRecent(updatedSecret.CreationDate);
+        Assert.Null(updatedSecret.DeletedDate);
+        Assert.NotEqual(initialSecret.Value, updatedSecret.Value);
+        Assert.NotEqual(initialSecret.RevisionDate, updatedSecret.RevisionDate);
+    }
+
+    [Fact]
+    public async Task DeleteSecrets()
+    {
+        var secretsToDelete = 3;
+        var secretIds = new List<Guid>();
+        for (var i = 0; i < secretsToDelete; i++)
+        {
+            var secret = await _secretRepository.CreateAsync(new Secret
+            {
+                OrganizationId = _organization.Id,
+                Key = _mockEncryptedString,
+                Value = _mockEncryptedString,
+                Note = _mockEncryptedString
+            });
+            secretIds.Add(secret.Id);
+        }
+
+        var response = await _client.PostAsync("/secrets/delete", JsonContent.Create(secretIds));
+        response.EnsureSuccessStatusCode();
+
+        var content = await response.Content.ReadAsStringAsync();
+        Assert.NotEmpty(content);
+
+        var jsonResult = JsonDocument.Parse(content);
+        var index = 0;
+        foreach (var element in jsonResult.RootElement.GetProperty("data").EnumerateArray())
+        {
+            Assert.Equal(secretIds[index].ToString(), element.GetProperty("id").ToString());
+            Assert.Empty(element.GetProperty("error").ToString());
+            index++;
+        }
+
+        var secrets = await _secretRepository.GetManyByIds(secretIds);
+        Assert.Empty(secrets);
+    }
+
+    [Fact]
+    public async Task GetSecret()
+    {
+        var createdSecret = await _secretRepository.CreateAsync(new Secret
+        {
+            OrganizationId = _organization.Id,
+            Key = _mockEncryptedString,
+            Value = _mockEncryptedString,
+            Note = _mockEncryptedString
+        });
+
+
+        var response = await _client.GetAsync($"/secrets/{createdSecret.Id}");
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<Secret>();
+        Assert.Equal(createdSecret.Key, result!.Key);
+        Assert.Equal(createdSecret.Value, result.Value);
+        Assert.Equal(createdSecret.Note, result.Note);
+        Assert.Equal(createdSecret.RevisionDate, result.RevisionDate);
+        Assert.Equal(createdSecret.CreationDate, result.CreationDate);
+        Assert.Null(result.DeletedDate);
+    }
+
+    [Fact]
+    public async Task GetSecretsByOrganization()
+    {
+        var secretsToCreate = 3;
+        var secretIds = new List<Guid>();
+        for (var i = 0; i < secretsToCreate; i++)
+        {
+            var secret = await _secretRepository.CreateAsync(new Secret
+            {
+                OrganizationId = _organization.Id,
+                Key = _mockEncryptedString,
+                Value = _mockEncryptedString,
+                Note = _mockEncryptedString
+            });
+            secretIds.Add(secret.Id);
+        }
+
+        var response = await _client.GetAsync($"/organizations/{_organization.Id}/secrets");
+        response.EnsureSuccessStatusCode();
+        var content = await response.Content.ReadAsStringAsync();
+
+        var jsonResult = JsonDocument.Parse(content);
+
+        Assert.NotEmpty(jsonResult.RootElement.GetProperty("secrets").EnumerateArray());
+        Assert.Equal(secretIds.Count(), jsonResult.RootElement.GetProperty("secrets").EnumerateArray().Count());
+    }
+}
--- a/test/Api.IntegrationTest/Controllers/ServiceAccountsControllerTests.cs
+++ b/test/Api.IntegrationTest/Controllers/ServiceAccountsControllerTests.cs
@ -0,0 +1,183 @@
+using System.Net.Http.Headers;
+using System.Text.Json;
+using Bit.Api.IntegrationTest.Factories;
+using Bit.Api.IntegrationTest.Helpers;
+using Bit.Api.SecretManagerFeatures.Models.Request;
+using Bit.Core.Entities;
+using Bit.Core.Repositories;
+using Bit.Test.Common.Helpers;
+using Xunit;
+
+namespace Bit.Api.IntegrationTest.Controllers;
+
+public class ServiceAccountsControllerTest : IClassFixture<ApiApplicationFactory>, IAsyncLifetime
+{
+    private readonly string _mockEncryptedString =
+        "2.3Uk+WNBIoU5xzmVFNcoWzz==|1MsPIYuRfdOHfu/0uY6H2Q==|/98sp4wb6pHP1VTZ9JcNCYgQjEUMFPlqJgCwRk1YXKg=";
+
+    private readonly HttpClient _client;
+    private readonly ApiApplicationFactory _factory;
+    private readonly IServiceAccountRepository _serviceAccountRepository;
+    private Organization _organization = null!;
+
+    public ServiceAccountsControllerTest(ApiApplicationFactory factory)
+    {
+        _factory = factory;
+        _client = _factory.CreateClient();
+        _serviceAccountRepository = _factory.GetService<IServiceAccountRepository>();
+    }
+
+    public async Task InitializeAsync()
+    {
+        var ownerEmail = $"integration-test{Guid.NewGuid()}@bitwarden.com";
+        var tokens = await _factory.LoginWithNewAccount(ownerEmail);
+        var (organization, _) = await OrganizationTestHelpers.SignUpAsync(_factory, ownerEmail: ownerEmail, billingEmail: ownerEmail);
+        _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokens.Token);
+        _organization = organization;
+    }
+
+    public Task DisposeAsync()
+    {
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public async Task GetServiceAccountsByOrganization()
+    {
+        var serviceAccountsToCreate = 3;
+        var serviceAccountIds = new List<Guid>();
+        for (var i = 0; i < serviceAccountsToCreate; i++)
+        {
+            var serviceAccount = await _serviceAccountRepository.CreateAsync(new ServiceAccount
+            {
+                OrganizationId = _organization.Id,
+                Name = _mockEncryptedString,
+            });
+            serviceAccountIds.Add(serviceAccount.Id);
+        }
+
+        var response = await _client.GetAsync($"/organizations/{_organization.Id}/service-accounts");
+        response.EnsureSuccessStatusCode();
+        var content = await response.Content.ReadAsStringAsync();
+
+        var jsonResult = JsonDocument.Parse(content);
+
+        Assert.NotEmpty(jsonResult.RootElement.GetProperty("data").EnumerateArray());
+        Assert.Equal(serviceAccountIds.Count(), jsonResult.RootElement.GetProperty("data").EnumerateArray().Count());
+    }
+
+    [Fact]
+    public async Task CreateServiceAccount()
+    {
+        var request = new ServiceAccountCreateRequestModel()
+        {
+            Name = _mockEncryptedString,
+        };
+
+        var response = await _client.PostAsJsonAsync($"/organizations/{_organization.Id}/service-accounts", request);
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<ServiceAccount>();
+
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, result!.Name);
+        AssertHelper.AssertRecent(result.RevisionDate);
+        AssertHelper.AssertRecent(result.CreationDate);
+
+        var createdServiceAccount = await _serviceAccountRepository.GetByIdAsync(result.Id);
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, createdServiceAccount.Name);
+        AssertHelper.AssertRecent(createdServiceAccount.RevisionDate);
+        AssertHelper.AssertRecent(createdServiceAccount.CreationDate);
+    }
+
+    [Fact]
+    public async Task UpdateServiceAccount()
+    {
+        var initialServiceAccount = await _serviceAccountRepository.CreateAsync(new ServiceAccount
+        {
+            OrganizationId = _organization.Id,
+            Name = _mockEncryptedString,
+        });
+
+        var request = new ServiceAccountUpdateRequestModel()
+        {
+            Name = "2.3Uk+WNBIoU5xzmVFNcoWzz==|1MsPIYuRfdOHfu/0uY6H2Q==|/98xy4wb6pHP1VTZ9JcNCYgQjEUMFPlqJgCwRk1YXKg=",
+        };
+
+        var response = await _client.PutAsJsonAsync($"/service-accounts/{initialServiceAccount.Id}", request);
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<ServiceAccount>();
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, result!.Name);
+        Assert.NotEqual(initialServiceAccount.Name, result.Name);
+        AssertHelper.AssertRecent(result.RevisionDate);
+        Assert.NotEqual(initialServiceAccount.RevisionDate, result.RevisionDate);
+
+        var updatedServiceAccount = await _serviceAccountRepository.GetByIdAsync(initialServiceAccount.Id);
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, updatedServiceAccount.Name);
+        AssertHelper.AssertRecent(updatedServiceAccount.RevisionDate);
+        AssertHelper.AssertRecent(updatedServiceAccount.CreationDate);
+        Assert.NotEqual(initialServiceAccount.Name, updatedServiceAccount.Name);
+        Assert.NotEqual(initialServiceAccount.RevisionDate, updatedServiceAccount.RevisionDate);
+    }
+
+    [Fact]
+    public async Task CreateServiceAccountAccessToken()
+    {
+        var serviceAccount = await _serviceAccountRepository.CreateAsync(new ServiceAccount
+        {
+            OrganizationId = _organization.Id,
+            Name = _mockEncryptedString,
+        });
+
+        var mockExpiresAt = DateTime.UtcNow.AddDays(30);
+        var request = new AccessTokenCreateRequestModel()
+        {
+            Name = _mockEncryptedString,
+            EncryptedPayload = _mockEncryptedString,
+            Key = _mockEncryptedString,
+            ExpireAt = mockExpiresAt
+        };
+
+        var response = await _client.PostAsJsonAsync($"/service-accounts/{serviceAccount.Id}/access-tokens", request);
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<ApiKey>();
+
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, result!.Name);
+        Assert.NotNull(result.ClientSecret);
+        Assert.Equal(mockExpiresAt, result.ExpireAt);
+        AssertHelper.AssertRecent(result.RevisionDate);
+        AssertHelper.AssertRecent(result.CreationDate);
+    }
+
+    [Fact]
+    public async Task CreateServiceAccountAccessTokenExpireAtNullAsync()
+    {
+        var serviceAccount = await _serviceAccountRepository.CreateAsync(new ServiceAccount
+        {
+            OrganizationId = _organization.Id,
+            Name = _mockEncryptedString,
+        });
+
+        var request = new AccessTokenCreateRequestModel()
+        {
+            Name = _mockEncryptedString,
+            EncryptedPayload = _mockEncryptedString,
+            Key = _mockEncryptedString,
+            ExpireAt = null
+        };
+
+        var response = await _client.PostAsJsonAsync($"/service-accounts/{serviceAccount.Id}/access-tokens", request);
+        response.EnsureSuccessStatusCode();
+        var result = await response.Content.ReadFromJsonAsync<ApiKey>();
+
+        Assert.NotNull(result);
+        Assert.Equal(request.Name, result!.Name);
+        Assert.NotNull(result.ClientSecret);
+        Assert.Null(result.ExpireAt);
+        AssertHelper.AssertRecent(result.RevisionDate);
+        AssertHelper.AssertRecent(result.CreationDate);
+    }
+}
--- a/test/Api.IntegrationTest/Factories/ApiApplicationFactory.cs
+++ b/test/Api.IntegrationTest/Factories/ApiApplicationFactory.cs
@ -12,6 +12,7 @@ public class ApiApplicationFactory : WebApplicationFactoryBase<Startup>
    public ApiApplicationFactory()
    {
        _identityApplicationFactory = new IdentityApplicationFactory();
+        _identityApplicationFactory.DatabaseName = DatabaseName;
    }

    protected override void ConfigureWebHost(IWebHostBuilder builder)
@ -20,6 +21,10 @@ public class ApiApplicationFactory : WebApplicationFactoryBase<Startup>

        builder.ConfigureTestServices(services =>
        {
+            // Remove scheduled background jobs to prevent errors in parallel test execution
+            var jobService = services.First(sd => sd.ServiceType == typeof(Microsoft.Extensions.Hosting.IHostedService) && sd.ImplementationType == typeof(Bit.Api.Jobs.JobsHostedService));
+            services.Remove(jobService);
+
            services.PostConfigure<IdentityServerAuthenticationOptions>(IdentityServerAuthenticationDefaults.AuthenticationScheme, options =>
            {
                options.JwtBackChannelHandler = _identityApplicationFactory.Server.CreateHandler();
--- a/test/Api.IntegrationTest/Helpers/OrganizationTestHelpers.cs
+++ b/test/Api.IntegrationTest/Helpers/OrganizationTestHelpers.cs
@ -0,0 +1,33 @@
+using Bit.Core.Entities;
+using Bit.Core.Enums;
+using Bit.Core.Models.Business;
+using Bit.Core.Repositories;
+using Bit.Core.Services;
+using Bit.IntegrationTestCommon.Factories;
+
+namespace Bit.Api.IntegrationTest.Helpers;
+
+public static class OrganizationTestHelpers
+{
+    public static async Task<Tuple<Organization, OrganizationUser>> SignUpAsync<T>(WebApplicationFactoryBase<T> factory,
+        PlanType plan = PlanType.Free,
+        string ownerEmail = "integration-test@bitwarden.com",
+        string name = "Integration Test Org",
+        string billingEmail = "integration-test@bitwarden.com",
+        string ownerKey = "test-key") where T : class
+    {
+        var userRepository = factory.GetService<IUserRepository>();
+        var organizationService = factory.GetService<IOrganizationService>();
+
+        var owner = await userRepository.GetByEmailAsync(ownerEmail);
+
+        return await organizationService.SignUpAsync(new OrganizationSignup
+        {
+            Name = name,
+            BillingEmail = billingEmail,
+            Plan = plan,
+            OwnerKey = ownerKey,
+            Owner = owner,
+        });
+    }
+}
--- a/test/Api.IntegrationTest/packages.lock.json
+++ b/test/Api.IntegrationTest/packages.lock.json
@ -674,6 +674,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.ApiDescription.Server": {
        "type": "Transitive",
        "resolved": "3.0.0",
@ -3132,6 +3141,7 @@
        "dependencies": {
          "Azure.Messaging.EventGrid": "[4.10.0, )",
          "Commercial.Core": "[2022.12.0, )",
+          "Commercial.Infrastructure.EntityFramework": "[2022.12.0, )",
          "Core": "[2022.12.0, )",
          "SharedWeb": "[2022.12.0, )",
          "Swashbuckle.AspNetCore": "[6.3.1, )"
@ -3143,6 +3153,14 @@
          "Core": "[2022.12.0, )"
        }
      },
+      "commercial.infrastructure.entityframework": {
+        "type": "Project",
+        "dependencies": {
+          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
+          "Core": "[2022.12.0, )",
+          "Infrastructure.EntityFramework": "[2022.12.0, )"
+        }
+      },
      "common": {
        "type": "Project",
        "dependencies": {
@ -3216,6 +3234,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",
--- a/test/Api.Test/Api.Test.csproj
+++ b/test/Api.Test/Api.Test.csproj
@ -23,6 +23,7 @@
    <ProjectReference Include="..\..\src\Api\Api.csproj" />
    <ProjectReference Include="..\..\src\Core\Core.csproj" />
    <ProjectReference Include="..\Common\Common.csproj" />
+    <ProjectReference Include="..\Core.Test\Core.Test.csproj" />
  </ItemGroup>

 </Project>
--- a/test/Api.Test/Controllers/ProjectsControllerTests.cs
+++ b/test/Api.Test/Controllers/ProjectsControllerTests.cs
@ -0,0 +1,42 @@
+using Bit.Api.Controllers;
+using Bit.Core.Entities;
+using Bit.Core.SecretManagerFeatures.Projects.Interfaces;
+using Bit.Core.Test.AutoFixture.ProjectsFixture;
+using Bit.Test.Common.AutoFixture;
+using Bit.Test.Common.AutoFixture.Attributes;
+using NSubstitute;
+using Xunit;
+
+namespace Bit.Api.Test.Controllers;
+
+[ControllerCustomize(typeof(ProjectsController))]
+[SutProviderCustomize]
+[ProjectCustomize]
+[JsonDocumentCustomize]
+public class ProjectsControllerTests
+{
+    [Theory]
+    [BitAutoData]
+    public async void BulkDeleteProjects_Success(SutProvider<ProjectsController> sutProvider, List<Project> data)
+    {
+        var ids = data.Select(project => project.Id).ToList();
+        var mockResult = new List<Tuple<Project, string>>();
+        foreach (var project in data)
+        {
+            mockResult.Add(new Tuple<Project, string>(project, ""));
+        }
+        sutProvider.GetDependency<IDeleteProjectCommand>().DeleteProjects(ids).ReturnsForAnyArgs(mockResult);
+
+        var results = await sutProvider.Sut.BulkDeleteProjectsAsync(ids);
+        await sutProvider.GetDependency<IDeleteProjectCommand>().Received(1)
+                     .DeleteProjects(Arg.Is(ids));
+        Assert.Equal(data.Count, results.Data.Count());
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void BulkDeleteProjects_NoGuids_ThrowsArgumentNullException(SutProvider<ProjectsController> sutProvider)
+    {
+        await Assert.ThrowsAsync<ArgumentNullException>(() => sutProvider.Sut.BulkDeleteProjectsAsync(new List<Guid>()));
+    }
+}
--- a/test/Api.Test/Controllers/SecretsControllerTests.cs
+++ b/test/Api.Test/Controllers/SecretsControllerTests.cs
@ -0,0 +1,114 @@
+using Bit.Api.Controllers;
+using Bit.Api.SecretManagerFeatures.Models.Request;
+using Bit.Core.Entities;
+using Bit.Core.Exceptions;
+using Bit.Core.Repositories;
+using Bit.Core.SecretManagerFeatures.Secrets.Interfaces;
+using Bit.Core.Test.AutoFixture.SecretsFixture;
+using Bit.Test.Common.AutoFixture;
+using Bit.Test.Common.AutoFixture.Attributes;
+using Bit.Test.Common.Helpers;
+using NSubstitute;
+using Xunit;
+
+namespace Bit.Api.Test.Controllers;
+
+[ControllerCustomize(typeof(SecretsController))]
+[SutProviderCustomize]
+[JsonDocumentCustomize]
+[SecretCustomize]
+public class SecretsControllerTests
+{
+    [Theory]
+    [BitAutoData]
+    public async void GetSecretsByOrganization_ReturnsEmptyList(SutProvider<SecretsController> sutProvider, Guid id)
+    {
+        var result = await sutProvider.Sut.GetSecretsByOrganizationAsync(id);
+
+        await sutProvider.GetDependency<ISecretRepository>().Received(1)
+                     .GetManyByOrganizationIdAsync(Arg.Is(AssertHelper.AssertPropertyEqual(id)));
+
+        Assert.Empty(result.Secrets);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void GetSecret_NotFound(SutProvider<SecretsController> sutProvider)
+    {
+        await Assert.ThrowsAsync<NotFoundException>(() => sutProvider.Sut.GetSecretAsync(Guid.NewGuid()));
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void GetSecret_Success(SutProvider<SecretsController> sutProvider, Secret resultSecret)
+    {
+        sutProvider.GetDependency<ISecretRepository>().GetByIdAsync(default).ReturnsForAnyArgs(resultSecret);
+
+        var result = await sutProvider.Sut.GetSecretAsync(resultSecret.Id);
+
+        await sutProvider.GetDependency<ISecretRepository>().Received(1)
+                     .GetByIdAsync(Arg.Is(AssertHelper.AssertPropertyEqual(resultSecret.Id)));
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void GetSecretsByOrganization_Success(SutProvider<SecretsController> sutProvider, Secret resultSecret)
+    {
+        sutProvider.GetDependency<ISecretRepository>().GetManyByOrganizationIdAsync(default).ReturnsForAnyArgs(new List<Secret>() { resultSecret });
+
+        var result = await sutProvider.Sut.GetSecretsByOrganizationAsync(resultSecret.OrganizationId);
+
+        await sutProvider.GetDependency<ISecretRepository>().Received(1)
+                     .GetManyByOrganizationIdAsync(Arg.Is(AssertHelper.AssertPropertyEqual(resultSecret.OrganizationId)));
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void CreateSecret_Success(SutProvider<SecretsController> sutProvider, SecretCreateRequestModel data, Guid organizationId)
+    {
+        var resultSecret = data.ToSecret(organizationId);
+
+        sutProvider.GetDependency<ICreateSecretCommand>().CreateAsync(default).ReturnsForAnyArgs(resultSecret);
+
+        var result = await sutProvider.Sut.CreateSecretAsync(organizationId, data);
+        await sutProvider.GetDependency<ICreateSecretCommand>().Received(1)
+                     .CreateAsync(Arg.Any<Secret>());
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void UpdateSecret_Success(SutProvider<SecretsController> sutProvider, SecretUpdateRequestModel data, Guid secretId)
+    {
+        var resultSecret = data.ToSecret(secretId);
+        sutProvider.GetDependency<IUpdateSecretCommand>().UpdateAsync(default).ReturnsForAnyArgs(resultSecret);
+
+        var result = await sutProvider.Sut.UpdateSecretAsync(secretId, data);
+        await sutProvider.GetDependency<IUpdateSecretCommand>().Received(1)
+                     .UpdateAsync(Arg.Any<Secret>());
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void BulkDeleteSecret_Success(SutProvider<SecretsController> sutProvider, List<Secret> data)
+    {
+        var ids = data.Select(secret => secret.Id).ToList();
+        var mockResult = new List<Tuple<Secret, string>>();
+        foreach (var secret in data)
+        {
+            mockResult.Add(new Tuple<Secret, string>(secret, ""));
+        }
+        sutProvider.GetDependency<IDeleteSecretCommand>().DeleteSecrets(ids).ReturnsForAnyArgs(mockResult);
+
+        var results = await sutProvider.Sut.BulkDeleteAsync(ids);
+        await sutProvider.GetDependency<IDeleteSecretCommand>().Received(1)
+                     .DeleteSecrets(Arg.Is(ids));
+        Assert.Equal(data.Count, results.Data.Count());
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void BulkDeleteSecret_NoGuids_ThrowsArgumentNullException(SutProvider<SecretsController> sutProvider)
+    {
+        await Assert.ThrowsAsync<ArgumentNullException>(() => sutProvider.Sut.BulkDeleteAsync(new List<Guid>()));
+    }
+}
--- a/test/Api.Test/Controllers/ServiceAccountsControllerTests.cs
+++ b/test/Api.Test/Controllers/ServiceAccountsControllerTests.cs
@ -0,0 +1,82 @@
+using Bit.Api.Controllers;
+using Bit.Api.SecretManagerFeatures.Models.Request;
+using Bit.Core.Entities;
+using Bit.Core.Repositories;
+using Bit.Core.SecretManagerFeatures.AccessTokens.Interfaces;
+using Bit.Core.SecretManagerFeatures.ServiceAccounts.Interfaces;
+using Bit.Test.Common.AutoFixture;
+using Bit.Test.Common.AutoFixture.Attributes;
+using Bit.Test.Common.Helpers;
+using NSubstitute;
+using Xunit;
+
+namespace Bit.Api.Test.Controllers;
+
+[ControllerCustomize(typeof(ServiceAccountsController))]
+[SutProviderCustomize]
+[JsonDocumentCustomize]
+public class ServiceAccountsControllerTests
+{
+    [Theory]
+    [BitAutoData]
+    public async void GetServiceAccountsByOrganization_ReturnsEmptyList(SutProvider<ServiceAccountsController> sutProvider, Guid id)
+    {
+        var result = await sutProvider.Sut.GetServiceAccountsByOrganizationAsync(id);
+
+        await sutProvider.GetDependency<IServiceAccountRepository>().Received(1)
+                     .GetManyByOrganizationIdAsync(Arg.Is(AssertHelper.AssertPropertyEqual(id)));
+
+        Assert.Empty(result.Data);
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void GetServiceAccountsByOrganization_Success(SutProvider<ServiceAccountsController> sutProvider, ServiceAccount resultServiceAccount)
+    {
+        sutProvider.GetDependency<IServiceAccountRepository>().GetManyByOrganizationIdAsync(default).ReturnsForAnyArgs(new List<ServiceAccount>() { resultServiceAccount });
+
+        var result = await sutProvider.Sut.GetServiceAccountsByOrganizationAsync(resultServiceAccount.OrganizationId);
+
+        await sutProvider.GetDependency<IServiceAccountRepository>().Received(1)
+                     .GetManyByOrganizationIdAsync(Arg.Is(AssertHelper.AssertPropertyEqual(resultServiceAccount.OrganizationId)));
+    }
+
+
+    [Theory]
+    [BitAutoData]
+    public async void CreateServiceAccount_Success(SutProvider<ServiceAccountsController> sutProvider, ServiceAccountCreateRequestModel data, Guid organizationId)
+    {
+        var resultServiceAccount = data.ToServiceAccount(organizationId);
+
+        sutProvider.GetDependency<ICreateServiceAccountCommand>().CreateAsync(default).ReturnsForAnyArgs(resultServiceAccount);
+
+        var result = await sutProvider.Sut.CreateServiceAccountAsync(organizationId, data);
+        await sutProvider.GetDependency<ICreateServiceAccountCommand>().Received(1)
+                     .CreateAsync(Arg.Any<ServiceAccount>());
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void UpdateServiceAccount_Success(SutProvider<ServiceAccountsController> sutProvider, ServiceAccountUpdateRequestModel data, Guid serviceAccountId)
+    {
+        var resultServiceAccount = data.ToServiceAccount(serviceAccountId);
+        sutProvider.GetDependency<IUpdateServiceAccountCommand>().UpdateAsync(default).ReturnsForAnyArgs(resultServiceAccount);
+
+        var result = await sutProvider.Sut.UpdateServiceAccountAsync(serviceAccountId, data);
+        await sutProvider.GetDependency<IUpdateServiceAccountCommand>().Received(1)
+                     .UpdateAsync(Arg.Any<ServiceAccount>());
+    }
+
+    [Theory]
+    [BitAutoData]
+    public async void CreateAccessToken_Success(SutProvider<ServiceAccountsController> sutProvider, AccessTokenCreateRequestModel data, Guid serviceAccountId)
+    {
+        var resultAccessToken = data.ToApiKey(serviceAccountId);
+
+        sutProvider.GetDependency<ICreateAccessTokenCommand>().CreateAsync(default).ReturnsForAnyArgs(resultAccessToken);
+
+        var result = await sutProvider.Sut.CreateAccessTokenAsync(serviceAccountId, data);
+        await sutProvider.GetDependency<ICreateAccessTokenCommand>().Received(1)
+            .CreateAsync(Arg.Any<ApiKey>());
+    }
+}
--- a/test/Api.Test/packages.lock.json
+++ b/test/Api.Test/packages.lock.json
@ -658,6 +658,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.ApiDescription.Server": {
        "type": "Transitive",
        "resolved": "3.0.0",
@ -1053,6 +1062,15 @@
          "System.Security.Cryptography.Pkcs": "6.0.0"
        }
      },
+      "Moq": {
+        "type": "Transitive",
+        "resolved": "4.17.2",
+        "contentHash": "HytUPJ3/uks2UgJ9hIcyXm3YxpFAR4OJzbQwTHltbKGun3lFLhEHs97hiiPj1dY8jV/kasXeihTzDxct6Zf3iQ==",
+        "dependencies": {
+          "Castle.Core": "4.4.1",
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        }
+      },
      "MySqlConnector": {
        "type": "Transitive",
        "resolved": "2.1.2",
@ -3002,6 +3020,7 @@
        "dependencies": {
          "Azure.Messaging.EventGrid": "[4.10.0, )",
          "Commercial.Core": "[2022.12.0, )",
+          "Commercial.Infrastructure.EntityFramework": "[2022.12.0, )",
          "Core": "[2022.12.0, )",
          "SharedWeb": "[2022.12.0, )",
          "Swashbuckle.AspNetCore": "[6.3.1, )"
@ -3013,6 +3032,14 @@
          "Core": "[2022.12.0, )"
        }
      },
+      "commercial.infrastructure.entityframework": {
+        "type": "Project",
+        "dependencies": {
+          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
+          "Core": "[2022.12.0, )",
+          "Infrastructure.EntityFramework": "[2022.12.0, )"
+        }
+      },
      "common": {
        "type": "Project",
        "dependencies": {
@ -3065,6 +3092,20 @@
          "YubicoDotNetClient": "[1.2.0, )"
        }
      },
+      "core.test": {
+        "type": "Project",
+        "dependencies": {
+          "AutoFixture.AutoNSubstitute": "[4.17.0, )",
+          "AutoFixture.Xunit2": "[4.17.0, )",
+          "Common": "[2022.12.0, )",
+          "Core": "[2022.12.0, )",
+          "Kralizek.AutoFixture.Extensions.MockHttp": "[1.2.0, )",
+          "Microsoft.NET.Test.Sdk": "[17.1.0, )",
+          "Moq": "[4.17.2, )",
+          "NSubstitute": "[4.3.0, )",
+          "xunit": "[2.4.1, )"
+        }
+      },
      "infrastructure.dapper": {
        "type": "Project",
        "dependencies": {
@ -3078,6 +3119,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",
--- a/test/Billing.Test/packages.lock.json
+++ b/test/Billing.Test/packages.lock.json
@ -893,6 +893,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.Caching.Abstractions": {
        "type": "Transitive",
        "resolved": "6.0.0",
@ -3526,6 +3535,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",
--- a/test/Core.Test/AutoFixture/ProjectFixtures.cs
+++ b/test/Core.Test/AutoFixture/ProjectFixtures.cs
@ -0,0 +1,22 @@
+using AutoFixture;
+using Bit.Core.Entities;
+using Bit.Test.Common.AutoFixture.Attributes;
+
+namespace Bit.Core.Test.AutoFixture.ProjectsFixture;
+
+public class ProjectCustomization : ICustomization
+{
+    public void Customize(IFixture fixture)
+    {
+        var projectId = Guid.NewGuid();
+
+        fixture.Customize<Project>(composer => composer
+            .With(p => p.Id, projectId)
+            .Without(s => s.Secrets));
+    }
+}
+
+public class ProjectCustomizeAttribute : BitCustomizeAttribute
+{
+    public override ICustomization GetCustomization() => new ProjectCustomization();
+}
--- a/test/Core.Test/AutoFixture/SecretFixtures.cs
+++ b/test/Core.Test/AutoFixture/SecretFixtures.cs
@ -0,0 +1,22 @@
+using AutoFixture;
+using Bit.Core.Entities;
+using Bit.Test.Common.AutoFixture.Attributes;
+
+namespace Bit.Core.Test.AutoFixture.SecretsFixture;
+
+public class SecretCustomization : ICustomization
+{
+    public void Customize(IFixture fixture)
+    {
+        var secretId = Guid.NewGuid();
+
+        fixture.Customize<Secret>(composer => composer
+            .With(o => o.Id, secretId)
+            .Without(s => s.Projects));
+    }
+}
+
+public class SecretCustomizeAttribute : BitCustomizeAttribute
+{
+    public override ICustomization GetCustomization() => new SecretCustomization();
+}
--- a/test/Icons.Test/packages.lock.json
+++ b/test/Icons.Test/packages.lock.json
@ -612,6 +612,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.Caching.Abstractions": {
        "type": "Transitive",
        "resolved": "6.0.0",
@ -2947,6 +2956,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",
--- a/test/Identity.IntegrationTest/openid-configuration.json
+++ b/test/Identity.IntegrationTest/openid-configuration.json
@ -11,6 +11,7 @@
    "api.organization",
    "api.installation",
    "internal",
+    "api.secrets",
    "offline_access"
  ],
  "claims_supported": [
@ -27,7 +28,8 @@
    "orgcustom",
    "providerprovideradmin",
    "providerserviceuser",
-    "sub"
+    "sub",
+    "organization"
  ],
  "grant_types_supported": [
    "authorization_code",
--- a/test/Identity.IntegrationTest/packages.lock.json
+++ b/test/Identity.IntegrationTest/packages.lock.json
@ -675,6 +675,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.Caching.Abstractions": {
        "type": "Transitive",
        "resolved": "6.0.0",
@ -3172,6 +3181,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",
--- a/test/Identity.Test/packages.lock.json
+++ b/test/Identity.Test/packages.lock.json
@ -648,6 +648,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.Caching.Abstractions": {
        "type": "Transitive",
        "resolved": "6.0.0",
@ -3039,6 +3048,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",
--- a/test/Infrastructure.EFIntegration.Test/Repositories/CipherRepositoryTests.cs
+++ b/test/Infrastructure.EFIntegration.Test/Repositories/CipherRepositoryTests.cs
@ -24,20 +24,20 @@ public class CipherRepositoryTests
    }

    [CiSkippedTheory, EfUserCipherCustomize, BitAutoData]
-    public void UserCipher_CreateAsync_Works_DataMatches(Cipher cipher, User user, Organization org,
+    public Task UserCipher_CreateAsync_Works_DataMatches(Cipher cipher, User user, Organization org,
        CipherCompare equalityComparer, List<EfRepo.CipherRepository> suts, List<EfRepo.UserRepository> efUserRepos,
        List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.CipherRepository sqlCipherRepo,
        SqlRepo.UserRepository sqlUserRepo, SqlRepo.OrganizationRepository sqlOrgRepo) => CreateAsync_Works_DataMatches(
            cipher, user, org, equalityComparer, suts, efUserRepos, efOrgRepos, sqlCipherRepo, sqlUserRepo, sqlOrgRepo);

    [CiSkippedTheory, EfOrganizationCipherCustomize, BitAutoData]
-    public void OrganizationCipher_CreateAsync_Works_DataMatches(Cipher cipher, User user, Organization org,
+    public Task OrganizationCipher_CreateAsync_Works_DataMatches(Cipher cipher, User user, Organization org,
        CipherCompare equalityComparer, List<EfRepo.CipherRepository> suts, List<EfRepo.UserRepository> efUserRepos,
        List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.CipherRepository sqlCipherRepo,
        SqlRepo.UserRepository sqlUserRepo, SqlRepo.OrganizationRepository sqlOrgRepo) => CreateAsync_Works_DataMatches(
            cipher, user, org, equalityComparer, suts, efUserRepos, efOrgRepos, sqlCipherRepo, sqlUserRepo, sqlOrgRepo);

-    private async void CreateAsync_Works_DataMatches(Cipher cipher, User user, Organization org,
+    private async Task CreateAsync_Works_DataMatches(Cipher cipher, User user, Organization org,
        CipherCompare equalityComparer, List<EfRepo.CipherRepository> suts, List<EfRepo.UserRepository> efUserRepos,
        List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.CipherRepository sqlCipherRepo,
        SqlRepo.UserRepository sqlUserRepo, SqlRepo.OrganizationRepository sqlOrgRepo)
@ -184,7 +184,11 @@ public class CipherRepositoryTests
        List<EfRepo.CipherRepository> suts,
        List<EfRepo.UserRepository> efUserRepos,
        List<EfRepo.OrganizationRepository> efOrgRepos
-            ) => DeleteAsync_CipherIsDeleted(cipher, user, org, suts, efUserRepos, efOrgRepos);
+            )
+    {
+        DeleteAsync_CipherIsDeleted(cipher, user, org, suts, efUserRepos, efOrgRepos);
+        return Task.CompletedTask;
+    }

    private async Task DeleteAsync_CipherIsDeleted(
        Cipher cipher,
--- a/test/Infrastructure.EFIntegration.Test/packages.lock.json
+++ b/test/Infrastructure.EFIntegration.Test/packages.lock.json
@ -659,6 +659,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.Caching.Abstractions": {
        "type": "Transitive",
        "resolved": "6.0.0",
@ -3035,6 +3044,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",
--- a/test/Infrastructure.IntegrationTest/DatabaseDataAttribute.cs
+++ b/test/Infrastructure.IntegrationTest/DatabaseDataAttribute.cs
@ -2,7 +2,6 @@
 using Bit.Core.Enums;
 using Bit.Core.Settings;
 using Bit.Infrastructure.Dapper;
-using Bit.Infrastructure.EntityFramework;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@ -67,7 +66,8 @@ public class DatabaseDataAttribute : DataAttribute
        {
            var efPostgresCollection = new ServiceCollection();
            efPostgresCollection.AddLogging(configureLogging);
-            efPostgresCollection.AddEFRepositories(SelfHosted, efPostgresConnectionString, SupportedDatabaseProviders.Postgres);
+            efPostgresCollection.SetupEntityFramework(efPostgresConnectionString, SupportedDatabaseProviders.Postgres);
+            efPostgresCollection.AddPasswordManagerEFRepositories(SelfHosted);
            efPostgresCollection.AddTransient<ITestDatabaseHelper, EfTestDatabaseHelper>();
            yield return efPostgresCollection.BuildServiceProvider();
        }
@ -76,7 +76,8 @@ public class DatabaseDataAttribute : DataAttribute
        {
            var efMySqlCollection = new ServiceCollection();
            efMySqlCollection.AddLogging(configureLogging);
-            efMySqlCollection.AddEFRepositories(SelfHosted, efMySqlConnectionString, SupportedDatabaseProviders.MySql);
+            efMySqlCollection.SetupEntityFramework(efMySqlConnectionString, SupportedDatabaseProviders.MySql);
+            efMySqlCollection.AddPasswordManagerEFRepositories(SelfHosted);
            efMySqlCollection.AddTransient<ITestDatabaseHelper, EfTestDatabaseHelper>();
            yield return efMySqlCollection.BuildServiceProvider();
        }
--- a/test/Infrastructure.IntegrationTest/packages.lock.json
+++ b/test/Infrastructure.IntegrationTest/packages.lock.json
@ -616,6 +616,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.Caching.Abstractions": {
        "type": "Transitive",
        "resolved": "6.0.0",
@ -2869,6 +2878,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",
--- a/test/IntegrationTestCommon/Factories/WebApplicationFactoryBase.cs
+++ b/test/IntegrationTestCommon/Factories/WebApplicationFactoryBase.cs
@ -26,7 +26,7 @@ public abstract class WebApplicationFactoryBase<T> : WebApplicationFactory<T>
    /// <remarks>
    /// This will need to be set BEFORE using the <c>Server</c> property
    /// </remarks>
-    public string DatabaseName { get; set; } = FactoryConstants.DefaultDatabaseName;
+    public string DatabaseName { get; set; } = Guid.NewGuid().ToString();

    /// <summary>
    /// Configure the web host to use an EF in memory database
@ -115,4 +115,10 @@ public abstract class WebApplicationFactoryBase<T> : WebApplicationFactory<T>
        var scope = Services.CreateScope();
        return scope.ServiceProvider.GetRequiredService<DatabaseContext>();
    }
+
+    public T GetService<T>()
+    {
+        var scope = Services.CreateScope();
+        return scope.ServiceProvider.GetRequiredService<T>();
+    }
 }
--- a/test/IntegrationTestCommon/packages.lock.json
+++ b/test/IntegrationTestCommon/packages.lock.json
@ -643,6 +643,15 @@
          "Microsoft.Extensions.DependencyModel": "6.0.0"
        }
      },
+      "Microsoft.EntityFrameworkCore.SqlServer": {
+        "type": "Transitive",
+        "resolved": "6.0.12",
+        "contentHash": "bdKnSz1w+WZz9QYWhs3wwGuMn4YssjdR+HOBpzChQ6C3+dblq4Pammm5fzugcPOhTgCiWftOT2jPOT5hEy4bYg==",
+        "dependencies": {
+          "Microsoft.Data.SqlClient": "2.1.4",
+          "Microsoft.EntityFrameworkCore.Relational": "6.0.12"
+        }
+      },
      "Microsoft.Extensions.Caching.Abstractions": {
        "type": "Transitive",
        "resolved": "6.0.0",
@ -3158,6 +3167,7 @@
          "AutoMapper.Extensions.Microsoft.DependencyInjection": "[11.0.0, )",
          "Core": "[2022.12.0, )",
          "Microsoft.EntityFrameworkCore.Relational": "[6.0.12, )",
+          "Microsoft.EntityFrameworkCore.SqlServer": "[6.0.12, )",
          "Microsoft.EntityFrameworkCore.Sqlite": "[6.0.12, )",
          "Npgsql.EntityFrameworkCore.PostgreSQL": "[6.0.8, )",
          "Pomelo.EntityFrameworkCore.MySql": "[6.0.2, )",