LocalDbSpec.scala - scouchdb - Scala CouchDB client

Source path: svn/ trunk/ src/ test/ scala/ couch/ json/ LocalDbSpec.scala

‹r6

r23

package couch.json

import org.scalatest.Spec
import org.scalatest.BeforeAndAfter
import org.scalatest.FeatureSuite
import org.scalatest.matchers.ShouldMatchers

import org.apache.http._
import org.apache.http.client._

import dispatch.json._
import dispatch.json.Js._
import couch.db._
import couch.db.Options._
import couch.db.BulkDocument._

import TestBeans._

class LocalDbSpec extends Spec with ShouldMatchers with BeforeAndAfter {
  
  val couch = Couch("127.0.0.1")
  val test = Db("test_db")
  
  override def beforeAll {
    couch(test.create)
    println(couch(test as_str))
//    assert(status == 201)
    println("** created database")
  }
  
  override def afterAll {
    couch(test.delete)
//    assert(status == 200)
    println("** destroyed database")
  }
  
  describe("Initially the db should not have any document") {
    it("design document count should equal 0") {
      couch(test all_docs)
       .filter(_.startsWith("_design") == true)
       .size should equal (0)
    }
    it("non design document count should equal 0") {
      couch(test all_docs)
       .filter(_.startsWith("_design") == false)
       .size should equal (0)
    }
  }
  
