public async Task WhenAddingApplicationThenUnitOfWorkIsCommitted()
{
// Arrange
IApplicationRepository fakeApplicationRepository = A.Fake <IApplicationRepository>();
A.CallTo(() => fakeApplicationRepository.TryGetByDisplayNameAsync(A <string> .Ignored)).Returns(Task.FromResult <ApplicationEntity>(null));
IUnitOfWork fakeUnitOfWork = A.Fake <IUnitOfWork>();
IPasswordWithSaltHasher fakePasswordHasher = A.Fake <IPasswordWithSaltHasher>();
A.CallTo(() => fakePasswordHasher.HashPassword(A <string> .Ignored)).Returns(new HashWithSaltResult());
IApplicationService applicationService = new ApplicationService(fakeApplicationRepository, fakeUnitOfWork, fakePasswordHasher);
ApplicationCreateDto applicationCreateDto = new ApplicationCreateDto()
{
DisplayName = "TestApplicationDisplayName",
Password = "******"
};
// Act
await applicationService.AddApplicationAsync(applicationCreateDto);
// Assert
A.CallTo(() => fakeUnitOfWork.CommitAsync()).MustHaveHappened();
}
public async Task <int> AddApplicationAsync(ApplicationCreateDto applicationCreateDto)
{
if (applicationCreateDto == null ||
string.IsNullOrWhiteSpace(applicationCreateDto.DisplayName) ||
string.IsNullOrWhiteSpace(applicationCreateDto.Password))
{
throw new ArgumentException("Application name and password must be provided.");
}
if (await _applicationRepository.TryGetByDisplayNameAsync(applicationCreateDto.DisplayName) != null)
{
throw new ArgumentException($"Application with DisplayName {applicationCreateDto.DisplayName} already exists.");
}
ApplicationEntity application = applicationCreateDto.ToApplication();
HashWithSaltResult hashWithSaltResultDto = _passwordWithSaltHasher.HashPassword(applicationCreateDto.Password);
application.PasswordHash = hashWithSaltResultDto.Hash;
application.PasswordSalt = hashWithSaltResultDto.Salt;
_applicationRepository.Add(application);
await _unitOfWork.CommitAsync();
return(application.Id);
}
public void WhenAddingExistingApplicationThenExceptionIsThrown()
{
// Arrange
IApplicationRepository fakeApplicationRepository = A.Fake <IApplicationRepository>();
A.CallTo(() => fakeApplicationRepository.TryGetByDisplayNameAsync(A <string> .Ignored)).Returns(Task.FromResult(new ApplicationEntity()));
IUnitOfWork fakeUnitOfWork = A.Fake <IUnitOfWork>();
IPasswordWithSaltHasher fakePasswordHasher = A.Fake <IPasswordWithSaltHasher>();
IApplicationService applicationService = new ApplicationService(fakeApplicationRepository, fakeUnitOfWork, fakePasswordHasher);
ApplicationCreateDto applicationCreateDto = new ApplicationCreateDto()
{
DisplayName = "TestApplicationDisplayName",
Password = "******"
};
// Act
ArgumentException ex = Assert.CatchAsync <ArgumentException>(async() => await applicationService.AddApplicationAsync(applicationCreateDto));
// Assert
StringAssert.Contains("Application with DisplayName TestApplicationDisplayName already exists.", ex.Message);
}
public static ApplicationEntity ToApplication(this ApplicationCreateDto applicationCreateDto)
{
return(ObjectMapperManager
.DefaultInstance
.GetMapper <ApplicationCreateDto, ApplicationEntity>()
.Map(applicationCreateDto));
}
public async void UpdateApplicationShouldCreateNewApplicationWithUpdatedVersion()
{
var result = await _fixture.GetHttpResult(UrlPath + _applicationToUpdateId);
var applicationToUpdate = JsonConvert.DeserializeObject <ApplicationDetailDto>(result.Content.ReadAsStringAsync().Result);
var newCreateDto = new ApplicationCreateDto()
{
ConferenceId = applicationToUpdate.Conference?.Id,
FilledForm = "{\"1\":\"Messi\",\"2\":\"Rolando\"}",
FormId = applicationToUpdate.Form.Id,
StatusId = applicationToUpdate.StatusId,
UserId = applicationToUpdate.User.Id
};
var serializedApplication = JsonConvert.SerializeObject(newCreateDto);
var response = await _fixture.PutHttpResult($"{UrlPath}{_applicationToUpdateId}", serializedApplication);
response.Should().NotBeNull();
response.StatusCode.Should().Be(HttpStatusCode.OK);
var deserializedResponse = JsonConvert.DeserializeObject <ApplicationDetailDto>(response.Content.ReadAsStringAsync().Result);
deserializedResponse.Version.Should().Be(applicationToUpdate.Version + 1);
deserializedResponse.PreviousVersion.Should().Be(applicationToUpdate.Id);
deserializedResponse.Comments.Count().Should().Be(applicationToUpdate.Comments.Count());
deserializedResponse.Assignments.Count().Should().Be(applicationToUpdate.Assignments.Count());
deserializedResponse.Assignments.Select(userDto => userDto.Id).ToList().ForEach(guid =>
{
applicationToUpdate.Assignments.Select(userDto => userDto.Id).Contains(guid).Should().Be(true);
});
}
// creates an new application and returns the object as a DTO
public ApplicationDetailDto CreateApplication(ApplicationCreateDto applicationToCreate)
{
var newApplication = applicationToCreate.ToModel();
newApplication.IsCurrent = true;
newApplication.Version = 1;
_applicationDbContext.Application.Add(newApplication);
Save();
return(GetApplicationById(newApplication.Id));
}
public static Application ToModel(this ApplicationCreateDto response)
{
return(new Application()
{
Id = Guid.NewGuid(),
Created = DateTime.UtcNow,
LastModified = DateTime.UtcNow,
FilledForm = response.FilledForm,
UserId = response.UserId,
ConferenceId = response.ConferenceId,
StatusId = response.StatusId,
FormId = response.FormId
});
}
// updates an Application
// the updated application is set to IsCurrent = false
// a new application will be created referencing the old one
public ApplicationDetailDto UpdateApplication(Guid applicationId, ApplicationCreateDto newApplication)
{
var currentApplication = _applicationDbContext.Application
.Include(application => application.Comment)
.Include(application => application.Assignment)
.SingleOrDefault(app => app.Id == applicationId);
currentApplication.IsCurrent = false;
var updatedApplication = newApplication.ToModel();
updatedApplication.IsCurrent = true;
updatedApplication.Version = currentApplication.Version + 1;
updatedApplication.PreviousVersion = currentApplication.Id;
_applicationDbContext.Application.Add(updatedApplication);
// Copies the old comments to the new application
currentApplication.Comment?.ToList()
.ForEach(comment =>
{
var copyOfComment = new Comment()
{
Id = Guid.NewGuid(),
ApplicationId = updatedApplication.Id,
Created = DateTime.UtcNow,
IsPrivate = comment.IsPrivate,
RequiresChanges = comment.RequiresChanges,
Message = comment.Message,
UserId = comment.UserId
};
_applicationDbContext.Comment.Add(copyOfComment);
});
// copies the old assignments to the new one
currentApplication.Assignment?.ToList().ForEach(assignment =>
{
_applicationDbContext.Assignment.Add(new Assignment()
{
ApplicationId = updatedApplication.Id,
UserId = assignment.UserId
});
});
Save();
return(GetApplicationById(updatedApplication.Id));
}
public virtual IActionResult CreateApplication([FromBody] ApplicationCreateDto application)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newApplication = _applicationRepository.CreateApplication(application);
_applicationRepository.Save();
var location = "/application/" + newApplication.Id;
return(Created(location, newApplication));
}
public async void CreateApplicationWithInvalidModelStateShouldReturnBadRequest()
{
var newApplication = new ApplicationCreateDto()
{
FormId = DataSeeder.FormId1,
StatusId = StatusValue.CREATED,
FilledForm = "{\"1\":\"Messi\",\"2\":\"Rolando\"}"
};
var serializedApplication = JsonConvert.SerializeObject(newApplication);
var result = await _fixture.PostHttpResult(UrlPath, serializedApplication);
result.Should().NotBeNull();
result.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task <IHttpActionResult> RegisterAsync(ApplicationCreateModel applicationCreateModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
ApplicationCreateDto applicationCreateDto = applicationCreateModel.ToApplicationCreateDto();
int applicationId = await _applicationService.AddApplicationAsync(applicationCreateDto);
return(Ok(applicationId));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void WhenAddingApplicationWithEmptyPasswordThenExceptionIsThrown()
{
// Arrange
IApplicationRepository fakeApplicationRepository = A.Fake <IApplicationRepository>();
IUnitOfWork fakeUnitOfWork = A.Fake <IUnitOfWork>();
IPasswordWithSaltHasher fakePasswordHasher = A.Fake <IPasswordWithSaltHasher>();
IApplicationService applicationService = new ApplicationService(fakeApplicationRepository, fakeUnitOfWork, fakePasswordHasher);
ApplicationCreateDto applicationCreateDto = new ApplicationCreateDto()
{
DisplayName = "TestApplicationDisplayName",
Password = ""
};
// Act
ArgumentException ex = Assert.CatchAsync <ArgumentException>(async() => await applicationService.AddApplicationAsync(applicationCreateDto));
// Assert
StringAssert.Contains("Application name and password must be provided.", ex.Message);
}
public IActionResult CreateApplication([FromBody] ApplicationCreateDto ApplicationDto)
{
if (ApplicationDto == null)
{
return(BadRequest(ModelState));
}
if (_apRepo.ApplicationExists(ApplicationDto.IdentityNumber))
{
ModelState.AddModelError("", "application Exists!");
return(StatusCode(404, ModelState));
}
var ApplicationObj = _mapper.Map <Application>(ApplicationDto);
if (!_apRepo.CreateApplication(ApplicationObj))
{
ModelState.AddModelError("", $"Something went wrong when saving the record {ApplicationObj.IdentityNumber}");
return(StatusCode(500, ModelState));
}
return(CreatedAtRoute("GetApplication", new { version = HttpContext.GetRequestedApiVersion().ToString(),
ApplicationId = ApplicationObj.Id }, ApplicationObj));
}
public virtual IActionResult UpdateApplicationById([FromRoute] Guid applicationId, [FromBody] ApplicationCreateDto application)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var updatedApplication = _applicationRepository.UpdateApplication(applicationId, application);
_applicationRepository.Save();
return(Ok(updatedApplication));
}
