Version 0.5.0

+ Use sbt TestsListener to start/stop cluster around the test task.
  Not before nor after like before. Which also mean you can now use
  any test commands multiple times in the same sbt session.
+ Auto import all redis-plugin keys. No more `import redis.embedded.util.{Architecture, OS}`
  in your `build.sbt`.
+ Simplify the RedisInstance creation for a single server (no Seq needed)

README.md

@@ -1,6 +1,6 @@
 # sbt-redis-plugin [![Build Status](https://travis-ci.org/fmonniot/sbt-redis-plugin.svg?branch=master)](https://travis-ci.org/fmonniot/sbt-redis-plugin)
 
-_Coming Soon_
+Launch redis before your test and bring it down after. No more waiting for it on each test or test suite !
 
 ## Usage
 
@@ -9,22 +9,20 @@ Add this snippet to your `project/plugins.sbt`
 ```scala
 resolvers += Resolver.url("fmonniot", url("https://dl.bintray.com/fmonniot/sbt-plugins"))(Resolver.ivyStylePatterns)
 
-addSbtPlugin("eu.monniot.redis" % "redis-plugin" % "0.1.1")
+addSbtPlugin("eu.monniot.redis" % "redis-plugin" % "0.5.0")
 ```
 
 You can now configure the plugin:
 
 ```scala
-import redis.embedded.util.{Architecture, OS}
-
 // [Optional] Configure a redis binary matrix
 redisBinaries := Seq(
  (("3.0.7", OS.UNIX, Architecture.x86_64), "/path/to/the/correct/redis-server")
 )
 
 // Launch a server and a cluster
 redisInstances := Seq(
- RedisInstance("3.0.7", RedisInstance.SERVER, Seq(7894)),
+ RedisInstance("3.0.7", RedisInstance.SERVER, 7894),
  RedisInstance("3.0.7", RedisInstance.CLUSTER, Seq(7895, 7896, 7897))
 )
 ```

build.sbt

@@ -6,11 +6,11 @@ sbtPlugin := true
 
 scalaVersion in Global := "2.10.6"
 
-version := "0.2.4"
+version := "0.5.0"
 
 resolvers += Resolver.jcenterRepo
 
-libraryDependencies += "eu.monniot.redis" % "embedded-redis" % "1.2.2"
+libraryDependencies += "eu.monniot.redis" % "embedded-redis" % "1.4.0"
 
 // Scripted - sbt plugin tests
 scriptedSettings

sample/build.sbt

@@ -1,5 +1,3 @@
-import redis.embedded.util.{Architecture, OS}
-
 name := "sample-project"
 version := "1.0"
 

sample/project/plugin.sbt

@@ -1,3 +1,4 @@
+resolvers += Resolver.jcenterRepo
 resolvers += Resolver.url("fmonniot", url("https://dl.bintray.com/fmonniot/sbt-plugins"))(Resolver.ivyStylePatterns)
 
-addSbtPlugin("eu.monniot.redis" % "redis-plugin" % "0.1.1")
+addSbtPlugin("eu.monniot.redis" % "redis-plugin" % "0.5.0")

src/main/scala/RedisPlugin.scala

