Fix problem where Database referenced Spring.

Author: David Pratt

src/main/scala/janus/Database.scala

@@ -7,22 +7,6 @@ import scala.concurrent._
 import org.springframework.transaction.PlatformTransactionManager
 
 object Database {
-  /**
-   * Create a new Database. Sessions created by this database will manage their own transaction semantics.
-   *
-   * Note - if this datasource is synchronized to a Spring PlatformTransactionManager, usage of a Database returned from
-   * this method will interfere with and likely cause undefined behavior with Spring managed transactions.
-   */
-  def apply(ds: DataSource) = new JdbcDatabase(ds)
-
-  /**
-   * Create a new Database that will create and participate in Spring managed transactions.
-   *
-   * Note - the supplied DataSource *MUST* be synchronized by the supplied PlatformTransactionManager,
-   * or undefined (and likely destructive) behavior will occur.
-   */
-  def apply(ds: DataSource, txManager: PlatformTransactionManager) = new SpringDatabase(ds, txManager)
-
   private val logger = LoggerFactory.getLogger(classOf[Database])
 }
 
@@ -61,10 +45,21 @@ trait Database {
 
 }
 
-private[janus] class JdbcDatabase(ds: DataSource) extends Database {
+/**
+ * A plain Database implementation that does it's own transaction management.
+ *
+ */
+class JdbcDatabase(ds: DataSource) extends Database {
   def createSession: Session = new SimpleSession(ds)
 }
 
-private[janus] class SpringDatabase(ds: DataSource, txManager: PlatformTransactionManager) extends Database {
+/**
+ * A Database that can participate in Spring managed transactions. This Database will delegate all transaction
+ * semantics to Spring, and is capable of creating and participating in a thread-bound transaction context.
+ *
+ * IMPORTANT - The supplied DataSource *MUST* be synchronized by the provided PlatformTransactionManager. If it is not,
+ * undefined (and likely destructive) behavior will occur.
+ */
+class SpringDatabase(ds: DataSource, txManager: PlatformTransactionManager) extends Database {
   def createSession: Session = new SpringSession(ds, txManager)
 }

src/test/scala/janus/DatabaseSpec.scala

@@ -12,12 +12,12 @@ class DatabaseSpec extends FlatSpec {
 
   def basicDatabase = {
     val ds = emptyDataSource()
-    Database(ds)
+    new JdbcDatabase(ds)
   }
 
   def springDatabase = {
     val ds = emptyDataSource()
-    Database(ds, new DataSourceTransactionManager(ds))
+    new SpringDatabase(ds, new DataSourceTransactionManager(ds))
   }
 
   "A Database based on a simple DataSource" should behave like basicDatabaseBehavior(basicDatabase)

src/test/scala/janus/JTASpec.scala

@@ -15,7 +15,7 @@ class JTASpec extends FlatSpec {
   "A database" should "properly participate in an XA tranasaction with a single datasource" in {
     val ds = emptyDataSource("first-ds")
     val txManager = transactionManager
-    val db = Database(ds, new JtaTransactionManager(txManager, txManager))
+    val db = new SpringDatabase(ds, new JtaTransactionManager(txManager, txManager))
     try {
       db.withSession { session =>
         session.executeQuery("select count(*) from test") { rs =>
@@ -52,7 +52,7 @@ class JTASpec extends FlatSpec {
     val unmanagedDs = emptyDataSource("first-ds")
     val managedDs = emptyDataSource("second-ds")
     val txManager = transactionManager
-    val managedDatabase = Database(unmanagedDs, new JtaTransactionManager(txManager, txManager))
+    val managedDatabase = new SpringDatabase(unmanagedDs, new JtaTransactionManager(txManager, txManager))
     try {
 
       def validateUnmanaged(expectedCount: Int) {