couchobject 0.5.0 → 0.6.0

data/spec/database_spec.rb.orig

@@ -0,0 +1,173 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe CouchObject::Database do
+  before(:each) do
+    @server = mock("Couch server")
+    @uri = "http://localhost:8888"
+    @response = mock("Net::HTTP::Response")
+    CouchObject::Server.should_receive(:new).with(@uri).and_return(@server)
+    @response.stub!(:code).and_return(200)
+    @response.stub!(:body).and_return("[\"db1\", \"db2\"]")
+    @document_response = {
+      "_id" => "123BAC", 
+      "_rev" => "946B7D1C", 
+      "attributes" => {
+        "wheels" => 3
+      }
+    }
+  end
+  
+  it "should create a database" do
+    @server.should_receive(:put).with("/foo", "").and_return(@response)
+    CouchObject::Database.create(@uri, "foo")
+  end
+  
+  it "should delete a database" do
+    @server.should_receive(:delete).with("/foo").and_return(@response)
+    CouchObject::Database.delete!(@uri, "foo")
+  end
+  
+  it "should get all databases" do
+    @server.should_receive(:get).with("/_all_dbs").and_return(@response)
+    CouchObject::Database.all_databases(@uri)
+  end
+  
+  it "should return all databases as an array" do
+    @server.should_receive(:get).with("/_all_dbs").and_return(@response)
+    dbs = CouchObject::Database.all_databases(@uri)
+    dbs.should == ["db1", "db2"]
+  end
+  
+  it "should open a connection to the server" do
+    db = CouchObject::Database.new(@uri, "foo")
+    db.server.should == @server
+  end
+  
+  it "should have a name" do
+    db = CouchObject::Database.new(@uri, "foo")
+    db.name.should == "foo"    
+  end
+  
+  it "should lint the database name from slashes with ::open" do
+    db = CouchObject::Database.open("http://localhost:8888/foo")
+    class << db
+      attr_accessor :dbname
+    end
+    db.dbname.should == "foo"
+  end
+  
+  it "should GET" do
+    db = CouchObject::Database.new(@uri, "foo")    
+    @server.should_receive(:get).with("/foo/123").and_return(@response)
+    db.get("123")
+  end
+  
+  it "should POST" do
+    db = CouchObject::Database.new(@uri, "foo")        
+    @server.should_receive(:post).with("/foo/123", "postdata").and_return(@response)
+    db.post("123", "postdata")
+  end
+  
+  it "should PUT" do
+    db = CouchObject::Database.new(@uri, "foo")        
+    @server.should_receive(:put).with("/foo/123", "postdata").and_return(@response)
+    db.put("123", "postdata")
+  end
+  
+  it "should DELETE" do
+    db = CouchObject::Database.new(@uri, "foo")        
+    @server.should_receive(:delete).with("/foo/123").and_return(@response)
+    db.delete("123")
+  end
+  
+  it "should open a new connection from a full uri spec" do
+    proc{ CouchObject::Database.open("http://localhost:8888/foo") }.should_not raise_error
+  end
+  
+  it "should know the database name" do
+    db = CouchObject::Database.new(@uri, "foo")
+    db.name.should == "foo"    
+  end
+  
+  it "should know the full uri" do
+    db = CouchObject::Database.new(@uri, "foo")
+    db.url.should == "http://localhost:8888/foo"    
+  end
+  
+  it "should load a document from id with #[]" do
+    db = CouchObject::Database.new(@uri, "foo")
+    db.should_receive(:get).with("123").twice.and_return(@document_response)
+    proc{ db["123"] }.should_not raise_error
+    db["123"].should == @document_response
+  end
+  
+  it "should accept symbols for #[] too" do
+    db = CouchObject::Database.new(@uri, "foo")
+    db.should_receive(:get).with("foo").and_return(@document_response)
+    db[:foo]
+  end
+  
+  it "should get a document by id" do
+    db = CouchObject::Database.new(@uri, "foo")
+    db.should_receive(:get).with("foo").twice.and_return(@document_response)
+    proc{ db.document("foo") }.should_not raise_error
+    db.document("foo").should == @document_response
+  end
+  
+  it "should get a document by id and revision" do
+    db = CouchObject::Database.new(@uri, "foo")
+    db.should_receive(:get).with("foo?rev=123").twice.and_return(@document_response)
+    proc{ db.document("foo", "123") }.should_not raise_error
+    db.document("foo", "123").should == @document_response
+  end
+  
+  it "should query the view" do
+    db = CouchObject::Database.new(@uri, "foo")
+    CouchObject::View.should_receive(:new).with(db, "myview").and_return(view = mock("View mock"))
+    view.should_receive(:query).and_return(nil)
+    db.views("myview")
+  end
+  
+  it "should get a list of all documents" do
+    db = CouchObject::Database.new(@uri, "foo")
+    resp = mock("response")
+    resp.stub!(:body).and_return(JSON.unparse("rows" => [{"_rev"=>123, "_id"=>"123ABC"}]))
+    resp.stub!(:to_document).and_return(
+      CouchObject::Document.new("rows" => [{"_rev"=>123, "_id"=>"123ABC"}])
+    )
+    db.should_receive(:get).with("_all_docs").and_return(resp)
+    db.all_documents.should == [{"_rev"=>123, "_id"=>"123ABC"}]
+  end
+  
+  it "should store a document" do
+    db = CouchObject::Database.new(@uri, "foo")
+    doc = CouchObject::Document.new({"foo" => "bar"})
+    db.should_receive(:post).with("", JSON.unparse("foo" => "bar"))
+    db.store(doc)
+  end
+  
+  it "should return the rows when filtering" do
+    db = CouchObject::Database.new(@uri, "foo")
+    rowdata = { "_rev"=>1,
+                "_id"=>"1",
+                "value"=> {
+                  "_id"=>"1",
+                  "_rev"=>1,
+                  "foo"=>"bar"
+                }
+              }
+    resp = mock("response")
+    resp.stub!(:body).and_return(JSON.unparse("rows" => [rowdata]))
+    resp.stub!(:parse).and_return(resp)
+    resp.stub!(:to_document).and_return(
+      CouchObject::Document.new("rows" => [rowdata])
+    )
+    db.should_receive(:post).with(
+      "_temp_view", "proc { |doc|\n (doc[\"foo\"] == \"bar\")\n}").and_return(resp)
+    rows = db.filter{|doc| doc["foo"] == "bar"}
+    rows.size.should == 1
+    rows.first["value"]["foo"].should == "bar"
+  end
+  
+  #it "should url encode paths"
+end

