public void AccountService_DeleteUserAccountAsync_UnsuccessfulDeletion()
{
var loggedInUser = new User
{
Id = "1243435",
Name = "Test User",
Email = "*****@*****.**",
UserName = "******"
};
var mockRestaurantRepo = Mock.Of <IRepository <Restaurant> >();
var mockRestaurantTagRepo = Mock.Of <IRepository <RestaurantTag> >();
var mockTagRepo = Mock.Of <IRepository <Tag> >();
var mockUserProvider = new MockUserProvider().MockGetLoggedInUserAsync(loggedInUser);
_mockUserManager.Setup(x => x.DeleteAsync(It.IsAny <User>()))
.ReturnsAsync(IdentityResult.Failed());
_mockSignInManager.Setup(x => x.CheckPasswordSignInAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <bool>()))
.ReturnsAsync(SignInResult.Success);
var accountService = new AccountService(_mockUserManager.Object, _mockSignInManager.Object, mockRestaurantRepo, mockRestaurantTagRepo, mockTagRepo, mockUserProvider.Object);
string deleteResult = accountService.DeleteUserAccountAsync("Password123_1").Result;
Assert.Equal("Error deleting account", deleteResult);
}
protected override void SeedData(ObjectConfigContext context, MockUserProvider userProvider)
{
Application app1 = DataSeed.Application1;
Application app2 = DataSeed.Application2;
ObjectConfig.Data.User viewer = DataSeed.UserViewer1;
ObjectConfig.Data.User admin = DataSeed.UserAdmin1;
context.UsersApplications.Add(new UsersApplications(viewer, app1, ApplicationRole.Viewer));
context.UsersApplications.Add(new UsersApplications(userProvider.User, app1, ApplicationRole.Administrator));
context.UsersApplications.Add(new UsersApplications(userProvider.User, app2, ApplicationRole.Viewer));
ObjectConfig.Data.Environment env1 = DataSeed.Environment1(app1);
ObjectConfig.Data.Environment env2 = DataSeed.Environment2(app1);
ForUpdateEnv = DataSeed.Environment3(app1);
context.UsersEnvironments.Add(new UsersEnvironments(admin, env1, EnvironmentRole.Editor));
context.UsersEnvironments.Add(new UsersEnvironments(admin, env2, EnvironmentRole.Editor));
context.UsersEnvironments.Add(new UsersEnvironments(admin, ForUpdateEnv, EnvironmentRole.Editor));
context.UsersEnvironments.Add(new UsersEnvironments(userProvider.User, env1, EnvironmentRole.TargetEditor));
context.UsersEnvironments.Add(new UsersEnvironments(userProvider.User, env2, EnvironmentRole.TargetEditor));
context.UsersEnvironments.Add(new UsersEnvironments(userProvider.User, ForUpdateEnv, EnvironmentRole.TargetEditor));
_app2Env1 = DataSeed.Environment1(app2);
context.UsersEnvironments.Add(new UsersEnvironments(admin, _app2Env1, EnvironmentRole.Editor));
}
public async Task AdminController_AddInvalidRestaurant()
{
var loggedInUser = new User
{
Id = "1234567890",
Name = "Test User",
Email = "*****@*****.**",
UserName = "******"
};
var restaurant = new Restaurant
{
Website = "https://www.testrestaurant.com",
Menu = "https://www.testrestaurant.com/menu",
PhoneNumber = "(215) 555 - 5555",
TagString = "Burgers,Fries,Beer"
};
await Assert.ThrowsAsync <System.ComponentModel.DataAnnotations.ValidationException>(async() =>
{
var mockAdminService = new MockAdminService().MockAddRestaurant(restaurant);
var loggerMoq = Mock.Of <ILogger <AdminController> >();
var userProviderMoq = new MockUserProvider().MockGetLoggedInUserAsync(loggedInUser);
var controller = new AdminController(userProviderMoq.Object, loggerMoq, mockAdminService.Object);
await controller.AddRestaurant(restaurant);
});
}
protected override void SeedData(ObjectConfigContext context, MockUserProvider userProvider)
{
Application app1 = DataSeed.Application1;
ObjectConfig.Data.User viewer = DataSeed.UserViewer1;
context.UsersApplications.Add(new UsersApplications(viewer, app1, ApplicationRole.Viewer));
}
protected override void SeedData(ObjectConfigContext context, MockUserProvider userProvider)
{
Application app1 = DataSeed.Application1;
Application app2 = DataSeed.Application2;
User viewer = DataSeed.UserViewer1;
User admin = DataSeed.UserAdmin1;
context.UsersApplications.Add(new UsersApplications(viewer, app1, ApplicationRole.Viewer));
context.UsersApplications.Add(new UsersApplications(userProvider.User, app1,
ApplicationRole.Administrator));
context.UsersApplications.Add(new UsersApplications(userProvider.User, app2, ApplicationRole.Viewer));
_env1 = DataSeed.Environment1(app1);
_env2 = DataSeed.Environment2(app1);
context.UsersEnvironments.Add(new UsersEnvironments(admin, _env1, EnvironmentRole.Editor));
context.UsersEnvironments.Add(new UsersEnvironments(admin, _env2, EnvironmentRole.Editor));
context.UsersEnvironments.Add(new UsersEnvironments(userProvider.User, _env1, EnvironmentRole.TargetEditor));
context.UsersEnvironments.Add(new UsersEnvironments(userProvider.User, _env2, EnvironmentRole.Editor));
_env1.CreateConfig("conf1");
_env1.CreateConfig("conf2");
_env1.CreateConfig("conf3");
}
public async Task HomeController_Index_ListTagsForUser()
{
var mockUserProvider = new MockUserProvider().MockGetLoggedInUserAsync(_loggedInUser);
var mockLogger = Mock.Of <ILogger <HomeController> >();
var mockHomeService = new MockHomeService();
var tags = new List <Tag>
{
new Tag {
TagId = 1, Name = "tag1"
},
new Tag {
TagId = 2, Name = "tag2"
},
new Tag {
TagId = 3, Name = "tag3"
}
};
mockHomeService.MockGetUserTags(tags);
var restaurants = new List <Restaurant>
{
new Restaurant {
RestaurantId = 1, Name = "Restaurant 1"
},
new Restaurant {
RestaurantId = 2, Name = "Restaurant 2"
},
new Restaurant {
RestaurantId = 3, Name = "Restaurant 3"
},
new Restaurant {
RestaurantId = 4, Name = "Restaurant 4"
},
new Restaurant {
RestaurantId = 5, Name = "Restaurant 5"
}
};
mockHomeService.MockGetUserRestaurants(restaurants);
var homeController = new HomeController(mockUserProvider.Object, mockLogger, mockHomeService.Object);
homeController.TempData = _tempData;
var result = await homeController.Index();
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.Randomizer>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.Randomizer>(model);
Assert.Equal(3, model.Tags.Count);
Assert.Equal(5, model.RestaurantCount);
}
protected override void SeedData(ObjectConfigContext context, MockUserProvider userProvider)
{
Application app1 = DataSeed.Application1;
Application app2 = DataSeed.Application2;
ObjectConfig.Data.User viewer = DataSeed.UserViewer1;
ObjectConfig.Data.User admin = DataSeed.UserAdmin1;
context.UsersApplications.Add(new UsersApplications(viewer, app1, ApplicationRole.Viewer));
context.UsersApplications.Add(new UsersApplications(admin, app2, ApplicationRole.Administrator));
context.UsersApplications.Add(new UsersApplications(userProvider.User, app1, ApplicationRole.Administrator));
}
public void HomeService_GetUserRestaurants_ReturnsList()
{
var mockRestaurantRespository = new MockRepository <Restaurant>().MockGet(_restaurants.AsQueryable());
var mockRestaurantTagRespository = Mock.Of <IRepository <RestaurantTag> >();
var mockUserProvider = new MockUserProvider().MockGetUserId(_loggedInUser.Id);
var homeService = new HomeService(mockRestaurantRespository.Object, mockRestaurantTagRespository, mockUserProvider.Object);
var result = homeService.GetUserRestaurants();
Assert.IsType <List <Restaurant> >(result.ToList());
Assert.Equal(2, (int)result.Count());
}
public async Task HomeController_Index_GetsRestaurantWithNoTags()
{
var mockUserProvider = new MockUserProvider().MockGetLoggedInUserAsync(_loggedInUser);
var mockLogger = Mock.Of <ILogger <HomeController> >();
var mockHomeService = new MockHomeService();
var tags = new List <Tag>();
mockHomeService.MockGetUserTags(tags);
var restaurants = new List <Restaurant>
{
new Restaurant {
RestaurantId = 1, Name = "Restaurant 1"
},
new Restaurant {
RestaurantId = 2, Name = "Restaurant 2"
},
new Restaurant {
RestaurantId = 3, Name = "Restaurant 3"
},
new Restaurant {
RestaurantId = 4, Name = "Restaurant 4"
},
new Restaurant {
RestaurantId = 5, Name = "Restaurant 5"
}
};
mockHomeService.MockGetUserRestaurants(restaurants);
_tempData["choice_count"] = 0;
var homeController = new HomeController(mockUserProvider.Object, mockLogger, mockHomeService.Object);
homeController.TempData = _tempData;
var randomizerViewModel = new ViewModel.Randomizer
{
Tags = new List <Tag>()
};
var result = await homeController.Index(randomizerViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.Randomizer>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.Randomizer>(model);
Assert.Contains(model.SelectedRestaurant, restaurants);
}
public void HomeService_GetUserRestaurantsWithTags_ReturnsEmpty()
{
var tags = new List <int>();
var mockRestaurantRespository = Mock.Of <IRepository <Restaurant> >();
var mockRestaurantTagRespository = new MockRepository <RestaurantTag>().MockGet(_restaurantTags.AsQueryable().Where(rt => tags.Contains(rt.TagId) && rt.Restaurant.UserId == _loggedInUser.Id));
var mockUserProvider = new MockUserProvider().MockGetUserId(_loggedInUser.Id);
var homeService = new HomeService(mockRestaurantRespository, mockRestaurantTagRespository.Object, mockUserProvider.Object);
var result = homeService.GetUserRestaurantsWithTags(tags);
Assert.IsType <List <Restaurant> >(result.ToList());
Assert.Equal(0, (int)result.Count());
}
public async Task It_should_get_user()
{
MockUserProvider testUser = new MockUserProvider(UserRole.Viewer);
using TestServer server = TestServer(testUser);
using HttpClient client = server.CreateHttpClient();
HttpResponseMessage result = await client.GetAsync("feature/user");
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
UserDto responseDto = result.Deserialize <UserDto>();
Assert.Equal(testUser._user.DisplayName, responseDto.DisplayName);
Assert.Equal(testUser._user.AccessRole, responseDto.AccessRole);
Assert.Equal(testUser._user.Email, responseDto.Email);
Assert.Equal(testUser._user.ExternalId, responseDto.ExternalId);
Assert.NotEqual(0, responseDto.UserId);
}
protected TestServer TestServer(MockUserProvider userProvider, Action <IServiceCollection> services = null)
{
void InternalAction(IServiceCollection s)
{
services?.Invoke(s);
s.AddSingleton <IUserProvider>(userProvider);
}
TestServer testServer = TestServer(InternalAction);
testServer.CreateClient();
(ObjectConfigContext instance, IServiceScope scope) = testServer.GetInstanceFromScope <ObjectConfigContext>();
instance.Database.EnsureCreated();
SeedData(instance, userProvider);
instance.SaveChanges();
instance.Dispose();
scope.Dispose();
return(testServer);
}
public async Task AdminController_DeleteRestaurant()
{
var loggedInUser = new User
{
Id = "1234567890",
Name = "Test User",
Email = "*****@*****.**",
UserName = "******"
};
var restaurant = new Restaurant
{
Name = "Test Restaurant",
AddressLine1 = "",
AddressLine2 = "",
City = "",
State = "",
ZipCode = "",
Website = "https://www.testrestaurant.com",
Menu = "https://www.testrestaurant.com/menu",
PhoneNumber = "(215) 555 - 5555",
Latitude = 0,
Longitude = 0,
User = loggedInUser,
UserId = loggedInUser.Id,
TagString = "Burgers,Fries,Beer"
};
var mockAdminService = new MockAdminService().MockDeleteRestaurant(restaurant);
mockAdminService.MockGetRestaurantById(restaurant);
var loggerMoq = Mock.Of <ILogger <AdminController> >();
var userProviderMoq = new MockUserProvider().MockGetLoggedInUserAsync(loggedInUser);
var controller = new AdminController(userProviderMoq.Object, loggerMoq, mockAdminService.Object);
var result = (RedirectToActionResult)await controller.DeleteRestaurant(restaurant);
Assert.Equal("Restaurants", result.ActionName);
}
public void AccountService_ChangeUserPasswordAsync_UnsuccessfulChange()
{
var loggedInUser = new User
{
Name = "Test User",
Email = "*****@*****.**",
UserName = "******"
};
var mockRestaurantRepo = Mock.Of <IRepository <Restaurant> >();
var mockRestaurantTagRepo = Mock.Of <IRepository <RestaurantTag> >();
var mockTagRepo = Mock.Of <IRepository <Tag> >();
var mockUserProvider = new MockUserProvider().MockGetLoggedInUserAsync(null);
_mockUserManager.Setup(x => x.ChangePasswordAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
var accountService = new AccountService(_mockUserManager.Object, _mockSignInManager.Object, mockRestaurantRepo, mockRestaurantTagRepo, mockTagRepo, mockUserProvider.Object);
bool successfulChange = accountService.ChangeUserPasswordAsync("Password123_1", "Password123_2").Result;
Assert.False(successfulChange);
}
public async Task HomeController_Index_NoTagsSelected()
{
var mockUserProvider = new MockUserProvider().MockGetLoggedInUserAsync(_loggedInUser);
var mockLogger = Mock.Of <ILogger <HomeController> >();
var mockHomeService = new MockHomeService();
var tags = new List <Tag>
{
new Tag {
TagId = 1, Name = "tag1"
},
new Tag {
TagId = 2, Name = "tag2"
},
new Tag {
TagId = 3, Name = "tag3"
}
};
mockHomeService.MockGetUserTags(tags);
var restaurants = new List <Restaurant>
{
new Restaurant {
RestaurantId = 1, Name = "Restaurant 1"
},
new Restaurant {
RestaurantId = 2, Name = "Restaurant 2"
},
new Restaurant {
RestaurantId = 3, Name = "Restaurant 3"
},
new Restaurant {
RestaurantId = 4, Name = "Restaurant 4"
},
new Restaurant {
RestaurantId = 5, Name = "Restaurant 5"
}
};
mockHomeService.MockGetUserRestaurantsWithTags(restaurants);
_tempData["choice_count"] = 0;
var homeController = new HomeController(mockUserProvider.Object, mockLogger, mockHomeService.Object);
homeController.TempData = _tempData;
var randomizerViewModel = new ViewModel.Randomizer
{
Tags = new List <Tag>
{
new Tag {
TagId = 1, Name = "tag1", Selected = false
},
new Tag {
TagId = 2, Name = "tag2", Selected = false
},
new Tag {
TagId = 3, Name = "tag3", Selected = false
}
}
};
var result = await homeController.Index(randomizerViewModel);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.Randomizer>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.Randomizer>(model);
Assert.Equal("Please select at least one tag", model.ErrorMessage);
}
protected virtual void SeedData(ObjectConfigContext context, MockUserProvider userProvider)
{
}
public async Task AdminController_ListRestaurants()
{
var mockRestaurantsList = new List <Restaurant>
{
new Restaurant {
RestaurantId = 1,
Name = "Restaurant One",
RestaurantTags = new List <RestaurantTag>
{
new RestaurantTag
{
RestaurantId = 1,
Tag = new Tag
{
Name = "Mexican"
}
},
new RestaurantTag
{
RestaurantId = 1,
Tag = new Tag
{
Name = "Tacos"
}
}
}
},
new Restaurant {
RestaurantId = 2,
Name = "Restaurant Two",
RestaurantTags = new List <RestaurantTag>
{
new RestaurantTag
{
RestaurantId = 2,
Tag = new Tag
{
Name = "Italian"
}
},
new RestaurantTag
{
RestaurantId = 2,
Tag = new Tag
{
Name = "Pasta"
}
}
}
},
};
var mockAdminService = new MockAdminService().MockGetUserRestaurants(mockRestaurantsList);
var mockLogger = Mock.Of <ILogger <AdminController> >();
var mockUserProvider = new MockUserProvider().MockGetLoggedInUserAsync(new User {
Id = "12345", Name = "Test User", Email = "*****@*****.**"
});
var controller = new AdminController(mockUserProvider.Object, mockLogger, mockAdminService.Object);
controller.TempData = _tempData;
var result = await controller.Restaurants();
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ViewModel.RestaurantAdmin>(viewResult.ViewData.Model);
Assert.IsType <ViewModel.RestaurantAdmin>(model);
Assert.Equal(2, model.Restaurants.Count);
}
/// <summary>
/// Configure virtual app server and seed data
/// </summary>
/// <param name="userRole">use provider role</param>
/// <param name="services">func for mock configure</param>
/// <returns>Configured testserver</returns>
protected virtual TestServer TestServer(UserRole userRole, Action <IServiceCollection> services = null)
{
MockUserProvider userProvider = new MockUserProvider(userRole);
return(TestServer(userProvider, services));
}
