Play2 and Scala, How should I configure my integration tests to run with proper DB - scala

Question

I'm trying to figure out how to write my db integration tests in my Play2 app.
In my conf file I have specified two databases, xxx_test for regular use and h2 db for testing:
db.xxx_test.driver=com.mysql.jdbc.Driver
db.xxx_test.url="jdbc:mysql://localhost/xxx_test?characterEncoding=UTF-8"
db.xxx_test.user="root"
db.xxx_test.password=""
db.h2.driver=org.h2.Driver
db.h2.url="jdbc:h2:mem:play"
db.h2.user=sa
db.h2.password=""
In my User object I have specified xxx_test to be used when I run the application.
def createUser(user: User): Option[User] = {
DB.withConnection("xxx_test") {
implicit connection =>
SQL("insert into users(first_name, last_name, email, email_validated, last_login, created, modified, active) values({first_name},{last_name},{email},{email_validated},{last_login}, {created}, {modified}, {active})").on(
'first_name -> user.firstName,
'last_name -> user.lastName,
'email -> user.email,
'email_validated -> user.emailValidated,
'last_login -> user.lastLogin,
'created -> user.created,
'modified -> user.modified,
'active -> true
).executeInsert().map(id => {
return Some(User(new Id[Long](id), user.firstName, user.lastName, user.email, user.emailValidated, user.lastLogin, user.created, user.modified, true))
}
)
}
None
}
In my test I create a new inMemoryDatabase and then use the User to create and get my object
for testing.
class DBEvolutionsTest extends Specification {
"The Database" should {
"persist data properly" in {
running(FakeApplication(additionalConfiguration = inMemoryDatabase())) {
User.create(User(Id[Long](1L), "jakob",
"aa",
"aaa",
true,
DateTime.now(),
DateTime.now(),
DateTime.now(),
true))
val newUser = User.findBy(Id[Long](1L))
newUser.get.firstName must beEqualTo("jakob")
}
}
}
}
This of course is not the correct way since the User object uses the xxx_test and not the
h2 db. The test will create a User in the real db and not the one in memory since I have specified the db in the User(DB.withConnection("xxx_test")) object.
I guess there is some smart way of doing this, I do not want to pass the db name around
inte the application like User.create(User(...), "xxx_test")
How have you solved this problem?

Answer 1

You might want to checkout how to do dependency injection in scala. A good solution is to abstract your database out of your User model and then pass it as a dependency.
A simple way to do it would be to change the configuration file for testing. Play lets you specify which config file is used on the command line.
This is not the most practical though.
Another solution is to use implicits, define your database connection as an implicit parameter of your function:
def createUser(user: User)(implicit dbName: String): Option[User]=
DB.withConnection(dbName) { ... }
You will still have to propagate the parameter upwards in all your calls, but you can hide it:
def importUsers(csvFile: File)(implicit dbName: String): Seq[User] = { conn =>
...
User.createUser(u)
...
}
and when you call it from the top:
implicit dbName = "test"
importUsers(...)
This is build in in scala, so it's pretty easy to setup and doesn't need a lot of boilerplate supporting it. Personally, I think that implicits make the code unclear and I prefer the solution presented in this presentation Dead-Simple Dependency Injection.
The gist of it is that you make your createUser and all other methods that depend on a database connection to return a function depending on the connection, and not just the result. Here is how it would work with your example.
1- you create a Connection trait that configures a connection. A simple form would be:
trait ConnectionConfig {
def dbName: String
}
2- your method depending on that config returns a function:
def createUser(user: User): ConnectionConfig => Option[User] = { conn =>
DB.withConnection(conn.dbName) { ... }
}
3- when you use createUser in another method, that method becomes dependent on the connection too, so you mark it as such by returning the dependency on ConnectionConfig with a function return type, for example:
def importUsers(csvFile: File): ConnectionConfig => Seq[User] = { conn =>
...
User.createUser(u)(conn)
...
}
This is a good habit to have, as it will be clear in your code which methods depends on a connection to the database, and you can easily swap connections. So, in your main app, you would create the real connection:
class RealConncetionConfig extends ConnectionConfig {
val dbName = "xxx_test"
}
but in your test file, you create a test DB config:
class DBEvolutionsTest extends Specification {
class TestDBConfig extends ConnectionConfig {
val dbName = "h2"
}
val testDB = new TestDBConfig()
"The Database" should {
"persist data properly" in {
running(FakeApplication(additionalConfiguration = inMemoryDatabase())) {
User.create(User(Id[Long](1L), "jakob",
"aa",
"aaa",
true,
DateTime.now(),
DateTime.now(),
DateTime.now(),
true))(testDB)
val newUser = User.findBy(Id[Long](1L))
newUser.get.firstName must beEqualTo("jakob")
}
}
}
}
This is the gist of it. Check out the presentation and slides I mentioned, there is a nice way to abstract all of that so that you can loose the (conn) argument that is making this code ugly.
As a side comment, if I were you, I would even abstract the type of DB. So, instead of having the SQL in the User model object, have it in a separate implementation, this way you can easily switch the type of database (use mongodb, dynamo...).
It would just be something like this, extending from the previous code:
trait ConnectionConfig {
def createUser(user: User): Option[User]
}
and in the User model object:
def createUser(user: User): ConnectionConfig => Option[User] = { conn =>
conn.createUser(user)
}
this way, when testing parts of your code depending on the User model, you can make a mock DB where createUser always works and returns the expected result (or always fails...), without even using the in memory database (you would still need tests for the real SQL connection, but you could test other parts of your app):
trait ConnectionConfig {
def createUser(user: User): Option[User] = Some(user)
}

Answer 2

The inMemoryDatabase method is defined like this:
def inMemoryDatabase(
name: String = "default",
options: Map[String, String] = Map.empty[String, String]): Map[String, String]
My guess is that you should pass the xxx_test as the name parameter.

Answer 3

You must define a name other than your default(xxx_test) name for the in memory database. I think the following snippet should work.
FakeApplication(additionalConfiguration = inMemoryDatabase("h2"))
Please see also: https://stackoverflow.com/a/11029324/2153190