added some real test code

pom.xml

@@ -114,6 +114,11 @@
 			<artifactId>spring-aspects</artifactId>
 			<version>${spring.version}</version>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-jdbc</artifactId>
+			<version>${spring.version}</version>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-tx</artifactId>
@@ -130,6 +135,13 @@
 			<artifactId>data-commons</artifactId>
 			<version>1.0.0.CI-SNAPSHOT</version>
 		</dependency>
+		
+		<!-- Test only  dependencies -->
+		<dependency>
+            <groupId>org.hsqldb</groupId>
+            <artifactId>hsqldb</artifactId>
+            <version>1.8.0.10</version>
+        </dependency>
 	</dependencies>
 
 	<build>

src/main/java/org/springframework/persistence/transaction/NaiveDoubleTransactionManager.java

@@ -0,0 +1,69 @@
+package org.springframework.persistence.transaction;
+
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.TransactionException;
+import org.springframework.transaction.TransactionStatus;
+import org.springframework.transaction.support.DefaultTransactionStatus;
+
+public class NaiveDoubleTransactionManager implements PlatformTransactionManager {
+	
+	private final PlatformTransactionManager a;
+	
+	private final PlatformTransactionManager b;
+	
+	public NaiveDoubleTransactionManager(PlatformTransactionManager a, PlatformTransactionManager b) {
+		System.err.println("WARNING: Naive JTA/Neo4j Spring transaction manager--must implement properly");
+		this.a = a;
+		this.b = b;
+	}
+
+	@Override
+	public void commit(TransactionStatus ts) throws TransactionException {
+		TransactionStatus tsb = copyTransactionStatus(ts);
+		try {
+			a.commit(ts);
+		}
+		catch (Throwable t) {
+			System.err.println("Continuing to commit tx despite this:" + t);
+		}
+		try {
+			b.commit(tsb);
+		}
+		catch (Throwable t) {
+			System.err.println("Can't commit tx" + t);
+			throw new TransactionException(t.getMessage(), t) {}; 
+		}
+	}
+
+	private TransactionStatus copyTransactionStatus(TransactionStatus ts) {
+		return new DefaultTransactionStatus(null, ts.isNewTransaction(), false,  false, false, null);
+	}
+	
+	@Override
+	public TransactionStatus getTransaction(TransactionDefinition td)
+			throws TransactionException {
+		TransactionStatus atx = a.getTransaction(td);
+		TransactionStatus btx = b.getTransaction(td);
+		return atx;
+	}
+
+	@Override
+	public void rollback(TransactionStatus ts) throws TransactionException {
+		TransactionStatus tsb = copyTransactionStatus(ts);
+		try {
+			a.rollback(ts);
+		}
+		catch (Throwable t) {
+			System.err.println("Continuing to rollback tx despite this:" + t);
+		}
+		try {
+			b.rollback(tsb);
+		}
+		catch (Throwable t) {
+			System.err.println("Can't rollback tx" + t);
+			throw new TransactionException(t.getMessage(), t) {}; 
+		}
+	}
+
+}

src/test/java/org/springframework/persistence/test/Person.java

@@ -0,0 +1,34 @@
+package org.springframework.persistence.test;
+
+import org.springframework.persistence.graph.GraphEntity;
+
+@GraphEntity
+public class Person {
+	
+	private String name;
+	
+	private int age;
+	
+	public Person(String name, int age) {
+		this.name = name;
+		this.age = age;
+	}
+	
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public int getAge() {
+		return age;
+	}
+
+	public void setAge(int age) {
+		this.age = age;
+	}
+
+}

src/test/java/org/springframework/persistence/test/graph/Neo4jGraphPersistenceTest.java

@@ -0,0 +1,38 @@
+package org.springframework.persistence.test.graph;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.neo4j.graphdb.GraphDatabaseService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.persistence.test.Person;
+import org.springframework.test.annotation.Rollback;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+public class Neo4jGraphPersistenceTest {
+
+	@Autowired
+	protected GraphDatabaseService graphDatabaseService;
+	
+	@Test
+	public void testGraphDatabaseServiceCreatedAndAutowired() {
+        Assert.assertNotNull( graphDatabaseService );
+	}
+
+	@Test
+	@Transactional
+	@Rollback(false)
+	public void testUserConstructor() {
+		int age = 39;
+		Person p = new Person("Rod", age);
+		Assert.assertEquals(p.getUnderlyingNode().getProperty("Person.name"), p.getName());
+		Assert.assertEquals(age, p.getAge());
+	}
+
+}

src/test/resources/log4j.properties

@@ -7,7 +7,7 @@ log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c - %m%n 
 
 log4j.appender.R=org.apache.log4j.RollingFileAppender
-log4j.appender.R.File=application.log
+log4j.appender.R.File=target/application.log
 
 log4j.appender.R.MaxFileSize=100KB
 # Keep one backup file

src/test/resources/org/springframework/persistence/test/graph/Neo4jGraphPersistenceTest-context.xml

