jchris-couchrest 0.9.12 → 0.12.2

data/spec/couchrest/core/couchrest_spec.rb

@@ -46,48 +46,48 @@ describe CouchRest do
     it "should parse just a dbname" do
       db = CouchRest.parse "my-db"
       db[:database].should == "my-db"
-      db[:host].should == "localhost:5984"
+      db[:host].should == "127.0.0.1:5984"
     end
     it "should parse a host and db" do
-      db = CouchRest.parse "localhost/my-db"
+      db = CouchRest.parse "127.0.0.1/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "localhost"
+      db[:host].should == "127.0.0.1"
     end
     it "should parse a host and db with http" do
-      db = CouchRest.parse "http://localhost/my-db"
+      db = CouchRest.parse "http://127.0.0.1/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "localhost"
+      db[:host].should == "127.0.0.1"
     end
     it "should parse a host with a port and db" do
-      db = CouchRest.parse "localhost:5555/my-db"
+      db = CouchRest.parse "127.0.0.1:5555/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "localhost:5555"
+      db[:host].should == "127.0.0.1:5555"
     end
     it "should parse a host with a port and db with http" do
-      db = CouchRest.parse "http://localhost:5555/my-db"
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "localhost:5555"
+      db[:host].should == "127.0.0.1:5555"
     end
     it "should parse just a host" do
-      db = CouchRest.parse "http://localhost:5555/"
+      db = CouchRest.parse "http://127.0.0.1:5555/"
       db[:database].should be_nil
-      db[:host].should == "localhost:5555"
+      db[:host].should == "127.0.0.1:5555"
     end
     it "should parse just a host no slash" do
-      db = CouchRest.parse "http://localhost:5555"
-      db[:host].should == "localhost:5555"
+      db = CouchRest.parse "http://127.0.0.1:5555"
+      db[:host].should == "127.0.0.1:5555"
       db[:database].should be_nil
     end
     it "should get docid" do
-      db = CouchRest.parse "localhost:5555/my-db/my-doc"
+      db = CouchRest.parse "127.0.0.1:5555/my-db/my-doc"
       db[:database].should == "my-db"
-      db[:host].should == "localhost:5555"
+      db[:host].should == "127.0.0.1:5555"
       db[:doc].should == "my-doc"
     end
     it "should get docid with http" do
-      db = CouchRest.parse "http://localhost:5555/my-db/my-doc"
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db/my-doc"
       db[:database].should == "my-db"
-      db[:host].should == "localhost:5555"
+      db[:host].should == "127.0.0.1:5555"
       db[:doc].should == "my-doc"
     end
 
@@ -137,24 +137,24 @@ describe CouchRest do
 
   describe "easy initializing a database adapter" do
     it "should be possible without an explicit CouchRest instantiation" do
-      db = CouchRest.database "http://localhost:5984/couchrest-test"
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
       db.should be_an_instance_of(CouchRest::Database)
-      db.host.should == "localhost:5984"
+      db.host.should == "127.0.0.1:5984"
     end
     # TODO add https support (need test environment...)
     # it "should work with https" # do
-    #      db = CouchRest.database "https://localhost:5984/couchrest-test"
-    #      db.host.should == "https://localhost:5984"
+    #      db = CouchRest.database "https://127.0.0.1:5984/couchrest-test"
+    #      db.host.should == "https://127.0.0.1:5984"
     #    end
     it "should not create the database automatically" do
-      db = CouchRest.database "http://localhost:5984/couchrest-test"
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
       lambda{db.info}.should raise_error(RestClient::ResourceNotFound)      
     end
   end
 
   describe "ensuring the db exists" do
     it "should be super easy" do
-      db = CouchRest.database! "http://localhost:5984/couchrest-test-2"
+      db = CouchRest.database! "http://127.0.0.1:5984/couchrest-test-2"
       db.name.should == 'couchrest-test-2'
       db.info["db_name"].should == 'couchrest-test-2'
     end
@@ -188,4 +188,14 @@ describe CouchRest do
     end
   end
 
+  describe "using a proxy for RestClient connections" do
+    it "should set proxy url for RestClient" do
+      CouchRest.proxy 'http://localhost:8888/'
+      proxy_uri = URI.parse(RestClient.proxy)
+      proxy_uri.host.should eql( 'localhost' )
+      proxy_uri.port.should eql( 8888 )
+      CouchRest.proxy nil
+    end
+  end
+
 end