@@ -1,72 +1,32 @@
-import redis.embedded.RedisExecProvider
-import redis.embedded.util.{Architecture, OS}
+import eu.monniot.redis.plugin.{Architecture, OS, RedisKeys, RedisTestsListener}
 import sbt.Keys._
 import sbt._
 
 object RedisPlugin extends AutoPlugin {
 
  import RedisKeys._
 
- override def trigger = allRequirements
+ override def trigger: PluginTrigger = allRequirements
 
  override def requires = plugins.JvmPlugin
 
- val autoImport = RedisKeys
-
- override lazy val projectSettings = defaultSettings
+ object autoImport extends RedisKeys {
+ val RedisInstance = eu.monniot.redis.plugin.RedisInstance
+ val OS = eu.monniot.redis.plugin.OS
+ val Architecture = eu.monniot.redis.plugin.Architecture
+ }
 
- def defaultSettings: Seq[Setting[_]] = Seq(
+ override lazy val projectSettings = Seq(
  redisInstances := Seq.empty,
  redisBinaries := Seq(
  ("3.0.7", OS.MAC_OS_X, Architecture.x86_64) -> "redis-server-3.0.7-darwin",
  ("3.0.7", OS.UNIX, Architecture.x86_64) -> "redis-server-3.0.7"
  ),
 
- startRedis := effectivelyStartRedis(redisBinaries.value, redisInstances.value, streams.value.log),
- stopRedis := effectivelyStopRedis(streams.value.log),
-
- (test in Test) <<= {
- val t = (test in Test).dependsOn(startRedis)
-
- t.andFinally(RedisUtils.stopRedisInstances())
- },
- (testOnly in Test) <<= {
- val t = (testOnly in Test).dependsOn(startRedis)
-
- t.andFinally(RedisUtils.stopRedisInstances())
- }
+ testListeners += new RedisTestsListener(
+ streams.value.log,
+ redisBinaries.value,
+ redisInstances.value
+ )
  )
-
- def buildProvider(redisBinaries: Seq[((String, OS, Architecture), String)]) = {
- redisBinaries
- .map { case ((v, os, arch), path) =>
- (v, os, arch, path)
- }
- .groupBy(_._1)
- .map { case (v, list) =>
- val provider = RedisExecProvider.defaultProvider()
-
- list.foreach { case (_, os, arch, path) =>
- provider.`override`(os, arch, path)
- }
-
- (v, provider)
- }
- }
-
- def effectivelyStartRedis(redisBinaries: Seq[((String, OS, Architecture), String)], redis: Seq[RedisInstance], logger: Logger): Unit = {
- val redisExecProviders = buildProvider(redisBinaries)
-
- logger.debug(s"Redis configuration: ${redisBinaries.toMap}")
- logger.debug(s"Redis servers defined: $redis")
-
- RedisUtils.startRedisCluster(logger, redisExecProviders, redis.filter(m => m.isRedisCluster))
- RedisUtils.startRedisServer(logger, redisExecProviders, redis.filter(m => m.isRedisServer))
- }
-
- def effectivelyStopRedis(logger: Logger): Unit = {
- logger.info("Stopping redis instances")
-
- RedisUtils.stopRedisInstances()
- }
 }

src/main/scala/eu/monniot/redis/plugin/Architecture.scala

@@ -0,0 +1,23 @@
+package eu.monniot.redis.plugin
+
+import redis.embedded.util.{Architecture => jArch}
+
+/**
+ * Correspond to the redis.embedded.util.Architecture enum, but scalaified to be automatically
+ * imported in a sbt config file
+ */
+sealed trait Architecture {
+ def toJava: jArch
+}
+
+object Architecture {
+
+ object x86 extends Architecture {
+ def toJava: jArch = jArch.x86
+ }
+
+ object x86_64 extends Architecture {
+ def toJava: jArch = jArch.x86_64
+ }
+
+}

src/main/scala/eu/monniot/redis/plugin/OS.scala

@@ -0,0 +1,27 @@
+package eu.monniot.redis.plugin
+
+import redis.embedded.util.{OS => jOS}
+
+/**
+ * Correspond to the redis.embedded.util.OS enum, but scalaified to be automatically
+ * imported in a sbt config file
+ */
+sealed trait OS {
+ def toJava: jOS
+}
+
+object OS {
+
+ object WINDOWS extends OS {
+ def toJava: jOS = jOS.WINDOWS
+ }
+
+ object UNIX extends OS {
+ def toJava: jOS = jOS.UNIX
+ }
+
+ object MAC_OS_X extends OS {
+ def toJava: jOS = jOS.MAC_OS_X
+ }
+
+}

src/main/scala/RedisInstance.scala → src/main/scala/eu/monniot/redis/plugin/RedisInstance.scala

@@ -1,3 +1,5 @@
+package eu.monniot.redis.plugin
+
 import java.util
 
 import redis.embedded.PortProvider
@@ -8,6 +10,9 @@ object RedisInstance {
  def apply(version: String, kind: String, ports: Seq[Int]) =
  new RedisInstance(version, kind, new PredefinedPortProvider(scalaToJava(ports)))
 
+ def apply(version: String, kind: String, port: Int) =
+ new RedisInstance(version, kind, new PredefinedPortProvider(scalaToJava(Seq(port))))
+
  private def scalaToJava(list: Seq[Int]): util.List[Integer] = {
  seqAsJavaList(list).asInstanceOf[util.List[Integer]]
  }
@@ -23,7 +28,7 @@ case class RedisInstance(version: String,
 
  import RedisInstance._
 
- def isRedisCluster = kind == CLUSTER
+ def isRedisCluster: Boolean = kind == CLUSTER
 
- def isRedisServer = kind == SERVER
+ def isRedisServer: Boolean = kind == SERVER
 }

src/main/scala/eu/monniot/redis/plugin/RedisKeys.scala

@@ -0,0 +1,20 @@
+package eu.monniot.redis.plugin
+
+import sbt.SettingKey
+
+/**
+ * Created by francois on 27/01/17.
+ */
+trait RedisKeys {
+ lazy val redisBinaries = SettingKey[Seq[((String, OS, Architecture), String)]](
+ "redis-binaries",
+ "A list of redis path associated with a version, os and arch"
+ )
+
+ lazy val redisInstances = SettingKey[Seq[RedisInstance]](
+ "redis-instances",
+ "A list of redis instances to start for tests"
+ )
+}
+
+object RedisKeys extends RedisKeys