Using implicit contexts to remove duplication

gistfile1.scala

/**
 * You can compare this Specification with:
 *  https://github.com/etorreborre/hammersmith/blob/master/mongo-driver/src/test/scala/DirectConnectionSpec.scala
 * 
 * Note that: 
 *  * connectIsMaster returns a function (not a method anymore)
 *  * distinctValue returns 'ok' (a MatchResult) instead of 'success' (a Result)
 */
class DirectConnectionSpec extends Specification with Logging { def is =

  "The MongoDB Direct Connection"                          ^
    "Connect correctly and grab isMaster, then disconnect" ! connectIsMaster^
    "Iterate a simple cursor correctly"                    ! iterateSimpleCursor^
    "Iterate a complex (iteratee) cursor correctly"        ! iterateComplexCursor^
    "Correctly calculate values for 'distinct'"            ! distinctValue^
                                                           p^
  "The write behavior"                                     ^
    "Support 'blind' (NoOp) writes"                        ! noopInsert^
    "Support inserts with no (default) write concern"      ! insertWithDefaultWriteConcern^
    "Support inserts with implicit safe write concern"     ! insertWithSafeImplicitWriteConcern^
                                                           end
    

  implicit object mongo extends mongoConn

  trait mongoConn extends AroundOutside[MongoConnection] {

    var conn = MongoConnection()

    def around[T <% Result](t: =>T) = {
      conn.connected_? must eventually(beTrue)
      t
      /*conn.close()
      conn.connected_? must eventually(beFalse)*/
    }

    def outside: MongoConnection = { conn = MongoConnection()
                                     conn }
  }

  def connectIsMaster = (conn: MongoConnection) => {
    conn.databaseNames({ dbs: Seq[String] => dbs.foreach(log.trace("DB: %s", _)) })

    conn("test").collectionNames({ colls: Seq[String] => colls.foreach(log.trace("Collection: %s", _)) })

    conn.connected_? must eventually(beTrue)

  }

  // todo - this relies heavily on whats on my local workstation; needs to be generic
  def iterateSimpleCursor = (conn: MongoConnection) => {
    var x = 0
    conn("bookstore").find("inventory")(Document.empty, Document.empty)((cursor: Cursor) => {
      for (doc <- cursor) {
        x += 1
      }
    })

    x must eventually (be_==(336))
  }

  def iterateComplexCursor = (conn: MongoConnection) => {
    var x = 0
    conn("bookstore").find("inventory")(Document.empty, Document.empty)((cursor: Cursor) => {
      def next(op: Cursor.IterState): Cursor.IterCmd = op match {
        case Cursor.Entry(doc) => {
          x += 1
          if (x < 100) Cursor.Next(next) else Cursor.Done
        }
        case Cursor.Empty => {
          if (x < 100) Cursor.NextBatch(next) else Cursor.Done
        }
        case Cursor.EOF => {
          Cursor.Done
        }
      }
      Cursor.iterate(cursor)(next)
    })

    x must eventually(5, 5.seconds) (be_==(100))
  }

  def distinctValue = (conn: MongoConnection) => {
    conn("bookstore")("inventory").distinct("author")((values: Seq[Any]) => {
      for (item <- values) {
        log.trace("Got a value: %s", item.asInstanceOf[String])
      }
    })

    ok
  }

  def noopInsert = (conn: MongoConnection) => {
    val mongo = conn("testHammersmith")("test_insert")
    mongo.dropCollection()(success => {
      log.info("Dropped collection... Success? " + success)
    })
    mongo.insert(Document("foo" -> "bar", "bar" -> "baz")){}
    // TODO - Implement 'count'
    var doc: BSONDocument = null
    mongo.findOne(Document("foo" -> "bar"))((_doc: BSONDocument) => {
      doc = _doc 
    })
    doc must not (beNull.eventually)
    doc must eventually (havePairs("foo" -> "bar", "bar" -> "baz"))
  }

  def insertWithDefaultWriteConcern = (conn: MongoConnection) => {
    val mongo = conn("testHammersmith")("test_insert")
    mongo.dropCollection()(success => {
      log.info("Dropped collection... Success? " + success)
    })
    var id: AnyRef = null
    mongo.insert(Document("foo" -> "bar", "bar" -> "baz"))((oid: Option[AnyRef], res: WriteResult) => {
      id = oid.getOrElse(null)
    })
    // TODO - Implement 'count'
    var doc: BSONDocument = null
    mongo.findOne(Document("foo" -> "bar"))((_doc: BSONDocument) => {
      doc = _doc 
    })
    doc must not (beNull.eventually)
    doc must eventually (havePairs("foo" -> "bar", "bar" -> "baz"))
  }

  def insertWithSafeImplicitWriteConcern = (conn: MongoConnection) => {
    val mongo = conn("testHammersmith")("test_insert")
    implicit val safeWrite = WriteConcern.Safe
    mongo.dropCollection()(success => {
      log.info("Dropped collection... Success? " + success)
    })
    var id: Option[AnyRef] = null
    var ok: Option[Boolean] = None

    val handler = RequestFutures.write((result: Either[Throwable, (Option[AnyRef], WriteResult)]) => { 
      result match {
        case Right((oid, wr)) => {
          ok = Some(true)
          id = oid        }
        case Left(t) => {
          ok = Some(false)
          log.error(t, "Command Failed.")
        }
      }
    })
    mongo.insert(Document("foo" -> "bar", "bar" -> "baz"))(handler)
    ok must eventually { beSome(true) }
    id must not (beNull.eventually)
    // TODO - Implement 'count'
    var doc: BSONDocument = null
    mongo.findOne(Document("foo" -> "bar"))((_doc: BSONDocument) => {
      doc = _doc 
    })
    doc must not (beNull.eventually)
    doc must eventually (havePairs("foo" -> "bar", "bar" -> "baz"))
  }

/*    "Support findAndModify" in {
      val mongo = conn("testHammersmith")("test_findModify")
      mongo.insert(Document("x" -> 1), Document("x" -> 2), Document("x" -> 3))

    }*/
}