data/spec/couchrest/core/database_spec.rb

@@ -29,8 +29,8 @@ describe CouchRest::Database do
       rs = @db.temp_view(@temp_view, :key => "wild")
       rs['rows'].length.should == 1
     end
-    it "should work with a count" do
-      rs = @db.temp_view(@temp_view, :count => 1)
+    it "should work with a limit" do
+      rs = @db.temp_view(@temp_view, :limit => 1)
       rs['rows'].length.should == 1
     end
     it "should work with multi-keys" do
@@ -109,8 +109,8 @@ describe CouchRest::Database do
       rs = @db.view('first/test', :key => "wild")
       rs['rows'].length.should == 1
     end
-    it "should work with a count" do
-      rs = @db.view('first/test', :count => 1)
+    it "should work with a limit" do
+      rs = @db.view('first/test', :limit => 1)
       rs['rows'].length.should == 1
     end
     it "should work with multi-keys" do
@@ -159,7 +159,7 @@ describe CouchRest::Database do
       
       docs = [{'key' => 'value'}, {'_id' => 'totally-uniq'}]
       id_docs = [{'key' => 'value', '_id' => 'asdf6sgadkfhgsdfusdf'}, {'_id' => 'totally-uniq'}]
-      CouchRest.should_receive(:post).with("http://localhost:5984/couchrest-test/_bulk_docs", {:docs => id_docs})
+      CouchRest.should_receive(:post).with("http://127.0.0.1:5984/couchrest-test/_bulk_docs", {:docs => id_docs})
       
       @db.bulk_save(docs)
     end
@@ -190,6 +190,16 @@ describe CouchRest::Database do
         @db.get('twoB')
       end.should raise_error(RestClient::ResourceNotFound)
     end
+
+    it "should empty the bulk save cache if no documents are given" do
+      @db.save({"_id" => "bulk_cache_1", "val" => "test"}, true)
+      lambda do
+        @db.get('bulk_cache_1')
+      end.should raise_error(RestClient::ResourceNotFound)
+      @db.bulk_save
+      @db.get("bulk_cache_1")["val"].should == "test"
+    end
+
     it "should raise an error that is useful for recovery" do
       @r = @db.save({"_id" => "taken", "field" => "stuff"})
       begin
@@ -215,7 +225,7 @@ describe CouchRest::Database do
       r2["lemons"].should == "from texas"
     end
     it "should use PUT with UUIDs" do
-      CouchRest.should_receive(:put)
+      CouchRest.should_receive(:put).and_return({"ok" => true, "id" => "100", "rev" => "55"})
       r = @db.save({'just' => ['another document']})      
     end
     
@@ -400,7 +410,48 @@ describe CouchRest::Database do
       now['them-keys'].should == 'huge'
     end
   end
-  
+
+  describe "cached bulk save" do
+    it "stores documents in a database-specific cache" do
+      td = {"_id" => "btd1", "val" => "test"}
+      @db.save(td, true)
+      @db.instance_variable_get("@bulk_save_cache").should == [td]
+      
+    end
+
+    it "doesn't save to the database until the configured cache size is exceded" do
+      @db.bulk_save_cache_limit = 3
+      td1 = {"_id" => "td1", "val" => true}
+      td2 = {"_id" => "td2", "val" => 4}
+      @db.save(td1, true)
+      @db.save(td2, true)
+      lambda do
+        @db.get(td1["_id"])
+      end.should raise_error(RestClient::ResourceNotFound)
+      lambda do
+        @db.get(td2["_id"])
+      end.should raise_error(RestClient::ResourceNotFound)
+      td3 = {"_id" => "td3", "val" => "foo"}
+      @db.save(td3, true)
+      @db.get(td1["_id"])["val"].should == td1["val"]
+      @db.get(td2["_id"])["val"].should == td2["val"]
+      @db.get(td3["_id"])["val"].should == td3["val"]
+    end
+
+    it "clears the bulk save cache the first time a non bulk save is requested" do
+      td1 = {"_id" => "blah", "val" => true}
+      td2 = {"_id" => "steve", "val" => 3}
+      @db.bulk_save_cache_limit = 50
+      @db.save(td1, true)
+      lambda do
+        @db.get(td1["_id"])
+      end.should raise_error(RestClient::ResourceNotFound)
+      @db.save(td2)
+      @db.get(td1["_id"])["val"].should == td1["val"]
+      @db.get(td2["_id"])["val"].should == td2["val"]
+    end
+  end
+
   describe "DELETE existing document" do
     before(:each) do
       @r = @db.save({'lemons' => 'from texas', 'and' => 'spain'})
