public void EntityConflict_Resolve() { TestEntityContainer ec = new TestEntityContainer(); EntitySet<Product> set = ec.Products; Product current = new Product { ProductID = 1, Color = "Red", ProductNumber = "1234" }; set.LoadEntity(current); // create a conflict and resolve current.Color += "X"; Product store = new Product { ProductID = 1, Color = "Red", ProductNumber = "4321" }; EntityConflict conflict = new EntityConflict(current, store, new string[] { "ProductNumber" }, false); current.EntityConflict = conflict; Assert.AreEqual(EntityState.Modified, current.EntityState); var originalState = conflict.OriginalEntity.ExtractState(); Assert.IsTrue((string)originalState["Color"] == "Red" && (string)originalState["ProductNumber"] == "1234"); conflict.Resolve(); // verify that calling Resolve multiple // times is a no-op conflict.Resolve(); conflict.Resolve(); // resolve should update the original state originalState = current.GetOriginal().ExtractState(); Assert.IsTrue((string)originalState["Color"] == "Red" && (string)originalState["ProductNumber"] == "4321"); // current state should not be modified Assert.AreEqual("RedX", current.Color); Assert.AreEqual("1234", current.ProductNumber); // the conflict should be cleared out Assert.IsNull(current.EntityConflict); }
public void Inherit_Run_Entity_SpecializedAssociation() { TestEntityContainer container = new TestEntityContainer(); var cities = container.LoadEntities(_citiesWithInfo).OfType<CityWithInfo>(); var redmond = cities.Single(c => c.Name == "Redmond"); Assert.AreEqual(3, redmond.ZipCodes.Count); Assert.AreEqual(1, redmond.ZipCodesWithInfo.Count); Assert.AreEqual("Microsoft", redmond.ZipCodesWithInfo.Single().Info); }
public void Inherit_Run_Entity_SpecializedAssociation() { TestEntityContainer container = new TestEntityContainer(); var cities = container.LoadEntities(_citiesWithInfo).OfType <CityWithInfo>(); var redmond = cities.Single(c => c.Name == "Redmond"); Assert.AreEqual(3, redmond.ZipCodes.Count); Assert.AreEqual(1, redmond.ZipCodesWithInfo.Count); Assert.AreEqual("Microsoft", redmond.ZipCodesWithInfo.Single().Info); }
public void Inherit_Run_Entity_ReadOnly() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_citiesWithInfo); Assert.IsFalse(_citiesWithInfo[0].IsReadOnly); _citiesWithInfo[0].SetCityInfo("new stuff"); Assert.IsTrue(_citiesWithInfo[0].IsReadOnly); ((System.ComponentModel.IRevertibleChangeTracking)_cities[0]).RejectChanges(); Assert.IsFalse(_citiesWithInfo[1].IsReadOnly); }
public void Entity_InvokeOnLoaded() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); Assert.AreEqual(EntityState.Unmodified, _cities[0].EntityState); Assert.AreEqual(0, _cities[0].EntityActions.Count()); Assert.IsTrue(_cities[0].CanInvokeAction(_assignCityZone.Name)); // verify invoke on a new entity succeeds and subsequent CanInvoke returns false _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); Assert.AreEqual(1, _cities[0].EntityActions.Count()); Assert.AreEqual(EntityState.Modified, _cities[0].EntityState); Assert.AreEqual<string>(_assignCityZone.Name, _cities[0].EntityActions.Single().Name); Assert.AreEqual<int>(_assignCityZone.Parameters.Count(), _cities[0].EntityActions.Single().Parameters.Count()); Assert.IsFalse(_cities[0].CanInvokeAction(_assignCityZone.Name)); }
public void Inherit_Run_Entity_InvokeOnLoaded() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_citiesWithInfo); Assert.AreEqual(EntityState.Unmodified, _citiesWithInfo[0].EntityState); Assert.AreEqual(0, _citiesWithInfo[0].EntityActions.Count()); Assert.IsTrue(_citiesWithInfo[0].CanInvokeAction(_setCityInfo.Name)); // verify invoke on a new entity succeeds and subsequent CanInvoke returns false _citiesWithInfo[0].InvokeAction(_setCityInfo.Name, _setCityInfo.Parameters.ToArray <object>()); Assert.AreEqual(1, _citiesWithInfo[0].EntityActions.Count()); Assert.AreEqual(EntityState.Modified, _citiesWithInfo[0].EntityState); Assert.AreEqual <string>(_setCityInfo.Name, _citiesWithInfo[0].EntityActions.Single().Name); Assert.AreEqual <int>(_setCityInfo.Parameters.Count(), _citiesWithInfo[0].EntityActions.Single().Parameters.Count()); Assert.IsFalse(_citiesWithInfo[0].CanInvokeAction(_setCityInfo.Name)); }
public void Inherit_Run_Entity_Invoke_Illegal_EntityAction() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_rootCities); var invocableCity = _rootCities[0]; Assert.IsNotNull(invocableCity); // verify calling Invoke throws InvalidOperationException and the invocation list remains the same ExceptionHelper.ExpectException <MissingMethodException>(delegate { invocableCity.InvokeAction(_setCityInfo.Name, _setCityInfo.Parameters.ToArray()); }, string.Format(Resource.ValidationUtilities_MethodNotFound, "Cities.City", _setCityInfo.Name, _setCityInfo.Parameters.Count(), "'System.String'")); Assert.AreEqual(EntityState.Unmodified, _rootCities[0].EntityState); }
public void Entity_ReadOnly() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); Assert.IsFalse(_cities[0].IsReadOnly); _cities[0].AssignCityZone(_assignCityZone.Name); Assert.IsTrue(_cities[0].IsReadOnly); Assert.IsFalse(_cities[1].IsReadOnly); _cities[1].CountyName += "X"; _cities[1].AssignCityZone(_assignCityZone.Name); Assert.IsTrue(_cities[1].IsReadOnly); ((System.ComponentModel.IRevertibleChangeTracking)_cities[1]).RejectChanges(); Assert.IsFalse(_cities[1].IsReadOnly); }
public void EntityConflict_Resolve() { TestEntityContainer ec = new TestEntityContainer(); EntitySet <Product> set = ec.Products; Product current = new Product { ProductID = 1, Color = "Red", ProductNumber = "1234" }; set.LoadEntity(current); // create a conflict and resolve current.Color += "X"; Product store = new Product { ProductID = 1, Color = "Red", ProductNumber = "4321" }; EntityConflict conflict = new EntityConflict(current, store, new string[] { "ProductNumber" }, false); current.EntityConflict = conflict; Assert.AreEqual(EntityState.Modified, current.EntityState); var originalState = conflict.OriginalEntity.ExtractState(); Assert.IsTrue((string)originalState["Color"] == "Red" && (string)originalState["ProductNumber"] == "1234"); conflict.Resolve(); // verify that calling Resolve multiple // times is a no-op conflict.Resolve(); conflict.Resolve(); // resolve should update the original state originalState = current.GetOriginal().ExtractState(); Assert.IsTrue((string)originalState["Color"] == "Red" && (string)originalState["ProductNumber"] == "4321"); // current state should not be modified Assert.AreEqual("RedX", current.Color); Assert.AreEqual("1234", current.ProductNumber); // the conflict should be cleared out Assert.IsNull(current.EntityConflict); }
public void Entity_InvalidNameToInvoke() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); // call Invoke with name=empty string ExceptionHelper.ExpectArgumentException(delegate { _cities[0].InvokeAction(""); }, string.Format(CultureInfo.CurrentCulture, Resource.Parameter_NullOrEmpty, "actionName")); // call invoke with name=null ExceptionHelper.ExpectArgumentException(delegate { _cities[0].InvokeAction(null); }, string.Format(CultureInfo.CurrentCulture, Resource.Parameter_NullOrEmpty, "actionName")); // The following is commented since the product currently ignores the name attribute as // only one domain method is allowed for an entity. //// call CanInvoke with name=emtpy string //ExceptionHelper.ExpectArgumentException(delegate //{ // _cities[0].CanInvoke(""); //}, string.Format(CultureInfo.CurrentCulture, Resource.Parameter_NullOrEmpty, "actionName")); //// call CanInvoke with name=null //ExceptionHelper.ExpectArgumentException(delegate //{ // _cities[0].CanInvoke(null); //}, string.Format(CultureInfo.CurrentCulture, Resource.Parameter_NullOrEmpty, "actionName")); Assert.AreEqual(EntityState.Unmodified, _cities[0].EntityState); }
public void DomainClient_SubmitWithNullInvocation() { TestEntityContainer container = new TestEntityContainer(); //TODO: find a better way to not hardcode the list of known types WebDomainClient<CityDomainContext.ICityDomainServiceContract> client = new WebDomainClient<CityDomainContext.ICityDomainServiceContract>(TestURIs.Cities) { EntityTypes = new Type[] { typeof(City), typeof(ChangeSetEntry), typeof(EntityOperationType) } }; List<Entity> emptyList = new List<Entity>(); List<Entity> modifiedEntities = new List<Entity>(); // invoke domain methods on a few entities container.LoadEntities(_cities); _cities[1].AssignCityZone(_assignCityZone.Parameters.First().ToString()); // submit changeset with hand-crafted entities: valid invocation and null invocation modifiedEntities.Add(_cities[0]); modifiedEntities.Add(_cities[1]); modifiedEntities.Add(_cities[2]); Assert.AreEqual(EntityState.Modified, _cities[1].EntityState); EntityChangeSet changeset = new EntityChangeSet(emptyList.AsReadOnly(), modifiedEntities.AsReadOnly(), emptyList.AsReadOnly()); SubmitCompletedResult submitResults = null; client.BeginSubmit( changeset, delegate(IAsyncResult asyncResult) { submitResults = client.EndSubmit(asyncResult); }, null ); // wait for submit to complete EnqueueConditional(() => submitResults != null); EnqueueCallback(delegate { Assert.AreEqual(1, submitResults.Results.Count()); Assert.AreEqual(1, submitResults.Results.Where(e => e.Operation == EntityOperationType.Update).Count()); // REVIEW: Do we really need the operation data back from the server? // ChangeSetEntry returned = submitResults.Results.Single(e => e.OperationName == _assignCityZone.Name); // Assert.IsNotNull(returned); // Assert.AreEqual(1, returned.OperationData.Count()); }); EnqueueTestComplete(); }
public void DomainClient_SubmitWithNonexistentDomainMethod() { TestEntityContainer container = new TestEntityContainer(); WebDomainClient<CityDomainContext.ICityDomainServiceContract> client = new WebDomainClient<CityDomainContext.ICityDomainServiceContract>(TestURIs.Cities) { EntityTypes = new Type[] { typeof(City) } }; List<Entity> emptyList = new List<Entity>(); List<Entity> modifiedEntities = new List<Entity>(); // invoke domain methods on a few entities container.LoadEntities(_cities); _cities[0].CustomMethodInvocation = _reject; // submit changeset with hand-crafted entities (without calling Invoke) modifiedEntities.Add(_cities[0]); EntityChangeSet changeset = new EntityChangeSet(emptyList.AsReadOnly(), modifiedEntities.AsReadOnly(), emptyList.AsReadOnly()); SubmitCompletedResult submitResults = null; DomainOperationException expectedException = null; EnqueueCallback(delegate { client.BeginSubmit( changeset, delegate(IAsyncResult asyncResult) { try { submitResults = client.EndSubmit(asyncResult); } catch (DomainOperationException e) { expectedException = e; } }, null ); }); EnqueueConditional(() => expectedException != null); EnqueueCallback(delegate { Assert.IsNull(submitResults); Assert.AreEqual("This DomainService does not support operation 'Reject' for entity 'CityWithInfo'.", expectedException.Message); }); EnqueueTestComplete(); }
public void Entity_InvokeOnDeleted() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); container.GetEntitySet<City>().Remove(_cities[2]); Assert.AreEqual(EntityState.Deleted, _cities[2].EntityState); Assert.IsFalse(_cities[2].CanInvokeAction(_assignCityZone.Name)); ExceptionHelper.ExpectException<InvalidOperationException>(delegate { _cities[2].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray()); }, Resource.Entity_InvokeOnDeletedEntity); Assert.AreEqual(0, _cities[2].EntityActions.Count()); Assert.AreEqual(EntityState.Deleted, _cities[2].EntityState); }
public void PropertyNotification_RaisedOnRejectChanges() { List<string> propChanged = new List<string>(); TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); // invoke domain method and remove the entity _cities[0].AssignCityZone("Zone1"); container.GetEntitySet<City>().Remove(_cities[0]); Assert.IsFalse(_cities[0].CanInvokeAction("AssignCityZone")); // subscribe to property changed events on entity and call RejectChanges _cities[0].PropertyChanged += delegate(object sender, System.ComponentModel.PropertyChangedEventArgs e) { propChanged.Add(e.PropertyName); }; ((System.ComponentModel.IRevertibleChangeTracking)container).RejectChanges(); // RejectChanges should raise property changed notification for guard properties EnqueueConditional(() => propChanged.Any<string>(p => p.StartsWith("Can"))); EnqueueCallback(delegate { Assert.IsTrue(_cities[0].CanInvokeAction("AssignCityZone")); // verify RejectChanges does not cause multiple property change notifications Assert.IsNotNull(propChanged.Single<string>(p => p == "CanAssignCityZone")); }); EnqueueTestComplete(); }
public void Entity_CancelAndEndEdit() { // BeginEdit -> invoke domain method -> EndEdit. Verify state reverts after End but changeset is not empty. TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); System.ComponentModel.IEditableObject editableCity = _cities[0] as System.ComponentModel.IEditableObject; editableCity.BeginEdit(); _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); Assert.AreEqual(EntityState.Modified, _cities[0].EntityState); Assert.AreEqual(1, _cities[0].EntityActions.Count()); editableCity.EndEdit(); Assert.AreEqual(EntityState.Modified, _cities[0].EntityState); Assert.AreEqual(1, _cities[0].EntityActions.Count()); // begin another session and CancelEdit immediately. Verify that previous invocation is not affected editableCity.BeginEdit(); Assert.IsFalse(_cities[0].CanInvokeAction(_assignCityZone.Name)); editableCity.CancelEdit(); Assert.AreEqual(EntityState.Modified, _cities[0].EntityState); Assert.AreEqual(1, _cities[0].EntityActions.Count()); }
public void EntityContainer_GetChanges_DetachAfterInvoke() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); EntityChangeSet changeset = container.GetChanges(); Assert.IsTrue(changeset.IsEmpty); // invoke then delete the entity. Verify the ModifiedEntities are updated _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); Assert.AreEqual(1, _cities[0].EntityActions.Count()); Assert.AreEqual(1, container.GetChanges().ModifiedEntities.Count()); container.GetEntitySet<City>().Detach(_cities[0]); Assert.AreEqual(0, container.GetChanges().ModifiedEntities.Count()); }
public void Entity_InvokeNull_Throws() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); var invocableCity = _cities[0]; Assert.IsNotNull(invocableCity); ExceptionHelper.ExpectArgumentException(delegate { invocableCity.InvokeAction(null); }, String.Format(Resource.Parameter_NullOrEmpty, "actionName")); Assert.AreEqual(EntityState.Unmodified, _cities[0].EntityState); }
public void Entity_Invoke_Unknown_EntityAction() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_rootCities); // root ensures we don't get a derived type which changes message text var invocableCity = _rootCities[0]; Assert.IsNotNull(invocableCity); // verify calling Invoke throws InvalidOperationException and the invocation list remains the same ExceptionHelper.ExpectException<MissingMethodException>(delegate { invocableCity.InvokeAction(_reject.Name, _reject.Parameters.ToArray()); }, string.Format(Resource.ValidationUtilities_MethodNotFound, "Cities.City", _reject.Name, _reject.Parameters.Count(), "'System.String'")); Assert.AreEqual(EntityState.Unmodified, _rootCities[0].EntityState); }
public void Entity_InvokeTwiceOnNew() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray()); Assert.AreEqual<string>(_assignCityZone.Name, _cities[0].EntityActions.Single().Name); ExceptionHelper.ExpectException<InvalidOperationException>(delegate { _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray()); }, "Method can only be invoked once."); Assert.AreEqual<string>(_assignCityZone.Name, _cities[0].EntityActions.Single().Name); Assert.AreEqual(EntityState.Modified, _cities[0].EntityState); }
public void Entity_InvokeOnUpdated() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); _cities[1].ZoneID += 1; Assert.AreEqual(EntityState.Modified, _cities[1].EntityState); Assert.IsTrue(_cities[1].CanInvokeAction(_assignCityZone.Name)); Assert.IsTrue(_cities[1].EntityState == EntityState.Modified); _cities[1].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray()); Assert.AreEqual(1, _cities[1].EntityActions.Count()); Assert.AreEqual(_assignCityZone.Name, _cities[1].EntityActions.Single().Name); Assert.AreEqual(EntityState.Modified, _cities[1].EntityState); }
public void Entity_DeleteAfterInvoke() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); // first invoke the action City city = _cities.First(); city.InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray()); Assert.IsFalse(city.CanInvokeAction(_assignCityZone.Name)); Assert.AreEqual(1, city.EntityActions.Count()); // delete the entity - expect the actions to be cleared container.GetEntitySet<City>().Remove(city); Assert.AreEqual(0, city.EntityActions.Count()); Assert.IsFalse(city.CanInvokeAction(_assignCityZone.Name)); }
public void Entity_RejectChanges() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); Assert.AreEqual(1, _cities[0].EntityActions.Count()); ((System.ComponentModel.IRevertibleChangeTracking)_cities[0]).RejectChanges(); Assert.AreEqual(0, _cities[0].EntityActions.Count()); Assert.AreEqual(EntityState.Unmodified, _cities[0].EntityState); var invocableCity = _cities[0]; Assert.AreEqual(0, invocableCity.EntityActions.Count()); }
public void Entity_EntityAction_InvokeOnLoaded() { // verify initial state: empty invocations and one can invoke any methods TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); var invocableCity = _cities[1]; Assert.IsNotNull(invocableCity); Assert.IsTrue(invocableCity.CanInvokeAction(_assignCityZone.Name)); Assert.AreEqual(0, invocableCity.EntityActions.Count()); // verify invoke on a new entity succeeds and subsequent CanInvoke for a different entity action returns false invocableCity.InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray()); Assert.IsFalse(invocableCity.CanInvokeAction(_assignCityZone.Name)); // different entity action name Assert.AreSame(_assignCityZone.Name, _cities[1].EntityActions.Single().Name); // verify you get back the same entity action on GetInvocations Assert.AreEqual<string>(_assignCityZone.Name, invocableCity.EntityActions.Single().Name); }
public void EntityContainer_GetChanges() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); EntityChangeSet changeset = container.GetChanges(); Assert.IsNotNull(changeset); Assert.IsTrue(changeset.IsEmpty); // invoke domain method on 2 cities and verify invocation is in changeset // TODO: need 2 separate legal domain methods _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); _cities[2].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); changeset = container.GetChanges(); Assert.IsTrue(changeset.AddedEntities.Count == 0); Assert.IsTrue(changeset.ModifiedEntities.Count == 2); Assert.IsTrue(changeset.RemovedEntities.Count == 0); Assert.AreEqual<string>(_assignCityZone.Name, changeset.ModifiedEntities[0].EntityActions.Single().Name); Assert.AreEqual<string>(_assignCityZone.Name, changeset.ModifiedEntities[1].EntityActions.Single().Name); // revert one of the domain method invocations. verify invocation in changeset is updated ((System.ComponentModel.IRevertibleChangeTracking)_cities[0]).RejectChanges(); changeset = container.GetChanges(); City returned = changeset.ModifiedEntities.Single(p => p == _cities[2]) as City; Assert.IsNotNull(returned); Assert.AreEqual<string>(_assignCityZone.Name, returned.EntityActions.Single().Name); Assert.AreEqual<int>(_assignCityZone.Parameters.Count(), returned.EntityActions.Single().Parameters.Count()); }
public void Entity_CancelEdit() { // verify that DomainMethod invocations participate in IEditableObject sessions properly TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); System.ComponentModel.IEditableObject editableCity = _cities[0] as System.ComponentModel.IEditableObject; Assert.IsNotNull(editableCity); editableCity.BeginEdit(); int prevZoneID = _cities[0].ZoneID; _cities[0].ZoneID = 777; _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); Assert.AreEqual(1, _cities[0].EntityActions.Count()); // cancel editing. Domain method invocation and property updates are reverted editableCity.CancelEdit(); Assert.AreEqual(prevZoneID, _cities[0].ZoneID); Assert.AreEqual(0, _cities[0].EntityActions.Count()); Assert.AreEqual(EntityState.Unmodified, _cities[0].EntityState); Assert.IsTrue(container.GetChanges().IsEmpty); // now start an edit session with a modified entity // and verify same results _cities[0].ZoneID = 777; Assert.AreEqual(EntityState.Modified, _cities[0].EntityState); editableCity.BeginEdit(); _cities[0].ZoneID = 888; _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); editableCity.CancelEdit(); Assert.AreEqual(777, _cities[0].ZoneID); Assert.AreEqual(0, _cities[0].EntityActions.Count()); Assert.AreEqual(EntityState.Modified, _cities[0].EntityState); // now test an edit session where only a DM was invoked (no property edits) ((System.ComponentModel.IRevertibleChangeTracking)_cities[0]).RejectChanges(); Assert.AreEqual(EntityState.Unmodified, _cities[0].EntityState); editableCity.BeginEdit(); _cities[0].InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray<object>()); Assert.AreEqual(EntityState.Modified, _cities[0].EntityState); editableCity.CancelEdit(); Assert.AreEqual(EntityState.Unmodified, _cities[0].EntityState); Assert.IsTrue(container.GetChanges().IsEmpty); }
public void Entity_InvokeOnAdded() { TestEntityContainer container = new TestEntityContainer(); City city = new City { Name = "Redmond", CountyName = "King", StateName = "WA" }; container.GetEntitySet<City>().Add(city); Assert.AreEqual(EntityState.New, city.EntityState); Assert.AreEqual(0, city.EntityActions.Count()); Assert.IsTrue(city.CanInvokeAction(_assignCityZone.Name)); city.InvokeAction(_assignCityZone.Name, _assignCityZone.Parameters.ToArray()); Assert.AreEqual(1, city.EntityActions.Count()); Assert.AreEqual(EntityState.New, city.EntityState); Assert.AreEqual<string>(_assignCityZone.Name, city.EntityActions.Single().Name); Assert.AreEqual<int>(_assignCityZone.Parameters.Count(), city.EntityActions.Single().Parameters.Count()); Assert.IsFalse(city.CanInvokeAction(_assignCityZone.Name)); }
public void Entity_Invoke_Validates_Entity_Validation() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_rootCities); // root ensures we don't get a derived type which changes message text var invocableCity = _rootCities[0]; Assert.IsNotNull(invocableCity); invocableCity.ZoneID += 1; invocableCity.StateName = "WA"; invocableCity.MakeEntityValidationFail = true; ExceptionHelper.ExpectValidationException(delegate { invocableCity.AssignCityZone("West"); }, "MakeEntityValidationFail is true", typeof(CustomValidationAttribute), invocableCity); }
public void DomainClient_SubmitWithInvalidInvocation() { TestEntityContainer container = new TestEntityContainer(); WebDomainClient<CityDomainContext.ICityDomainServiceContract> client = new WebDomainClient<CityDomainContext.ICityDomainServiceContract>(TestURIs.Cities) { EntityTypes = new Type[] { typeof(City) } }; List<Entity> emptyList = new List<Entity>(); List<Entity> modifiedEntities = new List<Entity>(); // verify exception is thrown when trying to invoke invalid action ExceptionHelper.ExpectArgumentException(delegate { _cities[0].InvokeAction(""); }, string.Format(CultureInfo.CurrentCulture, Resource.Parameter_NullOrEmpty,"actionName")); }
public void Entity_Invoke_Validates_Required_Properties() { TestEntityContainer container = new TestEntityContainer(); var invocableCity = new City(); container.GetEntitySet<City>().Add(invocableCity); RequiredAttribute expectedAttribute = new RequiredAttribute(); string expectedMember = "CityName"; string expectedError = expectedAttribute.FormatErrorMessage(expectedMember); ExceptionHelper.ExpectValidationException(delegate { invocableCity.AssignCityZone("West"); }, expectedError, expectedAttribute.GetType(), null); }
public void PropertyNotification_RaisedOnDelete() { List<string> propChanged = new List<string>(); TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_cities); Assert.IsTrue(_cities[0].CanInvokeAction("AssignCityZone")); // subscribe to property changed events on entity and Remove _cities[0].PropertyChanged += delegate(object sender, System.ComponentModel.PropertyChangedEventArgs e) { propChanged.Add(e.PropertyName); }; container.GetEntitySet<City>().Remove(_cities[0]); // Deleting entity should raise property changed notification for guard properties EnqueueConditional(() => propChanged.Any<string>(p => p.StartsWith("Can"))); EnqueueCallback(delegate { Assert.IsFalse(_cities[0].CanInvokeAction("AssignCityZone")); }); EnqueueTestComplete(); }
public void Entity_Invoke_Validates_Property_Validation() { TestEntityContainer container = new TestEntityContainer(); var invocableCity = new City("This is an invalid state name"); container.GetEntitySet<City>().Add(invocableCity); invocableCity.Name = "Redmond"; StringLengthAttribute expectedAttribute = new StringLengthAttribute(2); string expectedMember = "StateName"; string expectedError = expectedAttribute.FormatErrorMessage(expectedMember); ExceptionHelper.ExpectValidationException(delegate { invocableCity.AssignCityZone("West"); }, expectedError, expectedAttribute.GetType(), invocableCity.StateName); }
public void Inherit_Run_Entity_Invoke_Illegal_EntityAction() { TestEntityContainer container = new TestEntityContainer(); container.LoadEntities(_rootCities); var invocableCity = _rootCities[0]; Assert.IsNotNull(invocableCity); // verify calling Invoke throws InvalidOperationException and the invocation list remains the same ExceptionHelper.ExpectException<MissingMethodException>(delegate { invocableCity.InvokeAction(_setCityInfo.Name, _setCityInfo.Parameters.ToArray()); }, string.Format(Resource.ValidationUtilities_MethodNotFound, "Cities.City", _setCityInfo.Name, _setCityInfo.Parameters.Count(), "'System.String'")); Assert.AreEqual(EntityState.Unmodified, _rootCities[0].EntityState); }