  describe("Create a design document, query by id and update") {
    val d = DesignDocument("foo", null, Map[String, View]())
    val mapfn = "function(doc) { emit(doc.value,doc); }"
    val vi = new View(mapfn, null)
    var revision: String = null
    var nir: (String, String) = null
    val de = Doc(test, d._id)
    
    it("creation should be successful") {
      d._id should equal("_design/foo")
      couch(de add d)
      val ir = couch(de ># %(Id._id, Id._rev))
      ir._1 should equal(d._id)
    }
    it("design document count should equal 1") {
      couch(test all_docs)
       .filter(_.startsWith("_design") == true)
       .size should equal (1)
    }
    it("query by id should fetch the document") {
      val ir = couch(test by_id d._id)
      ir._1 should equal(d._id)
      val sh = couch(test by_id(d._id, classOf[DesignDocument]))
      sh._1 should equal(d._id)
      sh._2 should equal(ir._2)
      sh._3._id should equal(sh._1)
      sh._3._rev should equal(sh._2)
      revision = sh._2
    }
    it("update the document with a view") {
      val doc = DesignDocument(d._id, revision, Map("map" -> vi))
      couch(de update(doc, revision))
      nir = couch(de ># %(Id._id, Id._rev))
      nir._1 should equal(d._id)
      nir._2 should not equal(revision)
    }
    it("design document count should still equal 1") {
      couch(test all_docs)
       .filter(_.startsWith("_design") == true)
       .size should equal (1)
    }
    it("re-query by id should fetch the updated document") {
      val ir = couch(test by_id d._id)
      ir._1 should equal(d._id)
      val sh = couch(test by_id(d._id, classOf[DesignDocument]))
      sh._1 should equal(d._id)
      sh._2 should equal(nir._2)
      sh._3._id should equal(sh._1)
      sh._3._rev should equal(sh._2)
    }
    it("update with incorrect revision should give 409 (conflict in update)") {
      val doc = DesignDocument(d._id, revision, Map("map" -> vi)) // using same revision as before
      intercept[dispatch.StatusCode] {
        couch(de update(doc, revision))
      }
      try {
        couch(de update(doc, revision))
      }
      catch {
        case e: dispatch.StatusCode =>
          e.code should equal(409)
      }
    }
    it("update with null revision and same matching id should give 409 (conflict in update)") {
      val doc = DesignDocument(d._id, null, Map("map" -> vi)) // using null revision 
      try {
        couch(de update(doc, revision))
      }
      catch {
        case e: dispatch.StatusCode =>
          e.code should equal(409)
      }
    }
  }
  
  import TestBeans._
  
  describe("Create a document, query by id and update") {
    
    val s = Shop("Shoppers Stop", "refrigerator", 12500)
    val d = Doc(test, "sstop")
    var ir:(String, String) = null
    var ii:(String, String) = null
    var nir:(String, String) = null
    
    it("creation should be successful") {
      couch(d add s)
      ir = couch(d ># %(Id._id, Id._rev))
      ir._1 should equal("sstop")
    }
    it("query by id should fetch a row") {
      ii = couch(test by_id ir._1)
      ii._1 should equal("sstop")
    }
    it("query by id and class should construct an object of that class") {
      val sh = couch(test by_id(ir._1, classOf[Shop]))
      sh._1 should equal(ii._1)
      sh._2 should equal(ii._2)
      sh._3.toString should equal(s.toString)
    }
    it("query by id, rev and class should construct an object of that class") {
      val st = couch(test by_id(ir._1, ir._2, classOf[Shop]))
      st._1 should equal(ir._1)
      st._2 should equal(ir._2)
      st._3.toString should equal(s.toString)
    }
    it("updating a document should keep the id same and change the revision") {
      val t = Shop("Shoppers Stop", "television", 22500)
      couch(d update(t, ir._2))
      nir = couch(d ># %(Id._id, Id._rev))
      nir._1 should equal(ir._1)
      nir._2 should not equal(ir._2)
    }
    it("subsequent query by id and class should give changed value for the object's fields") {
      val sh = couch(test by_id(ir._1, classOf[Shop]))
      sh._1 should equal(ii._1)
      sh._2 should equal(nir._2)
      sh._3.item should equal("television")
      sh._3.price should equal(22500)
    }
  }
  
  describe("Create a document without explicit id, query by id and update") {
    
    val s = Shop("Capital Electronics", "air-conditioner", 32500)
    var ir:(String, String) = null
    var ii:(String, String) = null
    var nir:(String, String) = null
    var d: Doc = null
    
    it("creation should be successful") {
      val sz = couch(test all_docs).size
      ir = couch(test doc(s))
      d = Doc(test, ir._1)
      ir._1 should not equal(null)
      ir._2 should not equal(null)
      couch(test all_docs).size should equal(sz + 1)
    }
    it("query by id should fetch a row") {
      ii = couch(test by_id ir._1)
      ii._1 should equal(ir._1)
    }
    it("query by id and class should construct an object of that class") {
      val sh = couch(test by_id(ir._1, classOf[Shop]))
      sh._1 should equal(ii._1)
      sh._2 should equal(ii._2)
      sh._3.toString should equal(s.toString)
      sh._3.store should equal("Capital Electronics")
      sh._3.item should equal("air-conditioner")
      sh._3.price should equal(32500)
    }
    it("query by id, rev and class should construct an object of that class") {
      val st = couch(test by_id(ir._1, ir._2, classOf[Shop]))
      st._1 should equal(ir._1)
      st._2 should equal(ir._2)
      st._3.toString should equal(s.toString)
      st._3.store should equal("Capital Electronics")
      st._3.item should equal("air-conditioner")
      st._3.price should equal(32500)
    }
    it("updating a document should keep the id same and change the revision") {
      val t = Shop("Capital Electronics", "air-conditioner", 62500)
      couch(d update(t, ir._2))
      nir = couch(d ># %(Id._id, Id._rev))
      nir._1 should equal(ir._1)
      nir._2 should not equal(ir._2)
    }
    it("subsequent query by id and class should give changed value for the object's fields") {
      val sh = couch(test by_id(ir._1, classOf[Shop]))
      sh._1 should equal(ii._1)
      sh._2 should equal(nir._2)
      sh._3.item should equal("air-conditioner")
      sh._3.price should equal(62500)
    }
  }
  
  describe("Create a complex document from an object having aggregate data member and query by id") {
    
    val addr1 = new Address("10 Market Street", "San Francisco, CA", "94111")
    val addr2 = new Address("3300 Tamarac Drive", "Denver, CO", "98301")
    val c1 = Contact("Debasish Ghosh", Map("primary" -> addr1, "secondary" -> addr2))
    
    val d = Doc(test, "contact_1")
    var ir:(String, String) = null
    var ii:(String, String) = null
    
    it("creation should be successful") {
      couch(d add c1)
      ir = couch(d ># %(Id._id, Id._rev))
      ir._1 should equal("contact_1")
      println(couch(d apply((c, res, e) => 
               (c, res.getStatusLine.getReasonPhrase, scala.io.Source.fromInputStream(e.get.getContent).mkString))))
    }
    it("query by id should fetch a row") {
      ii = couch(test by_id ir._1)
      ii._1 should equal("contact_1")
    }
    it("query by id and class should construct an object of that class") {
      val sh = couch(test by_id(ir._1, classOf[Contact]))
      sh._1 should equal(ii._1)
      sh._2 should equal(ii._2)
      sh._3.toString should equal(c1.toString)
    }
  }
  
  describe("Create a document from an object whose json property should be diff from bean property and query by id") {
    
    val book = Book(123, "Programming Scala", "1022-09-98762")
    
    val d = Doc(test, "prog_scala")
    var ir:(String, String) = null
    var ii:(String, String) = null
    
    it("creation should be successful") {
      couch(d add book)
      ir = couch(d ># %(Id._id, Id._rev))
      ir._1 should equal("prog_scala")
      println(couch(d apply((c, res, e) => 
               (c, res.getStatusLine.getReasonPhrase, scala.io.Source.fromInputStream(e.get.getContent).mkString))))
    }
    it("query by id should fetch a row") {
      ii = couch(test by_id ir._1)
      ii._1 should equal("prog_scala")
    }
    it("query by id and class should construct an object of that class") {
      val sh = couch(test by_id(ir._1, classOf[Book]))
      sh._1 should equal(ii._1)
      sh._2 should equal(ii._2)
      sh._3.toString should equal(book.toString)
    }
  }
  
  describe("create records") {
    it("should create new records") {
      val sz = couch(test all_docs).size
      val ir1 = couch(test doc Js("""{"item":"banana","prices":{"Fresh Mart":1.99,"Price Max":0.79,"Banana Montana":4.22}}"""))
      val ir2 = couch(test doc Js("""{"item":"apple","prices":{"Fresh Mart":1.59,"Price Max":5.99,"Apples Express":0.79}}"""))
      val ir3 = couch(test doc Js("""{"item":"orange","prices":{"Fresh Mart":1.99,"Price Max":3.19,"Citrus Circus":1.09}}"""))
      couch(test all_docs).size should equal(sz + 3)
      println(ir1)
      println(ir2)
      println(ir3)
    }
  }
  
  describe("Create another design document, query by id and update") {
    val d = DesignDocument("lunch", null, Map[String, View]())
    val mapfn = "function(doc) {\n    var store, price, key;\n    if (doc.item && doc.prices) {\n        for (store in doc.prices) {\n            price = doc.prices[store];\n            key = [doc.item, price];\n            emit(key, store);\n    }\n  }\n}\n"
    val vi = new View(mapfn, null)
    var revision: String = null
    var nir: (String, String) = null
    val de = Doc(test, d._id)
    
    it("creation should be successful") {
      d._id should equal("_design/lunch")
      couch(de add d)
      val ir = couch(de ># %(Id._id, Id._rev))
      ir._1 should equal(d._id)
    }
    it("design document count should equal 2") {
      couch(test all_docs)
       .filter(_.startsWith("_design") == true)
       .size should equal (2)
    }
    it("query by id should fetch the document") {
      val ir = couch(test by_id d._id)
      ir._1 should equal(d._id)
      val sh = couch(test by_id(d._id, classOf[DesignDocument]))
      sh._1 should equal(d._id)
      sh._2 should equal(ir._2)
      sh._3._id should equal(sh._1)
      sh._3._rev should equal(sh._2)
      revision = sh._2
    }
    it("update the document with a view") {
      val doc = DesignDocument(d._id, revision, Map("least_cost_lunch" -> vi))
      couch(de update(doc, revision))
      nir = couch(de ># %(Id._id, Id._rev))
      nir._1 should equal(d._id)
      nir._2 should not equal(revision)
    }
    it("design document count should still equal 2") {
      couch(test all_docs)
       .filter(_.startsWith("_design") == true)
       .size should equal (2)
    }
    it("re-query by id should fetch the updated document") {
      val ir = couch(test by_id d._id)
      ir._1 should equal(d._id)
      val sh = couch(test by_id(d._id, classOf[DesignDocument]))
      sh._1 should equal(d._id)
      sh._2 should equal(nir._2)
      sh._3._id should equal(sh._1)
      sh._3._rev should equal(sh._2)
    }
    it("get all design docs") {
      val idrev = couch(test all_docs).filter(_.startsWith("_design") == true)
      idrev foreach {ir =>
        val d = Doc(test, ir)
        println(couch(d apply((c, res, e) => 
               (scala.io.Source.fromInputStream(e.get.getContent).mkString))))
      }
    }
  }
  
  describe("update design document _lunch adding another view big_lunch having map as well as reduce") {
    val mf = 
        """function(doc) {
             var store, price;
             if (doc.item && doc.prices) {
               for (store in doc.prices) {
                 price = doc.prices[store];
                 emit(doc.item, price);
               }
             }
           }"""
      
    val rf = 
      """function(key, values, rereduce) {
           return(sum(values))
         }"""

    val vi = new View(mf, rf)
    
    it("should get design document with id = _design/lunch") {
      val ir = couch(test by_id("_design/lunch", classOf[DesignDocument]))
      ir._1 should equal("_design/lunch")
      val d = ir._3
      val de = Doc(test, ir._1)
      val doc = DesignDocument(ir._1, ir._2, ir._3.views + ("big_lunch" -> vi))
      
      couch(de update(doc, ir._2))
      
      val nir = couch(de ># %(Id._id, Id._rev))
      nir._1 should equal(ir._1)
      nir._2 should not equal(ir._2)
      
      val new_ir = couch(test by_id("_design/lunch", classOf[DesignDocument]))
      new_ir._3.views.keySet.size should equal(2)
    }
  }
  
  describe("fetch from view least_cost_lunch") {
    it("should fetch 9 rows from view least_cost_lunch") {
      val ls1 = couch(test view(
        Views builder("lunch/least_cost_lunch") build))
      ls1.size should equal(9)
    }
    it("should fetch 1 row for view with option") {
      val ls2 = couch(test view(
      Views.builder("lunch/least_cost_lunch")
           .options(optionBuilder key(List("apple", 0.79)) limit(10) build)
           .build))
      ls2.size should equal(1)
    }
    it("should fetch 2 rows for view with key specification") {
      val ls3 = couch(test view(
       Views.builder("lunch/least_cost_lunch")
         .keys(List(List("apple", 0.79), List("banana", 0.79)))
         .build))
      ls3.size should equal(2)
    }
    it("should fetch 2 rows for view with option and key specification") {
      val ls4 = couch(test view(
       Views.builder("lunch/least_cost_lunch")
         .options(optionBuilder descending(true) limit(10) build)
         .keys(List(List("apple", 0.79), List("banana", 0.79)))
         .build))
      ls4.size should equal(2)
    }
  }
  
  describe("fetch from view big_lunch") {
    it("should fetch 1 row from view big_lunch") {
      val ls1 = couch(test view(
        Views builder("lunch/big_lunch") build))
      ls1.size should equal(1)
    }
    it("should also fetch 1 row from view big_lunch") {
      val ls1 = couch(test view(
        Views.builder("lunch/big_lunch").options(optionBuilder group(true) limit(10) build).build))
      ls1.size should equal(3)
    }
  }
  
  describe("fetch from temporary views") {
    it("should fetch 3 rows with group option and 1 row without group option") {
      val mf = 
        """function(doc) {
             var store, price;
             if (doc.item && doc.prices) {
               for (store in doc.prices) {
                 price = doc.prices[store];
                 emit(doc.item, price);
               }
             }
           }"""
      
      val rf = 
        """function(key, values, rereduce) {
             return(sum(values))
           }"""
      
      // with grouping
      val aq = 
        Views.adhocBuilder(View(mf, rf))
             .options(optionBuilder group(true) build)
             .build
      val s = couch(
        test adhocView(aq))
      s.size should equal(3)
      
      // without grouping
      val aq_1 = 
        Views.adhocBuilder(View(mf, rf))
             .build
      val s_1 = couch(
        test adhocView(aq_1))
      s_1.size should equal(1)
    }
  }
  
  describe("all_docs with view query options") {
    it("should fetch all docs") {
      val ls1 = couch(test view(
        Views builder("_all_docs") build))
      println(ls1)
      ls1.size should equal(9)
    }
    it("include_docs should also fetch documents as well") {
      val ls1 = couch(test view(
        Views.builder("_all_docs").options(optionBuilder includeDocs(true) build).build))
      ls1.map { j =>
        val d = ('doc ? obj)
        val d(d_) = j
        d_
      }.size should equal(9)
    }
  }
  
  describe("create a document and make an attachment") {
    val att = "The quick brown fox jumps over the lazy dog."
    
    val s = Shop("Sears", "refrigerator", 12500)
    val d = Doc(test, "sears")
    var ir:(String, String) = null
    var ii:(String, String) = null
    
    it("document creation should be successful") {
      couch(d add s)
      ir = couch(d ># %(Id._id, Id._rev))
      ir._1 should equal("sears")
    }
    it("query by id should fetch a row") {
      ii = couch(test by_id ir._1)
      ii._1 should equal("sears")
    }
    it("sticking an attachment should be successful") {
      couch(d attach("foo", "text/plain", att.getBytes, Some(ii._2)))
    }
    it("retrieving the attachment should equal to att") {
      val air = couch(d ># %(Id._id, Id._rev))
      air._1 should equal("sears")
      couch(d.getAttachment("foo") as_str) should equal(att)
    }
  }
  
  describe("create an attachment on a non-existing document") {
    val att = "The quick brown fox jumps over the lazy dog."
    val new_att = "Hedge hog and a sly fox"
    
    val s = Shop("cc", "refrigerator", 12500)
    val d = Doc(test, "cc")
    var ir:(String, String) = null
    var ii:(String, String) = null
    var nir:(String, String) = null
    var air:(String, String) = null
    
    it("d has not yet been added, still attachment should go through and crate a document as well") {
      couch(d attach("foo", "text/plain", att.getBytes, None))
      air = couch(d ># %(Id._id, Id._rev))
      air._1 should equal("cc")
      couch(d.getAttachment("foo") as_str) should equal(att)
    }
    it("query by id should fetch a row") {
      ii = couch(test by_id "cc")
      ii._1 should equal("cc")
    }
    it("change an attachment") {
      couch(d attach("foo", "text/plain", new_att.getBytes, Some(ii._2)))
      air = couch(d ># %(Id._id, Id._rev))
      air._1 should equal("cc")
      couch(d.getAttachment("foo") as_str) should equal(new_att)
    }
    it("add another attachment") {
      couch(d attach("bar", "text/plain", att.getBytes, Some(air._2)))
      air = couch(d ># %(Id._id, Id._rev))
      air._1 should equal("cc")
      couch(d.getAttachment("foo") as_str) should equal(new_att)
      couch(d.getAttachment("bar") as_str) should equal(att)
    }
    it("delete new_att") {
      couch(d deleteAttachment("foo", air._2))
      air = couch(d ># %(Id._id, Id._rev))
      air._1 should equal("cc")
      couch(d.getAttachment("bar") as_str) should equal(att)
      couch(d.getAttachment("foo").apply((c, res, e) => c)) should equal(404)
    }
  }
  
  describe("bulk updates of documents") {
    it("should create 3 documents with 1 post") {
      val cnt = couch(test all_docs).filter(_.startsWith("_design") == false).size 
      
      val s1 = Shop("cc", "refrigerator", 12500)
      val s2 = Shop("best buy", "macpro", 1500)
      val a1 = Address("Survey Park", "Kolkata", "700075")
      val a2 = Address("Salt Lake", "Kolkata", "700091")
      
      couch(test docs(List(s1, s2, a1, a2), false)).size should equal(4)
      couch(test all_docs).filter(_.startsWith("_design") == false).size should equal(cnt + 4)
    }
    it("should insert 2 new documents, update 1 existing document and delete 1 - all in 1 post") {
      val sz = couch(test all_docs).filter(_.startsWith("_design") == false).size
      val s = Shop("Shoppers Stop", "refrigerator", 12500)
      val d = Doc(test, "ss")
      
      val t = Address("Monroe Street", "Denver, CO", "987651")
      val ad = Doc(test, "add1")
      
      var ir:(String, String) = null
      var ir1:(String, String) = null
    
      couch(d add s)
      ir = couch(d ># %(Id._id, Id._rev))
      ir._1 should equal("ss")
      
      couch(ad add t)
      ir1 = couch(ad ># %(Id._id, Id._rev))
      ir1._1 should equal("add1")
      
      val s1 = Shop("cc", "refrigerator", 12500)
      val s2 = Shop("best buy", "macpro", 1500)
      val a1 = Address("Survey Park", "Kolkata", "700075")
      
      val d1 = bulkBuilder(Some(s1)).id("a").build 
      val d2 = bulkBuilder(Some(s2)).id("b").build
      val d3 = bulkBuilder(Some(s)).id("ss").rev(ir._2).build
      val d4 = bulkBuilder(None).id("add1").rev(ir1._2).deleted(true).build
      couch(test bulkDocs(List(d1, d2, d3, d4), false)).size should equal(4)
      couch(test all_docs).filter(_.startsWith("_design") == false).size should equal(sz + 3)
    }
  }
}

Show details Hide details

Change log

r8 by ghosh.debasish on May 8, 2009 Diff

Checkin for release 0.2 :
- added bulk document feature
- enhanced views to incorporate temporary
views
- added attachment support
- enhanced test cases

Go to:

Project members, sign in to write a code review

Older revisions

r6 by ghosh.debasish on May 3, 2009 Diff

[No log message]

All revisions of this file

File info

Size: 21208 bytes, 603 lines

View raw file