public void FetchByScanSpec()
{
var ec1 = new EntityC {
A = new EntityA(), B = new EntityB(), X = new EntityX(), Y = new EntityY()
};
TestBase.TestSerialization(ec1);
var ex21 = new EntityX2();
TestBase.TestSerialization(ex21);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
em.Persist(ex21);
}
using (var em = Emf.CreateEntityManager())
{
var _ec = em.Fetch <EntityC>(new ScanSpec(ec1.Id));
Assert.IsNotNull(_ec);
Assert.AreEqual(1, _ec.Count());
Assert.AreEqual(ec1, _ec.First());
var ss = new ScanSpec();
ss.AddColumn("a");
var _ex = em.Fetch <EntityXBase>(ss);
Assert.IsNotNull(_ex);
Assert.AreEqual(2, _ex.Count());
Assert.AreEqual(ec1.X, _ex.OfType <EntityX>().First());
Assert.AreEqual(ex21, _ex.OfType <EntityX2>().First());
}
}
public void Find()
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ec2 = new EntityC();
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
var _ec2 = em.Find <EntityC>(ec2.Id);
Assert.AreEqual(ec2, _ec2);
}
}
/// <summary>
/// Función para crear una entidad dentro de la factoría a partir
/// de los argumentos especificados.
/// </summary>
/// <remarks>
/// Crea una entidad de tipo <see cref="ICategoria"/>
/// </remarks>
/// <param name="nombre">
///
/// </param>
/// <returns>
/// Devuelve una entidad de tipo <see cref="ICategoriaFactory"/>
/// </returns>
public static EntityC Create(EntityA entityA, string nombre)
{
// El Id viene dado cuando se inserte en la BBDD... de momento tiene uno temporal.
// Creamos la nueva entidad.
EntityC entityC = new EntityC(entityA, nombre);
//devolvemos la entidad recien creada
return entityC;
}
public void PersistChildren()
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ec2 = new EntityC {
A = new EntityA(), B = new EntityB()
};
TestBase.TestSerialization(ec2);
var ec3 = new EntityC {
X = new EntityX(), Y = new EntityY()
};
TestBase.TestSerialization(ec3);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
Assert.IsFalse(ec2.A.Id.Equals(Guid.Empty));
Assert.IsFalse(ec2.B.Id.Equals(Guid.Empty));
em.Persist(ec3);
Assert.IsFalse(string.IsNullOrEmpty(ec3.Id));
Assert.IsFalse(string.IsNullOrEmpty(ec3.X.Id));
Assert.IsFalse(string.IsNullOrEmpty(ec3.Y.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
var _ea2 = em.Find <EntityA>(ec2.A.Id);
Assert.AreEqual(ec2.A, _ea2);
var _eb2 = em.Find <EntityB>(ec2.B.Id);
Assert.AreEqual(ec2.B, _eb2);
var _ec2 = em.Find <EntityC>(ec2.Id);
Assert.AreEqual(ec2, _ec2);
var _ex3 = em.Find <EntityX>(ec3.X.Id);
Assert.AreEqual(ec3.X, _ex3);
var _ey3 = em.Find <EntityY>(ec3.Y.Id);
Assert.AreEqual(ec3.Y, _ey3);
var _ec3 = em.Find <EntityC>(ec3.Id);
Assert.AreEqual(ec3, _ec3);
}
}
public void Test()
{
using (var store = NewDocumentStore())
{
EntityA a = new EntityA { Id = Guid.NewGuid() };
EntityB b = new EntityB { Id = a.Id };
EntityC c = new EntityC { Id = Guid.NewGuid(), EntityAId = a.Id, EntityBId = b.Id };
using (var session = store.OpenSession())
{
session.Store(a);
session.Store(b);
session.Store(c);
session.SaveChanges();
Assert.AreEqual(store.DatabaseCommands.GetStatistics().CountOfDocuments, 3);
}
using (var session = store.OpenSession())
{
var resultA = session.Load<EntityA>(c.EntityAId);
var resultB = session.Load<EntityB>(c.EntityBId);
var resultC = session.Load<EntityC>(c.Id);
Assert.NotNull(resultA, "resultA");
Assert.NotNull(resultB, "resultB - Load");
Assert.NotNull(resultC, "resultC");
Assert.AreEqual(session.Advanced.NumberOfRequests, 3);
}
using (var session = store.OpenSession())
{
var resultC =
session
.Include<EntityC, EntityA>(x => x.EntityAId)
.Include<EntityB>(x => x.EntityBId)
.Load<EntityC>(c.Id);
var resultA = session.Load<EntityA>(a.Id);
var resultB = session.Load<EntityB>(b.Id);
Assert.AreEqual(1, session.Advanced.NumberOfRequests);
Assert.NotNull(resultC, "resultC");
Assert.NotNull(resultA, "resultA");
Assert.NotNull(resultB, "resultB - Include");
}
}
}
public void FindMany()
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ec2 = new EntityC();
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
}
using (var em = Emf.CreateEntityManager())
{
{
var _ec = em.FindMany <EntityC>(new[] { ec1.Id, ec2.Id });
Assert.IsNotNull(_ec);
var l = _ec.ToList();
Assert.AreEqual(ec1, l[0]);
Assert.AreEqual(ec2, l[1]);
}
{
var _ec = em.FindMany <EntityC>(new[] { ec1.Id, ec2.Id, ec2.Id, ec1.Id });
Assert.IsNotNull(_ec);
var l = _ec.ToList();
Assert.AreEqual(ec1, l[0]);
Assert.AreEqual(ec2, l[1]);
Assert.AreEqual(ec2, l[2]);
Assert.AreEqual(ec1, l[3]);
}
{
var _ec = em.FindMany <EntityBase>(new[] { ec1.Id, ec2.Id, ec2.Id, ec1.Id });
Assert.IsNotNull(_ec);
var l = _ec.ToList();
Assert.AreEqual(ec1, l[0]);
Assert.AreEqual(ec2, l[1]);
Assert.AreEqual(ec2, l[2]);
Assert.AreEqual(ec1, l[3]);
}
}
}
public void SharedEntities_AccessWrongPropertyReturnsNull()
{
this.EnqueueLoadEntityA();
this.EnqueueCallback(
() =>
{
EntityC c = this.DomainChildContext.EntityAs.First().EntityC;
Assert.IsNull(c);
EntityB b = this.DomainParentContext.EntityAs.First().EntityB;
Assert.IsNull(b);
});
this.EnqueueTestComplete();
}
public void ApplyToFieldWithDifferentAccessModifiers()
{
var cfg = "private=pvt protected=prot public=pub private-prop=pvt2 protected-prop=prot2 public-prop=pub2".AsLaconicConfig();
var obj = new EntityC();
ConfigAttribute.Apply(obj, cfg);
obj.See();
Aver.AreEqual("pvt", obj.Private);
Aver.AreEqual("prot", obj.Protected);
Aver.AreEqual("pub", obj.Public);
Aver.AreEqual("pvt2", obj.GetPrivateProp());
Aver.AreEqual("prot2", obj.GetProtectedProp());
Aver.AreEqual("pub2", obj.PublicProp);
}
public void Fetch()
{
var ec1 = new EntityC {
A = new EntityA(), B = new EntityB(), X = new EntityX(), Y = new EntityY()
};
TestBase.TestSerialization(ec1);
var ec2 = new EntityC {
A = new EntityA(), B = new EntityB(), X = new EntityX(), Y = new EntityY()
};
TestBase.TestSerialization(ec2);
var ex1 = new EntityX();
TestBase.TestSerialization(ex1);
var ex2 = new EntityX();
TestBase.TestSerialization(ex2);
var ex21 = new EntityX2();
TestBase.TestSerialization(ex21);
var ex22 = new EntityX2();
TestBase.TestSerialization(ex22);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
em.Persist(ec2);
em.Persist(ex1);
em.Persist(ex2);
em.Persist(ex21);
em.Persist(ex22);
}
using (var em = Emf.CreateEntityManager())
{
{
var _ec = em.Fetch <EntityC>();
Assert.IsNotNull(_ec);
ISet <EntityC> s = new HashSet <EntityC>(_ec.ToList());
Assert.AreEqual(2, s.Count);
Assert.IsTrue(s.Contains(ec1));
Assert.IsTrue(s.Contains(ec2));
}
{
var _ec = em.Fetch <EntityBase>(new[] { typeof(EntityC) });
Assert.IsNotNull(_ec);
ISet <EntityBase> s = new HashSet <EntityBase>(_ec.ToList());
Assert.AreEqual(2, s.Count);
Assert.IsTrue(s.Contains(ec1));
Assert.IsTrue(s.Contains(ec2));
}
Assert.AreEqual(2, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
Assert.AreEqual(2, em.Fetch <EntityC>().Count());
Assert.AreEqual(4, em.Fetch <EntityX>().Count());
Assert.AreEqual(2, em.Fetch <EntityX2>().Count());
Assert.AreEqual(6, em.Fetch <EntityXBase>().Count());
Assert.AreEqual(2, em.Fetch <EntityY>().Count());
Assert.AreEqual(10, em.Fetch <EntityBase>().Count());
Assert.AreEqual(6, em.Fetch <EntityBase>(new[] { typeof(EntityX), typeof(EntityX2) }).Count());
Assert.AreEqual(2, em.Fetch <EntityBase>(new[] { typeof(EntityY) }).Count());
// pre-fetch
// TODOAssert.AreEqual(2, em.Fetch<EntityC>(new[] { typeof(EntityC), typeof(EntityX), typeof(EntityY) }).Count());
}
}
public void PersistAndFind()
{
var bindings = Emf.Configuration.Binding;
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA()));
Assert.IsFalse(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA()));
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityB), new KeyBindingEntityB()));
{
var cb = new ColumnBinding("e");
Assert.IsTrue(bindings.RegisterColumnBinding(typeof(EntityC), cb));
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityC), new KeyBinding<EntityC>(e => e.Name)));
}
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB { A = new EntityA() };
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsNotNull(eb1.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier));
Assert.IsTrue(eb1.Key.Row.StartsWith(typeof(EntityB).Name));
em.Persist(eb2);
Assert.IsNotNull(eb2.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier));
Assert.IsTrue(eb2.Key.Row.StartsWith(typeof(EntityB).Name));
Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
Assert.IsTrue(_eb1.Key.Row.StartsWith(_eb1.GetType().Name));
var _ea2 = em.Find<EntityA>(eb2.A.Name); // EntityA key binding uses the Name property as row key
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find<EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
Assert.IsTrue(_eb2.Key.Row.StartsWith(typeof(EntityB).Name));
Assert.AreEqual(eb2.A.Name, _eb2.A.Name);
Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name));
}
var ec1 = new EntityC { Name = "11", A = new EntityA() };
TestBase.TestSerialization(ec1);
var ec2 = new EntityC { Name = "222", A = new EntityA(), B = new EntityB() };
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.AreEqual(ec1.Id, ec1.Name);
em.Persist(ec2);
Assert.AreEqual(ec2.Id, ec2.Name);
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find<EntityC>("11");
Assert.AreEqual(ec1, _ec1);
var _ec2 = em.Find<EntityC>(ec2);
Assert.AreEqual(ec2, _ec2);
}
bindings.UnregisterBinding(typeof(EntityA));
bindings.UnregisterBinding(typeof(EntityB));
bindings.UnregisterBinding(typeof(EntityC));
}
public void PersistAndFind()
{
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ey = new EntityY();
var ec2 = new EntityC {
X = new[] { new EntityX(), new EntityX() }, Y = new[] { ey, ey }, Y2 = ey
};
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
var _ec2 = em.Find <EntityC>(ec2.Id);
Assert.AreEqual(ec2, _ec2);
Assert.AreSame(_ec2.Y[0], _ec2.Y[1]);
Assert.AreSame(_ec2.Y2, _ec2.Y[0]);
}
}
{
var ed1 = new EntityD();
TestBase.TestSerialization(ed1);
var ey = new EntityY();
var ed2 = new EntityD {
X = new HashSet <EntityX>(new[] { new EntityX(), new EntityX() }), Y = new HashSet <EntityY>(new[] { ey, new EntityY() }), Y2 = ey
};
TestBase.TestSerialization(ed2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ed1);
Assert.IsFalse(string.IsNullOrEmpty(ed1.Id));
em.Persist(ed2);
Assert.IsFalse(string.IsNullOrEmpty(ed2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ed1 = em.Find <EntityD>(ed1.Id);
Assert.AreEqual(ed1, _ed1);
var _ed2 = em.Find <EntityD>(ed2.Id);
Assert.AreEqual(ed2, _ed2);
Assert.IsNotNull(_ed2.Y.FirstOrDefault(item => object.ReferenceEquals(item, _ed2.Y2)));
}
}
{
var ee1 = new EntityE();
TestBase.TestSerialization(ee1);
var ey = new EntityY();
var ee2 = new EntityE {
X = new List <EntityX>(new[] { new EntityX(), new EntityX() }), Y = new List <EntityY>(new[] { ey, ey }), Y2 = ey
};
TestBase.TestSerialization(ee2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ee1);
Assert.IsFalse(string.IsNullOrEmpty(ee1.Id));
em.Persist(ee2);
Assert.IsFalse(string.IsNullOrEmpty(ee2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ee1 = em.Find <EntityE>(ee1.Id);
Assert.AreEqual(ee1, _ee1);
var _ee2 = em.Find <EntityE>(ee2.Id);
Assert.AreEqual(ee2, _ee2);
Assert.AreSame(_ee2.Y[0], _ee2.Y[1]);
Assert.AreSame(_ee2.Y2, _ee2.Y[0]);
}
}
{
var ef1 = new EntityF();
TestBase.TestSerialization(ef1);
var ey = new EntityY();
var ef2 = new EntityF {
X = new ArrayList(new[] { new EntityX(), new EntityX() }), Y = new ArrayList(new[] { ey, ey }), Y2 = ey
};
TestBase.TestSerialization(ef2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ef1);
Assert.IsFalse(string.IsNullOrEmpty(ef1.Id));
em.Persist(ef2);
Assert.IsFalse(string.IsNullOrEmpty(ef2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ef1 = em.Find <EntityF>(ef1.Id);
Assert.AreEqual(ef1, _ef1);
var _ef2 = em.Find <EntityF>(ef2.Id);
Assert.AreEqual(ef2, _ef2);
Assert.AreSame(_ef2.Y[0], _ef2.Y[1]);
Assert.AreSame(_ef2.Y2, _ef2.Y[0]);
}
}
}
public void PersistAndFind()
{
var bindings = Emf.Configuration.Binding;
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA()));
Assert.IsFalse(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA()));
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityB), new KeyBindingEntityB()));
{
var cb = new ColumnBinding("e");
Assert.IsTrue(bindings.RegisterColumnBinding(typeof(EntityC), cb));
Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityC), new KeyBinding <EntityC>(e => e.Name)));
}
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = new EntityA()
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsNotNull(eb1.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier));
Assert.IsTrue(eb1.Key.Row.StartsWith(typeof(EntityB).Name));
em.Persist(eb2);
Assert.IsNotNull(eb2.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier));
Assert.IsTrue(eb2.Key.Row.StartsWith(typeof(EntityB).Name));
Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
Assert.IsTrue(_eb1.Key.Row.StartsWith(_eb1.GetType().Name));
var _ea2 = em.Find <EntityA>(eb2.A.Name); // EntityA key binding uses the Name property as row key
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
Assert.IsTrue(_eb2.Key.Row.StartsWith(typeof(EntityB).Name));
Assert.AreEqual(eb2.A.Name, _eb2.A.Name);
Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name));
}
var ec1 = new EntityC {
Name = "11", A = new EntityA()
};
TestBase.TestSerialization(ec1);
var ec2 = new EntityC {
Name = "222", A = new EntityA(), B = new EntityB()
};
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.AreEqual(ec1.Id, ec1.Name);
em.Persist(ec2);
Assert.AreEqual(ec2.Id, ec2.Name);
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC>("11");
Assert.AreEqual(ec1, _ec1);
var _ec2 = em.Find <EntityC>(ec2);
Assert.AreEqual(ec2, _ec2);
}
bindings.UnregisterBinding(typeof(EntityA));
bindings.UnregisterBinding(typeof(EntityB));
bindings.UnregisterBinding(typeof(EntityC));
}
public void PersistAndFind()
{
{
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB();
eb2.A = new EntityA(eb2);
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
em.Persist(eb2);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find <EntityA>(eb2.A.Id);
Assert.AreEqual(eb2.A, _ea2);
Assert.AreEqual(eb2, _ea2.OwnerB);
Assert.AreSame(_ea2, _ea2.OwnerB.A);
var _eb2 = em.Find <EntityB>(eb2.Id);
Assert.AreEqual(eb2, _eb2);
Assert.AreSame(_eb2, _eb2.A.OwnerB);
}
}
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ec2 = new EntityC();
ec2.I.A = new EntityA(ec2);
TestBase.TestSerialization(ec2);
var ec3 = new EntityC {
I = { A = new EntityA(ec1) }
};
TestBase.TestSerialization(ec3);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
em.Persist(ec3);
Assert.IsFalse(string.IsNullOrEmpty(ec3.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
var _ea2 = em.Find <EntityA>(ec2.I.A.Id);
Assert.AreEqual(ec2.I.A, _ea2);
Assert.AreEqual(ec2, _ea2.OwnerC);
Assert.AreSame(_ea2, _ea2.OwnerC.I.A);
var _ec2 = em.Find <EntityC>(ec2.Id);
Assert.AreEqual(ec2, _ec2);
Assert.AreSame(_ec2, _ec2.I.A.OwnerC);
var _ea3 = em.Find <EntityA>(ec3.I.A.Id);
Assert.AreEqual(ec3.I.A, _ea3);
Assert.AreEqual(ec1, _ea3.OwnerC);
Assert.IsNull(_ea3.OwnerC.I.A);
var _ec3 = em.Find <EntityC>(ec3.Id);
Assert.AreEqual(ec3, _ec3);
Assert.AreEqual(_ec1, _ec3.I.A.OwnerC);
}
}
{
var ed1 = new EntityD();
TestBase.TestSerialization(ed1);
var ed2 = new EntityD();
ed2.I1.A = new EntityA(ed2);
TestBase.TestSerialization(ed2);
var ed3 = new EntityD {
I2 = { A = new EntityA(ed1) }
};
TestBase.TestSerialization(ed3);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ed1);
Assert.IsFalse(string.IsNullOrEmpty(ed1.Id));
em.Persist(ed2);
Assert.IsFalse(string.IsNullOrEmpty(ed2.Id));
em.Persist(ed3);
Assert.IsFalse(string.IsNullOrEmpty(ed3.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ed1 = em.Find <EntityD>(ed1.Id);
Assert.AreEqual(ed1, _ed1);
Assert.AreSame(_ed1.I1, _ed1.I2);
var _ea2 = em.Find <EntityA>(ed2.I1.A.Id);
Assert.AreEqual(ed2.I1.A, _ea2);
Assert.AreEqual(ed2, _ea2.OwnerD);
Assert.AreSame(_ea2.OwnerD.I2, _ea2.OwnerD.I2);
Assert.AreSame(_ea2, _ea2.OwnerD.I1.A);
var _ed2 = em.Find <EntityD>(ed2.Id);
Assert.AreEqual(ed2, _ed2);
Assert.AreSame(_ed2, _ed2.I1.A.OwnerD);
Assert.AreSame(_ed2.I1, _ed2.I2);
var _ea3 = em.Find <EntityA>(ed3.I1.A.Id);
Assert.AreEqual(ed3.I1.A, _ea3);
Assert.AreEqual(ed1, _ea3.OwnerD);
Assert.IsNull(_ea3.OwnerD.I1.A);
Assert.AreSame(_ea3.OwnerD.I1, _ea3.OwnerD.I2);
var _ed3 = em.Find <EntityD>(ed3.Id);
Assert.AreEqual(ed3, _ed3);
Assert.AreEqual(_ed1, _ed3.I1.A.OwnerD);
Assert.AreSame(_ed1.I1, _ed1.I2);
}
}
}
public EntityA(EntityC owner)
{
this.OwnerC = owner;
this.Name = Guid.NewGuid().ToString();
}
public void PersistAndFind()
{
{
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB();
eb2.A = new EntityA(eb2);
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
em.Persist(eb2);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find<EntityA>(eb2.A.Id);
Assert.AreEqual(eb2.A, _ea2);
Assert.AreEqual(eb2, _ea2.OwnerB);
Assert.AreSame(_ea2, _ea2.OwnerB.A);
var _eb2 = em.Find<EntityB>(eb2.Id);
Assert.AreEqual(eb2, _eb2);
Assert.AreSame(_eb2, _eb2.A.OwnerB);
}
}
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ec2 = new EntityC();
ec2.I.A = new EntityA(ec2);
TestBase.TestSerialization(ec2);
var ec3 = new EntityC { I = { A = new EntityA(ec1) } };
TestBase.TestSerialization(ec3);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
em.Persist(ec3);
Assert.IsFalse(string.IsNullOrEmpty(ec3.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find<EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
var _ea2 = em.Find<EntityA>(ec2.I.A.Id);
Assert.AreEqual(ec2.I.A, _ea2);
Assert.AreEqual(ec2, _ea2.OwnerC);
Assert.AreSame(_ea2, _ea2.OwnerC.I.A);
var _ec2 = em.Find<EntityC>(ec2.Id);
Assert.AreEqual(ec2, _ec2);
Assert.AreSame(_ec2, _ec2.I.A.OwnerC);
var _ea3 = em.Find<EntityA>(ec3.I.A.Id);
Assert.AreEqual(ec3.I.A, _ea3);
Assert.AreEqual(ec1, _ea3.OwnerC);
Assert.IsNull(_ea3.OwnerC.I.A);
var _ec3 = em.Find<EntityC>(ec3.Id);
Assert.AreEqual(ec3, _ec3);
Assert.AreEqual(_ec1, _ec3.I.A.OwnerC);
}
}
{
var ed1 = new EntityD();
TestBase.TestSerialization(ed1);
var ed2 = new EntityD();
ed2.I1.A = new EntityA(ed2);
TestBase.TestSerialization(ed2);
var ed3 = new EntityD { I2 = { A = new EntityA(ed1) } };
TestBase.TestSerialization(ed3);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ed1);
Assert.IsFalse(string.IsNullOrEmpty(ed1.Id));
em.Persist(ed2);
Assert.IsFalse(string.IsNullOrEmpty(ed2.Id));
em.Persist(ed3);
Assert.IsFalse(string.IsNullOrEmpty(ed3.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ed1 = em.Find<EntityD>(ed1.Id);
Assert.AreEqual(ed1, _ed1);
Assert.AreSame(_ed1.I1, _ed1.I2);
var _ea2 = em.Find<EntityA>(ed2.I1.A.Id);
Assert.AreEqual(ed2.I1.A, _ea2);
Assert.AreEqual(ed2, _ea2.OwnerD);
Assert.AreSame(_ea2.OwnerD.I2, _ea2.OwnerD.I2);
Assert.AreSame(_ea2, _ea2.OwnerD.I1.A);
var _ed2 = em.Find<EntityD>(ed2.Id);
Assert.AreEqual(ed2, _ed2);
Assert.AreSame(_ed2, _ed2.I1.A.OwnerD);
Assert.AreSame(_ed2.I1, _ed2.I2);
var _ea3 = em.Find<EntityA>(ed3.I1.A.Id);
Assert.AreEqual(ed3.I1.A, _ea3);
Assert.AreEqual(ed1, _ea3.OwnerD);
Assert.IsNull(_ea3.OwnerD.I1.A);
Assert.AreSame(_ea3.OwnerD.I1, _ea3.OwnerD.I2);
var _ed3 = em.Find<EntityD>(ed3.Id);
Assert.AreEqual(ed3, _ed3);
Assert.AreEqual(_ed1, _ed3.I1.A.OwnerD);
Assert.AreSame(_ed1.I1, _ed1.I2);
}
}
}
public void PersistAndFind()
{
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = new EntityA()
};
TestBase.TestSerialization(eb2);
var ec1 = new EntityC {
A = new EntityA()
};
TestBase.TestSerialization(ec1);
var dateTime = DateTime.UtcNow - TimeSpan.FromMilliseconds(250);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.AreEqual(0, eb1.LastModified.Ticks);
em.Persist(eb2);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Id));
Assert.IsFalse(eb2.A.Id.Equals(Guid.Empty));
Assert.AreEqual(0, eb2.LastModified.Ticks);
Assert.AreEqual(0, eb2.A.LastModified.Ticks);
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
Assert.IsFalse(ec1.A.Id.Equals(Guid.Empty));
Assert.AreEqual(0, ec1.LastModified.Ticks);
Assert.AreEqual(0, ec1.A.LastModified.Ticks);
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
Assert.IsTrue(_eb1.LastModified > dateTime);
var _ea2 = em.Find <EntityA>(eb2.A.Id);
Assert.AreEqual(eb2.A, _ea2);
Assert.IsTrue(_ea2.LastModified > dateTime);
var _eb2 = em.Find <EntityB>(eb2.Id);
Assert.AreEqual(eb2, _eb2);
Assert.IsTrue(_eb2.LastModified > dateTime);
Assert.IsTrue(_eb2.A.LastModified > dateTime);
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
Assert.IsTrue(_ec1.LastModified > dateTime);
Assert.IsTrue(_ec1.A.LastModified > dateTime);
var _ea2 = em.Find <EntityA>(ec1.A.Id);
Assert.AreEqual(ec1.A, _ea2);
Assert.IsTrue(_ec1.A.LastModified > dateTime);
}
}
public void PersistAndFind()
{
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ey = new EntityY();
var ec2 = new EntityC { X = new[] { new EntityX(), new EntityX() }, Y = new[] { ey, ey }, Y2 = ey };
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find<EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
var _ec2 = em.Find<EntityC>(ec2.Id);
Assert.AreEqual(ec2, _ec2);
Assert.AreSame(_ec2.Y[0], _ec2.Y[1]);
Assert.AreSame(_ec2.Y2, _ec2.Y[0]);
}
}
{
var ed1 = new EntityD();
TestBase.TestSerialization(ed1);
var ey = new EntityY();
var ed2 = new EntityD { X = new HashSet<EntityX>(new[] { new EntityX(), new EntityX() }), Y = new HashSet<EntityY>(new[] { ey, new EntityY() }), Y2 = ey };
TestBase.TestSerialization(ed2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ed1);
Assert.IsFalse(string.IsNullOrEmpty(ed1.Id));
em.Persist(ed2);
Assert.IsFalse(string.IsNullOrEmpty(ed2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ed1 = em.Find<EntityD>(ed1.Id);
Assert.AreEqual(ed1, _ed1);
var _ed2 = em.Find<EntityD>(ed2.Id);
Assert.AreEqual(ed2, _ed2);
Assert.IsNotNull(_ed2.Y.FirstOrDefault(item => object.ReferenceEquals(item, _ed2.Y2)));
}
}
{
var ee1 = new EntityE();
TestBase.TestSerialization(ee1);
var ey = new EntityY();
var ee2 = new EntityE { X = new List<EntityX>(new[] { new EntityX(), new EntityX() }), Y = new List<EntityY>(new[] { ey, ey }), Y2 = ey };
TestBase.TestSerialization(ee2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ee1);
Assert.IsFalse(string.IsNullOrEmpty(ee1.Id));
em.Persist(ee2);
Assert.IsFalse(string.IsNullOrEmpty(ee2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ee1 = em.Find<EntityE>(ee1.Id);
Assert.AreEqual(ee1, _ee1);
var _ee2 = em.Find<EntityE>(ee2.Id);
Assert.AreEqual(ee2, _ee2);
Assert.AreSame(_ee2.Y[0], _ee2.Y[1]);
Assert.AreSame(_ee2.Y2, _ee2.Y[0]);
}
}
{
var ef1 = new EntityF();
TestBase.TestSerialization(ef1);
var ey = new EntityY();
var ef2 = new EntityF { X = new ArrayList(new[] { new EntityX(), new EntityX() }), Y = new ArrayList(new[] { ey, ey }), Y2 = ey };
TestBase.TestSerialization(ef2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ef1);
Assert.IsFalse(string.IsNullOrEmpty(ef1.Id));
em.Persist(ef2);
Assert.IsFalse(string.IsNullOrEmpty(ef2.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ef1 = em.Find<EntityF>(ef1.Id);
Assert.AreEqual(ef1, _ef1);
var _ef2 = em.Find<EntityF>(ef2.Id);
Assert.AreEqual(ef2, _ef2);
Assert.AreSame(_ef2.Y[0], _ef2.Y[1]);
Assert.AreSame(_ef2.Y2, _ef2.Y[0]);
}
}
}
public void PersistAndFind()
{
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB { A = new EntityA() };
TestBase.TestSerialization(eb2);
var ec1 = new EntityC { A = new EntityA() };
TestBase.TestSerialization(ec1);
var dateTime = DateTime.UtcNow - TimeSpan.FromMilliseconds(250);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.AreEqual(0, eb1.LastModified.Ticks);
em.Persist(eb2);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Id));
Assert.IsFalse(eb2.A.Id.Equals(Guid.Empty));
Assert.AreEqual(0, eb2.LastModified.Ticks);
Assert.AreEqual(0, eb2.A.LastModified.Ticks);
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
Assert.IsFalse(ec1.A.Id.Equals(Guid.Empty));
Assert.AreEqual(0, ec1.LastModified.Ticks);
Assert.AreEqual(0, ec1.A.LastModified.Ticks);
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
Assert.IsTrue(_eb1.LastModified > dateTime);
var _ea2 = em.Find<EntityA>(eb2.A.Id);
Assert.AreEqual(eb2.A, _ea2);
Assert.IsTrue(_ea2.LastModified > dateTime);
var _eb2 = em.Find<EntityB>(eb2.Id);
Assert.AreEqual(eb2, _eb2);
Assert.IsTrue(_eb2.LastModified > dateTime);
Assert.IsTrue(_eb2.A.LastModified > dateTime);
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find<EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
Assert.IsTrue(_ec1.LastModified > dateTime);
Assert.IsTrue(_ec1.A.LastModified > dateTime);
var _ea2 = em.Find<EntityA>(ec1.A.Id);
Assert.AreEqual(ec1.A, _ea2);
Assert.IsTrue(_ec1.A.LastModified > dateTime);
}
}
public void Any()
{
var ec1 = new EntityC {
A = new EntityA(), B = new EntityB(), X = new EntityX(), Y = new EntityY()
};
TestBase.TestSerialization(ec1);
using (var em = Emf.CreateEntityManager())
{
Assert.IsFalse(em.Any <EntityC>());
Assert.IsFalse(em.Any <EntityA>());
Assert.IsFalse(em.Any <EntityB>());
Assert.IsFalse(em.Any <EntityXBase>());
Assert.IsFalse(em.Any <EntityX>());
Assert.IsFalse(em.Any <EntityX2>());
Assert.IsFalse(em.Any <EntityY>());
Assert.IsFalse(em.Any(new[] { typeof(EntityX), typeof(EntityX2) }));
}
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
}
using (var em = Emf.CreateEntityManager())
{
Assert.IsTrue(em.Any <EntityC>());
Assert.IsTrue(em.Any <EntityA>());
Assert.IsTrue(em.Any <EntityB>());
Assert.IsTrue(em.Any <EntityXBase>());
Assert.IsTrue(em.Any <EntityX>());
Assert.IsFalse(em.Any <EntityX2>());
Assert.IsTrue(em.Any <EntityY>());
Assert.IsTrue(em.Any(new[] { typeof(EntityX), typeof(EntityX2) }));
}
var ex21 = new EntityX2();
TestBase.TestSerialization(ex21);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ex21);
em.Flush();
Assert.IsTrue(em.Any <EntityXBase>());
Assert.IsTrue(em.Any <EntityX>());
Assert.IsTrue(em.Any <EntityX2>());
Assert.IsTrue(em.Any(new[] { typeof(EntityX), typeof(EntityX2) }));
em.Remove(ec1.X);
em.Flush();
Assert.IsTrue(em.Any <EntityXBase>());
Assert.IsFalse(em.Any <EntityX>());
Assert.IsTrue(em.Any <EntityX2>());
Assert.IsTrue(em.Any(new[] { typeof(EntityX), typeof(EntityX2) }));
em.Remove(ex21);
em.Flush();
Assert.IsFalse(em.Any <EntityXBase>());
Assert.IsFalse(em.Any <EntityX>());
Assert.IsFalse(em.Any <EntityX2>());
Assert.IsFalse(em.Any(new[] { typeof(EntityX), typeof(EntityX2) }));
}
}
public void PersistChildren()
{
var ec1 = new EntityC();
TestBase.TestSerialization(ec1);
var ec2 = new EntityC { A = new EntityA(), B = new EntityB() };
TestBase.TestSerialization(ec2);
var ec3 = new EntityC { X = new EntityX(), Y = new EntityY() };
TestBase.TestSerialization(ec3);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Id));
em.Persist(ec2);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Id));
Assert.IsFalse(ec2.A.Id.Equals(Guid.Empty));
Assert.IsFalse(ec2.B.Id.Equals(Guid.Empty));
em.Persist(ec3);
Assert.IsFalse(string.IsNullOrEmpty(ec3.Id));
Assert.IsFalse(string.IsNullOrEmpty(ec3.X.Id));
Assert.IsFalse(string.IsNullOrEmpty(ec3.Y.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find<EntityC>(ec1.Id);
Assert.AreEqual(ec1, _ec1);
var _ea2 = em.Find<EntityA>(ec2.A.Id);
Assert.AreEqual(ec2.A, _ea2);
var _eb2 = em.Find<EntityB>(ec2.B.Id);
Assert.AreEqual(ec2.B, _eb2);
var _ec2 = em.Find<EntityC>(ec2.Id);
Assert.AreEqual(ec2, _ec2);
var _ex3 = em.Find<EntityX>(ec3.X.Id);
Assert.AreEqual(ec3.X, _ex3);
var _ey3 = em.Find<EntityY>(ec3.Y.Id);
Assert.AreEqual(ec3.Y, _ey3);
var _ec3 = em.Find<EntityC>(ec3.Id);
Assert.AreEqual(ec3, _ec3);
}
}
public EntityA(EntityC owner)
{
this.OwnerC = owner;
this.Name = Guid.NewGuid().ToString();
}
public void starter()
{
this.unityContainer = new UnityContainer();
ServiceLocator.Initialize(
(x, y) => this.unityContainer.RegisterType(x, y),
(x, y) => this.unityContainer.RegisterInstance(x, y),
(x) => { return(this.unityContainer.Resolve(x)); },
(x) => { return(this.unityContainer.ResolveAll(x)); });
// Context Factory
connString = this.ConnectionString();
RootAggregateFrameworkUnitOfWorkFactory <BootstrapUnitOfWork> ctxFactory = new RootAggregateFrameworkUnitOfWorkFactory <BootstrapUnitOfWork>(connString);
if (!ctxFactory.DatabaseExists())
{
ctxFactory.CreateDatabase();
}
ctxFactory.ValidateDatabaseSchema();
this.unityContainer.RegisterInstance <IDatabaseManager>(ctxFactory);
this.unityContainer.RegisterType <DbContext, BootstrapUnitOfWork>(this.contextPerTestLifeTimeManager, new InjectionConstructor(connString));
this.unityContainer.RegisterType <IUnitOfWork, EntityFrameworkUnitOfWork>(this.unitOfWorkPerTestLifeTimeManager);
// Repositories
this.unityContainer.RegisterType <IEntityARepository, EntityARepository>(new PerResolveLifetimeManager());
this.unityContainer.RegisterType <IEntityBRepository, EntityBRepository>(new PerResolveLifetimeManager());
ApplicationContext.User = new CorePrincipal(new CoreIdentity("cmendible", "hexa.auth", "*****@*****.**"), new string[] { });
// comienzan las operaciones
// añadimos una entidad
// metodo sin factoria y con constructor publico
//var entityA = new EntityA();
// entityA.Name = "Martin";
// metodo con factoria y constructor interno
IEntityA entityA = EntityAFactory.Create("Martin");
entityA.CanBeDeleted();
IEntityARepository repo = this.unityContainer.Resolve <IEntityARepository>();
repo.Add((EntityA)entityA);
this.Commit();
entityA.CanBeDeleted();
// añadimos 2 entidades y su relación
var a = EntityAFactory.Create("Willi");
var b = EntityBFactory.Create("matematicas");
a.AddB(b);
IEntityARepository repoA = this.unityContainer.Resolve <IEntityARepository>();
IEntityBRepository repoB = this.unityContainer.Resolve <IEntityBRepository>();
repoB.Add((EntityB)b);
repoA.Add((EntityA)a);
this.Commit();
//añadimos una entidad c dependiente de entidad a la primera entidad a
EntityA padre = repoA.GetFilteredElements(e => e.Id == 1).FirstOrDefault();
EntityC hijo = EntityCFactory.Create(padre, "hijo");
this.Commit();
padre = repoA.GetFilteredElements(e => e.Id == 1).FirstOrDefault();
padre.CanBeDeleted();
}
