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)); }