public void T1_RevertDirectedReferenceCollection()
{
var ctx = Default.DataContext();
// get data
var employee = ctx.Employees
.AsQueryable()
.Include("Territories")
.Single(e => e.EmployeeID == EMPLOYEE_ID);
var territory1 = ctx.Territories.AsQueryable().Single(t => t.TerritoryID == TERRITORY1_ID);
var territory2 = ctx.Territories.AsQueryable().Single(t => t.TerritoryID == TERRITORY2_ID);
var territory3 = ctx.Territories.AsQueryable().Single(t => t.TerritoryID == TERRITORY3_ID);
// check initial state
Expect(employee, Is.Not.Null);
Expect(territory1, Is.Not.Null);
Expect(territory2, Is.Not.Null);
Expect(territory3, Is.Not.Null);
Expect(employee.Territories, Is.Not.Empty);
Expect(employee.Territories.Count, Is.EqualTo(2));
Assert.Contains(territory1, employee.Territories.ToArray());
Assert.Contains(territory2, employee.Territories.ToArray());
Expect(employee.HasChanges, Is.False);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// add one new
employee.Territories.Add(territory3);
Expect(employee.Territories.Count, Is.EqualTo(3));
Assert.Contains(territory3, employee.Territories.ToArray());
Expect(employee.HasChanges, Is.True);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory3.HasChanges, Is.False);
Expect(territory3.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// revert
employee.RevertChanges();
Expect(employee.Territories.Count, Is.EqualTo(2));
Expect(employee.HasChanges, Is.False);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory3.HasChanges, Is.False);
Expect(territory3.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// remove one existing
employee.Territories.Remove(territory2);
Expect(employee.Territories.Count, Is.EqualTo(1));
Expect(employee.HasChanges, Is.True);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory2.HasChanges, Is.False);
Expect(territory2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// revert
employee.RevertChanges();
Expect(employee.Territories.Count, Is.EqualTo(2));
Expect(employee.HasChanges, Is.False);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory2.HasChanges, Is.False);
Expect(territory2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// remove all existing, add one new, and re-add one of the old
employee.Territories.Clear();
Expect(employee.Territories.Count, Is.EqualTo(0));
Expect(employee.Territories, Is.Empty);
Expect(employee.HasChanges, Is.True);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
employee.Territories.Add(territory3);
employee.Territories.Add(territory2);
Expect(territory1.HasChanges, Is.False);
Expect(territory2.HasChanges, Is.False);
Expect(territory3.HasChanges, Is.False);
Expect(territory1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory3.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// revert
employee.RevertChanges();
Expect(employee.Territories.Count, Is.EqualTo(2));
Expect(employee.HasChanges, Is.False);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory1.HasChanges, Is.False);
Expect(territory2.HasChanges, Is.False);
Expect(territory3.HasChanges, Is.False);
Expect(territory1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(territory3.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// add one new, remove one existing, and accept changes
Assert.Contains(territory1, employee.Territories.ToArray());
Assert.Contains(territory2, employee.Territories.ToArray());
employee.Territories.Add(territory3);
employee.Territories.Remove(territory2);
Expect(employee.Territories.Count, Is.EqualTo(2));
Expect(employee.Territories, Is.Not.Empty);
Expect(employee.HasChanges, Is.True);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Assert.Contains(territory1, employee.Territories.ToArray());
Assert.Contains(territory3, employee.Territories.ToArray());
employee.AcceptChanges();
Expect(employee.HasChanges, Is.False);
Expect(employee.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// revert
employee.RevertChanges();
Expect(employee.Territories.Count, Is.EqualTo(2));
Assert.Contains(territory1, employee.Territories.ToArray());
Assert.Contains(territory3, employee.Territories.ToArray());
}
public void SetReferenceToAddedEntity()
{
var ctx = Default.DataContext();
// load suppliers
ctx.Suppliers.AsQueryable().WhereIn(s => s.SupplierID, SUPPLIER1_ID, SUPPLIER2_ID, SUPPLIER3_ID, SUPPLIER4_ID).Execute();
var supplier1 = ctx.Suppliers.SingleOrDefault(s => s.SupplierID == SUPPLIER1_ID);
var supplier2 = ctx.Suppliers.SingleOrDefault(s => s.SupplierID == SUPPLIER2_ID);
var supplier3 = ctx.Suppliers.SingleOrDefault(s => s.SupplierID == SUPPLIER3_ID);
var supplier4 = ctx.Suppliers.SingleOrDefault(s => s.SupplierID == SUPPLIER4_ID);
Expect(supplier1, Is.Not.Null);
Expect(supplier2, Is.Not.Null);
Expect(supplier3, Is.Not.Null);
Expect(supplier4, Is.Not.Null);
// add new product
var product = new Product();
ctx.Products.Add(product);
Expect(product.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
// set supplier reference (existing supplier)
product.Supplier = supplier1;
Expect(product.HasChanges, Is.True); // product has changes (state is added)
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
Expect(supplier1.HasChanges, Is.True); // supplier1 has changes (state is unchanged)
Expect(supplier1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(supplier2.HasChanges, Is.False); // supplier2 has no changes (state is unchanged)
Expect(supplier2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// set different supplier reference (existing supplier)
product.Supplier = supplier2;
Expect(product.HasChanges, Is.True); // product has changes (state is added)
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
Expect(supplier1.HasChanges, Is.False); // supplier1 has no changes anymore (state is unchanged)
Expect(supplier1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(supplier2.HasChanges, Is.True); // supplier2 has changes now (state is unchanged)
Expect(supplier2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// set different supplier reference (existing supplier)
product.Supplier = supplier3;
Expect(product.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
// set different supplier reference (existing supplier)
product.Supplier = supplier4;
Expect(product.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
// set supplier reference to null
product.Supplier = null;
Expect(product.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
// set different supplier reference (existing supplier)
product.Supplier = supplier4;
Expect(product.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
// create and add new supplier to context (using factory method)
var newSupplier1 = ctx.Suppliers.CreateNew();
Expect(newSupplier1.HasChanges, Is.True);
Expect(newSupplier1.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
// set different supplier reference (new supplier)
product.Supplier = newSupplier1;
Expect(product.HasChanges, Is.True);
Expect(newSupplier1.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
Expect(newSupplier1.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
// create new supplier without adding it to context
var newSupplier2 = new Supplier();
Expect(newSupplier2.HasChanges, Is.True);
Expect(newSupplier2.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
// set different supplier reference (new supplier)
product.Supplier = newSupplier2;
Expect(product.HasChanges, Is.True);
Expect(newSupplier2.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
Expect(newSupplier2.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
}
public void T1_RevertDirectedReference()
{
var ctx = Default.DataContext();
// get data
var product = ctx.Products
.AsQueryable()
.Include("Category")
.Single(p => p.ProductID == PROD_ID);
var oldCategory = ctx.Categories.AsQueryable().Single(c => c.CategoryID == CAT_OLD_ID);
var newCategory = ctx.Categories.AsQueryable().Single(c => c.CategoryID == CAT_NEW_ID);
// check initial state
Expect(product.CategoryID, Is.EqualTo(CAT_OLD_ID));
Expect(product.Category, Is.EqualTo(oldCategory));
Expect(product.HasChanges, Is.False);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// set new
product.Category = newCategory;
Expect(product.CategoryID, Is.EqualTo(CAT_NEW_ID));
Expect(product.Category, Is.EqualTo(newCategory));
Expect(product.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Modified));
// revert to old
product.RevertChanges();
Expect(product.CategoryID, Is.EqualTo(CAT_OLD_ID));
Expect(product.Category, Is.EqualTo(oldCategory));
Expect(product.HasChanges, Is.False);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// set null
product.Category = null;
Expect(product.CategoryID, Is.Null);
Expect(product.Category, Is.Null);
Expect(product.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Modified));
// revert to old
product.RevertChanges();
Expect(product.CategoryID, Is.EqualTo(CAT_OLD_ID));
Expect(product.Category, Is.EqualTo(oldCategory));
Expect(product.HasChanges, Is.False);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// set null and accept
product.Category = null;
product.AcceptChanges();
Expect(product.CategoryID, Is.Null);
Expect(product.Category, Is.Null);
Expect(product.HasChanges, Is.False);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// set new
product.Category = newCategory;
Expect(product.CategoryID, Is.EqualTo(CAT_NEW_ID));
Expect(product.Category, Is.EqualTo(newCategory));
Expect(product.HasChanges, Is.True);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Modified));
// revert to null
product.RevertChanges();
Expect(product.CategoryID, Is.Null);
Expect(product.Category, Is.Null);
Expect(product.HasChanges, Is.False);
Expect(product.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
}
public void IncludeOnForChangedRelatedEntities()
{
var ctx = Default.DataContext();
var prodcount = ctx.Products.AsQueryable().Count();
//create new category and new supplier for a new product and save together
var newCategory = ctx.Categories.CreateNew(false);
var newSupplier = ctx.Suppliers.CreateNew(false);
var newProduct = ctx.Products.CreateNew(false);
newCategory.CategoryName = "NewCategory";
newCategory.Description = "NewCategory for Test Description";
Expect(newCategory.HasChanges, Is.True);
Expect(newCategory.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
newSupplier.CompanyName = "TestCompanyName";
newSupplier.Region = "TestRegion";
newSupplier.PostalCode = "007007";
newSupplier.Phone = "1234567890";
newSupplier.ContactName = "TestContact";
newSupplier.ContactTitle = "TestTitle";
newSupplier.City = "TestCity";
newSupplier.Address = "TestAdress";
newSupplier.Country = "TestCountry";
Expect(newSupplier.HasChanges, Is.True);
Expect(newSupplier.ChangeTracker.State, Is.EqualTo(ObjectState.Added));
newProduct.ProductName = "TestName";
newProduct.QuantityPerUnit = "2";
newProduct.UnitPrice = 33;
newProduct.Discontinued = false;
newProduct.ReorderLevel = 0;
newProduct.UnitsInStock = 3;
newProduct.UnitsOnOrder = 0;
newProduct.Category = newCategory;
newProduct.Supplier = newSupplier;
ctx.Add(newCategory);
ctx.Add(newSupplier);
ctx.Add(newProduct);
//save all in one call
ctx.SaveChanges();
// check existance in entity set
var catElement = ctx.Categories.GetAllEntities().FirstOrDefault(p => object.ReferenceEquals(p, newCategory));
Expect(catElement, Is.Not.Null);
var suppElement = ctx.Suppliers.GetAllEntities().FirstOrDefault(p => object.ReferenceEquals(p, newSupplier));
Expect(suppElement, Is.Not.Null);
var prodElement = ctx.Products.GetAllEntities().FirstOrDefault(p => object.ReferenceEquals(p, newProduct));
Expect(prodElement, Is.Not.Null);
//delete created entities
ctx.Delete(newProduct);
ctx.Delete(newSupplier);
ctx.Delete(newCategory);
//save deletes in one call (execution order must match for delete to be successful)
//have to supply a secret to make the delete pass thru clientinfo test logic in service
var clientInfo = new ClientInfo();
clientInfo["ForceDelete"] = "yes please";
ServerValidationException serverValidationException = null;
try
{
ctx.SaveChanges(clientInfo: clientInfo);
}
catch (ServerValidationException ex)
{
serverValidationException = ex;
throw;
}
catch (UpdateException ex)
{
foreach (var se in ex.StateEntries)
{
string error = string.Empty;
if (se.Entity != null)
{
foreach (var er in se.Entity.Errors)
{
error += er.Message;
}
}
if (se.StoreValue != null)
{
foreach (var er in se.StoreValue.Errors)
{
error += er.Message;
}
}
Expect(error.Length == 0, String.Format("Concatenated Errors from StateEntities: {0}", error));
}
throw;
}
// check existance in entity set
catElement = ctx.Categories.GetAllEntities().FirstOrDefault(p => object.ReferenceEquals(p, newCategory));
Expect(catElement, Is.Null);
suppElement = ctx.Suppliers.GetAllEntities().FirstOrDefault(p => object.ReferenceEquals(p, newSupplier));
Expect(suppElement, Is.Null);
prodElement = ctx.Products.GetAllEntities().FirstOrDefault(p => object.ReferenceEquals(p, newProduct));
Expect(prodElement, Is.Null);
}
public void T1_RevertReferenceCollection()
{
var ctx = Default.DataContext();
// get data
var customer = ctx.Customers
.AsQueryable()
.Include("CustomerDemographics")
.Single(c => c.CustomerID == CUSTOMER_ID);
var customerGroup1 = ctx.DemographicGroups.AsQueryable().Single(g => g.CustomerTypeID == GROUP1_ID);
var customerGroup2 = ctx.DemographicGroups.AsQueryable().Single(g => g.CustomerTypeID == GROUP2_ID);
Expect(customer, Is.Not.Null);
Expect(customerGroup1, Is.Not.Null);
Expect(customerGroup2, Is.Not.Null);
Expect(customer.CustomerDemographics, Is.Empty);
Expect(customer.CustomerDemographics.Count, Is.EqualTo(0));
Expect(customer.HasChanges, Is.False);
Expect(customer.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup1.HasChanges, Is.False);
Expect(customerGroup2.HasChanges, Is.False);
Expect(customerGroup1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// add one group
customer.CustomerDemographics.Add(customerGroup1);
Expect(customer.CustomerDemographics, Is.Not.Empty);
Expect(customer.CustomerDemographics.Count, Is.EqualTo(1));
Expect(customerGroup1.Customers, Is.Not.Empty);
Expect(customerGroup1.Customers.Count, Is.EqualTo(1));
Expect(customer.HasChanges, Is.True);
Expect(customer.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup1.HasChanges, Is.True);
Expect(customerGroup1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Assert.Contains(customerGroup1, customer.CustomerDemographics.ToArray());
Assert.Contains(customer, customerGroup1.Customers.ToArray());
// revert on customer
customer.RevertChanges();
Expect(customer.CustomerDemographics, Is.Empty);
Expect(customer.CustomerDemographics.Count, Is.EqualTo(0));
Expect(customerGroup1.Customers, Is.Empty);
Expect(customerGroup1.Customers.Count, Is.EqualTo(0));
// add two groups
customer.CustomerDemographics.Add(customerGroup1);
customer.CustomerDemographics.Add(customerGroup2);
Expect(customer.CustomerDemographics, Is.Not.Empty);
Expect(customer.CustomerDemographics.Count, Is.EqualTo(2));
Expect(customerGroup1.Customers, Is.Not.Empty);
Expect(customerGroup1.Customers.Count, Is.EqualTo(1));;
Expect(customerGroup2.Customers, Is.Not.Empty);
Expect(customerGroup2.Customers.Count, Is.EqualTo(1));
Expect(customer.HasChanges, Is.True);
Expect(customer.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup1.HasChanges, Is.True);
Expect(customerGroup1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup2.HasChanges, Is.True);
Expect(customerGroup2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Assert.Contains(customerGroup1, customer.CustomerDemographics.ToArray());
Assert.Contains(customerGroup2, customer.CustomerDemographics.ToArray());
Assert.Contains(customer, customerGroup1.Customers.ToArray());
Assert.Contains(customer, customerGroup2.Customers.ToArray());
// revert on one group
customerGroup1.RevertChanges();
Expect(customer.CustomerDemographics, Is.Not.Empty);
Expect(customer.CustomerDemographics.Count, Is.EqualTo(1));
Expect(customerGroup1.Customers, Is.Empty);
Expect(customerGroup1.Customers.Count, Is.EqualTo(0));;
Expect(customerGroup2.Customers, Is.Not.Empty);
Expect(customerGroup2.Customers.Count, Is.EqualTo(1));
Expect(customer.HasChanges, Is.True);
Expect(customer.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup1.HasChanges, Is.False);
Expect(customerGroup1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup2.HasChanges, Is.True);
Expect(customerGroup2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Assert.Contains(customerGroup2, customer.CustomerDemographics.ToArray());
Assert.Contains(customer, customerGroup2.Customers.ToArray());
// accept changes on customer
customer.AcceptChanges();
Expect(customer.HasChanges, Is.False);
Expect(customer.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup1.HasChanges, Is.False);
Expect(customerGroup1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup2.HasChanges, Is.True); // note: changes on customer group have not yet been accepted
Expect(customerGroup2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
// revert on group
customerGroup2.RevertChanges();
Expect(customer.HasChanges, Is.True); // note: since chage has been accepted, this revert is now a change
Expect(customer.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup1.HasChanges, Is.False);
Expect(customerGroup1.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
Expect(customerGroup2.HasChanges, Is.False);
Expect(customerGroup2.ChangeTracker.State, Is.EqualTo(ObjectState.Unchanged));
}
public void T1_AddReferences()
{
var ctx = Default.DataContext();
// create supplier
var supplier1 = ctx.Suppliers.CreateNew();
supplier1.AcceptChanges();
// create products
var product1 = ctx.Products.CreateNew();
var product2 = ctx.Products.CreateNew();
var product3 = ctx.Products.CreateNew();
// set supplier reference (existing supplier)
product1.Supplier = supplier1;
Expect(product1.HasChanges, Is.True); // product has changes
Expect(supplier1.HasChanges, Is.True); // supplier has changes
Expect(supplier1.Products.Count, Is.EqualTo(1));
// begin edit of suplier
var editableSuplier = supplier1 as IEditable;
Expect(editableSuplier, Is.Not.Null);
Expect(editableSuplier.CanEdit, Is.True);
Expect(editableSuplier.CanCancelEdit, Is.False);
Expect(editableSuplier.IsEditing, Is.False);
editableSuplier.BeginEdit();
Expect(editableSuplier.CanEdit, Is.True);
Expect(editableSuplier.CanCancelEdit, Is.True);
Expect(editableSuplier.IsEditing, Is.True);
// set different supplier
product2.Supplier = supplier1;
Expect(product2.Supplier, Is.EqualTo(supplier1));
Expect(supplier1.Products.Count, Is.EqualTo(2));
// cancel edit of suplier
editableSuplier.CancelEdit();
Expect(product2.Supplier, Is.Null);
Expect(supplier1.Products.Count, Is.EqualTo(1));
// re-begin edit of suplier
editableSuplier.BeginEdit();
Expect(supplier1.HasChanges, Is.True); // supplier still has changes
// set different supplier
product3.Supplier = supplier1;
Expect(product3.Supplier, Is.EqualTo(supplier1));
Expect(supplier1.Products.Count, Is.EqualTo(2));
// end edit of suplier
editableSuplier.EndEdit();
Expect(product3.Supplier, Is.EqualTo(supplier1));
Expect(supplier1.Products.Count, Is.EqualTo(2));
}
