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_ValidInputsWithTitleAndBody_ExpectSaveToRepositories()
{
//Arrange
var client = _appFactory.CreateAuthorizedClient();
var form = await GetNewPoemForm(client);
var newPoem = new PoemBuilder().Random().Build();
var inputs = CreateFormInputs(newPoem);
//Act
var response = await PostRequestHelper.PostWithUpdateInputsAsync(client, form, inputs);
var selectors = new SelectorHelper(response, PageElements.NewPoemPageSelectors);
//Assert
var queryPoem = _appFactory.DbContext.GetQueryable <Poem>();
var poemResult = queryPoem.FirstOrDefault(p => p.Name == newPoem.Name);
Assert.NotNull(poemResult);
Assert.Equal(newPoem.Notes, poemResult.Notes);
Assert.Equal(newPoem.ConceivedDateUTC.ToString("yyyy-MM-dd HH:mm"),
poemResult.ConceivedDateUTC.ToString("yyyy-MM-dd HH:mm"));
var queryRevision = _appFactory.DbContext.GetQueryable <PoemRevision>();
var revisionResult = queryRevision.FirstOrDefault(r => r.Title == inputs["NewRevision.Title"]);
Assert.NotNull(revisionResult);
Assert.Equal(inputs["NewRevision.Body"], revisionResult.Body);
}
public async void OnGet_DefaultPage_ReturnsPublishedPoemFromRepository()
{
//Arrange
var client = _appFactory.CreateClient();
var poems = new PoemBuilder().Default().BuildCollection(size: 2);
var publishedPoem = poems.Last();
var publishedRevision = publishedPoem.PoemRevisions.FirstOrDefault();
publishedPoem.PublishedRevision = publishedRevision;
var nonPublishedPoem = poems.FirstOrDefault();
nonPublishedPoem.PublishedRevision = null;
_appFactory.DbContext.AddRange(poems);
_appFactory.DbContext.SaveChanges();
//Act
var response = await client.GetAsync("/");
var pageContent = await ResponseHelper.GetDocumentAsync(response);
var selectors = new SelectorHelper(pageContent, PageElements.IndexPageSelectors);
var title = selectors.Get <IHtmlElement>((int)PageElements.IndexPageElementEnum.PoemTitle);
var body = selectors.Get <IHtmlElement>((int)PageElements.IndexPageElementEnum.PoemBody);
//Assert
Assert.NotNull(title);
Assert.NotNull(body);
Assert.Equal(publishedRevision.Title, title.TextContent);
Assert.Equal(publishedRevision.Body, body.TextContent);
}
public async void OnGet_ReturnsAllPublishedPoemTitleInAscOrder()
{
//Arrange
var client = _appFactory.CreateClient();
var poems = new PoemBuilder().Random().BuildCollection(size: 2);
poems.First().PublishedRevision = poems.First().PoemRevisions.FirstOrDefault();
poems.Last().PublishedRevision = poems.Last().PoemRevisions.FirstOrDefault();
_appFactory.DbContext.AddRange(poems);
_appFactory.DbContext.SaveChanges();
//Act
var response = await client.GetAsync("/ListPoemsByTitle");
var pageContent = await ResponseHelper.GetDocumentAsync(response);
var selectors = new SelectorHelper(pageContent, PageElements.ListPageSelectors);
var links = selectors.GetAll <IHtmlAnchorElement>((int)PageElements.ListPageElementEnum.PoemLink);
var titles = selectors.GetAll <IHtmlElement>((int)PageElements.ListPageElementEnum.PoemTitle);
//Assert
var expectResults = poems.OrderBy(p => p.PublishedRevision.Title);
Assert.Equal(expectResults.Count(), titles.Count());
Assert.Equal(expectResults.Count(), links.Count());
for (int n = 0; n < expectResults.Count(); n++)
{
Assert.Contains(expectResults.ElementAt(n).Id.ToString(),
links.ElementAt(n).Href);
Assert.Equal(expectResults.ElementAt(n).PublishedRevision.Title,
titles.ElementAt(n).TextContent);
}
}
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 OnGet_ExpectPoemDisplayed()
{
//Arrange
var client = _appFactory.CreateClient();
var poems = new PoemBuilder().Default().BuildCollection(size: 2);
var poemToGet = poems.Last();
var publishedRevision = poemToGet.PoemRevisions.FirstOrDefault();
poemToGet.PublishedRevision = publishedRevision;
_appFactory.DbContext.AddRange(poems);
_appFactory.DbContext.SaveChanges();
//Act
var response = await client.GetAsync("/Poem?id=" + poemToGet.Id.ToString());
var pageContent = await ResponseHelper.GetDocumentAsync(response);
var selectors = new SelectorHelper(pageContent, PageElements.PoemPageSelectors);
var title = selectors.Get <IHtmlElement>((int)PageElements.PoemPageElementEnum.PoemTitle);
var body = selectors.Get <IHtmlElement>((int)PageElements.PoemPageElementEnum.PoemBody);
//Assert
Assert.NotNull(title);
Assert.NotNull(body);
Assert.Equal(publishedRevision.Title, title.TextContent);
Assert.Equal(publishedRevision.Body, body.TextContent);
}
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_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);
}
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 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 void NoMatch_ExpectNullReturned()
{
//Arrange
var poems = new PoemBuilder().Default().BuildCollection(size: 3);
//Act
var spec = new GetPoemAndPublishedRevisionByIdSpec(Guid.Empty);
var testResult = poems.AsQueryable().FirstOrDefault(spec.Criteria);
//Assert
Assert.Null(testResult);
}
public void NoMatch_ExpectNullReturned()
{
//Arrange
var poems = new PoemBuilder().Default().BuildCollection(size: 3);
//Act
var spec = new GetPoemByNameSpec("non exist poem");
var testResult = poems.AsQueryable().FirstOrDefault(spec.Criteria);
//Assert
Assert.Null(testResult);
}
public void MatchingId_ExpectAllRevisionsReturned()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemRevisions = poem.PoemRevisions;
//Act
var spec = new GetRevisionsSpec(poem.Id);
var testResult = poemRevisions.AsQueryable().Where(spec.Criteria);
//Assert
Assert.Equal(poemRevisions, testResult);
}
public void NoMatch_ExpectEmptyListReturned()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemRevisions = poem.PoemRevisions;
//Act
var spec = new GetRevisionsSpec(Guid.Empty);
var testResult = poemRevisions.AsQueryable().Where(spec.Criteria);
//Assert
Assert.Equal(new List <PoemRevision>(), testResult);
}
public void NoMatchingPublishedPoem_ExpectNullReturned()
{
//Arrange
var poemList = new PoemBuilder().Default().BuildCollection(size: 2);
poemList.FirstOrDefault().PublishedRevision = poemList.FirstOrDefault().PoemRevisions.FirstOrDefault();
poemList.Last().PublishedRevision = poemList.Last().PoemRevisions.FirstOrDefault();
//Act
var testResult = ApplySpecificationToList(poemList, Guid.Empty);
//Assert
Assert.Null(testResult);
}
public void NoPublishedPoem_ExpectEmptyListReturned()
{
//Arrange
var poemList = new PoemBuilder().Default().BuildCollection(size: 2);
poemList.FirstOrDefault().PublishedRevision = null;
poemList.Last().PublishedRevision = null;
//Act
var testResult = ApplySpecificationToList(poemList);
//Assert
Assert.Empty(testResult);
}
public void NonCaseSensitiveMatch_ExpectPoemReturned()
{
//Arrange
var poems = new PoemBuilder().Default().BuildCollection(size: 3).ToList();
var expectResult = poems[1];
//Act
var spec = new GetPoemByNameSpec(expectResult.Name.ToUpper());
var testResult = poems.AsQueryable().FirstOrDefault(spec.Criteria);
//Assert
Assert.NotNull(testResult);
Assert.Equal(expectResult.Id, testResult.Id);
}
public void ExactMatch_ExpectPoemReturned()
{
//Arrange
var poems = new PoemBuilder().Default().BuildCollection(size: 3).ToList();
var expectResult = poems[1];
//Act
var spec = new GetPoemAndPublishedRevisionByIdSpec(expectResult.Id);
var testResult = poems.AsQueryable().FirstOrDefault(spec.Criteria);
//Assert
Assert.NotNull(testResult);
Assert.Equal(expectResult.Id, testResult.Id);
}
public void HasMultiplePublishedPoems_ExpectAllReturnedAndTitleInAscOrder()
{
//Arrange
var poemList = new PoemBuilder().Random().BuildCollection(size: 2);
poemList.First().PublishedRevision = poemList.First().PoemRevisions.FirstOrDefault();
poemList.Last().PublishedRevision = poemList.Last().PoemRevisions.FirstOrDefault();
//Act
var testResult = ApplySpecificationToList(poemList);
//Assert
var expectResult = poemList.OrderBy(p => p.PublishedRevision.Title);
Assert.Equal(expectResult, testResult);
}
public void SinglePoem_ExpectListWithSamePoem()
{
//Arrange
var poems = new PoemBuilder().Default().BuildCollection(size: 1).ToList();
var queryable = poems.AsQueryable();
var expectResult = poems;
//Act
var spec = ListPoemsByLastModifiedDateSpec.CreateSpecification();
var testResult = queryable.OrderByDescending(spec.OrderByDesc);
//Assert
Assert.Null(spec.Criteria);
Assert.Null(spec.OrderBy);
Assert.Equal(expectResult, testResult);
}
public void MatchingPoemIsNotPublished_ExpectNullReturned()
{
//Arrange
var poemList = new PoemBuilder().Default().BuildCollection(size: 2);
poemList.FirstOrDefault().PublishedRevision = poemList.FirstOrDefault().PoemRevisions.FirstOrDefault();
var poemToGet = poemList.Last();
poemToGet.PublishedRevision = null;
//Act
var testResult = ApplySpecificationToList(poemList, poemToGet.Id);
//Assert
Assert.Null(testResult);
}
public void NoMatch_ExpectNullReturned()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
var poemRevisions = poem.PoemRevisions;
//Act
var spec = new GetLatestRevisionSpec(Guid.Empty);
var testResult = poemRevisions.AsQueryable()
.Where(spec.Criteria)
.OrderByDescending(spec.OrderByDesc)
.FirstOrDefault();
//Assert
Assert.Null(testResult);
}
public void CreateDTOFromEntity_ValidInput()
{
//Arrange
var poemEntity = new PoemBuilder().Default().Build();
poemEntity.PublishedRevision = poemEntity.PoemRevisions.FirstOrDefault();
//Act
var poemDTO = PoemDTO.CreateDTOFromEntity(poemEntity);
//Assert
Assert.NotNull(poemDTO);
Assert.Equal(poemEntity.Id, poemDTO.Id);
Assert.Equal(poemEntity.PublishedRevision.Title, poemDTO.Title);
Assert.Equal(poemEntity.PublishedRevision.Body, poemDTO.Body);
}
public async void OnGet_WithPublishedRevision_VerifyHtmlElements()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
poem.PoemRevisions = new RevisionBuilder(poem).Random().BuildCollection(size: 3);
poem.PublishedRevision = poem.PoemRevisions.FirstOrDefault();
var client = CreateClientAndTestData(poem);
//Act
var response = await client.GetAsync("/EditPoem?Id=" + poem.Id.ToString());
var pageContent = await ResponseHelper.GetDocumentAsync(response);
var selectors = new SelectorHelper(pageContent, PageElements.EditPoemPageSelectors);
//Assert
var publishRevisionSelectList = selectors.Get <IHtmlSelectElement>
((int)PageElements.EditPoemElementEnum.PublishRevisionSelectList);
var publishRevisionValidationMsg = selectors.Get <IHtmlElement>
((int)PageElements.EditPoemElementEnum.PublishRevisionValidationMsg);
var titleInput = selectors.Get <IHtmlInputElement>
((int)PageElements.EditPoemElementEnum.TitleInputField);
var bodyInput = selectors.Get <IHtmlTextAreaElement>
((int)PageElements.EditPoemElementEnum.BodyInputField);
var pastRevisionSelectList = selectors.Get <IHtmlSelectElement>
((int)PageElements.EditPoemElementEnum.PastRevisionSelectList);
Assert.NotNull(publishRevisionSelectList);
Assert.NotNull(publishRevisionValidationMsg);
Assert.NotNull(titleInput);
Assert.NotNull(bodyInput);
Assert.NotNull(pastRevisionSelectList);
Assert.NotEmpty(publishRevisionSelectList.SelectedOptions);
var selectedOption = publishRevisionSelectList.SelectedOptions.FirstOrDefault();
Assert.Equal(poem.PublishedRevision.Id.ToString(), selectedOption.Value);
var revisionList = new RevisionList(poem.PoemRevisions);
var publishedRevision = revisionList.Where(r => r.Id == poem.PublishedRevision.Id).FirstOrDefault();
Assert.Equal(publishedRevision.DisplayName, selectedOption.Text);
Assert.Equal(revisionList.Count + 2, publishRevisionSelectList.Length);
Assert.Equal(revisionList.Count, pastRevisionSelectList.Length);
}
public async void OnGet_WithoutRevision_VerifyHtmlElements()
{
//Arrange
var poem = new PoemBuilder().Default().Build();
poem.PublishedRevision = null;
poem.PoemRevisions = null;
var client = CreateClientAndTestData(poem);
//Act
var response = await client.GetAsync("/EditPoem?Id=" + poem.Id.ToString());
var pageContent = await ResponseHelper.GetDocumentAsync(response);
var selectors = new SelectorHelper(pageContent, PageElements.EditPoemPageSelectors);
//Assert
var idInput = selectors.Get <IHtmlInputElement>
((int)PageElements.EditPoemElementEnum.IdHiddenField);
var nameInput = selectors.Get <IHtmlInputElement>
((int)PageElements.EditPoemElementEnum.NameInputField);
var nameValidationMsg = selectors.Get <IHtmlElement>
((int)PageElements.EditPoemElementEnum.NameValidationMsg);
var notesInput = selectors.Get <IHtmlTextAreaElement>
((int)PageElements.EditPoemElementEnum.NotesInputField);
var conceivedDateInput = selectors.Get <IHtmlInputElement>
((int)PageElements.EditPoemElementEnum.ConceivedDateInputField);
var conceivedDateValidationMsg = selectors.Get <IHtmlElement>
((int)PageElements.EditPoemElementEnum.ConceivedDateValidationMsg);
var publishRevisionSelectList = selectors.Get <IHtmlSelectElement>
((int)PageElements.EditPoemElementEnum.PublishRevisionSelectList);
Assert.NotNull(idInput);
Assert.NotNull(nameInput);
Assert.NotNull(nameValidationMsg);
Assert.NotNull(notesInput);
Assert.NotNull(conceivedDateInput);
Assert.NotNull(nameValidationMsg);
Assert.NotNull(publishRevisionSelectList);
Assert.Equal(poem.Id.ToString(), idInput.Value);
Assert.Equal(poem.Name, nameInput.Value);
Assert.Equal(poem.Notes, notesInput.Value);
Assert.Equal(poem.ConceivedDateUTC.ToLocalTime().ToString("yyyy-MM-dd"),
conceivedDateInput.Value);
Assert.Empty(publishRevisionSelectList.SelectedOptions);
}
public void HasPublishedPoem_ExpectPoemReturned()
{
//Arrange
var poemList = new PoemBuilder().Default().BuildCollection(size: 2);
poemList.FirstOrDefault().PublishedRevision = null;
var publishedPoem = poemList.Last();
publishedPoem.PublishedRevision = publishedPoem.PoemRevisions.FirstOrDefault();
//Act
var testResult = ApplySpecificationToList(poemList);
var returnedPoem = testResult.Single();
//Assert
Assert.Equal(publishedPoem.Id, returnedPoem.Id);
Assert.Equal(publishedPoem.PublishedRevision.Title, returnedPoem.PublishedRevision.Title);
}
public void HasMultiplePublishedPoems_ExpectAllReturnedAndModifiedDateInDescOrder()
{
//Arrange
var poemList = new PoemBuilder().Random().BuildCollection(size: 2);
poemList.First().PublishedRevision = poemList.First().PoemRevisions.FirstOrDefault();
poemList.First().LastModifiedDateUTC = DateTime.UtcNow.AddDays(-2);
poemList.Last().PublishedRevision = poemList.Last().PoemRevisions.FirstOrDefault();
poemList.Last().LastModifiedDateUTC = DateTime.UtcNow.AddDays(-1);
//Act
var testResult = ApplySpecificationToList(poemList);
//Assert
var expectResult = poemList.OrderByDescending(p => p.LastModifiedDateUTC);
Assert.Equal(expectResult, testResult);
}
public void PoemsWithDescModifiedDate_ExpectListOrderedDesc()
{
//Arrange
var poems = new PoemBuilder().Default().BuildCollection(size: 3).ToList();
poems[0].LastModifiedDateUTC = DateTime.UtcNow.AddDays(-1);
poems[1].LastModifiedDateUTC = DateTime.UtcNow.AddDays(-2);
poems[2].LastModifiedDateUTC = DateTime.UtcNow.AddDays(-3);
var queryable = poems.AsQueryable();
var expectResult = poems;
//Act
var spec = ListPoemsByLastModifiedDateSpec.CreateSpecification();
var testResult = queryable.OrderByDescending(spec.OrderByDesc);
//Assert
Assert.Equal(expectResult, testResult);
}