@@ -0,0 +1,121 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:aop="http://www.springframework.org/schema/aop"
+	xmlns:context="http://www.springframework.org/schema/context"
+	xmlns:jee="http://www.springframework.org/schema/jee"
+	xmlns:tx="http://www.springframework.org/schema/tx"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:task="http://www.springframework.org/schema/task"
+	xmlns:p="http://www.springframework.org/schema/p"
+	xsi:schemaLocation="http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
+		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
+		http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
+		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+
+	<!--
+		This will automatically locate any and all property files you have
+		within your classpath, provided they fall under the META-INF/spring
+		directory. The located property files are parsed and their values can
+		then be used within application context files in the form of
+		${propertyKey}.
+	-->
+	<context:property-placeholder location="classpath*:META-INF/spring/*.properties"/>
+
+	<!--
+		Turn on AspectJ @Configurable support. As a result, any time you
+		instantiate an object, Spring will attempt to perform dependency
+		injection on that object. This occurs for instantiation via the "new"
+		keyword, as well as via reflection. This is possible because AspectJ
+		is used to "weave" Roo-based applications at compile time. In effect
+		this feature allows dependency injection of any object at all in your
+		system, which is a very useful feature (without @Configurable you'd
+		only be able to dependency inject objects acquired from Spring or
+		subsequently presented to a specific Spring dependency injection
+		method). Roo applications use this useful feature in a number of
+		areas, such as @PersistenceContext injection into entities.
+	-->
+	<context:spring-configured/>
+
+	<!--
+		This declaration will cause Spring to locate every @Component,
+		@Repository and @Service in your application. In practical terms this
+		allows you to write a POJO and then simply annotate the new POJO as an
+		@Service and Spring will automatically detect, instantiate and
+		dependency inject your service at startup time. Importantly, you can
+		then also have your new service injected into any other class that
+		requires it simply by declaring a field for your service inside the
+		relying class and Spring will inject it. Note that two exclude filters
+		are declared. The first ensures that Spring doesn't spend time
+		introspecting Roo-specific ITD aspects. The second ensures Roo doesn't
+		instantiate your @Controller classes, as these should be instantiated
+		by a web tier application context. Refer to web.xml for more details
+		about the web tier application context setup services.
+		
+		Furthermore, this turns on @Autowired, @PostConstruct etc support. These 
+		annotations allow you to use common Spring and Java Enterprise Edition 
+		annotations in your classes without needing to do any special configuration. 
+		The most commonly used annotation is @Autowired, which instructs Spring to
+		dependency inject an object into your class.
+	-->
+	<context:component-scan base-package="org.springframework.persistence.test">
+		<context:exclude-filter expression=".*_Roo_.*" type="regex"/>
+		<context:exclude-filter expression="org.springframework.stereotype.Controller" type="annotation"/>
+	</context:component-scan>
+	
+	
+	<!-- 
+	    Start datastore config
+    -->
+
+	<bean class="org.springframework.persistence.graph.neo4j.Neo4jNodeBacking" 
+		factory-method="aspectOf" />
+
+	<!--
+		<bean class="org.springframework.persistence.graph.Neo4jSimpleNodePropertyStorageForeignStoreKeyManager"/>
+	-->
+	
+	<bean id="graphDbService" class="org.neo4j.kernel.EmbeddedGraphDatabase" 
+			destroy-method="shutdown" >
+		 <constructor-arg index="0" value="${neo4j.databaseDirectory}" />
+	</bean>
+	
+	<bean class="org.springframework.persistence.graph.neo4j.Neo4jConstructorEntityInstantiator" />	
+
+	<!--
+ 	-->
+	<bean id="transactionManager" class="org.springframework.persistence.transaction.NaiveDoubleTransactionManager" >
+		<constructor-arg>
+			 <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
+			 	<property name="dataSource" ref="dataSource"/>
+			 </bean>
+		</constructor-arg>
+		<constructor-arg>
+			<bean 
+			    class="org.springframework.transaction.jta.JtaTransactionManager">
+			    <property name="transactionManager" ref="neo4jTransactionManagerService" />
+			    <property name="userTransaction" ref="neo4jUserTransactionService" />
+			</bean>
+		</constructor-arg>
+	</bean>
+
+
+	<bean id="neo4jTransactionManagerService" class="org.neo4j.kernel.impl.transaction.SpringTransactionManager" >
+	  <constructor-arg index="0" ref="graphDbService" />
+	</bean>
+	
+	<bean id="neo4jUserTransactionService" class="org.neo4j.kernel.impl.transaction.UserTransactionImpl">
+	    <constructor-arg index="0" ref="graphDbService" />
+	</bean>
+	
+	<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
+        <property name="driverClassName" value="${database.driverClassName}"/>
+        <property name="url" value="${database.url}"/>
+        <property name="username" value="${database.username}"/>
+        <property name="password" value="${database.password}"/>
+    </bean>
+ 
+    <tx:annotation-driven mode="aspectj" transaction-manager="transactionManager"/>
+     
+</beans>