public abstract class LoginContext
    {
        protected Mock<IUserRepository> userRepository;
        protected Mock<ILdapService> ldapService;
        protected Mock<IAuthenticationManager> authenticationManager;
        protected SessionController controller;

        protected LoginContext()
        {
            userRepository = new Mock<IUserRepository>();
            ldapService = new Mock<ILdapService>();
            authenticationManager = new Mock<IAuthenticationManager>();
            controller = new SessionController(ldapService.Object, userRepository.Object, authenticationManager.Object);
        }

    }

    // scenario: attempting to login without a username and password.

    public class WhenSigningInWithoutAUsernameAndPassword: LoginContext
    {
        private ViewResult result;
        public WhenSigningInWithoutAUsernameAndPassword(): base()
        {
            var model = new SessionControllerViewModel();
            result = controller.Index(model) as ViewResult;

        }

        [Fact]
        public void should_display_login_view()
        {
            Assert.NotNull(result);
            Assert.Equal("",result.ViewName);
        }

        [Fact]
        public void should_contain_error_message_to_render()
        {
            var model = result.ViewData.Model as SessionControllerViewModel;
            Assert.NotNull(model);
            Assert.True(model.Errors.Any());
        }
    }


    // scenario: attempting to login with invalid credentials
    public class WhenSigningInWithInvalidCredentials: LoginContext
    {
        private ViewResult result;

        public WhenSigningInWithInvalidCredentials()
        {
            ldapService.Setup(x => x.Authenticate(It.IsAny<string>(), It.IsAny<string>())).Returns((LdapAccount)null);
            var model = new SessionControllerViewModel();
            model.Username = "test";
            model.Password = "password";
            result = controller.Index(model) as ViewResult;

        }

        [Fact]
        public void should_display_login_view()
        {
            Assert.NotNull(result);
            Assert.Equal("",result.ViewName);
        }

        [Fact]
        public void should_contain_error_message_to_render()
        {
            var model = result.ViewData.Model as SessionControllerViewModel;
            Assert.NotNull(model);
            Assert.True(model.Errors.Any());
            Assert.True(model.Errors[0].Contains("Incorrect"));
        }
    }

    // scenario: attempting to login when they're not authorized
    public class WhenSigningInWithoutAuthorizedAccess : LoginContext
    {
        private ViewResult result;

        public WhenSigningInWithoutAuthorizedAccess()
        {
            var model = new SessionControllerViewModel();
            model.Username = "test";
            model.Password = "password";
            var ldapAccount = new LdapAccount() {Username = model.Username};

            ldapService.Setup(x => x.Authenticate(It.IsAny<string>(), It.IsAny<string>())).Returns(ldapAccount);
            userRepository.Setup(x => x.Get(ldapAccount.Username)).Returns((User) null);

            result = controller.Index(model) as ViewResult;

        }

        [Fact]
        public void should_display_login_view()
        {
            Assert.NotNull(result);
            Assert.Equal("", result.ViewName);
        }

        [Fact]
        public void should_contain_error_message_to_render()
        {
            var model = result.ViewData.Model as SessionControllerViewModel;
            Assert.NotNull(model);
            Assert.True(model.Errors.Any());
            Assert.True(model.Errors[0].Contains("access"));
        }
    }

    // scenario: signing in correctly
    public class WhenSigningInWithCorrectAccessAndCredentials: LoginContext
    {
        private RedirectToRouteResult result;
        public WhenSigningInWithCorrectAccessAndCredentials()
        {
            var model = new SessionControllerViewModel();
            model.Username = "test";
            model.Password = "password";
            var ldapAccount = new LdapAccount() { Username = model.Username };
            var user = new User();
            user.Username = model.Username;

            ldapService.Setup(x => x.Authenticate(model.Username, model.Password)).Returns(ldapAccount);
            userRepository.Setup(x => x.Get(ldapAccount.Username)).Returns(user);
            authenticationManager.Setup(x => x.SignIn(user.Username)).AtMostOnce();

            result = controller.Index(model) as RedirectToRouteResult;
        }

        [Fact]
        public void should_signin_the_user()
        {
            authenticationManager.VerifyAll();
        }

        [Fact]
        public void should_redirect_the_user_to_the_main_page()
        {
            Assert.NotNull(result);
            Assert.Equal("Home",result.RouteValues["controller"]);
            Assert.Equal("Index",result.RouteValues["action"]);
        }
    }