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);
});
}
