public void ShouldExcludeDraftPagesWhenListingAllPages()
{
UsingSession((session) =>
{
var repository = new Repository(session);
var controller = new PagesController(repository);
controller.Create(new StaticPageInformation()
{
Model = new StaticPage { Id = 1, Title = "test title", Content = "Hello\n=====\nWorld" }
});
controller.Create(new StaticPageInformation()
{
Model = new StaticPage { Id = 2, Title = "test title2", Content = "Hello\n=====\nAnother World" }
});
controller.Create(new StaticPageInformation()
{
Model = new StaticPage { Id = 3, Title = "Draft Page", Content = "Hello\n=====\nI'm a draft", IsDraft = true }
});
});
UsingSession((session) =>
{
WaitForTheLastWrite<StaticPage>(session);
var controller = new PagesController(new Repository(session));
var result = controller.List();
var pages = (PagedList.IPagedList<StaticPageInformation>)result.Model;
Assert.AreEqual(2, pages.Count);
});
}
public void ShouldDisplayFormForNewPage()
{
var repository = new Mock<Repository>();
var controller = new PagesController(repository.Object);
var result = (ViewResult)controller.Create();
Assert.AreEqual("Create", result.ViewName);
}
public void ShouldKnowHowToDeletePage()
{
var id = 1;
var repository = new Mock<Repository>();
var controller = new PagesController(repository.Object);
var result = (RedirectToRouteResult)controller.Delete(id);
repository.Verify(it => it.Delete<StaticPage>(id), Times.Once());
Assert.AreEqual("List", result.RouteValues["action"]);
}
public void ShouldKnowHowToDisplayAPage()
{
var id = 12;
var repository = new Mock<Repository>();
var savedPage = new StaticPage { Id = id, Title = "test title", Content = "some content" };
repository.Setup(repo => repo.Get<StaticPage>(id)).Returns(savedPage);
var controller = new PagesController(repository.Object);
var result = controller.Details(id);
repository.Verify(it => it.Get<StaticPage>(id), Times.Once());
Assert.AreEqual(id, ((StaticPageInformation)result.Model).Model.Id);
}
public void ShouldHandleDuplicatePageProblem()
{
var repository = new Mock<Repository>();
var duplicatePage = new StaticPage { Title = "test title", Content = "test content" };
repository.Setup(repo => repo.Create(duplicatePage))
.Throws(new Raven.Client.Exceptions.NonUniqueObjectException());
var controller = new PagesController(repository.Object);
controller.Create(new StaticPageInformation {Model = duplicatePage});
Assert.AreEqual(string.Format("Sorry, page {0} already exists.", duplicatePage.Title), controller.TempData["flashError"]);
}
public void ShouldDisplayOnlyDraftPagesCreatedByCurrentUserWhenListingDraftPages()
{
string userName = "******";
UsingSession((session) =>
{
var repository = new Repository(session);
var controller = new PagesController(repository);
controller.Create(new StaticPageInformation()
{
Model = new StaticPage { Id = 1, Title = "Draft Page", Content = "Hello\n=====\nWorld", IsDraft = true, Creator = userName}
});
controller.Create(new StaticPageInformation()
{
Model = new StaticPage { Id = 2, Title = "Draft Page 2", Content = "Hello\n=====\nAnother World", IsDraft = true, Creator = userName}
});
controller.Create(new StaticPageInformation()
{
Model = new StaticPage { Id = 3, Title = "Draft Page 3", Content = "Hello\n=====\nI'm a draft", IsDraft = true, Creator = "anotherUser" }
});
});
UsingSession((session) =>
{
WaitForTheLastWrite<StaticPage>(session);
var httpContextStub = new Mock<HttpContextBase>
{
DefaultValue = DefaultValue.Mock
};
var user = Mock.Get(httpContextStub.Object.User);
user.Setup(u => u.Identity.Name).Returns(userName);
var controller = new PagesController(new Repository(session));
controller.ControllerContext = new ControllerContext(httpContextStub.Object, new RouteData(), controller);
var result = controller.List(excludeDraft:false);
var pages = (PagedList.IPagedList<StaticPageInformation>)result.Model;
Assert.AreEqual(2, pages.Count);
});
}
public void ShouldKnowHowToRenderAnEditPage()
{
var repositoryMock = new Mock<Repository>();
var page = new StaticPage {Id = 1, Title = "The Page"};
repositoryMock.Setup(repo => repo.Get<StaticPage>(page.Id)).Returns(page);
var pagesController = new PagesController(repositoryMock.Object);
var result = pagesController.Edit(page.Id);
var actualModel = (StaticPageInformation) result.Model;
Assert.AreEqual(page.Title, actualModel.Model.Title);
repositoryMock.Verify(repo => repo.Get<StaticPage>(1), Times.Once());
}
public void ShouldKnowHowToListAllPages()
{
var repository = new Mock<Repository>();
var savedPages = new List<StaticPage>
{
new StaticPage { Id = 1, Title = "test title", Content = "Hello\n=====\nWorld" },
new StaticPage { Id = 2, Title = "test title2", Content = "Hello\n=====\nAnother World" }
};
var savedPageInformations = new List<StaticPageInformation>
{
new StaticPageInformation {Model = savedPages[0]},
new StaticPageInformation {Model = savedPages[1]}
};
repository.Setup(repo => repo.Search<StaticPage>(It.IsAny<Expression<Func<StaticPage, bool>>>(), It.IsAny<int>(), It.IsAny<int>())).Returns(savedPages);
repository.Setup(repo => repo.Search<StaticPage>(It.IsAny<Expression<Func<StaticPage, bool>>>())).Returns(savedPages);
var controller = new PagesController(repository.Object);
var result = controller.List();
repository.Verify(it => it.Search<StaticPage>(It.IsAny<Expression<Func<StaticPage, bool>>>(), It.IsAny<int>(), It.IsAny<int>()), Times.Once());
Assert.AreEqual(savedPageInformations[0].Model, ((PagedList.IPagedList<StaticPageInformation>)result.Model)[0].Model);
Assert.AreEqual(savedPageInformations[1].Model, ((PagedList.IPagedList<StaticPageInformation>)result.Model)[1].Model);
}
public void ShouldStorePageWhenCreated()
{
var repository = new Mock<Repository>();
var submittedPage = new StaticPage { Title = "test title", Content = "some content" };
repository.Setup(repo => repo.Create(submittedPage)).Returns(new StaticPage { Id = 1, Title = submittedPage.Title, Content = submittedPage.Content });
var controller = new PagesController(repository.Object);
var result = (RedirectToRouteResult)controller.Create(new StaticPageInformation {Model = submittedPage});
repository.Verify(it => it.Create(submittedPage), Times.Once());
Assert.AreEqual(string.Format("Added {0}", submittedPage.Title), controller.TempData["flashSuccess"]);
Assert.AreEqual(1, result.RouteValues["id"]);
}
public void ShouldNotStorePageWhenTitleIsInvalid()
{
var repository = new Mock<Repository>();
var submittedPage = new StaticPage { Title = "", Content = "some content" };
repository.Setup(repo => repo.Create(submittedPage)).Returns(submittedPage);
var controller = new PagesController(repository.Object);
ValidateViewModel(submittedPage, controller);
Assert.IsFalse(controller.ModelState.IsValid);
}
public void ShouldKnowToRenderThePageContentAsMarkdown()
{
var id = 12;
var repository = new Mock<Repository>();
var markdown = new Markdown();
var savedPage = new StaticPage { Id = id, Title = "test title", Content = "Hello\n=====\nWorld" };
repository.Setup(repo => repo.Get<StaticPage>(id)).Returns(savedPage);
var transformedContent = markdown.Transform(savedPage.Content);
var controller = new PagesController(repository.Object);
var result = controller.Details(id);
Assert.AreEqual(transformedContent, ((StaticPageInformation)result.Model).Content);
}
public void ShouldKnowHowToUpdateAPage()
{
var repository = new Mock<Repository>();
var existingPage = new StaticPage {Id = 1, Title = "Derping for dummies."};
repository.Setup(repo => repo.Edit(existingPage));
var pagesController = new PagesController(repository.Object);
var result = pagesController.Edit(new StaticPageInformation { Model = existingPage });
Assert.AreEqual(existingPage.Id, result.RouteValues["id"]);
repository.Verify(repo => repo.Edit(existingPage), Times.Once());
}
