mirror of
https://github.com/bitwarden/server.git
synced 2025-12-10 00:42:07 -06:00
381 lines
15 KiB
C#
381 lines
15 KiB
C#
using Bit.Core.AdminConsole.Entities;
|
|
using Bit.Core.Auth.Entities;
|
|
using Bit.Core.Entities;
|
|
using Bit.Core.Enums;
|
|
using Bit.Core.KeyManagement.Enums;
|
|
using Bit.Core.KeyManagement.Models.Data;
|
|
using Bit.Core.Models.Data;
|
|
using Bit.Core.Test.AutoFixture.Attributes;
|
|
using Bit.Infrastructure.EFIntegration.Test.AutoFixture;
|
|
using Bit.Infrastructure.EFIntegration.Test.Repositories.EqualityComparers;
|
|
using Xunit;
|
|
using EfRepo = Bit.Infrastructure.EntityFramework.Repositories;
|
|
using SqlAuthRepo = Bit.Infrastructure.Dapper.Auth.Repositories;
|
|
using SqlRepo = Bit.Infrastructure.Dapper.Repositories;
|
|
|
|
namespace Bit.Infrastructure.EFIntegration.Test.Repositories;
|
|
|
|
public class UserRepositoryTests
|
|
{
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task CreateAsync_Works_DataMatches(
|
|
User user, UserCompare equalityComparer,
|
|
List<EfRepo.UserRepository> suts,
|
|
SqlRepo.UserRepository sqlUserRepo
|
|
)
|
|
{
|
|
var savedUsers = new List<User>();
|
|
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
|
|
sut.ClearChangeTracking();
|
|
|
|
var savedUser = await sut.GetByIdAsync(postEfUser.Id);
|
|
savedUsers.Add(savedUser);
|
|
}
|
|
|
|
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
|
savedUsers.Add(await sqlUserRepo.GetByIdAsync(sqlUser.Id));
|
|
|
|
var distinctItems = savedUsers.Distinct(equalityComparer);
|
|
Assert.True(!distinctItems.Skip(1).Any());
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task ReplaceAsync_Works_DataMatches(User postUser, User replaceUser,
|
|
UserCompare equalityComparer, List<EfRepo.UserRepository> suts,
|
|
SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var savedUsers = new List<User>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(postUser);
|
|
replaceUser.Id = postEfUser.Id;
|
|
await sut.ReplaceAsync(replaceUser);
|
|
var replacedUser = await sut.GetByIdAsync(replaceUser.Id);
|
|
savedUsers.Add(replacedUser);
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(postUser);
|
|
replaceUser.Id = postSqlUser.Id;
|
|
await sqlUserRepo.ReplaceAsync(replaceUser);
|
|
savedUsers.Add(await sqlUserRepo.GetByIdAsync(replaceUser.Id));
|
|
|
|
var distinctItems = savedUsers.Distinct(equalityComparer);
|
|
Assert.True(!distinctItems.Skip(1).Any());
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task DeleteAsync_Works_DataMatches(User user, List<EfRepo.UserRepository> suts, SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
|
|
var savedEfUser = await sut.GetByIdAsync(postEfUser.Id);
|
|
Assert.True(savedEfUser != null);
|
|
sut.ClearChangeTracking();
|
|
|
|
await sut.DeleteAsync(savedEfUser);
|
|
sut.ClearChangeTracking();
|
|
|
|
savedEfUser = await sut.GetByIdAsync(savedEfUser.Id);
|
|
Assert.True(savedEfUser == null);
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
|
var savedSqlUser = await sqlUserRepo.GetByIdAsync(postSqlUser.Id);
|
|
Assert.True(savedSqlUser != null);
|
|
|
|
await sqlUserRepo.DeleteAsync(postSqlUser);
|
|
savedSqlUser = await sqlUserRepo.GetByIdAsync(postSqlUser.Id);
|
|
Assert.True(savedSqlUser == null);
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task GetByEmailAsync_Works_DataMatches(User user, UserCompare equalityComparer,
|
|
List<EfRepo.UserRepository> suts, SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var savedUsers = new List<User>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
var savedUser = await sut.GetByEmailAsync(postEfUser.Email.ToUpperInvariant());
|
|
savedUsers.Add(savedUser);
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
|
savedUsers.Add(await sqlUserRepo.GetByEmailAsync(postSqlUser.Email.ToUpperInvariant()));
|
|
|
|
var distinctItems = savedUsers.Distinct(equalityComparer);
|
|
Assert.True(!distinctItems.Skip(1).Any());
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task GetKdfInformationByEmailAsync_Works_DataMatches(User user,
|
|
UserKdfInformationCompare equalityComparer, List<EfRepo.UserRepository> suts,
|
|
SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var savedKdfInformation = new List<UserKdfInformation>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
var kdfInformation = await sut.GetKdfInformationByEmailAsync(postEfUser.Email.ToUpperInvariant());
|
|
savedKdfInformation.Add(kdfInformation);
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
|
var sqlKdfInformation = await sqlUserRepo.GetKdfInformationByEmailAsync(postSqlUser.Email);
|
|
savedKdfInformation.Add(sqlKdfInformation);
|
|
|
|
var distinctItems = savedKdfInformation.Distinct(equalityComparer);
|
|
Assert.True(!distinctItems.Skip(1).Any());
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task SearchAsync_Works_DataMatches(User user, int skip, int take,
|
|
UserCompare equalityCompare, List<EfRepo.UserRepository> suts,
|
|
SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var searchedEfUsers = new List<User>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
|
|
var searchedEfUsersCollection = await sut.SearchAsync(postEfUser.Email.ToUpperInvariant(), skip, take);
|
|
searchedEfUsers.Concat(searchedEfUsersCollection.ToList());
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
|
var searchedSqlUsers = await sqlUserRepo.SearchAsync(postSqlUser.Email.ToUpperInvariant(), skip, take);
|
|
|
|
var distinctItems = searchedEfUsers.Concat(searchedSqlUsers).Distinct(equalityCompare);
|
|
Assert.True(!distinctItems.Skip(1).Any());
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task GetManyByPremiumAsync_Works_DataMatches(User user,
|
|
List<EfRepo.UserRepository> suts, SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var returnedUsers = new List<User>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
|
|
var searchedEfUsers = await sut.GetManyByPremiumAsync(user.Premium);
|
|
returnedUsers.Concat(searchedEfUsers.ToList());
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
|
var searchedSqlUsers = await sqlUserRepo.GetManyByPremiumAsync(user.Premium);
|
|
returnedUsers.Concat(searchedSqlUsers.ToList());
|
|
|
|
Assert.True(returnedUsers.All(x => x.Premium == user.Premium));
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task GetPublicKeyAsync_Works_DataMatches(User user, List<EfRepo.UserRepository> suts,
|
|
SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var returnedKeys = new List<string>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
|
|
var efKey = await sut.GetPublicKeyAsync(postEfUser.Id);
|
|
returnedKeys.Add(efKey);
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
|
var sqlKey = await sqlUserRepo.GetPublicKeyAsync(postSqlUser.Id);
|
|
returnedKeys.Add(sqlKey);
|
|
|
|
Assert.True(!returnedKeys.Distinct().Skip(1).Any());
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task GetAccountRevisionDateAsync(User user, List<EfRepo.UserRepository> suts,
|
|
SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var returnedKeys = new List<string>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
|
|
var efKey = await sut.GetPublicKeyAsync(postEfUser.Id);
|
|
returnedKeys.Add(efKey);
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
|
var sqlKey = await sqlUserRepo.GetPublicKeyAsync(postSqlUser.Id);
|
|
returnedKeys.Add(sqlKey);
|
|
|
|
Assert.True(!returnedKeys.Distinct().Skip(1).Any());
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task UpdateRenewalReminderDateAsync_Works_DataMatches(User user,
|
|
DateTime updatedReminderDate, List<EfRepo.UserRepository> suts,
|
|
SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var savedDates = new List<DateTime?>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var postEfUser = user;
|
|
postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
|
|
await sut.UpdateRenewalReminderDateAsync(postEfUser.Id, updatedReminderDate);
|
|
sut.ClearChangeTracking();
|
|
|
|
var replacedUser = await sut.GetByIdAsync(postEfUser.Id);
|
|
savedDates.Add(replacedUser.RenewalReminderDate);
|
|
}
|
|
|
|
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
|
await sqlUserRepo.UpdateRenewalReminderDateAsync(postSqlUser.Id, updatedReminderDate);
|
|
var replacedSqlUser = await sqlUserRepo.GetByIdAsync(postSqlUser.Id);
|
|
savedDates.Add(replacedSqlUser.RenewalReminderDate);
|
|
|
|
var distinctItems = savedDates.GroupBy(e => e.ToString());
|
|
Assert.True(!distinctItems.Skip(1).Any() &&
|
|
savedDates.All(e => e.ToString() == updatedReminderDate.ToString()));
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task GetBySsoUserAsync_Works_DataMatches(User user, Organization org,
|
|
SsoUser ssoUser, UserCompare equalityComparer, List<EfRepo.UserRepository> suts,
|
|
List<EfRepo.SsoUserRepository> ssoUserRepos, List<EfRepo.OrganizationRepository> orgRepos,
|
|
SqlRepo.UserRepository sqlUserRepo, SqlAuthRepo.SsoUserRepository sqlSsoUserRepo,
|
|
SqlRepo.OrganizationRepository sqlOrgRepo)
|
|
{
|
|
var returnedList = new List<User>();
|
|
foreach (var sut in suts)
|
|
{
|
|
var i = suts.IndexOf(sut);
|
|
|
|
var postEfUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
|
|
var efOrg = await orgRepos[i].CreateAsync(org);
|
|
sut.ClearChangeTracking();
|
|
|
|
ssoUser.UserId = postEfUser.Id;
|
|
ssoUser.OrganizationId = efOrg.Id;
|
|
var postEfSsoUser = await ssoUserRepos[i].CreateAsync(ssoUser);
|
|
sut.ClearChangeTracking();
|
|
|
|
var returnedUser = await sut.GetBySsoUserAsync(postEfSsoUser.ExternalId.ToUpperInvariant(), efOrg.Id);
|
|
returnedList.Add(returnedUser);
|
|
}
|
|
|
|
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
|
var sqlOrganization = await sqlOrgRepo.CreateAsync(org);
|
|
|
|
ssoUser.UserId = sqlUser.Id;
|
|
ssoUser.OrganizationId = sqlOrganization.Id;
|
|
var postSqlSsoUser = await sqlSsoUserRepo.CreateAsync(ssoUser);
|
|
|
|
var returnedSqlUser = await sqlUserRepo
|
|
.GetBySsoUserAsync(postSqlSsoUser.ExternalId, sqlOrganization.Id);
|
|
returnedList.Add(returnedSqlUser);
|
|
|
|
var distinctItems = returnedList.Distinct(equalityComparer);
|
|
Assert.True(!distinctItems.Skip(1).Any());
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task UpdateUserKeyAndEncryptedDataAsync_Works_DataMatches(User user, SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
|
sqlUser.Kdf = KdfType.PBKDF2_SHA256;
|
|
sqlUser.KdfIterations = 6_000_000;
|
|
sqlUser.KdfMemory = 7_000_000;
|
|
sqlUser.KdfParallelism = 8_000_000;
|
|
sqlUser.MasterPassword = "masterPasswordHash";
|
|
sqlUser.MasterPasswordHint = "masterPasswordHint";
|
|
sqlUser.Email = "example@example.com";
|
|
|
|
await sqlUserRepo.UpdateUserKeyAndEncryptedDataV2Async(sqlUser, []);
|
|
var updatedUser = await sqlUserRepo.GetByIdAsync(sqlUser.Id);
|
|
Assert.Equal(sqlUser.Kdf, updatedUser.Kdf);
|
|
Assert.Equal(sqlUser.KdfIterations, updatedUser.KdfIterations);
|
|
Assert.Equal(sqlUser.KdfMemory, updatedUser.KdfMemory);
|
|
Assert.Equal(sqlUser.KdfParallelism, updatedUser.KdfParallelism);
|
|
Assert.Equal(sqlUser.MasterPassword, updatedUser.MasterPassword);
|
|
Assert.Equal(sqlUser.MasterPasswordHint, updatedUser.MasterPasswordHint);
|
|
Assert.Equal(sqlUser.Email, updatedUser.Email);
|
|
}
|
|
|
|
[CiSkippedTheory, EfUserAutoData]
|
|
public async Task UpdateAccountCryptographicStateAsync_Works_DataMatches(
|
|
User user,
|
|
List<EfRepo.UserRepository> suts,
|
|
SqlRepo.UserRepository sqlUserRepo)
|
|
{
|
|
// Test for V1 user (no signature key pair or security state)
|
|
var accountKeysDataV1 = new UserAccountKeysData
|
|
{
|
|
PublicKeyEncryptionKeyPairData = new PublicKeyEncryptionKeyPairData(
|
|
wrappedPrivateKey: "v1-wrapped-private-key",
|
|
publicKey: "v1-public-key"
|
|
)
|
|
};
|
|
|
|
foreach (var sut in suts)
|
|
{
|
|
var createdUser = await sut.CreateAsync(user);
|
|
sut.ClearChangeTracking();
|
|
|
|
await sut.SetV2AccountCryptographicStateAsync(createdUser.Id, accountKeysDataV1);
|
|
sut.ClearChangeTracking();
|
|
|
|
var updatedUser = await sut.GetByIdAsync(createdUser.Id);
|
|
Assert.Equal("v1-public-key", updatedUser.PublicKey);
|
|
Assert.Equal("v1-wrapped-private-key", updatedUser.PrivateKey);
|
|
Assert.Null(updatedUser.SignedPublicKey);
|
|
Assert.Null(updatedUser.SecurityState);
|
|
Assert.Null(updatedUser.SecurityVersion);
|
|
}
|
|
|
|
// Test for V2 user (with signature key pair and security state)
|
|
var accountKeysDataV2 = new UserAccountKeysData
|
|
{
|
|
PublicKeyEncryptionKeyPairData = new PublicKeyEncryptionKeyPairData(
|
|
wrappedPrivateKey: "v2-wrapped-private-key",
|
|
publicKey: "v2-public-key",
|
|
signedPublicKey: "v2-signed-public-key"
|
|
),
|
|
SignatureKeyPairData = new SignatureKeyPairData(
|
|
signatureAlgorithm: SignatureAlgorithm.Ed25519,
|
|
wrappedSigningKey: "v2-wrapped-signing-key",
|
|
verifyingKey: "v2-verifying-key"
|
|
),
|
|
SecurityStateData = new SecurityStateData
|
|
{
|
|
SecurityState = "v2-security-state",
|
|
SecurityVersion = 2
|
|
}
|
|
};
|
|
|
|
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
|
await sqlUserRepo.SetV2AccountCryptographicStateAsync(sqlUser.Id, accountKeysDataV2);
|
|
|
|
var updatedSqlUser = await sqlUserRepo.GetByIdAsync(sqlUser.Id);
|
|
Assert.Equal("v2-public-key", updatedSqlUser.PublicKey);
|
|
Assert.Equal("v2-wrapped-private-key", updatedSqlUser.PrivateKey);
|
|
Assert.Equal("v2-signed-public-key", updatedSqlUser.SignedPublicKey);
|
|
Assert.Equal("v2-security-state", updatedSqlUser.SecurityState);
|
|
Assert.Equal(2, updatedSqlUser.SecurityVersion);
|
|
}
|
|
}
|