public void Entity_Validation_Property_Fail_ReadOnly_Throws() { MockEntity entity = new MockEntity(); ExceptionHelper.ExpectInvalidOperationException(delegate() { entity.ReadOnlyProperty = "x"; }, "The 'ReadOnlyProperty' property is read only."); }
public void Entity_Validation_Property_Fail_Bogus_Throws() { MockEntity entity = new MockEntity(); ExceptionHelper.ExpectArgumentException(delegate() { entity.BogusProperty = "x"; }, "Type 'MockEntity' does not contain a public property named 'XXX'.\r\nParameter name: propertyName"); }
public void EntityConflict_ArgumentNullExceptions() { MockEntity entity = new MockEntity(); IEnumerable<string> propertyNames = new[] { "Property1" }; ExceptionHelper.ExpectArgumentNullException( () => new EntityConflict(entity, null, propertyNames, false), "storeEntity"); ExceptionHelper.ExpectArgumentNullException( () => new EntityConflict(null, entity, propertyNames, false), "currentEntity"); ExceptionHelper.ExpectArgumentNullException( () => new EntityConflict(entity, entity, null, false), "propertyNames"); }
public void CustomMethod(MockEntity entity) { var parameters = new Dictionary<string, object>(); parameters.Add("entity", entity); this.OnOperationInvoked("CustomMethod", parameters); if (entity.Name == "ThrowError") { throw new ValidationException(entity.Name); } }
public void DisposalTracking() { var proxy = DomainServiceProxy.Create<IMockDomainServiceContract, MockDomainService>(new MockDomainServiceContext(DomainOperationType.Submit)); var entity = new MockEntity(); var args = new List<OperationInvokedEventArgs>(); EventHandler<OperationInvokedEventArgs> handler = (s, a) => args.Add(a); try { MockDomainService.Disposed += handler; // Invoke a operation multiple times proxy.CustomMethod(entity); proxy.CustomMethod(entity); proxy.CustomMethod(entity); proxy.Dispose(); Assert.AreEqual(3, args.Count); Assert.AreEqual("Dispose", args[0].Name); Assert.AreEqual("Dispose", args[1].Name); Assert.AreEqual("Dispose", args[2].Name); } finally { MockDomainService.Disposed -= handler; } }
public void UpdateEntity(MockEntity entity) { var parameters = new Dictionary<string, object>(); parameters.Add("entity", entity); this.OnOperationInvoked("UpdateEntity", parameters); if (entity.Name == "ThrowError") { throw new ValidationException(entity.Name); } else if (entity.Name == "CurrentEntity") { var original = this.ChangeSet.GetOriginal(entity); Assert.IsNotNull(original); entity.ID = original.ID; entity.Name = original.Name; } }
public void Overload2(MockEntity e) { }
public void AssociateOriginal_ChangeSet_GetOriginal() { var proxy = DomainServiceProxy.Create<IMockDomainServiceContract, MockDomainService>(new MockDomainServiceContext(DomainOperationType.Submit)); Assert.IsNull(this.OperationInvokedArgs); var entity = proxy.GetSingletonEntity(); entity.Name = "CurrentEntity"; Assert.AreEqual("CurrentEntity", entity.Name); var original = new MockEntity() { ID = entity.ID, Name = "OriginalEntity" }; DomainServiceProxy.AssociateOriginal(proxy, entity, original); proxy.UpdateEntity(entity); Assert.IsNotNull(this.OperationInvokedArgs); Assert.AreEqual("UpdateEntity", this.OperationInvokedArgs.Name); Assert.AreEqual(1, this.OperationInvokedArgs.Parameters.Count); Assert.AreSame(entity, this.OperationInvokedArgs.Parameters.Values.Single()); Assert.AreEqual("OriginalEntity", entity.Name); }
public void Entity_Validation_Property_Fail_Null_Required() { MockEntity entity = new MockEntity(); #if SILVERLIGHT INotifyDataErrorInfo notifier = (INotifyDataErrorInfo)entity; List<string> actualErrors = new List<string>(); notifier.ErrorsChanged += (s, e) => { actualErrors.Add(e.PropertyName); }; entity.ReadWriteProperty = null; // With INotifyDataErrorInfo validation, the property will get set, even though it's invalid Assert.AreEqual<string>(null, entity.ReadWriteProperty, "The value should have been set"); Assert.IsTrue(actualErrors.SequenceEqual(new string[] { "ReadWriteProperty" }), "The list of errors received"); // Verify that we have the expected validation error for the property IEnumerable<ValidationResult> results = entity.ValidationErrors.Where(e => e.MemberNames.Contains("ReadWriteProperty")); Assert.AreEqual<int>(1, results.Count(), "Expected a single error for the property"); Assert.AreEqual<string>("The ReadWriteProperty field is required.", results.Single().ErrorMessage, "ErrorMessage from the result"); #else ExceptionHelper.ExpectValidationException(delegate() { entity.ReadWriteProperty = null; }, "The ReadWriteProperty field is required.", typeof(RequiredAttribute), null); #endif }
public void ValidateProperty_Null_ValidationContext_Throws() { MockEntity entity = new MockEntity(); ExceptionHelper.ExpectArgumentNullException(() => entity.CallValidateProperty(null, "value"), "validationContext"); }
public void CustomMethodWithParams(MockEntity entity, long param1, IEnumerable<string> param2, Dictionary<byte, string> param3, Uri param4) { var parameters = new Dictionary<string, object>(); parameters.Add("entity", entity); parameters.Add("param1", param1); parameters.Add("param2", param2); parameters.Add("param3", param3); parameters.Add("param4", param4); this.OnOperationInvoked("CustomMethodWithParams", parameters); if (entity.Name == "ThrowError") { throw new ValidationException(entity.Name); } }
public void Entity_Validation_Object_Fail_Null_Required_Throws() { MockEntity entity = new MockEntity(); ValidationContext context = new ValidationContext(entity, null, null); ExceptionHelper.ExpectValidationException(delegate() { System.ComponentModel.DataAnnotations.Validator.ValidateObject(entity, context); }, "The ReadWriteProperty field is required.", typeof(RequiredAttribute), null); }
public void ValidationErrors_PropertyErrorsAreReplacedFromValidateProperty() { MockEntity entity = new MockEntity(); INotifyDataErrorInfo notifier = (INotifyDataErrorInfo)entity; string[] affectedMemberNames = new string[] { "ReadWriteProperty" }; string[] unaffectedMemberNames = new string[] { "Foo", "Bar" }; // Add a fake error that we'll ensure gets cleared out as well as other errors that will remain entity.ValidationErrors.Add(new ValidationResult("Fake error for affected members", affectedMemberNames)); entity.ValidationErrors.Add(new ValidationResult("Fake error for unaffected members", unaffectedMemberNames)); List<string> actualChanges = new List<string>(); IEnumerable<ValidationResult> errors; notifier.ErrorsChanged += (s, e) => actualChanges.Add(e.PropertyName); // Set the property to an invalid value entity.ReadWriteProperty = null; errors = notifier.GetErrors(affectedMemberNames.Single()).Cast<ValidationResult>(); Assert.IsTrue(actualChanges.SequenceEqual(affectedMemberNames), "Events when setting to an invalid value"); Assert.AreEqual<int>(1, errors.Count(), "Expect a single error after setting to an invalid value"); errors = notifier.GetErrors("Foo").Cast<ValidationResult>(); Assert.AreEqual<int>(1, errors.Count(), "Expect a single Foo error after setting to an invalid value"); errors = notifier.GetErrors("Bar").Cast<ValidationResult>(); Assert.AreEqual<int>(1, errors.Count(), "Expect a single Bar error after setting to an invalid value"); actualChanges.Clear(); // Set the property to a valid value entity.ReadWriteProperty = "Valid"; errors = notifier.GetErrors(affectedMemberNames.Single()).Cast<ValidationResult>(); Assert.IsTrue(actualChanges.SequenceEqual(affectedMemberNames), "Events when setting to a valid value"); Assert.AreEqual<int>(0, errors.Count(), "Expect no errors after setting to a valid value"); actualChanges.Clear(); }
public void Entity_Validation_Property_ReadOnly_Missing() { MockEntity entity = new MockEntity(); entity.ReadWriteProperty = "x"; Assert.AreEqual("x", entity.ReadWriteProperty); }
public void ValidationErrors_ErrorsChangedEvents() { MockEntity entity = new MockEntity(); INotifyDataErrorInfo notifier = (INotifyDataErrorInfo)entity; List<string> actualChanges = new List<string>(); notifier.ErrorsChanged += (s, e) => actualChanges.Add(e.PropertyName); // Adding an error for Foo should raise a single event only for Foo string[] oneMemberName = new string[] { "Foo" }; ValidationResult singlePropertyResult = new ValidationResult("Error Message", oneMemberName); entity.ValidationErrors.Add(singlePropertyResult); Assert.IsTrue(actualChanges.SequenceEqual(oneMemberName), "Events when adding single property error"); actualChanges.Clear(); // Adding an error for Foo and Bar will raise events for both properties even though it's a single error // Additionally, having a member name of null (entity-level error) will cause an event with a null property name string[] twoMemberNamesPlusNull = new string[] { "Foo", "Bar", null }; ValidationResult multiPropertyResult = new ValidationResult("Error Message", twoMemberNamesPlusNull); entity.ValidationErrors.Add(multiPropertyResult); Assert.IsTrue(actualChanges.OrderBy(s => s).SequenceEqual(twoMemberNamesPlusNull.OrderBy(s => s)), "Events when adding multi-property error"); actualChanges.Clear(); // Removing the single-property result will raise an event for that property entity.ValidationErrors.Remove(singlePropertyResult); Assert.IsTrue(actualChanges.SequenceEqual(oneMemberName), "HasChanges events when removing single property error"); actualChanges.Clear(); // Removing the multi-property result will raise events for both properties entity.ValidationErrors.Remove(multiPropertyResult); Assert.IsTrue(actualChanges.OrderBy(s => s).SequenceEqual(twoMemberNamesPlusNull.OrderBy(s => s)), "HasChanges events when removing multi-property error"); }
public void ValidationErrors_PropertyChangedEventsEntityErrors() { MockEntity entity = new MockEntity(); INotifyDataErrorInfo notifier = (INotifyDataErrorInfo)entity; // Expect property change notifications for: HasValidationErrors, ValidationErrors string[] expectedChanges = new string[] { "HasValidationErrors", "ValidationErrors" }; List<string> actualChanges = new List<string>(); entity.PropertyChanged += (s, e) => actualChanges.Add(e.PropertyName); Assert.IsFalse(entity.HasValidationErrors, "HasValidationErrors before adding"); Assert.IsFalse(notifier.HasErrors, "HasErrors before adding"); entity.ValidationErrors.Add(new ValidationResult("Error Message", null)); Assert.IsTrue(entity.HasValidationErrors, "HasValidationErrors after adding"); Assert.IsTrue(notifier.HasErrors, "HasErrors after adding"); Assert.IsTrue(actualChanges.SequenceEqual(expectedChanges), "Property changes after adding"); actualChanges.Clear(); entity.ValidationErrors.Clear(); Assert.IsFalse(entity.HasValidationErrors, "HasValidationErrors after clearing"); Assert.IsFalse(notifier.HasErrors, "HasErrors after clearing"); Assert.IsTrue(actualChanges.SequenceEqual(expectedChanges), "Property changes after clearing"); }
public void Entity_Validation_Property_ReadOnly_False() { MockEntity entity = new MockEntity(); entity.ReadOnlyFalseProperty = "x"; Assert.AreEqual("x", entity.ReadOnlyFalseProperty); }
public void Entity_Validation_Property_Internal_Setter() { MockEntity entity = new MockEntity(); entity.PublicGetterInternalSetter = "x"; Assert.AreEqual("x", entity.PublicGetterInternalSetter); }
public void Entity_Validation_Property_Fail_StringLength_Exceeded_Throws() { MockEntity entity = new MockEntity(); #if SILVERLIGHT INotifyDataErrorInfo notifier = (INotifyDataErrorInfo)entity; List<string> actualErrors = new List<string>(); notifier.ErrorsChanged += (s, e) => { actualErrors.Add(e.PropertyName); }; string newValue = "LongerThan10Characters"; entity.ReadWriteProperty = newValue; // With INotifyDataErrorInfo validation, the property will get set, even though it's invalid Assert.AreEqual<string>(newValue, entity.ReadWriteProperty, "The value should have been set"); Assert.IsTrue(actualErrors.SequenceEqual(new string[] { "ReadWriteProperty" }), "The list of errors received"); // Verify that we have the expected validation error for the property IEnumerable<ValidationResult> results = entity.ValidationErrors.Where(e => e.MemberNames.Contains("ReadWriteProperty")); Assert.AreEqual<int>(1, results.Count(), "Expected a single error for the property"); Assert.AreEqual<string>("The field ReadWriteProperty must be a string with a maximum length of 10.", results.Single().ErrorMessage, "ErrorMessage from the result"); #else ExceptionHelper.ExpectValidationException(delegate() { entity.ReadWriteProperty = "LongerThan10Characters"; }, "The field ReadWriteProperty must be a string with a maximum length of 10.", typeof(StringLengthAttribute), "LongerThan10Characters"); #endif }