public async Task UpdateProfile_ProfileUpdated_Success()
{
// Arrange
var updateProfileDTO = DummyData.UpdateProfileDTOFaker.Generate();
var user = DummyData.UserFaker.Generate();
var appUser = FakeAppUser.For(user);
_updateProfileValidator.SetupPass();
_um.FindByNameAsync(appUser.Email).Returns(appUser);
_um.UpdateAsync(appUser).Returns(IdentityResult.Success);
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
// Act
var result = await _sut.Update(updateProfileDTO);
// Assert
result.Should().BeOfType <OkObjectResult>()
.Which.Value.Should().BeEquivalentTo(
updateProfileDTO,
options => options.Excluding(u => u.Friends)
);
_userRepository.Received().Update(user);
}
public void Post_LoggedInUserWithGoodRoute_ShouldRegisterAndReturnsOk()
{
// Arrange
var route = DummyData.RouteFaker.Generate();
var user = DummyData.UserFaker.Generate();
var routeRegistrationDTO = DummyData.RouteRegistrationDTOFaker.Generate();
routeRegistrationDTO.OrderedShirt = true;
routeRegistrationDTO.RouteId = route.Id;
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
_routeRepository.GetBy(route.Id).Returns(route);
_validator.SetupPass();
// Act
var numberOfRegistrations = user.Registrations.Count;
var result = _sut.Post(routeRegistrationDTO);
// Assert
result.Should().BeOfType<OkObjectResult>()
.Which.Value.Should().BeEquivalentTo(
routeRegistrationDTO,
options => options.Using(new EnumAsStringAssertionRule()) //treat enums as strings
);
_userRepository.Received().GetBy(user.Email);
_routeRepository.Received().GetBy(route.Id);
//registration is added to user
user.Registrations.Count.Should().Be(numberOfRegistrations + 1);
}
public void Post_ValidationFailed_ReturnsBadRequest()
{
// Arrange
var route = DummyData.RouteFaker.Generate();
var user = DummyData.UserFaker.Generate();
var routeRegistrationDTO = DummyData.RouteRegistrationDTOFaker.Generate();
routeRegistrationDTO.OrderedShirt = true;
routeRegistrationDTO.RouteId = route.Id;
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
_routeRepository.GetBy(route.Id).Returns(route);
_validator.SetupFail();
// Act
var numberOfRegistrations = user.Registrations.Count;
var result = _sut.Post(routeRegistrationDTO);
// Assert
result.Should().BeOfType<BadRequestObjectResult>()
.Which.Value.Should().BeOfType<ValidationResult>()
.Which.IsValid.Should().BeFalse();
_userRepository.DidNotReceive().GetBy(user.Email);
user.Registrations.Count.Should().Be(numberOfRegistrations);
}
public void GetCurrentUserAreasShouldReturnProperResult()
{
var userId = Guid.NewGuid().ToString();
var request = new Mock <HttpRequestBase>();
request.SetupGet(x => x.IsAuthenticated).Returns(true);
var areasFake = new Mock <IAreasServices>();
areasFake.Setup(a => a.GetByUserId(It.IsAny <string>())).Returns(areas);
var recordsFake = new Mock <IRecordsServices>().Object;
var documentsFake = new Mock <IDocumentsServices>().Object;
var usersFake = new Mock <IUsersServices>().Object;
request.SetupGet(x => x.IsAuthenticated).Returns(false);
var controller = new AreasController(areasFake.Object, recordsFake, documentsFake, usersFake)
{
ControllerContext = FakeControllerContext.GetFakeControllerContextWithFakeIdentity()
};
Mapper.CreateMap <Area, AreaShortViewModel>();
Mapper.CreateMap <Area, AreaListViewModel>();
Mapper.CreateMap <User, UserShortViewModel>();
ViewResult viewResult = controller.Index() as ViewResult;
controller.WithCallTo(c => c.GetCurrentUserAreas())
.ShouldRenderPartialView("_UserAreasDropDownList")
.WithModel <List <AreaShortViewModel> >(x => Assert.AreEqual(4, x.Count()));
}
public static HtmlHelper <TModel> GetHtmlHelper <TModel>(
TModel model, ControllerBase controller, bool clientValidationEnabled)
{
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new FakeViewEngine());
var httpContext = new FakeHttpContext();
var viewData = new FakeViewDataContainer {
ViewData = new ViewDataDictionary <TModel>(model)
};
var routeData = new RouteData();
routeData.Values["controller"] = "home";
routeData.Values["action"] = "index";
ControllerContext controllerContext = new FakeControllerContext(controller);
var viewContext = new FakeViewContext(controllerContext, "MyView", routeData);
viewContext.HttpContext = httpContext;
viewContext.ClientValidationEnabled = clientValidationEnabled;
viewContext.UnobtrusiveJavaScriptEnabled = clientValidationEnabled;
viewContext.FormContext = new FakeFormContext();
HtmlHelper <TModel> htmlHelper = new HtmlHelper <TModel>(viewContext, viewData);
return(htmlHelper);
}
public async Task Delete_NoSuchRegistration_ReturnsBadRequest()
{
// Arrange
var user = DummyData.UserFaker.Generate();
var registrationId = Guid.NewGuid();
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
_registrationRepository.GetBy(Arg.Any<Guid>(), user.Email).ReturnsNull();
var appUser = FakeAppUser.For(user).WithClaims("admin");
_um.FindByNameAsync(user.Email).Returns(Task.FromResult(appUser));
// Act
var numberOfRegistrations = user.Registrations.Count;
var result = await _sut.DeleteAsync(registrationId);
// Assert
result.Should().BeOfType<BadRequestResult>();
user.Registrations.Count.Should().Be(numberOfRegistrations);
_userRepository.Received().GetBy(user.Email);
_registrationRepository.Received().GetBy(registrationId, user.Email);
_registrationRepository.DidNotReceive().Delete(Arg.Any<Registration>(), user.Email);
}
public async Task Delete_LoggedInUserWithGoodRegistration_ShouldDeleteRegistrationAndReturnsOk()
{
// Arrange
var user = DummyData.UserFaker.Generate();
var registration = user.Registrations.Last();
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
_registrationRepository.GetBy(registration.Id, user.Email).Returns(registration);
var appUser = FakeAppUser.For(user).WithClaims("admin");
_um.FindByNameAsync(user.Email).Returns(Task.FromResult(appUser));
// Act
var result = await _sut.DeleteAsync(registration.Id);
// Assert
result.Should().BeOfType<OkObjectResult>()
.Which.Value.Should().BeEquivalentTo(
registration,
options => options.Using(new EnumAsStringAssertionRule()) //treat enums as strings
);
_userRepository.Received().GetBy(user.Email);
_registrationRepository.Received().Delete(registration, user.Email);
}
public void Post_RouteNotFound_ReturnsBadRequest()
{
// Arrange
var route = DummyData.RouteFaker.Generate();
var user = DummyData.UserFaker.Generate();
var routeRegistrationDTO = DummyData.RouteRegistrationDTOFaker.Generate();
routeRegistrationDTO.OrderedShirt = true;
routeRegistrationDTO.RouteId = route.Id;
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
_routeRepository.GetBy(route.Id).ReturnsNull(); //!
_validator.SetupPass();
// Act
var numberOfRegistrations = user.Registrations.Count;
var result = _sut.Post(routeRegistrationDTO);
// Assert
result.Should().BeOfType<NotFoundObjectResult>();
_userRepository.Received().GetBy(user.Email);
_routeRepository.Received().GetBy(route.Id);
user.Registrations.Count.Should().Be(numberOfRegistrations);
}
public void GetProfile_UserLoggedIn_ReturnsBadRequestResult()
{
// Arrange
var user = DummyData.UserFaker.Generate();
_sut.ControllerContext = FakeControllerContext.GetLoggedInUserContextFor(user);
_userRepository.GetBy(user.Email).ReturnsNull();
// Act
var result = _sut.Get();
// Assert
result.Should().BeOfType <BadRequestResult>();
}
public async Task DeleteProfile_UserNotFound_FailsAndReturnsBadRequestResult()
{
// Arrange
var user = DummyData.UserFaker.Generate();
_sut.ControllerContext = FakeControllerContext.GetLoggedInUserContextFor(user);
_userRepository.GetBy(user.Email).ReturnsNull();
// Act
var result = await _sut.Delete();
// Assert
result.Should().BeOfType <BadRequestResult>();
}
public void GetProfile_UserLoggedIn_ReceivesUser()
{
// Arrange
var user = DummyData.UserFaker.Generate();
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
// Act
var meResult = _sut.Get();
// Assert
meResult.Should().BeOfType <OkObjectResult>();
_userRepository.Received().GetBy(user.Email);
}
public void IndexListNothing()
{
var fishRepository = new FishRepositoryMock().GetUserRepoMockedInstance();
var fishController = new FishController(fishRepository)
{
ControllerContext = FakeControllerContext.GetContextWithMockedNullSession()
};
var result = fishController.Index();
Assert.IsInstanceOfType(result, typeof(ViewResult));
var model = (FishListViewModel)((ViewResult)result).Model;
Assert.AreEqual(null, model.Fishes);
}
public void GetProfile_UserLoggedIn_ReturnsUser()
{
// Arrange
var user = DummyData.UserFaker.Generate();
_sut.ControllerContext = FakeControllerContext.GetLoggedInUserContextFor(user);
_userRepository.GetBy(user.Email).Returns(user);
// Act
var result = _sut.Get();
// Assert
result.Should().BeOkObjectEquivalentTo(user.MapToDTO());
_userRepository.Received().GetBy(user.Email);
}
public async Task UpdateProfile_ValidationFailed_ShouldReturnBadRequest()
{
// Arrange
var updateProfileDTO = DummyData.ProfileDTOFaker.Generate();
var user = DummyData.UserFaker.Generate();
_sut.ControllerContext = FakeControllerContext.GetLoggedInUserContextFor(user);
_profileValidator.SetupFail();
// Act
var result = await _sut.Update(updateProfileDTO);
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
}
public void Logout()
{
var userRepository = new UserRepositoryMock().GetUserRepoMockedInstance();
var authProvider = new Mock <FormsAuthProvider>();
authProvider.Setup(m => m.SignOut());
var accountController = new AccountController(authProvider.Object, userRepository)
{
ControllerContext = FakeControllerContext.GetContextWithMockedSession()
};
var result = accountController.LogOut();
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
}
public void EditWithNoImage()
{
var fishRepository = new FishRepositoryMock().GetUserRepoMockedInstance();
var fishController = new FishController(fishRepository)
{
ControllerContext = FakeControllerContext.GetContextWithMockedSession()
};
var fish = new Fish {
FishId = 1, UserId = 1, Name = "Lüfer", Price = 15.90, ImageData = Encoding.UTF8.GetBytes("LüferFoto"), ImageMimeType = "image/png"
};
var result = fishController.Edit(fish, null);
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
}
public void GetLast_NoRegistrations_ReturnsNotFound()
{
// Arrange
var user = DummyData.UserFaker.Generate();
user.Registrations = new List<Registration>(); //empty
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
_registrationRepository.GetLast(user.Email).ReturnsNull();
//Act
var result = _sut.GetLast();
// Assert
result.Should().BeOfType<NotFoundObjectResult>();
}
public void IndexListAllFishes()
{
var fishRepository = new FishRepositoryMock().GetUserRepoMockedInstance();
var fishController = new FishController(fishRepository)
{
ControllerContext = FakeControllerContext.GetContextWithMockedSession()
};
var result = fishController.Index();
Assert.IsInstanceOfType(result, typeof(ViewResult));
var model = (FishListViewModel)((ViewResult)result).Model;
Assert.AreEqual(3, model.Fishes.Count());
Assert.AreEqual("Lüfer", model.Fishes.ElementAt(0).Name);
Assert.AreEqual("Palamut", model.Fishes.ElementAt(2).Name);
}
public async Task UpdateProfile_UserNotFound_ShouldReturnBadRequest()
{
// Arrange
var updateProfileDTO = DummyData.ProfileDTOFaker.Generate();
var user = DummyData.UserFaker.Generate();
var identityUser = user.MapToIdentityUser();
_um.FindByNameAsync(identityUser.Email).Returns(identityUser);
_profileValidator.SetupPass();
_sut.ControllerContext = FakeControllerContext.GetLoggedInUserContextFor(user);
_userRepository.GetBy(user.Email).ReturnsNull();
// Act
var result = await _sut.Update(updateProfileDTO);
// Assert
result.Should().BeOfType <BadRequestResult>();
}
public void LoginSuccess()
{
var model = new LoginViewModel {
Email = "*****@*****.**", Password = "******"
};
var userRepository = new UserRepositoryMock().GetUserRepoMockedInstance();
var authProvider = new Mock <FormsAuthProvider>();
authProvider.Setup(m => m.Authenticate(model.Email, model.Password)).Returns(true);
var accountController = new AccountController(authProvider.Object, userRepository)
{
ControllerContext = FakeControllerContext.GetContextWithMockedSession()
};
var result = accountController.Login(model, "/Fish/Index");
Assert.IsInstanceOfType(result, typeof(RedirectResult));
}
public async Task DeleteProfile_ProfileDeleted_Succes()
{
// Arrange
var user = DummyData.UserFaker.Generate();
var idUser = FakeAppUser.For(user);
_um.FindByNameAsync(idUser.Email).Returns(idUser);
_um.DeleteAsync(idUser).Returns(IdentityResult.Success);
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
// Act
var result = await _sut.Delete();
// Assert
result.Should().BeOfType <OkResult>();
_userRepository.Received().Delete(user);
}
public void GetAll_AtLeastOneRegistration_ReturnsAllRegistrations()
{
// Arrange
var user = DummyData.UserFaker.Generate();
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
_registrationRepository.GetAllFromUser(user.Email).Returns(user.Registrations);
//Act
var result = _sut.GetAllAsync();
// Assert
result.Should().BeOfType<OkObjectResult>()
.Which.Value.Should().BeEquivalentTo(
user.Registrations,
options => options.Using(new EnumAsStringAssertionRule()) //treat enums as strings
);
}
public void TestServerListHappyPath()
{
// in an actual desktop app this will need to be setup as static
var cookieContainer = new System.Net.CookieContainer();
using (var handler = new System.Net.Http.HttpClientHandler()
{
CookieContainer = cookieContainer
})
using (var client = new System.Net.Http.HttpClient(handler))
{
var header = new NameValueCollection();
header.Add("VpnAuthToken", Setup.token1);
header.Add("VpnUserId", Setup.userid.ToString());
var mock = new Mock <Majorsilence.Vpn.Site.Helpers.ISessionVariables>();
mock.SetupAllProperties();
Majorsilence.Vpn.Site.Helpers.ISessionVariables sessionVars = mock.Object;
var controller = new Majorsilence.Vpn.Site.Controllers.ApiV2Controller(sessionVars);
FakeControllerContext.SetContext(controller, header);
var data = controller.Servers();
Assert.That(controller.Response.StatusCode, Is.EqualTo((int)System.Net.HttpStatusCode.OK));
var deserializedContent = Newtonsoft.Json.JsonConvert.DeserializeObject <IEnumerable <Majorsilence.Vpn.Logic.Accounts.UserServerDetailsInfo> >(data.Content);
Assert.That(deserializedContent.Count() > 1);
var defaultVagrantServer = (from a in deserializedContent
where a.Address == "127.0.0.1" &&
a.VpnServerName == "default vagrant testing vpn authority"
select a);
Assert.That(defaultVagrantServer.Count() == 1);
}
}
public async Task UpdateProfile_ProfileUpdated_Success()
{
// Arrange
var updateProfileDTO = DummyData.ProfileDTOFaker.Generate();
var user = DummyData.UserFaker.Generate();
var identityUser = user.MapToIdentityUser();
_profileValidator.SetupPass();
_um.FindByNameAsync(identityUser.Email).Returns(identityUser);
_um.UpdateAsync(identityUser).Returns(IdentityResult.Success);
_sut.ControllerContext = FakeControllerContext.GetLoggedInUserContextFor(user);
_userRepository.GetBy(user.Email).Returns(user);
// Act
var result = await _sut.Update(updateProfileDTO);
// Assert
result.Should().BeOkObjectEquivalentTo(user.MapToDTO());
_userRepository.Received().Update(user);
_userRepository.Received().SaveChanges();
}
public void CheckCurrentRegistered_LastRouteInPast_ReturnsFalse()
{
// Arrange
var user = DummyData.UserFaker.Generate();
var registration = user.Registrations.Last();
var route = new Route { Date = DateTime.Today.AddDays(-1), Id = registration.RouteId };
_sut.ControllerContext = FakeControllerContext.For(user);
_userRepository.GetBy(user.Email).Returns(user);
_registrationRepository.GetLast(user.Email).Returns(registration);
_routeRepository.GetBy(registration.RouteId).Returns(route);
// Act
var result = _sut.CheckCurrentRegistered();
// Assert
result.Should().BeOfType<OkObjectResult>().Which.Value.Should().Be(false);
_userRepository.Received().GetBy(user.Email);
_registrationRepository.Received().GetLast(user.Email);
_routeRepository.Received().GetBy(registration.RouteId);
}
private void RetrieveLoginTokenAndAssert()
{
var peterAccount = new Majorsilence.Vpn.Logic.Accounts.CreateAccount(
new Majorsilence.Vpn.Logic.Accounts.CreateAccountInfo()
{
Email = emailAddress,
EmailConfirm = emailAddress,
Firstname = "Peter",
Lastname = "Gill",
Password = password,
PasswordConfirm = password,
BetaKey = betaKey
}
, true, Majorsilence.Vpn.Logic.InitializeSettings.Email);
userid = peterAccount.Execute();
// in an actual desktop app this will need to be setup as static
var cookieContainer = new System.Net.CookieContainer();
using (var handler = new System.Net.Http.HttpClientHandler()
{
CookieContainer = cookieContainer
})
using (var client = new System.Net.Http.HttpClient(handler))
{
var byteArray = System.Text.Encoding.UTF8.GetBytes(string.Format("{0}:{1}", emailAddress, password));
var headerAuth = new System.Net.Http.Headers.AuthenticationHeaderValue(
"Basic", Convert.ToBase64String(byteArray));
client.DefaultRequestHeaders.Authorization = headerAuth;
var mock = new Mock <Majorsilence.Vpn.Site.Helpers.ISessionVariables>();
mock.SetupAllProperties();
Majorsilence.Vpn.Site.Helpers.ISessionVariables sessionVars = mock.Object;
var controller = new Majorsilence.Vpn.Site.Controllers.ApiV2Controller(sessionVars);
var header = new NameValueCollection();
header.Add("Authorization", headerAuth.ToString());
// See http://stephenwalther.com/archive/2008/07/01/asp-net-mvc-tip-12-faking-the-controller-context
FakeControllerContext.SetContext(controller, header);
var blah = controller.Auth();
//controller.Auth();
System.Console.WriteLine(blah.Content);
// mock.VerifySet(framework => framework.IsAdmin = true);
Assert.That(sessionVars.LoggedIn, Is.EqualTo(true));
Assert.That(sessionVars.Username, Is.EqualTo(emailAddress));
Assert.That(sessionVars.UserId, Is.EqualTo(userid));
Assert.That(sessionVars.IsAdmin, Is.EqualTo(true));
Assert.That(controller.Response.StatusCode, Is.EqualTo((int)System.Net.HttpStatusCode.OK));
var content = Newtonsoft.Json.JsonConvert.DeserializeObject <Majorsilence.Vpn.Logic.DTO.ApiAuthResponse>(blah.Content);
Assert.That(string.IsNullOrEmpty(content.Token1), Is.EqualTo(false));
Assert.That(string.IsNullOrEmpty(content.Token2), Is.EqualTo(false));
Assert.That(content.Token1ExpireUtc, Is.GreaterThan(DateTime.UtcNow));
Assert.That(content.Token1ExpireUtc, Is.LessThan(DateTime.UtcNow.AddDays(1)));
Assert.That(content.Token2ExpireUtc, Is.GreaterThan(DateTime.UtcNow.AddDays(1)));
Assert.That(content.Token2ExpireUtc, Is.LessThan(DateTime.UtcNow.AddDays(2)));
token1 = content.Token1;
token2 = content.Token2;
// See http://haacked.com/archive/2007/06/19/unit-tests-web-code-without-a-web-server-using-httpsimulator.aspx/
// var responseString = response.Content.ReadAsStringAsync();
}
}