@@ -418,8 +469,102 @@ describe CouchRest::Database do
       @db.delete doc
       lambda{@db.get @docid}.should raise_error
     end
+    it "should fail without an _id" do
+      lambda{@db.delete({"not"=>"a real doc"})}.should raise_error(ArgumentError)
+    end
+    it "should defer actual deletion when using bulk save" do
+      doc = @db.get(@docid)
+      @db.delete doc, true
+      lambda{@db.get @docid}.should_not raise_error
+      @db.bulk_save
+      lambda{@db.get @docid}.should raise_error
+    end
+    
+  end
+  
+  describe "COPY existing document" do
+    before :each do
+      @r = @db.save({'artist' => 'Zappa', 'title' => 'Muffin Man'})
+      @docid = 'tracks/zappa/muffin-man'
+      @doc = @db.get(@r['id'])
+    end
+    describe "to a new location" do
+      it "should work" do
+        @db.copy @doc, @docid
+        newdoc = @db.get(@docid)
+        debugger
+        newdoc['artist'].should == 'Zappa'
+      end
+      it "should fail without an _id" do
+        lambda{@db.copy({"not"=>"a real doc"})}.should raise_error(ArgumentError)
+      end
+    end
+    describe "to an existing location" do
+      before :each do
+        @db.save({'_id' => @docid, 'will-exist' => 'here'})
+      end
+      it "should fail without a rev" do
+        lambda{@db.copy @doc, @docid}.should raise_error(RestClient::RequestFailed)
+      end
+      it "should succeed with a rev" do
+        @to_be_overwritten = @db.get(@docid)
+        @db.copy @doc, "#{@docid}?rev=#{@to_be_overwritten['_rev']}"
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+      end
+      it "should succeed given the doc to overwrite" do
+        @to_be_overwritten = @db.get(@docid)
+        @db.copy @doc, @to_be_overwritten
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+      end
+    end
   end
   
+  describe "MOVE existing document" do
+    before :each do
+      @r = @db.save({'artist' => 'Zappa', 'title' => 'Muffin Man'})
+      @docid = 'tracks/zappa/muffin-man'
+      @doc = @db.get(@r['id'])
+    end
+    describe "to a new location" do
+      it "should work" do
+        @db.move @doc, @docid
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+        lambda {@db.get(@r['id'])}.should raise_error(RestClient::ResourceNotFound)
+      end
+      it "should fail without an _id or _rev" do
+        lambda{@db.move({"not"=>"a real doc"})}.should raise_error(ArgumentError)
+        lambda{@db.move({"_id"=>"not a real doc"})}.should raise_error(ArgumentError)
+      end
+    end
+    describe "to an existing location" do
+      before :each do
+        @db.save({'_id' => @docid, 'will-exist' => 'here'})
+      end
+      it "should fail without a rev" do
+        lambda{@db.move @doc, @docid}.should raise_error(RestClient::RequestFailed)
+        lambda{@db.get(@r['id'])}.should_not raise_error
+      end
+      it "should succeed with a rev" do
+        @to_be_overwritten = @db.get(@docid)
+        @db.move @doc, "#{@docid}?rev=#{@to_be_overwritten['_rev']}"
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+        lambda {@db.get(@r['id'])}.should raise_error(RestClient::ResourceNotFound)
+      end
+      it "should succeed given the doc to overwrite" do
+        @to_be_overwritten = @db.get(@docid)
+        @db.move @doc, @to_be_overwritten
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+        lambda {@db.get(@r['id'])}.should raise_error(RestClient::ResourceNotFound)
+      end
+    end
+  end
+  
+  
   it "should list documents" do
     5.times do
       @db.save({'another' => 'doc', 'will-exist' => 'anywhere'})
