jdbc: decouple rxjdbc module fix jooby-project#874

jknack · jknack · commit ca07f9e20e95 · 2017-09-24T19:17:02.000-03:00
diff --git a/doc/doc/rxjava-jdbc/rxjava-jdbc.md b/doc/doc/rxjava-jdbc/rxjava-jdbc.md
@@ -3,7 +3,7 @@
 <a href="https://github.com/davidmoten/rxjava-jdbc">rxjava-jdbc</a> efficient execution, concise code, and functional composition of database calls using JDBC and RxJava Observable.
 
 
-> This module depends on [jdbc module](/doc/jdbc) and [rx module](/doc/rxjava), please read the documentation of [jdbc module](/doc/jdbc) and [rx module](/doc/rxjava) before using ```rx-jdbc```.
+> This module depends on [jdbc](/doc/jdbc) module.
 
 ## dependency
 
@@ -28,6 +28,7 @@ import org.jooby.rx.Rx;
 {
   // required
   use(new Rx());
+  use(new Jdbc());
 
   use(new RxJdbc());
 
@@ -49,12 +50,13 @@ The [Rx.rx()]({{defdocs}}/rx/Rx.html#rx--) mapper converts ```Observable``` to [
 import org.jooby.rx.RxJdbc;
 import org.jooby.rx.Rx;
 {
+  use(new Jdbc("db.main"));
   use(new RxJdbc("db.main"));
 
+  use(new Jdbc("db.audit"));
   use(new RxJdbc("db.audit"));
 
   get("/", req ->
-
     Databse db = require("db.main", Database.class);
     Databse audit = require("db.audit", Database.class);
     // ...
diff --git a/modules/jooby-rxjava-jdbc/src/main/java/org/jooby/rx/RxJdbc.java b/modules/jooby-rxjava-jdbc/src/main/java/org/jooby/rx/RxJdbc.java
@@ -205,13 +205,18 @@
 
 import javax.sql.DataSource;
 
+import com.google.inject.Key;
+import com.google.inject.name.Names;
 import org.jooby.Env;
+import org.jooby.Jooby;
 import org.jooby.jdbc.Jdbc;
 
 import com.github.davidmoten.rx.jdbc.Database;
 import com.google.inject.Binder;
 import com.typesafe.config.Config;
 
+import java.util.NoSuchElementException;
+
 /**
  * <h1>rxjdbc</h1>
  * <p>
@@ -246,6 +251,7 @@
  * {
  *   // required by RxJdbc
  *   use(new Rx());
+ *   use(new Jdbc());
  *
  *   use(new RxJdbc());
  *
@@ -269,7 +275,10 @@
  *   // required by RxJdbc
  *   use(new Rx());
  *
+ *   use(new Jdbc("db.main"));
  *   use(new RxJdbc("db.main"));
+ *
+ *   use(new Jdbc("db.audit"));
  *   use(new RxJdbc("db.audit"));
  *
  *   get("/", req ->
@@ -292,32 +301,36 @@
  * @author edgar
  * @since 1.0.0.CR3
  */
-public class RxJdbc extends Jdbc {
+public class RxJdbc implements Jooby.Module {
+
+  private final String name;
 
   /**
    * Creates a new {@link RxJdbc} module.
    *
    * @param name Database name.
    */
   public RxJdbc(final String name) {
-    super(name);
+    this.name = name;
   }
 
   /**
    * Creates a new {@link RxJdbc} module.
    */
   public RxJdbc() {
+    this("db");
   }
 
   @Override
   public void configure(final Env env, final Config config, final Binder binder) {
-    super.configure(env, config, binder, (name, ds) -> {
-      Database db = Database.fromDataSource(ds);
+    Key<DataSource> dskey = Key.get(DataSource.class, Names.named(name));
+    DataSource ds = env.get(dskey)
+        .orElseThrow(() -> new NoSuchElementException("DataSource missing: " + dskey));
+    Database db = Database.fromDataSource(ds);
 
-      env.serviceKey().generate(Database.class, name, k -> binder.bind(k).toInstance(db));
+    env.serviceKey().generate(Database.class, name, k -> binder.bind(k).toInstance(db));
 
-      // close on shutdown
-      env.onStop(db::close);
-    });
+    // close on shutdown
+    env.onStop(db::close);
   }
 }
diff --git a/modules/jooby-rxjava-jdbc/src/test/java/org/jooby/rx/RxJdbcTest.java b/modules/jooby-rxjava-jdbc/src/test/java/org/jooby/rx/RxJdbcTest.java
@@ -8,11 +8,15 @@
 import com.google.inject.name.Names;
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigValueFactory;
+
 import static com.typesafe.config.ConfigValueFactory.fromAnyRef;
+
 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
+
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.isA;
+
 import org.jooby.Env;
 import org.jooby.test.MockUnit;
 import org.jooby.test.MockUnit.Block;
@@ -23,6 +27,9 @@
 import org.powermock.modules.junit4.PowerMockRunner;
 
 import javax.sql.DataSource;
+import javax.xml.crypto.Data;
+import java.util.NoSuchElementException;
+import java.util.Optional;
 import java.util.Properties;
 
 @RunWith(PowerMockRunner.class)
@@ -32,35 +39,34 @@ public class RxJdbcTest {
   private MockUnit.Block onStop = unit -> {
     Env env = unit.get(Env.class);
     expect(env.onStop(unit.capture(Throwing.Runnable.class))).andReturn(env);
-    expect(env.onStop(isA(Throwing.Runnable.class))).andReturn(env);
   };
 
   @SuppressWarnings("unchecked")
   private Block bind = unit -> {
+    Env env = unit.get(Env.class);
+    expect(env.serviceKey()).andReturn(new Env.ServiceKey());
+
+    DataSource ds = unit.registerMock(DataSource.class);
+    expect(env.get(Key.get(DataSource.class, Names.named("db")))).andReturn(Optional.of(ds));
+
     unit.mockStatic(Database.class);
 
     Database db = unit.mock(Database.class);
     unit.registerMock(Database.class, db);
-    expect(Database.fromDataSource(unit.get(HikariDataSource.class))).andReturn(db);
+    expect(Database.fromDataSource(unit.get(DataSource.class))).andReturn(db);
 
     LinkedBindingBuilder<Database> lbb = unit.mock(LinkedBindingBuilder.class);
     lbb.toInstance(db);
     lbb.toInstance(db);
 
     Binder binder = unit.get(Binder.class);
     expect(binder.bind(Key.get(Database.class))).andReturn(lbb);
-    expect(binder.bind(Key.get(Database.class, Names.named("jdbctest")))).andReturn(lbb);
+    expect(binder.bind(Key.get(Database.class, Names.named("db")))).andReturn(lbb);
   };
 
   @Test
   public void configure() throws Exception {
-    String url = "jdbc:h2:target/jdbctest";
     new MockUnit(Env.class, Config.class, Binder.class)
-        .expect(props("org.h2.jdbcx.JdbcDataSource", url, "h2.jdbctest",
-            "sa", "", false))
-        .expect(hikariConfig())
-        .expect(hikariDataSource())
-        .expect(serviceKey("jdbctest"))
         .expect(bind)
         .expect(onStop)
         .run(unit -> {
@@ -69,15 +75,22 @@ public void configure() throws Exception {
         });
   }
 
+  @Test(expected = NoSuchElementException.class)
+  public void noDataSource() throws Exception {
+    new MockUnit(Env.class, Config.class, Binder.class)
+        .expect(unit -> {
+          Env env = unit.get(Env.class);
+          expect(env.get(Key.get(DataSource.class, Names.named("db")))).andReturn(Optional.empty());
+        })
+        .run(unit -> {
+          new RxJdbc()
+              .configure(unit.get(Env.class), config(), unit.get(Binder.class));
+        });
+  }
+
   @Test
   public void withDb() throws Exception {
-    String url = "jdbc:h2:target/jdbctest";
     new MockUnit(Env.class, Config.class, Binder.class)
-        .expect(props("org.h2.jdbcx.JdbcDataSource", url, "h2.jdbctest",
-            "sa", "", false))
-        .expect(hikariConfig())
-        .expect(hikariDataSource())
-        .expect(serviceKey("jdbctest"))
         .expect(bind)
         .expect(onStop)
         .run(unit -> {
@@ -88,13 +101,7 @@ public void withDb() throws Exception {
 
   @Test
   public void onStop() throws Exception {
-    String url = "jdbc:h2:target/jdbctest";
     new MockUnit(Env.class, Config.class, Binder.class)
-        .expect(props("org.h2.jdbcx.JdbcDataSource", url, "h2.jdbctest",
-            "sa", "", false))
-        .expect(hikariConfig())
-        .expect(hikariDataSource())
-        .expect(serviceKey("jdbctest"))
         .expect(bind)
         .expect(onStop)
         .expect(unit -> {
@@ -110,84 +117,7 @@ public void onStop() throws Exception {
 
   private Config config() {
     return new RxJdbc().config()
-        .withValue("db", ConfigValueFactory.fromAnyRef("fs"))
-        .withValue("application.ns", ConfigValueFactory.fromAnyRef("my.model"))
-        .withValue("application.tmpdir", ConfigValueFactory.fromAnyRef("target"))
-        .withValue("application.name", ConfigValueFactory.fromAnyRef("jdbctest"))
-        .withValue("application.charset", ConfigValueFactory.fromAnyRef("UTF-8"))
-        .withValue("runtime.processors-x2", fromAnyRef("4"))
         .resolve();
   }
 
-  @SuppressWarnings("unchecked")
-  private Block serviceKey(final String db) {
-    return unit -> {
-      Env env = unit.get(Env.class);
-      expect(env.serviceKey()).andReturn(new Env.ServiceKey()).times(2);
-
-      AnnotatedBindingBuilder<DataSource> binding = unit.mock(AnnotatedBindingBuilder.class);
-      binding.toInstance(unit.get(HikariDataSource.class));
-      binding.toInstance(unit.get(HikariDataSource.class));
-
-      Binder binder = unit.get(Binder.class);
-      expect(binder.bind(Key.get(DataSource.class))).andReturn(binding);
-      expect(binder.bind(Key.get(DataSource.class, Names.named(db)))).andReturn(binding);
-    };
-  }
-
-  private Block hikariConfig() {
-    return unit -> {
-      Properties properties = unit.get(Properties.class);
-      HikariConfig hikari = unit.constructor(HikariConfig.class)
-          .build(properties);
-      unit.registerMock(HikariConfig.class, hikari);
-    };
-  }
-
-  private Block hikariDataSource() {
-    return unit -> {
-      HikariConfig properties = unit.get(HikariConfig.class);
-      HikariDataSource hikari = unit.constructor(HikariDataSource.class)
-          .build(properties);
-
-      unit.registerMock(HikariDataSource.class, hikari);
-    };
-  }
-
-  private Block props(final String dataSourceClassName, final String url, final String name,
-      final String username, final String password, final boolean hasDataSourceClassName) {
-    return unit -> {
-      Properties properties = unit.constructor(Properties.class)
-          .build();
-
-      expect(properties
-          .setProperty("dataSource.dataSourceClassName", dataSourceClassName))
-          .andReturn(null);
-      if (username != null) {
-        expect(properties
-            .setProperty("dataSource.user", username))
-            .andReturn(null);
-        expect(properties
-            .setProperty("dataSource.password", password))
-            .andReturn(null);
-      }
-      expect(properties
-          .setProperty("dataSource.url", url))
-          .andReturn(null);
-
-      if (hasDataSourceClassName) {
-        expect(properties.getProperty("dataSourceClassName")).andReturn(dataSourceClassName);
-      } else {
-        expect(properties.getProperty("dataSourceClassName")).andReturn(null);
-        expect(properties.getProperty("dataSource.dataSourceClassName"))
-            .andReturn(dataSourceClassName);
-        expect(properties.setProperty("dataSourceClassName", dataSourceClassName)).andReturn(null);
-      }
-      expect(properties.remove("dataSource.dataSourceClassName")).andReturn(dataSourceClassName);
-      expect(properties.setProperty("poolName", name)).andReturn(null);
-      expect(properties.setProperty("maximumPoolSize", "4")).andReturn(null);
-
-      unit.registerMock(Properties.class, properties);
-    };
-  }
 }
