public async System.Threading.Tasks.Task SuppliersDeleteItemAsync()
{
//Arrange
//init
var controller = new NorthwindWeb.Controllers.SuppliersController();
var db = new NorthwindDatabase();
//create Suppliers
var Suppliers = new Suppliers()
{
CompanyName = "TestSuppliersCreate",
ContactName = "contact",
};
db.Entry(Suppliers).State = System.Data.Entity.EntityState.Added;
db.SaveChanges();
//detach Suppliers from db
db.Entry(Suppliers).State = System.Data.Entity.EntityState.Detached;
db.SaveChanges();
//Act
//run controller action
await controller.DeleteConfirmed(Suppliers.SupplierID);
controller.Dispose();
//Assert
//this will throw a InvalidOperationException
var actualSuppliers = db.Suppliers.Where(x => x.SupplierID == Suppliers.SupplierID).First();
}
public async Task CategoryEditEdits()
{
//Arrange
Categories categoriesTest = new Categories()
{
CategoryName = "foto"
};
await _categoriesControllerTest.Create(categoriesTest);
db.Entry(categoriesTest).State = System.Data.Entity.EntityState.Added;
var expectedCategory = db.Categories.Find(categoriesTest.CategoryID);
db.Dispose();
categoriesTest.CategoryName = "video";
db = new NorthwindDatabase();
//Act
await _categoriesControllerTest.Edit(categoriesTest);
db.Entry(categoriesTest).State = System.Data.Entity.EntityState.Modified;
var actualCategory = db.Categories.Find(categoriesTest.CategoryID);
//Assert
Assert.AreEqual(expectedCategory, actualCategory);
var category = db.Categories.Where(c => (c.CategoryName == "video") || (c.CategoryName == "foto"));
db.Categories.RemoveRange(category);
db.SaveChanges();
}
public async System.Threading.Tasks.Task ProductCreateItemAsync()
{
//Arrange
var controller = new ProductController();
var db = new NorthwindDatabase();
int productCountBefore = db.Products.Count();
var product = new Products()
{
CategoryID = 4,
ProductName = "TestProductCreate",
Discontinued = false,
QuantityPerUnit = "1",
UnitPrice = 1,
UnitsInStock = 1,
ReorderLevel = 0,
SupplierID = 1,
UnitsOnOrder = 0
};
//Act
await controller.Create(product, null);
//Assert
Assert.AreEqual(productCountBefore + 1, db.Products.Count());
db.Entry(db.Products.Where(x => x.ProductName == product.ProductName).First()).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
controller.Dispose();
db.Dispose();
}
public async System.Threading.Tasks.Task RegionEditEdits()
{
//Arrange
Region regionTest = new Region()
{
RegionID = 100, RegionDescription = "Aici"
};
await _regionsControllerTest.Create(regionTest);
db.Entry(regionTest).State = System.Data.Entity.EntityState.Added;
var expectedRegion = db.Regions.Find(regionTest.RegionID);
db.Dispose();
regionTest.RegionDescription = "Acolo";
db = new NorthwindDatabase();
//Act
await _regionsControllerTest.Edit(regionTest);
db.Entry(regionTest).State = System.Data.Entity.EntityState.Modified;
var actualRegion = db.Regions.Find(regionTest.RegionID);
//Assert
Assert.AreEqual(expectedRegion, actualRegion);
var region = db.Regions.Where(r => (r.RegionDescription == "Aici") || (r.RegionDescription == "Acolo"));
db.Regions.RemoveRange(region);
db.SaveChanges();
}
public async Task OrdersReturnsEditEdits()
{
//Arrange
Orders orderTest = new Orders()
{
OrderID = 222, EmployeeID = 3
};
await _ordersControllerUnderTest.Create(orderTest);
db.Entry(orderTest).State = System.Data.Entity.EntityState.Added;
var expectedOrder = db.Orders.Find(orderTest.OrderID);
db.Dispose();
orderTest.EmployeeID = 4;
db = new NorthwindDatabase();
//Act
await _ordersControllerUnderTest.Edit(orderTest);
db.Entry(orderTest).State = System.Data.Entity.EntityState.Modified;
var actualOrder = db.Orders.Find(orderTest.OrderID);
//Assert
Assert.AreEqual(expectedOrder, actualOrder);
var orders = db.Orders.Where(o => o.OrderID == orderTest.OrderID && o.EmployeeID == orderTest.EmployeeID);
db.Orders.RemoveRange(orders);
db.SaveChanges();
}
public async Task CustomersReturnsEditEdits()
{
//Arrange
var expectedCustomer = new Customers()
{
CustomerID = "ZZZZZ", CompanyName = "test"
};
db.Customers.Add(expectedCustomer);
db.SaveChanges();
db.Entry(expectedCustomer).State = System.Data.Entity.EntityState.Added;
db.Dispose();
expectedCustomer.CompanyName = "test2";
db = new NorthwindDatabase();
//Act
await _customersControllerUnderTest.Edit(expectedCustomer);
db.Entry(expectedCustomer).State = System.Data.Entity.EntityState.Modified;
var actualCustomer = db.Customers.Find(expectedCustomer.CustomerID);
//Assert
Assert.AreEqual(expectedCustomer.CustomerID, actualCustomer.CustomerID);
var customerss = db.Customers.Where(c => c.CompanyName == expectedCustomer.CompanyName || c.CompanyName == actualCustomer.CompanyName);
db.Customers.RemoveRange(customerss);
db.SaveChanges();
}
public async System.Threading.Tasks.Task EmployeesEditEditsAsync()
{
//Arrange
Employees employeeTest = new Employees()
{
LastName = "test1", FirstName = "test1"
};
await _EmployeesControllerUnderTest.Create(employeeTest);
_db.Entry(employeeTest).State = System.Data.Entity.EntityState.Added;
var expectedEmployee = _db.Employees.Find(employeeTest.EmployeeID);
_db.Dispose();
employeeTest.LastName = "test2";
employeeTest.FirstName = "test2";
_db = new NorthwindDatabase();
//Act
await _EmployeesControllerUnderTest.Edit(employeeTest);
_db.Entry(employeeTest).State = System.Data.Entity.EntityState.Modified;
var actualEmployee = _db.Employees.Find(employeeTest.EmployeeID);
//Assert
Assert.AreEqual(expectedEmployee, actualEmployee);
DeleteTestFromDb();
}
public void ContactCreateItem()
{
//Arrange
var controller = new NorthwindWeb.Controllers.ContactController();
var db = new NorthwindDatabase();
NorthwindWeb.Models.Persons person = new NorthwindWeb.Models.Persons()
{
ID = db.Persons.Count() + 1,
FirstName = "test1223",
LastName = "123331111",
Email = "*****@*****.**",
Comment = "Buna!"
};
//Act
var result = controller.Index(person);
//Assert
Assert.IsNotNull(result);
db.Entry(person).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
db.Dispose();
}
public async Task ShipperEditEdits()
{
//Arrange
Shippers shipperTest = new Shippers()
{
CompanyName = "Express", Phone = "0240-111-111"
};
await _shippersControllerTest.Create(shipperTest);
db.Entry(shipperTest).State = System.Data.Entity.EntityState.Added;
var expectedShipper = db.Shippers.Find(shipperTest.ShipperID);
db.Dispose();
shipperTest.CompanyName = "Nero Express";
shipperTest.Phone = "0240-222-222";
db = new NorthwindDatabase();
//Act
await _shippersControllerTest.Edit(shipperTest);
db.Entry(shipperTest).State = System.Data.Entity.EntityState.Modified;
var actualShipper = db.Shippers.Find(shipperTest.ShipperID);
//Assert
Assert.AreEqual(expectedShipper, actualShipper);
var shipper = db.Shippers.Where(s => (s.CompanyName == "Express" && s.Phone == "0240-111-111") || (s.CompanyName == "Nero Express" && s.Phone == "0240-222-222"));
db.Shippers.RemoveRange(shipper);
db.SaveChanges();
}
public async Task <ActionResult> Edit([Bind(Include = "CustomerID,CompanyName,ContactName,ContactTitle,Address,City,Region,PostalCode,Country,Phone,Fax")] Customers customers)
{
if (ModelState.IsValid)
{
db.Entry(customers).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(customers));
}
public async Task <ActionResult> Edit([Bind(Include = "ShipperID,CompanyName,Phone")] Shippers shippers)
{
if (ModelState.IsValid)
{
db.Entry(shippers).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(shippers));
}
public async Task <ActionResult> Edit([Bind(Include = "RegionID,RegionDescription")] Region region)
{
if (ModelState.IsValid)
{
db.Entry(region).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(region));
}
public async Task <ActionResult> Edit([Bind(Include = "SupplierID,CompanyName,ContactName,ContactTitle,Address,City,Region,PostalCode,Country,Phone,Fax,HomePage")] Suppliers suppliers)
{//if inputs data correspond to the model
if (ModelState.IsValid)
{
db.Entry(suppliers).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(suppliers));
}
public async Task <ActionResult> Edit([Bind(Include = "EmployeeID,LastName,FirstName,Title,TitleOfCourtesy,BirthDate,HireDate,Address,City,Region,PostalCode,Country,HomePhone,Extension,Notes,ReportsTo")] Employees employees)
{
if (ModelState.IsValid)
{
db.Entry(employees).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.ReportsTo = new SelectList(db.Employees, "EmployeeID", "LastName", employees.ReportsTo);
return(View(employees));
}
public async System.Threading.Tasks.Task SuppliersEditItemAsync()
{
//Arrange
//init
var controller = new NorthwindWeb.Controllers.SuppliersController();
var db = new NorthwindDatabase();
//create Suppliers
var Suppliers = new Suppliers()
{
CompanyName = "TestSuppliersCreate",
ContactName = "contact",
};
db.Entry(Suppliers).State = System.Data.Entity.EntityState.Added;
db.SaveChanges();
//detach Suppliers from db
db.Entry(Suppliers).State = System.Data.Entity.EntityState.Detached;
db.SaveChanges();
//edit name of Suppliers
string name = Suppliers.CompanyName;
string nameExpected = "test1223";
Suppliers.CompanyName = nameExpected;
//Act
//run controller action
await controller.Edit(Suppliers);
controller.Dispose();
string actual = db.Suppliers.Where(x => x.SupplierID == Suppliers.SupplierID).First().CompanyName;
//Assert
//check and delete Suppliers
Assert.AreEqual(nameExpected, actual);
Suppliers = db.Suppliers.Where(x => x.SupplierID == Suppliers.SupplierID).First();
Suppliers.CompanyName = name;
db.Entry(Suppliers).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
db.Dispose();
}
public async Task <ActionResult> Edit([Bind("ProductID,ProductName,SupplierID,CategoryID,QuantityPerUnit,UnitPrice,UnitsInStock,UnitsOnOrder,ReorderLevel,Discontinued")] Products products, IFormFile ProductImage)
{
try
{
if (!((ProductImage == null) || ProductImage.ContentType.Contains("image")))
{
throw new ArgumentException("The provided file is not an image");
}
if (ModelState.IsValid && !(String.IsNullOrEmpty(products.ProductName)))
{
db.Entry(products).State = EntityState.Modified;
await db.SaveChangesAsync();
if (ProductImage != null)
{
string path = System.IO.Path.Combine(Startup._hostingEnvironment.WebRootPath + ($"Images/{db.Categories.Where(x => x.CategoryID == products.CategoryID).FirstOrDefault().CategoryName}/"), $"{products.ProductID}.jpg");
using (var fileStream = new FileStream(path, FileMode.Create))
{
await ProductImage.CopyToAsync(fileStream);
}
}
}
ViewBag.CategoryID = new SelectList(db.Categories, "CategoryID", "CategoryName", products.CategoryID);
ViewBag.SupplierID = new SelectList(db.Suppliers, "SupplierID", "CompanyName", products.SupplierID);
return(View(products));
}
catch (NullReferenceException e)
{
//todo
//logger.Error(e.ToString());
throw new NullReferenceException("Imaginea nu a putut fi gasita");
}
catch (DbUpdateException e)
{
//todo
//logger.Error(e.ToString());
throw new DbUpdateException("Nu s-au putut efectua modificatile", new Exception());
}
catch (ArgumentException e)
{
//
//logger.Error(e.ToString());
throw new ArgumentException("Fisierul ales nu este o imagine");
}
catch (Exception e)
{
//if something else goes wrong
//todo
//logger.Error(e.ToString());
throw new Exception("Ceva nu a mers bine, va rugam reincercati. Daca problema persista contactati un administrator.");
}
}
public async System.Threading.Tasks.Task ProductEditItemAsync()
{
//Arrange
//init
var controller = new ProductController();
var db = new NorthwindDatabase();
//create product
var product = new Products()
{
ProductName = "test", CategoryID = 1, SupplierID = 1
};
db.Entry(product).State = System.Data.Entity.EntityState.Added;
db.SaveChanges();
//detach product from db
db.Entry(product).State = System.Data.Entity.EntityState.Detached;
db.SaveChanges();
//edit name of product
string name = product.ProductName;
string nameExpected = "test12232";
product.ProductName = nameExpected;
//Act
//run controller action
await controller.Edit(product, null);
controller.Dispose();
string actual = db.Products.Where(x => x.ProductID == product.ProductID).First().ProductName;
//Assert
//check and delete product
Assert.AreEqual(nameExpected, actual);
product = db.Products.Where(x => x.ProductID == product.ProductID).First();
product.ProductName = name;
db.Entry(product).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
db.Dispose();
}
public async Task <ActionResult> Edit([Bind(Include = "TerritoryID,TerritoryDescription,RegionID")] Territories territories)
{
if (ModelState.IsValid)
{
db.Entry(territories).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Details", "Regions", new { id = Convert.ToInt32(TempData["RegionID"]) }));
}
ViewBag.RegionID = new SelectList(db.Regions, "RegionID", "RegionDescription", territories.RegionID);
return(View(territories));
}
public async Task <ActionResult> Edit([Bind(Include = "OrderID,CustomerID,EmployeeID,OrderDate,RequiredDate,ShippedDate,ShipVia,Freight,ShipName,ShipAddress,ShipCity,ShipRegion,ShipPostalCode,ShipCountry")] Orders orders)
{
if (ModelState.IsValid)
{
db.Entry(orders).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.CustomerID = new SelectList(db.Customers, "CustomerID", "CompanyName", orders.CustomerID);
ViewBag.EmployeeID = new SelectList(db.Employees, "EmployeeID", "LastName", orders.EmployeeID);
ViewBag.ShipVia = new SelectList(db.Shippers, "ShipperID", "CompanyName", orders.ShipVia);
return(View(orders));
}
public async Task <ActionResult> Edit([Bind(Include = "OrderID,ProductID,Quantity,Discount")] Order_Details order_Details)
{
order_Details.UnitPrice = db.Products.Find(order_Details.ProductID).UnitPrice ?? 0;
if (ModelState.IsValid)
{
db.Entry(order_Details).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Details", "Orders", new { id = order_Details.OrderID }));
}
ViewBag.OrderID = new SelectList(db.Orders, "OrderID", "CustomerID", order_Details.OrderID);
ViewBag.ProductID = new SelectList(db.Products, "ProductID", "ProductName", order_Details.ProductID);
return(View(order_Details));
}
public async Task <ActionResult> Edit([Bind("CategoryID,CategoryName,Description")] Categories categories)
{
if (!ModelState.IsValid)
{
return(View(categories));
}
if (db.Categories.Where(c => (c.CategoryName == categories.CategoryName) && (c.CategoryID != categories.CategoryID)).Count() != 0)
{
ModelState.AddModelError("CategoryName", "Numele de categorie este deja folosit");
return(View(categories));
}
db.Entry(categories).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit([Bind(Include = "ProductID,ProductName,SupplierID,CategoryID,QuantityPerUnit,UnitPrice,UnitsInStock,UnitsOnOrder,ReorderLevel,Discontinued")] Products products, HttpPostedFileBase ProductImage)
{
try
{
if (!((ProductImage == null) || ProductImage.ContentType.Contains("image")))
{
throw new ArgumentException("The provided file is not an image");
}
if (ModelState.IsValid && !(String.IsNullOrEmpty(products.ProductName)))
{
db.Entry(products).State = EntityState.Modified;
await db.SaveChangesAsync();
if (ProductImage != null)
{
string path = System.IO.Path.Combine(Server.MapPath($"~/images/{db.Categories.Where(x => x.CategoryID == products.CategoryID).FirstOrDefault().CategoryName}/"), $"{products.ProductID}.jpg");
System.IO.File.Delete(path);
ProductImage.SaveAs(path);
}
}
ViewBag.CategoryID = new SelectList(db.Categories, "CategoryID", "CategoryName", products.CategoryID);
ViewBag.SupplierID = new SelectList(db.Suppliers, "SupplierID", "CompanyName", products.SupplierID);
return(View(products));
}
catch (NullReferenceException e)
{
logger.Error(e.ToString());
throw new NullReferenceException("Imaginea nu a putut fi gasita");
}
catch (System.Data.Entity.Infrastructure.DbUpdateException e)
{
logger.Error(e.ToString());
throw new System.Data.Entity.Infrastructure.DbUpdateException("Nu s-au putut efectua modificatile");
}
catch (ArgumentException e)
{
logger.Error(e.ToString());
throw new ArgumentException("Fisierul ales nu este o imagine");
}
catch (Exception e)
{
//if something else goes wrong
logger.Error(e.ToString());
throw new Exception("Ceva nu a mers bine, va rugam reincercati. Daca problema persista contactati un administrator.");
}
}
public async Task OrderDetailReturnsEditEdits()
{
//Arrange
Orders OrderTest = new Orders()
{
OrderID = 22, CustomerID = "ALFKI", EmployeeID = 3
};
Order_Details detailsTest = new Order_Details()
{
ProductID = 20, UnitPrice = 23, Quantity = 12, Discount = 1, Order = OrderTest
};
await _detailsControllerUnderTest.Create(detailsTest, OrderTest.OrderID);
db.Entry(detailsTest).State = System.Data.Entity.EntityState.Added;
var expectedDetails = db.Order_Details.Find(detailsTest.OrderID, detailsTest.ProductID);
db.Dispose();
detailsTest.UnitPrice = 43;
detailsTest.Quantity = 22;
db = new NorthwindDatabase();
//Act
await _detailsControllerUnderTest.Edit(detailsTest);
db.Entry(detailsTest).State = System.Data.Entity.EntityState.Modified;
var actualDetails = db.Order_Details.Find(detailsTest.OrderID, detailsTest.ProductID);
//Assert
Assert.AreEqual(expectedDetails, actualDetails);
var details = db.Order_Details.Where(o => o.OrderID == detailsTest.OrderID && o.ProductID == detailsTest.ProductID && o.UnitPrice == detailsTest.UnitPrice && o.Quantity == detailsTest.Quantity && o.Discount == detailsTest.Discount);
var orders = db.Orders.Find(OrderTest.OrderID);
foreach (var orderdet in details)
{
db.Order_Details.Remove(orderdet);
}
db.Orders.Remove(orders);
db.SaveChanges();
}
public async System.Threading.Tasks.Task SuppliersCreateItemAsync()
{
//Arrange
var controller = new NorthwindWeb.Controllers.SuppliersController();
var db = new NorthwindDatabase();
int SuppliersCountBefore = db.Suppliers.Count();
var Suppliers = new Suppliers()
{
CompanyName = "TestSuppliersCreate",
ContactName = "contact",
};
//Act
await controller.Create(Suppliers);
//Assert
Assert.AreEqual(SuppliersCountBefore + 1, db.Suppliers.Count());
db.Entry(Suppliers).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
controller.Dispose();
db.Dispose();
}
public async Task TerritoryEditEdits()
{
//Arrange
Region regionTest = new Region()
{
RegionID = 100, RegionDescription = "test"
};
Territories territoryTest = new Territories()
{
TerritoryID = "102", TerritoryDescription = "Aici", Region = regionTest
};
await _territoriesControllerTest.Create(territoryTest, regionTest.RegionID);
db.Entry(territoryTest).State = System.Data.Entity.EntityState.Added;
var expectedTerritory = db.Territories.Find(territoryTest.TerritoryID);
db.Dispose();
territoryTest.TerritoryDescription = "Acolo";
db = new NorthwindDatabase();
//Act
await _territoriesControllerTest.Edit(territoryTest);
db.Entry(territoryTest).State = System.Data.Entity.EntityState.Modified;
var actualTerritory = db.Territories.Find(territoryTest.TerritoryID);
//Assert
Assert.AreEqual(expectedTerritory, actualTerritory);
var territory = db.Territories.Where(t => (t.TerritoryDescription == "Aici") || (t.TerritoryDescription == "Acolo"));
db.Territories.RemoveRange(territory);
var regions = db.Regions.Where(t => t.RegionDescription.Contains(regionTest.RegionDescription));
db.Regions.RemoveRange(regions);
db.SaveChanges();
}
public async System.Threading.Tasks.Task ProductDeleteItemAsync()
{
//Arrange
var controller = new ProductController();
var db = new NorthwindDatabase();
//create product
var product = new Products()
{
ProductName = "test", CategoryID = 1, SupplierID = 1
};
db.Entry(product).State = System.Data.Entity.EntityState.Added;
db.SaveChanges();
//Act
try
{
//run controller action
await controller.DeleteConfirmed(product.ProductID);
controller.Dispose();
}
catch (Exception ex)
{
//image not found
if (!(ex is NullReferenceException))
{
throw;
}
}
//Assert
//this will throw a InvalidOperationException
if (db.Products.Any(x => x.ProductID == product.ProductID))
{
Assert.Fail();
}
}