public async Task EditWhenEmailNull() { // ARRANGE string email = null; // ACT var resultTask = _controller.Edit(email); // Type cast var result = await resultTask as HttpStatusCodeResult; // ASSERT Assert.AreEqual((int)HttpStatusCode.BadRequest, result.StatusCode); }
public void Task_Edit_ResetPassword_Return_View() { Assert.Throws<NullReferenceException>(() => { //Arrange var controller = new CustomersController(context); int id = 1; var customers = new Customers() { CustomerId = 1, OldPassword = "******", NewPassword = "******", }; //Act var EditData = controller.Edit(id, customers); //Assert Assert.IsType<RedirectToActionResult>(EditData); }); }
public void TestEditGet_ExistingCustomer_InvalidUser() { #region ASSIGN TestRepository tRepo = new TestRepository(); CustomersController tController = null; tController = new CustomersController(tRepo) { ControllerContext = UtilityFunctions.GenerateMockControllerContext("UserA"), }; #endregion #region ACT var tResult = tController.Edit(10) as ViewResult; #endregion #region ASSERT var tValue = tResult.Model as Customer; Assert.AreNotEqual(tValue.FirstName, "Mary"); #endregion }
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 TestEditGet_NewCustomer() { #region ASSIGN TestRepository tRepo = new TestRepository(); CustomersController tController = null; tController = new CustomersController(tRepo) { ControllerContext = UtilityFunctions.GenerateMockControllerContext("User"), }; #endregion #region ACT var tResult = tController.Edit(1); #endregion #region ASSERT Assert.IsTrue(tResult is RedirectToActionResult); Assert.AreEqual((tResult as RedirectToActionResult).ActionName, "Create"); #endregion }
public async Task Should_receive_correct_customer_details_from_request() { // Arrange var controller = new CustomersController(TestFixture.GetInstance <IMediator>()); const string customerId = "ANATR"; var expectedModel = DataMocks.GetCustomerList(0) .Single(c => c.CustomerId == customerId); // Act var result = await controller.Edit(new Edit.Query { Id = customerId }) as ViewResult; // Assert var model = result?.ViewData.Model as Edit.Command; model?.Id.ShouldBe(expectedModel.CustomerId); model?.CompanyName.ShouldBe(expectedModel.CompanyName); model?.ContactName.ShouldBe(expectedModel.ContactName); model?.ContactTitle.ShouldBe(expectedModel.ContactTitle); model?.Address.ShouldBe(expectedModel.Address); model?.City.ShouldBe(expectedModel.City); model?.Region.ShouldBe(expectedModel.Region); model?.PostalCode.ShouldBe(expectedModel.PostalCode); model?.Country.ShouldBe(expectedModel.Country); model?.Phone.ShouldBe(expectedModel.Phone); model?.Fax.ShouldBe(expectedModel.Fax); }
public void TestEditPost_ExistingCustomer_InvalidID() { #region ASSIGN TestRepository tRepo = new TestRepository(); CustomersController tController = null; Customer tCustomer = new Customer() { FirstName = "Mary", ID = 1, UserIdentity = "UserB" }; tController = new CustomersController(tRepo) { ControllerContext = UtilityFunctions.GenerateMockControllerContext("UserB"), }; #endregion #region ACT var tResult = tController.Edit(0, tCustomer); #endregion #region ASSERT Assert.IsTrue(tResult is UnauthorizedResult); #endregion }
public void EditCustomersSuccessViewRenders() { var cust_id = Guid.NewGuid(); var existing_cust = new Customer { customer_id = cust_id, name = "Test2", billing_address = " 123 Cherry Oak Street", billing_city = "Hilliard", billing_state = "OH", billing_zip = "43221", isActive = true }; var mockCust = new Mock <DbSet <Customer> >(); mockCust.Setup(m => m.Find(cust_id)).Returns(existing_cust); var mockContext = new Mock <StoreDbContext>(); mockContext.Setup(m => m.Customers).Returns(mockCust.Object); var controller = new CustomersController(mockContext.Object); var result = controller.Edit(cust_id); Assert.IsAssignableFrom(typeof(ViewResult), result); }
public void TestEditPost_ExistingCustomer_ValidID() { #region ASSIGN TestRepository tRepo = new TestRepository(); CustomersController tController = null; Customer tCustomer = new Customer() { FirstName = "Mary", ID = 1, UserIdentity = "UserB" }; tController = new CustomersController(tRepo) { ControllerContext = UtilityFunctions.GenerateMockControllerContext("UserB"), }; #endregion #region ACT var tResult = tController.Edit(1, tCustomer); #endregion #region ASSERT Assert.IsTrue(tResult is RedirectToActionResult); Assert.AreEqual((tResult as RedirectToActionResult).ActionName, "Index"); #endregion }
public void EditReturnsHttpNotFoundWhenCustomerIsNull() { var context = new Mock <IApplicationDbContext>(); Customer editCustomer = new Customer { Id = -1 }; 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); var controller = new CustomersController(context.Object); var result = controller.Edit(editCustomer.Id); Assert.IsInstanceOf(typeof(HttpNotFoundResult), result); }
public void EditReturnsCustomerInfoWhenModelIsValid() { var context = new Mock <IApplicationDbContext>(); var editCustomer = new Customer { Id = 4, 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); var controller = new CustomersController(context.Object); var result = (ViewResult)controller.Edit(editCustomer.Id); Assert.AreEqual(result.ViewName, "CustomerForm"); var SingleMethodResult = mockedDbCustomers.Object.Single(c => c.Id == editCustomer.Id); Assert.AreEqual(SingleMethodResult.Name, editCustomer.Name); }
public async Task EditCustomerWithInvalidData() { var customer = new Customer() { FirstName = "Tomasz", LastName = "Nowak", Email = "*****@*****.**" }; var newCustomerData = new Customer() { FirstName = "Tomasz", LastName = "Nowak", Email = "tomasznowakwp.pl" }; var service = new Mock <ICustomerRepository>(); service.Setup(x => x.GetCustomer(0)).ReturnsAsync(customer); service.Setup(x => x.CustomerExists(0)).Returns(true); var controller = new CustomersController(service.Object); controller.ModelState.AddModelError("", ""); var result = await controller.Edit(0, newCustomerData); var model = ((ViewResult)result).Model as Customer; Assert.AreEqual(newCustomerData, model); }
public void EditPost() { var controller = new CustomersController(); var customer = new Customer(); var result = controller.Edit(customer) as ViewResult; var editCustomer = (Customer)result.ViewData.Model; Assert.AreEqual(result, editCustomer); }
public void EditTest() { Customers v = new Customers(); using (var context = new DataContext(_seed, DBTypeEnum.Memory)) { v.CusName = "FnN6ZV7"; v.CusGrade = SCMSupplyChain.Model.CusGrade.VIP1; v.CusCompany = "32bio"; v.CusMan = "B7358aReV"; v.CusTelephone = "uohl9Ebf"; v.CusDesc = "FIpOlvhn"; context.Set <Customers>().Add(v); context.SaveChanges(); } CustomersVM vm = _controller.Wtm.CreateVM <CustomersVM>(); var oldID = v.ID; v = new Customers(); v.ID = oldID; v.CusName = "3TkrCGcR"; v.CusGrade = SCMSupplyChain.Model.CusGrade.VIP4; v.CusCompany = "hNL3"; v.CusMan = "ZS4IJLc0"; v.CusTelephone = "xXR6AgyP"; v.CusDesc = "R41Wk"; vm.Entity = v; vm.FC = new Dictionary <string, object>(); vm.FC.Add("Entity.CusName", ""); vm.FC.Add("Entity.CusGrade", ""); vm.FC.Add("Entity.CusCompany", ""); vm.FC.Add("Entity.CusMan", ""); vm.FC.Add("Entity.CusTelephone", ""); vm.FC.Add("Entity.CusDesc", ""); var rv = _controller.Edit(vm); Assert.IsInstanceOfType(rv, typeof(OkObjectResult)); using (var context = new DataContext(_seed, DBTypeEnum.Memory)) { var data = context.Set <Customers>().Find(v.ID); Assert.AreEqual(data.CusName, "3TkrCGcR"); Assert.AreEqual(data.CusGrade, SCMSupplyChain.Model.CusGrade.VIP4); Assert.AreEqual(data.CusCompany, "hNL3"); Assert.AreEqual(data.CusMan, "ZS4IJLc0"); Assert.AreEqual(data.CusTelephone, "xXR6AgyP"); Assert.AreEqual(data.CusDesc, "R41Wk"); Assert.AreEqual(data.UpdateBy, "user"); Assert.IsTrue(DateTime.Now.Subtract(data.UpdateTime.Value).Seconds < 10); } }
public void Edit_Customer_with_id() { var mockSetCustomer = new Mock <DbSet <Customer> >(); var mockContext = new Mock <ApplicationDbContext>(); mockContext.Setup(m => m.Customers).Returns(mockSetCustomer.Object); var customerController = new CustomersController(mockContext.Object); ActionResult result = customerController.Edit(1) as ViewResult; Assert.ThrowsException <NotSupportedException>(() => result); }
public void EditTest() { // Arrange CustomersController controller = new CustomersController(new CustomerManager(new TestCustomerRepository())); // Act ViewResult result = controller.Edit(1) as ViewResult; // Assert Assert.IsNotNull(result); }
public void EditGet() { var controller = new CustomersController(); // var customer = new Customer(); var result = controller.Edit(3) as ViewResult; // var editedCustomer = (Customer) result.ViewData.Model; Assert.IsNotNull(result); }
public async Task Edit_should_return_edit_view_when_customer_was_found() { // Arrange var viewNames = new[] { null, "Edit" }; var id = 1; var model = new CustomerModel { Id = id }; _customerServiceMock.Setup(service => service.GetCustomer(id)) .ReturnsAsync(model); // Act var result = await _controller.Edit(id) as ViewResult; var viewName = result.ViewName; // Assert Assert.Contains(viewName, viewNames); Assert.Equal(model, result.Model); }
public void Edit_CustomerIdIsNull_EditedFalse() { // Act controller.Edit(null); // Assert Verify fakeCustomerRepository.Verify(x => x.Edit(It.IsAny <Customer>()), Times.Never); }
public async Task CustomersReturnsEdit() { //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.Edit(customer.CustomerID) as ViewResult; //Assert Assert.IsNotNull(result); var customerss = db.Customers.Where(c => c.CustomerID == customer.CustomerID && c.CompanyName == customer.CompanyName); db.Customers.RemoveRange(customerss); db.SaveChanges(); }
public void EditPostEmailValid() { // arrange controller.ModelState.AddModelError("some error name", "Error description"); var uppercaseEmail = this.customers[0].Email.ToUpper(); var uppercasedEmailCustomerList = this.customers; uppercasedEmailCustomerList[0].Email = uppercaseEmail; // act var result = (Customer)((ViewResult)controller.Edit(uppercasedEmailCustomerList[0])).Model; // assert Assert.AreEqual("*****@*****.**", result.Email); }
public async Task EditPOST_Returns_BadRequestResult() { int id = 4; var customer = GetCustomers().FirstOrDefault(p => p.Id == id); //Arrange mock.Setup(repo => repo.EditAsync(customer)) .ThrowsAsync(new DbUpdateConcurrencyException()); controller = new CustomersController(mock.Object); //Act var result = await controller.Edit(id, customer); //Assert var badRequestResult = Assert.IsType <BadRequestResult>(result); }
public async Task Edit_Returns_CustomerInfoForEditing() { int id = 4; var customer = GetCustomers().FirstOrDefault(p => p.Id == id); //Arrange mock .Setup(repo => repo.GetByIdAsync(customer.Id)).ReturnsAsync(customer); controller = new CustomersController(mock.Object); //Act var result = await controller.Edit(customer.Id); //Assert var viewResult = Assert.IsType <ViewResult>(result); }
public void EditShouldReturnUnprocessableEntityIfModelStateIsInvalid() { // Arrange var mock = new Mock <ICustomerService>(); Service = mock.Object; Controller = new CustomersController(Service); Controller.Configuration = new HttpConfiguration(); Controller.Request = new HttpRequestMessage(); Controller.ModelState.AddModelError("", ""); var mockCustomer = Builder <CustomerEditModel> .CreateNew().Build(); // Act var result = Controller.Edit(mockCustomer); // Assert Assert.AreEqual(422, (int)result.StatusCode); }
public async Task EditPOST_Returns_RedirectToActionResult() { int id = 4; var customer = GetCustomers().FirstOrDefault(p => p.Id == id); //Arrange mock.Setup(repo => repo.EditAsync(customer)); controller = new CustomersController(mock.Object); //Act var result = await controller.Edit(id, customer); //Assert var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result); Assert.Null(redirectToActionResult.ControllerName); Assert.Equal("Index", redirectToActionResult.ActionName); mock.Verify(r => r.EditAsync(customer)); }
public void EditShoudlReturnNotFoundIfServiceReturnsFalse() { // Arrange var mock = new Mock <ICustomerService>(); mock.Setup <bool>(_ => _.Edit(It.IsAny <CustomerEditModel>())) .Returns(false); Service = mock.Object; Controller = new CustomersController(Service); Controller.Configuration = new HttpConfiguration(); Controller.Request = new HttpRequestMessage(); var mockCustomer = Builder <CustomerEditModel> .CreateNew().Build(); // Act var result = Controller.Edit(mockCustomer); // Assert Assert.AreEqual(HttpStatusCode.NotFound, result.StatusCode); }
public void UpdatingACustomer_ChangesItsDataOnDb() { this.session.Save(new Customer { Name = "Pippo", VATNumber = "12345678901" }); var controller = new CustomersController(this.session); var newName = "Mario"; var newVat = "12345678902"; var updatedCustomer = new CreateOrEditCustomerViewModel { Name = newName, VATNumber = newVat }; var result = controller.Edit(1, updatedCustomer); var customerOnDb = this.session.Get <Customer>(1); customerOnDb.Should().Not.Be.Null(); customerOnDb.Name.Should().Be.EqualTo(newName); customerOnDb.VATNumber.Should().Be.EqualTo(newVat); }
public void EditCustomersSuccessPosttoMockDb() { var cust_id = Guid.NewGuid(); var existing_cust = new Customer { customer_id = cust_id, name = "Test2", billing_address = " 123 Cherry Oak Street", billing_city = "Hilliard", billing_state = "OH", billing_zip = "43221", isActive = true }; var updated_cust = new Customer { customer_id = cust_id, name = "Test2", billing_address = " 223 Pine Street", billing_city = "Dublin", billing_state = "OH", billing_zip = "43220", isActive = true }; var vm = new CustomerViewModel(updated_cust); var mockCust = new Mock <DbSet <Customer> >(); mockCust.Setup(m => m.Find(cust_id)).Returns(existing_cust); var mockContext = new Mock <StoreDbContext>(); mockContext.Setup(m => m.Customers).Returns(mockCust.Object); var controller = new CustomersController(mockContext.Object); var result = controller.Edit(vm); mockContext.Verify(m => m.SaveChanges()); Assert.IsAssignableFrom(typeof(RedirectToRouteResult), result); }
public async Task EditCustomerIsValid() { string validLastName = "Nowak"; var customer = new Customer() { LastName = validLastName, FirstName = "Tomasz", Email = "*****@*****.**" }; var teamToEditWith = new Customer() { LastName = validLastName, FirstName = "Adam", Email = "*****@*****.**" }; var service = new Mock <ICustomerRepository>(); service.Setup(x => x.GetCustomer(0)).ReturnsAsync(customer); service.Setup(x => x.CustomerExists(0)).Returns(true); var controller = new CustomersController(service.Object); var result = await controller.Edit(0, teamToEditWith); Assert.IsInstanceOfType(result, typeof(RedirectToActionResult)); }
public void Task_Edit_Profile_Return_View() { Assert.Throws<NullReferenceException>(() => { //Arrange var controller = new CustomersController(context); int id = 1; var customers = new Customers() { CustomerId = 1, FirstName = "Kritika", LastName = "Yadav", UserName = "******", Email = "*****@*****.**", OldPassword = "******", NewPassword = "******", Country = "India", Address = "Faridabad", City = "Faridabad", ZipCode = 123, Contact = 5785, BillingAddress = true, ShippingAddress = true, SaveInformation = true, PaymentType = true }; //Act var EditData = controller.Edit(id, customers); //Assert Assert.IsType<ViewResult>(EditData); }); }