public void TestCompareStructurePropertyArray()
{
var merger = new MyLittleMerger <NamedArrayObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var itemA = new NamedArrayObject {
Name = null, Items = new[] { "A", null, "B", "C" }
};
var instanceStructureA = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemA);
var itemB = new NamedArrayObject {
Name = null, Items = new[] { "A", "B", "C" }
};
var instanceStructureB = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemB);
var mergeStructure = new MergerCompareStructure <NamedArrayObject>(instanceStructureA, instanceStructureB);
var itemsProperties = mergeStructure.Properties.First(p => Equals(p.Key.Identifier, nameof(NamedArrayObject.Items))).Value;
Assert.AreEqual(MergerCompareResult.Equal, itemsProperties[0].Result);
Assert.AreEqual(MergerCompareResult.OnlyRight, itemsProperties[1].Result);
Assert.AreEqual(MergerCompareResult.Different, itemsProperties[2].Result);
Assert.AreEqual(MergerCompareResult.OnlyLeft, itemsProperties[3].Result);
Assert.AreEqual(MergerCompareResult.Different, mergeStructure.Result);
}
internal MergerTypeStructure(MyLittleMerger merger, Type type, PropertyInfo propertyInfo = null, string name = "", bool isArray = false, bool isNullable = false)
: base(propertyInfo, type, name, isArray, isNullable)
{
Merger = merger;
Properties = new List <MergerTypeProperty>();
Nodes = new List <MergerTypeStructure>();
foreach (var property in type.GetProperties())
{
Type underlyingPropertyType;
var propertyIsArray = false;
var propertyIsNullable = false;
if (property.PropertyType.IsArray)
{
propertyIsArray = true;
underlyingPropertyType = property.PropertyType.GetElementType();
}
else if (property.PropertyType.TryGetUnderlyingNullable(out underlyingPropertyType))
{
propertyIsNullable = true;
}
else
{
underlyingPropertyType = property.PropertyType;
}
if (Options.NodeAssemblies.Any(a => Equals(a.FullName, underlyingPropertyType?.Assembly.FullName)))
{
Nodes.Add(new MergerTypeStructure(merger, property, underlyingPropertyType, property.Name, isArray: propertyIsArray, isNullable: propertyIsNullable));
}
else
{
Properties.Add(new MergerTypeProperty(property, underlyingPropertyType, property.Name, isArray: propertyIsArray, isNullable: propertyIsNullable));
}
}
}
public void TestCompareStructurePropertyEqualString()
{
var merger = new MyLittleMerger <NamedArrayObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var itemA = new NamedArrayObject {
Name = "Item"
};
var instanceStructureA = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemA);
var itemB = new NamedArrayObject {
Name = "Item"
};
var instanceStructureB = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemB);
var mergeStructure = new MergerCompareStructure <NamedArrayObject>(instanceStructureA, instanceStructureB);
Assert.AreEqual(itemA, mergeStructure.Instance.Value);
Assert.AreEqual(itemB, mergeStructure.Compare.Value);
Assert.AreEqual(0, mergeStructure.Nodes.Count);
Assert.AreEqual(2, mergeStructure.Properties.Count);
Assert.AreEqual(MergerCompareResult.Equal, mergeStructure.Properties.First().Value.First().Result);
Assert.AreEqual(MergerCompareResult.Equal, mergeStructure.Result);
}
public void TestResolveWrongType()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var executed = false;
merger.RegisterResolver("ContactObject.FirstName", (left, right) =>
{
left.Value = 12;
executed = true;
return(left);
});
var instance = ContactData.David;
var compare = ContactData.Jennifer;
try
{
merger.Resolve(instance, compare);
}
catch (ArgumentException)
{
Assert.IsTrue(executed);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public void TestResolveStructureNonRun()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var executed = false;
merger.RegisterResolver <SocialMediaObject>("ContactObject.TwitterAccount", (left, right) =>
{
left.Value = new SocialMediaObject()
{
Name = "NEW"
};
executed = true;
return(left);
});
var instance = ContactData.David;
var compare = ContactData.Jennifer;
merger.Resolve(instance, compare);
Assert.IsFalse(executed);
Assert.AreEqual(ContactData.David.TwitterAccount.Name, instance.TwitterAccount.Name);
}
public void TestCompareStructurePropertyPrint()
{
var merger = new MyLittleMerger <NamedArrayObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var itemA = new NamedArrayObject {
Name = "ItemA", Items = new[] { "A", null, "B", "C" }
};
var instanceStructureA = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemA);
var itemB = new NamedArrayObject {
Name = "ItemB", Items = new[] { "A", "B", "C" }
};
var instanceStructureB = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemB);
var mergeStructure = new MergerCompareStructure <NamedArrayObject>(instanceStructureA, instanceStructureB);
var print = mergeStructure.Print();
Assert.IsTrue(print.Contains($"{nameof(NamedArrayObject)}: {MergerCompareResult.Different}"));
Assert.IsTrue(print.Contains($"A <> A: {MergerCompareResult.Equal}"));
Assert.IsTrue(print.Contains($"NULL <> B: {MergerCompareResult.OnlyRight}"));
Assert.IsTrue(print.Contains($"B <> C: {MergerCompareResult.Different}"));
Assert.IsTrue(print.Contains($"C <> NULL: {MergerCompareResult.OnlyLeft}"));
}
public void TestResolveStringPropertyTyped()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var executed = false;
merger.RegisterResolver <string>("ContactObject.FirstName", (left, right) =>
{
left.Value += right.Value;
executed = true;
return(left);
});
var instance = ContactData.David;
var compare = ContactData.Jennifer;
merger.Resolve(instance, compare);
Assert.IsTrue(executed);
Assert.AreEqual(ContactData.David.FirstName + ContactData.Jennifer.FirstName, instance.FirstName);
Assert.AreEqual(ContactData.Jennifer.FirstName, compare.FirstName);
}
public void TestInitialize()
{
var merger = new MyLittleMerger <LittleObject>();
Assert.IsFalse(merger.Initialized);
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
Assert.IsTrue(merger.Initialized);
}
public void TestContactObjectStructure()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
Assert.AreEqual(typeof(ContactObject), merger.Structure.Type);
Assert.AreEqual(5, merger.Structure.Nodes.Count);
Assert.AreEqual(6, merger.Structure.Properties.Count);
}
public void TestLittleObjectPrint()
{
var merger = new MyLittleMerger <LittleObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var print = merger.Structure.Print();
Assert.IsFalse(string.IsNullOrEmpty(print));
Assert.IsTrue(print.Contains($"- {nameof(LittleObject)}"));
Assert.IsTrue(print.Contains($"{nameof(LittleObject.LonelyProperty)} - String"));
}
public void TestNodeNullArray()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var item = new ContactObject();
var instanceStructure = new MergerInstanceStructure <ContactObject>(merger.Structure, item);
var print = instanceStructure.Print();
Assert.IsTrue(print.Contains($"{nameof(ContactObject.Addresses)} - {nameof(AddressObject)}[]"));
}
public void TestLittleObjectStructure()
{
var merger = new MyLittleMerger <LittleObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
Assert.AreEqual(typeof(LittleObject), merger.Structure.Type);
Assert.AreEqual(0, merger.Structure.Nodes.Count);
Assert.AreEqual(1, merger.Structure.Properties.Count);
Assert.AreEqual(typeof(string), merger.Structure.Properties[0].Type);
}
public void TestContactObjectPrint()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var item = ContactData.David;
var instanceStructure = new MergerInstanceStructure <ContactObject>(merger.Structure, item);
var print = instanceStructure.Print();
Assert.IsTrue(print.Contains($"{nameof(ContactObject.Id)} - {nameof(Guid)}: {item.Id}"));
}
public void TestFindByPropertyFail()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var lonelyProperty = typeof(LittleObject).GetProperty(nameof(LittleObject.LonelyProperty));
var success = merger.Structure.TryFind(lonelyProperty, out var result);
Assert.IsFalse(success);
Assert.IsNull(result);
}
public void TestFindByStringFail()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var foobarPath = $"{nameof(ContactObject)}.{nameof(ContactObject.Addresses)}.Foobar";
var success = merger.Structure.TryFind(foobarPath, out var result);
Assert.IsFalse(success);
Assert.IsNull(result);
}
public void TestNullInstance()
{
var merger = new MyLittleMerger <LittleObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var instanceStructure = new MergerInstanceStructure <LittleObject>(merger.Structure, null);
var print = instanceStructure.Print();
Assert.IsFalse(instanceStructure.HasValue);
Assert.IsTrue(print.Contains($"+ LittleObject"));
Assert.IsTrue(print.Contains($"{nameof(LittleObject.LonelyProperty)} - {nameof(String)}: NULL"));
}
public void TestContactObjectLonelyObjectStructureEquality()
{
var mergerA = new MyLittleMerger <ContactObject>(new MergerOptions
{
AutoAddTypeAssembly = true
});
var structureA = new MergerTypeStructure <ContactObject>(mergerA);
var mergerB = new MyLittleMerger <LittleObject>(new MergerOptions
{
AutoAddTypeAssembly = true
});
var structureB = new MergerTypeStructure <LittleObject>(mergerB);
// ReSharper disable once PossibleUnintendedReferenceComparison
Assert.AreNotEqual(structureA, structureB);
}
public void TestFindByPropertyPropertyCity()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var cityProperty = typeof(AddressObject).GetProperty(nameof(AddressObject.City));
var success = merger.Structure.TryFind(cityProperty, out var result);
Assert.IsTrue(success);
Assert.IsNotNull(result);
Assert.AreEqual(cityProperty?.Name, result.Identifier);
}
public void TestCompareStructureNode()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var instanceStructureA = new MergerInstanceStructure <ContactObject>(merger.Structure, ContactData.David);
var instanceStructureB = new MergerInstanceStructure <ContactObject>(merger.Structure, ContactData.Jennifer);
var mergeStructure = new MergerCompareStructure <ContactObject>(instanceStructureA, instanceStructureB);
var print = mergeStructure.Print();
Assert.IsTrue(print.Contains($"{ContactData.David.FirstName} <> {ContactData.Jennifer.FirstName}: {MergerCompareResult.Different}"));
}
public void TestContactObjectStructure()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var instanceStructure = new MergerInstanceStructure <ContactObject>(merger.Structure, ContactData.David);
Assert.AreEqual(typeof(ContactObject), instanceStructure.TypeStructure.Type);
Assert.AreEqual(5, instanceStructure.Nodes.Count);
Assert.AreEqual(6, instanceStructure.Properties.Count);
Assert.AreEqual(typeof(Guid), instanceStructure.Properties.First().Value.First().TypeProperty.Type);
Assert.AreEqual(ContactData.David.Id, instanceStructure.Properties.First().Value.First().Value);
}
public void TestFindByStringPropertyCity()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var cityPath = $"{nameof(ContactObject)}.{nameof(ContactObject.Addresses)}.{nameof(AddressObject.City)}";
var success = merger.Structure.TryFind(cityPath, out var result);
Assert.IsTrue(success);
Assert.IsNotNull(result);
Assert.AreEqual(nameof(AddressObject.City), result.Identifier);
}
public void TestContactObjectStructureEquality()
{
var merger = new MyLittleMerger <ContactObject>(new MergerOptions
{
AutoAddTypeAssembly = true
});
var structureA = new MergerTypeStructure <ContactObject>(merger);
var structureB = new MergerTypeStructure <ContactObject>(merger);
var genderNodeA = structureA.Nodes.First(n => Equals(n.Identifier, nameof(ContactObject.Gender)));
var genderNodeB = structureB.Nodes.First(n => Equals(n.Identifier, nameof(ContactObject.Gender)));
// ReSharper disable once PossibleUnintendedReferenceComparison
Assert.IsFalse(structureA == structureB);
Assert.AreEqual(genderNodeA, genderNodeB);
Assert.AreEqual(structureA, structureB);
}
public void TestLittleObjectPrint()
{
var merger = new MyLittleMerger <LittleObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var littleObject = new LittleObject()
{
LonelyProperty = "Hello there"
};
var instanceStructure = new MergerInstanceStructure <LittleObject>(merger.Structure, littleObject);
var print = instanceStructure.Print();
Assert.IsTrue(print.Contains($"+ LittleObject"));
Assert.IsTrue(print.Contains($"{nameof(LittleObject.LonelyProperty)} - {nameof(String)}: {littleObject.LonelyProperty}"));
}
public void TestPropertyNullArray()
{
var merger = new MyLittleMerger <NamedArrayObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var item = new NamedArrayObject()
{
Name = "Test", Items = null
};
var instanceStructure = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, item);
var print = instanceStructure.Print();
Assert.IsTrue(print.Contains($"{nameof(NamedArrayObject.Name)} - {nameof(String)}: {item.Name}"));
Assert.IsTrue(print.Contains($"{nameof(NamedArrayObject.Items)} - {nameof(String)}[]"));
}
public void TestPropertyNullString()
{
var merger = new MyLittleMerger <LittleObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var item = new LittleObject()
{
LonelyProperty = null
};
var instanceStructure = new MergerInstanceStructure <LittleObject>(merger.Structure, item);
var print = instanceStructure.Print();
Assert.IsNull(instanceStructure.Properties.First().Value.First().Value);
Assert.IsFalse(instanceStructure.Properties.First().Value.First().HasValue);
Assert.IsTrue(print.Contains($"{nameof(LittleObject.LonelyProperty)} - {nameof(String)}: NULL"));
}
public void TestCompareStructurePropertyOnlyRightString()
{
var merger = new MyLittleMerger <NamedArrayObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var instanceStructureA = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, null);
var itemB = new NamedArrayObject {
Name = "ItemB"
};
var instanceStructureB = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemB);
var mergeStructure = new MergerCompareStructure <NamedArrayObject>(instanceStructureA, instanceStructureB);
Assert.AreEqual(MergerCompareResult.OnlyRight, mergeStructure.Properties.First().Value.First().Result);
Assert.AreEqual(MergerCompareResult.OnlyRight, mergeStructure.Result);
}
public void TestContactObjectPrint()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var print = merger.Structure.Print();
Assert.IsFalse(string.IsNullOrEmpty(print));
Assert.IsTrue(print.Contains($"- {nameof(ContactObject)}"));
Assert.IsTrue(print.Contains($"{nameof(ContactObject.Id)} - {nameof(Guid)}"));
Assert.IsTrue(print.Contains($"{nameof(ContactObject.FirstName)} - {nameof(String)}"));
Assert.IsTrue(print.Contains($"{nameof(ContactObject.Friends)} - {nameof(String)}[]"));
Assert.IsTrue(print.Contains($"{nameof(ContactObject.Birthday)} - {nameof(DateTime)}?"));
Assert.IsTrue(print.Contains($"+ {nameof(ContactObject.Gender)} - {nameof(GenderEnum)}?"));
Assert.IsTrue(print.Contains($"+ {nameof(ContactObject.Addresses)} - {nameof(AddressObject)}[]"));
Assert.IsTrue(print.Contains($"+ {nameof(AddressObject.County)} - {nameof(CountryObject)}"));
}
public void TestLittleObjectStructure()
{
var merger = new MyLittleMerger <LittleObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var littleObject = new LittleObject {
LonelyProperty = "Hello there"
};
var instanceStructure = new MergerInstanceStructure <LittleObject>(merger.Structure, littleObject);
Assert.AreEqual(typeof(LittleObject), instanceStructure.TypeStructure.Type);
Assert.IsTrue(instanceStructure.HasValue);
Assert.AreEqual(0, instanceStructure.Nodes.Count);
Assert.AreEqual(1, instanceStructure.Properties.Count);
Assert.AreEqual(1, instanceStructure.Properties.First().Value.Count);
Assert.AreEqual(typeof(string), instanceStructure.Properties.First().Value.First().TypeProperty.Type);
Assert.AreEqual(littleObject.LonelyProperty, instanceStructure.Properties.First().Value.First().Value);
}
public void TestCompareStructurePropertyOnlyRightProperty()
{
var merger = new MyLittleMerger <NamedArrayObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var itemA = new NamedArrayObject {
Name = null, Items = new[] { "A1", "C", "A3" }
};
var instanceStructureA = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemA);
var itemB = new NamedArrayObject {
Name = "ItemB", Items = new[] { "B1", "C", "B3" }
};
var instanceStructureB = new MergerInstanceStructure <NamedArrayObject>(merger.Structure, itemB);
var mergeStructure = new MergerCompareStructure <NamedArrayObject>(instanceStructureA, instanceStructureB);
Assert.AreEqual(MergerCompareResult.OnlyRight, mergeStructure.Properties.First().Value.First().Result);
Assert.AreEqual(MergerCompareResult.Different, mergeStructure.Properties.Second().Value.First().Result);
Assert.AreEqual(MergerCompareResult.Equal, mergeStructure.Properties.Second().Value.Second().Result);
Assert.AreEqual(MergerCompareResult.Different, mergeStructure.Result);
}
internal MergerTypeStructure(MyLittleMerger merger, PropertyInfo property, Type type, string name, bool isArray = false, bool isNullable = false)
: this(merger, type, property, name, isArray, isNullable)
{
}
