public void ReferenceInterferenceOnSave() { // Arrange var instance = new InterferenceResource() { Id = 1 }; ResourceReferenceTools.InitializeCollections(instance); // Prepare reference objects var derived = new DerivedResource { Id = 2, Name = "Ref1" }; var other = new OtherResource { Id = 3, Name = "Ref2" }; var different = new DifferentResource { Id = 4, Name = "Different" }; // Fill graph _graph[1] = new ResourceWrapper(instance); _graph[2] = new ResourceWrapper(derived); _graph[3] = new ResourceWrapper(other); _graph[4] = new ResourceWrapper(different); // Set references instance.Derived = derived; instance.Others.Add(other); instance.Different = different; // Setup uow and repo to simulate the current database var relations = new List <ResourceRelation> { // Current exchangable parts Relation(2, 1, ResourceRelationType.CurrentExchangablePart), Relation(3, 1, ResourceRelationType.CurrentExchangablePart), Relation(4, 1, ResourceRelationType.CurrentExchangablePart), }; var mocks = SetupDbMocks(relations); // Act _linker.SaveReferences(mocks.Item1.Object, instance, new ResourceEntity { Id = 1 }); // Assert Assert.DoesNotThrow(() => mocks.Item2.Verify(repo => repo.Remove(It.Is <ResourceRelation>(removed => removed.SourceId == 1 && removed.TargetId == 2)), Times.Never), "Linker did remove relation 1-2"); Assert.DoesNotThrow(() => mocks.Item2.Verify(repo => repo.Remove(It.Is <ResourceRelation>(removed => removed.SourceId == 1 && removed.TargetId == 3)), Times.Never), "Linker did remove relation 1-3"); Assert.DoesNotThrow(() => mocks.Item2.Verify(repo => repo.Remove(It.Is <ResourceRelation>(removed => removed.SourceId == 1 && removed.TargetId == 3)), Times.Never), "Linker did remove relation 1-4"); }
public void CallMethodOnDerivedType() { // Arrange: Create instance var instance = new DerivedResource { Id = 5, Foo = 10 }; // Act: Build proxy and call method var proxy = (ISimpleResource)_typeController.GetProxy(instance); var result = proxy.MultiplyFoo(3); // Assert: Check result and modified foo Assert.AreEqual(40, result); Assert.AreEqual(40, proxy.Foo); }
public void UseBaseProxyForDerivedType() { // Arrange: Create instance var baseInstance = new SimpleResource { Id = 2 }; var instance = new DerivedResource { Id = 3 }; // Act: Build Proxy var baseProxy = (ISimpleResource)_typeController.GetProxy(baseInstance); var proxy = (ISimpleResource)_typeController.GetProxy(instance); // Assert: Make sure proxy is still the base type Assert.AreEqual(baseProxy.GetType(), proxy.GetType()); }
public void RemoveLinking() { // Arrange var instance = new ReferenceResource(); ResourceReferenceTools.InitializeCollections(instance); var deletedRef = new DerivedResource(); instance.Reference2 = deletedRef; instance.References.Add(deletedRef); instance.References.Add(new SimpleResource()); // Act // Call once for each relation _linker.RemoveLinking(deletedRef, instance); _linker.RemoveLinking(deletedRef, instance); // Assert Assert.IsNull(instance.Reference2); Assert.AreEqual(1, instance.References.Count); }
public void ReplaceWithProxy() { // Arrange: Create instance and reference var ref1 = new DerivedResource { Id = 9, Foo = 20 }; var ref2 = new SimpleResource { Id = 10, Foo = 30 }; var nonPub = new NonPublicResource { Name = "NonPublic" }; var instance = new ReferenceResource { Id = 8, Reference = ref1, NonPublic = nonPub }; instance.References = new ReferenceCollection <ISimpleResource>(instance, instance.GetType().GetProperty(nameof(ReferenceResource.References)), new List <IResource>()) { ref2 }; // Act: Convert to proxy and access the reference var proxy = (IReferenceResource)_typeController.GetProxy(instance); var reference = proxy.Reference; var methodRef = proxy.GetReference(); var references = proxy.MoreReferences.ToArray(); var references2 = proxy.GetReferences(); var nonPubProxy = proxy.NonPublic; ISimpleResource eventArgs = null; proxy.ReferenceChanged += (sender, resource) => eventArgs = resource; ISimpleResource[] eventArgs2 = null; proxy.SomeChanged += (sender, resources) => eventArgs2 = resources; // Act: Set resource property through proxy proxy.Reference = references[0]; proxy.SetReference(reference); // Make sure all references where replaced with proxies Assert.AreNotEqual(ref1, reference); Assert.AreNotEqual(ref2, references[0]); Assert.AreNotEqual(ref2, references2[0]); Assert.AreNotEqual(nonPub, nonPubProxy); Assert.AreEqual(20, reference.Foo); Assert.AreEqual(reference, methodRef); Assert.AreEqual(30, references[0].Foo); Assert.AreEqual(30, references2[0].Foo); Assert.NotNull(eventArgs); Assert.AreEqual(30, eventArgs.Foo); Assert.NotNull(eventArgs2); Assert.AreEqual(1, eventArgs2.Length); Assert.AreEqual(30, eventArgs2[0].Foo); Assert.AreEqual("NonPublic", nonPubProxy.Name); // Assert modifications of the setters Assert.AreEqual(instance.Reference, ref2); Assert.AreEqual(instance.References.Count(), 2); Assert.AreEqual(instance.References.ElementAt(1), ref1); }
public void SaveReferences() { // Arrange var instance = new ReferenceResource { Id = 1 }; ResourceReferenceTools.InitializeCollections(instance); // Prepare reference objects var ref1 = new SimpleResource { Id = 2, Name = "Ref1" }; var ref2 = new SimpleResource { Id = 3, Name = "Pos1" }; var ref3 = new DerivedResource { Name = "Ref2" }; ResourceReferenceTools.InitializeCollections(ref3); var ref4 = new DerivedResource { Id = 5, Name = "ChildOnly" }; var ref5 = new DerivedResource { Id = 6, Name = "BackRef" }; ResourceReferenceTools.InitializeCollections(ref5); // Fill graph _graph[1] = new ResourceWrapper(instance); _graph[2] = new ResourceWrapper(ref1); _graph[3] = new ResourceWrapper(ref2); _graph[5] = new ResourceWrapper(ref4); _graph[6] = new ResourceWrapper(ref5); // Set single references instance.Parent = ref5; // Parent is set and // ref5.Children.Add(instance); Bidirectional reference synced --> no longer necessary instance.Reference = ref2; // Reference is changed from ref1 to ref2 instance.Reference2 = ref3; // Reference2 is assigned with a new object // Fill collections instance.References.Add(ref1); // This element remains //instance.References.Add(ref2); // This element was removed instance.References.Add(ref3); // The new element is also added to the list, but is not a child // Fill children with all except the unsaved one to simulate an unchanged collection instance.Children.Add(ref1); instance.Children.Add(ref2); instance.Children.Add(ref4); // Setup uow and repo to simulate the current database var relations = new List <ResourceRelation> { // Parent child relations //Relation(6, ResourceRelationType.ParentChild, ResourceReferenceRole.Source), <-- Represents the missing bidirectional parent relationship created during this test Relation(2, 1), Relation(3, 1), Relation(5, 1), // Current exchangable part Relation(2, 1, ResourceRelationType.CurrentExchangablePart, ResourceReferenceRole.Target, nameof(ReferenceResource.Reference)), // This is changed to ref2 // Possible exchangable part Relation(2, 1, ResourceRelationType.PossibleExchangablePart), // This remains untouched Relation(3, 1, ResourceRelationType.PossibleExchangablePart) // This is removed }; var mocks = SetupDbMocks(relations); // Act var newResources = _linker.SaveReferences(mocks.Item1.Object, instance, new ResourceEntity { Id = 1 }); // Assert Assert.AreEqual(1, newResources.Count); Assert.AreEqual(ref3, newResources[0]); Assert.IsTrue(ref5.Children.Contains(instance), "Backlink sync failed for parent ref5"); Assert.DoesNotThrow(() => mocks.Item3.Verify(repo => repo.Create(), Times.Once), "Linker did not detect the new resource"); Assert.DoesNotThrow(() => mocks.Item2.Verify(repo => repo.Create((int)ResourceRelationType.PossibleExchangablePart), Times.Once), "Linker did not create relation for ref3 in References"); Assert.DoesNotThrow(() => mocks.Item2.Verify(repo => repo.Create((int)ResourceRelationType.ParentChild), Times.Once), "Linker did not create relation for parent ref5"); Assert.DoesNotThrow(() => mocks.Item2.Verify(repo => repo.Remove(It.Is <ResourceRelation>(removed => removed.SourceId == 1 && removed.TargetId == 3)), Times.Once), "Linker did not remove relation 1-3"); var parentChild = relations.Where(r => r.RelationType == (int)ResourceRelationType.ParentChild).ToArray(); Assert.AreEqual(4, parentChild.Length); var currentPart = relations.Where(r => r.RelationType == (int)ResourceRelationType.CurrentExchangablePart).ToArray(); Assert.AreEqual(2, currentPart.Length); Assert.AreEqual(1, currentPart.Count(r => r.Target.Id == 3)); Assert.AreEqual(1, currentPart.Count(r => r.Target.Id == 0)); var possiblePart = relations.Where(r => r.RelationType == (int)ResourceRelationType.PossibleExchangablePart).ToArray(); Assert.AreEqual(2, possiblePart.Length); Assert.AreEqual(1, possiblePart.Count(r => r.Target.Id == 2)); Assert.AreEqual(1, possiblePart.Count(r => r.Target.Id == 0)); }