data/spec/document_spec.rb

@@ -10,10 +10,14 @@ describe CouchObject::Document do
       "foo" => "bar",
       "baz" => {"quux" => [1,2,3]},
     }
+    
     @response = mock("Response mock")
     @response.stub!(:code).and_return(200)
     @response.stub!(:body).and_return("")
     @response.stub!(:to_document).and_return(CouchObject::Document.new(@test_data))
+    
+    @db.stub!(:post).and_return(@response)
+    @db.stub!(:put).and_return(@response)    
   end
   
   it "should initialize with a bunch of attributes" do
@@ -71,11 +75,25 @@ describe CouchObject::Document do
     doc.save(@db)
   end
   
+  it "should set id and rev on create with POST" do
+    doc = CouchObject::Document.new({"foo" => "bar"})
+    doc.save(@db)
+    doc.id.should == '123'
+    doc.revision.should == '666'    
+  end
+  
   it "should PUT to the database with create" do
-    doc = CouchObject::Document.new(@test_data)    
-    doc.should_receive(:to_json).and_return("JSON")
-    @db.should_receive(:put).with(@test_data["_id"], "JSON").and_return(@response)
+    doc = CouchObject::Document.new({"foo" => "bar", "_id" => "quux"})
+    doc.should_receive(:to_json).with(no_args).and_return("JSON")
+    @db.should_receive(:put).with("quux", "JSON").and_return(@response)
+    doc.save(@db)
+  end
+  
+  it "should set id and rev on save with PUT" do
+    doc = CouchObject::Document.new({"foo" => "bar", "_id" => "quux"})
     doc.save(@db)
+    doc.id.should == '123'
+    doc.revision.should == '666'
   end
   
   it "should send the current revision along when updating a doc" do

data/spec/integration/database_integration_spec.rb

@@ -9,7 +9,7 @@ describe "Database operations" do
   end
   
   it "should create a database " do
-    all_dbs = proc{ CouchObject::Database.all_databases("http://localhost:8888") }
+    all_dbs = proc{ CouchObject::Database.all_databases("http://localhost:5984") }
     all_dbs.call.include?("couchobject_test").should == false
     
     create_test_db.should == {"ok" => true}
