public void Details_CustomerExists_ReturnsViewResultWithCustomer()
{
// Act
var result = controller.Details(2) as ViewResult;
var customer = result.Model as Customer;
var customerId = customer.Id;
// Assert
Assert.InRange <int>(customerId, 1, 2);
}
public async Task Details_should_return_bad_request_for_missing_id()
{
// Arrange
var id = (int?)null;
// Act
var result = await _controller.Details(id);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public async Task DetailsWhenEmailNull()
{
// ARRANGE
string email = null;
// ACT
var resultTask = await _controller.Details(email);
// Type cast
var result = resultTask as HttpStatusCodeResult;
// ASSERT
Assert.AreEqual((int)HttpStatusCode.BadRequest, result.StatusCode);
}
public void DetailsReturnsHttpNotFoundWhenCustomerIsNull()
{
var context = new Mock <IApplicationDbContext>();
var editCustomer = new Customer {
Id = -1, Name = "Test", isSubscribedToNewsletter = true, MembershipType = new MembershipType(), MembershipTypeId = 2, Birthdate = DateTime.Parse("10/30/2001")
};
var mockedDbMemberships = new Mock <DbSet <MembershipType> >();
var mockedDbCustomers = new Mock <DbSet <Customer> >();
var membershipTypeData = TestMembershipTypeList();
mockedDbMemberships.As <IQueryable <MembershipType> >().Setup(m => m.Provider).Returns(membershipTypeData.Provider);
mockedDbMemberships.As <IQueryable <MembershipType> >().Setup(m => m.Expression).Returns(membershipTypeData.Expression);
mockedDbMemberships.As <IQueryable <MembershipType> >().Setup(m => m.ElementType).Returns(membershipTypeData.ElementType);
mockedDbMemberships.As <IQueryable <MembershipType> >().Setup(m => m.GetEnumerator()).Returns(membershipTypeData.GetEnumerator());
context.Setup(m => m.MembershipTypes).Returns(mockedDbMemberships.Object);
var customerData = TestCustomerList();
mockedDbCustomers.As <IQueryable <Customer> >().Setup(m => m.Provider).Returns(customerData.Provider);
mockedDbCustomers.As <IQueryable <Customer> >().Setup(m => m.Expression).Returns(customerData.Expression);
mockedDbCustomers.As <IQueryable <Customer> >().Setup(m => m.ElementType).Returns(customerData.ElementType);
mockedDbCustomers.As <IQueryable <Customer> >().Setup(m => m.GetEnumerator()).Returns(customerData.GetEnumerator());
context.Setup(m => m.Customers).Returns(mockedDbCustomers.Object);
mockedDbCustomers.Setup(m => m.Include(It.IsAny <string>())).Returns(mockedDbCustomers.Object);
var controller = new CustomersController(context.Object);
var result = controller.Details(editCustomer.Id);
Assert.IsInstanceOf(typeof(HttpNotFoundResult), result);
}
public void Detail_ReturnsAView_CustomerDetailsWithListOfOrders()
{
// Arrange
int id = 1;
var mockCustRepo = new Mock <ICustomerRepository>();
mockCustRepo.Setup(repo => repo.Get(id))
.Returns(new Customer("Sherlock", "Holmes", id));
var mockOrderRepo = new Mock <IOrderRepository>();
mockOrderRepo.Setup(repo => repo.GetByCustomerId(id))
.Returns(ListOfTwoOrders());
var controller = new CustomersController(mockCustRepo.Object, mockOrderRepo.Object);
// Act
var result = controller.Details(id);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <CustomerWithOrderViewModel>(viewResult.ViewData.Model);
var orders = Assert.IsAssignableFrom <IEnumerable <OrderViewModel> >(model.Orders);
Assert.Equal("Sherlock", model.FirstName);
Assert.Equal("Holmes", model.LastName);
Assert.Equal(2, orders.Count());
}
public void TestDetailsGet_ExistingCustomer()
{
#region ASSIGN
TestRepository tRepo = new TestRepository();
CustomersController tController = null;
tController = new CustomersController(tRepo)
{
ControllerContext = UtilityFunctions.GenerateMockControllerContext("UserA"),
};
#endregion
#region ACT
var tResult = tController.Details(null) as ViewResult;
#endregion
#region ASSERT
var tValue = tResult.Model as Customer;
Assert.AreEqual(tValue.FirstName, "John");
#endregion
}
public void DetailsTestRedirect()
{
var controller = new CustomersController();
var result = (RedirectToRouteResult)controller.Details();
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public async void Edit_ExistedId_ReturnViewResultCustomer(int id)
{
var customer = new Customer {
FirstName = "RamilQ", LastName = "NaumQ", Address = "LosQ-Ang", Discount = "5", Id = id
};
var option = new DbContextOptionsBuilder <ShoppingContext>().
UseInMemoryDatabase(databaseName: "testsEdit").Options;
var context = new ShoppingContext(option);
SampleData.Initialize(context);
var mock = new Mock <CustomersService>(context);
var controller = new CustomersController(mock.Object);
var resultView = await controller.Edit(id, customer);
var viewResult = Assert.IsType <RedirectToActionResult>(resultView);
var actionName = Assert.IsAssignableFrom <string>(viewResult.ActionName);
var resultViewDetails = await controller.Details(id);
var viewResultDetails = Assert.IsType <ViewResult>(resultViewDetails);
var model = Assert.IsAssignableFrom <Customer>(viewResultDetails.Model);
Assert.Equal("Index", actionName);
Assert.Equal(model, customer);
}
public void TestDetailsGet_NewCustomer()
{
#region ASSIGN
TestRepository tRepo = new TestRepository();
CustomersController tController = null;
tController = new CustomersController(tRepo)
{
ControllerContext = UtilityFunctions.GenerateMockControllerContext("User"),
};
#endregion
#region ACT
var tResult = tController.Details(null);
#endregion
#region ASSERT
Assert.IsTrue(tResult is RedirectToActionResult);
Assert.AreEqual((tResult as RedirectToActionResult).ActionName, "Create");
#endregion
}
public void TestMethod1()
{
CustomersController cc = new CustomersController();
Customer c = cc.Details(1);
Assert.AreEqual("Tom", c.FirstName);
}
public void ViewCustomerDetail()
{
// Arrange
CustomersController controller = new CustomersController();
// Act
ViewResult result = controller.Details(1) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public async Task Details_should_return_bad_request_for_missing_id()
{
var customerServiceMock = new Mock <ICustomerService>();
var controller = new CustomersController(customerServiceMock.Object);
var id = (int?)null;
var result = await controller.Details(id);
Assert.IsType <BadRequestResult>(result);
}
public void DetailsTest()
{
// Arrange
CustomersController controller = new CustomersController(new CustomerManager(new TestCustomerRepository()));
// Act
ViewResult result = controller.Details(1) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void Details()
{
// Arrange
controller = new CustomersController();
// Act
result = controller.Details(13) as ViewResult;
Assert.AreEqual("Details", result.ViewName);
}
public void DetailsWithInvalidId()
{
// Arrange
CustomersController controller = new CustomersController();
// Act
ViewResult result = controller.Details(0) as ViewResult;
// Assert
Assert.IsNull(result);
}
public async Task Details_should_return_not_found_for_missing_customer()
{
var customerServiceMock = new Mock <ICustomerService>();
customerServiceMock.Setup(c => c.GetCustomer(It.IsAny <int>()))
.ReturnsAsync(() => null);
var controller = new CustomersController(customerServiceMock.Object);
var id = -1;
var result = await controller.Details(id);
Assert.IsType <NotFoundResult>(result);
}
public void CustomerAccessInvalidIdTest()
{
//Arrange
Mock <IDataApi> dataMock = new Mock <IDataApi>();
dataMock.Setup(d => d.getCustomers()).ReturnsAsync(new List <Customer>
{
new Customer {
Id = 0, FirstName = "Ofek", LastName = "Agmon"
}
});
Mock <ICustomerFactory> customerFactoryMock = new Mock <ICustomerFactory>();
CustomersController customersController = new CustomersController(dataMock.Object, customerFactoryMock.Object);
// Act
var resultNegative = customersController.Details(-1); // negative id
var resultOutOfIndex = customersController.Details(1); // id doesn't exist
// Assert
Assert.IsInstanceOfType(resultNegative.Result, typeof(HttpNotFoundResult));
Assert.IsInstanceOfType(resultOutOfIndex.Result, typeof(HttpNotFoundResult));
}
public async Task Details_Returns_BadRequestResult()
{
int id = 4;
var customer = GetCustomers().FirstOrDefault(p => p.Id == id);
//Arrange
mock.Setup(repo => repo.GetByIdAsync(id)).Throws(new Exception());
controller = new CustomersController(mock.Object);
//Act
var result = await controller.Details(id);
//Assert
var badRequestResult = Assert.IsType <BadRequestResult>(result);
}
public void TestCustomerDetails_ReturnsCustomer()
{
// Arrange.
ICustomerRepository repo = new CustomerTestRepository();
CustomersController controller = new CustomersController(repo);
var expected = "John";
// Act.
var result = controller.Details(102);
var fname = ((Customer)(result.Result as ViewResult).Model).Firstname;
// Assert.
Assert.AreEqual(expected, fname);
}
public async void Details_ExistedId_ReturnViewResultCustomer(int a)
{
var option = new DbContextOptionsBuilder <ShoppingContext>().
UseInMemoryDatabase(databaseName: "testsDBDetails").Options;
var context = new ShoppingContext(option);
SampleData.Initialize(context);
var mock = new Mock <CustomersService>(context);
var controller = new CustomersController(mock.Object);
var resultView = await controller.Details(a);
var viewResult = Assert.IsType <ViewResult>(resultView);
var model = Assert.IsAssignableFrom <Customer>(viewResult.Model);
Assert.Equal(a, model.Id);
}
public async Task Details_should_return_details_view_for_existing_customer()
{
var model = new CustomerModel();
var customerServiceMock = new Mock <ICustomerService>();
customerServiceMock.Setup(c => c.GetCustomer(It.IsAny <int>()))
.ReturnsAsync(() => model);
var controller = new CustomersController(customerServiceMock.Object);
var id = 10;
var result = await controller.Details(id) as ViewResult;
var viewName = result.ViewName;
Assert.True(string.IsNullOrEmpty(viewName) || viewName == "Details");
Assert.Equal(model, result.Model);
}
public void Search_ReturnACustomer()
{
var customerRepository = Mock.Create <IEntityRepository <Customer, string> >();
Mock.Arrange(() => customerRepository.Search("1")).Returns(
new Customer
{
CustomerID = "1",
CompanyName = "MSP DIY"
}).MustBeCalled();
CustomersController controller = new CustomersController(customerRepository);
ViewResult view = controller.Details("1") as ViewResult;
var model = view.Model as Customer;
Assert.AreEqual("MSP DIY", model.CompanyName);
}
public async Task Details_Returns_ViewResult_CustomerByID()
{
int id = 4;
var customer = GetCustomers().FirstOrDefault(p => p.Id == id);
//Arrange
mock.Setup(repo => repo.GetByIdAsync(id)).ReturnsAsync(customer);
controller = new CustomersController(mock.Object);
//Act
var result = await controller.Details(id);
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <Customer>(viewResult.ViewData.Model);
customer.Should().BeEquivalentTo(model);
}
public async Task DetailsCustomerDoesNotExist()
{
var customer1 = new Customer()
{
LastName = "Nowak"
};
var customer2 = new Customer()
{
LastName = "Kowalski"
};
var service = new Mock <ICustomerRepository>();
service.Setup(x => x.GetCustomer(1)).ReturnsAsync(customer1);
service.Setup(x => x.GetCustomer(2)).ReturnsAsync(customer2);
var controller = new CustomersController(service.Object);
var result = await controller.Details(100);
var viewResult = (ViewResult)result;
Assert.AreEqual("NotFound", viewResult.ViewName);
}
public async Task DetailsCustomerExist()
{
var customer1 = new Customer()
{
LastName = "Nowak"
};
var customer2 = new Customer()
{
LastName = "Kowalski"
};
var service = new Mock <ICustomerRepository>();
service.Setup(x => x.GetCustomer(1)).ReturnsAsync(customer1);
service.Setup(x => x.GetCustomer(2)).ReturnsAsync(customer2);
var controller = new CustomersController(service.Object);
var result = await controller.Details(1);
var model = ((ViewResult)result).Model as Customer;
Assert.AreEqual(customer1, model);
}
public async Task CustomersReturnsDetails()
{
//Arrage
DashbordCustomer customers = new DashbordCustomer()
{
CompanyName = "test"
};
await _customersControllerUnderTest.Create(customers);
var customer = db.Customers.Where(c => c.CompanyName == customers.CompanyName).FirstOrDefault();
//Act
var result = await _customersControllerUnderTest.Details(customer.CustomerID) as ViewResult;
//Assert
Assert.IsNotNull(result);
var customerss = db.Customers.Where(c => c.CustomerID == customer.CustomerID && c.CompanyName == customers.CompanyName);
db.Customers.RemoveRange(customerss);
db.SaveChanges();
}
