public void SingleActiveLink()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v => v.AddManyToMany <Organisation, Person>("Employee"));
dynamic acme = population.New <Organisation>();
dynamic hooli = population.New <Organisation>();
dynamic jane = population.New <Person>();
dynamic john = population.New <Person>();
dynamic jenny = population.New <Person>();
acme.AddEmployee(jane);
acme.AddEmployee(john);
acme.AddEmployee(jenny);
Assert.Single(jane.OrganisationWhereEmployee);
Assert.Contains(acme, jane.OrganisationWhereEmployee);
Assert.Single(john.OrganisationWhereEmployee);
Assert.Contains(acme, john.OrganisationWhereEmployee);
Assert.Single(jenny.OrganisationWhereEmployee);
Assert.Contains(acme, jenny.OrganisationWhereEmployee);
Assert.Equal(3, acme.Employees.Length);
Assert.Contains(jane, acme.Employees);
Assert.Contains(john, acme.Employees);
Assert.Contains(jenny, acme.Employees);
Assert.Empty(hooli.Employees);
}
public void StaticPropertySet()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v =>
{
v.AddOneToOne <Organisation, Named>("Named");
v.AddOneToOne <Organisation, Person>("Owner");
});
var acme = population.New <Organisation>();
var gizmo = population.New <Organisation>();
var jane = population.New <Person>();
var john = population.New <Person>();
acme.Owner(jane);
Assert.Equal(jane, acme.Owner());
Assert.Equal(acme, jane.OrganisationWhereOwner());
Assert.Null(gizmo.Owner());
Assert.Null(john.OrganisationWhereOwner());
acme.Named(jane);
Assert.Equal(jane, acme.Named());
Assert.Equal(acme, jane.OrganisationWhereNamed());
Assert.Null(gizmo.Named());
Assert.Null(john.OrganisationWhereNamed());
}
public void Derivation()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v =>
{
v.AddUnit <Person, string>("FirstName");
v.AddUnit <Person, string>("LastName");
v.AddUnit <Person, string>("FullName");
v.AddUnit <Person, string>("DerivedAt");
});
population.DerivationById["FullName"] = new FullNameDerivation();
dynamic john = population.New <Person>();
john.FirstName = "John";
john.LastName = "Doe";
population.Derive();
Assert.Equal("John Doe", john.FullName);
population.DerivationById["FullName"] = new GreetingDerivation(population.DerivationById["FullName"]);
dynamic jane = population.New <Person>();
jane.FirstName = "Jane";
jane.LastName = "Doe";
population.Derive();
Assert.Equal("Jane Doe Chained", jane.FullName);
}
public void IndexByNameSet()
{
var meta = new DynamicMeta(new Pluralizer());
var population = new Default.DynamicPopulation(meta);
var(property, owner) = meta.AddOneToOne <Organisation, Person>("Owner");
var(organisation, named) = meta.AddOneToOne <Organisation, Person>("Named");
dynamic acme = population.New <Organisation>();
dynamic gizmo = population.New <Organisation>();
dynamic jane = population.New <Person>();
dynamic john = population.New <Person>();
acme["Owner"] = jane;
Assert.Equal(jane, acme.Owner);
Assert.Equal(acme, jane.OrganisationWhereOwner);
Assert.Equal(jane, acme["Owner"]);
Assert.Equal(acme, jane["OrganisationWhereOwner"]);
Assert.Equal(jane, acme[owner]);
Assert.Equal(acme, jane[property]);
Assert.Null(gizmo.Owner);
Assert.Null(john.OrganisationWhereOwner);
Assert.Null(gizmo["Owner"]);
Assert.Null(john["OrganisationWhereOwner"]);
Assert.Null(gizmo[owner]);
Assert.Null(john[property]);
// Wrong Type
Assert.Throws <ArgumentException>(() =>
{
acme["Owner"] = gizmo;
});
}
public void Derivation()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v =>
{
v.AddUnit <Person, string>("FirstName");
v.AddUnit <Person, string>("LastName");
v.AddUnit <Person, string>("FullName");
v.AddUnit <Person, DateTime>("DerivedAt");
v.AddUnit <Person, string>("Greeting");
});
population.DerivationById["FullName"] = new FullNameDerivation();
population.DerivationById["Greeting"] = new GreetingDerivation();
dynamic john = population.New <Person>();
john.FirstName = "John";
john.LastName = "Doe";
population.Derive();
Assert.Equal("Hello John Doe!", john.Greeting);
}
public void Filter()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v =>
{
v.AddUnit <Person, string>("FirstName");
v.AddUnit <Person, string>("LastName");
});
dynamic Create <T>(params Action <T>[] builders)
where T : DynamicObject
{
return(population.New <T>(builders));
}
Action <dynamic> FirstName(string firstName)
{
return((obj) => obj.FirstName = firstName);
}
Action <dynamic> LastName(string lastName)
{
return((obj) => obj.LastName = lastName);
}
dynamic NewPerson(string firstName, string lastName)
{
return(Create <Person>(FirstName(firstName), LastName(lastName)));
}
dynamic jane = NewPerson("Jane", "Doe");
dynamic john = NewPerson("John", "Doe");
dynamic jenny = NewPerson("Jenny", "Doe");
dynamic[] lastNameDoe = population.Objects.Where(v => v.LastName == "Doe").ToArray();
Assert.Equal(3, lastNameDoe.Length);
Assert.Contains(jane, lastNameDoe);
Assert.Contains(john, lastNameDoe);
Assert.Contains(jenny, lastNameDoe);
dynamic[] lessThanFourLetterFirstNames = population.Objects.Where(v => v.FirstName.Length < 4).ToArray();
Assert.Empty(lessThanFourLetterFirstNames);
dynamic[] fourLetterFirstNames = population.Objects.Where(v => v.FirstName.Length == 4).ToArray();
Assert.Equal(2, fourLetterFirstNames.Length);
Assert.Contains(jane, fourLetterFirstNames);
Assert.Contains(john, fourLetterFirstNames);
dynamic[] fiveLetterFirstNames = population.Objects.Where(v => v.FirstName.Length == 5).ToArray();
Assert.Single(fiveLetterFirstNames);
Assert.Contains(jenny, fiveLetterFirstNames);
}
public void PropertySet()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v => v.AddUnit <Person, string>("FirstName"));
dynamic jubayer = population.New <Person>();
dynamic walter = population.New <Person>();
jubayer.FirstName = "Jubayer";
walter.FirstName = "Walter";
Assert.Equal("Jubayer", jubayer.FirstName);
Assert.Equal("Walter", walter.FirstName);
}
public void AddDifferentAssociation()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v =>
{
v.AddUnit <Named, string>("Name");
v.AddOneToMany <Organisation, Person>("Employee");
});
dynamic acme = population.New <Organisation>();
dynamic jane = population.New <Person>();
jane.Name = "Jane";
dynamic john = population.New <Person>();
john.Name = "John";
dynamic jenny = population.New <Person>();
jenny.Name = "Jenny";
acme.AddEmployee(jane);
acme.AddEmployee(john);
acme.AddEmployee(jenny);
dynamic hooli = population.New <Organisation>();
hooli.AddEmployee(jane);
dynamic[] people = new[] { jane, john, jenny };
System.Collections.Generic.IEnumerable <dynamic> x = people.Where(v => "Jane".Equals(v.FirstName));
Assert.Contains(jane, hooli.Employees);
Assert.DoesNotContain(jane, acme.Employees);
Assert.Contains(john, acme.Employees);
Assert.Contains(jenny, acme.Employees);
Assert.Equal(hooli, jane.OrganisationWhereEmployee);
Assert.NotEqual(acme, jane.OrganisationWhereEmployee);
Assert.Equal(acme, john.OrganisationWhereEmployee);
Assert.Equal(acme, jenny.OrganisationWhereEmployee);
}
public void Remove()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v => v.AddOneToMany <Organisation, Person>("Employee"));
dynamic acme = population.New <Organisation>();
dynamic jane = population.New <Person>();
dynamic john = population.New <Person>();
dynamic jenny = population.New <Person>();
acme.AddEmployee(jane);
acme.AddEmployee(john);
acme.AddEmployee(jenny);
acme.RemoveEmployee(jane);
Assert.DoesNotContain(jane, acme.Employees);
Assert.Contains(john, acme.Employees);
Assert.Contains(jenny, acme.Employees);
Assert.NotEqual(acme, jane.OrganisationWhereEmployee);
Assert.Equal(acme, john.OrganisationWhereEmployee);
Assert.Equal(acme, jenny.OrganisationWhereEmployee);
acme.RemoveEmployee(john);
Assert.DoesNotContain(jane, acme.Employees);
Assert.DoesNotContain(john, acme.Employees);
Assert.Contains(jenny, acme.Employees);
Assert.NotEqual(acme, jane.OrganisationWhereEmployee);
Assert.NotEqual(acme, john.OrganisationWhereEmployee);
Assert.Equal(acme, jenny.OrganisationWhereEmployee);
acme.RemoveEmployee(jenny);
Assert.DoesNotContain(jane, acme.Employees);
Assert.DoesNotContain(john, acme.Employees);
Assert.DoesNotContain(jenny, acme.Employees);
Assert.NotEqual(acme, jane.OrganisationWhereEmployee);
Assert.NotEqual(acme, john.OrganisationWhereEmployee);
Assert.NotEqual(acme, jenny.OrganisationWhereEmployee);
}
public void SameUnitTypeName()
{
var population = new Default.DynamicPopulation(new DynamicMeta(new Pluralizer()));
var c1Same = population.Meta.AddUnit <C1, string>("Same");
var c2Same = population.Meta.AddUnit <C2, string>("Same");
New <C1> newC1 = population.New;
New <C2> newC2 = population.New;
var c1 = newC1(v =>
{
v.Same("c1");
});
var c2 = newC2(v =>
{
v.Same("c2");
});
Assert.Equal("c1", c1.Same());
Assert.Equal("c2", c2.Same());
}
public void Snapshot()
{
var population = new Default.DynamicPopulation(
new DynamicMeta(new Pluralizer()),
v =>
{
v.AddUnit <Person, string>("FirstName");
v.AddUnit <Person, string>("LastName");
});
dynamic john = population.New <Person>();
dynamic jane = population.New <Person>();
john.FirstName = "John";
john.LastName = "Doe";
DynamicChangeSet snapshot1 = population.Snapshot();
jane.FirstName = "Jane";
jane.LastName = "Doe";
System.Collections.Generic.Dictionary <DynamicObject, object> changedFirstNames = snapshot1.ChangedRoles <Person>("FirstName");
System.Collections.Generic.Dictionary <DynamicObject, object> changedLastNames = snapshot1.ChangedRoles <Person>("LastName");
Assert.Single(changedFirstNames.Keys);
Assert.Single(changedLastNames.Keys);
Assert.Contains(john, changedFirstNames.Keys);
Assert.Contains(john, changedLastNames.Keys);
DynamicChangeSet snapshot2 = population.Snapshot();
changedFirstNames = snapshot2.ChangedRoles <Person>("FirstName");
changedLastNames = snapshot2.ChangedRoles <Person>("LastName");
Assert.Single(changedFirstNames.Keys);
Assert.Single(changedLastNames.Keys);
Assert.Contains(jane, changedFirstNames.Keys);
Assert.Contains(jane, changedLastNames.Keys);
}
public void New()
{
var population = new Default.DynamicPopulation(new DynamicMeta(new Pluralizer()));
var name = population.Meta.AddUnit <Named, string>("Name");
var(property, owner) = population.Meta.AddOneToOne <Organisation, Person>("Owner");
New <Organisation> newOrganisation = population.New;
New <Person> newPerson = population.New;
var acme = newOrganisation(v =>
{
v.Name("Acme");
v.Owner(newPerson(v => v.Name("Jane")));
});
var jane = acme.Owner();
Assert.Equal("Acme", acme.Name());
Assert.Equal("Jane", jane.Name());
Assert.Equal(acme, jane.OrganisationWhereOwner());
}
