public async void OnPost_WithoutNewRevision_VerifyServiceMethodIsCalledAndConfirmationMessageIsSet()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemDTO = PoemDTO.CreateDTOFromEntity(poem);
var mockReadService = new Mock <IReadPoemService>();
mockReadService.Setup(r => r.IsNameUsedByOtherPoem(poemDTO.Id, poemDTO.Name))
.Returns(false);
var mockWriteService = new Mock <IWritePoemService>();
mockWriteService.Setup(w => w.UpdatePoem(It.IsAny <PoemDTO>()));
mockWriteService.Setup(w => w.SaveNewRevision(poemDTO.Id, It.IsAny <RevisionDTO>()));
var testModel = new EditPoemModel(mockReadService.Object, mockWriteService.Object);
//Act
testModel.PoemToEdit = poemDTO;
testModel.NewRevision = new RevisionDTO();
await testModel.OnPostAsync();
//Assert
mockWriteService.Verify(w => w.UpdatePoem(It.IsAny <PoemDTO>()), Times.Once);
mockWriteService.Verify(w => w.SaveNewRevision(poemDTO.Id, It.IsAny <RevisionDTO>()), Times.Never);
Assert.Equal(EditPoemModel.POEM_SAVED_MESSAGE, testModel.ConfirmationMessage);
}
public async void OnPost_WithRevision_VerifyServiceMethodIsCalledAndConfirmationMessageIsSet()
{
//Arrange
var mockReadService = new Mock <IReadPoemService>();
mockReadService.Setup(r => r.IsNameUsed(It.IsAny <string>())).Returns(false);
var mockWriteService = new Mock <IWritePoemService>();
mockWriteService.Setup(w => w.SaveNewPoem(It.IsAny <PoemDTO>(), It.IsAny <RevisionDTO>()));
//Act
var testModel = new NewPoemModel(mockReadService.Object, mockWriteService.Object);
testModel.NewPoem = PoemDTO.CreateDTOFromEntity(new PoemBuilder().Default().Build());
testModel.NewRevision = new RevisionDTO()
{
Title = "title",
Body = "body"
};
var testResult = await testModel.OnPostAsync();
//Assert
mockWriteService.Verify(w => w.SaveNewPoem(It.IsAny <PoemDTO>(), It.IsAny <RevisionDTO>()));
Assert.Equal(NewPoemModel.POEM_CREATED_MESSAGE, testModel.ConfirmationMessage);
}
public async void OnPost_PublishNewRevision_NewRevisionNotSaved_VerifyServiceMethodIsNotCalledAndErrorMessageIsSetCorrectly()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemDTO = PoemDTO.CreateDTOFromEntity(poem);
var revisionDTO = RevisionDTO.CreateDTOFromEntity(poem.PoemRevisions.FirstOrDefault());
revisionDTO.Id = Guid.NewGuid();
var mockReadService = new Mock <IReadPoemService>();
mockReadService.Setup(r => r.IsNameUsedByOtherPoem(poemDTO.Id, poemDTO.Name))
.Returns(false);
mockReadService.Setup(r => r.GetLatestPoemRevision(poemDTO.Id))
.Returns(new RevisionDTO());
var mockWriteService = new Mock <IWritePoemService>();
mockWriteService.Setup(w => w.UpdatePoem(It.IsAny <PoemDTO>()));
mockWriteService.Setup(w => w.SaveNewRevision(poemDTO.Id, It.IsAny <RevisionDTO>()));
var testModel = new EditPoemModel(mockReadService.Object, mockWriteService.Object);
//Act
testModel.PoemToEdit = poemDTO;
testModel.PoemToEdit.PublishedRevisionId = EditPoemModel.PUBLISH_NEW_REVISION;
testModel.NewRevision = revisionDTO;
//Assert
await Assert.ThrowsAsync <ApplicationException>(() => testModel.OnPostAsync());
}
public void OnGet_WithRevision_ExpectCorrectValuesInProperties()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemDTO = PoemDTO.CreateDTOFromEntity(poem);
var mockReadService = new Mock <IReadPoemService>();
mockReadService.Setup(r => r.GetPoemById(poemDTO.Id))
.Returns(poemDTO);
var revisions = new RevisionBuilder(poem).Default().BuildCollection(size: 2);
revisions.First().CreatedDateUTC = DateTime.UtcNow.AddDays(-2);
revisions.Last().CreatedDateUTC = DateTime.UtcNow.AddDays(-1);
var revisionList = new RevisionList(revisions);
mockReadService.Setup(r => r.GetPoemRevisions(poemDTO.Id))
.Returns(revisionList);
var mockWriteService = new Mock <IWritePoemService>();
var testModel = new EditPoemModel(mockReadService.Object, mockWriteService.Object);
//Act
testModel.OnGet(poemDTO.Id);
//Assert
Assert.Equal(poemDTO, testModel.PoemToEdit);
Assert.Equal(revisionList, testModel.PastRevisions);
var latestRevision = revisionList.OrderByDescending(r => r.CreatedDateLocal).First();
Assert.Equal(latestRevision, testModel.LatestRevision);
}
public async void OnPost_NameConflict_VerifyServiceMethodIsNotCalledAndErrorMessageIsSetCorrectly()
{
var newName = "new name";
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemDTO = PoemDTO.CreateDTOFromEntity(poem);
var mockReadService = new Mock <IReadPoemService>();
mockReadService.Setup(r => r.GetPoemRevisions(poemDTO.Id))
.Returns(new RevisionList());
mockReadService.Setup(r => r.IsNameUsedByOtherPoem(poemDTO.Id, newName))
.Returns(true);
var mockWriteService = new Mock <IWritePoemService>();
mockWriteService.Setup(w => w.UpdatePoem(It.IsAny <PoemDTO>()));
var testModel = new EditPoemModel(mockReadService.Object, mockWriteService.Object);
//Act
testModel.PoemToEdit = poemDTO;
testModel.PoemToEdit.Name = newName;
await testModel.OnPostAsync();
//Assert
mockWriteService.Verify(w => w.UpdatePoem(It.IsAny <PoemDTO>()), Times.Never);
var inputFieldName = nameof(testModel.PoemToEdit) + "." + nameof(testModel.PoemToEdit.Name);
AssertKeyInErrorState(testModel, inputFieldName);
AssertErrorMessage(testModel, EditPoemModel.NAME_CONFLICT_MESSAGE);
}
public async void OnPost_PublishEmptyRevision_VerifyServiceMethodIsNotCalledAndErrorMessageIsSetCorrectly()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemDTO = PoemDTO.CreateDTOFromEntity(poem);
var mockReadService = new Mock <IReadPoemService>();
mockReadService.Setup(r => r.GetPoemRevisions(poemDTO.Id))
.Returns(new RevisionList());
mockReadService.Setup(r => r.IsNameUsedByOtherPoem(poemDTO.Id, poemDTO.Name))
.Returns(false);
var mockWriteService = new Mock <IWritePoemService>();
mockWriteService.Setup(w => w.UpdatePoem(It.IsAny <PoemDTO>()));
var testModel = new EditPoemModel(mockReadService.Object, mockWriteService.Object);
//Act
testModel.PoemToEdit = poemDTO;
testModel.PoemToEdit.PublishedRevisionId = EditPoemModel.PUBLISH_NEW_REVISION;
testModel.NewRevision = new RevisionDTO();
await testModel.OnPostAsync();
//Assert
mockWriteService.Verify(w => w.UpdatePoem(It.IsAny <PoemDTO>()), Times.Never);
var inputFieldName = nameof(testModel.PoemToEdit) + "." + nameof(testModel.PoemToEdit.PublishedRevisionId);
AssertKeyInErrorState(testModel, inputFieldName);
AssertErrorMessage(testModel, EditPoemModel.NEW_REVISION_EMPTY_MESSAGE);
}
public async void OnPost_PublishNewRevision_VerifyServiceMethodIsCalledAndConfirmationMessageIsSet()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemDTO = PoemDTO.CreateDTOFromEntity(poem);
var revisionDTO = RevisionDTO.CreateDTOFromEntity(poem.PoemRevisions.FirstOrDefault());
revisionDTO.Id = Guid.NewGuid();
var mockReadService = new Mock <IReadPoemService>();
mockReadService.Setup(r => r.IsNameUsedByOtherPoem(poemDTO.Id, poemDTO.Name))
.Returns(false);
mockReadService.Setup(r => r.GetLatestPoemRevision(poemDTO.Id))
.Returns(revisionDTO);
var mockWriteService = new Mock <IWritePoemService>();
mockWriteService.Setup(w => w.UpdatePoem(It.IsAny <PoemDTO>()));
mockWriteService.Setup(w => w.SaveNewRevision(poemDTO.Id, It.IsAny <RevisionDTO>()));
var testModel = new EditPoemModel(mockReadService.Object, mockWriteService.Object);
//Act
testModel.PoemToEdit = poemDTO;
testModel.PoemToEdit.PublishedRevisionId = EditPoemModel.PUBLISH_NEW_REVISION;
testModel.NewRevision = revisionDTO;
await testModel.OnPostAsync();
//Assert
mockReadService.Verify(r => r.GetLatestPoemRevision(poemDTO.Id), Times.Once);
mockWriteService.Verify(w => w.UpdatePoem(testModel.PoemToEdit), Times.Once);
mockWriteService.Verify(w => w.SaveNewRevision(poemDTO.Id, revisionDTO), Times.Once);
Assert.Equal(EditPoemModel.POEM_SAVED_MESSAGE, testModel.ConfirmationMessage);
}
public async void OnPost_InvalidModelState_VerifyServiceMethodIsNotCalled()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemDTO = PoemDTO.CreateDTOFromEntity(poem);
var mockReadService = new Mock <IReadPoemService>();
mockReadService.Setup(r => r.GetPoemRevisions(poemDTO.Id))
.Returns(new RevisionList());
mockReadService.Setup(r => r.IsNameUsedByOtherPoem(poemDTO.Id, poemDTO.Name));
var mockWriteService = new Mock <IWritePoemService>();
mockWriteService.Setup(w => w.UpdatePoem(It.IsAny <PoemDTO>()));
var testModel = new EditPoemModel(mockReadService.Object, mockWriteService.Object);
//Act
testModel.PoemToEdit = poemDTO;
testModel.ModelState.AddModelError("test", "invalid state");
await testModel.OnPostAsync();
//Assert
mockReadService.Verify(r => r.IsNameUsedByOtherPoem(poemDTO.Id, poemDTO.Name), Times.Never);
mockWriteService.Verify(w => w.UpdatePoem(It.IsAny <PoemDTO>()), Times.Never);
}
public PoemDTO GetPoemById(Guid poemId)
{
var spec = new GetPoemByIdSpec(poemId);
var poem = _poemRepository.GetBySpec(spec);
return(PoemDTO.CreateDTOFromEntity(poem));
}
public void SaveNewPoemWithRevision_VerifyCallToPoemRepository()
{
//Arrange
var poemDTO = new PoemDTO()
{
Name = "name",
Notes = "notes",
ConceivedDateLocal = DateTime.Now
};
var revisionDTO = new RevisionDTO()
{
Title = "title",
Body = "body"
};
var poemEntity = poemDTO.ToEntity();
poemEntity.PoemRevisions = new List <PoemRevision>()
{
revisionDTO.ToEntity()
};
var mockPoemRepository = new Mock <IEntityRepository <Poem> >();
mockPoemRepository.Setup(p => p.Add(It.IsAny <Poem>()));
var mockRevisionRepository = new Mock <IEntityRepository <PoemRevision> >();
//Act
new WritePoemService(
mockPoemRepository.Object, mockRevisionRepository.Object)
.SaveNewPoem(poemDTO, revisionDTO);
//Assert
mockPoemRepository.Verify(p => p.Add(It.IsAny <Poem>()));
}
public PoemDTO GetDefaultPoem()
{
var spec = new GetDefaultPoemSpec();
var poem = _poemRepository.GetBySpec(spec);
return(PoemDTO.CreateDTOFromEntity(poem));
}
public void OnGet()
{
if (ModelState.IsValid)
{
Poem = _poemService.GetDefaultPoem();
}
}
public void UpdatePoem(PoemDTO poem)
{
var spec = new GetPoemAndPublishedRevisionByIdSpec(poem.Id);
var poemEntity = _poemRepository.GetBySpec(spec);
if (poemEntity == null)
{
throw new ApplicationException();
}
poemEntity.Name = poem.Name;
poemEntity.Notes = poem.Notes;
poemEntity.ConceivedDateUTC = poem.ConceivedDateLocal.ToUniversalTime();
poemEntity.LastModifiedDateUTC = DateTime.UtcNow;
if (poem.PublishedRevisionId != null && poem.PublishedRevisionId != Guid.Empty)
{
poemEntity.PublishedRevision = _revisionRepository.GetByGuid((Guid)poem.PublishedRevisionId);
}
else
{
poemEntity.PublishedRevision = null;
}
_poemRepository.Update(poemEntity);
}
public PoemDTO GetPoemById(Guid id)
{
var spec = new GetPoemAndPublishedRevisionByIdSpec(id);
var poem = _poemRepository.GetBySpec(spec);
return(PoemDTO.CreateDTOFromEntity(poem));
}
public async void OnPost_AllFieldsModified_ExpectChangesSavedToRepository()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
poem.PublishedRevision = null;
var client = CreateClientAndTestData(poem);
var form = await GetInputFormAsync(client, poem.Id);
var modifiedPoemDTO = PoemDTO.CreateDTOFromEntity(poem);
modifiedPoemDTO.Name = "Updated " + poem.Name;
modifiedPoemDTO.Notes = poem.Notes + " and more notes";
modifiedPoemDTO.ConceivedDateLocal = poem.ConceivedDateUTC.ToLocalTime().AddDays(-1);
modifiedPoemDTO.PublishedRevisionId = poem.PoemRevisions.FirstOrDefault().Id;
var newRevision = new RevisionBuilder(poem).Random().Build();
var newRevisionDTO = RevisionDTO.CreateDTOFromEntity(newRevision);
var inputs = CreateFormInputs(modifiedPoemDTO, newRevisionDTO);
//Act
var response = await PostRequestHelper.PostWithUpdateInputsAsync(client, form, inputs);
//Assert
var revisionList = new RevisionList(poem.PoemRevisions.Append(newRevision));
AssertEditPoemPage(response, modifiedPoemDTO, revisionList);
}
private SelectList CreatePublishRevisionSelectList(RevisionList revisions, PoemDTO poem)
{
return(new SelectList(
items: revisions,
dataValueField: nameof(RevisionDTO.Id),
dataTextField: nameof(RevisionDTO.DisplayName),
selectedValue: poem.PublishedRevisionId));
}
public IActionResult OnGet(Guid id)
{
if (ModelState.IsValid)
{
Poem = _retrievePoemService.GetPoemById(id);
if (Poem != null && !Poem.IsEmpty())
{
return(Page());
}
}
return(RedirectToPage("./Index"));
}
private bool IsEqual(PoemDTO expectResult, PoemDTO testResult)
{
if (expectResult.Id == testResult.Id &&
expectResult.Name == testResult.Name &&
expectResult.Notes == testResult.Notes &&
expectResult.ConceivedDateLocal == testResult.ConceivedDateLocal &&
expectResult.PublishedRevisionId == testResult.PublishedRevisionId)
{
return(true);
}
return(false);
}
public IEnumerable <PoemDTO> ListPoemsByDate()
{
var spec = new ListPoemsByDateSpec();
var poems = _poemRepository.List(spec);
if (poems != null)
{
return(poems.Select(p => PoemDTO.CreateDTOFromEntity(p)));
}
else
{
return(new List <PoemDTO>());
}
}
public IEnumerable <PoemDTO> ListByConceivedDate()
{
IEnumerable <Poem> poems = _poemRepository.List(
new ListPoemsByConceivedDateSpec());
if (poems == null)
{
return(new List <PoemDTO>());
}
else
{
return(poems.Select(p => { return PoemDTO.CreateDTOFromEntity(p); }));
}
}
public IEnumerable <PoemDTO> ListByLastModifiedDate()
{
IEnumerable <Poem> poems = _poemRepository.List(
ListPoemsByLastModifiedDateSpec.CreateSpecification());
if (poems == null)
{
return(new List <PoemDTO>());
}
else
{
return(poems.Select(p => { return PoemDTO.CreateDTOFromEntity(p); }));
}
}
public void NameTooLong_ExpectErrorMessage()
{
//Arrange
var validationObject = new PoemDTO()
{
Name = new string('a', 451)
};
//Act
var testResults = Validate(validationObject);
//Assert
Assert.Equal(1, testResults.Count);
Assert.Contains(nameof(PoemDTO.Name), testResults[0].ErrorMessage);
}
public void EmptyName_ExpectErrorMessage()
{
//Arrange
var validationObject = new PoemDTO()
{
Name = ""
};
//Act
var testResults = Validate(validationObject);
//Assert
Assert.Equal(1, testResults.Count);
Assert.Contains(nameof(PoemDTO.Name), testResults[0].ErrorMessage);
}
public void SaveNewPoem(PoemDTO newPoem, RevisionDTO newRevision)
{
var poemEntity = newPoem.ToEntity();
poemEntity.CreatedDateUTC = DateTime.UtcNow;
if (newRevision != null && !newRevision.IsEmpty())
{
var revisionEntity = newRevision.ToEntity();
revisionEntity.CreatedDateUTC = DateTime.UtcNow;
poemEntity.PoemRevisions = new List <PoemRevision>()
{
revisionEntity
};
}
_poemRepository.Add(poemEntity);
}
public void FutureConceivedDate_ExpectErrorMessage()
{
//Arrange
var validationObject = new PoemDTO()
{
Name = "name",
ConceivedDateLocal = DateTime.Now.AddDays(1)
};
//Act
var testResults = Validate(validationObject);
//Assert
Assert.Equal(1, testResults.Count);
Assert.Contains("date", testResults[0].ErrorMessage);
}
public ActionResult <Poem> PostPoem(PoemDTO poemDTO)
{
Poem poem = new Poem {
Title = poemDTO.Title,
Author = poemDTO.Author,
PoemText = poemDTO.PoemText,
Themes = poemDTO.Themes,
UpVoters = new List <string>(),
DownVoters = new List <string>(),
Image = poemDTO.Image
};
_poemRepository.Add(poem);
_poemRepository.SaveChanges();
return(NoContent());
}
void ListPoemsByTitle_RepositoryReturnsPoemList_ExpectPoemDTOList()
{
//Arrange
var poemList = new PoemBuilder().Default().BuildCollection(size: 3);
var mockRepository = new Mock <IEntityRepository <Poem> >();
mockRepository.Setup(r => r.List(It.IsAny <ListPoemsByTitleSpec>()))
.Returns(poemList);
//Act
var service = new ListPoemsService(mockRepository.Object);
var testResult = service.ListPoemsByTitle();
//Assert
var expectResult = poemList.Select(p => PoemDTO.CreateDTOFromEntity(p));
Assert.Equal(expectResult.Count(), testResult.Count());
}
public void OnGet_VerifyPageIsReturnedAndPoemListIsSet()
{
//Arrange
var poems = new PoemBuilder().Default().BuildCollection(size: 3);
var poemDTOList = poems.Select(p => PoemDTO.CreateDTOFromEntity(p));
var mockService = new Mock <IListPoemsService>();
mockService.Setup(s => s.ListPoemsByDate()).Returns(poemDTOList);
//Act
var listModel = new ListPoemsByDateModel(mockService.Object);
var testResult = listModel.OnGet();
//Assert
Assert.IsType <PageResult>(testResult);
Assert.Equal(poemDTOList.Count(), listModel.Poems.Count());
}
public void OnGet_ExistingPoems_VerifyPoemListIsNotEmpty()
{
//Arrange
var poems = new PoemBuilder().Default().BuildCollection(size: 3);
var poemDTOList = poems.Select(p => PoemDTO.CreateDTOFromEntity(p));
var mockService = new Mock <IListPoemsService>();
mockService.Setup(s => s.ListByConceivedDate()).Returns(poemDTOList);
//Act
var listModel = new ListPoemsByConceivedDateModel(mockService.Object);
listModel.OnGet();
//Assert
Assert.Equal(poemDTOList.Count(), listModel.Poems.Count());
}
public void GetPoemById_InvalidId_ExpectEmptyDTO()
{
//Arrange
var expectResult = new PoemDTO();
var invalidId = Guid.Empty;
var mockPoemRepository = new Mock <IEntityRepository <Poem> >();
mockPoemRepository.Setup(pr => pr.GetByGuid(invalidId))
.Returns((Poem)null);
var mockRevisionRepository = new Mock <IEntityRepository <PoemRevision> >();
//Act
var testResult = new ReadPoemService(
mockPoemRepository.Object, mockRevisionRepository.Object)
.GetPoemById(invalidId);
//Assert
Assert.True(IsEqual(expectResult, testResult));
}
