public async Task CreateUserInviteListDuplicateInvite()
{
_userInviteRepositoryMock.SetupCreateItemQuery(o => new List <UserInvite> {
new UserInvite {
Id = Guid.NewGuid(), FirstName = "abc", LastName = "xyz", Email = "*****@*****.**"
}
});
_userRepositoryMock.SetupCreateItemQuery();
var createUserInviteRequest = new List <UserInvite> {
new UserInvite {
FirstName = "abc", LastName = "xyz", Email = "*****@*****.**"
}
};
var tenantId = Guid.NewGuid();
_tenantApiMock.Setup(m => m.GetTenantDomainsAsync(It.IsAny <Guid>()))
.ReturnsAsync(MicroserviceResponse.Create <IEnumerable <TenantDomain> >(HttpStatusCode.OK, new List <TenantDomain> {
new TenantDomain {
Domain = "yopmail.com"
}
}));
var userInvite = await _controller.CreateUserInviteListAsync(createUserInviteRequest, tenantId);
Assert.NotNull(userInvite);
Assert.Equal(InviteUserStatus.DuplicateUserEmail, userInvite.ElementAt(0).Status);
}
public async Task ChangeMachineTenantAsync_WhenInvalidSettingProfileId_ThrowsValidationFailedException()
{
var machineId = Guid.NewGuid();
_machineRepositoryMock.SetupCreateItemQuery(o => new List <Machine> {
new Machine {
Id = machineId
}
});
_tenantApiMock.Setup(m => m.GetTenantByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync((Guid tenantId) => MicroserviceResponse.Create(HttpStatusCode.OK, new Tenant {
Id = tenantId
}));
_cloudShimMock.Setup(m => m.ValidateSettingProfileId(It.IsAny <Guid>(), It.IsAny <Guid>()))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, false));
var request = new ChangeMachineTenantRequest
{
Id = machineId,
TenantId = Guid.NewGuid(),
SettingProfileId = Guid.NewGuid()
};
var ex = await Assert.ThrowsAsync <ValidationFailedException>(() => _controller.ChangeMachineTenantAsync(request, null));
Assert.Collection(ex.Errors, failure => Assert.Equal(nameof(ChangeMachineTenantRequest.SettingProfileId), failure.PropertyName));
}
public async Task ChangeMachineTenantAsync_WhenSuccessfulChange_ReturnsUpdatedMachine()
{
var machineId = Guid.NewGuid();
_machineRepositoryMock.SetupCreateItemQuery(o => new List <Machine> {
new Machine {
Id = machineId
}
});
_tenantApiMock.Setup(m => m.GetTenantByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, new Tenant()));
_cloudShimMock.Setup(m => m.ValidateSettingProfileId(It.IsAny <Guid>(), It.IsAny <Guid>()))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, true));
_machineRepositoryMock.Setup(m => m.UpdateItemAsync(It.IsAny <Guid>(), It.IsAny <Machine>(), It.IsAny <UpdateOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((Guid i, Machine m, UpdateOptions o, CancellationToken t) => m);
var request = new ChangeMachineTenantRequest
{
Id = machineId,
TenantId = Guid.NewGuid(),
SettingProfileId = Guid.NewGuid()
};
var result = await _controller.ChangeMachineTenantAsync(request, null, CancellationToken.None);
Assert.NotNull(result);
}
public async Task GetValidGuestInvitesByProjectIdThrowsNotFoundExceptionIfProjectIsNotFound()
{
_projectApiMock.Setup(x => x.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create <Project>(HttpStatusCode.NotFound, new ErrorResponse()));
await Assert.ThrowsAsync <NotFoundException>(() => _target.GetValidGuestInvitesByProjectIdAsync(Guid.NewGuid()));
}
public async Task CreateNewGuestInviteThrowsGetUserExceptionWhenGetUserFails()
{
_userApiMock.Setup(x => x.GetUserAsync(It.IsAny <Guid>()))
.ReturnsAsync(MicroserviceResponse.Create <User>(HttpStatusCode.NotFound, new ErrorResponse()));
await Assert.ThrowsAsync <GetUserException>(async() => await _target.CreateGuestInviteAsync(_defaultGuestInvite));
}
public async Task SetProjectGuestContext_WhenEvaluatingNonMemberUserCanEnterLobbyAndVerifyGuestReturnsSuccess_ReturnsCurrentProjectState()
{
_projectGuestContextServiceMock
.SetupSequence(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(default(ProjectGuestContext))
.ReturnsAsync(_defaultProjectGuestContext);
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
_guestSessionRepositoryMock
.Setup(x => x.GetItemAsync(It.Is <Guid>(g => g == _defaultGuestSession.Id), It.IsAny <QueryOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_defaultGuestSession);
var result = await _target.SetProjectGuestContextAsync(_defaultProjectId, null, _currentUserId, _projectTenantId, _defaultPrincipalId);
Assert.IsAssignableFrom <CurrentProjectState>(result);
Assert.IsAssignableFrom <GuestSession>(result.GuestSession);
Assert.False(result.UserHasAccess);
Assert.Equal(_defaultGuestSession.Id, result.GuestSession.Id);
Assert.Equal(_defaultAccessCode, result.GuestSession.ProjectAccessCode);
Assert.Equal(_defaultProjectId, result.GuestSession.ProjectId);
Assert.Equal(_currentUserId, result.GuestSession.UserId);
Assert.Equal(GuestState.InLobby, result.GuestSession.GuestSessionState);
Assert.Equal(_defaultProject, result.Project);
Assert.Equal(LobbyState.Normal, result.LobbyState);
}
public async Task SetProjectGuestContext_IfProjectCannotBeFetchedByServiceToServiceClientForGuest_ThrowsInvalidOperationException(HttpStatusCode statusCode)
{
_serviceToServiceProjectApiMock
.Setup(x => x.GetProjectByIdAsync(_defaultProjectId, null))
.ReturnsAsync(MicroserviceResponse.Create(statusCode, default(Project)));
await Assert.ThrowsAsync <InvalidOperationException>(() =>
_target.SetProjectGuestContextAsync(_defaultProjectId, null, _currentUserId, _noTenantId, _defaultPrincipalId));
}
public async Task SetProjectGuestContext_IfProjectMembershipCannotBeFetched_ThrowsInvalidOperationException(HttpStatusCode statusCode)
{
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(statusCode, default(IEnumerable <Guid>)));
await Assert.ThrowsAsync <InvalidOperationException>(() =>
_target.SetProjectGuestContextAsync(_defaultProjectId, null, _currentUserId, _noTenantId, _defaultPrincipalId));
}
public async Task CreateGuestInvite_SetsProjectTenantIdToTenantIdOfTheProject()
{
_projectApiMock.Setup(x => x.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, _defaultProject));
var tenantId = _defaultProject.TenantId;
var result = await _target.CreateGuestInviteAsync(_defaultGuestInvite);
Assert.Equal(result.ProjectTenantId, tenantId);
}
public async Task GetProjectLobbyStateAsync_IfProjectDoesNotExist_ThrowsNotFound()
{
_cacheMock
.Setup(m => m.TryItemGetAsync(It.IsAny <string>(), typeof(ProjectLobbyState), It.IsAny <Reference <ProjectLobbyState> >()))
.ReturnsAsync(false);
_projectApi
.Setup(m => m.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.NotFound, default(Project)));
await Assert.ThrowsAsync <NotFoundException>(() => _target.GetProjectLobbyStateAsync(Guid.NewGuid()));
}
public async Task CreateNewGuestInviteResetsAccessCodeIfCodeIsMissing()
{
var project = Project.Example();
project.GuestAccessCode = null;
_projectApiMock.Setup(x => x.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, project));
await _target.CreateGuestInviteAsync(_defaultGuestInvite);
_projectApiMock.Verify(x => x.ResetGuestAccessCodeAsync(It.IsAny <Guid>(), null));
}
public async Task CreateNewGuestInviteThrowsResetAccessCodeExceptionWhenResetAccessCodeFails()
{
var project = Project.Example();
project.GuestAccessCode = null;
_projectApiMock.Setup(x => x.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, project));
_projectApiMock.Setup(x => x.ResetGuestAccessCodeAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create <Project>(HttpStatusCode.NotFound, new ErrorResponse()));
await Assert.ThrowsAsync <ResetAccessCodeException>(async() => await _target.CreateGuestInviteAsync(_defaultGuestInvite));
}
public async Task SetProjectGuestContext_WhenUserIsNotFullProjectMemberAndRequestingLobbyEntry_UserHasAccessIsFalse()
{
_projectGuestContextServiceMock
.Setup(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(default(ProjectGuestContext));
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
var response = await _target.SetProjectGuestContextAsync(_defaultProjectId, "code", _currentUserId, Guid.NewGuid(), _defaultPrincipalId);
Assert.False(response.UserHasAccess);
}
public async Task SetProjectGuestContext_WhenEvaluatingNonMemberUserCanEnterLobby_CallsGetUser()
{
_projectGuestContextServiceMock
.Setup(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(default(ProjectGuestContext));
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
await _target.SetProjectGuestContextAsync(_defaultProjectId, null, _currentUserId, _projectTenantId, _defaultPrincipalId);
_userApiMock.Verify(x => x.GetUserAsync(It.Is <Guid>(id => id == _currentUserId)));
}
public async Task SetProjectGuestContext_WhenEvaluatingNonMemberUserCanEnterLobbyAndGetUserCallReturnsNotOK_ThrowsInvalidOperationException()
{
_projectGuestContextServiceMock
.Setup(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(default(ProjectGuestContext));
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
_userApiMock
.Setup(x => x.GetUserAsync(It.IsAny <Guid>()))
.Throws <InvalidOperationException>();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await _target.SetProjectGuestContextAsync(_defaultProjectId, null, _currentUserId, _projectTenantId, _defaultPrincipalId));
}
public async Task SetProjectGuestContext_WhenEvaluatingNonMemberUserCanEnterLobbyAndVerifyGuestReturnsSuccess_CachesProjectGuestContextRecord()
{
_projectGuestContextServiceMock
.Setup(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(default(ProjectGuestContext));
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
await _target.SetProjectGuestContextAsync(_defaultProjectId, null, _currentUserId, _projectTenantId, _defaultPrincipalId);
_projectGuestContextServiceMock
.Verify(x => x.SetProjectGuestContextAsync(It.Is <ProjectGuestContext>(props => props.GuestSessionId == _defaultGuestSession.Id &&
props.ProjectId == _defaultProjectId &&
props.TenantId == _defaultProject.TenantId &&
props.GuestState == Guest.ProjectContext.Enums.GuestState.InLobby), It.IsAny <string>()));
}
public async Task SetProjectGuestContext_WhenEvaluatingNonMemberUserCanEnterLobbyAndVerifyGuestResultIsNotSuccess_ThrowsInvalidOperationException(VerifyGuestResponseCode code)
{
_projectGuestContextServiceMock
.Setup(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(default(ProjectGuestContext));
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
_guestSessionControllerMock
.Setup(x => x.VerifyGuestAsync(It.IsAny <GuestVerificationRequest>(), It.IsAny <Project>(), _projectTenantId))
.ReturnsAsync(new GuestVerificationResponse()
{
ResultCode = code, Username = _defaultUser.Username
});
await Assert.ThrowsAsync <InvalidOperationException>(async() => await _target.SetProjectGuestContextAsync(_defaultProjectId, null, _currentUserId, _projectTenantId, _defaultPrincipalId));
}
public async Task SetProjectGuestContext_WhenEvaluatingNonMemberUserCanEnterLobby_CallsVerifyGuest()
{
_projectGuestContextServiceMock
.Setup(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(default(ProjectGuestContext));
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
await _target.SetProjectGuestContextAsync(_defaultProjectId, null, _currentUserId, _projectTenantId, _defaultPrincipalId);
_guestSessionControllerMock.Verify(x => x.VerifyGuestAsync(It.Is <GuestVerificationRequest>(props =>
props.ProjectAccessCode == null &&
props.ProjectId == _defaultProjectId &&
props.Username == _defaultUser.Username)
, It.Is <Project>(p => p == _defaultProject)
, It.Is <Guid>(t => t == _projectTenantId)));
}
public async Task GetGuestInvitesByProjectIdGetsInvitesForProject()
{
var inviteForProjectCount = 3;
var invites = MakeTestInviteList(_defaultProject.Id, "*****@*****.**", 0, inviteForProjectCount, 2, 2);
_projectApiMock.Setup(x => x.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, _defaultProject));
_guestInviteRepositoryMock.Setup(m => m.GetItemsAsync(It.IsAny <Expression <Func <GuestInvite, bool> > >(), It.IsAny <BatchOptions>(), It.IsAny <CancellationToken>()))
.Returns <Expression <Func <GuestInvite, bool> >, BatchOptions, CancellationToken>((predicate, o, c) =>
{
var expression = predicate.Compile();
IEnumerable <GuestInvite> sublist = invites.Where(expression).ToList();
return(Task.FromResult(sublist));
});
var response = await _target.GetValidGuestInvitesByProjectIdAsync(_defaultProject.Id);
Assert.Equal(inviteForProjectCount, response.Count());
}
public async Task SetProjectGuestContext_WhenNonMemberIsPermittedIntoLobby_IsGrantedGuestMembershipToProject()
{
_projectGuestContextServiceMock
.SetupSequence(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.Returns(Task.FromResult(default(ProjectGuestContext)))
.Returns(Task.FromResult(_defaultProjectGuestContext));
_guestSessionRepositoryMock
.Setup(x => x.GetItemAsync(It.IsAny <Guid>(), It.IsAny <QueryOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_defaultGuestSession);
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
await _target.SetProjectGuestContextAsync(_defaultProjectId, _defaultAccessCode, _currentUserId, null, _defaultPrincipalId);
_projectAccessApiMock
.Verify(x => x.GrantProjectMembershipAsync(It.IsAny <GrantProjectMembershipRequest>(), _defaultProjectTenantHeaders)); //_currentUserId, _defaultProjectId, _defaultProjectTenantHeaders));
}
private void SetupApisForRecalculate(HttpStatusCode projectStatusCode = HttpStatusCode.OK, bool participantRequestThrows = false, Project project = null)
{
if (participantRequestThrows)
{
var taskSource = new TaskCompletionSource <IEnumerable <Participant> >();
taskSource.SetException(new Exception("participants failed"));
_sessionServiceMock.Setup(m => m.GetParticipantsByGroupNameAsync(It.IsAny <string>(), It.IsAny <bool>(), false))
.Returns(taskSource.Task);
}
else
{
_sessionServiceMock.Setup(m => m.GetParticipantsByGroupNameAsync(It.IsAny <string>(), It.IsAny <bool>(), false))
.ReturnsAsync(default(IEnumerable <Participant>));
}
var projectPayload = projectStatusCode == HttpStatusCode.OK ? project ?? Project.Example() : default(Project);
_projectApi
.Setup(m => m.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(projectStatusCode, projectPayload));
}
public async Task SetProjectGuestContext_WhenNonMemberIsPermittedIntoLobbyAndGrantMembershipCallFails_ThrowsInvalidOperationException()
{
_projectGuestContextServiceMock
.SetupSequence(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.Returns(Task.FromResult(default(ProjectGuestContext)))
.Returns(Task.FromResult(_defaultProjectGuestContext));
_guestSessionRepositoryMock
.Setup(x => x.GetItemAsync(_defaultGuestSession.Id, It.IsAny <QueryOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_defaultGuestSession);
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
_projectAccessApiMock
.Setup(x => x.GrantProjectMembershipAsync(It.IsAny <GrantProjectMembershipRequest>(), _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.InternalServerError));
await Assert.ThrowsAsync <InvalidOperationException>(() => _target.SetProjectGuestContextAsync(_defaultProjectId, _defaultAccessCode, _currentUserId, null, _defaultPrincipalId));
}
public async Task GetValidGuestInvitesByProjectIdFiltersToReturnOneInvitePerEmail()
{
var firstEmailInvites = MakeTestInviteList(_defaultProject.Id, "*****@*****.**", 2, 0, 0, 0);
var secondEmailInvites = MakeTestInviteList(_defaultProject.Id, "*****@*****.**", 2, 0, 0, 0);
var thirdEmailInvites = MakeTestInviteList(_defaultProject.Id, "*****@*****.**", 2, 0, 0, 0);
_projectApiMock.Setup(x => x.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, _defaultProject));
_guestInviteRepositoryMock.Setup(m => m
.GetItemsAsync(It.IsAny <Expression <Func <GuestInvite, bool> > >(), It.IsAny <BatchOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(firstEmailInvites.Concat(secondEmailInvites.Concat(thirdEmailInvites)));
var result = await _target.GetValidGuestInvitesByProjectIdAsync(_defaultProject.Id);
var resultList = result.ToList();
Assert.Equal(3, resultList.Count);
Assert.Contains(resultList, invite => invite.GuestEmail == firstEmailInvites.First().GuestEmail);
Assert.Contains(resultList, invite => invite.GuestEmail == secondEmailInvites.First().GuestEmail);
Assert.Contains(resultList, invite => invite.GuestEmail == thirdEmailInvites.First().GuestEmail);
}
public async Task CreateUserInviteListInvalidEmailFormate()
{
_validatorLocatorMock.Setup(m => m.GetValidator(typeof(EmailValidator)))
.Returns(_validatorFailsMock.Object);
var createUserInviteRequest = new List <UserInvite> {
new UserInvite {
FirstName = "abc", LastName = "xyz", Email = "abc.com"
}
};
var tenantId = Guid.NewGuid();
_tenantApiMock.Setup(m => m.GetTenantDomainsAsync(It.IsAny <Guid>()))
.ReturnsAsync(MicroserviceResponse.Create <IEnumerable <TenantDomain> >(HttpStatusCode.OK, new List <TenantDomain> {
new TenantDomain {
Domain = "gmail.com"
}
}));
var userInvite = await _controller.CreateUserInviteListAsync(createUserInviteRequest, tenantId);
Assert.NotNull(userInvite);
Assert.Equal(InviteUserStatus.UserEmailFormatInvalid, userInvite.ElementAt(0).Status);
}
public async Task SetProjectGuestContext_IfUserHasDifferentTenantHasBeenAdmittedToProject_UserHasAccessIsTrue()
{
var guestSessionId = Guid.NewGuid();
_projectGuestContextServiceMock
.Setup(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(new ProjectGuestContext()
{
GuestSessionId = guestSessionId,
GuestState = Guest.ProjectContext.Enums.GuestState.InProject,
ProjectId = _defaultProjectId,
TenantId = _projectTenantId
});
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()).AsEnumerable()));
var guestSession = new GuestSession {
Id = guestSessionId, ProjectId = _defaultProjectId, UserId = _currentUserId, ProjectAccessCode = _defaultAccessCode, GuestSessionState = GuestState.InProject
};
_guestSessionRepositoryMock
.Setup(x => x.GetItemAsync(It.Is <Guid>(g => g == guestSessionId), It.IsAny <QueryOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(guestSession);
_guestSessionRepositoryMock
.Setup(x => x.GetItemsAsync(It.IsAny <Expression <Func <GuestSession, bool> > >(), It.IsAny <BatchOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <GuestSession> {
guestSession
});
var response = await _target.SetProjectGuestContextAsync(_defaultProjectId, "code", _currentUserId, Guid.NewGuid(), _defaultPrincipalId);
Assert.True(response.UserHasAccess);
}
public async Task RecalculateProjectLobbyStateAsync_ReturnsExpectedLobbyState(int fullMemberParticipantCount, int guestSessionCount, LobbyState lobbyState)
{
var project = Project.Example();
var projectId = project.Id;
var participants = new List <Participant>();
for (int i = 1; i <= fullMemberParticipantCount; i++)
{
var participant = Participant.Example();
ParticipantExtensions.SetProjectId(participant, project.Id);
participant.GuestSessionId = null;
participant.IsGuest = false;
participants.Add(participant);
}
_sessionServiceMock.Setup(m => m.GetParticipantsByGroupNameAsync(It.IsAny <string>(), It.IsAny <bool>(), false))
.ReturnsAsync(participants);
var guestSessions = new List <GuestSession>();
project.GuestAccessCode = Guid.NewGuid().ToString();
for (int i = 1; i <= guestSessionCount; i++)
{
var guestSession = GuestSession.Example();
guestSession.ProjectId = projectId;
guestSession.ProjectAccessCode = project.GuestAccessCode;
guestSession.GuestSessionState = GuestState.InProject;
guestSession.CreatedDateTime = DateTime.UtcNow;
guestSession.UserId = Guid.NewGuid();
guestSessions.Add(guestSession);
// Should never have more than one InProject sessions for same user and project,
// but need to test LINQ query with group by, where, and order by clauses,
// for correct calculation of current guest quantity.
var guestSession2 = CloneGuestSession(guestSession);
guestSession2.CreatedDateTime = DateTime.UtcNow.AddHours(-1.0);
guestSessions.Add(guestSession2);
var guestSession3 = CloneGuestSession(guestSession);
guestSession3.CreatedDateTime = DateTime.UtcNow.AddHours(-2.0);
guestSessions.Add(guestSession3);
}
_guestSessionRepositoryMock
.Setup(m => m.GetItemsAsync(It.IsAny <Expression <Func <GuestSession, bool> > >(), It.IsAny <BatchOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(guestSessions);
_projectApi
.Setup(m => m.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, project));
_cacheMock
.SetupSequence(m => m.ItemGetAsync(It.IsAny <List <string> >(), typeof(ProjectLobbyState)))
.ReturnsAsync(new List <ProjectLobbyState>()
{
default(ProjectLobbyState)
});
_cacheMock
.Setup(m => m.ItemSetAsync(It.IsAny <string>(), It.IsAny <ProjectLobbyState>(), It.IsAny <TimeSpan>(), It.IsAny <CacheCommandOptions>()))
.Returns(Task.FromResult(ProjectLobbyState.Example()));
var result = await _target.RecalculateProjectLobbyStateAsync(project.Id);
Assert.IsAssignableFrom <ProjectLobbyState>(result);
Assert.Equal(lobbyState, result.LobbyState);
}
public GuestInviteControllerTests()
{
var repositoryFactoryMock = new Mock <IRepositoryFactory>();
_guestInviteRepositoryMock = new Mock <IRepository <GuestInvite> >();
_defaultGuestInvite = new GuestInvite
{
Id = Guid.NewGuid(),
InvitedBy = Guid.NewGuid(),
ProjectId = Guid.NewGuid(),
CreatedDateTime = DateTime.UtcNow
};
_defaultProject = new Project
{
Id = Guid.NewGuid(),
GuestAccessCode = Guid.NewGuid().ToString(),
IsGuestModeEnabled = true
};
_userApiMock.Setup(x => x.GetUserAsync(It.IsAny <Guid>()))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, User.GuestUserExample()));
_projectApiMock.Setup(x => x.GetProjectByIdAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, Project.Example()));
_projectApiMock.Setup(x => x.ResetGuestAccessCodeAsync(It.IsAny <Guid>(), null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, Project.Example()));
_emailServiceMock.Setup(x => x.SendGuestInviteEmailAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK));
_guestInviteRepositoryMock
.Setup(x => x.GetItemAsync(It.IsAny <Guid>(), It.IsAny <BatchOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_defaultGuestInvite);
_guestInviteRepositoryMock
.Setup(x => x.CreateItemAsync(It.IsAny <GuestInvite>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((GuestInvite guestInvite, CancellationToken c) => guestInvite);
_guestInviteRepositoryMock
.Setup(x => x.UpdateItemAsync(_defaultGuestInvite.Id, It.IsAny <GuestInvite>(), It.IsAny <UpdateOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((Guid id, GuestInvite guestInvite, UpdateOptions o, CancellationToken c) => guestInvite);
repositoryFactoryMock
.Setup(x => x.CreateRepository <GuestInvite>())
.Returns(_guestInviteRepositoryMock.Object);
_validatorMock
.Setup(v => v.ValidateAsync(It.IsAny <object>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new ValidationResult());
_validatorMock
.Setup(v => v.Validate(It.IsAny <object>()))
.Returns(new ValidationResult());
_validatorLocator
.Setup(g => g.GetValidator(It.IsAny <Type>()))
.Returns(_validatorMock.Object);
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock
.Setup(x => x.Get(It.IsAny <LogTopic>()))
.Returns(new Mock <ILogger>().Object);
_target = new GuestInviteController(_userApiMock.Object, _projectApiMock.Object, _emailServiceMock.Object, repositoryFactoryMock.Object, _validatorLocator.Object, _eventServiceMock.Object, loggerFactoryMock.Object, _serializerMock.Object);
}
public ProjectGuestContextControllerTests()
{
_defaultProject = new Project()
{
Id = _defaultProjectId, TenantId = _projectTenantId, GuestAccessCode = _defaultAccessCode
};
_defaultPrincipalId = Guid.NewGuid();
_defaultProjectTenantHeaders = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>(HeaderKeys.Tenant, _defaultProject.TenantId.ToString())
};
_defaultUser = new User {
Id = _currentUserId, Username = "******"
};
var defaultProjectLobbyState = new ProjectLobbyState {
LobbyState = LobbyState.Normal, ProjectId = _defaultProjectId
};
_defaultGuestSession = new GuestSession {
Id = Guid.NewGuid(), ProjectId = _defaultProjectId, UserId = _currentUserId, ProjectAccessCode = _defaultAccessCode, GuestSessionState = GuestState.InLobby, SessionId = _defaultUserSessionId
};
_defaultProjectGuestContext = new ProjectGuestContext
{
GuestSessionId = _defaultGuestSession.Id,
GuestState = Guest.ProjectContext.Enums.GuestState.InLobby,
ProjectId = _defaultProjectId,
TenantId = _projectTenantId
};
var repositoryFactoryMock = new Mock <IRepositoryFactory>();
repositoryFactoryMock
.Setup(x => x.CreateRepository <GuestSession>())
.Returns(_guestSessionRepositoryMock.Object);
_projectGuestContextServiceMock
.Setup(x => x.GetProjectGuestContextAsync(It.IsAny <string>()))
.ReturnsAsync(_defaultProjectGuestContext);
_projectAccessApiMock
.Setup(x => x.GrantProjectMembershipAsync(It.IsAny <GrantProjectMembershipRequest>(), _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK));
_guestSessionControllerMock
.Setup(x => x.UpdateGuestSessionStateAsync(It.IsAny <UpdateGuestSessionStateRequest>(), It.IsAny <Guid>()))
.ReturnsAsync(new UpdateGuestSessionStateResponse());
_guestSessionControllerMock
.Setup(x => x.VerifyGuestAsync(It.IsAny <GuestVerificationRequest>(), It.IsAny <Project>(), It.IsAny <Guid?>()))
.ReturnsAsync(new GuestVerificationResponse()
{
ResultCode = VerifyGuestResponseCode.Success
});
_guestSessionControllerMock
.Setup(x => x.CreateGuestSessionAsync(It.IsAny <GuestSession>(), _defaultPrincipalId, It.IsAny <Guid>()))
.ReturnsAsync(_defaultGuestSession);
_userApiMock
.Setup(x => x.GetUserAsync(_currentUserId))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, _defaultUser));
_serviceToServiceProjectApiMock
.Setup(x => x.GetProjectByIdAsync(_defaultProjectId, null))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, _defaultProject));
_projectAccessApiMock
.Setup(x => x.GetProjectMemberUserIdsAsync(_defaultProjectId, MemberRoleFilter.FullUser, _defaultProjectTenantHeaders))
.ReturnsAsync(MicroserviceResponse.Create(HttpStatusCode.OK, (new List <Guid>()
{
_currentUserId
}).AsEnumerable()));
_projectLobbyStateControllerMock
.Setup(x => x.GetProjectLobbyStateAsync(_defaultProjectId))
.ReturnsAsync(defaultProjectLobbyState);
_target = new ProjectGuestContextController(repositoryFactoryMock.Object,
_guestSessionControllerMock.Object,
_projectLobbyStateControllerMock.Object,
_projectGuestContextServiceMock.Object,
_projectAccessApiMock.Object,
_serviceToServiceProjectApiMock.Object,
_userApiMock.Object);
}
