Wie man manuelle Entwicklungen in Tests mit Slick and Play anwendet! 2.4

Question

Ich möchte mein Evolution Script am Anfang jeder Testdatei manuell ausführen. Ich arbeite mit Play! 2.4 und Slick 3.

Gemäß der Dokumentation, scheint der Weg zu gehen zu sein:

Evolutions.applyEvolutions(database) 

aber ich schaffe keine Instanz meiner Datenbank zu erhalten. Im documentationplay.api.db.Databases wird importiert, um eine Datenbankinstanz zu bekommen, aber wenn ich versuche, es zu importieren, ich diesen Fehler: object Databases is not a member of package play.api.db

Wie kann ich eine Instanz meiner Datenbank zu erhalten, um die Evolution Skript ausführen?

Edit: wie in den Kommentaren gefragt, hier ist die gesamte Codequelle den Fehler geben:

import models._ 
import org.scalatest.concurrent.ScalaFutures._ 
import org.scalatest.time.{Seconds, Span} 
import org.scalatestplus.play._ 
import play.api.db.evolutions.Evolutions 
import play.api.db.Databases 

class TestAddressModel extends PlaySpec with OneAppPerSuite { 
    lazy val appBuilder = new GuiceApplicationBuilder() 
    lazy val injector = appBuilder.injector() 
    lazy val dbConfProvider = injector.instanceOf[DatabaseConfigProvider] 

    def beforeAll() = { 
    //val database: Database = ??? 
    //Evolutions.applyEvolutions(database) 
    } 

    "test" must { 
    "test" in { } 
    } 
} 

Answer 1

Schließlich fand ich diese Lösung. Ich spritze mit Guice:

lazy val appBuilder = new GuiceApplicationBuilder() 

lazy val injector = appBuilder.injector() 

lazy val databaseApi = injector.instanceOf[DBApi] //here is the important line 

(Sie haben play.api.db.DBApi zu importieren.)

Und in meinen Tests, das tue ich einfach die folgende (eigentlich verwende ich eine andere Datenbank für meine Tests):

override def beforeAll() = { 
    Evolutions.applyEvolutions(databaseApi.database("default")) 
} 

override def afterAll() = { 
    Evolutions.cleanupEvolutions(databaseApi.database("default")) 
} 

Answer 2

Bedenkt man, dass man 2,4 Wiedergabe verwenden, wo Entwicklungen in einem separaten Modul verschoben wurden, haben Sie fügen Sie Ihren Projektabhängigkeiten evolutions hinzu.

libraryDependencies += evolutions 

• Quelle: Evolutions
• Relevante begehen: Split play-jdbc into three different modules

Answer 3

ich die einfachste Weg finden Tests mit Evolutionen ausführen angewendet wird FakeApplication zu verwenden, und geben Sie die Verbindungsinformationen für den DB manuell .

def withDB[T](code: => T): T = 
    // Create application to run database evolutions 
    running(FakeApplication(additionalConfiguration = Map(
    "db.default.driver" -> "<my-driver-class>", 
    "db.default.url"  -> "<my-db-url>", 
    "db.default.user"  -> "<my-db>", 
    "db.default.password" -> "<my-password>", 
    "evolutionplugin"  -> "enabled" 
    ))) { 
    // Start a db session 
    withSession(code) 
    } 

es wie folgt verwendet:

"test" in withDB { } 

Diese Sie können zum Beispiel Ihre Unit-Tests für die Beschleunigung eines In-Memory-Datenbank zu verwenden.

Sie können auf die DB-Instanz als play.api.db.DB zugreifen, wenn Sie sie benötigen. Sie müssen auch import play.api.Play.current.

Answer 4

Verwenden Sie FakeApplication, um Ihre DB-Konfiguration zu lesen und eine DB-Instanz bereitzustellen.

def withDB[T](code: => T): T = 
    // Create application to run database evolutions 
    running(FakeApplication(additionalConfiguration = Map(
     "evolutionplugin" -> "disabled"))) { 
    import play.api.Play.current 
    val database = play.api.db.DB 
    Evolutions.applyEvolutions(database) 
    withSession(code) 
    Evolutions.cleanupEvolutions(database) 
    } 

es wie folgt verwendet:

"test" in withDB { } 

Answer 5

Um den Zugriff auf play.api.db.Databases haben, können Sie jdbc auf Ihre Abhängigkeiten müssen hinzufügen:

libraryDependencies += jdbc 

Ich hoffe, es hilft ein paar Leute vorbeikommen.

EDIT: Der Code würde dann wie folgt aussehen:

import play.api.db.Databases 

val database = Databases(
    driver = "com.mysql.jdbc.Driver", 
    url = "jdbc:mysql://localhost/test", 
    name = "mydatabase", 
    config = Map(
    "user" -> "test", 
    "password" -> "secret" 
) 
) 

Sie nun eine Instanz der DB hat, und kann Abfragen auf es ausführen:

val statement = database.getConnection().createStatement() 
val resultSet = statement.executeQuery("some_sql_query") 

Sie können mehr von dem sehen docs

EDIT: Tippfehler