public async Task UserHasInvites_False()
{
var invite1 = new UserReleaseInvite
{
Email = "*****@*****.**",
ReleaseId = Guid.NewGuid(),
Role = Contributor,
};
var invite2 = new UserReleaseInvite
{
Email = "*****@*****.**",
ReleaseId = Guid.NewGuid(),
Role = Contributor,
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddRangeAsync(invite1, invite2);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var repository = new UserReleaseInviteRepository(contentDbContext);
var result = await repository.UserHasInvites(
ListOf(invite1.ReleaseId, invite2.ReleaseId, Guid.NewGuid()),
"*****@*****.**", Contributor);
Assert.False(result);
}
}
public async Task UserHasInvite_True()
{
var invite = new UserReleaseInvite
{
Email = "*****@*****.**",
ReleaseId = Guid.NewGuid(),
Role = Contributor,
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddAsync(invite);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var repository = new UserReleaseInviteRepository(contentDbContext);
var result = await repository.UserHasInvite(invite.ReleaseId, invite.Email, invite.Role);
Assert.True(result);
}
}
public async Task RemoveByPublication_NoPublication()
{
var invite = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = new Release(),
Role = Contributor,
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddAsync(invite);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var service = SetupReleaseInviteService(
contentDbContext: contentDbContext);
var result = await service.RemoveByPublication(
email : "*****@*****.**",
publicationId : Guid.NewGuid(),
releaseRole : Contributor);
result.AssertNotFound();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var userReleaseInvites = await contentDbContext.UserReleaseInvites
.AsQueryable()
.ToListAsync();
Assert.Single(userReleaseInvites);
Assert.Equal(invite.Email, userReleaseInvites[0].Email);
Assert.Equal(invite.ReleaseId, userReleaseInvites[0].ReleaseId);
Assert.Equal(invite.Role, userReleaseInvites[0].Role);
}
}
private async Task MarkInviteEmailAsSent(UserReleaseInvite invite)
{
invite.EmailSent = true;
_context.Update(invite);
await _context.SaveChangesAsync();
}
public async Task RemoveAllUserContributorPermissionForPublication()
{
var publication = new Publication();
var release1 = new Release
{
Publication = publication,
ReleaseName = "2000",
TimePeriodCoverage = TimeIdentifier.AcademicYear,
};
var release2Original = new Release
{
Publication = publication,
ReleaseName = "2001",
TimePeriodCoverage = TimeIdentifier.AcademicYear,
};
var release2Amendment = new Release
{
Publication = publication,
ReleaseName = "2001",
TimePeriodCoverage = TimeIdentifier.AcademicYear,
PreviousVersion = release2Original,
};
var user1 = new User
{
FirstName = "User1",
LastName = "One",
Email = "*****@*****.**",
};
var user1ReleaseRole1 = new UserReleaseRole
{
User = user1,
Release = release1,
Role = Contributor,
};
var user2 = new User
{
FirstName = "User2",
LastName = "Two",
Email = "*****@*****.**",
};
var user2ReleaseRole1 = new UserReleaseRole
{
User = user2,
Release = release2Amendment,
Role = Contributor,
};
var user2ReleaseRole2 = new UserReleaseRole
{
User = user2,
Release = release1,
Role = Contributor,
};
var user3 = new User
{
FirstName = "User3",
LastName = "Three",
Email = "*****@*****.**",
};
var user3ReleaseRole1 = new UserReleaseRole
{
User = user3,
Release = release2Amendment,
Role = Contributor,
};
var user1Release1Invite = new UserReleaseInvite
{
Email = user1.Email,
Release = release1,
Role = Contributor,
};
var user2Release2Invite = new UserReleaseInvite
{
Email = user2.Email,
Release = release2Original,
Role = Contributor,
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddRangeAsync(release1, release2Original, release2Amendment,
user1ReleaseRole1, user2ReleaseRole1, user2ReleaseRole2, user3ReleaseRole1,
user1Release1Invite, user2Release2Invite);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var service = SetupReleasePermissionService(contentDbContext);
var result =
await service.RemoveAllUserContributorPermissionsForPublication(publication.Id, user2.Id);
result.AssertRight();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var userReleaseRoles = await contentDbContext.UserReleaseRoles
.AsAsyncEnumerable()
.Where(urr => urr.Role == Contributor)
.ToListAsync();
Assert.Equal(2, userReleaseRoles.Count);
Assert.Equal(user1.Id, userReleaseRoles[0].UserId);
Assert.Equal(user3.Id, userReleaseRoles[1].UserId);
var userReleaseInvites = await contentDbContext.UserReleaseInvites
.ToAsyncEnumerable()
.ToListAsync();
Assert.Single(userReleaseInvites); // user1's invite remains
Assert.Equal(user1Release1Invite.Id, userReleaseInvites[0].Id);
}
}
public async Task ListReleaseContributorsInvites_AcceptedFalse()
{
var publication = new Publication();
var release1 = new Release
{
Publication = publication,
ReleaseName = "2000",
TimePeriodCoverage = TimeIdentifier.AcademicYear,
};
var release2Original = new Release
{
Publication = publication,
ReleaseName = "2001",
TimePeriodCoverage = TimeIdentifier.AcademicYear,
};
var release2Amendment = new Release
{
Publication = publication,
ReleaseName = "2001",
TimePeriodCoverage = TimeIdentifier.AcademicYear,
PreviousVersion = release2Original,
};
var user1ReleaseInvite = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Contributor,
Accepted = false,
};
var user2ReleaseInviteIgnored = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release2Amendment, // ignored because not release1
Role = Contributor,
Accepted = false,
};
var user3ReleaseInvite = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Contributor,
Accepted = false,
};
var user3ReleaseInviteIgnored = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Lead, // ignored because not a Contributor
Accepted = false,
};
var user5ReleaseInviteIgnored = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Contributor,
Accepted = true, // ignored because invite already accepted
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddRangeAsync(release1, release2Original, release2Amendment,
user1ReleaseInvite, user2ReleaseInviteIgnored, user3ReleaseInvite,
user3ReleaseInviteIgnored, user5ReleaseInviteIgnored);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var service = SetupReleasePermissionService(contentDbContext);
var result = await service.ListReleaseContributorInvites(release1.Id, false);
var viewModel = result.AssertRight();
Assert.Equal(2, viewModel.Count);
Assert.Equal("*****@*****.**", viewModel[0].Email);
Assert.Equal("*****@*****.**", viewModel[1].Email);
}
}
public async Task RemoveByPublication()
{
var release1 = new Release()
{
TimePeriodCoverage = TimeIdentifier.AcademicYear,
ReleaseName = "2000",
};
var release2 = new Release()
{
TimePeriodCoverage = TimeIdentifier.April,
ReleaseName = "2001",
};
var publication1 = new Publication
{
Title = "Publication title",
Releases = ListOf(release1, release2)
};
var release3 = new Release()
{
TimePeriodCoverage = TimeIdentifier.January,
ReleaseName = "2222",
};
var publication2 = new Publication
{
Title = "Ignored publication title",
Releases = ListOf(release3),
};
var invite1 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Contributor,
};
var invite2 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release2,
Role = Contributor,
};
var notRemoveInvite1 = new UserReleaseInvite
{
Email = "*****@*****.**", // different email
Release = release1,
Role = Contributor,
};
var notRemoveInvite2 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release3, // release under different publication
Role = Contributor,
};
var notRemoveInvite3 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Lead, // different role
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddRangeAsync(publication1, publication2, invite1, invite2,
notRemoveInvite1, notRemoveInvite2, notRemoveInvite3);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var service = SetupReleaseInviteService(
contentDbContext: contentDbContext);
var result = await service.RemoveByPublication(
email : "*****@*****.**",
publicationId : publication1.Id,
releaseRole : Contributor);
result.AssertRight();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var userReleaseInvites = await contentDbContext.UserReleaseInvites
.AsQueryable()
.ToListAsync();
Assert.Equal(3, userReleaseInvites.Count);
Assert.Equal("*****@*****.**", userReleaseInvites[0].Email);
Assert.Equal(release1.Id, userReleaseInvites[0].ReleaseId);
Assert.Equal(Contributor, userReleaseInvites[0].Role);
Assert.Equal("*****@*****.**", userReleaseInvites[1].Email);
Assert.Equal(release3.Id, userReleaseInvites[1].ReleaseId);
Assert.Equal(Contributor, userReleaseInvites[1].Role);
Assert.Equal("*****@*****.**", userReleaseInvites[2].Email);
Assert.Equal(release1.Id, userReleaseInvites[2].ReleaseId);
Assert.Equal(Lead, userReleaseInvites[2].Role);
}
}
public async Task InviteContributor_UserAlreadyHasReleaseRoleInvites()
{
var release1 = new Release()
{
TimePeriodCoverage = TimeIdentifier.AcademicYear,
ReleaseName = "2000",
};
var release2 = new Release()
{
TimePeriodCoverage = TimeIdentifier.AcademicYear,
ReleaseName = "2001",
};
var publication = new Publication
{
Title = "Publication title",
Releases = ListOf(release1, release2)
};
var userRelease1Invite = new UserReleaseInvite()
{
Email = "*****@*****.**",
Release = release1,
Role = Contributor,
Created = new DateTime(2000, 1, 1),
CreatedById = Guid.NewGuid(),
};
var userRelease2Invite = new UserReleaseInvite()
{
Email = "*****@*****.**",
Release = release2,
Role = Contributor,
Created = new DateTime(2001, 1, 1),
CreatedById = Guid.NewGuid(),
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddRangeAsync(publication, userRelease1Invite, userRelease2Invite);
await contentDbContext.SaveChangesAsync();
}
var usersAndRolesDbContextId = Guid.NewGuid().ToString();
await using (var usersAndRolesDbContext = InMemoryUserAndRolesDbContext(usersAndRolesDbContextId))
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var service = SetupReleaseInviteService(
contentDbContext: contentDbContext,
usersAndRolesDbContext: usersAndRolesDbContext);
var result = await service.InviteContributor(
email : "*****@*****.**",
publicationId : publication.Id,
releaseIds : ListOf(release1.Id, release2.Id));
result.AssertBadRequest(UserAlreadyHasReleaseRoleInvites);
}
await using (var usersAndRolesDbContext = InMemoryUserAndRolesDbContext(usersAndRolesDbContextId))
{
var userInvites = await usersAndRolesDbContext.UserInvites
.AsQueryable()
.ToListAsync();
Assert.Empty(userInvites);
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var userReleaseRoles = await contentDbContext.UserReleaseRoles
.AsQueryable()
.ToListAsync();
Assert.Empty(userReleaseRoles);
var userReleaseInvites = await contentDbContext.UserReleaseInvites
.AsQueryable()
.ToListAsync();
Assert.Equal(2, userReleaseInvites.Count);
Assert.Equal(userRelease1Invite.Id, userReleaseInvites[0].Id);
Assert.Equal(userRelease2Invite.Id, userReleaseInvites[1].Id);
}
}
public async Task CreateManyIfNotExists()
{
var createdById = Guid.NewGuid();
var releaseId1 = Guid.NewGuid();
var releaseId2 = Guid.NewGuid();
var existingReleaseInvite = new UserReleaseInvite
{
Email = "*****@*****.**",
ReleaseId = Guid.NewGuid(),
Role = Contributor,
EmailSent = true,
CreatedById = createdById,
Accepted = true,
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddAsync(existingReleaseInvite);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var repository = new UserReleaseInviteRepository(contentDbContext);
await repository.CreateManyIfNotExists(
releaseIds : ListOf(releaseId1, releaseId2,
existingReleaseInvite.ReleaseId),
email : "*****@*****.**",
releaseRole : Contributor,
emailSent : false,
createdById : createdById);
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var userReleaseInvites = await contentDbContext.UserReleaseInvites
.AsQueryable()
.ToListAsync();
Assert.Equal(3, userReleaseInvites.Count);
Assert.Equal(existingReleaseInvite.Id, userReleaseInvites[0].Id);
Assert.Equal(existingReleaseInvite.ReleaseId, userReleaseInvites[0].ReleaseId);
Assert.Equal("*****@*****.**", userReleaseInvites[0].Email);
Assert.Equal(Contributor, userReleaseInvites[0].Role);
Assert.True(userReleaseInvites[0].EmailSent);
Assert.InRange(DateTime.UtcNow.Subtract(userReleaseInvites[0].Created).Milliseconds, 0, 1500);
Assert.Equal(createdById, userReleaseInvites[0].CreatedById);
Assert.True(userReleaseInvites[0].Accepted);
Assert.Equal(releaseId1, userReleaseInvites[1].ReleaseId);
Assert.Equal("*****@*****.**", userReleaseInvites[1].Email);
Assert.Equal(Contributor, userReleaseInvites[1].Role);
Assert.False(userReleaseInvites[1].EmailSent);
Assert.InRange(DateTime.UtcNow.Subtract(userReleaseInvites[1].Created).Milliseconds, 0, 1500);
Assert.Equal(createdById, userReleaseInvites[1].CreatedById);
Assert.False(userReleaseInvites[1].Accepted);
Assert.Equal(releaseId2, userReleaseInvites[2].ReleaseId);
Assert.Equal("*****@*****.**", userReleaseInvites[2].Email);
Assert.Equal(Contributor, userReleaseInvites[2].Role);
Assert.False(userReleaseInvites[2].EmailSent);
Assert.InRange(DateTime.UtcNow.Subtract(userReleaseInvites[2].Created).Milliseconds, 0, 1500);
Assert.Equal(createdById, userReleaseInvites[2].CreatedById);
Assert.False(userReleaseInvites[2].Accepted);
}
}
public async Task RemoveByPublication()
{
var release1 = new Release();
var release2 = new Release();
var release3 = new Release();
var publication = new Publication
{
Releases = ListOf(release1, release3),
};
var invite1 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Contributor,
};
// not attached to publication
var invite2 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release2,
Role = Contributor,
};
var invite3 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release3,
Role = Contributor,
};
// not Contributor
var invite4 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Lead,
};
// different email address
var invite5 = new UserReleaseInvite
{
Email = "*****@*****.**",
Release = release1,
Role = Contributor,
};
var contentDbContextId = Guid.NewGuid().ToString();
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddRangeAsync(publication,
invite1, invite2, invite3, invite4, invite5);
await contentDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
var repository = new UserReleaseInviteRepository(contentDbContext);
await repository.RemoveByPublication(
publication, "*****@*****.**", Contributor);
var remainingInvites = await contentDbContext.UserReleaseInvites
.AsQueryable()
.ToListAsync();
Assert.Equal(3, remainingInvites.Count);
Assert.Equal(invite2.Id, remainingInvites[0].Id);
Assert.Equal(invite2.Email, remainingInvites[0].Email);
Assert.Equal(invite2.ReleaseId, remainingInvites[0].ReleaseId);
Assert.Equal(invite2.Role, remainingInvites[0].Role);
Assert.Equal(invite4.Id, remainingInvites[1].Id);
Assert.Equal(invite4.Email, remainingInvites[1].Email);
Assert.Equal(invite4.ReleaseId, remainingInvites[1].ReleaseId);
Assert.Equal(invite4.Role, remainingInvites[1].Role);
Assert.Equal(invite5.Id, remainingInvites[2].Id);
Assert.Equal(invite5.Email, remainingInvites[2].Email);
Assert.Equal(invite5.ReleaseId, remainingInvites[2].ReleaseId);
Assert.Equal(invite5.Role, remainingInvites[2].Role);
}
}
