public async Task UpdateAsync_given_study_updates_study()
{
// Arrange
var context = new Mock <IContext>();
var entity = new Study {
Id = 11
};
context.Setup(c => c.Studies.FindAsync(11)).ReturnsAsync(entity);
using (var repository = new StudyRepository(context.Object))
{
var study = new StudyDTO
{
Id = 11,
Title = "StudyTitle",
Description = "StudyDescription"
};
// Act
await repository.UpdateAsync(study);
}
// Assert
Assert.Equal("StudyTitle", entity.Title);
Assert.Equal("StudyDescription", entity.Description);
}
public async Task UpdateAsync_given_study_returns_true()
{
// Arrange
var context = new Mock <IContext>();
var entity = new Study {
Id = 11
};
context.Setup(c => c.Studies.FindAsync(11)).ReturnsAsync(entity);
using (var repository = new StudyRepository(context.Object))
{
var study = new StudyDTO
{
Id = 11,
Title = "StudyTitle",
Description = "StudyDescription"
};
// Act
var result = await repository.UpdateAsync(study);
// Assert
Assert.True(result);
}
}
public StudyDTO Addstudy(StudyDTO studyDto)
{
if (studyDto.ProjectAcc != null)
{
var project = _projectRepository.FindSingle(p => p.Accession == studyDto.ProjectAcc,
new List <string>()
{
"Studies"
});
if (project != null)
{
var num = project.Studies.Count;
var abbr = studyDto.ProjectAcc.Substring(2, 3);
studyDto.Accession = "S-" + abbr + "-" + (num + 1).ToString("00");
studyDto.ProjectId = project.Id;
}
}
var study = new Study()
{
Name = studyDto.Name, Description = studyDto.Title, Accession = studyDto.Accession, ProjectId = studyDto.ProjectId
};
study = _studyRepository.Insert(study);
if (!_studyServiceUnit.Save().Equals("CREATED"))
{
return(null);
}
studyDto.Id = study.Id;
studyDto.Accession = study.Accession;
return(studyDto);
}
public async Task UpdateAsync_given_study_calls_SaveChangesAsync()
{
// Arrange
var context = new Mock <IContext>();
var entity = new Study {
Id = 11
};
context.Setup(c => c.Studies.FindAsync(11)).ReturnsAsync(entity);
using (var repository = new StudyRepository(context.Object))
{
var study = new StudyDTO
{
Id = 11,
Title = "StudyTitle",
Description = "StudyDescription"
};
// Act
await repository.UpdateAsync(study);
}
// Assert
context.Verify(c => c.SaveChangesAsync(default(CancellationToken)));
}
public IActionResult Study([FromBody] StudyModel model)
{
StudyDTO dto = Mapping.Mapper.Map <StudyModel, StudyDTO>(model);
_curriculumService.AddOrUpdateSectionBlock <StudyDTO>(dto, model.FormMode, SectionNames.Study);
return(Ok(new { id = model.StudyId }));
}
public StudyControllerTests()
{
_studyLogicMock = new Mock <IStudyLogic>();
_studyDTO = new StudyDTO()
{
Id = 1, Name = "Test", Description = "Test"
};
}
public StudyLogicTests()
{
_mock = new Mock <IRepository <StudyDTO> >();
_studyDTO = new StudyDTO()
{
Id = 1
};
}
//public void addDatasetVariables(List<VariableDefinition> variableDefinitions)
//{
// for (int i = 0; i < variableDefinitions.Count; i++)
// {
// _variableDefinitionRepository.Insert(variableDefinitions[i]);
// }
// _studyServiceUnit.Save();
//}
public string Updatestudy(StudyDTO studyDto, int studyId)
{
var studyToUpdate = _studyRepository.Get(studyId);
studyToUpdate.Name = studyDto.Name;
studyToUpdate.Description = studyDto.Title;
_studyRepository.Update(studyToUpdate);
return(_studyServiceUnit.Save());
}
public IActionResult Addstudy([FromBody] StudyDTO studyDTO)
{
var addedstudy = _studyService.Addstudy(studyDTO);
if (addedstudy != null)
{
return(new CreatedAtActionResult("GET", "GetstudyById", new { studyId = addedstudy.Id }, studyDTO));
}
return(new BadRequestResult());
}
public async Task <IActionResult> CreateStudy([FromBody] StudyDTO study)
{
if (!ModelState.IsValid || study.Id != 0)
{
return(BadRequest(ModelState));
}
var create = await _studyLogic.Create(study);
return(Ok(create));
}
public StudyLogicIntegrationTests()
{
var efContext = new EFContext();
_repo = new StudyRepository(efContext);
_studyDTO = new StudyDTO()
{
Id = 1
};
efContext.PurgeData();
}
public IActionResult Updatestudy(int studyId, [FromBody] StudyDTO studyDTO)
{
try
{
_studyService.Updatestudy(studyDTO, studyId);
return(new CreatedAtActionResult("GET", "GetstudyById", new { studyId = studyDTO.Id }, studyDTO));
}
catch (Exception e)
{
return(new BadRequestObjectResult(e.Message));
}
}
public static Study ConvertToEntity(this StudyDTO dto)
{
return(new Study {
Id = dto.Id,
Name = dto.Name,
Phases = dto.Phases?.Select(d => d.ConvertToEntity()).ToList(),
Description = dto.Description,
ActivePhase = dto.ActivePhase?.ConvertToEntity(),
Participants = dto.Users?.Select(d => d.ConvertToEntity()).ToList(),
Publications = dto.Publications?.Select(d => d.ConvertToEntity()).ToList()
});
}
public async Task Post_when_not_ModelState_IsValid_returns_BadRequest()
{
var controller = new StudiesController(null);
controller.ModelState.AddModelError("", "");
var study = new StudyDTO();
var result = await controller.Post(study);
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task Put_when_repository_Update_returns_false_returns_NotFound()
{
var study = new StudyDTO {
Id = 42, Name = "Name"
};
var repository = new Mock <IStudyRepository>();
var controller = new StudiesController(repository.Object);
var result = await controller.Put(42, study);
Assert.IsType <NotFoundResult>(result);
}
public async Task Post_when_valid_returns_Created()
{
var repository = new Mock <IStudyRepository>();
var controller = new StudiesController(repository.Object);
var study = new StudyDTO {
Name = "Name"
};
var result = await controller.Post(study);
Assert.IsAssignableFrom <CreatedAtActionResult>(result);
}
public async Task <IActionResult> Post([FromBody] StudyDTO study)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var id = await _repository.CreateAsync(study);
study.Id = id;
return(CreatedAtAction("Get", new { id }, study));
}
public async Task Post_calls_repository_Create()
{
var repository = new Mock <IStudyRepository>();
var controller = new StudiesController(repository.Object);
var study = new StudyDTO {
Name = "Name"
};
await controller.Post(study);
repository.Verify(r => r.CreateAsync(study), Times.Once);
}
public void Gets_all_phases_for_study_valid_input()
{
var study = new StudyDTO
{
Id = 0,
Name = "test",
Description = "for testing",
ActivePhase = null,
ExclusionCriteria = null,
ClassificationCriteria = null,
Users = null,
Publications = null,
Phases = null
};
var listOfPhases = new List <PhaseDTO>
{
new PhaseDTO
{
Id = 0, Purpose = "something", Participants = null, TaskDelegations = null,
DisplayFields = null, InputFields = null, OverlapPercentage = 50,
IsAutomatic = true, ConflictManager = null, StudyId = study.Id
},
new PhaseDTO
{
Id = 1, Purpose = "something1", Participants = null, TaskDelegations = null,
DisplayFields = null, InputFields = null, OverlapPercentage = 50,
IsAutomatic = true, ConflictManager = null, StudyId = study.Id
},
new PhaseDTO
{
Id = 5, Purpose = "something", Participants = null, TaskDelegations = null,
DisplayFields = null, InputFields = null, OverlapPercentage = 50,
IsAutomatic = true, ConflictManager = null, StudyId = study.Id
}
};
study.Phases = listOfPhases.ToList();
_phaseDtoRepository.Setup(a => a.ReadAsync()).Returns(Task.FromResult(listOfPhases.AsQueryable()));
var result = _phaseLogic.GetAllForStudy(study.Id).Result;
var phase1 = listOfPhases.ElementAt(0);
var res1 = result.ElementAt(0);
Assert.Equal(listOfPhases.Count(), result.Count());
Assert.Equal(phase1.Id, res1.Id);
}
public async Task Get_42_returns_repository_FindAsync_42()
{
var repository = new Mock <IStudyRepository>();
var study = new StudyDTO {
Id = 42
};
repository.Setup(r => r.FindAsync(42)).ReturnsAsync(study);
var controller = new StudiesController(repository.Object);
var result = await controller.Get(42) as OkObjectResult;
Assert.Same(study, result.Value);
}
public async Task Put_when_repository_Update_returns_true_returns_NoContent()
{
var study = new StudyDTO {
Id = 42, Name = "Name"
};
var repository = new Mock <IStudyRepository>();
repository.Setup(r => r.UpdateAsync(study)).ReturnsAsync(true);
var controller = new StudiesController(repository.Object);
var result = await controller.Put(42, study);
Assert.IsType <NoContentResult>(result);
}
public async Task Put_when_not_ModelState_IsValid_does_not_call_repository()
{
var study = new StudyDTO {
Id = 42, Name = "Name"
};
var repository = new Mock <IStudyRepository>();
var controller = new StudiesController(repository.Object);
controller.ModelState.AddModelError("", "");
await controller.Put(42, study);
repository.Verify(r => r.UpdateAsync(study), Times.Never);
}
public async Task Put_given_id_not_eq_to_studyId_returns_BadRequest()
{
// Arrange
var repository = new Mock <IStudyRepository>();
var controller = new StudyController(repository.Object, log.Object);
var customer = new StudyDTO {
Id = 11
};
// Act
var result = await controller.Put(0, customer);
// Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task Put_given_valid_study_calls_UpdateAsync()
{
// Arrange
var repository = new Mock <IStudyRepository>();
var controller = new StudyController(repository.Object, log.Object);
var study = new StudyDTO {
Id = 11
};
// Act
await controller.Put(11, study);
// Arrange
repository.Verify(r => r.UpdateAsync(study));
}
public async Task <IActionResult> UpdateStudy([FromBody] StudyDTO study, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var update = await _studyLogic.Update(study, id);
if (update)
{
return(NoContent());
}
return(NotFound());
}
public async Task <bool> UpdateAsync(StudyDTO study)
{
var entity = await _context.Studies.FindAsync(study.Id);
if (entity == null)
{
return(false);
}
entity.Title = study.Title;
entity.Description = study.Description;
await _context.SaveChangesAsync();
return(true);
}
public async Task Post_when_valid_returns_study_with_new_id()
{
var study = new StudyDTO {
Name = "Name"
};
var repository = new Mock <IStudyRepository>();
repository.Setup(r => r.CreateAsync(study)).ReturnsAsync(42);
var controller = new StudiesController(repository.Object);
var result = await controller.Post(study) as CreatedAtActionResult;
var created = result.Value as StudyDTO;
Assert.Equal(42, created.Id);
}
public async Task <IActionResult> Put(int id, [FromBody] StudyDTO study)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var ok = await _repository.UpdateAsync(study);
if (ok)
{
return(NoContent());
}
return(NotFound());
}
public async Task Post_when_valid_returns_Get_action()
{
var study = new StudyDTO {
Name = "Name"
};
var repository = new Mock <IStudyRepository>();
repository.Setup(r => r.CreateAsync(study)).ReturnsAsync(42);
var controller = new StudiesController(repository.Object);
var result = await controller.Post(study) as CreatedAtActionResult;
Assert.Equal("Get", result.ActionName);
Assert.Null(result.ControllerName); // null means current controller
Assert.Equal(42, result.RouteValues["id"]);
}
public async void Gets_all_phases_for_study_valid_input_integration()
{
var study = new StudyDTO {
Id = 0,
Name = "test",
Description = "for testing",
ActivePhase = null,
ExclusionCriteria = null,
ClassificationCriteria = null,
Users = null,
Publications = null,
Phases = null
};
var listOfPhases = new Collection <PhaseDTO>
{
new PhaseDTO
{
Id = 0, Purpose = "something", Participants = null, TaskDelegations = null,
DisplayFields = null, InputFields = null, OverlapPercentage = 50,
IsAutomatic = true, ConflictManager = null
},
new PhaseDTO
{
Id = 1, Purpose = "something1", Participants = null, TaskDelegations = null,
DisplayFields = null, InputFields = null, OverlapPercentage = 50,
IsAutomatic = true, ConflictManager = null
},
new PhaseDTO
{
Id = 5, Purpose = "something", Participants = null, TaskDelegations = null,
DisplayFields = null, InputFields = null, OverlapPercentage = 50,
IsAutomatic = true, ConflictManager = null
}
};
study.Phases = listOfPhases;
var result = await _phaseLogic.GetAllForStudy(study.Id);
var phase1 = listOfPhases.ElementAt(0);
var res1 = result.ElementAt(0);
Assert.Equal(listOfPhases.Count(), result.Count());
Assert.Equal(phase1.Id, res1.Id);
}
