public void DomainContext_Submit_DomainMethodAndCRUD()
{
List<string> propChanged_addedCity = new List<string>();
City newCity = new City { Name = "Sammamish", CountyName = "King", StateName = "WA" };
int refZipCode = 0;
int refCityCount = 0;
CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities);
LoadOperation lo = citiesProvider.Load(citiesProvider.GetCitiesQuery(), false);
SubmitOperation so = null;
// wait for LoadCities to complete, then LoadZips
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(delegate
{
refCityCount = citiesProvider.Cities.Count;
lo = citiesProvider.Load(citiesProvider.GetZipsQuery(), false);
});
// wait for Load to complete, then invoke some domain methods
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(delegate
{
// this test the following combinations of CRUD and Domain method in changeset:
// - Invoke -> update
// - Add -> invoke
// - Remove
// - Invoke only
City[] cities = citiesProvider.Cities.ToArray();
cities[0].ZoneName = "Zone44";
cities[0].AssignCityZone("Zone1");
cities[1].AssignCityZone("Zone2");
citiesProvider.Cities.Add(newCity);
newCity.AssignCityZone("Zone3");
citiesProvider.Cities.Remove(cities[4]);
citiesProvider.Cities.Remove(cities[5]);
// keep a reference zip code before invoking the method: this will increment Code by offset=1 on the server
Zip zip = citiesProvider.Zips.First();
refZipCode = zip.Code;
zip.ReassignZipCode(1, true);
newCity.PropertyChanged += delegate(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (e.PropertyName != "IsReadOnly" && e.PropertyName != "HasChanges"
&& e.PropertyName != "EntityState" && e.PropertyName != "ValidationErrors")
{
propChanged_addedCity.Add(e.PropertyName);
}
};
Assert.IsTrue(newCity.CanAssignCityZoneIfAuthorized);
Assert.IsTrue(newCity.CanAutoAssignCityZone);
so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
Assert.IsFalse(newCity.CanAssignCityZoneIfAuthorized);
Assert.IsFalse(newCity.CanAutoAssignCityZone);
Assert.AreEqual(3, so.ChangeSet.ModifiedEntities.Count);
Assert.AreEqual(1, so.ChangeSet.AddedEntities.Count);
Assert.AreEqual(2, so.ChangeSet.RemovedEntities.Count);
});
EnqueueConditional(() => so.IsComplete);
EnqueueCallback(delegate
{
Assert.IsNull(so.Error, string.Format("SubmitOperation.Error should be null.\r\nMessage: {0}\r\nStack Trace:\r\n{1}", so.Error != null ? so.Error.Message : string.Empty, so.Error != null ? so.Error.StackTrace : string.Empty));
Assert.IsTrue(newCity.CanAssignCityZoneIfAuthorized);
Assert.IsTrue(newCity.CanAutoAssignCityZone);
Assert.IsTrue(newCity.CanAssignCityZone);
// verify we got property change notifications for the new city entity (guard property should be reverted once SubmitChanges is called)
Assert.AreEqual(9, propChanged_addedCity.Count);
Assert.AreEqual(1, propChanged_addedCity.Count(prop => prop == "ZoneName"));
Assert.AreEqual(1, propChanged_addedCity.Count(prop => prop == "ZoneID"));
Assert.AreEqual(1, propChanged_addedCity.Count(prop => prop == "CanAssignCityZone"));
Assert.AreEqual(1, propChanged_addedCity.Count(prop => prop == "IsAssignCityZoneInvoked"));
// The other custom method invocations should have changed from true -> false during submit
// and from false -> true after submit
Assert.AreEqual(2, propChanged_addedCity.Count(prop => prop == "CanAssignCityZoneIfAuthorized"));
Assert.AreEqual(2, propChanged_addedCity.Count(prop => prop == "CanAutoAssignCityZone"));
// verify entities are auto-synced back to the client as a result of the domain method execution on server
Assert.AreEqual(1, citiesProvider.Cities.Single<City>(c => (c.ZoneName == "Zone1" && c.CountyName == "King")).ZoneID);
Assert.AreEqual(2, citiesProvider.Cities.Single<City>(c => (c.ZoneName == "Zone2")).ZoneID);
Assert.AreEqual(3, citiesProvider.Cities.Single<City>(c => (c.ZoneName == "Zone3" && c.Name == newCity.Name)).ZoneID);
Assert.IsTrue(citiesProvider.Zips.Any<Zip>(z => z.Code == refZipCode - 1));
// verify unchanged entities
Assert.IsFalse(citiesProvider.Cities.Any(c => (c.ZoneName == null && c.ZoneID != 0)));
// verify that after a successful submit, DM invocations on the entities have been accepted
Assert.IsFalse(so.ChangeSet.ModifiedEntities.Any(p => p.EntityActions.Any()));
EntityChangeSet changeSet = citiesProvider.EntityContainer.GetChanges();
Assert.IsTrue(changeSet.IsEmpty);
});
EnqueueTestComplete();
}
public void CustomMethod_ValidationExceptionRecovery()
{
bool completed = false;
Zip zip = null;
SubmitOperation submitOp = null;
LoadOperation<Zip> loadOp = null;
EventHandler completedDelegate = (sender, args) => completed = true;
CityDomainContext context = new CityDomainContext(TestURIs.Cities);
loadOp = context.Load(context.GetZipsQuery(), false);
loadOp.Completed += completedDelegate;
this.EnqueueConditional(() => completed);
this.EnqueueCallback(() =>
{
Assert.IsFalse(loadOp.HasError, "Failed to load Zips");
// Grab a Zip and invoke a custom operation that will throw a ValidationException.
zip = context.Zips.First();
zip.ThrowException(typeof(ValidationException).Name);
// Submit
completed = false;
submitOp = context.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
submitOp.Completed += completedDelegate;
// Verify entity state
Assert.IsTrue(zip.IsReadOnly, "Expected Zip to be in a read-only state.");
Assert.IsTrue(zip.IsSubmitting, "Expected Zip to be in a submitting state.");
Assert.AreEqual(1, zip.EntityActions.Count(), "Expected Zip EntityActions property to contain a single invocation");
});
this.EnqueueConditional(() => completed);
this.EnqueueCallback(() =>
{
// Verify results
Assert.IsTrue(submitOp.HasError, "Expected errors.");
Assert.AreEqual(1, submitOp.EntitiesInError.Count(), "Expected 1 Zip entity in error.");
Assert.AreEqual(submitOp.EntitiesInError.Single(), zip, "Expected 1 Zip entity in error.");
Assert.AreEqual(1, zip.ValidationErrors.Count, "Expected 1 validation error on Zip entity.");
// Verify entity state
Assert.IsFalse(zip.IsReadOnly, "Zip should not be in a read-only state.");
Assert.IsFalse(zip.IsSubmitting, "Zip should not be in a submitting state.");
Assert.AreEqual(1, zip.EntityActions.Count(), "Expected Zip EntityActions property to contain a single invocation");
// Explicitly set a property
zip.StateName += "x";
});
this.EnqueueTestComplete();
}
public void ErrorPipeline_UnauthorizedEx()
{
CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities);
SubmitOperation so = null;
LoadOperation lo = citiesProvider.Load(citiesProvider.GetZipsQuery(), false);
// wait for Load to complete, then invoke domain method that throws on server. Submit.
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(delegate
{
Zip[] zips = citiesProvider.Zips.ToArray();
citiesProvider.Zips.Remove(zips[1]);
so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
});
// wait for submitted event being fired and verify submittedEventArgs.Error is not null
EnqueueConditional(() => so.IsComplete);
EnqueueCallback(delegate
{
DomainOperationException error = so.Error as DomainOperationException;
Assert.IsNotNull(error);
Assert.AreEqual(string.Format(Resource.DomainContext_SubmitOperationFailed, "Access to operation 'DeleteZip' was denied."), error.Message);
});
EnqueueTestComplete();
}
public void ErrorPipeline_DomainServiceEx()
{
CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities);
LoadOperation lo = citiesProvider.Load(citiesProvider.GetZipsQuery(), false);
SubmitOperation so = null;
// wait for Load to complete, then invoke domain method that throws on server. Submit.
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(delegate
{
Zip zip = citiesProvider.Zips.First();
zip.ThrowException("DomainServiceExceptionWithErrorCode");
so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
});
EnqueueConditional(() => so.IsComplete);
EnqueueCallback(delegate
{
DomainException ex = so.Error as DomainException;
Assert.IsNotNull(ex);
Assert.AreEqual("testing with error code", ex.Message);
Assert.AreEqual(10, ex.ErrorCode);
});
EnqueueTestComplete();
}
public void DomainContext_Submit_DomainMethodsThrow_EntityValidationError()
{
List<string>[] propChanged = new List<string>[] { new List<string>(), new List<string>(), new List<string>() };
int refZip = 0;
CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities);
SubmitOperation so = null;
LoadOperation lo = citiesProvider.Load(citiesProvider.GetZipsQuery(), false);
// wait for Load to complete, then invoke some domain methods
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(delegate
{
// invoke methods that cause exception
Zip[] zips = citiesProvider.Zips.ToArray();
citiesProvider.ThrowException(zips[0], "EntityValidationException");
citiesProvider.ThrowException(zips[1], "EntityValidationException");
// invoke method that does not cause exception
zips[2].ReassignZipCode(1, true);
refZip = zips[2].Code;
zips[0].PropertyChanged += delegate(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
propChanged[0].Add(e.PropertyName);
};
zips[1].PropertyChanged += delegate(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
propChanged[1].Add(e.PropertyName);
};
zips[2].PropertyChanged += delegate(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
propChanged[2].Add(e.PropertyName);
};
so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
});
EnqueueConditional(() => so.IsComplete);
EnqueueCallback(delegate
{
Assert.IsNotNull(so.Error);
DomainOperationException ex = so.Error as DomainOperationException;
// this is a case where method invocations causes a ValidationException.
Assert.AreEqual(OperationErrorStatus.ValidationFailed, ex.Status);
Assert.AreEqual(Resource.DomainContext_SubmitOperationFailed_Validation, ex.Message);
// verify ValidationError collection is correct
Zip[] zips = citiesProvider.Zips.ToArray();
IEnumerable<ValidationResult> errors = zips[0].ValidationErrors;
LogErrorListContents("citiesProvider.Zips[0].ValidationErrors", errors);
Assert.AreEqual(1, errors.Count());
ValidationResult vr = errors.First();
Assert.AreEqual("Invalid Zip properties!", vr.ErrorMessage);
Assert.AreEqual(2, vr.MemberNames.Count());
Assert.IsTrue(vr.MemberNames.Contains("CityName"));
Assert.IsTrue(vr.MemberNames.Contains("CountyName"));
errors = zips[1].ValidationErrors;
LogErrorListContents("citiesProvider.Zips[0].ValidationErrors", errors);
Assert.AreEqual(1, errors.Count());
vr = errors.First();
Assert.AreEqual("Invalid Zip properties!", vr.ErrorMessage);
Assert.AreEqual(2, vr.MemberNames.Count());
Assert.IsTrue(vr.MemberNames.Contains("CityName"));
Assert.IsTrue(vr.MemberNames.Contains("CountyName"));
// verify the Entity.ValidationErrors collection is populated as expected
Assert.IsTrue(propChanged[0].Contains("HasValidationErrors"));
Assert.IsTrue(propChanged[1].Contains("HasValidationErrors"));
// verify entities are not auto-synced back to the client because there were errors
Assert.IsFalse(propChanged[2].Contains("Code"));
Assert.IsFalse(propChanged[2].Contains("FourDigit"));
Assert.IsFalse(propChanged[2].Contains("HasValidationErrors"));
Assert.AreEqual(0, zips[2].ValidationErrors.Count());
Assert.AreEqual(refZip, zips[2].Code);
});
EnqueueTestComplete();
}
public void DomainContext_Submit_ValidationErrorDuringClientSubmit()
{
CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities);
Zip newZip = new Zip() { Code = 98765, FourDigit = 1234 };
Zip validZip = new Zip() { Code = 90000, FourDigit = 1000, CityName = "MyCity", StateName = "MY" };
City deletedCity = null;
SubmitOperation so = null;
LoadOperation loadCitiesOperation = citiesProvider.Load(citiesProvider.GetCitiesQuery(), false);
LoadOperation loadZipsOperation = citiesProvider.Load(citiesProvider.GetZipsQuery(), false);
// wait for Load to complete, then invoke domain method that throws on server. Submit.
EnqueueConditional(() => loadCitiesOperation.IsComplete && loadZipsOperation.IsComplete);
EnqueueCallback(delegate
{
// update entity in a way that caused entity validation to fail on client
Zip[] zips = citiesProvider.Zips.ToArray();
zips[0].CityName = zips[0].StateName;
// internally set domain method invocation to cause method param validation to fail on client
zips[0].CustomMethodInvocation = new EntityAction("ReassignZipCode", new object[] { -10000, true });
// insert entity that caused object/property validation to fail on client
citiesProvider.Zips.Add(newZip);
// Add a temporary error to that invalid object to ensure errors are reset during submit
newZip.ValidationErrors.Add(new ValidationResult("Temporary Error", new string[] { "StateName" }));
// insert entity that is valid
citiesProvider.Zips.Add(validZip);
// Add a temporary error to that valid object to ensure errors are reset during submit
validZip.ValidationErrors.Add(new ValidationResult("Temporary Error", new string[] { "StateName" }));
// remove city
City[] cities = citiesProvider.Cities.ToArray();
deletedCity = cities[1];
citiesProvider.Cities.Remove(deletedCity);
so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
});
// wait for submitted event being fired and verify Entity.ValidationErrors is not empty
EnqueueConditional(() => so.IsComplete);
EnqueueCallback(delegate
{
DomainOperationException ex = so.Error as DomainOperationException;
Assert.IsNotNull(ex);
Assert.AreEqual(OperationErrorStatus.ValidationFailed, ex.Status);
Assert.AreEqual(Resource.DomainContext_SubmitOperationFailed_Validation, ex.Message);
// verify errors are generated on the client side
Zip[] zips = citiesProvider.Zips.ToArray();
IEnumerable<ValidationResult> errors = zips[0].ValidationErrors;
LogErrorListContents("citiesProvider.Zips[0].ValidationErrors", errors);
Assert.AreEqual(2, errors.Count());
UnitTestHelper.AssertListContains<ValidationResult>(errors, (e => e.ErrorMessage == "The field offset must be between -9999 and 9999."));
UnitTestHelper.AssertListContains<ValidationResult>(errors, (e => e.ErrorMessage == "Zip codes cannot have matching city and state names" && e.MemberNames.Contains("StateName") && e.MemberNames.Contains("CityName")));
LogErrorListContents("newZip.ValidationErrors", newZip.ValidationErrors);
errors = newZip.ValidationErrors;
// Expect only 2 errors for the properties. The entity level error is not checked if property level checks fail
Assert.AreEqual(2, errors.Count());
UnitTestHelper.AssertListContains<ValidationResult>(errors, (e => e.ErrorMessage == "The CityName field is required."));
UnitTestHelper.AssertListContains<ValidationResult>(errors, (e => e.ErrorMessage == "The StateName field is required."));
Assert.AreEqual(0, deletedCity.ValidationErrors.Count(), "The deleted city shouldn't have any validation errors");
Assert.AreEqual(0, validZip.ValidationErrors.Count(), "The valid city shouldn't have any validation errors");
});
EnqueueTestComplete();
}
public void DomainContext_Submit_ValidationErrorOnServer()
{
CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities);
Zip newZip = null;
SubmitOperation so = null;
LoadOperation lo = citiesProvider.Load(citiesProvider.GetZipsQuery(), false);
// wait for Load to complete, then invoke domain method that throws on server. Submit.
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(delegate
{
// Add an entity that will cause a Validation exception on the server (99999 is used as a way to signal failure for our validator)
newZip = new Zip()
{
Code = 99999,
FourDigit = 8625,
CityName = "Redmond",
CountyName = "King",
StateName = "WA"
};
citiesProvider.Zips.Add(newZip);
newZip.ThrowException("InvalidOperationException");
so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
});
EnqueueConditional(() => so.IsComplete);
EnqueueCallback(delegate
{
DomainOperationException ex = so.Error as DomainOperationException;
Assert.IsNotNull(ex);
Assert.AreEqual(OperationErrorStatus.ValidationFailed, ex.Status);
Assert.AreEqual(Resource.DomainContext_SubmitOperationFailed_Validation, ex.Message);
IEnumerable<ValidationResult> errors = newZip.ValidationErrors;
LogErrorListContents("newZip.ValidationErrors", errors);
Assert.AreEqual(1, errors.Count());
UnitTestHelper.AssertListContains<ValidationResult>(errors, (e => e.ErrorMessage == "Server fails validation"));
});
EnqueueTestComplete();
}
public void DomainContext_Submit_ErrorsClearOnReject()
{
int refZip = 0;
CityDomainContext citiesProvider = new CityDomainContext(TestURIs.Cities);
SubmitOperation so = null;
LoadOperation lo = citiesProvider.Load(citiesProvider.GetZipsQuery(), false);
// wait for Load to complete, then invoke domain method that throws on server. Submit.
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(delegate
{
// invoke methods that cause exception
Zip[] zips = citiesProvider.Zips.ToArray();
zips[0].ThrowException("ValidationException");
so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
});
// wait for submitted event being fired and verify Entity.ValidationErrors is not empty
EnqueueConditional(() => so.IsComplete);
EnqueueCallback(delegate
{
DomainOperationException ex = so.Error as DomainOperationException;
Assert.IsNotNull(ex);
Zip zip = citiesProvider.Zips.First();
IEnumerable<ValidationResult> errors = zip.ValidationErrors;
LogErrorListContents("zips[0].ValidationErrors", errors);
Assert.AreEqual(1, errors.Count());
// Verify that failed submission does not clear out the last invocation
Assert.IsFalse(zip.CanThrowException);
Assert.IsTrue(zip.EntityActions.Any(a => a.Name == "ThrowException"));
// Add a custom validation error to ensure it gets cleared
zip.ValidationErrors.Add(new ValidationResult("Temporary Error"));
// Call RejectChanges and verify ValidationErrors collection is cleared
citiesProvider.RejectChanges();
Assert.IsFalse(zip.ValidationErrors.Any());
// Invoke domain method that does not throw on same entity
zip.ReassignZipCode(1, true);
refZip = zip.Code;
so = citiesProvider.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
});
// wait for submitted event being fired and verify Entity.ValidationErrors remains empty
EnqueueConditional(() => so.IsComplete);
EnqueueCallback(delegate
{
Zip zip = citiesProvider.Zips.First();
Assert.IsNull(so.Error);
Assert.IsFalse(zip.ValidationErrors.Any());
Assert.AreEqual(refZip + 1, zip.Code);
});
EnqueueTestComplete();
}
public void Cities_ShouldSupportLongQueries()
{
LoadOperation<Zip> lo = null;
const int zipToFind = 98053;
const int QUERY_ITERATIONS = 50;
EnqueueCallback(() =>
{
CityDomainContext dp = new CityDomainContext(TestURIs.Cities); // Abs URI so runs on desktop too
// Generate a really long query
// The load will result in a query where just the query part has length > 3000
var query = dp.GetZipsQuery();
// Create a query with QUERY_ITERATIONS where statements checking a range of QUERY_ITERATIONS each
// this should in the end if simplified result in Code = zipToFind (zipToFind - 1 < Code <= zipToFind)
for (int i = 0; i < QUERY_ITERATIONS; ++i)
{
int min = zipToFind + i - QUERY_ITERATIONS;
int max = zipToFind + i;
query = query.Where(c => min < c.Code && c.Code <= max);
}
lo = dp.Load(query, false);
});
EnqueueConditional(() => lo.IsComplete);
EnqueueCallback(() =>
{
if (lo.Error != null)
Assert.Fail("LoadOperation.Error: " + lo.Error.Message);
var expected = new CityData().Zips.Single(z => z.Code == zipToFind);
Assert.AreEqual(1, lo.Entities.Count(), "Wrong number of entities returned");
var returned = lo.Entities.Single();
Assert.AreEqual(expected.Code, returned.Code);
Assert.AreEqual(expected.FourDigit, returned.FourDigit);
Assert.AreEqual(expected.CityName, returned.CityName);
Assert.AreEqual(expected.CountyName, returned.CountyName);
Assert.AreEqual(expected.StateName, returned.StateName);
});
EnqueueTestComplete();
}
