public async void UpdateDeveloperTest(Status expectedStatus)
{
var developerDto = new DeveloperUpdateDto
{
Id = Guid.NewGuid(),
Name = RandomHelper.RandomString(),
Login = RandomHelper.RandomString()
};
var developer = EntitiesFactory.NewDeveloper(id: developerDto.Id).Get();
_developerRepository.Setup(d => d.ExistAsync(developerDto.Id))
.ReturnsAsync(expectedStatus != Status.NotFund);
_developerRepository.Setup(d => d.GetByIdAsync(developerDto.Id))
.ReturnsAsync(developer);
_developerRepository.Setup(d => d.ExistByLoginAsync(developerDto.Login, developerDto.Id))
.ReturnsAsync(expectedStatus == Status.Conflict);
var service = new DeveloperService(_developerRepository.Object, _workRepository.Object, _mockyRepository.Object);
var result = await service.UpdateDeveloperAsync(developerDto);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == Status.Success)
{
_developerRepository.Verify(d => d.UpdateAsync(developer), Times.Once);
Assert.Equal(developerDto.Name, developer.Name);
Assert.Equal(developerDto.Login, developer.Login);
}
else
{
_developerRepository.Verify(d => d.UpdateAsync(developer), Times.Never);
}
}
public async void LoginDeveloper(bool equalPassword)
{
var loginDto = new LoginDto {
Login = RandomHelper.RandomString(),
Password = RandomHelper.RandomNumbers()
};
var developer = EntitiesFactory.NewDeveloper(
login: loginDto.Login,
password: equalPassword ? loginDto.Password : null
).Save();
var(status, result) = await Request.PostAsync <ResultTest <TokenDto> >(Uri, loginDto);
Assert.Equal(equalPassword ? Status.Success : Status.Unauthorized, status);
if (equalPassword)
{
var loginResult = result.Data;
Assert.Equal(developer.Id, loginResult.Id);
Assert.Equal(developer.Login, loginResult.Login);
Assert.Equal(TimeSpan.FromMinutes(5), loginResult.ExpiresAt - loginResult.CreatedAt);
Assert.NotEmpty(loginResult.Token);
var jwt = new JwtSecurityToken(loginResult.Token);
Assert.NotEmpty(jwt.Claims);
}
}
private string GenerateToken()
{
SessionDeveloper = EntitiesFactory.NewDeveloper().Save();
var authService = _services.GetService <IAuthService>();
return(authService.GenerateJwtTokenAsync(SessionDeveloper).Result.Token);
}
public async void UpdateProjectTest()
{
var developer = EntitiesFactory.NewDeveloper().Save();
var project = EntitiesFactory.NewProject().Save();
var projectDto = new ProjectUpdateDto
{
Id = project.Id,
Title = RandomHelper.RandomString(),
Description = RandomHelper.RandomString(490),
DeveloperIds = new[] { developer.Id }
};
var(status, result) = await Request.PutAsync <ResultTest>(new Uri($"{Uri}/{project.Id}"), projectDto);
var projectDb = await DbContext.Projects
.Include(p => p.DeveloperProjects)
.SingleAsync(p => p.Id == projectDto.Id);
await DbContext.Entry(projectDb).ReloadAsync();
Assert.Equal(Status.Success, status);
Assert.True(result.Success);
Assert.Equal(projectDto.Title, projectDb.Title);
Assert.Equal(projectDto.Description, projectDb.Description);
Assert.Single(projectDb.DeveloperProjects);
Assert.Contains(projectDb.DeveloperProjects, d => d.DeveloperId == developer.Id);
}
public async void DeleteWorkTest(
Status expectedStatus
)
{
var developer = EntitiesFactory.NewDeveloper().Save();
var project = EntitiesFactory.NewProject(developerIds: new[] { developer.Id }).Save();
var work = EntitiesFactory.NewWork(Guid.NewGuid(), project.DeveloperProjects.Single().Id).Get();
_workRepository.Setup(d => d.ExistAsync(work.Id))
.ReturnsAsync(expectedStatus != Status.NotFund);
_workRepository.Setup(d => d.GetByIdAsync(work.Id))
.ReturnsAsync(work);
_mockyRepository.Setup(m => m.SendNotificationAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new Result <bool>(expectedStatus != Status.Error));
var service = new WorkService(
_workRepository.Object,
_developerRepository.Object,
_projectRepository.Object,
_mockyRepository.Object
);
var result = await service.DeleteWorkAsync(work.Id);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == Status.Success)
{
_workRepository.Verify(d => d.DeleteAsync(work), Times.Once);
_mockyRepository.Verify(d => d.SendNotificationAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
}
public async void DeveloperRankingAsync()
{
var projectsToRemove = DbContext.Projects.ToArray();
var developersToRemove = DbContext.Developers.Where(d => d.Id != SessionDeveloper.Id).ToArray();
DbContext.Developers.RemoveRange(developersToRemove);
DbContext.Projects.RemoveRange(projectsToRemove);
var developerFirstPosition = EntitiesFactory.NewDeveloper().Save();
var developerSecondPosition = EntitiesFactory.NewDeveloper().Save();
var project = EntitiesFactory.NewProject(
developerIds: new[] { developerFirstPosition.Id, developerSecondPosition.Id }
).Save();
var query = new DeveloperRankingSearchDto {
ProjectId = project.Id, StartTime = default
};
EntitiesFactory.NewWork(
hours: 10,
id: Guid.NewGuid(),
developerProjectId: project.DeveloperProjects
.First(dp => dp.DeveloperId == developerFirstPosition.Id).Id
).Save();
EntitiesFactory.NewWork(
hours: 20,
id: Guid.NewGuid(),
developerProjectId: project.DeveloperProjects
.First(dp => dp.DeveloperId == developerFirstPosition.Id).Id
).Save();
EntitiesFactory.NewWork(
hours: 12,
id: Guid.NewGuid(),
developerProjectId: project.DeveloperProjects
.First(dp => dp.DeveloperId == developerSecondPosition.Id).Id
).Save();
var(status, result) = await Request.GetAsync <ResultTest <IEnumerable <DeveloperRankingListDto> > >(new Uri($"{Uri}/ranking"), query);
var developerList = result.Data;
Assert.Equal(Status.Success, status);
Assert.NotEmpty(developerList);
Assert.Equal(3, developerList.Count());
Assert.Equal(3, result.TotalRows);
var firstPosition = developerList.ElementAt(0);
Assert.Equal(developerFirstPosition.Id, firstPosition.Id);
Assert.Equal(developerFirstPosition.Name, firstPosition.Name);
Assert.Equal(15, firstPosition.AvgHours);
Assert.Equal(30, firstPosition.SumHours);
var secondPosition = developerList.ElementAt(1);
Assert.Equal(developerSecondPosition.Id, secondPosition.Id);
Assert.Equal(developerSecondPosition.Name, secondPosition.Name);
Assert.Equal(12, secondPosition.AvgHours);
Assert.Equal(12, secondPosition.SumHours);
}
public void ValidatePasswordTest(string source, string target)
{
var developer = EntitiesFactory.NewDeveloper(password: source).Get();
var expectedValid = source.Equals(target);
var valid = developer.ValidatePassword(target);
Assert.Equal(expectedValid, valid);
}
public void HashingPasswordTest()
{
var password = "******";
var expectedHash = MD5Crypto.Encode(password);
var developer = EntitiesFactory.NewDeveloper(password: password).Get();
Assert.Equal(expectedHash, developer.PasswordHash);
Assert.NotEqual(password, developer.PasswordHash);
}
public async void DeleteDeveloperAsync()
{
var developer = EntitiesFactory.NewDeveloper().Save();
var(status, result) = await Request.DeleteAsync <ResultTest>(new Uri($"{Uri}/{developer.Id}"));
var existDeveloper = await DbContext.Developers.AnyAsync(d => d.Id == developer.Id);
Assert.Equal(Status.Success, status);
Assert.True(result.Success);
Assert.False(existDeveloper);
}
public async void CreateWorkTest(
Status expectedStatus,
DateTime startTime,
DateTime endTime,
bool withProject = false,
bool withDeveloper = false
)
{
var developer = EntitiesFactory.NewDeveloper().Get();
var project = EntitiesFactory.NewProject(developerIds: new[] { developer.Id }).Save();
var workDto = new WorkCreateDto
{
DeveloperId = developer.Id,
ProjectId = project.Id,
StartTime = startTime,
EndTime = endTime,
Comment = RandomHelper.RandomString(180),
Hours = 10
};
var worksPersisted = new List <Work>();
_projectRepository.Setup(p => p.ExistAsync(project.Id)).ReturnsAsync(withProject);
_projectRepository.Setup(p => p.GetDeveloperProjectIdAsync(project.Id, developer.Id))
.ReturnsAsync(project.DeveloperProjects.Single().Id);
_projectRepository.Setup(p => p.ExistDeveloperVinculatedAsync(project.Id, developer.Id))
.ReturnsAsync(expectedStatus != Status.NotAllowed);
_developerRepository.Setup(p => p.ExistAsync(developer.Id)).ReturnsAsync(withDeveloper);
_workRepository.Setup(d => d.CreateAsync(Capture.In(worksPersisted)));
_mockyRepository.Setup(m => m.SendNotificationAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new Result <bool>(expectedStatus != Status.Error));
var service = new WorkService(
_workRepository.Object,
_developerRepository.Object,
_projectRepository.Object,
_mockyRepository.Object
);
var result = await service.CreateWorkAsync(workDto);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == Status.Success)
{
_workRepository.Verify(d => d.CreateAsync(It.IsAny <Work>()), Times.Once);
_mockyRepository.Verify(d => d.SendNotificationAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
var work = worksPersisted.Single();
Assert.Equal(workDto.Comment, work.Comment);
Assert.Equal(workDto.StartTime, work.StartTime);
Assert.Equal(workDto.EndTime, work.EndTime);
Assert.Equal(workDto.Hours, work.Hours);
}
}
public async void GetDeveloperByIdTest()
{
var developer = EntitiesFactory.NewDeveloper().Save();
var(status, result) = await Request.GetAsync <ResultTest <DeveloperDetailDto> >(new Uri($"{Uri}/{developer.Id}"));
var developerResult = result.Data;
Assert.Equal(Status.Success, status);
Assert.Equal(developer.Id, developerResult.Id);
Assert.Equal(developer.Name, developerResult.Name);
Assert.Equal(developer.Login, developerResult.Login);
Assert.Equal(developer.CPF, developerResult.CPF);
}
public async void UpdateWorkTest(
Status expectedStatus,
DateTime startTime,
DateTime endTime
)
{
var developer = EntitiesFactory.NewDeveloper().Save();
var project = EntitiesFactory.NewProject(developerIds: new[] { developer.Id }).Save();
var work = EntitiesFactory.NewWork(
id: Guid.NewGuid(),
developerProjectId: project.DeveloperProjects.Single().Id
).Get();
var workDto = new WorkUpdateDto
{
Id = work.Id,
StartTime = startTime,
EndTime = endTime,
Comment = RandomHelper.RandomString(180),
Hours = 250
};
_workRepository.Setup(d => d.ExistAsync(workDto.Id))
.ReturnsAsync(expectedStatus != Status.NotFund);
_workRepository.Setup(d => d.GetByIdAsync(workDto.Id))
.ReturnsAsync(work);
_mockyRepository.Setup(m => m.SendNotificationAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new Result <bool>(expectedStatus != Status.Error));
var service = new WorkService(
_workRepository.Object,
_developerRepository.Object,
_projectRepository.Object,
_mockyRepository.Object
);
var result = await service.UpdateWorkAsync(workDto);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == Status.Success)
{
_workRepository.Verify(d => d.UpdateAsync(work), Times.Once);
_mockyRepository.Verify(d => d.SendNotificationAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
Assert.Equal(workDto.Comment, work.Comment);
Assert.Equal(workDto.StartTime, work.StartTime);
Assert.Equal(workDto.EndTime, work.EndTime);
Assert.Equal(workDto.Hours, work.Hours);
}
}
public async void ListDevelopersTest()
{
EntitiesFactory.NewDeveloper().Save();
EntitiesFactory.NewDeveloper().Save();
var query = new PaginationDto {
Page = 1, Limit = 1
};
var expectedTotal = await DbContext.Developers.CountAsync();
var(status, result) = await Request.GetAsync <ResultTest <IEnumerable <DeveloperListDto> > >(Uri, query);
var developerList = result.Data;
Assert.Equal(Status.Success, status);
Assert.NotEmpty(developerList);
Assert.Equal(expectedTotal, result.TotalRows);
Assert.True(developerList.Count() == query.Limit);
}
public async void GetProjectByIdTest()
{
var developer = EntitiesFactory.NewDeveloper().Save();
var project = EntitiesFactory.NewProject(developerIds: new [] { developer.Id }).Save();
var(status, result) = await Request.GetAsync <ResultTest <ProjectDetailDto> >(new Uri($"{Uri}/{project.Id}"));
var projectResult = result.Data;
Assert.Equal(Status.Success, status);
Assert.Equal(project.Id, projectResult.Id);
Assert.Equal(project.Title, projectResult.Title);
Assert.Equal(project.Description, projectResult.Description);
var developerModel = projectResult.Developers.Single();
Assert.Equal(developer.Id, developerModel.Id);
Assert.Equal(developer.Name, developerModel.Name);
}
public async void LoginDeveloperTest(
Status expectedStatus,
bool persistedDeveloper = false,
bool equalPassword = false
)
{
var loginDto = new LoginDto {
Login = RandomHelper.RandomString(),
Password = RandomHelper.RandomNumbers()
};
var developer = EntitiesFactory.NewDeveloper(
login: loginDto.Login,
password: equalPassword ? loginDto.Password : null
).Get();
if (persistedDeveloper)
{
_developerRepository.Setup(d => d.ExistByLoginAsync(developer.Login, default)).ReturnsAsync(true);
_developerRepository.Setup(d => d.FindByLoginAsync(developer.Login)).ReturnsAsync(developer);
}
var service = new AuthService(_developerRepository.Object, _tokenConfiguration);
var result = await service.LoginAsync(loginDto);
var data = result.Data;
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == Status.Success)
{
Assert.Equal(developer.Id, data.Id);
Assert.Equal(developer.Login, data.Login);
Assert.Equal(TimeSpan.FromSeconds(_tokenConfiguration.Seconds), data.ExpiresAt - data.CreatedAt);
Assert.NotEmpty(data.Token);
var jwt = new JwtSecurityToken(data.Token);
Assert.NotEmpty(jwt.Claims);
}
else
{
Assert.Null(data?.Token);
}
}
public async void UpdateDeveloperTest()
{
var developer = EntitiesFactory.NewDeveloper().Save();
var developerDto = new DeveloperUpdateDto
{
Id = developer.Id,
Login = RandomHelper.RandomString(),
Name = RandomHelper.RandomString()
};
var(status, result) = await Request.PutAsync <ResultTest>(new Uri($"{Uri}/{developer.Id}"), developerDto);
var developerDb = await DbContext.Developers.FindAsync(developerDto.Id);
await DbContext.Entry(developerDb).ReloadAsync();
Assert.Equal(Status.Success, status);
Assert.True(result.Success);
Assert.Equal(developerDto.Login, developerDb.Login);
Assert.Equal(developerDto.Name, developerDb.Name);
}
public async void DeleteDeveloperTest(Status expectedStatus)
{
var developer = EntitiesFactory.NewDeveloper().Get();
_developerRepository.Setup(d => d.ExistAsync(developer.Id))
.ReturnsAsync(expectedStatus != Status.NotFund);
_developerRepository.Setup(d => d.GetByIdAsync(developer.Id))
.ReturnsAsync(developer);
var service = new DeveloperService(_developerRepository.Object, _workRepository.Object, _mockyRepository.Object);
var result = await service.DeleteDeveloperAsync(developer.Id);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == Status.Success)
{
_developerRepository.Verify(d => d.DeleteAsync(developer), Times.Once);
}
else
{
_developerRepository.Verify(d => d.DeleteAsync(developer), Times.Never);
}
}
