mirror of
https://github.com/bitwarden/server
synced 2025-12-30 15:14:02 +00:00
Postgres & MySql Support For Self-Hosted Installations (#1386)
* EF Database Support Init (#1221) * scaffolding for ef support * deleted old postgres repos * added tables to oncreate * updated all the things to .NET 5 * Addition to #1221: Migrated DockerFiles from dotnet/3.1 to 5.0 (#1223) * Migrated DockerFiles from dotnet/3.1 to 5.0 * Migrated SSO/Dockerfile from dotnet 3.1 to 5.0 Co-authored-by: Daniel James Smith <djsmith85@users.noreply.github.com> * EFDatabaseSupport: Updated links and description in README.md and SETUP.md (#1232) * Updated requirements in README.md * Updated link to documentation of app-secrets * upgraded dotnet version to 5.0 * Ef database support implementation examples (#1265) * mostly finished testing the user repo * finished testing user repo * finished org, user, ssoconfig, and ssouser ef implementations * removed unused prop * fixed a sql file * fixed a spacing issue * fixed a spacing issue * removed extra database creation * refactoring * MsSql => SqlServer * refactoring * code review fixes * build fix * code review * continued attempts to fix the the build * skipped another test * finished all create test * initial pass at several repos * continued building out repos * initial pass at several repos * initial pass at device repo * initial pass at collection repo * initial run of all Entity Framework implementations * signup, signin, create/edit ciphers works * sync working * all web vault pages seem to load with 100% 200s * bulkcopy, folders, and favorites * group and collection management * sso, groups, emergency access, send * get basic creates matching on all repos * got everything building again post merge * removed some IDE config files * cleanup * no more notimplemented methods in the cipher repo * no more not implementeds everywhere * cleaned up schema/navigation properties and fixed tests * removed a sql comment that was written in c# style * fixed build issues from merge * removed unsupported db providers * formatting * code review refactors * naming cleanup for queries * added provider methods * cipher repo cleanup * implemented several missing procedures from the EF implementation surround account revision dates, keys, and storage * fixed the build * added a null check * consolidated some cipher repo methods * formatting fix * cleaned up indentation of queries * removed .idea file * generated postgres migrations * added mysql migrations * formatting * Bug Fixes & Formatting * Formatting * fixed a bug with bulk import when using MySql * code review fixes * fixed the build * implemented new methods * formatting * fixed the build * cleaned up select statements in ef queries * formatting * formatting * formatting Co-authored-by: Daniel James Smith <djsmith85@users.noreply.github.com>
This commit is contained in:
Addison Beck
GitHub
@@ -0,0 +1,200 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Bit.Core.Models.Table;
|
||||
using Bit.Core.Repositories.EntityFramework;
|
||||
using Bit.Core.Test.AutoFixture;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.CipherFixtures;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Xunit;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using Bit.Core.Test.AutoFixture.CipherFixtures;
|
||||
using Bit.Core.Repositories.EntityFramework.Queries;
|
||||
using Bit.Core.Models.Data;
|
||||
using System;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class CipherRepositoryTests
|
||||
{
|
||||
[Theory (Skip = "Run ad-hoc"), EfUserCipherAutoData]
|
||||
public async void RefreshDb(List<EfRepo.CipherRepository> suts)
|
||||
{
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
await sut.RefreshDb();
|
||||
}
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfUserCipherAutoData, EfOrganizationCipherAutoData]
|
||||
public async void 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)
|
||||
{
|
||||
var savedCiphers = new List<Cipher>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
sut.ClearChangeTracking();
|
||||
cipher.UserId = efUser.Id;
|
||||
|
||||
if (cipher.OrganizationId.HasValue)
|
||||
{
|
||||
var efOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
cipher.OrganizationId = efOrg.Id;
|
||||
}
|
||||
|
||||
var postEfCipher = await sut.CreateAsync(cipher);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedCipher = await sut.GetByIdAsync(postEfCipher.Id);
|
||||
savedCiphers.Add(savedCipher);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
cipher.UserId = sqlUser.Id;
|
||||
|
||||
if (cipher.OrganizationId.HasValue)
|
||||
{
|
||||
var sqlOrg = await sqlOrgRepo.CreateAsync(org);
|
||||
cipher.OrganizationId = sqlOrg.Id;
|
||||
}
|
||||
|
||||
var sqlCipher = await sqlCipherRepo.CreateAsync(cipher);
|
||||
var savedSqlCipher = await sqlCipherRepo.GetByIdAsync(sqlCipher.Id);
|
||||
savedCiphers.Add(savedSqlCipher);
|
||||
|
||||
var distinctItems = savedCiphers.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfUserCipherAutoData]
|
||||
public async void CreateAsync_BumpsUserAccountRevisionDate(Cipher cipher, User user,
|
||||
CipherCompare equalityComparer, List<EfRepo.CipherRepository> suts, List<EfRepo.UserRepository> efUserRepos,
|
||||
SqlRepo.CipherRepository sqlCipherRepo, SqlRepo.UserRepository sqlUserRepo)
|
||||
{
|
||||
var bumpedUsers = new List<User>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
efUserRepos[i].ClearChangeTracking();
|
||||
cipher.UserId = efUser.Id;
|
||||
cipher.OrganizationId = null;
|
||||
|
||||
var postEfCipher = await sut.CreateAsync(cipher);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var bumpedUser = await efUserRepos[i].GetByIdAsync(efUser.Id);
|
||||
bumpedUsers.Add(bumpedUser);
|
||||
}
|
||||
|
||||
Assert.True(bumpedUsers.All(u => u.AccountRevisionDate.ToShortDateString() == DateTime.UtcNow.ToShortDateString() ));
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfOrganizationCipherAutoData]
|
||||
public async void CreateAsync_BumpsOrgUserAccountRevisionDates(Cipher cipher, List<User> users,
|
||||
List<OrganizationUser> orgUsers, Collection collection, Organization org, CipherCompare equalityComparer,
|
||||
List<EfRepo.CipherRepository> suts, List<EfRepo.UserRepository> efUserRepos, List<EfRepo.OrganizationRepository> efOrgRepos,
|
||||
List<EfRepo.OrganizationUserRepository> efOrgUserRepos, List<EfRepo.CollectionRepository> efCollectionRepos)
|
||||
{
|
||||
var savedCiphers = new List<Cipher>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efUsers = await efUserRepos[i].CreateMany(users);
|
||||
efUserRepos[i].ClearChangeTracking();
|
||||
var efOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
efOrgRepos[i].ClearChangeTracking();
|
||||
|
||||
cipher.OrganizationId = efOrg.Id;
|
||||
|
||||
collection.OrganizationId = efOrg.Id;
|
||||
var efCollection = await efCollectionRepos[i].CreateAsync(collection);
|
||||
efCollectionRepos[i].ClearChangeTracking();
|
||||
|
||||
IEnumerable<object>[] lists = {efUsers, orgUsers};
|
||||
var maxOrgUsers = lists.Min(l => l.Count());
|
||||
|
||||
orgUsers = orgUsers.Take(maxOrgUsers).ToList();
|
||||
efUsers = efUsers.Take(maxOrgUsers).ToList();
|
||||
|
||||
for (var j = 0; j < maxOrgUsers; j++)
|
||||
{
|
||||
orgUsers[j].OrganizationId = efOrg.Id;
|
||||
orgUsers[j].UserId = efUsers[j].Id;
|
||||
}
|
||||
|
||||
orgUsers = await efOrgUserRepos[i].CreateMany(orgUsers);
|
||||
|
||||
var selectionReadOnlyList = new List<SelectionReadOnly>();
|
||||
orgUsers.ForEach(ou => selectionReadOnlyList.Add(new SelectionReadOnly() { Id = ou.Id }));
|
||||
|
||||
await efCollectionRepos[i].UpdateUsersAsync(efCollection.Id, selectionReadOnlyList);
|
||||
efCollectionRepos[i].ClearChangeTracking();
|
||||
|
||||
foreach (var ou in orgUsers)
|
||||
{
|
||||
var collectionUser = new CollectionUser() {
|
||||
CollectionId = efCollection.Id,
|
||||
OrganizationUserId = ou.Id
|
||||
};
|
||||
}
|
||||
|
||||
cipher.UserId = null;
|
||||
var postEfCipher = await sut.CreateAsync(cipher);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var query = new UserBumpAccountRevisionDateByCipherIdQuery(cipher);
|
||||
var modifiedUsers = await sut.Run(query).ToListAsync();
|
||||
Assert.True(modifiedUsers
|
||||
.All(u => u.AccountRevisionDate.ToShortDateString() ==
|
||||
DateTime.UtcNow.ToShortDateString()));
|
||||
}
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfUserCipherAutoData, EfOrganizationCipherAutoData]
|
||||
public async void DeleteAsync_CipherIsDeleted(
|
||||
Cipher cipher,
|
||||
User user,
|
||||
Organization org,
|
||||
List<EfRepo.CipherRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos
|
||||
)
|
||||
{
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var postEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
efOrgRepos[i].ClearChangeTracking();
|
||||
var postEfUser = await efUserRepos[i].CreateAsync(user);
|
||||
efUserRepos[i].ClearChangeTracking();
|
||||
|
||||
if (cipher.OrganizationId.HasValue)
|
||||
{
|
||||
cipher.OrganizationId = postEfOrg.Id;
|
||||
}
|
||||
cipher.UserId = postEfUser.Id;
|
||||
|
||||
await sut.CreateAsync(cipher);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
await sut.DeleteAsync(cipher);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedCipher = await sut.GetByIdAsync(cipher.Id);
|
||||
Assert.True(savedCipher == null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
using Bit.Core.Repositories.EntityFramework;
|
||||
using Bit.Core.Test.AutoFixture;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Xunit;
|
||||
using Bit.Core.Models.Table;
|
||||
using System.Collections.Generic;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Bit.Core.Test.AutoFixture.CollectionFixtures;
|
||||
using System.Linq;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class CollectionRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfCollectionAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
Collection collection,
|
||||
Organization organization,
|
||||
CollectionCompare equalityComparer,
|
||||
List<EfRepo.CollectionRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrganizationRepos,
|
||||
SqlRepo.CollectionRepository sqlCollectionRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo
|
||||
)
|
||||
{
|
||||
var savedCollections = new List<Collection>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
var efOrganization = await efOrganizationRepos[i].CreateAsync(organization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
collection.OrganizationId = efOrganization.Id;
|
||||
var postEfCollection = await sut.CreateAsync(collection);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedCollection = await sut.GetByIdAsync(postEfCollection.Id);
|
||||
savedCollections.Add(savedCollection);
|
||||
}
|
||||
|
||||
var sqlOrganization = await sqlOrganizationRepo.CreateAsync(organization);
|
||||
collection.OrganizationId = sqlOrganization.Id;
|
||||
|
||||
var sqlCollection = await sqlCollectionRepo.CreateAsync(collection);
|
||||
var savedSqlCollection = await sqlCollectionRepo.GetByIdAsync(sqlCollection.Id);
|
||||
savedCollections.Add(savedSqlCollection);
|
||||
|
||||
var distinctItems = savedCollections.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Xunit;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using System.Collections.Generic;
|
||||
using Bit.Core.Models.Table;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using System.Linq;
|
||||
using Bit.Core.Test.AutoFixture.DeviceFixtures;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class DeviceRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfDeviceAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(Device device, User user,
|
||||
DeviceCompare equalityComparer, List<EfRepo.DeviceRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos, SqlRepo.DeviceRepository sqlDeviceRepo,
|
||||
SqlRepo.UserRepository sqlUserRepo)
|
||||
{
|
||||
var savedDevices = new List<Device>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
device.UserId = efUser.Id;
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var postEfDevice = await sut.CreateAsync(device);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedDevice = await sut.GetByIdAsync(postEfDevice.Id);
|
||||
savedDevices.Add(savedDevice);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
device.UserId = sqlUser.Id;
|
||||
|
||||
var sqlDevice = await sqlDeviceRepo.CreateAsync(device);
|
||||
var savedSqlDevice = await sqlDeviceRepo.GetByIdAsync(sqlDevice.Id);
|
||||
savedDevices.Add(savedSqlDevice);
|
||||
|
||||
var distinctItems = savedDevices.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
using System.Collections.Generic;
|
||||
using Bit.Core.Models.Table;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.EmergencyAccessFixtures;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Xunit;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using System.Linq;
|
||||
using AutoFixture;
|
||||
using Bit.Core.Test.AutoFixture.TransactionFixtures;
|
||||
using AutoFixture.DataAnnotations;
|
||||
using AutoFixture.Kernel;
|
||||
using Bit.Core.Test.AutoFixture.Relays;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class EmergencyAccessRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfEmergencyAccessAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
EmergencyAccess emergencyAccess,
|
||||
List<User> users,
|
||||
EmergencyAccessCompare equalityComparer,
|
||||
List<EfRepo.EmergencyAccessRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos,
|
||||
SqlRepo.EmergencyAccessRepository sqlEmergencyAccessRepo,
|
||||
SqlRepo.UserRepository sqlUserRepo
|
||||
)
|
||||
{
|
||||
var savedEmergencyAccesss = new List<EmergencyAccess>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
for (int j = 0; j < users.Count; j++)
|
||||
{
|
||||
users[j] = await efUserRepos[i].CreateAsync(users[j]);
|
||||
}
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
emergencyAccess.GrantorId = users[0].Id;
|
||||
emergencyAccess.GranteeId = users[0].Id;
|
||||
var postEfEmergencyAccess = await sut.CreateAsync(emergencyAccess);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEmergencyAccess = await sut.GetByIdAsync(postEfEmergencyAccess.Id);
|
||||
savedEmergencyAccesss.Add(savedEmergencyAccess);
|
||||
}
|
||||
|
||||
for (int j = 0; j < users.Count; j++)
|
||||
{
|
||||
users[j] = await sqlUserRepo.CreateAsync(users[j]);
|
||||
}
|
||||
|
||||
emergencyAccess.GrantorId = users[0].Id;
|
||||
emergencyAccess.GranteeId = users[0].Id;
|
||||
var sqlEmergencyAccess = await sqlEmergencyAccessRepo.CreateAsync(emergencyAccess);
|
||||
var savedSqlEmergencyAccess = await sqlEmergencyAccessRepo.GetByIdAsync(sqlEmergencyAccess.Id);
|
||||
savedEmergencyAccesss.Add(savedSqlEmergencyAccess);
|
||||
|
||||
var distinctItems = savedEmergencyAccesss.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class CipherCompare: IEqualityComparer<Cipher>
|
||||
{
|
||||
public bool Equals(Cipher x, Cipher y)
|
||||
{
|
||||
return x.Type == y.Type &&
|
||||
x.Data == y.Data &&
|
||||
x.Favorites == y.Favorites &&
|
||||
x.Attachments == y.Attachments;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Cipher obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class CollectionCompare: IEqualityComparer<Collection>
|
||||
{
|
||||
public bool Equals(Collection x, Collection y)
|
||||
{
|
||||
return x.Name == y.Name &&
|
||||
x.ExternalId == y.ExternalId;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Collection obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class DeviceCompare: IEqualityComparer<Device>
|
||||
{
|
||||
public bool Equals(Device x, Device y)
|
||||
{
|
||||
return x.Name == y.Name &&
|
||||
x.Type == y.Type &&
|
||||
x.Identifier == y.Identifier &&
|
||||
x.PushToken == y.PushToken;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Device obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class EmergencyAccessCompare: IEqualityComparer<EmergencyAccess>
|
||||
{
|
||||
public bool Equals(EmergencyAccess x, EmergencyAccess y)
|
||||
{
|
||||
return x.Email == y.Email &&
|
||||
x.KeyEncrypted == y.KeyEncrypted &&
|
||||
x.Type == y.Type &&
|
||||
x.Status == y.Status &&
|
||||
x.WaitTimeDays == y.WaitTimeDays &&
|
||||
x.RecoveryInitiatedDate == y.RecoveryInitiatedDate &&
|
||||
x.LastNotificationDate == y.LastNotificationDate;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] EmergencyAccess obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class EventCompare: IEqualityComparer<Event>
|
||||
{
|
||||
public bool Equals(Event x, Event y)
|
||||
{
|
||||
return x.Date.ToShortDateString() == y.Date.ToShortDateString() &&
|
||||
x.Type == y.Type &&
|
||||
x.IpAddress == y.IpAddress;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Event obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class FolderCompare: IEqualityComparer<Folder>
|
||||
{
|
||||
public bool Equals(Folder x, Folder y)
|
||||
{
|
||||
return x.Name == y.Name;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Folder obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class GrantCompare: IEqualityComparer<Grant>
|
||||
{
|
||||
public bool Equals(Grant x, Grant y)
|
||||
{
|
||||
return x.Key == y.Key &&
|
||||
x.Type == y.Type &&
|
||||
x.SubjectId == y.SubjectId &&
|
||||
x.ClientId == y.ClientId &&
|
||||
x.Description == y.Description &&
|
||||
x.ExpirationDate == y.ExpirationDate &&
|
||||
x.ConsumedDate == y.ConsumedDate &&
|
||||
x.Data == y.Data;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Grant obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class GroupCompare: IEqualityComparer<Group>
|
||||
{
|
||||
public bool Equals(Group x, Group y)
|
||||
{
|
||||
return x.Name == y.Name &&
|
||||
x.AccessAll == y.AccessAll &&
|
||||
x.ExternalId == y.ExternalId;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Group obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class InstallationCompare: IEqualityComparer<Installation>
|
||||
{
|
||||
public bool Equals(Installation x, Installation y)
|
||||
{
|
||||
return x.Email == y.Email &&
|
||||
x.Key == y.Key &&
|
||||
x.Enabled == y.Enabled;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Installation obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class OrganizationCompare: IEqualityComparer<Organization>
|
||||
{
|
||||
public bool Equals(Organization x, Organization y)
|
||||
{
|
||||
var a = x.ExpirationDate.ToString();
|
||||
var b = y.ExpirationDate.ToString();
|
||||
return x.Identifier.Equals(y.Identifier) &&
|
||||
x.Name.Equals(y.Name) &&
|
||||
x.BusinessName.Equals(y.BusinessName) &&
|
||||
x.BusinessAddress1.Equals(y.BusinessAddress1) &&
|
||||
x.BusinessAddress2.Equals(y.BusinessAddress2) &&
|
||||
x.BusinessAddress3.Equals(y.BusinessAddress3) &&
|
||||
x.BusinessCountry.Equals(y.BusinessCountry) &&
|
||||
x.BusinessTaxNumber.Equals(y.BusinessTaxNumber) &&
|
||||
x.BillingEmail.Equals(y.BillingEmail) &&
|
||||
x.Plan.Equals(y.Plan) &&
|
||||
x.PlanType.Equals(y.PlanType) &&
|
||||
x.Seats.Equals(y.Seats) &&
|
||||
x.MaxCollections.Equals(y.MaxCollections) &&
|
||||
x.UsePolicies.Equals(y.UsePolicies) &&
|
||||
x.UseSso.Equals(y.UseSso) &&
|
||||
x.UseGroups.Equals(y.UseGroups) &&
|
||||
x.UseDirectory.Equals(y.UseDirectory) &&
|
||||
x.UseEvents.Equals(y.UseEvents) &&
|
||||
x.UseTotp.Equals(y.UseTotp) &&
|
||||
x.Use2fa.Equals(y.Use2fa) &&
|
||||
x.UseApi.Equals(y.UseApi) &&
|
||||
x.SelfHost.Equals(y.SelfHost) &&
|
||||
x.UsersGetPremium.Equals(y.UsersGetPremium) &&
|
||||
x.Storage.Equals(y.Storage) &&
|
||||
x.MaxStorageGb.Equals(y.MaxStorageGb) &&
|
||||
x.Gateway.Equals(y.Gateway) &&
|
||||
x.GatewayCustomerId.Equals(y.GatewayCustomerId) &&
|
||||
x.GatewaySubscriptionId.Equals(y.GatewaySubscriptionId) &&
|
||||
x.ReferenceData.Equals(y.ReferenceData) &&
|
||||
x.Enabled.Equals(y.Enabled) &&
|
||||
x.LicenseKey.Equals(y.LicenseKey) &&
|
||||
x.ApiKey.Equals(y.ApiKey) &&
|
||||
x.TwoFactorProviders.Equals(y.TwoFactorProviders) &&
|
||||
x.ExpirationDate.ToString().Equals(y.ExpirationDate.ToString());
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Organization obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class OrganizationUserCompare: IEqualityComparer<OrganizationUser>
|
||||
{
|
||||
public bool Equals(OrganizationUser x, OrganizationUser y)
|
||||
{
|
||||
return x.Email == y.Email &&
|
||||
x.Status == y.Status &&
|
||||
x.Type == y.Type &&
|
||||
x.AccessAll == y.AccessAll &&
|
||||
x.ExternalId == y.ExternalId &&
|
||||
x.Permissions == y.Permissions;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] OrganizationUser obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class PolicyCompare: IEqualityComparer<Policy>
|
||||
{
|
||||
public bool Equals(Policy x, Policy y)
|
||||
{
|
||||
return x.Type == y.Type &&
|
||||
x.Data == y.Data &&
|
||||
x.Enabled == y.Enabled;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Policy obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class SendCompare: IEqualityComparer<Send>
|
||||
{
|
||||
public bool Equals(Send x, Send y)
|
||||
{
|
||||
return x.Type == y.Type &&
|
||||
x.Data == y.Data &&
|
||||
x.Key == y.Key &&
|
||||
x.Password == y.Password &&
|
||||
x.MaxAccessCount == y.MaxAccessCount &&
|
||||
x.AccessCount == y.AccessCount &&
|
||||
x.ExpirationDate?.ToShortDateString() == y.ExpirationDate?.ToShortDateString() &&
|
||||
x.DeletionDate.ToShortDateString() == y.DeletionDate.ToShortDateString() &&
|
||||
x.Disabled == y.Disabled &&
|
||||
x.HideEmail == y.HideEmail;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Send obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class SsoConfigCompare: IEqualityComparer<SsoConfig>
|
||||
{
|
||||
public bool Equals(SsoConfig x, SsoConfig y)
|
||||
{
|
||||
return x.Enabled == y.Enabled &&
|
||||
x.OrganizationId == y.OrganizationId &&
|
||||
x.Data == y.Data;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] SsoConfig obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class SsoUserCompare: IEqualityComparer<SsoUser>
|
||||
{
|
||||
public bool Equals(SsoUser x, SsoUser y)
|
||||
{
|
||||
return x.ExternalId == y.ExternalId;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] SsoUser obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class TaxRateCompare: IEqualityComparer<TaxRate>
|
||||
{
|
||||
public bool Equals(TaxRate x, TaxRate y)
|
||||
{
|
||||
return x.Country == y.Country &&
|
||||
x.State == y.State &&
|
||||
x.PostalCode == y.PostalCode &&
|
||||
x.Rate == y.Rate &&
|
||||
x.Active == y.Active;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] TaxRate obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class TransactionCompare: IEqualityComparer<Transaction>
|
||||
{
|
||||
public bool Equals(Transaction x, Transaction y)
|
||||
{
|
||||
return x.Type == y.Type &&
|
||||
x.Amount == y.Amount &&
|
||||
x.Refunded == y.Refunded &&
|
||||
x.Details == y.Details &&
|
||||
x.PaymentMethodType == y.PaymentMethodType &&
|
||||
x.Gateway == y.Gateway &&
|
||||
x.GatewayId == y.GatewayId;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] Transaction obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class U2fCompare: IEqualityComparer<U2f>
|
||||
{
|
||||
public bool Equals(U2f x, U2f y)
|
||||
{
|
||||
return x.KeyHandle == y.KeyHandle &&
|
||||
x.Challenge == y.Challenge &&
|
||||
x.AppId == y.AppId &&
|
||||
x.Version == y.Version;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] U2f obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Table;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class UserCompare: IEqualityComparer<User>
|
||||
{
|
||||
public bool Equals(User x, User y)
|
||||
{
|
||||
return x.Name == y.Name &&
|
||||
x.Email == y.Email &&
|
||||
x.EmailVerified == y.EmailVerified &&
|
||||
x.MasterPassword == y.MasterPassword &&
|
||||
x.MasterPasswordHint == y.MasterPasswordHint &&
|
||||
x.Culture == y.Culture &&
|
||||
x.SecurityStamp == y.SecurityStamp &&
|
||||
x.TwoFactorProviders == y.TwoFactorProviders &&
|
||||
x.TwoFactorRecoveryCode == y.TwoFactorRecoveryCode &&
|
||||
x.EquivalentDomains == y.EquivalentDomains &&
|
||||
x.Key == y.Key &&
|
||||
x.PublicKey == y.PublicKey &&
|
||||
x.PrivateKey == y.PrivateKey &&
|
||||
x.Premium == y.Premium &&
|
||||
x.Storage == y.Storage &&
|
||||
x.MaxStorageGb == y.MaxStorageGb &&
|
||||
x.Gateway == y.Gateway &&
|
||||
x.GatewayCustomerId == y.GatewayCustomerId &&
|
||||
x.ReferenceData == y.ReferenceData &&
|
||||
x.LicenseKey == y.LicenseKey &&
|
||||
x.ApiKey == y.ApiKey &&
|
||||
x.Kdf == y.Kdf &&
|
||||
x.KdfIterations == y.KdfIterations;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] User obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using Bit.Core.Models.Data;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework.EqualityComparers
|
||||
{
|
||||
public class UserKdfInformationCompare: IEqualityComparer<UserKdfInformation>
|
||||
{
|
||||
public bool Equals(UserKdfInformation x, UserKdfInformation y)
|
||||
{
|
||||
return x.Kdf == y.Kdf &&
|
||||
x.KdfIterations == y.KdfIterations;
|
||||
}
|
||||
|
||||
public int GetHashCode([DisallowNull] UserKdfInformation obj)
|
||||
{
|
||||
return base.GetHashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
using System.Collections.Generic;
|
||||
using Bit.Core.Models.Table;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.FolderFixtures;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Xunit;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using System.Linq;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class FolderRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfFolderAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
Folder folder,
|
||||
User user,
|
||||
FolderCompare equalityComparer,
|
||||
List<EfRepo.FolderRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos,
|
||||
SqlRepo.FolderRepository sqlFolderRepo,
|
||||
SqlRepo.UserRepository sqlUserRepo)
|
||||
{
|
||||
var savedFolders = new List<Folder>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
folder.UserId = efUser.Id;
|
||||
var postEfFolder = await sut.CreateAsync(folder);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedFolder = await sut.GetByIdAsync(folder.Id);
|
||||
savedFolders.Add(savedFolder);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
|
||||
folder.UserId = sqlUser.Id;
|
||||
var sqlFolder = await sqlFolderRepo.CreateAsync(folder);
|
||||
savedFolders.Add(await sqlFolderRepo.GetByIdAsync(sqlFolder.Id));
|
||||
|
||||
var distinctItems = savedFolders.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
using System.Collections.Generic;
|
||||
using Bit.Core.Models.Table;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.InstallationFixtures;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Xunit;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using System.Linq;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class InstallationRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfInstallationAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
Installation installation,
|
||||
InstallationCompare equalityComparer,
|
||||
List<EfRepo.InstallationRepository> suts,
|
||||
SqlRepo.InstallationRepository sqlInstallationRepo
|
||||
)
|
||||
{
|
||||
var savedInstallations = new List<Installation>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var postEfInstallation = await sut.CreateAsync(installation);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedInstallation = await sut.GetByIdAsync(postEfInstallation.Id);
|
||||
savedInstallations.Add(savedInstallation);
|
||||
}
|
||||
|
||||
var sqlInstallation = await sqlInstallationRepo.CreateAsync(installation);
|
||||
var savedSqlInstallation = await sqlInstallationRepo.GetByIdAsync(sqlInstallation.Id);
|
||||
savedInstallations.Add(savedSqlInstallation);
|
||||
|
||||
var distinctItems = savedInstallations.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,158 @@
|
||||
using Bit.Core.Test.AutoFixture;
|
||||
using Bit.Core.Test.Helpers.Factories;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using TableModel = Bit.Core.Models.Table;
|
||||
using Bit.Core.Models.Data;
|
||||
using Xunit;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Bit.Core.Test.AutoFixture.OrganizationFixtures;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class OrganizationRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfOrganizationAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
TableModel.Organization organization,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo, OrganizationCompare equalityComparer,
|
||||
List<EfRepo.OrganizationRepository> suts)
|
||||
{
|
||||
var savedOrganizations = new List<TableModel.Organization>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var postEfOrganization = await sut.CreateAsync(organization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedOrganization = await sut.GetByIdAsync(organization.Id);
|
||||
savedOrganizations.Add(savedOrganization);
|
||||
}
|
||||
|
||||
var sqlOrganization = await sqlOrganizationRepo.CreateAsync(organization);
|
||||
savedOrganizations.Add(await sqlOrganizationRepo.GetByIdAsync(sqlOrganization.Id));
|
||||
|
||||
var distinctItems = savedOrganizations.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfOrganizationAutoData]
|
||||
public async void ReplaceAsync_Works_DataMatches(TableModel.Organization postOrganization,
|
||||
TableModel.Organization replaceOrganization, SqlRepo.OrganizationRepository sqlOrganizationRepo,
|
||||
OrganizationCompare equalityComparer, List<EfRepo.OrganizationRepository> suts)
|
||||
{
|
||||
var savedOrganizations = new List<TableModel.Organization>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var postEfOrganization = await sut.CreateAsync(postOrganization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
replaceOrganization.Id = postEfOrganization.Id;
|
||||
await sut.ReplaceAsync(replaceOrganization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var replacedOrganization = await sut.GetByIdAsync(replaceOrganization.Id);
|
||||
savedOrganizations.Add(replacedOrganization);
|
||||
}
|
||||
|
||||
var postSqlOrganization = await sqlOrganizationRepo.CreateAsync(postOrganization);
|
||||
replaceOrganization.Id = postSqlOrganization.Id;
|
||||
await sqlOrganizationRepo.ReplaceAsync(replaceOrganization);
|
||||
savedOrganizations.Add(await sqlOrganizationRepo.GetByIdAsync(replaceOrganization.Id));
|
||||
|
||||
var distinctItems = savedOrganizations.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfOrganizationAutoData]
|
||||
public async void DeleteAsync_Works_DataMatches(TableModel.Organization organization,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo, OrganizationCompare equalityComparer,
|
||||
List<EfRepo.OrganizationRepository> suts)
|
||||
{
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var postEfOrganization = await sut.CreateAsync(organization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEfOrganization = await sut.GetByIdAsync(postEfOrganization.Id);
|
||||
sut.ClearChangeTracking();
|
||||
Assert.True(savedEfOrganization != null);
|
||||
|
||||
await sut.DeleteAsync(savedEfOrganization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
savedEfOrganization = await sut.GetByIdAsync(savedEfOrganization.Id);
|
||||
Assert.True(savedEfOrganization == null);
|
||||
}
|
||||
|
||||
var postSqlOrganization = await sqlOrganizationRepo.CreateAsync(organization);
|
||||
var savedSqlOrganization = await sqlOrganizationRepo.GetByIdAsync(postSqlOrganization.Id);
|
||||
Assert.True(savedSqlOrganization != null);
|
||||
|
||||
await sqlOrganizationRepo.DeleteAsync(postSqlOrganization);
|
||||
savedSqlOrganization = await sqlOrganizationRepo.GetByIdAsync(postSqlOrganization.Id);
|
||||
Assert.True(savedSqlOrganization == null);
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfOrganizationAutoData]
|
||||
public async void GetByIdentifierAsync_Works_DataMatches(TableModel.Organization organization,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo, OrganizationCompare equalityComparer,
|
||||
List<EfRepo.OrganizationRepository> suts)
|
||||
{
|
||||
var returnedOrgs = new List<TableModel.Organization>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var postEfOrg = await sut.CreateAsync(organization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var returnedOrg = await sut.GetByIdentifierAsync(postEfOrg.Identifier.ToUpperInvariant());
|
||||
returnedOrgs.Add(returnedOrg);
|
||||
}
|
||||
|
||||
var postSqlOrg = await sqlOrganizationRepo.CreateAsync(organization);
|
||||
returnedOrgs.Add(await sqlOrganizationRepo.GetByIdentifierAsync(postSqlOrg.Identifier.ToUpperInvariant()));
|
||||
|
||||
var distinctItems = returnedOrgs.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfOrganizationAutoData]
|
||||
public async void GetManyByEnabledAsync_Works_DataMatches(TableModel.Organization organization,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo, OrganizationCompare equalityCompare,
|
||||
List<EfRepo.OrganizationRepository> suts)
|
||||
{
|
||||
var returnedOrgs = new List<TableModel.Organization>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var postEfOrg = await sut.CreateAsync(organization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var efReturnedOrgs = await sut.GetManyByEnabledAsync();
|
||||
returnedOrgs.Concat(efReturnedOrgs);
|
||||
}
|
||||
|
||||
var postSqlOrg = await sqlOrganizationRepo.CreateAsync(organization);
|
||||
returnedOrgs.Concat(await sqlOrganizationRepo.GetManyByEnabledAsync());
|
||||
|
||||
Assert.True(returnedOrgs.All(o => o.Enabled));
|
||||
}
|
||||
|
||||
// testing data matches here would require manipulating all organization abilities in the db
|
||||
[CiSkippedTheory, EfOrganizationAutoData]
|
||||
public async void GetManyAbilitiesAsync_Works(TableModel.Organization organization,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo, OrganizationCompare equalityComparer,
|
||||
List<EfRepo.OrganizationRepository> suts)
|
||||
{
|
||||
var list = new List<OrganizationAbility>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
list.Concat(await sut.GetManyAbilitiesAsync());
|
||||
}
|
||||
|
||||
list.Concat(await sqlOrganizationRepo.GetManyAbilitiesAsync());
|
||||
Assert.True(list.All(x => x.GetType() == typeof(OrganizationAbility)));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
using Bit.Core.Test.AutoFixture.OrganizationUserFixtures;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using TableModel = Bit.Core.Models.Table;
|
||||
using Xunit;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Bit.Core.Models.Data;
|
||||
using System;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class OrganizationUserRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfOrganizationUserAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(TableModel.OrganizationUser orgUser, TableModel.User user, TableModel.Organization org,
|
||||
OrganizationUserCompare equalityComparer, List<EfRepo.OrganizationUserRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos, List<EfRepo.UserRepository> efUserRepos,
|
||||
SqlRepo.OrganizationUserRepository sqlOrgUserRepo, SqlRepo.UserRepository sqlUserRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrgRepo)
|
||||
{
|
||||
var savedOrgUsers = new List<TableModel.OrganizationUser>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
var postEfUser = await efUserRepos[i].CreateAsync(user);
|
||||
var postEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
orgUser.UserId = postEfUser.Id;
|
||||
orgUser.OrganizationId = postEfOrg.Id;
|
||||
var postEfOrgUser = await sut.CreateAsync(orgUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedOrgUser = await sut.GetByIdAsync(postEfOrgUser.Id);
|
||||
savedOrgUsers.Add(savedOrgUser);
|
||||
}
|
||||
|
||||
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
var postSqlOrg = await sqlOrgRepo.CreateAsync(org);
|
||||
|
||||
orgUser.UserId = postSqlUser.Id;
|
||||
orgUser.OrganizationId = postSqlOrg.Id;
|
||||
var sqlOrgUser = await sqlOrgUserRepo.CreateAsync(orgUser);
|
||||
|
||||
var savedSqlOrgUser = await sqlOrgUserRepo.GetByIdAsync(sqlOrgUser.Id);
|
||||
savedOrgUsers.Add(savedSqlOrgUser);
|
||||
|
||||
var distinctItems = savedOrgUsers.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfOrganizationUserAutoData]
|
||||
public async void ReplaceAsync_Works_DataMatches(
|
||||
TableModel.OrganizationUser postOrgUser,
|
||||
TableModel.OrganizationUser replaceOrgUser,
|
||||
TableModel.User user,
|
||||
TableModel.Organization org,
|
||||
OrganizationUserCompare equalityComparer,
|
||||
List<EfRepo.OrganizationUserRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos,
|
||||
SqlRepo.OrganizationUserRepository sqlOrgUserRepo,
|
||||
SqlRepo.UserRepository sqlUserRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrgRepo
|
||||
)
|
||||
{
|
||||
var savedOrgUsers = new List<TableModel.OrganizationUser>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
var postEfUser = await efUserRepos[i].CreateAsync(user);
|
||||
var postEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
postOrgUser.UserId = replaceOrgUser.UserId = postEfUser.Id;
|
||||
postOrgUser.OrganizationId = replaceOrgUser.OrganizationId = postEfOrg.Id;
|
||||
var postEfOrgUser = await sut.CreateAsync(postOrgUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
replaceOrgUser.Id = postOrgUser.Id;
|
||||
await sut.ReplaceAsync(replaceOrgUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var replacedOrganizationUser = await sut.GetByIdAsync(replaceOrgUser.Id);
|
||||
savedOrgUsers.Add(replacedOrganizationUser);
|
||||
}
|
||||
|
||||
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
var postSqlOrg = await sqlOrgRepo.CreateAsync(org);
|
||||
|
||||
postOrgUser.UserId = replaceOrgUser.UserId = postSqlUser.Id;
|
||||
postOrgUser.OrganizationId = replaceOrgUser.OrganizationId = postSqlOrg.Id;
|
||||
var postSqlOrgUser = await sqlOrgUserRepo.CreateAsync(postOrgUser);
|
||||
|
||||
replaceOrgUser.Id = postSqlOrgUser.Id;
|
||||
await sqlOrgUserRepo.ReplaceAsync(replaceOrgUser);
|
||||
|
||||
var replacedSqlUser = await sqlOrgUserRepo.GetByIdAsync(replaceOrgUser.Id);
|
||||
|
||||
var distinctItems = savedOrgUsers.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfOrganizationUserAutoData]
|
||||
public async void DeleteAsync_Works_DataMatches(TableModel.OrganizationUser orgUser, TableModel.User user, TableModel.Organization org,
|
||||
OrganizationUserCompare equalityComparer, List<EfRepo.OrganizationUserRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos, List<EfRepo.OrganizationRepository> efOrgRepos,
|
||||
SqlRepo.OrganizationUserRepository sqlOrgUserRepo, SqlRepo.UserRepository sqlUserRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrgRepo)
|
||||
{
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
var postEfUser = await efUserRepos[i].CreateAsync(user);
|
||||
var postEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
orgUser.UserId = postEfUser.Id;
|
||||
orgUser.OrganizationId = postEfOrg.Id;
|
||||
var postEfOrgUser = await sut.CreateAsync(orgUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEfOrgUser = await sut.GetByIdAsync(postEfOrgUser.Id);
|
||||
Assert.True(savedEfOrgUser != null);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
await sut.DeleteAsync(savedEfOrgUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
savedEfOrgUser = await sut.GetByIdAsync(savedEfOrgUser.Id);
|
||||
Assert.True(savedEfOrgUser == null);
|
||||
}
|
||||
|
||||
var postSqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
var postSqlOrg = await sqlOrgRepo.CreateAsync(org);
|
||||
|
||||
orgUser.UserId = postSqlUser.Id;
|
||||
orgUser.OrganizationId = postSqlOrg.Id;
|
||||
var postSqlOrgUser = await sqlOrgUserRepo.CreateAsync(orgUser);
|
||||
|
||||
var savedSqlOrgUser = await sqlOrgUserRepo.GetByIdAsync(postSqlOrgUser.Id);
|
||||
Assert.True(savedSqlOrgUser != null);
|
||||
|
||||
await sqlOrgUserRepo.DeleteAsync(postSqlOrgUser);
|
||||
savedSqlOrgUser = await sqlOrgUserRepo.GetByIdAsync(postSqlOrgUser.Id);
|
||||
Assert.True(savedSqlOrgUser == null);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
using Bit.Core.Repositories.EntityFramework;
|
||||
using Bit.Core.Test.AutoFixture;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.PolicyFixtures;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Xunit;
|
||||
using TableModel = Bit.Core.Models.Table;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class PolicyRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfPolicyAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
TableModel.Policy policy,
|
||||
TableModel.Organization organization,
|
||||
PolicyCompare equalityComparer,
|
||||
List<EfRepo.PolicyRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrganizationRepos,
|
||||
SqlRepo.PolicyRepository sqlPolicyRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo
|
||||
)
|
||||
{
|
||||
var savedPolicys = new List<TableModel.Policy>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efOrganization = await efOrganizationRepos[i].CreateAsync(organization);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
policy.OrganizationId = efOrganization.Id;
|
||||
var postEfPolicy = await sut.CreateAsync(policy);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedPolicy = await sut.GetByIdAsync(postEfPolicy.Id);
|
||||
savedPolicys.Add(savedPolicy);
|
||||
}
|
||||
|
||||
var sqlOrganization = await sqlOrganizationRepo.CreateAsync(organization);
|
||||
|
||||
policy.OrganizationId = sqlOrganization.Id;
|
||||
var sqlPolicy = await sqlPolicyRepo.CreateAsync(policy);
|
||||
var savedSqlPolicy = await sqlPolicyRepo.GetByIdAsync(sqlPolicy.Id);
|
||||
savedPolicys.Add(savedSqlPolicy);
|
||||
|
||||
var distinctItems = savedPolicys.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
using System.Collections.Generic;
|
||||
using Bit.Core.Models.Table;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.SendFixtures;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Xunit;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using System.Linq;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class SendRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfUserSendAutoData, EfOrganizationSendAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
Send send,
|
||||
User user,
|
||||
Organization org,
|
||||
SendCompare equalityComparer,
|
||||
List<EfRepo.SendRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos,
|
||||
SqlRepo.SendRepository sqlSendRepo,
|
||||
SqlRepo.UserRepository sqlUserRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrgRepo
|
||||
)
|
||||
{
|
||||
var savedSends = new List<Send>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
if (send.OrganizationId.HasValue)
|
||||
{
|
||||
var efOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
send.OrganizationId = efOrg.Id;
|
||||
}
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
send.UserId = efUser.Id;
|
||||
var postEfSend = await sut.CreateAsync(send);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedSend = await sut.GetByIdAsync(postEfSend.Id);
|
||||
savedSends.Add(savedSend);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
if (send.OrganizationId.HasValue)
|
||||
{
|
||||
var sqlOrg = await sqlOrgRepo.CreateAsync(org);
|
||||
send.OrganizationId = sqlOrg.Id;
|
||||
}
|
||||
|
||||
send.UserId = sqlUser.Id;
|
||||
var sqlSend = await sqlSendRepo.CreateAsync(send);
|
||||
var savedSqlSend = await sqlSendRepo.GetByIdAsync(sqlSend.Id);
|
||||
savedSends.Add(savedSqlSend);
|
||||
|
||||
var distinctItems = savedSends.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,233 @@
|
||||
using Bit.Core.Test.AutoFixture;
|
||||
using Bit.Core.Test.Helpers.Factories;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Bit.Core.Models.Table;
|
||||
using Xunit;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Bit.Core.Test.AutoFixture.SsoConfigFixtures;
|
||||
using System;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class SsoConfigRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfSsoConfigAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(SsoConfig ssoConfig, Organization org,
|
||||
SsoConfigCompare equalityComparer, List<EfRepo.SsoConfigRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.SsoConfigRepository sqlSsoConfigRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo)
|
||||
{
|
||||
var savedSsoConfigs = new List<SsoConfig>();
|
||||
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var savedEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
ssoConfig.OrganizationId = savedEfOrg.Id;
|
||||
var postEfSsoConfig = await sut.CreateAsync(ssoConfig);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEfSsoConfig = await sut.GetByIdAsync(ssoConfig.Id);
|
||||
Assert.True(savedEfSsoConfig != null);
|
||||
savedSsoConfigs.Add(savedEfSsoConfig);
|
||||
}
|
||||
|
||||
var sqlOrganization = await sqlOrganizationRepo.CreateAsync(org);
|
||||
ssoConfig.OrganizationId = sqlOrganization.Id;
|
||||
|
||||
var sqlSsoConfig = await sqlSsoConfigRepo.CreateAsync(ssoConfig);
|
||||
var savedSqlSsoConfig = await sqlSsoConfigRepo.GetByIdAsync(sqlSsoConfig.Id);
|
||||
Assert.True(savedSqlSsoConfig != null);
|
||||
savedSsoConfigs.Add(savedSqlSsoConfig);
|
||||
|
||||
var distinctItems = savedSsoConfigs.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfSsoConfigAutoData]
|
||||
public async void ReplaceAsync_Works_DataMatches(SsoConfig postSsoConfig, SsoConfig replaceSsoConfig,
|
||||
Organization org, SsoConfigCompare equalityComparer, List<EfRepo.SsoConfigRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.SsoConfigRepository sqlSsoConfigRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo)
|
||||
{
|
||||
var savedSsoConfigs = new List<SsoConfig>();
|
||||
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var savedEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
postSsoConfig.OrganizationId = replaceSsoConfig.OrganizationId = savedEfOrg.Id;
|
||||
var postEfSsoConfig = await sut.CreateAsync(postSsoConfig);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
replaceSsoConfig.Id = postEfSsoConfig.Id;
|
||||
savedSsoConfigs.Add(postEfSsoConfig);
|
||||
await sut.ReplaceAsync(replaceSsoConfig);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var replacedSsoConfig = await sut.GetByIdAsync(replaceSsoConfig.Id);
|
||||
Assert.True(replacedSsoConfig != null);
|
||||
savedSsoConfigs.Add(replacedSsoConfig);
|
||||
}
|
||||
|
||||
var sqlOrganization = await sqlOrganizationRepo.CreateAsync(org);
|
||||
postSsoConfig.OrganizationId = sqlOrganization.Id;
|
||||
|
||||
var postSqlSsoConfig = await sqlSsoConfigRepo.CreateAsync(postSsoConfig);
|
||||
replaceSsoConfig.Id = postSqlSsoConfig.Id;
|
||||
savedSsoConfigs.Add(postSqlSsoConfig);
|
||||
|
||||
await sqlSsoConfigRepo.ReplaceAsync(replaceSsoConfig);
|
||||
var replacedSqlSsoConfig = await sqlSsoConfigRepo.GetByIdAsync(replaceSsoConfig.Id);
|
||||
Assert.True(replacedSqlSsoConfig != null);
|
||||
savedSsoConfigs.Add(replacedSqlSsoConfig);
|
||||
|
||||
var distinctItems = savedSsoConfigs.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(2).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfSsoConfigAutoData]
|
||||
public async void DeleteAsync_Works_DataMatches(SsoConfig ssoConfig, Organization org,
|
||||
SsoConfigCompare equalityComparer, List<EfRepo.SsoConfigRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.SsoConfigRepository sqlSsoConfigRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo)
|
||||
{
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var savedEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
ssoConfig.OrganizationId = savedEfOrg.Id;
|
||||
var postEfSsoConfig = await sut.CreateAsync(ssoConfig);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEfSsoConfig = await sut.GetByIdAsync(postEfSsoConfig.Id);
|
||||
Assert.True(savedEfSsoConfig != null);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
await sut.DeleteAsync(savedEfSsoConfig);
|
||||
var deletedEfSsoConfig= await sut.GetByIdAsync(savedEfSsoConfig.Id);
|
||||
Assert.True(deletedEfSsoConfig == null);
|
||||
}
|
||||
|
||||
var sqlOrganization = await sqlOrganizationRepo.CreateAsync(org);
|
||||
ssoConfig.OrganizationId = sqlOrganization.Id;
|
||||
|
||||
var postSqlSsoConfig = await sqlSsoConfigRepo.CreateAsync(ssoConfig);
|
||||
var savedSqlSsoConfig = await sqlSsoConfigRepo.GetByIdAsync(postSqlSsoConfig.Id);
|
||||
Assert.True(savedSqlSsoConfig != null);
|
||||
|
||||
await sqlSsoConfigRepo.DeleteAsync(savedSqlSsoConfig);
|
||||
savedSqlSsoConfig = await sqlSsoConfigRepo.GetByIdAsync(postSqlSsoConfig.Id);
|
||||
Assert.True(savedSqlSsoConfig == null);
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfSsoConfigAutoData]
|
||||
public async void GetByOrganizationIdAsync_Works_DataMatches(SsoConfig ssoConfig, Organization org,
|
||||
SsoConfigCompare equalityComparer, List<EfRepo.SsoConfigRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.SsoConfigRepository sqlSsoConfigRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrgRepo)
|
||||
{
|
||||
var returnedList = new List<SsoConfig>();
|
||||
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var savedEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
ssoConfig.OrganizationId = savedEfOrg.Id;
|
||||
await sut.CreateAsync(ssoConfig);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEfUser = await sut.GetByOrganizationIdAsync(savedEfOrg.Id);
|
||||
Assert.True(savedEfUser != null);
|
||||
returnedList.Add(savedEfUser);
|
||||
}
|
||||
|
||||
var savedSqlOrg = await sqlOrgRepo.CreateAsync(org);
|
||||
ssoConfig.OrganizationId = savedSqlOrg.Id;
|
||||
|
||||
var postSqlSsoConfig = await sqlSsoConfigRepo.CreateAsync(ssoConfig);
|
||||
|
||||
var savedSqlSsoConfig = await sqlSsoConfigRepo.GetByOrganizationIdAsync(ssoConfig.OrganizationId);
|
||||
Assert.True(savedSqlSsoConfig != null);
|
||||
returnedList.Add(savedSqlSsoConfig);
|
||||
|
||||
var distinctItems = returnedList.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfSsoConfigAutoData]
|
||||
public async void GetByIdentifierAsync_Works_DataMatches(SsoConfig ssoConfig, Organization org,
|
||||
SsoConfigCompare equalityComparer, List<EfRepo.SsoConfigRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.SsoConfigRepository sqlSsoConfigRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrgRepo)
|
||||
{
|
||||
var returnedList = new List<SsoConfig>();
|
||||
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var savedEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
ssoConfig.OrganizationId = savedEfOrg.Id;
|
||||
await sut.CreateAsync(ssoConfig);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEfSsoConfig = await sut.GetByIdentifierAsync(org.Identifier);
|
||||
Assert.True(savedEfSsoConfig != null);
|
||||
returnedList.Add(savedEfSsoConfig);
|
||||
}
|
||||
|
||||
var savedSqlOrg = await sqlOrgRepo.CreateAsync(org);
|
||||
ssoConfig.OrganizationId = savedSqlOrg.Id;
|
||||
|
||||
var postSqlSsoConfig = await sqlSsoConfigRepo.CreateAsync(ssoConfig);
|
||||
|
||||
var savedSqlSsoConfig = await sqlSsoConfigRepo.GetByIdentifierAsync(org.Identifier);
|
||||
Assert.True(savedSqlSsoConfig != null);
|
||||
returnedList.Add(savedSqlSsoConfig);
|
||||
|
||||
var distinctItems = returnedList.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
// Testing that data matches here would involve manipulating all SsoConfig records in the db
|
||||
[CiSkippedTheory, EfSsoConfigAutoData]
|
||||
public async void GetManyByRevisionNotBeforeDate_Works(SsoConfig ssoConfig, DateTime notBeforeDate,
|
||||
Organization org, SsoConfigCompare equalityComparer, List<EfRepo.SsoConfigRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos)
|
||||
{
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var savedEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
ssoConfig.OrganizationId = savedEfOrg.Id;
|
||||
await sut.CreateAsync(ssoConfig);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var returnedEfSsoConfigs = await sut.GetManyByRevisionNotBeforeDate(notBeforeDate);
|
||||
Assert.True(returnedEfSsoConfigs.All(sc => sc.RevisionDate >= notBeforeDate));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,192 @@
|
||||
using Bit.Core.Test.AutoFixture;
|
||||
using Bit.Core.Test.Helpers.Factories;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Bit.Core.Models.Table;
|
||||
using Xunit;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Bit.Core.Test.AutoFixture.SsoUserFixtures;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class SsoUserRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfSsoUserAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(SsoUser ssoUser, User user, Organization org,
|
||||
SsoUserCompare equalityComparer, List<EfRepo.SsoUserRepository> suts,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos, List<EfRepo.UserRepository> efUserRepos,
|
||||
SqlRepo.SsoUserRepository sqlSsoUserRepo, SqlRepo.OrganizationRepository sqlOrgRepo,
|
||||
SqlRepo.UserRepository sqlUserRepo)
|
||||
{
|
||||
var createdSsoUsers = new List<SsoUser>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
var efOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
ssoUser.UserId = efUser.Id;
|
||||
ssoUser.OrganizationId = efOrg.Id;
|
||||
var postEfSsoUser = await sut.CreateAsync(ssoUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedSsoUser = await sut.GetByIdAsync(ssoUser.Id);
|
||||
createdSsoUsers.Add(savedSsoUser);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
var sqlOrganization = await sqlOrgRepo.CreateAsync(org);
|
||||
|
||||
ssoUser.UserId = sqlUser.Id;
|
||||
ssoUser.OrganizationId = sqlOrganization.Id;
|
||||
var sqlSsoUser = await sqlSsoUserRepo.CreateAsync(ssoUser);
|
||||
|
||||
createdSsoUsers.Add(await sqlSsoUserRepo.GetByIdAsync(sqlSsoUser.Id));
|
||||
|
||||
var distinctSsoUsers = createdSsoUsers.Distinct(equalityComparer);
|
||||
Assert.True(!distinctSsoUsers.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfSsoUserAutoData]
|
||||
public async void ReplaceAsync_Works_DataMatches(SsoUser postSsoUser, SsoUser replaceSsoUser,
|
||||
Organization org, User user, SsoUserCompare equalityComparer,
|
||||
List<EfRepo.SsoUserRepository> suts, List<EfRepo.UserRepository> efUserRepos,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos, SqlRepo.SsoUserRepository sqlSsoUserRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrgRepo, SqlRepo.UserRepository sqlUserRepo)
|
||||
{
|
||||
var savedSsoUsers = new List<SsoUser>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
var efOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
postSsoUser.UserId = efUser.Id;
|
||||
postSsoUser.OrganizationId = efOrg.Id;
|
||||
var postEfSsoUser = await sut.CreateAsync(postSsoUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
replaceSsoUser.Id = postEfSsoUser.Id;
|
||||
replaceSsoUser.UserId = postEfSsoUser.UserId;
|
||||
replaceSsoUser.OrganizationId = postEfSsoUser.OrganizationId;
|
||||
await sut.ReplaceAsync(replaceSsoUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var replacedSsoUser = await sut.GetByIdAsync(replaceSsoUser.Id);
|
||||
savedSsoUsers.Add(replacedSsoUser);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
var sqlOrganization = await sqlOrgRepo.CreateAsync(org);
|
||||
|
||||
postSsoUser.UserId = sqlUser.Id;
|
||||
postSsoUser.OrganizationId = sqlOrganization.Id;
|
||||
var postSqlSsoUser = await sqlSsoUserRepo.CreateAsync(postSsoUser);
|
||||
|
||||
replaceSsoUser.Id = postSqlSsoUser.Id;
|
||||
replaceSsoUser.UserId = postSqlSsoUser.UserId;
|
||||
replaceSsoUser.OrganizationId = postSqlSsoUser.OrganizationId;
|
||||
await sqlSsoUserRepo.ReplaceAsync(replaceSsoUser);
|
||||
|
||||
savedSsoUsers.Add(await sqlSsoUserRepo.GetByIdAsync(replaceSsoUser.Id));
|
||||
|
||||
var distinctItems = savedSsoUsers.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfSsoUserAutoData]
|
||||
public async void DeleteAsync_Works_DataMatches(SsoUser ssoUser, Organization org, User user,
|
||||
SsoUserCompare equalityComparer, List<EfRepo.SsoUserRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos, List<EfRepo.OrganizationRepository> efOrgRepos,
|
||||
SqlRepo.SsoUserRepository sqlSsoUserRepo, SqlRepo.UserRepository sqlUserRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrganizationRepo)
|
||||
{
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var savedEfUser = await efUserRepos[i].CreateAsync(user);
|
||||
var savedEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
ssoUser.UserId = savedEfUser.Id;
|
||||
ssoUser.OrganizationId = savedEfOrg.Id;
|
||||
var postEfSsoUser = await sut.CreateAsync(ssoUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEfSsoUser = await sut.GetByIdAsync(postEfSsoUser.Id);
|
||||
Assert.True(savedEfSsoUser != null);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
await sut.DeleteAsync(savedEfSsoUser);
|
||||
savedEfSsoUser = await sut.GetByIdAsync(savedEfSsoUser.Id);
|
||||
Assert.True(savedEfSsoUser == null);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
var sqlOrganization = await sqlOrganizationRepo.CreateAsync(org);
|
||||
ssoUser.UserId = sqlUser.Id;
|
||||
ssoUser.OrganizationId = sqlOrganization.Id;
|
||||
|
||||
var postSqlSsoUser = await sqlSsoUserRepo.CreateAsync(ssoUser);
|
||||
var savedSqlSsoUser = await sqlSsoUserRepo.GetByIdAsync(postSqlSsoUser.Id);
|
||||
Assert.True(savedSqlSsoUser != null);
|
||||
|
||||
await sqlSsoUserRepo.DeleteAsync(savedSqlSsoUser);
|
||||
savedSqlSsoUser = await sqlSsoUserRepo.GetByIdAsync(postSqlSsoUser.Id);
|
||||
Assert.True(savedSqlSsoUser == null);
|
||||
}
|
||||
|
||||
[CiSkippedTheory, EfSsoUserAutoData]
|
||||
public async void DeleteAsync_UserIdOrganizationId_Works_DataMatches(SsoUser ssoUser,
|
||||
User user, Organization org, SsoUserCompare equalityComparer, List<EfRepo.SsoUserRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos, List<EfRepo.OrganizationRepository> efOrgRepos,
|
||||
SqlRepo.SsoUserRepository sqlSsoUserRepo, SqlRepo.UserRepository sqlUserRepo, SqlRepo.OrganizationRepository sqlOrgRepo
|
||||
)
|
||||
{
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var savedEfUser = await efUserRepos[i].CreateAsync(user);
|
||||
var savedEfOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
ssoUser.UserId = savedEfUser.Id;
|
||||
ssoUser.OrganizationId = savedEfOrg.Id;
|
||||
var postEfSsoUser = await sut.CreateAsync(ssoUser);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedEfSsoUser = await sut.GetByIdAsync(postEfSsoUser.Id);
|
||||
Assert.True(savedEfSsoUser != null);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
await sut.DeleteAsync(savedEfSsoUser.UserId, savedEfSsoUser.OrganizationId);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
savedEfSsoUser = await sut.GetByIdAsync(savedEfSsoUser.Id);
|
||||
Assert.True(savedEfSsoUser == null);
|
||||
}
|
||||
|
||||
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 savedSqlSsoUser = await sqlSsoUserRepo.GetByIdAsync(postSqlSsoUser.Id);
|
||||
Assert.True(savedSqlSsoUser != null);
|
||||
|
||||
await sqlSsoUserRepo.DeleteAsync(savedSqlSsoUser.UserId, savedSqlSsoUser.OrganizationId);
|
||||
savedSqlSsoUser = await sqlSsoUserRepo.GetByIdAsync(postSqlSsoUser.Id);
|
||||
Assert.True(savedSqlSsoUser == null);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Bit.Core.Models.Table;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.TaxRateFixtures;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Xunit;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class TaxRateRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfTaxRateAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
TaxRate taxRate,
|
||||
TaxRateCompare equalityComparer,
|
||||
List<EfRepo.TaxRateRepository> suts,
|
||||
SqlRepo.TaxRateRepository sqlTaxRateRepo
|
||||
)
|
||||
{
|
||||
var savedTaxRates = new List<TaxRate>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
var postEfTaxRate = await sut.CreateAsync(taxRate);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedTaxRate = await sut.GetByIdAsync(postEfTaxRate.Id);
|
||||
savedTaxRates.Add(savedTaxRate);
|
||||
}
|
||||
|
||||
var sqlTaxRate = await sqlTaxRateRepo.CreateAsync(taxRate);
|
||||
var savedSqlTaxRate = await sqlTaxRateRepo.GetByIdAsync(sqlTaxRate.Id);
|
||||
savedTaxRates.Add(savedSqlTaxRate);
|
||||
|
||||
var distinctItems = savedTaxRates.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
using System.Collections.Generic;
|
||||
using Bit.Core.Models.Table;
|
||||
using Bit.Core.Repositories.EntityFramework;
|
||||
using Bit.Core.Test.AutoFixture;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.TransactionFixtures;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Xunit;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using System.Linq;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class TransactionRepositoryTests
|
||||
{
|
||||
|
||||
[CiSkippedTheory, EfUserTransactionAutoData, EfOrganizationTransactionAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
Transaction transaction,
|
||||
User user,
|
||||
Organization org,
|
||||
TransactionCompare equalityComparer,
|
||||
List<EfRepo.TransactionRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos,
|
||||
List<EfRepo.OrganizationRepository> efOrgRepos,
|
||||
SqlRepo.TransactionRepository sqlTransactionRepo,
|
||||
SqlRepo.UserRepository sqlUserRepo,
|
||||
SqlRepo.OrganizationRepository sqlOrgRepo
|
||||
)
|
||||
{
|
||||
var savedTransactions = new List<Transaction>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
if (transaction.OrganizationId.HasValue)
|
||||
{
|
||||
var efOrg = await efOrgRepos[i].CreateAsync(org);
|
||||
transaction.OrganizationId = efOrg.Id;
|
||||
}
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
transaction.UserId = efUser.Id;
|
||||
var postEfTransaction = await sut.CreateAsync(transaction);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedTransaction = await sut.GetByIdAsync(postEfTransaction.Id);
|
||||
savedTransactions.Add(savedTransaction);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
if (transaction.OrganizationId.HasValue)
|
||||
{
|
||||
var sqlOrg = await sqlOrgRepo.CreateAsync(org);
|
||||
transaction.OrganizationId = sqlOrg.Id;
|
||||
}
|
||||
|
||||
transaction.UserId = sqlUser.Id;
|
||||
var sqlTransaction = await sqlTransactionRepo.CreateAsync(transaction);
|
||||
var savedSqlTransaction = await sqlTransactionRepo.GetByIdAsync(sqlTransaction.Id);
|
||||
savedTransactions.Add(savedSqlTransaction);
|
||||
|
||||
var distinctItems = savedTransactions.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Bit.Core.Models.Table;
|
||||
using Bit.Core.Repositories.EntityFramework;
|
||||
using Bit.Core.Test.AutoFixture;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
using Bit.Core.Test.AutoFixture.U2fFixtures;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Xunit;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class U2fRepositoryTests
|
||||
{
|
||||
|
||||
[CiSkippedTheory, EfU2fAutoData]
|
||||
public async void CreateAsync_Works_DataMatches(
|
||||
U2f u2f,
|
||||
User user,
|
||||
U2fCompare equalityComparer,
|
||||
List<EfRepo.U2fRepository> suts,
|
||||
List<EfRepo.UserRepository> efUserRepos,
|
||||
SqlRepo.U2fRepository sqlU2fRepo,
|
||||
SqlRepo.UserRepository sqlUserRepo
|
||||
)
|
||||
{
|
||||
var savedU2fs = new List<U2f>();
|
||||
foreach (var sut in suts)
|
||||
{
|
||||
var i = suts.IndexOf(sut);
|
||||
|
||||
var efUser = await efUserRepos[i].CreateAsync(user);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
u2f.UserId = efUser.Id;
|
||||
var postEfU2f = await sut.CreateAsync(u2f);
|
||||
sut.ClearChangeTracking();
|
||||
|
||||
var savedU2f = await sut.GetByIdAsync(postEfU2f.Id);
|
||||
savedU2fs.Add(savedU2f);
|
||||
}
|
||||
|
||||
var sqlUser = await sqlUserRepo.CreateAsync(user);
|
||||
|
||||
u2f.UserId = sqlUser.Id;
|
||||
var sqlU2f = await sqlU2fRepo.CreateAsync(u2f);
|
||||
var savedSqlU2f = await sqlU2fRepo.GetByIdAsync(sqlU2f.Id);
|
||||
savedU2fs.Add(savedSqlU2f);
|
||||
|
||||
var distinctItems = savedU2fs.Distinct(equalityComparer);
|
||||
Assert.True(!distinctItems.Skip(1).Any());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,294 @@
|
||||
using Bit.Core.Test.AutoFixture.UserFixtures;
|
||||
using EfRepo = Bit.Core.Repositories.EntityFramework;
|
||||
using SqlRepo = Bit.Core.Repositories.SqlServer;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Bit.Core.Models.Table;
|
||||
using Xunit;
|
||||
using Bit.Core.Test.Repositories.EntityFramework.EqualityComparers;
|
||||
using Bit.Core.Models.Data;
|
||||
using System;
|
||||
using Bit.Core.Test.AutoFixture.Attributes;
|
||||
|
||||
namespace Bit.Core.Test.Repositories.EntityFramework
|
||||
{
|
||||
public class UserRepositoryTests
|
||||
{
|
||||
[CiSkippedTheory, EfUserAutoData]
|
||||
public async void 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 void 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 void DeleteAsync_Works_DataMatches(User user, UserCompare equalityComparer,
|
||||
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 void 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 void 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 void 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 void 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 void 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 void 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 void 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 void 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, SqlRepo.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());
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user