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