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());
}
public async Task InviteUser_CustomUserConfiguringAdmin_Throws(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider <OrganizationService> sutProvider)
{
invitor.Permissions = JsonSerializer.Serialize(new Permissions()
{
ManageUsers = true
},
new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
var organizationRepository = sutProvider.GetDependency <IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency <IOrganizationUserRepository>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
organizationUserRepository.GetManyByUserAsync(invitor.UserId.Value).Returns(new List <OrganizationUser> {
invitor
});
var exception = await Assert.ThrowsAsync <BadRequestException>(
() => sutProvider.Sut.InviteUserAsync(organization.Id, invitor.UserId, null, invite));
Assert.Contains("can not manage admins", exception.Message.ToLowerInvariant());
}
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());
}
public async Task InviteUser_NoEmails_Throws(Organization organization, OrganizationUser invitor,
OrganizationUserInvite invite, SutProvider <OrganizationService> sutProvider)
{
invite.Emails = null;
sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
await Assert.ThrowsAsync <NotFoundException>(
() => sutProvider.Sut.InviteUserAsync(organization.Id, invitor.UserId, null, invite));
}
public async Task UpgradePlan_Passes(Organization organization, OrganizationUpgrade upgrade,
SutProvider <OrganizationService> sutProvider)
{
sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
await sutProvider.Sut.UpgradePlanAsync(organization.Id, upgrade);
await sutProvider.GetDependency <IOrganizationRepository>().Received(1).ReplaceAsync(organization);
}
public async Task UpgradePlan_UpgradeFromPaidPlan_Throws(Organization organization, OrganizationUpgrade upgrade,
SutProvider <OrganizationService> sutProvider)
{
sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
var exception = await Assert.ThrowsAsync <BadRequestException>(
() => sutProvider.Sut.UpgradePlanAsync(organization.Id, upgrade));
Assert.Contains("can only upgrade", exception.Message);
}
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());
}
public async Task UpgradePlan_AlreadyInPlan_Throws(Organization organization, OrganizationUpgrade upgrade,
SutProvider <OrganizationService> sutProvider)
{
upgrade.Plan = organization.PlanType;
sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
var exception = await Assert.ThrowsAsync <BadRequestException>(
() => sutProvider.Sut.UpgradePlanAsync(organization.Id, upgrade));
Assert.Contains("already on this plan", exception.Message);
}
public async Task UpgradePlan_GatewayCustomIdIsNull_Throws(Organization organization, OrganizationUpgrade upgrade,
SutProvider <OrganizationService> sutProvider)
{
organization.GatewayCustomerId = string.Empty;
sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
var exception = await Assert.ThrowsAsync <BadRequestException>(
() => sutProvider.Sut.UpgradePlanAsync(organization.Id, upgrade));
Assert.Contains("no payment method", exception.Message);
}
public async void DeleteAsync_Works_DataMatches(TableModel.OrganizationSponsorship organizationSponsorship,
TableModel.Organization sponsoringOrg,
List <EfRepo.OrganizationRepository> efOrgRepos,
SqlRepo.OrganizationRepository sqlOrganizationRepo,
SqlRepo.OrganizationSponsorshipRepository sqlOrganizationSponsorshipRepo,
List <EfRepo.OrganizationSponsorshipRepository> suts)
{
organizationSponsorship.InstallationId = null;
organizationSponsorship.SponsoredOrganizationId = null;
foreach (var(sut, orgRepo) in suts.Zip(efOrgRepos))
{
var efSponsoringOrg = await orgRepo.CreateAsync(sponsoringOrg);
sut.ClearChangeTracking();
organizationSponsorship.SponsoringOrganizationId = efSponsoringOrg.Id;
var postEfOrganizationSponsorship = await sut.CreateAsync(organizationSponsorship);
sut.ClearChangeTracking();
var savedEfOrganizationSponsorship = await sut.GetByIdAsync(postEfOrganizationSponsorship.Id);
sut.ClearChangeTracking();
Assert.True(savedEfOrganizationSponsorship != null);
await sut.DeleteAsync(savedEfOrganizationSponsorship);
sut.ClearChangeTracking();
savedEfOrganizationSponsorship = await sut.GetByIdAsync(savedEfOrganizationSponsorship.Id);
Assert.True(savedEfOrganizationSponsorship == null);
}
var sqlSponsoringOrg = await sqlOrganizationRepo.CreateAsync(sponsoringOrg);
organizationSponsorship.SponsoringOrganizationId = sqlSponsoringOrg.Id;
var postSqlOrganizationSponsorship = await sqlOrganizationSponsorshipRepo.CreateAsync(organizationSponsorship);
var savedSqlOrganizationSponsorship = await sqlOrganizationSponsorshipRepo.GetByIdAsync(postSqlOrganizationSponsorship.Id);
Assert.True(savedSqlOrganizationSponsorship != null);
await sqlOrganizationSponsorshipRepo.DeleteAsync(postSqlOrganizationSponsorship);
savedSqlOrganizationSponsorship = await sqlOrganizationSponsorshipRepo.GetByIdAsync(postSqlOrganizationSponsorship.Id);
Assert.True(savedSqlOrganizationSponsorship == null);
}
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)));
}
public async Task InviteUser_NoPermissionsObject_Passes(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider <OrganizationService> sutProvider)
{
invite.Permissions = null;
var organizationRepository = sutProvider.GetDependency <IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency <IOrganizationUserRepository>();
var eventService = sutProvider.GetDependency <IEventService>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
organizationUserRepository.GetManyByUserAsync(invitor.UserId.Value).Returns(new List <OrganizationUser> {
invitor
});
await sutProvider.Sut.InviteUserAsync(organization.Id, invitor.UserId, null, invite);
}
public async Task InviteUser_NonAdminConfiguringAdmin_Throws(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider <OrganizationService> sutProvider)
{
var organizationRepository = sutProvider.GetDependency <IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency <IOrganizationUserRepository>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
organizationUserRepository.GetManyByUserAsync(invitor.Id).Returns(new List <OrganizationUser> {
invitor
});
var exception = await Assert.ThrowsAsync <BadRequestException>(
() => sutProvider.Sut.InviteUserAsync(organization.Id, invitor.UserId, null, invite));
Assert.Contains("only owners and admins", exception.Message.ToLowerInvariant());
}
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());
}
public async void CreateAsync_Works_DataMatches(
TableModel.OrganizationSponsorship organizationSponsorship, TableModel.Organization sponsoringOrg,
List <EfRepo.OrganizationRepository> efOrgRepos,
SqlRepo.OrganizationRepository sqlOrganizationRepo,
SqlRepo.OrganizationSponsorshipRepository sqlOrganizationSponsorshipRepo,
OrganizationSponsorshipCompare equalityComparer,
List <EfRepo.OrganizationSponsorshipRepository> suts)
{
organizationSponsorship.InstallationId = null;
organizationSponsorship.SponsoredOrganizationId = null;
var savedOrganizationSponsorships = new List <TableModel.OrganizationSponsorship>();
foreach (var(sut, orgRepo) in suts.Zip(efOrgRepos))
{
var efSponsoringOrg = await orgRepo.CreateAsync(sponsoringOrg);
sut.ClearChangeTracking();
organizationSponsorship.SponsoringOrganizationId = efSponsoringOrg.Id;
await sut.CreateAsync(organizationSponsorship);
sut.ClearChangeTracking();
var savedOrganizationSponsorship = await sut.GetByIdAsync(organizationSponsorship.Id);
savedOrganizationSponsorships.Add(savedOrganizationSponsorship);
}
var sqlSponsoringOrg = await sqlOrganizationRepo.CreateAsync(sponsoringOrg);
organizationSponsorship.SponsoringOrganizationId = sqlSponsoringOrg.Id;
var sqlOrganizationSponsorship = await sqlOrganizationSponsorshipRepo.CreateAsync(organizationSponsorship);
savedOrganizationSponsorships.Add(await sqlOrganizationSponsorshipRepo.GetByIdAsync(sqlOrganizationSponsorship.Id));
var distinctItems = savedOrganizationSponsorships.Distinct(equalityComparer);
Assert.True(!distinctItems.Skip(1).Any());
}
public async Task OrgImportCreateNewUsers(SutProvider <OrganizationService> sutProvider, Guid userId,
Organization org, List <OrganizationUserUserDetails> existingUsers, List <ImportedOrganizationUser> newUsers)
{
org.UseDirectory = true;
newUsers.Add(new ImportedOrganizationUser
{
Email = existingUsers.First().Email,
ExternalId = existingUsers.First().ExternalId
});
var expectedNewUsersCount = newUsers.Count - 1;
sutProvider.GetDependency <IOrganizationRepository>().GetByIdAsync(org.Id).Returns(org);
sutProvider.GetDependency <IOrganizationUserRepository>().GetManyDetailsByOrganizationAsync(org.Id)
.Returns(existingUsers);
sutProvider.GetDependency <IOrganizationUserRepository>().GetCountByOrganizationIdAsync(org.Id)
.Returns(existingUsers.Count);
await sutProvider.Sut.ImportAsync(org.Id, userId, null, newUsers, null, false);
await sutProvider.GetDependency <IOrganizationUserRepository>().DidNotReceiveWithAnyArgs()
.UpsertAsync(default);
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));
}
public async Task InviteUser_Passes(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider <OrganizationService> sutProvider)
{
invitor.Permissions = JsonSerializer.Serialize(new Permissions()
{
ManageUsers = true
},
new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
var organizationRepository = sutProvider.GetDependency <IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency <IOrganizationUserRepository>();
var eventService = sutProvider.GetDependency <IEventService>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
organizationUserRepository.GetManyByUserAsync(invitor.UserId.Value).Returns(new List <OrganizationUser> {
invitor
});
await sutProvider.Sut.InviteUserAsync(organization.Id, invitor.UserId, null, invite);
}
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);
}
[EfPolicyApplicableToUserInlineAutoData(OrganizationUserType.User, false, OrganizationUserStatusType.Invited, true, true, false)] // User not minStatus
public async void GetManyByTypeApplicableToUser_Works_DataMatches_Corre(
// Inline data
OrganizationUserType userType,
bool canManagePolicies,
OrganizationUserStatusType orgUserStatus,
bool policyEnabled,
bool policySameType,
bool isProvider,
// Auto data - models
TableModel.Policy policy,
TableModel.User user,
TableModel.Organization organization,
TableModel.OrganizationUser orgUser,
TableModel.Provider.Provider provider,
TableModel.Provider.ProviderOrganization providerOrganization,
TableModel.Provider.ProviderUser providerUser,
PolicyCompareIncludingOrganization equalityComparer,
// Auto data - EF repos
List <EfRepo.PolicyRepository> suts,
List <EfRepo.UserRepository> efUserRepository,
List <EfRepo.OrganizationRepository> efOrganizationRepository,
List <EfRepo.OrganizationUserRepository> efOrganizationUserRepository,
List <EfRepo.ProviderRepository> efProviderRepository,
List <EfRepo.ProviderOrganizationRepository> efProviderOrganizationRepository,
List <EfRepo.ProviderUserRepository> efProviderUserRepository,
// Auto data - SQL repos
SqlRepo.PolicyRepository sqlPolicyRepo,
SqlRepo.UserRepository sqlUserRepo,
SqlRepo.OrganizationRepository sqlOrganizationRepo,
SqlRepo.ProviderRepository sqlProviderRepo,
SqlRepo.OrganizationUserRepository sqlOrganizationUserRepo,
SqlRepo.ProviderOrganizationRepository sqlProviderOrganizationRepo,
SqlRepo.ProviderUserRepository sqlProviderUserRepo
)
{
// Combine EF and SQL repos into one list per type
var policyRepos = suts.ToList <IPolicyRepository>();
policyRepos.Add(sqlPolicyRepo);
var userRepos = efUserRepository.ToList <IUserRepository>();
userRepos.Add(sqlUserRepo);
var orgRepos = efOrganizationRepository.ToList <IOrganizationRepository>();
orgRepos.Add(sqlOrganizationRepo);
var orgUserRepos = efOrganizationUserRepository.ToList <IOrganizationUserRepository>();
orgUserRepos.Add(sqlOrganizationUserRepo);
var providerRepos = efProviderRepository.ToList <IProviderRepository>();
providerRepos.Add(sqlProviderRepo);
var providerOrgRepos = efProviderOrganizationRepository.ToList <IProviderOrganizationRepository>();
providerOrgRepos.Add(sqlProviderOrganizationRepo);
var providerUserRepos = efProviderUserRepository.ToList <IProviderUserRepository>();
providerUserRepos.Add(sqlProviderUserRepo);
// Arrange data
var savedPolicyType = PolicyType.SingleOrg;
var queriedPolicyType = policySameType ? savedPolicyType : PolicyType.DisableSend;
orgUser.Type = userType;
orgUser.Status = orgUserStatus;
var permissionsData = new Permissions {
ManagePolicies = canManagePolicies
};
orgUser.Permissions = JsonSerializer.Serialize(permissionsData, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
policy.Enabled = policyEnabled;
policy.Type = savedPolicyType;
var results = new List <TableModel.Policy>();
foreach (var policyRepo in policyRepos)
{
var i = policyRepos.IndexOf(policyRepo);
// Seed database
var savedUser = await userRepos[i].CreateAsync(user);
var savedOrg = await orgRepos[i].CreateAsync(organization);
orgUser.UserId = savedUser.Id;
orgUser.OrganizationId = savedOrg.Id;
await orgUserRepos[i].CreateAsync(orgUser);
if (isProvider)
{
var savedProvider = await providerRepos[i].CreateAsync(provider);
providerOrganization.OrganizationId = savedOrg.Id;
providerOrganization.ProviderId = savedProvider.Id;
await providerOrgRepos[i].CreateAsync(providerOrganization);
providerUser.UserId = savedUser.Id;
providerUser.ProviderId = savedProvider.Id;
await providerUserRepos[i].CreateAsync(providerUser);
}
policy.OrganizationId = savedOrg.Id;
await policyRepo.CreateAsync(policy);
if (suts.Contains(policyRepo))
{
(policyRepo as BaseEntityFrameworkRepository).ClearChangeTracking();
}
// Act
var result = await policyRepo.GetManyByTypeApplicableToUserIdAsync(savedUser.Id, queriedPolicyType, OrganizationUserStatusType.Accepted);
results.Add(result.FirstOrDefault());
}
// Assert
var distinctItems = results.Distinct(equalityComparer);
Assert.True(results.All(r => r == null) ||
!distinctItems.Skip(1).Any());
}
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);
}
public async Task OrgImportCreateNewUsersAndMarryExistingUser()
{
var orgRepo = Substitute.For <IOrganizationRepository>();
var orgUserRepo = Substitute.For <IOrganizationUserRepository>();
var collectionRepo = Substitute.For <ICollectionRepository>();
var userRepo = Substitute.For <IUserRepository>();
var groupRepo = Substitute.For <IGroupRepository>();
var dataProtector = Substitute.For <IDataProtector>();
var mailService = Substitute.For <IMailService>();
var pushNotService = Substitute.For <IPushNotificationService>();
var pushRegService = Substitute.For <IPushRegistrationService>();
var deviceRepo = Substitute.For <IDeviceRepository>();
var licenseService = Substitute.For <ILicensingService>();
var eventService = Substitute.For <IEventService>();
var installationRepo = Substitute.For <IInstallationRepository>();
var appCacheService = Substitute.For <IApplicationCacheService>();
var paymentService = Substitute.For <IPaymentService>();
var policyRepo = Substitute.For <IPolicyRepository>();
var ssoConfigRepo = Substitute.For <ISsoConfigRepository>();
var ssoUserRepo = Substitute.For <ISsoUserRepository>();
var referenceEventService = Substitute.For <IReferenceEventService>();
var globalSettings = Substitute.For <Settings.GlobalSettings>();
var taxRateRepo = Substitute.For <ITaxRateRepository>();
var orgService = new OrganizationService(orgRepo, orgUserRepo, collectionRepo, userRepo,
groupRepo, dataProtector, mailService, pushNotService, pushRegService, deviceRepo,
licenseService, eventService, installationRepo, appCacheService, paymentService, policyRepo,
ssoConfigRepo, ssoUserRepo, referenceEventService, globalSettings, taxRateRepo);
var id = Guid.NewGuid();
var userId = Guid.NewGuid();
var org = new Organization
{
Id = id,
Name = "Test Org",
UseDirectory = true,
UseGroups = true,
Seats = 3
};
orgRepo.GetByIdAsync(id).Returns(org);
var existingUserAId = Guid.NewGuid();
var existingUsers = new List <OrganizationUserUserDetails>();
existingUsers.Add(new OrganizationUserUserDetails
{
Id = existingUserAId,
// No external id here
Email = "*****@*****.**"
});
orgUserRepo.GetManyDetailsByOrganizationAsync(id).Returns(existingUsers);
orgUserRepo.GetCountByOrganizationIdAsync(id).Returns(1);
orgUserRepo.GetByIdAsync(existingUserAId).Returns(new OrganizationUser {
Id = existingUserAId
});
var newUsers = new List <ImportedOrganizationUser>();
newUsers.Add(new ImportedOrganizationUser {
Email = "*****@*****.**", ExternalId = "a"
});
newUsers.Add(new ImportedOrganizationUser {
Email = "*****@*****.**", ExternalId = "b"
});
newUsers.Add(new ImportedOrganizationUser {
Email = "*****@*****.**", ExternalId = "c"
});
await orgService.ImportAsync(id, userId, null, newUsers, null, false);
await orgUserRepo.Received(1).UpsertAsync(Arg.Any <OrganizationUser>());
await orgUserRepo.Received(2).CreateAsync(Arg.Any <OrganizationUser>());
}