@@ -458,6 +603,16 @@ describe CouchRest::Database do
     end
   end
   
+
+  describe "compacting a database" do
+    it "should compact the database" do
+      db = @cr.database('couchrest-test')
+      # r = 
+      db.compact!
+      # r['ok'].should == true
+    end
+  end
+
   describe "deleting a database" do
     it "should start with the test database" do
       @cr.databases.should include('couchrest-test')
@@ -472,4 +627,4 @@ describe CouchRest::Database do
   end
 
 
-end
+end

data/spec/couchrest/core/design_spec.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRest::Design do
+  
+  describe "defining a view" do
+    it "should add a view to the design doc" do
+      @des = CouchRest::Design.new
+      method = @des.view_by :name
+      method.should == "by_name"
+      @des["views"]["by_name"].should_not be_nil
+    end
+  end
+  
+  describe "with an unsaved view" do
+    before(:each) do
+      @des = CouchRest::Design.new
+      method = @des.view_by :name
+    end
+    it "should accept a name" do
+      @des.name = "mytest"
+      @des.name.should == "mytest"
+    end
+    it "should not save on view definition" do
+      @des.rev.should be_nil
+    end
+    it "should freak out on view access" do
+      lambda{@des.view :by_name}.should raise_error
+    end
+  end
+  
+  describe "saving" do
+    before(:each) do
+      @des = CouchRest::Design.new
+      method = @des.view_by :name
+      @des.database = reset_test_db!
+    end
+    it "should fail without a name" do
+      lambda{@des.save}.should raise_error(ArgumentError)
+    end
+    it "should work with a name" do
+      @des.name = "myview"
+      @des.save
+    end
+  end
+  
+  describe "when it's saved" do
+    before(:each) do
+      @db = reset_test_db!
+      @db.bulk_save([{"name" => "x"},{"name" => "y"}])
+      @des = CouchRest::Design.new
+      @des.database = @db
+      method = @des.view_by :name
+    end
+    it "should by queryable when it's saved" do
+      @des.name = "mydesign"
+      @des.save
+      res = @des.view :by_name
+      res["rows"][0]["key"].should == "x"
+    end
+  end
+  
+  describe "from a saved document" do
+    before(:each) do
+      @db = reset_test_db!
+      @db.save({
+        "_id" => "_design/test",
+        "views" => {
+          "by_name" => {
+            "map" => "function(doc){if (doc.name) emit(doc.name, null)}"
+          }
+        }
+      })
+      @db.bulk_save([{"name" => "a"},{"name" => "b"}])
+      @des = @db.get "_design/test"
+    end
+    it "should be a Design" do
+      @des.should be_an_instance_of(CouchRest::Design)
+    end
+    it "should have a modifiable name" do
+      @des.name.should == "test"
+      @des.name = "supertest"
+      @des.id.should == "_design/supertest"
+    end
+    it "should by queryable" do
+      res = @des.view :by_name 
+      res["rows"][0]["key"].should == "a"
+    end
+  end
+  
+  describe "a view with default options" do
+    before(:all) do
+      @db = reset_test_db!
+      @des = CouchRest::Design.new
+      @des.name = "test"
+      method = @des.view_by :name, :descending => true
+      @des.database = @db
+      @des.save
+      @db.bulk_save([{"name" => "a"},{"name" => "z"}])
+    end
+    it "should save them" do
+      @d2 = @db.get(@des.id)
+      @d2["views"]["by_name"]["couchrest-defaults"].should == {"descending"=>true}
+    end
+    it "should use them" do
+      res = @des.view :by_name
+      res["rows"].first["key"].should == "z"
+    end
+    it "should override them" do
+      res = @des.view :by_name, :descending => false
+      res["rows"].first["key"].should == "a"
+    end
+  end
+  
+  describe "a view with multiple keys" do
+    before(:all) do
+      @db = reset_test_db!
+      @des = CouchRest::Design.new
+      @des.name = "test"
+      method = @des.view_by :name, :age
+      @des.database = @db
+      @des.save
+      @db.bulk_save([{"name" => "a", "age" => 2},
+        {"name" => "a", "age" => 4},{"name" => "z", "age" => 9}])
+    end
+    it "should work" do
+      res = @des.view :by_name_and_age
+      res["rows"].first["key"].should == ["a",2]
+    end
+  end
+  
+end