@@ -18,12 +18,12 @@ describe "Database operations" do
   end
   
   it "should delete a database" do
-    all_dbs = proc{ CouchObject::Database.all_databases("http://localhost:8888") }
+    all_dbs = proc{ CouchObject::Database.all_databases("http://localhost:5984") }
     all_dbs.call.include?("couchobject_test").should == false
     
     create_test_db.should == {"ok" => true}
     CouchObject::Database.delete!(
-      "http://localhost:8888", 
+      "http://localhost:5984", 
       "couchobject_test"
     ).should == {"ok" => true}
     
@@ -33,7 +33,7 @@ describe "Database operations" do
   it "should open a db connection and know the dbname and uri" do
     db = open_test_db
     db.name.should == "couchobject_test"
-    db.url.should == "http://localhost:8888/couchobject_test"
+    db.url.should == "http://localhost:5984/couchobject_test"
   end
   
   it "should GET a non existing document and return 404" do
@@ -68,24 +68,55 @@ describe "Database operations" do
     response = db.post("", JSON.unparse({"foo" => ["bar", "baz"]}))
     created_doc = response.to_document
     
-    resp = db.delete(created_doc.id)
+    resp = db.delete(created_doc.id, created_doc.revision)
     resp.code.should == 202
     
     resp = db.get(created_doc.id)
     resp.code.should == 404
   end
   
-  it "should filter documents" do
-    db = create_and_open_test_db
-    db.post("", JSON.unparse({"foo" => "bar"}))
-    db.post("", JSON.unparse({"foo" => "baz"}))
-    db.post("", JSON.unparse({"foo" => "qux"}))
-    db.all_documents.size.should == 3
-    results = db.filter do |doc|
-      doc["foo"] =~ /ba/
-    end
-    results.size.should == 2
+end
+
+
+describe "A Database and some UT8" do
+  include IntegrationSpecHelper
+   # Translated form couch_test.js
+   
+   before(:each) do
+     delete_test_db
+   end
+  
+  def do_check_text(db, text)
+    resp = db.post("", JSON.unparse("text" => text))
+    resp.code.should == 201
     
+    r = db.get(resp.to_document.id)
+    r.code.should == 200
+    r.to_document.text.should == text
+  end
+  
+  it "should deal with plain ascii nicely" do
+    db = create_and_open_test_db
+    do_check_text(db, "Ascii: hello")
+  end
+  
+  it "should deal with Russian cyrillic" do
+    db = create_and_open_test_db
+    do_check_text(db, "Russian: На берегу пустынных волн")
+  end
+  
+  it "should deal withn Math expressions" do
+    db = create_and_open_test_db
+    do_check_text(db, "Math: ∮ E⋅da = Q,  n → ∞, ∑ f(i) = ∏ g(i),")
   end
   
+  it "should deal with Greek" do
+    db = create_and_open_test_db
+    do_check_text(db, "Geek: STARGΛ̊TE SG-1")
+  end
+  
+  it "should braille" do
+    db = create_and_open_test_db
+    do_check_text(db, "Braille: ⡌⠁⠧⠑ ⠼⠁⠒  ⡍⠜⠇⠑⠹⠰⠎ ⡣⠕⠌")
+  end
 end

data/spec/integration/integration_helper.rb

@@ -2,15 +2,15 @@ require File.dirname(__FILE__) + '/../spec_helper.rb'
 
 module IntegrationSpecHelper
   def create_test_db(name="couchobject_test")
-    CouchObject::Database.create!("http://localhost:8888", name)
+    CouchObject::Database.create("http://localhost:5984", name)
   end
   
   def open_test_db(name="couchobject_test")
-    CouchObject::Database.open("http://localhost:8888/#{name}")    
+    CouchObject::Database.open("http://localhost:5984/#{name}")    
   end
   
   def delete_test_db(name="couchobject_test")
-    CouchObject::Database.delete!("http://localhost:8888", "couchobject_test")
+    CouchObject::Database.delete!("http://localhost:5984", "couchobject_test")
   end
   
   def create_and_open_test_db(name="couchobject_test")

