Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

165 lines (116 sloc) 4.804 kb
/**
* Copyright (c) 2010 10gen, Inc. <http://10gen.com>
* Copyright (c) 2009, 2010 Novus Partners, Inc. <http://novus.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* For questions and comments about this product, please see the project page at:
*
* http://github.com/mongodb/casbah
*
*/
package com.mongodb.casbah
import com.mongodb.casbah._
import com.mongodb.casbah.commons.test.CasbahMutableSpecification
class CoreWrappersSpec extends CasbahMutableSpecification {
"Casbah behavior between Scala and Java versions of Objects" should {
"provide working .asScala methods on the Java version of the objects" in {
val javaConn = new com.mongodb.Mongo() // Java connection
"Connection objects" in {
val scalaConn = javaConn.asScala
scalaConn.underlying must beEqualTo(javaConn)
}
val javaDb = javaConn.getDB("test")
"DB objects" in {
val scalaDb = javaDb.asScala
scalaDb.underlying must beEqualTo(javaDb)
}
val javaCollection = javaDb.getCollection("test")
"Collection objects" in {
val scalaCollection = javaCollection.asScala
scalaCollection.underlying must beEqualTo(javaCollection)
}
}
"be directly instantiable, with working apply methods" in {
lazy val conn: MongoConnection = MongoConnection()
lazy val db: MongoDB = conn("test")
lazy val coll: MongoCollection = db("collection.in")
"MongoConnection" in {
"direct instantiation" in {
conn.underlying must haveClass[com.mongodb.Mongo]
}
"the apply method works" in {
db.underlying must haveSuperclass[com.mongodb.DB]
}
"MongoDB" in {
"has a working apply method" in {
coll.underlying must haveSuperclass[com.mongodb.DBCollection]
}
}
}
}
"Renaming a collection successfully tracks the rename in MongoCollection" in {
val db = MongoConnection()("casbahTest")
db("collection").drop()
val coll = db("collectoin")
coll.drop()
coll.insert(MongoDBObject("foo" -> "bar"))
coll must beAnInstanceOf[com.mongodb.casbah.MongoCollection]
coll.name must beEqualTo("collectoin")
val newColl = coll.rename("collection")
newColl must beAnInstanceOf[com.mongodb.casbah.MongoCollection]
newColl.name must beEqualTo("collection")
// no mutability in the old collection
coll.name must beEqualTo("collectoin")
// collection should be gone so rename fails
newColl.rename("collection") must throwA[MongoException]
}
}
"findOne operations" should {
val db = MongoConnection()("casbahTest")
"Not fail as reported by Max Afonov in SCALA-11" in {
val coll = db("brand_new_coll_%d".format(System.currentTimeMillis))
coll.insert(MongoDBObject("foo" -> "bar"))
val basicFind = coll.find(MongoDBObject("foo" -> "bar"))
basicFind must haveSize(1)
val findOne = coll.findOne()
findOne must beSome
val findOneMatch = coll.findOne(MongoDBObject("foo" -> "bar"))
findOneMatch must beSome
}
}
"Cursor Operations" should {
import scala.util.Random
val db = MongoConnection()("casbahTest")
val coll = db("test_coll_%d".format(System.currentTimeMillis))
for (i <- 1 to 100)
coll += MongoDBObject("foo" -> "bar", "x" -> Random.nextDouble())
val first5 = coll.find(MongoDBObject("foo" -> "bar")) limit 5
"Behave in chains" in {
//"For loops for idiomatic cleanness" in {
//// todo - add limit, skip etc on COLLECTION for cleaner chains like this?
//val items = for (x <- coll.find(MongoDBObject("foo" -> "bar")) skip 5 limit 20) yield x
//items must haveSize(20)
//// TODO - Matchers that support freaking cursors, etc
//[>items must haveSameElementsAs(first5).not<]
//}
"Chain operations must return the proper *subtype*" in {
val cur = coll.find(MongoDBObject("foo" -> "bar")) skip 5
cur must beAnInstanceOf[MongoCursor]
val cur2 = coll.find(MongoDBObject("foo" -> "bar")) limit 25 skip 12
cur2 must beAnInstanceOf[MongoCursor]
}
}
}
}
// vim: set ts=2 sw=2 sts=2 et:
Jump to Line
Something went wrong with that request. Please try again.