public ShoppingListHub(IUserContext userContext, IShoppingListService shoppingListService, IListItemService listItemService, IUserService userService)
{
_userContext = userContext;
_shoppingListService = shoppingListService;
_listItemService = listItemService;
_userService = userService;
}
public async void ShouldReturnAnOkResultWhenTheUpdateIsSuccessful()
{
var updatedShoppingList = new ShoppingList
{
ShoppingListId = 1,
Name = "Test",
CreatedAt = DateTime.Now,
LastUpdated = DateTime.Now
};
var mockRepository = new Mock <IRepository <ShoppingList> >();
_service = new ShoppingListService(mockRepository.Object);
_controller = new ShoppingListController(_service);
IActionResult result = await _controller.UpdateShoppingList(updatedShoppingList);
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().BeAssignableTo <IApiResponse>()
.Which.Should().Match <IApiResponse>(response =>
response.StatusCode == HttpStatusCode.OK &&
response.Message == null &&
response.Result == null);
}
public ShoppingListsController(IUserContext userContext, IShoppingListService shoppingListService, IUserService userService, IPermissionTypeService permissionTypeService)
{
_userContext = userContext;
_shoppingListService = shoppingListService;
_userService = userService;
_permissionTypeService = permissionTypeService;
}
public void Init()
{
myRecipeDataAdapter = NSubstitute.Substitute.For <IRecipeDataAdapter>();
myProductAdapter = NSubstitute.Substitute.For <IProductDataAdapter>();
myShoppingListService = NSubstitute.Substitute.For <IShoppingListService>();
myService = new RecipeService(myRecipeDataAdapter, myProductAdapter, myShoppingListService);
}
public async void ShouldReturnAllShoppingLists()
{
IEnumerable <ShoppingList> shoppingLists = new List <ShoppingList>
{
Mock.Of <ShoppingList>(),
Mock.Of <ShoppingList>(),
Mock.Of <ShoppingList>()
};
var mockRepository = new Mock <IRepository <ShoppingList> >();
mockRepository.Setup(mock => mock.GetAllAsync())
.ReturnsAsync(shoppingLists);
_repository = mockRepository.Object;
_service = new ShoppingListService(_repository);
_controller = new ShoppingListController(_service);
IActionResult result = await _controller.GetAllShoppingListsAsync();
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().BeAssignableTo <IApiResponse>()
.Which.Result.Should().BeAssignableTo <IEnumerable <ShoppingList> >()
.Which.Count().Should().Be(3);
}
public async void ShouldReturnTheANewlyCreatedShoppingList()
{
var shoppingList = new ShoppingList
{
ShoppingListId = 1,
Name = "Test",
CreatedAt = DateTime.Now,
LastUpdated = DateTime.Now
};
var apiResponse = new ApiResponse(HttpStatusCode.Created)
{
Result = shoppingList
};
var mockService = new Mock <IShoppingListService <IApiResponse> >();
mockService.Setup(mock => mock.AddAsync(shoppingList.Name))
.ReturnsAsync(apiResponse);
_service = mockService.Object;
_controller = new ShoppingListController(_service);
IActionResult result = await _controller.AddNewShoppingList(shoppingList.Name);
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().BeAssignableTo <IApiResponse>()
.Which.Should().Match <IApiResponse>(response =>
response.StatusCode == HttpStatusCode.Created &&
response.Message == null &&
response.Result != null);
}
public HomeController()
{
ProductService = new ProductService();
ShoppingListService = new ShoppingListService();
ClientService = new ClientService();
ItemShoppingService = new ItemShoppingService();
}
public async void ShouldReturnAShoppingListWhenItExists()
{
var shoppingList = new ShoppingList
{
ShoppingListId = 1,
Name = "Test",
CreatedAt = DateTime.UtcNow,
LastUpdated = DateTime.UtcNow
};
var mockRepository = new Mock <IRepository <ShoppingList> >();
mockRepository.Setup(mock => mock.FindAsync(3))
.ReturnsAsync(shoppingList);
_repository = mockRepository.Object;
_service = new ShoppingListService(_repository);
_controller = new ShoppingListController(_service);
IActionResult result = await _controller.FindShoppingListAsync(3);
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().BeAssignableTo <IApiResponse>()
.Which.Should().Match <IApiResponse>(response =>
response.StatusCode == HttpStatusCode.OK &&
response.Message == null &&
response.Result != null);
}
public FavouriteProductTypeViewModel(ISimpleAuthService simpleAuthService, IShoppingListService shoppingListService) : base(simpleAuthService)
{
_shoppingListService = shoppingListService;
ProductTypes = new ObservableCollection <ProductType>();
RegisterCommand();
}
public HomeController()
{
ProductService = new ProductService();
ShoppingListService = new ShoppingListService();
ClientService = new ClientService();
ItemShoppingService = new ItemShoppingService();
}
public RecipeService(
IDeletableEntityRepository <Recipe> recipeRepository,
ICategoryService categoryService,
ILifestyleService lifestyleService,
IRecipeLifestyleService recipeLifestyleService,
IUserService userService,
IShoppingListService shoppingListService,
IUserShoppingListService userShoppingListService,
INutritionalValueService nutritionalValueService,
IAllergenService allergenService,
IRecipeAllergenService recipeAllergenService,
IUserFavoriteRecipeService userFavoriteRecipeService,
IUserCookedRecipeService userCookedRecipeService,
IUserAllergenService userAllergenService,
IStringFormatService stringFormatService,
IEnumParseService enumParseService)
{
this.recipeRepository = recipeRepository;
this.categoryService = categoryService;
this.lifestyleService = lifestyleService;
this.recipeLifestyleService = recipeLifestyleService;
this.userService = userService;
this.shoppingListService = shoppingListService;
this.userShoppingListService = userShoppingListService;
this.nutritionalValueService = nutritionalValueService;
this.allergenService = allergenService;
this.recipeAllergenService = recipeAllergenService;
this.userFavoriteRecipeService = userFavoriteRecipeService;
this.userCookedRecipeService = userCookedRecipeService;
this.userAllergenService = userAllergenService;
this.stringFormatService = stringFormatService;
this.enumParseService = enumParseService;
}
public ShoppingListComponent(ShoppingListViewModel viewModel, IShoppingListService service)
{
Guard.NotNull(viewModel, nameof(viewModel));
Guard.NotNull(service, nameof(service));
this.viewModel = viewModel;
this.service = service;
OnInit();
}
public ShoppingListViewModel(
IShoppingListService shoppingListService,
EditShoppingListViewModel editShoppingListViewModel)
{
_shoppingListService = shoppingListService;
_editShoppingListViewModel = editShoppingListViewModel;
}
public EditShoppingListViewModel(IShoppingListService shoppingListService, IRecipeService recipeService)
{
_shoppingListService = shoppingListService;
_recipeService = recipeService;
_ingredientDTO = new IngredientDTO
{
Ingredients = _recipeService.GetIngredients(),
UnitsOfMeasurement = _recipeService.GetUnits()
};
}
public ShoppingListsController(
IShoppingListService shoppingListService,
IRecipeService recipeService,
IUserService userService,
IUserShoppingListService userShoppingListService,
IStringFormatService stringFormatService)
{
this.shoppingListService = shoppingListService;
this.recipeService = recipeService;
this.userService = userService;
this.userShoppingListService = userShoppingListService;
this.stringFormatService = stringFormatService;
}
public UserService(
UserManager <ApplicationUser> userManager,
IDeletableEntityRepository <ApplicationUser> userRepository,
ILifestyleService lifestyleService,
IAllergenService allergenService,
IUserAllergenService userAllergenService,
IShoppingListService shoppingListService)
{
this.userManager = userManager;
this.userRepository = userRepository;
this.lifestyleService = lifestyleService;
this.allergenService = allergenService;
this.userAllergenService = userAllergenService;
this.shoppingListService = shoppingListService;
}
public async void ShouldReturnABadRequestResultWhenAnEmptyStringIsPassed(string data)
{
_service = Mock.Of <IShoppingListService <IApiResponse> >();
_controller = new ShoppingListController(_service);
IActionResult result = await _controller.AddNewShoppingList(data);
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().BeAssignableTo <IApiResponse>()
.Which.Should().Match <IApiResponse>(response =>
response.StatusCode == HttpStatusCode.BadRequest &&
response.Message.Equals("The shopping list must have a name.") &&
response.Result == null);
}
public async void ShouldReturnABadRequestWhenTheUpdatedShoppingListIsNull()
{
_service = Mock.Of <IShoppingListService <IApiResponse> >();
_controller = new ShoppingListController(_service);
IActionResult result = await _controller.UpdateShoppingList(null);
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().BeAssignableTo <IApiResponse>()
.Which.Should().Match <IApiResponse>(response =>
response.StatusCode == HttpStatusCode.BadRequest &&
response.Result == null &&
response.Message.Equals("Cannot update an invalid shopping list."));
}
public HomeViewModel(
IRecipeService recipeService,
ICategoryService categoryService,
IShoppingListService shoppingListService,
RecipeViewModel recipeViewModel,
ShoppingListViewModel shoppingListViewModel)
{
_recipeService = recipeService;
_categoryService = categoryService;
_shoppingListService = shoppingListService;
_recipeViewModel = recipeViewModel;
_shoppingListViewModel = shoppingListViewModel;
RecipesView = CollectionViewSource.GetDefaultView(Recipes);
RecipesView.Filter = Filter;
}
public async void ShouldReturnABadRequestResultWhenTheIdIsNull()
{
_repository = Mock.Of <IRepository <ShoppingList> >();
_service = new ShoppingListService(_repository);
_controller = new ShoppingListController(_service);
IActionResult result = await _controller.FindShoppingListAsync(null);
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().BeAssignableTo <IApiResponse>()
.Which.Should().Match <IApiResponse>(response =>
response.StatusCode == HttpStatusCode.BadRequest &&
response.Result == null &&
response.Message.Equals("The shopping list you are looking for is not valid."));
}
public void Setup()
{
_shoppingListItems = TestHelper.GetAllItems();
var data = _shoppingListItems.AsQueryable();
var mockSet = new Mock <DbSet <Item> >();
mockSet.Setup(m => m.AddRange(data));
mockSet.As <IQueryable <Item> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Item> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <Item> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <Item> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <ShoppingListDbContext>();
mockContext.Setup(c => c.Items).Returns(mockSet.Object);
_shoppingListRepository = new ShoppingListRepository(mockContext.Object);
_shoppingListService = new ShoppingListService(_shoppingListRepository);
}
public async void ShouldCallTheRepositoryOnceWhenUpdatingAShoppingList()
{
var updatedShoppingList = new ShoppingList
{
ShoppingListId = 1,
Name = "Test",
CreatedAt = DateTime.Now,
LastUpdated = DateTime.Now
};
var mockRepository = new Mock <IRepository <ShoppingList> >();
_service = new ShoppingListService(mockRepository.Object);
_controller = new ShoppingListController(_service);
await _controller.UpdateShoppingList(updatedShoppingList);
mockRepository.Verify(mock => mock.UpdateAsync(updatedShoppingList), Times.Once);
}
public async void ShouldReturnANotFoundResultWhenTheShoppingListDoesNotExist()
{
var mockRepository = new Mock <IRepository <ShoppingList> >();
mockRepository.Setup(mock => mock.FindAsync(3))
.ReturnsAsync(value: null);
_repository = mockRepository.Object;
_service = new ShoppingListService(_repository);
_controller = new ShoppingListController(_service);
IActionResult result = await _controller.FindShoppingListAsync(3);
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().BeAssignableTo <IApiResponse>()
.Which.Should().Match <IApiResponse>(response =>
response.StatusCode == HttpStatusCode.NotFound &&
response.Message == null &&
response.Result == null);
}
public ShoppingListController(IShoppingListService shoppingListService)
{
_shoppingListService = shoppingListService;
}
public ShoppingListHandler()
{
_shoppingListService = new ShoppingListService();
// temp!
}
public ShoppingListsController(IUserContext userContext, IShoppingListService shoppingListService, IUserService userService)
{
_userContext = userContext;
_shoppingListService = shoppingListService;
_userService = userService;
}
public CurrentShoppingListController(IShoppingListService shoppingListService)
{
this._shoppingListService = shoppingListService;
}
public ShoppingListsController(IShoppingListService service, IMapper mapper, ILogger <ShoppingListsController> logger)
{
_service = service;
_mapper = mapper;
_logger = logger;
}
public ShoppingController(IShoppingListService dataSource)
{
_data = dataSource;
}
public ShoppingListController(IJwtTokenService jwtTokenService, IShoppingListService shoppingListService)
{
_jwtTokenService = jwtTokenService;
_shoppingListService = shoppingListService;
}
public ShoppingListController(IShoppingListService shoppingListService, IUserService userService)
{
_shoppingListService = shoppingListService;
_userService = userService;
}
public ShoppingListsController(IShoppingListService service)
{
this.service = service;
}
public WeeklyMenuService(IUnitOfWork unitOfWork, IShoppingListService shoppingListService)
{
_unitOfWork = unitOfWork;
_shoppingListService = shoppingListService;
}
