public void Submit()
{
Cities.CityDomainContext ctx = new Cities.CityDomainContext(new CitiesMockDomainClient());
string myState = "Test User State";
Cities.Zip newZip = new Cities.Zip
{
Code = 93551,
FourDigit = 1234,
CityName = "Issaquah",
StateName = "Issaquah"
};
ctx.Zips.Add(newZip);
SubmitOperation so = ctx.SubmitChanges(TestHelperMethods.DefaultOperationAction, null);
this.EnqueueCompletion(() => so);
EnqueueCallback(delegate
{
// verify that validation logic is run
Assert.IsNotNull(so.Error);
Assert.AreSame(newZip, so.EntitiesInError.Single());
// fix by setting the Name
newZip.StateName = "WA";
so = ctx.SubmitChanges(null, myState);
});
this.EnqueueCompletion(() => so);
EnqueueCallback(delegate
{
Assert.IsNull(so.Error);
Assert.AreEqual(myState, so.UserState);
});
EnqueueTestComplete();
}
public void UpdateZip(Zip current)
{
}
public void InsertZip(Zip zip)
{
}
public string Process_EntitiesAndSimpleParams(Zip zip, City city, string otherParam)
{
return string.Format("{0}_{1}_{2}", zip.Code.ToString(), city.Name, otherParam);
}
public void DeleteZip(Zip zip)
{
}
private void AttachZipCodes(Zip entity)
{
entity.City = this;
}
public void Validation_Cities_Fail_Set_Bad_Range() {
ExceptionHelper.ExpectValidationException(delegate() {
Zip zip = new Zip() { Code = 999990 };
}, "The field Code must be between 0 and 99999.", typeof(RangeAttribute), 999990);
}
public void ThrowException(Zip zip, string scenario)
{
switch (scenario)
{
case "ValidationException":
throw new ValidationException("testing");
case "EntityValidationException":
// simulate an entity property validation error, ensuring that the specified entity
// property names are propagated back to the client
ValidationResult result = new ValidationResult("Invalid Zip properties!", new string[] { "CityName", "CountyName" });
throw new ValidationException(result, null, zip);
case "DomainServiceException":
throw new DomainException("testing");
case "InvalidOperationException":
throw new InvalidOperationException("testing");
case "DomainServiceExceptionWithErrorCode":
throw new DomainException("testing with error code", 10);
default:
// no op
break;
}
}
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();
}
/// <summary>
/// Invokes the 'ThrowException' method of the specified <see cref="Zip"/> entity.
/// </summary>
/// <param name="zip">The <see cref="Zip"/> entity instance.</param>
/// <param name="scenario">The value for the 'scenario' parameter for this action.</param>
public void ThrowException(Zip zip, string scenario)
{
zip.ThrowException(scenario);
}
/// <summary>
/// Invokes the 'ReassignZipCode' method of the specified <see cref="Zip"/> entity.
/// </summary>
/// <param name="zip">The <see cref="Zip"/> entity instance.</param>
/// <param name="offset">The value for the 'offset' parameter for this action.</param>
/// <param name="useFull">The value for the 'useFull' parameter for this action.</param>
public void ReassignZipCode(Zip zip, int offset, bool useFull)
{
zip.ReassignZipCode(offset, useFull);
}
private bool FilterZipCodes(Zip entity)
{
return (((entity.CityName == this.Name)
&& (entity.CountyName == this.CountyName))
&& (entity.StateName == this.StateName));
}
private void DetachZipCodes(Zip entity)
{
entity.City = null;
}
public void DeleteZip(Zip zip)
{
}
public void ReassignZipCode(Zip zip,
[Range(-9999, 9999)] int offset,
bool useFull)
{
zip.Code += offset;
if (useFull)
{
zip.FourDigit += offset;
}
}
public static ValidationResult IsZipValid(Zip zip, ValidationContext context)
{
if (string.Equals(zip.StateName, zip.CityName))
{
return new ValidationResult("Zip codes cannot have matching city and state names", new string[] { "StateName", "CityName" });
}
else
{
return ValidationResult.Success;
}
}
public void Validation_Cities_Fail_Object_Cross_Field_Validation() {
// First verify the validation test passes for a legal construction
Zip zip = new Zip() { Code = 90563, CityName = "Redmond", StateName = "WA" };
ValidationContext context = new ValidationContext(zip, null, null);
Validator.ValidateObject(zip, context);
// now make a cross-field validation error
zip.CityName = zip.StateName;
ExceptionHelper.ExpectValidationException(delegate() {
Validator.ValidateObject(zip, context);
}, "Zip codes cannot have matching city and state names", typeof(CustomValidationAttribute), zip);
}
public void InsertZip(Zip zip)
{
}
public void Validation_Cities_Fail_Set_Bad_MustStartWith() {
ExceptionHelper.ExpectValidationException(delegate() {
Zip zip = new Zip() { Code = 8 };
}, "Code must start with the prefix 9", typeof(MustStartWithAttribute), 8);
}
public void UpdateZip(Zip current)
{
}