data/spec/couchrest/core/document_spec.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRest::Document, "[]=" do
+  before(:each) do
+    @doc = CouchRest::Document.new
+  end
+  it "should work" do
+    @doc["enamel"].should == nil
+    @doc["enamel"] = "Strong"
+    @doc["enamel"].should == "Strong"
+  end
+  it "[]= should convert to string" do
+    @doc["enamel"].should == nil
+    @doc[:enamel] = "Strong"
+    @doc["enamel"].should == "Strong"
+  end
+  it "should read as a string" do
+    @doc[:enamel] = "Strong"
+    @doc[:enamel].should == "Strong"
+  end
+end
+
+describe CouchRest::Document, "new" do
+  before(:each) do
+    @doc = CouchRest::Document.new("key" => [1,2,3], :more => "values")    
+  end
+  it "should create itself from a Hash" do
+    @doc["key"].should == [1,2,3]
+    @doc["more"].should == "values"
+  end
+  it "should not have rev and id" do
+    @doc.rev.should be_nil
+    @doc.id.should be_nil
+  end
+  it "should freak out when saving without a database" do
+    lambda{@doc.save}.should raise_error(ArgumentError)
+  end
+end
+
+# move to database spec
+describe CouchRest::Document, "saving using a database" do
+  before(:all) do
+    @doc = CouchRest::Document.new("key" => [1,2,3], :more => "values")    
+    @db = reset_test_db!    
+    @resp = @db.save(@doc)
+  end
+  it "should apply the database" do
+    @doc.database.should == @db    
+  end
+  it "should get id and rev" do
+    @doc.id.should == @resp["id"]
+    @doc.rev.should == @resp["rev"]
+  end
+end
+
+describe CouchRest::Document, "bulk saving" do
+  before :all do
+    @db = reset_test_db!
+  end
+
+  it "should use the document bulk save cache" do
+    doc = CouchRest::Document.new({"_id" => "bulkdoc", "val" => 3})
+    doc.database = @db
+    doc.save(true)
+    lambda { doc.database.get(doc["_id"]) }.should raise_error(RestClient::ResourceNotFound)
+    doc.database.bulk_save
+    doc.database.get(doc["_id"])["val"].should == doc["val"]
+  end
+end
+
+describe "getting from a database" do
+  before(:all) do
+    @db = reset_test_db!
+    @resp = @db.save({
+      "key" => "value"
+    })
+    @doc = @db.get @resp['id']
+  end
+  it "should return a document" do
+    @doc.should be_an_instance_of(CouchRest::Document)
+  end
+  it "should have a database" do
+    @doc.database.should == @db
+  end
+  it "should be saveable and resavable" do
+    @doc["more"] = "keys"
+    @doc.save
+    @db.get(@resp['id'])["more"].should == "keys"
+    @doc["more"] = "these keys"    
+    @doc.save
+    @db.get(@resp['id'])["more"].should == "these keys"
+  end
+end
+
+describe "destroying a document from a db" do
+  before(:all) do
+    @db = reset_test_db!
+    @resp = @db.save({
+      "key" => "value"
+    })
+    @doc = @db.get @resp['id']
+  end
+  it "should make it disappear" do
+    @doc.destroy
+    lambda{@db.get @resp['id']}.should raise_error
+  end
+  it "should error when there's no db" do
+    @doc = CouchRest::Document.new("key" => [1,2,3], :more => "values")    
+    lambda{@doc.destroy}.should raise_error(ArgumentError)
+  end
+end
+
+
+describe "destroying a document from a db using bulk save" do
+  before(:all) do
+    @db = reset_test_db!
+    @resp = @db.save({
+      "key" => "value"
+    })
+    @doc = @db.get @resp['id']
+  end
+  it "should defer actual deletion" do
+    @doc.destroy(true)
+    @doc['_id'].should == nil
+    @doc['_rev'].should == nil
+    lambda{@db.get @resp['id']}.should_not raise_error
+    @db.bulk_save
+    lambda{@db.get @resp['id']}.should raise_error
+  end
+end