public void ShouldIgnoreMembersIfConfiguredInEntityConfig()
{
var entityA = new EntityA {One = "one", Two = "two"};
var entityB = new EntityB {One = "one", Two = "two"};
dynamic documentA = serializer.ConvertToJson(
entityA,
MockEntityConfig(
mock => mock.Setup(ec => ec.IgnoredMembers).Returns(typeof (EntityA).GetMember("One")),
documentType: "entityA",
entityType: typeof(EntityA)
),
true);
dynamic documentB = serializer.ConvertToJson(
entityB,
MockEntityConfig(
mock => mock.Setup(ec => ec.IgnoredMembers).Returns(typeof (EntityA).GetMember("Two")),
documentType: "entityB",
entityType: typeof(EntityB)
),
true);
Assert.Null(documentA.one);
Assert.Equal("two", documentA.two);
Assert.Equal("one", documentB.one);
Assert.Null(documentB.two);
}
/// <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 EntityB Create(string nombre)
{
// El Id viene dado cuando se inserte en la BBDD... de momento tiene uno temporal.
// Creamos la nueva entidad.
EntityB entityB = new EntityB(nombre);
//devolvemos la entidad recien creada
return entityB;
}
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");
}
}
}
static void Main()
{
IoC.IoC ioc = new IoC.IoC();
ioc.Register();
var mediator = ioc.Container.GetInstance <IMediator>();
Console.WriteLine("--- Communicating from context A to context B. ---");
EntityA entityA = new EntityA(mediator);
Console.WriteLine(entityA.MethodA().Result);
Console.WriteLine();
Console.WriteLine("--- Communicating from context B to context A. ---");
EntityB entityB = new EntityB(mediator);
Console.WriteLine(entityB.MethodB().Result);
Console.ReadKey();
}
public bool UpdateEntity(IEntityB entityB)
{
EntityB original = (EntityB)RepositoryDbContext.EntitiesB.Find(entityB.Id);
try
{
if (original != null)
{
original.Username = entityB.Username;
original.Email = entityB.Email;
return(true);
}
}
catch (Exception exception)
{
throw new DbUpdateException(GetType().FullName + " - " + MethodBase.GetCurrentMethod().Name, exception);
}
return(false);
}
static EntityB()
{
Encoder.Register(
101,
typeof(EntityB),
(serializer, any) =>
{
var e = (EntityB)any;
serializer.WriteObject(e.A);
serializer.WriteObject(e.B);
serializer.WriteObject(e.C);
},
(deserializer) =>
{
var eb = new EntityB();
deserializer.ReadObject <EntityA>(value => { eb.A = value; });
deserializer.ReadObject <EntityA>(value => { eb.B = value; });
deserializer.ReadObject <EntityA>(value => { eb.C = value; });
return(eb);
});
}
private EntityA Create_EntityA_EntityB_And_Many_To_Many_Relation()
{
using (IUnitOfWork unitOfWork = UnitOfWork.Start())
{
var a = new EntityA();
a.Name = "A";
var b = new EntityB();
b.Name = "B";
a.AddB(b);
var repoA = this.unityContainer.Resolve <IEntityARepository>();
var repoB = this.unityContainer.Resolve <IEntityBRepository>();
repoB.Add(b);
repoA.Add(a);
unitOfWork.Commit();
return(a);
}
}
//bool Delete(Int32 Entity1Id, UserContextDto userContextDto);// invocacion con identificación de usuario
public bool Delete(Int32 EntityBId)
{
#region Preconditions
// Comprobar el DTO de entrada.
if (EntityBId == default(int))
{
return(false);
}
#endregion
IEntityBRepository repo = this.unityContainer.Resolve <IEntityBRepository>();
IEnumerable <EntityB> results = repo.GetFilteredElements(u => u.Id == EntityBId);
EntityB entityB2Delete = results.First();
if (!entityB2Delete.CanBeDeleted())
{
return(false);
}
repo.Remove(entityB2Delete);
this.Commit();
return(true);
}
public override void Seed()
{
for (int i = 1; i <= 5; i++)
{
EntityASet.Add(new EntityA
{
ID = i,
Children = new List <EntityAChild>
{
new EntityAChild {
ID = i
}
}
});
var entityB = new EntityB {
ID = i
};
if (i <= 2)
{
entityB.Children = new List <EntityBChild>()
{
new EntityBChild {
ID = i * 10 + 1
}
}
}
;
EntityBSet.Add(entityB);
EntityCSet.Add(new EntityC {
ID = i, Children = new List <EntityCChild>()
{
new EntityCChild {
ID = i
}
}
});
EntityESet.Add(new EntityE {
ID = i, Children = new List <EntityEChild>()
{
new EntityEChild {
ID = i
}
}
});
}
EntityDSet.Add(new EntityD
{
ID = 1,
Children = new List <EntityDChild>
{
new EntityDChild {
ID = 1, ChildValue = 1
},
new EntityDChild {
ID = 2, ChildValue = 2
},
new EntityDChild {
ID = 3, ChildValue = 1
},
new EntityDChild {
ID = 4, ChildValue = 3
},
new EntityDChild {
ID = 5, ChildValue = 4
},
}
});
EntityDSet.Add(new EntityD
{
ID = 2,
Children = new List <EntityDChild>
{
new EntityDChild {
ID = 6, ChildValue = 1
},
new EntityDChild {
ID = 7, ChildValue = 3
},
new EntityDChild {
ID = 8, ChildValue = 1
},
}
});
EntityFSet.Add(new EntityF
{
ID = 1,
Children = new List <EntityFChild>
{
new EntityFChild {
ID = 1, ChildValue = 1
},
new EntityFChild {
ID = 2, ChildValue = 1
},
new EntityFChild {
ID = 3, ChildValue = 3
},
new EntityFChild {
ID = 4, ChildValue = 4
},
}
});
EntityFSet.Add(new EntityF
{
ID = 2,
Children = new List <EntityFChild>
{
new EntityFChild {
ID = 5, ChildValue = 1
},
new EntityFChild {
ID = 6, ChildValue = 2
},
new EntityFChild {
ID = 7, ChildValue = 3
},
}
});
EntityGSet.Add(new EntityG
{
ID = 1,
IsDeleted = false,
HEntities = new HashSet <EntityH>
{
new EntityH {
ID = 1, IsDeleted = false
},
new EntityH {
ID = 2, IsDeleted = true
},
}
});
EntityGSet.Add(new EntityG
{
ID = 2,
IsDeleted = true,
HEntities = new HashSet <EntityH>
{
new EntityH {
ID = 3, IsDeleted = false
},
new EntityH {
ID = 4, IsDeleted = true
},
}
});
SaveChanges();
}
}
public void PersistBehaviors()
{
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB { A = ea1 };
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ea1);
em.Persist(eb1);
em.Persist(eb2);
}
using (var em = Emf.CreateEntityManager())
{
Assert.AreEqual(1, em.Fetch<EntityA>().Count());
Assert.AreEqual(2, em.Fetch<EntityB>().Count());
var _ea1 = em.Find<EntityA>(ea1.RowKey);
Assert.AreEqual(ea1, _ea1);
var _eb1 = em.Find<EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _eb2 = em.Find<EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
var _ea2 = em.Find<EntityA>(eb2.A.RowKey);
Assert.AreEqual(ea1, _ea2);
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
em.Persist(ea1);
}
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
em.Persist(eb2);
}
using (var em = Emf.CreateEntityManager())
{
Assert.AreEqual(2, em.Fetch<EntityA>().Count());
Assert.AreEqual(2, em.Fetch<EntityB>().Count());
var _ea1 = em.Find<EntityA>(ea1.RowKey);
Assert.AreEqual(ea1, _ea1);
var _eb1 = em.Find<EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _eb2 = em.Find<EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
var _ea2 = em.Find<EntityA>(eb2.A.RowKey);
Assert.AreEqual(eb2.A, _ea2);
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet<string>();
var idb = new HashSet<string>();
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch<EntityA>().Count());
Assert.AreEqual(2, em.Fetch<EntityB>().Count());
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet<string>();
var idb = new HashSet<string>();
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(4, ida.Count);
Assert.AreEqual(4, idb.Count);
em.Flush();
Assert.AreEqual(4, em.Fetch<EntityA>().Count());
Assert.AreEqual(4, em.Fetch<EntityB>().Count());
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet<string>();
var idb = new HashSet<string>();
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch<EntityA>().Count());
Assert.AreEqual(2, em.Fetch<EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB { A = ea1 };
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet<string>();
var idb = new HashSet<string>();
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch<EntityA>().Count());
Assert.AreEqual(2, em.Fetch<EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB { A = ea1 };
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet<string>();
var idb = new HashSet<string>();
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(4, ida.Count);
Assert.AreEqual(4, idb.Count);
em.Flush();
Assert.AreEqual(4, em.Fetch<EntityA>().Count());
Assert.AreEqual(4, em.Fetch<EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB { A = ea1 };
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet<string>();
var idb = new HashSet<string>();
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch<EntityA>().Count());
Assert.AreEqual(2, em.Fetch<EntityB>().Count());
}
}
}
public void PersistAndFind()
{
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));
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.IsFalse(string.IsNullOrEmpty(eb2.A.RowKey));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find<EntityA>(eb2.A.RowKey);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find<EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
}
var ec1 = new EntityC1();
var ec2 = new EntityC2 { C1 = new EntityC1() };
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsNotNull(ec1.Key);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.ColumnFamily));
Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.ColumnQualifier));
em.Persist(ec2);
Assert.IsNotNull(ec2.Key);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.ColumnFamily));
Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.ColumnQualifier));
Assert.IsNotNull(ec2.C1);
Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.ColumnFamily));
Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.ColumnQualifier));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find<EntityC1>(ec1.Key);
Assert.AreEqual(ec1, _ec1);
var _ec12 = em.Find<EntityC1>(ec2.C1.Key);
Assert.AreEqual(ec2.C1, _ec12);
var _ec2 = em.Find<EntityC2>(ec2.Key);
Assert.AreEqual(ec2, _ec2);
}
}
public void PersistBehaviors()
{
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = ea1
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ea1);
em.Persist(eb1);
em.Persist(eb2);
}
using (var em = Emf.CreateEntityManager())
{
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
var _ea1 = em.Find <EntityA>(ea1.RowKey);
Assert.AreEqual(ea1, _ea1);
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
var _ea2 = em.Find <EntityA>(eb2.A.RowKey);
Assert.AreEqual(ea1, _ea2);
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
em.Persist(ea1);
}
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
em.Persist(eb2);
}
using (var em = Emf.CreateEntityManager())
{
Assert.AreEqual(2, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
var _ea1 = em.Find <EntityA>(ea1.RowKey);
Assert.AreEqual(ea1, _ea1);
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
var _ea2 = em.Find <EntityA>(eb2.A.RowKey);
Assert.AreEqual(eb2.A, _ea2);
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(4, ida.Count);
Assert.AreEqual(4, idb.Count);
em.Flush();
Assert.AreEqual(4, em.Fetch <EntityA>().Count());
Assert.AreEqual(4, em.Fetch <EntityB>().Count());
}
TestBase.ClearNamespace();
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = ea1
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateLazy);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateLazy);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateLazy);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = ea1
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateAlways);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateAlways);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateAlways);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(4, ida.Count);
Assert.AreEqual(4, idb.Count);
em.Flush();
Assert.AreEqual(4, em.Fetch <EntityA>().Count());
Assert.AreEqual(4, em.Fetch <EntityB>().Count());
}
}
TestBase.ClearNamespace();
{
var ea1 = new EntityA();
TestBase.TestSerialization(ea1);
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = ea1
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
var ida = new HashSet <string>();
var idb = new HashSet <string>();
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
em.Persist(ea1, Behaviors.CreateNew);
ida.Add(ea1.RowKey);
em.Persist(eb1, Behaviors.CreateNew);
idb.Add(eb1.Key.Row);
em.Persist(eb2, Behaviors.CreateNew);
idb.Add(eb2.Key.Row);
ida.Add(eb2.A.RowKey);
Assert.AreEqual(1, ida.Count);
Assert.AreEqual(2, idb.Count);
em.Flush();
Assert.AreEqual(1, em.Fetch <EntityA>().Count());
Assert.AreEqual(2, em.Fetch <EntityB>().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));
}
static EntityB()
{
Encoder.Register(
101,
typeof(EntityB),
(serializer, any) =>
{
var e = (EntityB)any;
serializer.WriteObject(e.A);
serializer.WriteObject(e.B);
serializer.WriteObject(e.C);
},
(deserializer) =>
{
var eb = new EntityB();
deserializer.ReadObject<EntityA>(value => { eb.A = value; });
deserializer.ReadObject<EntityA>(value => { eb.B = value; });
deserializer.ReadObject<EntityA>(value => { eb.C = value; });
return eb;
});
}
private EntityA Create_EntityA_EntityB_And_Many_To_Many_Relation()
{
using (IUnitOfWork unitOfWork = UnitOfWork.Start())
{
var a = new EntityA();
a.Name = "A";
var b = new EntityB();
b.Name = "B";
a.AddB(b);
var repoA = this.unityContainer.Resolve<IEntityARepository>();
var repoB = this.unityContainer.Resolve<IEntityBRepository>();
repoB.Add(b);
repoA.Add(a);
unitOfWork.Commit();
return a;
}
}
public EntityA(EntityB owner)
{
this.OwnerB = 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 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 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.IsFalse(string.IsNullOrEmpty(eb1.RowKey));
em.Persist(eb2);
Assert.IsFalse(string.IsNullOrEmpty(eb2.RowKey));
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.RowKey);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find<EntityA>(eb2.A.Id);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find<EntityB>(eb2.RowKey);
Assert.AreEqual(eb2, _eb2);
}
}
public void PersistAndFind()
{
var bindingContext = new BindingContext();
Assert.IsFalse(bindingContext.StrictExplicitColumnBinding);
Assert.IsFalse(bindingContext.StrictExplicitKeyBinding);
Assert.IsFalse(bindingContext.StrictExplicitTableBinding);
bindingContext.StrictExplicitColumnBinding = true;
Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityA), new ColumnBindingEntityA()));
Assert.IsFalse(bindingContext.RegisterColumnBinding(typeof(EntityA), new ColumnBindingEntityA()));
Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityB), new ColumnBinding("b", "qb")));
Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityC1), new ColumnBinding("c", "1")));
Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityC2), new ColumnBinding("c", "2")));
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = new EntityA()
};
TestBase.TestSerialization(eb2);
var ec1 = new EntityC1 {
A = new EntityA()
};
TestBase.TestSerialization(ec1);
var ec2 = new EntityC2 {
A = new EntityA()
};
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager(bindingContext))
{
Assert.IsTrue(em.IsTypeDeclared <EntityA>());
Assert.IsTrue(em.IsTypeDeclared <EntityB>());
Assert.IsTrue(em.IsTypeDeclared <EntityC1>());
Assert.IsTrue(em.IsTypeDeclared <EntityC2>());
em.Configuration.Binding.StrictExplicitColumnBinding = true;
em.Persist(eb1);
Assert.IsNotNull(eb1.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row));
Assert.AreEqual("b", eb1.Key.ColumnFamily);
Assert.AreEqual("qb", eb1.Key.ColumnQualifier);
em.Persist(eb2);
Assert.IsNotNull(eb2.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row));
Assert.AreEqual("b", eb2.Key.ColumnFamily);
Assert.AreEqual("qb", eb2.Key.ColumnQualifier);
Assert.IsNotNull(eb2.A.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row));
Assert.AreEqual("a", eb2.A.Key.ColumnFamily);
Assert.AreEqual("qa", eb2.A.Key.ColumnQualifier);
em.Persist(ec1);
Assert.IsNotNull(ec1.Key);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.Row));
Assert.AreEqual("c", ec1.Key.ColumnFamily);
Assert.AreEqual("1", ec1.Key.ColumnQualifier);
em.Persist(ec2);
Assert.IsNotNull(ec2.Key);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.Row));
Assert.AreEqual("c", ec2.Key.ColumnFamily);
Assert.AreEqual("2", ec2.Key.ColumnQualifier);
}
using (var em = Emf.CreateEntityManager(bindingContext))
{
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find <EntityA>(eb2.A.Key);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
var _ec1 = em.Find <EntityC1>(ec1.Key);
Assert.AreEqual(ec1, _ec1);
var _ec2 = em.Find <EntityC2>(ec2.Key);
Assert.AreEqual(ec2, _ec2);
var ecl = em.Fetch <EntityC>().ToList();
Assert.AreEqual(2, ecl.Count);
Assert.IsTrue(ecl.Contains(_ec1));
Assert.IsTrue(ecl.Contains(_ec2));
}
Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityA)));
Assert.IsFalse(bindingContext.UnregisterColumnBinding(typeof(EntityA)));
Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityB)));
Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityC1)));
Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityC2)));
}
public void PersistAndFind()
{
var bindingContext = new BindingContext();
Assert.IsFalse(bindingContext.StrictExplicitColumnBinding);
Assert.IsFalse(bindingContext.StrictExplicitKeyBinding);
Assert.IsFalse(bindingContext.StrictExplicitTableBinding);
bindingContext.StrictExplicitColumnBinding = true;
Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityA), new ColumnBindingEntityA()));
Assert.IsFalse(bindingContext.RegisterColumnBinding(typeof(EntityA), new ColumnBindingEntityA()));
Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityB), new ColumnBinding("b", "qb")));
Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityC1), new ColumnBinding("c", "1")));
Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityC2), new ColumnBinding("c", "2")));
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB { A = new EntityA() };
TestBase.TestSerialization(eb2);
var ec1 = new EntityC1 { A = new EntityA() };
TestBase.TestSerialization(ec1);
var ec2 = new EntityC2 { A = new EntityA() };
TestBase.TestSerialization(ec2);
using (var em = Emf.CreateEntityManager(bindingContext))
{
Assert.IsTrue(em.IsTypeDeclared<EntityA>());
Assert.IsTrue(em.IsTypeDeclared<EntityB>());
Assert.IsTrue(em.IsTypeDeclared<EntityC1>());
Assert.IsTrue(em.IsTypeDeclared<EntityC2>());
em.Configuration.Binding.StrictExplicitColumnBinding = true;
em.Persist(eb1);
Assert.IsNotNull(eb1.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row));
Assert.AreEqual("b", eb1.Key.ColumnFamily);
Assert.AreEqual("qb", eb1.Key.ColumnQualifier);
em.Persist(eb2);
Assert.IsNotNull(eb2.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row));
Assert.AreEqual("b", eb2.Key.ColumnFamily);
Assert.AreEqual("qb", eb2.Key.ColumnQualifier);
Assert.IsNotNull(eb2.A.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row));
Assert.AreEqual("a", eb2.A.Key.ColumnFamily);
Assert.AreEqual("qa", eb2.A.Key.ColumnQualifier);
em.Persist(ec1);
Assert.IsNotNull(ec1.Key);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.Row));
Assert.AreEqual("c", ec1.Key.ColumnFamily);
Assert.AreEqual("1", ec1.Key.ColumnQualifier);
em.Persist(ec2);
Assert.IsNotNull(ec2.Key);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.Row));
Assert.AreEqual("c", ec2.Key.ColumnFamily);
Assert.AreEqual("2", ec2.Key.ColumnQualifier);
}
using (var em = Emf.CreateEntityManager(bindingContext))
{
var _eb1 = em.Find<EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find<EntityA>(eb2.A.Key);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find<EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
var _ec1 = em.Find<EntityC1>(ec1.Key);
Assert.AreEqual(ec1, _ec1);
var _ec2 = em.Find<EntityC2>(ec2.Key);
Assert.AreEqual(ec2, _ec2);
var ecl = em.Fetch<EntityC>().ToList();
Assert.AreEqual(2, ecl.Count);
Assert.IsTrue(ecl.Contains(_ec1));
Assert.IsTrue(ecl.Contains(_ec2));
}
Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityA)));
Assert.IsFalse(bindingContext.UnregisterColumnBinding(typeof(EntityA)));
Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityB)));
Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityC1)));
Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityC2)));
}
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 EntityHandlerA(EntityB eb, TaskEntityB teb)
{
_entityB = ea;
_taskEntityB = teb;
}
public void PersistAndFind()
{
var bindings = Emf.Configuration.Binding;
Assert.IsFalse(bindings.StrictExplicitColumnBinding);
Assert.IsFalse(bindings.StrictExplicitKeyBinding);
Assert.IsFalse(bindings.StrictExplicitTableBinding);
Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA()));
Assert.IsFalse(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA()));
Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityB), new TableBindingEntityB()));
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB {
A = new EntityA()
};
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
Assert.IsTrue(em.IsTypeDeclared <EntityA>());
Assert.IsTrue(em.IsTypeDeclared <EntityB>());
em.Configuration.Binding.StrictExplicitTableBinding = true;
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));
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.IsNotNull(eb2.A.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb2.A.Key.ColumnQualifier));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find <EntityA>(eb2.A.Key);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
}
Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityA)));
Assert.IsFalse(bindings.UnregisterTableBinding(typeof(EntityA)));
Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityB)));
}
public void PersistAndFind()
{
var ea1 = new EntityA { X = 1, Y = 2, Z = 3 };
TestBase.TestSerialization(ea1);
var ea2 = new EntityA { X = 4, Y = 5, Z = 6 };
TestBase.TestSerialization(ea2);
var eb1 = new EntityB { A = ea1, B = ea2 };
TestBase.TestSerialization(eb1);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
}
eb1 = new EntityB { A = ea1, B = ea2, C = ea1 };
TestBase.TestSerialization(eb1);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
}
eb1 = new EntityB { A = ea1, B = ea1, C = ea2 };
TestBase.TestSerialization(eb1);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
}
eb1 = new EntityB { A = ea1, B = ea1, C = ea1 };
TestBase.TestSerialization(eb1);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
}
}
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 ea1 = new EntityA {
X = 1, Y = 2, Z = 3
};
TestBase.TestSerialization(ea1);
var ea2 = new EntityA {
X = 4, Y = 5, Z = 6
};
TestBase.TestSerialization(ea2);
var eb1 = new EntityB {
A = ea1, B = ea2
};
TestBase.TestSerialization(eb1);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
}
eb1 = new EntityB {
A = ea1, B = ea2, C = ea1
};
TestBase.TestSerialization(eb1);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
}
eb1 = new EntityB {
A = ea1, B = ea1, C = ea2
};
TestBase.TestSerialization(eb1);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
}
eb1 = new EntityB {
A = ea1, B = ea1, C = ea1
};
TestBase.TestSerialization(eb1);
using (var em = Emf.CreateEntityManager())
{
em.Persist(eb1);
Assert.IsFalse(string.IsNullOrEmpty(eb1.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id));
Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Id);
Assert.AreEqual(eb1, _eb1);
}
}
public void PersistAndFind()
{
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));
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.IsFalse(string.IsNullOrEmpty(eb2.A.RowKey));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find <EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find <EntityA>(eb2.A.RowKey);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find <EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
}
var ec1 = new EntityC1();
var ec2 = new EntityC2 {
C1 = new EntityC1()
};
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
Assert.IsNotNull(ec1.Key);
Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.ColumnFamily));
Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.ColumnQualifier));
em.Persist(ec2);
Assert.IsNotNull(ec2.Key);
Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.ColumnFamily));
Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.ColumnQualifier));
Assert.IsNotNull(ec2.C1);
Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.ColumnFamily));
Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.ColumnQualifier));
}
using (var em = Emf.CreateEntityManager())
{
var _ec1 = em.Find <EntityC1>(ec1.Key);
Assert.AreEqual(ec1, _ec1);
var _ec12 = em.Find <EntityC1>(ec2.C1.Key);
Assert.AreEqual(ec2.C1, _ec12);
var _ec2 = em.Find <EntityC2>(ec2.Key);
Assert.AreEqual(ec2, _ec2);
}
}
public void PersistAndFind()
{
var bindings = Emf.Configuration.Binding;
Assert.IsFalse(bindings.StrictExplicitColumnBinding);
Assert.IsFalse(bindings.StrictExplicitKeyBinding);
Assert.IsFalse(bindings.StrictExplicitTableBinding);
Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA()));
Assert.IsFalse(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA()));
Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityB), new TableBindingEntityB()));
var eb1 = new EntityB();
TestBase.TestSerialization(eb1);
var eb2 = new EntityB { A = new EntityA() };
TestBase.TestSerialization(eb2);
using (var em = Emf.CreateEntityManager())
{
Assert.IsTrue(em.IsTypeDeclared<EntityA>());
Assert.IsTrue(em.IsTypeDeclared<EntityB>());
em.Configuration.Binding.StrictExplicitTableBinding = true;
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));
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.IsNotNull(eb2.A.Key);
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row));
Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.ColumnFamily));
Assert.IsTrue(string.IsNullOrEmpty(eb2.A.Key.ColumnQualifier));
}
using (var em = Emf.CreateEntityManager())
{
var _eb1 = em.Find<EntityB>(eb1.Key);
Assert.AreEqual(eb1, _eb1);
var _ea2 = em.Find<EntityA>(eb2.A.Key);
Assert.AreEqual(eb2.A, _ea2);
var _eb2 = em.Find<EntityB>(eb2.Key);
Assert.AreEqual(eb2, _eb2);
}
Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityA)));
Assert.IsFalse(bindings.UnregisterTableBinding(typeof(EntityA)));
Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityB)));
}
private EntityA _Create_EntityA_EntityB_And_Many_To_Many_Relation()
{
var a = new EntityA();
a.Name = "A";
var b = new EntityB();
b.Name = "B";
a.AddB(b);
using (IUnitOfWork uow = UnitOfWorkScope.Start())
{
var repoA = ServiceLocator.GetInstance<IEntityARepository>();
var repoB = ServiceLocator.GetInstance<IEntityBRepository>();
repoB.Add(b);
repoA.Add(a);
uow.Commit();
}
return a;
}
public EntityA(EntityB owner)
{
this.OwnerB = 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 unityContainer.Resolve(x); },
(x) => { return unityContainer.ResolveAll(x); });
NHibernateUnitOfWorkFactory<int> ctxFactory = this.CreateNHContextFactory();
if (!ctxFactory.DatabaseExists())
{
ctxFactory.CreateDatabase();
}
ctxFactory.ValidateDatabaseSchema();
NHibernate.ISessionFactory sessionFactory = ctxFactory.Create();
this.unityContainer.RegisterInstance<NHibernate.ISessionFactory>(sessionFactory);
this.unityContainer.RegisterInstance<IDatabaseManager>(ctxFactory);
this.unityContainer.RegisterType<ISession, ISession>(this.sessionPerTestLifeTimeManager, new InjectionFactory((c) =>
{
ISession session = sessionFactory.OpenSession();
session.Transaction.Begin();
return session;
}));
this.unityContainer.RegisterType<IUnitOfWork, NHibernateUnitOfWork>(this.unitOfWorkPerTestLifeTimeManager);
// Repositories
this.unityContainer.RegisterType<IEntityARepository, EntityANHRepository>(new PerResolveLifetimeManager());
this.unityContainer.RegisterType<IEntityBRepository, EntityBNHRepository>(new PerResolveLifetimeManager());
ApplicationContext.User =
new CorePrincipal(new CoreIdentity("cmendible", "hexa.auth", "*****@*****.**"), new string[] { });
// comienzan las operaciones
// añadimos una entidad
var entityA = new EntityA();
entityA.Name = "Martin4";
var repo = this.unityContainer.Resolve<IEntityARepository>();
repo.Add(entityA);
//this.Commit();
// al contrario que en ef aqui no tenemos commint
// añadimos 2 entidades y su relación
var a = new EntityA();
a.Name = "willi4";
var b = new EntityB();
b.Name = "matematicas";
a.AddB(b);
var repoA = this.unityContainer.Resolve<IEntityARepository>();
var repoB = this.unityContainer.Resolve<IEntityBRepository>();
repoB.Add(b);
repoA.Add(a);
this.RollBack();
/////////////////////////////////////////////////////////////////////////////////////////////
IUnitOfWork unitOfWork = this.unityContainer.Resolve<IUnitOfWork>();
unitOfWork.Dispose();
this.unitOfWorkPerTestLifeTimeManager.RemoveValue();
this.sessionPerTestLifeTimeManager.RemoveValue();
}
