public void CanTrackListPropertyChanges()
{
A a = TrackableObjectFactory.CreateFrom(new A());
a.Items.Add("hola");
B b = TrackableObjectFactory.CreateFrom(new B());
b.Dogs.First().Name = "Rex";
b.Dogs.Add(new Dog {
Name = "Rex"
});
C c = TrackableObjectFactory.CreateFrom(new C());
c.Dogs.Add(new Dog {
Name = "Rex"
});
IObjectChangeTracker Atracking = a.GetChangeTracker();
IObjectChangeTracker Btracking = b.GetChangeTracker();
IObjectChangeTracker Ctracking = c.GetChangeTracker();
Assert.AreEqual(1, Atracking.ChangedProperties.Count);
Assert.AreEqual(1, Btracking.ChangedProperties.Count);
Assert.AreEqual(1, Ctracking.ChangedProperties.Count);
}
public void CanUndoAcceptSimplePropertyChangesAndContinueTrackingChanges()
{
const string initialValue = "hello world";
const string changedValue = "hello world 2";
A a = TrackableObjectFactory.CreateFrom(new A {
Text = initialValue
});
a.Text = changedValue;
IObjectChangeTracker changeTracker = a.GetChangeTracker();
a.UndoChanges();
a.Text = changedValue;
Assert.AreEqual(1, changeTracker.ChangedProperties.Count);
a.AcceptChanges();
a.Text = initialValue;
Assert.AreEqual(1, changeTracker.ChangedProperties.Count);
}
public void CanTrackSimplePropertyChanges()
{
const string initialValue = "hello world";
const string changedValue = "hello world 2";
A a = TrackableObjectFactory.CreateFrom(new A {
Text = initialValue
});
a.Text = changedValue;
Assert.AreNotEqual(initialValue, a.Text);
Assert.AreEqual(changedValue, a.Text);
IObjectChangeTracker changeTracker = a.GetChangeTracker();
Assert.AreEqual(1, changeTracker.ChangedProperties.Count);
Assert.AreEqual(1, changeTracker.UnchangedProperties.Count);
IDeclaredObjectPropertyChangeTracking tracking = changeTracker.ChangedProperties.OfType <IDeclaredObjectPropertyChangeTracking>().Single();
Assert.AreEqual("Text", tracking.Property.Name);
Assert.AreEqual(initialValue, tracking.OldValue);
Assert.AreEqual(changedValue, tracking.CurrentValue);
}
public void CanTrackChangesOfAssociations()
{
const string initialAText = "hello";
const string initialBText = "world";
const string initialCText = "!";
const string initialDText = "boh!";
A a = TrackableObjectFactory.CreateFrom
(
new A
{
Text = initialAText,
B = new B
{
Text = initialBText,
C = new C
{
Text = initialCText,
ListOfD = new List <D>
{
new D {
Text = initialDText
}
}
}
}
}
);
IObjectChangeTracker tracker = a.GetChangeTracker();
int changeCount = 0;
tracker.Changed += (s, e) =>
{
changeCount++;
};
a.B.C.Text = "changed 1!";
a.B.Text = "changed 2!";
a.Text = "changed 3!";
a.B.C.ListOfD.First().Text = "changed 4!";
a.B.C.ListOfD.Add(new D {
Text = "changed 5!"
});
Assert.AreEqual(5, changeCount);
Assert.AreEqual(4, tracker.ChangedProperties.Count);
Assert.AreEqual(2, tracker.UnchangedProperties.Count);
Assert.AreEqual("changed 1!", a.B.C.Text);
Assert.AreEqual("changed 2!", a.B.Text);
Assert.AreEqual("changed 3!", a.Text);
Assert.AreEqual("changed 4!", a.B.C.ListOfD.First().Text);
Assert.AreEqual("changed 5!", a.B.C.ListOfD.Last().Text);
}
public void CanTrackSetPropertyChanges()
{
C c = TrackableObjectFactory.CreateFrom(new C());
IObjectChangeTracker Ctracking = c.GetChangeTracker();
IReadOnlyChangeTrackableCollection trackableCollection = (IReadOnlyChangeTrackableCollection)c.Dogs;
c.Dogs.Add(new Dog {
Name = "Rex"
});
Assert.AreEqual(1, Ctracking.ChangedProperties.Count);
}
public void AffectTheSameValueObjectStayInUnchangedState()
{
const int initialValue = 0;
var a = TrackableObjectFactory.CreateFrom(new ClassWithIntegers {
Foo = initialValue
});
IObjectChangeTracker changeTracker = a.GetChangeTracker();
Assert.AreEqual(0, changeTracker.ChangedProperties.Count);
Assert.AreEqual(1, changeTracker.UnchangedProperties.Count);
a.Foo = 2;
a.Foo = initialValue;
Assert.AreEqual(0, changeTracker.ChangedProperties.Count);
Assert.AreEqual(1, changeTracker.UnchangedProperties.Count);
}
public void CanGetTrackingObjectGraph()
{
A a = TrackableObjectFactory.CreateFrom
(
new A
{
Text = "hey",
B = new B
{
Text = "hurray",
C = new C
{
Text = "uhm",
ListOfD = new List <D> {
new D {
Text = "ohm"
}
}
}
}
}
);
IObjectChangeTracker changeTracker = a.GetChangeTracker();
var C_ListOfDGraph = changeTracker.GetTrackingGraphFromProperty(typeof(C).GetTypeInfo().GetProperty("ListOfD"));
Assert.AreEqual(typeof(C).GetProperty("ListOfD"), C_ListOfDGraph.AggregateHierarchy[2].Property.GetBaseProperty());
Assert.AreEqual(typeof(B).GetProperty("C"), C_ListOfDGraph.AggregateHierarchy[1].Property.GetBaseProperty());
Assert.AreEqual(typeof(A).GetProperty("B"), C_ListOfDGraph.AggregateHierarchy[0].Property.GetBaseProperty());
Assert.AreEqual(a, C_ListOfDGraph.Parent);
changeTracker.Changed += (s, e) =>
{
DeclaredObjectPropertyChangeEventArgs declaredArgs = e as DeclaredObjectPropertyChangeEventArgs;
IObjectGraphTrackingInfo graphInfo = declaredArgs.GraphTrackingInfo;
Assert.AreEqual(typeof(B).GetProperty("Text"), graphInfo.AggregateHierarchy[1].Property.GetBaseProperty());
Assert.AreEqual(typeof(A).GetProperty("B"), graphInfo.AggregateHierarchy[0].Property.GetBaseProperty());
Assert.AreEqual(a, graphInfo.Parent);
};
a.B.Text = "hello world";
}
public void CanAcceptObjectGraphChanges()
{
const string initialValue = "hello world";
const string changedValue = "hello world 2";
A a = TrackableObjectFactory.CreateFrom
(
new A
{
Text = initialValue,
B = new B
{
Text = initialValue,
C = new C
{
Text = initialValue,
ListOfD = new List <D> {
new D {
Text = "initialValue"
}
}
}
}
}
);
a.Text = changedValue;
a.B.Text = changedValue;
a.B.C.Text = changedValue;
a.B.C.ListOfD.Add(new D {
Text = changedValue
});
IObjectChangeTracker changeTracker = a.GetChangeTracker();
a.AcceptChanges();
Assert.AreEqual(changedValue, a.Text);
Assert.AreEqual(changedValue, a.B.Text);
Assert.AreEqual(changedValue, a.B.C.Text);
Assert.AreEqual(2, a.B.C.ListOfD.Count);
}
public void CanConfigureClassWithReadOnlyProperties()
{
IObjectChangeTrackingConfiguration config = ObjectChangeTracking.CreateConfiguration();
config.TrackTypesFromAssembly(typeof(ConfigurationTest).GetTypeInfo().Assembly, searchSettings: new TypeSearchSettings
{
Mode = TypeSearchMode.AttributeConfigurationOnly,
Filter = t => t == typeof(ClassWithReadOnlyProperties)
});
ITrackableObjectFactory factory = config.CreateTrackableObjectFactory();
ClassWithReadOnlyProperties instance = factory.CreateFrom(new ClassWithReadOnlyProperties());
instance.Text = "hey";
IObjectChangeTracker tracker = instance.GetChangeTracker();
Assert.AreEqual(1, tracker.ChangedProperties.Count);
Assert.AreEqual(1, ((ObjectChangeTracker)tracker).PropertyTrackings.Count);
}
public void CanConfigureNonTrackablePropertiesFromBaseClasses()
{
IObjectChangeTrackingConfiguration config = ObjectChangeTracking.CreateConfiguration();
config.TrackTypesFromAssembly(typeof(ConfigurationTest).GetTypeInfo().Assembly, searchSettings: new TypeSearchSettings
{
Mode = TypeSearchMode.AttributeConfigurationOnly,
Recursive = true,
Filter = t =>
{
return(t.DeclaringType == typeof(ConfigurationTest));
}
});
ITrackableObjectFactory trackableObjectFactory = config.CreateTrackableObjectFactory();
DerivedClassOfBaseClassWithNonTrackableProperty obj = trackableObjectFactory.CreateOf <DerivedClassOfBaseClassWithNonTrackableProperty>();
IObjectChangeTracker changeTracker = obj.GetChangeTracker();
Assert.AreEqual(1, changeTracker.Count());
Assert.IsTrue(changeTracker.First().PropertyName == "Text2");
}
public void CanTrackDynamicObjectPropertyChanges()
{
dynamic dynamicObject = TrackableObjectFactory.CreateFrom(new TestDynamicObject());
dynamicObject.Text = "hello world 1";
dynamicObject.Text = "hello world 2";
dynamicObject.Text2 = "hello world 3";
((TestDynamicObject)dynamicObject).DeclaredText = "hello world 4";
((TestDynamicObject)dynamicObject).DeclaredText = "hello world 5";
IObjectChangeTracker tracker = ((object)dynamicObject).GetChangeTracker();
IObjectPropertyChangeTracking tracking = tracker.GetDynamicTrackingByProperty("Text");
Assert.AreEqual(2, tracker.ChangedProperties.Count);
Assert.AreEqual("Text", tracking.PropertyName);
Assert.AreEqual("hello world 1", tracking.OldValue);
Assert.AreEqual("hello world 2", tracking.CurrentValue);
Assert.AreEqual("hello world 1", ((object)dynamicObject).OldPropertyValue("Text"));
Assert.AreEqual(null, ((TestDynamicObject)dynamicObject).OldPropertyValue(o => o.DeclaredText));
Assert.AreEqual("hello world 2", ((object)dynamicObject).CurrentPropertyValue("Text"));
Assert.AreEqual("hello world 5", ((TestDynamicObject)dynamicObject).CurrentPropertyValue(o => o.DeclaredText));
Assert.IsTrue(((object)dynamicObject).PropertyHasChanged("Text"));
Assert.IsFalse(((object)dynamicObject).PropertyHasChanged("Text2"));
}
