public async Task TestGetAllStores()
{
var provider = CommonTestUtils.InitializeDatabaseProvider();
provider.AddStore(new Store()
{
Address = "Test Address1", Name = "TestName1"
});
provider.AddStore(new Store()
{
Address = "Test Address2", Name = "TestName2"
});
await provider.Save();
var controller = new StoresController(provider, CommonTestUtils.InitializeMapper());
var result = controller.GetStores();
var okResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <StoresListResponseDto>(okResult.Value);
Assert.Equal(2, model.Stores.Count);
Assert.Equal(2, model.TotalElements);
Assert.Equal(200, okResult.StatusCode);
return;
}
public async Task AvailableProductsShouldReturnView()
{
// arrange
var mockRepo = new Mock <IUnitOfWork>();
mockRepo.Setup(x => x.StoreRepository.All())
.ReturnsAsync(new List <Store> {
new Store {
StoreId = 1
}
});
var controller = new StoresController(mockRepo.Object, null);
// act
IActionResult result = await controller.Index();
// assert
// ...that the result is a ViewResult
var viewResult = Assert.IsAssignableFrom <ViewResult>(result);
// ...that the model of the view is a List<Store>
var list = Assert.IsAssignableFrom <List <Store> >(viewResult.Model);
// ...that the list has one element with ID 1 (based on the MockRepo's data)
Store store = Assert.Single(list);
Assert.Equal(1, store.StoreId);
// we might also test that the correct view was chosen (DailyTasks/Index)
mockRepo.Verify(x => x.StoreRepository.All(), Times.Once); // verify that the method was called once
}
public StoresControllerTests()
{
// In our tests we choose to ignore whatever logging is being done. We still need to mock it to avoid
// null reference exceptions; loose mocks just handle whatever you throw at them.
_loggerMock = new Mock <ILogger <StoresController> >(MockBehavior.Loose);
_storeRepoMock = new Mock <IStoreRepository>(MockBehavior.Strict);
_storesController = new StoresController(_storeRepoMock.Object, _loggerMock.Object);
}
public void Delete()
{
// Arrange
StoresController controller = new StoresController();
// Act
controller.DeleteStore(100);
// Assert
}
public async void NonExistentId_ReturnsNotFoundResult()
{
int id = 3;
var storeService = Mock.Of <IStoreService>(
s => s.GetByIdAsync(id) == Task.FromResult <StoreDto>(null));
var controller = new StoresController(storeService);
var result = await controller.GetAsync(id);
Assert.IsType <NotFoundResult>(result.Result);
}
public void Index_GetStores()
{
using (var context = new ApplicationDbContext(options))
{
var dataProtectionProvider = new EphemeralDataProtectionProvider();
storeController = new StoresController(context, dataProtectionProvider, mockHttpContextAccessor.Object, mockEnvironment.Object);
var resultTask = storeController.Index();
resultTask.Wait();
var model = (List <Store>)((ViewResult)resultTask.Result).Model;
Assert.AreEqual(1, model.Count);
}
}
public async Task DeleteStoreWhichDoesntExistInDatabase_ReturnNotFoundScreen()
{
var bookRepo = new FakeBookRepository();
var pubRepo = new FakePublisherRepository();
var storeRepo = new FakeStoreRepository();
var controller = new StoresController(bookRepo, pubRepo, storeRepo);
var result = await controller.Delete(1) as ViewResult;
Assert.AreEqual("NotFound", result.ViewName);
}
public async void UserCanDeleteStoreById()
{
var store = CreateRandomStore();
var mock = new Mock <IStoreService>();
mock.Setup(x => x.FindByIdAsync(store.StoreId)).ReturnsAsync(store);
var controller = new StoresController(mock.Object);
var response = await controller.DeleteById(store.StoreId);
Assert.IsType <OkObjectResult>(response.Result);
}
public async void GetStoreWithIncorrectIdWillReturnNotFound()
{
var mapper = Helper.CreateMapperWithProfile <StoreProfile>();
var store = CreateRandomStore();
var mock = new Mock <IStoreRepository>();
var service = new StoreService(mock.Object, mapper);
var controller = new StoresController(service);
var response = await controller.GetById(store.StoreId);
Assert.IsType <NotFoundResult>(response.Result);
}
public void Details_By_StoreId()
{
using (var context = new ApplicationDbContext(options))
{
var dataProtectionProvider = new EphemeralDataProtectionProvider();
storeController = new StoresController(context, dataProtectionProvider, mockHttpContextAccessor.Object, mockEnvironment.Object);
var resultTask = storeController.Details(1);
resultTask.Wait();
Assert.IsNotNull(resultTask.Result);
var model = (Tuple <IList <Product>, Store>)((ViewResult)resultTask.Result).Model;
Assert.AreEqual(1, model.Item2.StoreId);
}
}
public async void UpdateStoreWithExistingNameWillReturnBadRequest()
{
var store = CreateRandomStore();
var request = new Fixture().Create <StoreRequest>();
var mock = new Mock <IStoreService>();
mock.Setup(x => x.UpdateAsync(store, request)).Throws <ApiException>();
var controller = new StoresController(mock.Object);
var response = await controller.UpdateById(store.StoreId, request);
Assert.IsType <NotFoundResult>(response.Result);
}
public void Post()
{
// Arrange
StoresController controller = new StoresController();
// Act
var testStore = new Store {
id = 100, Name = "Store 100", Address = "Street 100"
};
controller.PostStore(testStore);
// Assert
}
public async Task CheckCreationOfStore_RedirectToActionResult()
{
var store = new Store();
var bookRepo = new FakeBookRepository();
var pubRepo = new FakePublisherRepository();
var storeRepo = new FakeStoreRepository();
var controller = new StoresController(bookRepo, pubRepo, storeRepo);
var result = await controller.Create(store);
Assert.IsInstanceOfType(result, typeof(RedirectToActionResult));
}
public async void UserCanAddStore()
{
var mapper = Helper.CreateMapperWithProfile <StoreProfile>();
var request = new Fixture().Create <StoreRequest>();
var mock = new Mock <IStoreService>();
mock.Setup(x => x.AddAsync(request)).ReturnsAsync(mapper.Map <Store>(request));
var controller = new StoresController(mock.Object);
var response = await controller.Add(request);
Assert.IsType <CreatedAtActionResult>(response.Result);
}
public void Put()
{
// Arrange
StoresController controller = new StoresController();
// Act
var testStore = new Store {
id = 100, Name = "Store 100", Address = "Street 100"
};
testStore.Name = "updated field";
controller.PutStore(100, testStore);
// Assert
}
public async void AddingExistingStoreWillReturnBadRequest()
{
var mapper = Helper.CreateMapperWithProfile <StoreProfile>();
var request = new Fixture().Create <StoreRequest>();
var mock = new Mock <IStoreRepository>();
mock.Setup(x => x.Find(request.StoreName, request.Address)).ReturnsAsync(mapper.Map <Store>(request));
var service = new StoreService(mock.Object, mapper);
var controller = new StoresController(service);
var response = await controller.Add(request);
Assert.IsType <BadRequestObjectResult>(response.Result);
}
public async void ReturnsAllFromService()
{
IEnumerable <StoreDto> stores = new[]
{
new StoreDto(42, "HugeStore", "123.123", "42.42"),
new StoreDto(43, "TinyStore", "123.123", "42.42"),
};
var storeService = Mock.Of <IStoreService>(
s => s.GetAllAsync() == Task.FromResult(stores));
var controller = new StoresController(storeService);
var result = await controller.GetAsync();
Assert.Equal(stores, result.Value);
}
public async void ExistingId_ReturnsDto()
{
// This test is pretty bad, it only tests
// that the controller returns the store
// that the service returns.
var id = 3;
var store = new StoreDto(id, "HugeStore", "123.132", "42.42");
var storeService = Mock.Of <IStoreService>(
s => s.GetByIdAsync(id) == Task.FromResult(store));
var controller = new StoresController(storeService);
var result = await controller.GetAsync(id);
Assert.Equal(store, result.Value);
}
public void GetById()
{
// Arrange
StoresController controller = new StoresController();
// Act
var store = controller.GetStore(1);
// Assert
var testStore = new Store {
id = 1, Name = "Store 1", Address = "Street 1"
};
Assert.AreEqual(store, testStore);
}
public async Task CheckCreationOfStoreByWrongPerson_RedirectToModel()
{
var store = new Store();
var bookRepo = new FakeBookRepository();
var pubRepo = new FakePublisherRepository();
var storeRepo = new FakeStoreRepository();
var controller = new StoresController(bookRepo, pubRepo, storeRepo);
controller.ModelState.AddModelError("", "pickAnything");
var result = await controller.Create(store) as ViewResult;
Assert.AreEqual(store, result.Model);
}
public void Get()
{
// Arrange
StoresController controller = new StoresController();
// Act
IEnumerable <Store> stores = controller.GetStores();
// Assert
Assert.IsNotNull(stores);
Assert.AreEqual(3, stores.Count());
var testStore = new Store {
id = 1, Name = "Store 1", Address = "Street 1"
};
Assert.AreEqual(stores, testStore);
}
public async void UserCanGetStoreById(int storesCount)
{
var stores = CreateRandomStoresList(storesCount);
var mapper = Helper.CreateMapperWithProfile <StoreProfile>();
var store = stores.FirstOrDefault();
var mock = new Mock <IStoreRepository>();
mock.Setup(x => x.Find(store.StoreId))
.ReturnsAsync(stores.FirstOrDefault(x => x.StoreId == store?.StoreId));
var service = new StoreService(mock.Object, mapper);
var controller = new StoresController(service);
var response = await controller.GetById(store?.StoreId ?? -1);
Assert.IsType <OkObjectResult>(response.Result);
}
public async Task Index_DisplayStores()
{
// ARRANGE
var mockRepository = new Mock <IRepository>();
// create a moq that returns store
mockRepository.Setup(r => r.GetAllStoresAsync()).ReturnsAsync(GetTestSessions());
// make a using my mock
var controller = new StoresController(mockRepository.Object);
// ACT
var result = await controller.Index("");
// assert
var viewResult = Assert.IsType <ViewResult>(result);
}
public async Task IndexShouldReturnViewWithData()
{
// arrange
var mockRepo = new Mock <IUnitOfWork>();
// Moq gives us Mock class
// which can implement interfaces at runtime
// 1. you create the Mock
// 2. you Setup the mock (giving it behavior)
// 3. you give mock.Object to your test subject object
// (4. you can use methods like Verify ot make sure that things were called on the mock object)
mockRepo.Setup(x => x.StoreRepository.All())
.ReturnsAsync(new List <Store> {
new Store {
StoreId = 1
}
});
// mockRepo.Setup(x => x.Delete(It.IsAny<int>()))
// mockRepo.Setup(x => x.Delete(It.IsInRange<int>(-99999, 0, Moq.Range.Inclusive)))
// mockRepo.Setup(x => x.Delete(5))
// .ThrowsAsync(new InvalidOperationException());
var controller = new StoresController(mockRepo.Object, null);
// act
IActionResult result = await controller.Index();
// assert
// ...that the result is a ViewResult
var viewResult = Assert.IsAssignableFrom <ViewResult>(result);
// ...that the model of the view is a List<Store>
var list = Assert.IsAssignableFrom <List <Store> >(viewResult.Model);
// ...that the list has one element with ID 1 (based on the MockRepo's data)
Store store = Assert.Single(list);
Assert.Equal(1, store.StoreId);
// we might also test that the correct view was chosen (DailyTasks/Index)
mockRepo.Verify(x => x.StoreRepository.All(), Times.Once); // verify that the method was called once
}
public async void UserCanViewAllStore(int storesCount)
{
var stores = CreateRandomStoresList(storesCount);
var repository = new Mock <IStoreRepository>();
repository.Setup(x => x.All()).ReturnsAsync(stores);
var service = new StoreService(repository.Object, Helper.CreateMapperWithProfile <StoreProfile>());
var controller = new StoresController(service);
var response = await controller.All();
if (storesCount > 0)
{
Assert.IsType <OkObjectResult>(response.Result);
Assert.Equal(stores, ((OkObjectResult)response.Result).Value);
}
else
{
Assert.IsType <NoContentResult>(response.Result);
}
}
public void ReturnIndexViewWithStoresList_WithActionIndex()
{
// Arrange
IEnumerable <Store> storeList = new List <Store> {
new Store {
Id = 1, Name = "Auchan"
}
};
Mock <IRepository <Store> > mockRepo = new Mock <IRepository <Store> >();
mockRepo.Setup(repo => repo.FindAll()).Returns(storeList);
StoresController sut = new StoresController(mockRepo.Object);
// Act
var result = sut.Index();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <Store> >(viewResult.Model);
Assert.Equal(storeList.Count(), model.Count());
}
public StoresControllerTest()
{
DBConfiguration.ConnectionString = "server=localhost;user id=root;password=root;port=8889;database=event_planner_tests;";
_controller = new StoresController();
_store = new Store("TestName");
}