public void Index_NoUserLoggedInNoFeedback_GivesSessionBasedOnIdAndCorrectViewData()
{
var session = new Session()
{
Id = 21, Title = "Testen testen testen", Description = "We testen live een SessionController klasse uit", Nameguest = "*****@*****.**", Eventdate = new DateTime(), Starthour = DateTime.Now.TimeOfDay.Add(TimeSpan.FromHours(2)), Endhour = DateTime.Now.TimeOfDay.Add(TimeSpan.FromHours(4))
};
_sessionRepository.Setup(m => m.GetById(21)).Returns(session);
IUserRepository.LoggedInUser = null;
var result = Assert.IsType <ViewResult>(_sessionController.Index(21));
var model = Assert.IsType <Session>(result.Model);
Assert.Equal(session.Id, model.Id);
Assert.Equal(session.Title, model.Title);
Assert.Equal(session.Description, model.Description);
Assert.Equal(session.Eventdate, model.Eventdate);
var userLoggedIn = Assert.IsType <bool>(result.ViewData["UserLoggedIn"]);
Assert.False(userLoggedIn);
var sessionIsFinished = Assert.IsType <bool>(result.ViewData["SessionIsFinished"]);
Assert.False(sessionIsFinished);
Assert.Null(result.ViewData["Feedback"]);
}
public void Index_SessionDoesNotExist_MemberExists_ReturnsNotFoundView()
{
_sessionRepository.Setup(sr => sr.GetBy(1)).Returns((Session)null);
_context.SetupGet(c => c.User.Identity.Name).Returns("test");
_memberRepository.Setup(mr => mr.GetBy("test")).Returns(_dummyContext.LoginTest);
var result = Assert.IsType <NotFoundResult>(_sessionController.Index(1));
}
public void Index_NoSessionInProgress()
{
_sessionRepository.Setup(m => m.GetByDateToday()).Returns((Session)null);
var actionResult = _controller.Index() as ViewResult;
var viewModel = actionResult?.Model as IndexViewModel;
Assert.Null(viewModel.Session);
}
public void Index_PassesAllSessionInOrderTest()
{
_mockSessionRepository.Setup(s => s.GetAll()).Returns(_dummyContext.Sessions);
var result = Assert.IsType <ViewResult>(_sessionController.Index());
List <Session> sessions = Assert.IsType <List <Session> >(result.Model);
Assert.Equal(5, sessions.Count);
Assert.Equal("What I Wish I Had Known Before Scaling Uber to 1000 Services", sessions.ElementAt(0).Title);
Assert.Equal("Life is Terrible: Let’s Talk About the Web", sessions.ElementAt(1).Title);
Assert.Equal("De weg naar de Cloud, hoe doen bedrijven dat nu eigenlijk?", sessions.ElementAt(2).Title);
Assert.Equal("Power Use of UNIX - Dan North", sessions.ElementAt(3).Title);
Assert.Equal("TDD, Where Did It All Go Wrong", sessions.ElementAt(4).Title);
}
public async Task IndexReturnsViewResultWithStormSessionViewModel()
{
// Arrange
int testSessionId = 1;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync(_sessions.FirstOrDefault(
s => s.Id == testSessionId));
var controller = new SessionController(mockRepo.Object);
// Act
var result = await controller.Index(testSessionId);
// Assert
Assert.That(result, Is.TypeOf <ViewResult>());
var viewResult = result as ViewResult;
Assert.That(viewResult.ViewData.Model, Is.TypeOf <StormSessionViewModel>());
var model = viewResult.ViewData.Model as StormSessionViewModel;
Assert.AreEqual("Brainstorming opdracht 1", model.Name);
Assert.AreEqual(2, model.DateCreated.Day);
Assert.AreEqual(testSessionId, model.Id);
}
public void Should_use_SessionService_to_fetch_list_of_sessions()
{
theSession = new ConCode.NET.Domain.Session()
{
Id = 1,
Start = DateTime.Now,
Talk = new Talk(),
TalkType = new TalkType(),
Venue = new Venue()
};
theSessionList = new[]
{
theSession
};
var sessionService = new Mock <ISessionService>();
var talkService = new Mock <ITalkService>();
var venueService = new Mock <IVenueService>();
var controller = new SessionController(sessionService.Object, talkService.Object, venueService.Object);
sessionService.Setup(x => x.GetSessions()).Returns(theSessionList.AsQueryable());
var result = (ViewResult)controller.Index();
var model = (SessionListViewModel)result.Model;
Assert.NotNull(model);
Assert.Contains(theSession, model.SessionList);
}
public void Index_WithSessionKey_ReturnsViewResult()
{
var sut = new SessionController();
ActionResult actual = sut.Index("asdf");
Assert.That(actual, Is.TypeOf <ViewResult>());
}
public void Index_WithWitespaceSessionKey_ReturnsNotFoundResult()
{
var sut = new SessionController();
ActionResult actual = sut.Index(" ");
Assert.That(actual, Is.TypeOf <HttpNotFoundResult>());
}
public void ShouldSetHitsOnSession()
{
var builder = new TestControllerBuilder();
var controller = new SessionController();
builder.InitializeController(controller);
controller.Index();
Assert.IsNotNull(controller.Session["hits"]);
}
public void ReturnsARedirectToIndexHomeWhenIdIsNull()
{
var controller = new SessionController(null);
var result = Assert.IsType <RedirectToActionResult>(controller.Index(null));
Assert.Equal("Home", result.ControllerName);
Assert.Equal("Index", result.ActionName);
}
public async Task IndexReturnRedirectToIndexHomeWhenIdIsNull()
{
var controller = new SessionController(sessionRepository: null);
var result = await controller.Index(id : null);
var redirectToAction = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Home", redirectToAction.ControllerName);
Assert.Equal("Index", redirectToAction.ActionName);
}
public void ReturnsContentWithSessionNotFoundWhenSessionNotFound()
{
var mockRepo = new Mock <IBrainStormSessionRepository>();
int testSessionId = 1;
mockRepo.Setup(r => r.GetById(testSessionId))
.Returns((BrainStormSession)null);
var controller = new SessionController(mockRepo.Object);
var result = Assert.IsType <ContentResult>(controller.Index(testSessionId));
Assert.Equal("Session not found.", result.Content);
}
public async Task IndexReturnContentWithSessionNotFoundWhenSessionNotFound()
{
int testSessionId = 1;
var mockRespo = new Mock <IBrainstormSessionRepository>();
mockRespo.Setup(x => x.GetByIdAsync(testSessionId))
.ReturnsAsync((BrainstormSession)null);
var controller = new SessionController(mockRespo.Object);
var result = await controller.Index(testSessionId);
var contentResult = Assert.IsType <ContentResult>(result);
Assert.Equal("Session not found.", contentResult.Content);
}
public async Task IndexReturnsARedirectToIndexHomeWhenIdIsNull()
{
// Arrange
var mockRepo = new Mock <IBrainstormSessionRepository>();
var controller = new SessionController(mockRepo.Object);
// Act
var result = await controller.Index(null);
// Assert
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirectToActionResult.ActionName);
Assert.Equal("Home", redirectToActionResult.ControllerName);
}
public void ReturnsViewResultWithStormSessionViewModel()
{
var mockRepo = new Mock <IBrainStormSessionRepository>();
int testSessionId = 1;
mockRepo.Setup(r => r.GetById(testSessionId))
.Returns(GetTestSessions().FirstOrDefault(s => s.Id == testSessionId));
var controller = new SessionController(mockRepo.Object);
var result = Assert.IsType <ViewResult>(controller.Index(testSessionId));
var model = Assert.IsType <StormSessionViewModel>(result.ViewData.Model);
Assert.Equal("Test One", model.Name);
Assert.Equal(2, model.DateCreated.Day);
Assert.Equal(testSessionId, model.Id);
}
public async Task IndexReturnsARedirectToIndexHomeWhenIdIsNull()
{
// Arrange
var controller = new SessionController(sessionRepository: null);
// Act
var result = await controller.Index(id : null);
// Assert
Assert.That(result, Is.TypeOf <RedirectToActionResult>());
var redirectToActionResult = result as RedirectToActionResult;
Assert.AreEqual("Home", redirectToActionResult.ControllerName);
Assert.AreEqual("Index", redirectToActionResult.ActionName);
}
public async Task IndexReturnsViewResultWithStormSessionViewModel()
{
int testsessionId = 1;
var mockRespo = new Mock <IBrainstormSessionRepository>();
mockRespo.Setup(x => x.GetByIdAsync(testsessionId))
.ReturnsAsync(GetTestSessions().FirstOrDefault(b => b.Id == testsessionId));
var controller = new SessionController(mockRespo.Object);
var result = await controller.Index(testsessionId);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <StormSessionViewModel>(viewResult.ViewData.Model);
Assert.Equal("Test One", model.Name);
Assert.Equal(9, model.DateCreated.Day);
Assert.Equal(testsessionId, model.Id);
}
public async Task SessionController_Index_LogDebugMessages()
{
// Arrange
int testSessionId = 1;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync(GetTestSessions().FirstOrDefault(
s => s.Id == testSessionId));
using var controller = new SessionController(mockRepo.Object);
// Act
await controller.Index(testSessionId);
// Assert
var logEntries = this.appender.GetEvents();
Assert.True(logEntries.Count(l => l.Level == Level.Debug) == 2, "Expected 2 Debug messages in the logs");
}
public async Task IndexReturnsContentWithSessionNotFoundWhenSessionNotFound()
{
// Arrange
int testSessionId = 1;
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
.ReturnsAsync((BrainstormSession)null);
var controller = new SessionController(mockRepo.Object);
// Act
var result = await controller.Index(testSessionId);
// Assert
Assert.That(result, Is.TypeOf <ContentResult>());
var contentResult = result as ContentResult;
Assert.AreEqual("Session not found.", contentResult.Content);
}
public async Task IndexReturnsAViewResultWhenId()
{
int id = 1;
var fixture = new Fixture();
var session = fixture.Create <BrainstormSession>();
var mockRepo = new Mock <IBrainstormSessionRepository>();
mockRepo.Setup(x => x.GetByIdAsync(id)).ReturnsAsync(session);
// Arrange
var controller = new SessionController(mockRepo.Object);
// Act
var result = await controller.Index(id);
// Assert
var redirectToActionResult =
Assert.IsType <ViewResult>(result);
// Assert.Equal("Home", redirectToActionResult.ControllerName);
//Assert.Equal("Index", redirectToActionResult);
}
public void TestIndex_GeeftIndexViewTerug()
{
var result = _controller.Index() as ViewResult;
Assert.Equal("Index", result?.ViewName);
}
