public void all_objects_in_the_object_graph_are_proxied()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var item = new Person
{
Id = "1",
Contacts = new List <Contact>
{
new Contact {
Id = "1"
}
}
};
var proxy = factory.Create(item, session);
Assert.True(ProxyUtils.IsProxy(proxy));
Assert.True(proxy.Contacts is ITrackableCollection <Contact>);
Assert.True(ProxyUtils.IsProxy(proxy.Contacts[0]));
}
}
public void circular_dependencies_are_proxied_correctly()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
var parentMapper = new Mock <IMapper <Parent> >();
repositoryFactory.Register <Parent>(x => parentMapper.Object);
var childMapper = new Mock <IMapper <Child> >();
repositoryFactory.Register <Child>(x => childMapper.Object);
var stateTracker = new EntityStateCache();
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
{
var a = new EntityA
{
Id = "a"
};
var b = new EntityB
{
Id = "b"
};
a.EntityB = b;
b.EntityA = a;
var proxy = proxyFactory.Create(a, session);
Assert.NotNull(proxy);
Assert.NotNull(proxy.EntityB);
Assert.NotNull(proxy.EntityB.EntityA);
Assert.Same(proxy, proxy.EntityB.EntityA);
}
}
public void properties_which_are_marked_as_ignored_are_not_proxied()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var item = new EntityWithIgnoredProperty
{
Id = "1",
Ignored = new AnotherEntity {
Id = "2"
},
Proxied = new AnotherEntity {
Id = "3"
}
};
var proxy = factory.Create(item, session);
Assert.True(ProxyUtils.IsProxy(proxy));
Assert.True(ProxyUtils.IsProxy(proxy.Proxied));
Assert.False(ProxyUtils.IsProxy(proxy.Ignored));
}
}
public void change_tracking_is_applied_when_entity_set_in_constructor()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var mapper = new Mock <IMapper <Parent> >();
var repositoryFactory = new Mock <IRepositoryFactory>();
repositoryFactory.Setup(x => x.Create(It.IsAny <IGraphSession>(), It.IsAny <Type>())).Returns <IGraphSession, Type>((s, t) => new GenericAbstractRepository <Parent>(mapper.Object, s, new DynamicProxyFactory(metadataFactory, new NullLogger())));
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var proxy = session.Create(new Parent
{
Id = "1",
Child = new Child {
Id = "2"
}
});
var state = stateTracker.Get(proxy.Child);
Assert.Equal(EntityStatus.New, state.Status);
}
}
public void depdendencies_are_incremented_when_property_set()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var parent = factory.Create(new Parent {
Id = "parent"
}, session);
var child = factory.Create(new Child {
Id = "child"
}, session);
parent.Child = child;
var parentState = stateTracker.Get(parent);
Assert.Equal(2, parentState.Dependencies.Sequence);
var childState = stateTracker.Get(child);
Assert.Equal(1, childState.Dependencies.Sequence);
}
}
public void factory_creates_meta_data_correctly_from_a_proxy_object()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var item = new Parent
{
Id = "1",
Child = new Child {
Id = "2"
},
Children = new List <Child> {
new Child {
Id = "3"
}
}
};
var proxy = factory.Create(item, session);
var parentMetadata = metadataFactory.Create(proxy);
Assert.Equal("Parent", parentMetadata.Name);
var childMetadta = metadataFactory.Create(proxy.Child);
Assert.Equal("Child", childMetadta.Name);
}
}
public void nullable_types_are_ignored()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
var parentMapper = new Mock <IMapper <Parent> >();
repositoryFactory.Register <Parent>(x => parentMapper.Object);
var childMapper = new Mock <IMapper <Child> >();
repositoryFactory.Register <Child>(x => childMapper.Object);
var stateTracker = new EntityStateCache();
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
{
var entity = new EntityWithNullableType
{
Id = "1",
Date = DateTime.Now
};
var proxy = proxyFactory.Create(entity, session);
Assert.NotNull(proxy.Date);
}
}
public void objects_with_inheritance_chain_are_proxied_correctly()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
var parentMapper = new Mock <IMapper <Parent> >();
repositoryFactory.Register <Parent>(x => parentMapper.Object);
var childMapper = new Mock <IMapper <Child> >();
repositoryFactory.Register <Child>(x => childMapper.Object);
var stateTracker = new EntityStateCache();
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
{
var entity = new ParentWithInheritedChild
{
Id = "1",
Type = new SuperTypeA {
Id = "1"
}
};
var proxy = proxyFactory.Create(entity, session);
Assert.True(proxy.Type is SuperTypeA);
}
}
public void dependencies_are_incremented_as_relationships_are_created()
{
var stateTracker = new EntityStateCache();
var stateFactory = new Mock <IEntityStateCacheFactory>();
stateFactory.Setup(x => x.Create()).Returns(stateTracker);
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
repositoryFactory.Register <Organisation>(session => new Mapper <Organisation>(session, metadataFactory));
repositoryFactory.Register <AccessGroup>(session => new Mapper <AccessGroup>(session, metadataFactory));
repositoryFactory.Register <Site>(session => new Mapper <Site>(session, metadataFactory));
repositoryFactory.Register <Person>(session => new Mapper <Person>(session, metadataFactory));
var sessionFactory = new GraphSessionFactory(queryExecutorFactory.Object, repositoryFactory, stateFactory.Object, proxyFactory);
using (var session = sessionFactory.OpenSession())
{
var organisation = session.Create(new Organisation
{
Id = "organisation"
});
var site = session.Create(new Site
{
Id = "site"
});
var accessGroup = session.Create(new AccessGroup
{
Id = "accessGroup"
});
var person = session.Create(new Person
{
Id = "person"
});
organisation.Add(site);
organisation.Add(accessGroup);
site.Add(accessGroup);
person.Add(organisation);
person.Add(site);
var organisationMetadata = stateTracker.Get(organisation);
var siteMetadata = stateTracker.Get(site);
var accessGroupMetadata = stateTracker.Get(accessGroup);
var personMetadata = stateTracker.Get(person);
Assert.Equal(1, accessGroupMetadata.Dependencies.Sequence);
Assert.Equal(2, siteMetadata.Dependencies.Sequence);
Assert.Equal(3, organisationMetadata.Dependencies.Sequence);
Assert.Equal(4, personMetadata.Dependencies.Sequence);
}
}
public void ShouldCreateParameterStatement()
{
var factory = new AttributeMetadataFactory(new NullLogger());
var person = new Person {
Id = "1"
};
var node = new Node(factory.Create(person), person);
var result = StatementFactory.Parameter(node);
Assert.Equal("Person_1", result);
}
public void ShouldCreateMergeStatement()
{
var factory = new AttributeMetadataFactory(new NullLogger());
var person = new Person {
Id = "1"
};
var node = new Node(factory.Create(person), person);
var id = StatementFactory.IdParameter(node);
var result = StatementFactory.Merge(node, id);
Assert.Equal("(Person_1:Person { Id:{Person_1_id}})", result);
}
public void MatchShouldGenerateValidSyntax()
{
var factory = new AttributeMetadataFactory(null);
var person = new Person {
Id = "1"
};
var node = new Node(factory.Create(person), person);
var statement = StatementFactory.Match(node, StatementFactory.Parameter(node));
var query = new CypherQuery <Person>();
var response = query.Match(statement);
Assert.Equal("MATCH (Person_1:Person { Id:{Person_1}})", response.Statement);
}
public void interceptors_are_not_created_for_re_entrant_proxies()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
var parentMapper = new Mock <IMapper <Parent> >();
repositoryFactory.Register <Parent>(x => parentMapper.Object);
var childMapper = new Mock <IMapper <Child> >();
repositoryFactory.Register <Child>(x => childMapper.Object);
var stateTracker = new EntityStateCache();
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
{
var proxy = session.Create(new Parent
{
Id = "1"
});
proxy.Child = session.Create(new Child
{
Id = "1"
});
var metadata = metadataFactory.Create(proxy);
var deleted = ProxyUtils.Flush(proxy, metadata["Child"].Relationship);
Assert.Equal(0, deleted.SelectMany(x => x.Flush().Cast <object>()).Count());
var reentrant = session.Create(proxy);
Assert.Equal(proxy, reentrant);
metadata = metadataFactory.Create(reentrant);
deleted = ProxyUtils.Flush(reentrant, metadata["Child"].Relationship);
Assert.Equal(0, deleted.SelectMany(x => x.Flush().Cast <object>()).Count());
proxy.Child = session.Create(new Child
{
Id = "2"
});
metadata = metadataFactory.Create(reentrant);
deleted = ProxyUtils.Flush(reentrant, metadata["Child"].Relationship);
Assert.Equal(1, deleted.SelectMany(x => x.Flush().Cast <object>()).Count());
}
}
public void properties_set_during_construction_are_restored_after_proxy_created()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var item = new EntityWithPropertiesSetInConstructor("1", "Test");
var proxy = factory.Create(item, session);
Assert.Equal("1", proxy.Id);
Assert.Equal("Test", proxy.Name);
}
}
public void ShouldCreateNamedRelationship()
{
var factory = new AttributeMetadataFactory(new NullLogger());
var personA = new Person {
Id = "A"
};
var nodeA = new Node(factory.Create(personA), personA);
var personB = new Person {
Id = "B"
};
var nodeB = new Node(factory.Create(personB), personB);
var relationship = new RelationshipMetadata {
Name = "REL", IsReverse = true
};
var result = StatementFactory.Relationship(nodeA, nodeB, relationship, "r");
Assert.Equal("(Person_A)<-[r:REL]-(Person_B)", result);
}
public void an_exception_is_thrown_if_id_null()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
Assert.Throws <PropertyNotSetException>(() =>
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var notSet = new AnotherEntity();
factory.Create(notSet, session);
});
}
}
public void factory_creates_meta_data()
{
var factory = new AttributeMetadataFactory(new NullLogger());
var node = factory.Create(typeof(Person));
Assert.Equal("Person", node.Name);
Assert.Equal(3, node.Properties.Count());
Assert.Equal("Id", node["Id"].Name);
Assert.True(node["Id"].IsPrimitive);
Assert.Equal("Name", node["Name"].Name);
Assert.True(node["Name"].IsPrimitive);
Assert.Equal("Contacts", node["Contacts"].Name);
Assert.True(node["Contacts"].IsList);
Assert.False(node["Contacts"].IsPrimitive);
Assert.NotNull(node["Contacts"].Relationship);
Assert.Equal("LINKED_TO", node["Contacts"].Relationship.Name);
}
public void a_proxy_is_generated_for_trackable_relationships()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var person = new Person
{
Id = "1",
Name = "Test",
Address = new Address
{
Id = "1",
Name = "first address"
}
};
var proxy = proxyFactory.Create(person, session);
proxy.Address = null;
proxy.Address = proxyFactory.Create(new Address {
Id = "2"
}, session);
var metadata = metadataFactory.Create(proxy);
var trackableRelationships = ProxyUtils.Flush(proxy, metadata["Address"].Relationship).ToList();
Assert.Equal(1, trackableRelationships.Count);
foreach (var trackableRelationship in trackableRelationships)
{
var enumerable = trackableRelationship.Flush();
var results = enumerable.Cast <object>().ToList();
Assert.Equal(1, results.Count);
Assert.Equal("1", ((Address)results[0]).Id);
Assert.Equal("2", proxy.Address.Id);
}
}
}
public void factory_is_thread_safe()
{
var error = false;
var factory = new AttributeMetadataFactory(new NullLogger());
var threads = new Thread[150];
for (int i = 0; i < threads.Length; i++)
{
threads[i] = new Thread(() =>
{
try
{
var node = factory.Create(typeof(Person));
var property = node["Id"];
Assert.Equal("Id", property.Name);
}
catch (Exception)
{
error = true;
}
});
}
foreach (var thread in threads)
{
thread.Start();
}
foreach (Thread thread in threads)
{
thread.Join();
}
Assert.False(error);
}
public void reverse_property_is_set_correctly_on_one_to_one_relationships()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var alpha = factory.Create(new ClassAlpha
{
Id = "1"
}, session);
var beta = factory.Create(new ClassBeta
{
Id = "2"
}, session);
alpha.Beta = beta;
var metadata = metadataFactory.Create(beta);
Assert.True(metadata["Alpha"].Relationship.IsReverse);
}
}