data/spec/persistable/callback.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/persistable_helper.rb'
+
+describe CouchObject::Persistable, "behaviour related to cloning and copying:" do
+  before(:each) do
+    @db = mock("mock db")
+    
+    content = HTTPResponse.new(JSON.unparse({
+      "_id" => "123BAC", 
+      "_rev" => "946B7D1C", 
+      "class" => WithCallbacks,
+      "created_at" => Time.new,
+      "updated_at" => Time.new,
+      "attributes" => {}
+    }))
+        
+    @empty_response = {}    
+    @ok_response = {"ok" => true}
+    @document_response = CouchObject::Response.new(content)
+  end
+ 
+  it "all callback should be called" do
+    CouchObject::Database.should_receive(:open).exactly(3).and_return(@db)
+    @db.should_receive(:post).and_return(@document_response)
+    @db.should_receive(:put).and_return(@document_response)
+    @db.should_receive(:delete).and_return(@document_response)
+    
+    wc = WithCallbacks.new
+    wc.save
+    wc.save
+    wc.delete
+    
+    wc.calls.should == ["before_save", 
+                        "before_create",
+                        "after_create",
+                        "after_save",
+                        "before_save",
+                        "before_update",
+                        "after_update",
+                        "after_save",
+                        "before_delete",
+                        "after_delete"]
+    
+  end
+end

data/spec/persistable/callback_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/persistable_helper.rb'
+
+describe CouchObject::Persistable, "behaviour related to cloning and copying:" do
+  before(:each) do
+    @db = mock("mock db")
+    
+    content = HTTPResponse.new(JSON.unparse({
+      "_id" => "123BAC", 
+      "_rev" => "946B7D1C", 
+      "class" => WithCallbacks,
+      "created_at" => Time.new,
+      "updated_at" => Time.new,
+      "attributes" => {}
+    }))
+        
+    @empty_response = {}    
+    @ok_response = {"ok" => true}
+    @document_response = CouchObject::Response.new(content)
+  end
+ 
+  it "all callback should be called" do
+    CouchObject::Database.should_receive(:open).exactly(3).and_return(@db)
+    @db.should_receive(:post).and_return(@document_response)
+    @db.should_receive(:put).and_return(@document_response)
+    @db.should_receive(:delete).and_return(@document_response)
+    
+    wc = WithCallbacks.new
+    wc.save
+    wc.save
+    wc.delete
+    
+    wc.calls.should == ["before_save", 
+                        "before_create",
+                        "after_create",
+                        "after_save",
+                        "before_save",
+                        "before_update",
+                        "after_update",
+                        "after_save",
+                        "before_delete",
+                        "after_delete"]
+    
+  end
+end

data/spec/persistable/cloning.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/persistable_helper.rb'
+
+describe CouchObject::Persistable, "behaviour related to cloning and copying:" do
+  before(:each) do
+    @bike = Bike.new
+    
+    @db = mock("mock db")
+    
+    content = HTTPResponse.new(JSON.unparse({
+      "_id" => "123BAC", 
+      "_rev" => "946B7D1C", 
+      "created_at" => Time.new,
+      "updated_at" => Time.new,
+      "attributes" => {
+        "wheels" => 3
+      }
+    }))
+        
+    @empty_response = {}    
+    @ok_response = {"ok" => true}
+    @document_response = CouchObject::Response.new(content)
+  end
+ 
+  it "clones and dupes should not have an ID and a revision number" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:post).
+      with("", @bike.to_json).and_return(@document_response)
+    @bike.set_location = "foo"
+    @bike.save
+    
+    new_bike = @bike.clone
+    second_new_bike = @bike.dup
+    
+    # clone
+    new_bike.id.should_not == @bike.id
+    new_bike.revision.should_not == @bike.revision
+    
+    # dup
+    second_new_bike.id.should_not == @bike.id
+    second_new_bike.revision.should_not == @bike.revision
+  end
+  
+  it "clones and dupes should share the same location" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:post).
+      with("", @bike.to_json).and_return(@document_response)
+    @bike.set_location = "foo"
+    @bike.save
+    
+    new_bike = @bike.clone
+    second_new_bike = @bike.dup
+    
+    # clone
+    new_bike.location.should == @bike.location
+    
+    # dup
+    second_new_bike.location.should == @bike.location
+  end
+  
+  it "clones should share attributes" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:post).
+      with("", @bike.to_json).and_return(@document_response)
+    @bike.set_location = "foo"
+    @bike.save
+    
+    new_bike = @bike.clone
+    second_new_bike = @bike.dup
+    
+    # clone
+    new_bike.wheels.should == @bike.wheels
+    
+    # dup
+    second_new_bike.wheels.should == @bike.wheels
+  end
+
+end