couch-client 0.0.1

data/lib/couch-client/row.rb

@@ -0,0 +1,10 @@
+module CouchClient
+  # The Row is an extended Hash that provides additional state to 
+  # get status codes and connect documents to the server.
+  class Row < ConsistentHash
+    def initialize(code, row, connection)
+      self.merge!(row)
+      self["doc"] &&= Document.new(code, row["doc"], connection)
+    end
+  end
+end

data/spec/attachment_list_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe CouchClient::AttachmentList do
+  it 'should exist inherent from ConsistentHash' do
+    CouchClient::AttachmentList.ancestors[1].should eql(CouchClient::ConsistentHash)
+  end
+end

data/spec/attachment_spec.rb

@@ -0,0 +1,57 @@
+require 'digest/sha1'
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe CouchClient::Attachment do
+  before(:all) do
+    @couch = CouchClient.connect(COUCHDB_TEST_SETTINGS)
+    @couch.database.create
+    
+    @alice = @couch.build({"name" => "alice", "city" => "nyc"})
+    @alice.save
+    
+    @read = lambda do |file|
+      File.read(File.join(File.dirname(__FILE__), "files", file))
+    end
+    
+    @digest = lambda do |file|
+      Digest::SHA1.hexdigest(file)
+    end
+    
+    @plain = @read.call("plain.txt")
+    @image = @read.call("image.png")
+    
+    @plain_digest = @digest.call(@plain)
+    @image_digest = @digest.call(@image)
+    
+    @alice.attach("plain.txt", @plain, "text/plain")
+    @alice.attach("image.png", @image, "image/png")
+    
+    @attachment_plain = @alice.saved_doc.attachments["plain.txt"]
+    @attachment_image = @alice.saved_doc.attachments["image.png"]
+  end
+  
+  after(:all) do
+    @couch.database.delete!
+  end
+  
+  describe '#uri' do
+    it 'should yield the uri for the attachment' do
+      @attachment_plain.uri.should eql([@couch.hookup.handler.uri, @alice.id, "plain.txt"].join("/"))
+      @attachment_image.uri.should eql([@couch.hookup.handler.uri, @alice.id, "image.png"].join("/"))
+    end
+  end
+  
+  describe '#path' do
+    it 'should yield the uri for the attachment' do
+      @attachment_plain.path.should eql([@couch.hookup.handler.path, @alice.id, "plain.txt"].join("/"))
+      @attachment_image.path.should eql([@couch.hookup.handler.path, @alice.id, "image.png"].join("/"))
+    end
+  end
+  
+  describe '#file' do
+    it 'should yield the file for the attachment as a string' do
+      @digest.call(@attachment_plain.data).should eql(@plain_digest)
+      @digest.call(@attachment_image.data).should eql(@image_digest)
+    end
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe CouchClient::Collection do
+  before(:all) do
+    @couch = CouchClient.connect(COUCHDB_TEST_SETTINGS)
+    @couch.database.create
+    
+    factory = lambda do |hash|
+      doc = @couch.build(hash)
+      doc.save
+      doc
+    end
+    
+    @alice   = factory.call({"_id" => "123", "name" => "alice", "city" => "nyc"})
+    @bob     = factory.call({"_id" => "456", "name" => "bob", "city" => "chicago"})
+    @design  = factory.call({"_id" => "_design/people", 
+      "views" => {
+        "all" => {"map" => "function(doc){emit(doc._id, doc)}"}
+      }
+    })
+    
+    @people = @couch.design("people").view("all", "include_docs" => true)
+  end
+  
+  after(:all) do
+    @couch.database.delete!
+  end
+  
+  it 'should be an CouchClient::Collection object' do
+    @people.should be_a_kind_of(CouchClient::Collection)
+  end
+  
+  it 'should have a collection of rows' do
+    @people.size.should eql(2)
+    @people.first["doc"].should eql(@alice)
+    @people.last["doc"].should eql(@bob)
+  end
+  
+  it 'should have `code` and `info` methods' do
+    @people.should respond_to(:code)
+    @people.should respond_to(:info)
+  end
+end

data/spec/conection_handler_spec.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe CouchClient::ConnectionHandler do
+  before(:all) do
+    @ch = CouchClient::ConnectionHandler.new
+  end
+  
+  it 'should have sensible defaults' do
+    @ch.scheme.should eql("http")
+    @ch.host.should eql("localhost")
+    @ch.port.should eql(5984)
+  end
+  
+  it 'should set parameters' do
+    @ch.scheme = "https"
+    @ch.username = "admin"
+    @ch.password = "nimda"
+    @ch.host = "couchone.com"
+    @ch.port = 8080
+    @ch.database = "sandbox"
+  end
+  
+  it 'should get parameters' do
+    @ch.scheme.should eql("https")
+    @ch.username.should eql("admin")
+    @ch.password.should eql("nimda")
+    @ch.host.should eql("couchone.com")
+    @ch.port.should eql(8080)
+    @ch.database.should eql("sandbox")
+  end
+  
+  it 'shoudl output a path string' do
+    @ch.path.should eql("/sandbox")
+  end
+  
+  it 'should output a uri string' do
+    @ch.uri.should eql("https://couchone.com:8080/sandbox")
+  end
+  
+  it 'should output a uri string with a path if passed a path' do
+    @ch.uri(["path"]).should eql("https://couchone.com:8080/sandbox/path")
+    @ch.uri(["path"], nil).should eql("https://couchone.com:8080/sandbox/path")
+    @ch.uri(["_$,+-/"]).should eql("https://couchone.com:8080/sandbox/_%24%2C%2B-%2F")
+    @ch.uri(["?=&; #"]).should eql("https://couchone.com:8080/sandbox/%3F%3D%26%3B+%23")
+    @ch.uri(["_design/test", "spaces & special/chars"]).should eql("https://couchone.com:8080/sandbox/_design/test/spaces+%26+special%2Fchars")
+  end
+  
+  it 'should output a uri string with a query if a query is given' do
+    @ch.uri(nil, {"a" => "apple"}).should eql("https://couchone.com:8080/sandbox?a=apple")
+    @ch.uri(nil, {"a" => "apple", "b" => "banana"}).should eql("https://couchone.com:8080/sandbox?a=apple&b=banana")
+    @ch.uri(nil, {"a" => "_$,+-/", "b" => "?=&; #"}).should eql("https://couchone.com:8080/sandbox?a=_%24%2C%2B-%2F&b=%3F%3D%26%3B+%23")
+  end
+  
+  it 'should output a uri string with path and query if both are given' do
+    @ch.uri(["path", "one", "two"], {"a" => "apple", "b" => "banana"}).should eql("https://couchone.com:8080/sandbox/path/one/two?a=apple&b=banana")
+  end
+  
+  it 'should properly escape database urls' do
+    @ch.database = "abc123/_$()+-"
+    @ch.uri(["path"]).should eql("https://couchone.com:8080/abc123%2F_%24%28%29%2B-/path")
+  end
+  
+  it 'should raise an error if an invalid name is given' do
+    lambda{@ch.database = "ABC!@#"}.should raise_error(CouchClient::InvalidDatabaseName)
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe CouchClient::Connection do
+  before(:all) do
+    @couch = CouchClient.connect(COUCHDB_TEST_SETTINGS)
+    @couch.database.create
+    
+    factory = lambda do |hash|
+      doc = @couch.build(hash)
+      doc.save
+      doc
+    end
+    
+    @alice   = factory.call({"name" => "alice", "city" => "nyc"})
+    @bob     = factory.call({"name" => "bob", "city" => "chicago"})
+    @deleted = factory.call({"name" => "deleted", "city" => "unknown"})
+    @deleted.delete! # used to test if deleted documents raise an error when fetched
+    @design  = factory.call({"_id" => "_design/people", "views" => {"all" => {"map" => "function(doc){emit(doc._id, doc)}"}}})
+  end
+  
+  after(:all) do
+    @couch.database.delete!
+  end
+  
+  it 'should have a Hookup' do
+    @couch.hookup.should be_a(CouchClient::Hookup)
+  end
+  
+  it 'should have a Database' do
+    @couch.database.should be_a(CouchClient::Database)
+  end
+  
+  describe '#[]' do
+    it 'should get the document associated if it exists' do
+      @couch[@alice["_id"]].should eql(@alice)
+      @couch[@bob["_id"]].should eql(@bob)
+      @couch[@design["_id"]].should eql(@design)
+    end
+    
+    it 'should raise an error if the document was deleted' do
+      lambda{@couch[@deleted["_id"]].should}.should raise_error(CouchClient::DocumentNotFound)
+    end
+    
+    it 'should raise an error if the document does not exist' do
+      lambda{@couch['missing'].should}.should raise_error(CouchClient::DocumentNotFound)
+    end
+    
+    it 'should raise an error if the response was not a valid document' do
+      lambda{@couch["_design/people/_view/all"]}.should raise_error(CouchClient::DocumentNotValid)
+    end
+  end
+  
+  describe '#design' do
+    it 'should return a design object when a valid design id is given' do
+       @couch.design("people").should be_a(CouchClient::Design)
+    end
+    
+    it 'should allow access to design views' do
+      @couch.design("people").view("all").should be_a(CouchClient::Collection)
+    end
+  end
+  
+  describe '#all_docs' do
+    it 'should return a list of all documents stored' do
+      all_docs = @couch.all_docs("include_docs" => true)
+      all_docs.should be_a(CouchClient::Collection)
+      docs = all_docs.map{|doc| doc["doc"].id}
+      docs.should include(@alice.id)
+      docs.should include(@bob.id)
+      docs.should include(@design.id)
+    end
+  end
+  
+  describe '#build' do
+    before(:all) do
+      @charlie = @couch.build({"name" => "charlie", "city" => "san fran"})
+    end
+    
+    it 'should create a new Document' do
+      @charlie.should be_a(CouchClient::Document)
+    end
+    
+    it 'should have the hash keys and values provided' do
+      @charlie.should eql({"name" => "charlie", "city" => "san fran"})
+    end
+  end
+  
+  describe '#inspect' do
+    it 'should yield an inspect string with valid settings' do
+      @couch.inspect.should eql("#<CouchClient::Connection: uri: http://localhost:5984/couch-client_test>")
+    end
+  end
+end

data/spec/consistent_hash_spec.rb

@@ -0,0 +1,171 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe CouchClient::ConsistentHash do
+  describe '#initialize' do
+    describe 'when given a hash' do
+      before do
+        @ch = CouchClient::ConsistentHash.new({:a => "apple", "b" => :banana})
+      end
+      
+      it 'should construct a new ConsistentHash' do
+        @ch[:a].should eql("apple")
+        @ch["a"].should eql("apple")
+        @ch[:b].should eql("banana")
+        @ch["b"].should eql("banana")
+        @ch[:c].should be_nil
+      end
+    end
+
+    describe 'when given a default value' do
+      before do
+        @ch = CouchClient::ConsistentHash.new("default")
+        @ch[:a] = "apple"
+      end
+      
+      it 'should construct a new ConsistentHash with a default' do
+        
+        @ch[:a].should eql("apple")
+        @ch[:b].should eql("default")
+      end
+    end
+    
+    describe 'when given a hash with a default value' do
+      before do
+        h = Hash.new("default")
+        h[:a] = "apple"
+        @ch = CouchClient::ConsistentHash.new(h)
+        @ch[:b] = "banana"
+      end
+      
+      it 'should construct a new ConsistentHash with a default' do
+        @ch[:a].should eql("apple")
+        @ch[:b].should eql("banana")
+        @ch[:z].should eql("default")
+      end
+    end
+  end
+
+  describe '#default' do
+    before do
+      @ch = CouchClient::ConsistentHash.new("default")
+      @ch[:a] = "apple"
+    end
+    
+    it 'should give the default value if it does not exists' do
+      @ch.default.should eql("default")
+    end
+  end
+
+  describe '#[]=' do
+    before do
+      @ch = CouchClient::ConsistentHash.new()
+    end
+    
+    it 'should set a field' do
+      @ch[:a] = "apple"
+      @ch[:a].should eql("apple")
+      @ch["a"].should eql("apple")
+    end
+  end
+
+  describe '#update, #merge!' do
+    before do
+      @ch = CouchClient::ConsistentHash.new({:a => "apple", :b => "banana"})
+    end
+    
+    it 'should update an existing hash with fields from a new hash' do
+      @ch.update({:b => "blueberry", :c => "cherry"})
+      @ch.should eql({"a"=>"apple", "b"=>"blueberry", "c"=>"cherry"})
+    end
+  end
+
+  describe '#key?' do
+    before do
+      @ch = CouchClient::ConsistentHash.new({:a => "apple"})
+    end
+    
+    it 'should identify if a hash has a key' do
+      @ch.key?(:a).should be_true
+      @ch.key?(:b).should be_false
+    end
+  end
+
+  describe '#fetch' do
+    before do
+      @ch = CouchClient::ConsistentHash.new({:a => "apple"})
+    end
+    
+    it 'should return the value if the key given exists' do
+      @ch.fetch(:a).should eql("apple")
+    end
+    
+    it 'should raise an error if the key given does not exist' do
+      lambda{@ch.fetch(:b)}.should raise_error(KeyError)
+    end
+    
+    it 'should return a default if one is given' do
+      @ch.fetch(:b, "default").should eql("default")
+    end
+  end
+
+  describe '#values_at' do
+   before do
+      @ch = CouchClient::ConsistentHash.new({:a => "apple", :b => "banana", :c => "cherry"})
+    end
+    
+    it 'should return an array of values for the keys given' do
+      @ch.values_at(:a, :c).should eql(["apple", "cherry"])
+    end
+  end
+
+  describe '#dup' do
+    before do
+      @ch = CouchClient::ConsistentHash.new({:a => "apple"})
+    end
+    
+    it 'should return a new hash' do
+      @ch2 = @ch.dup
+      @ch2.object_id.should_not eql(@ch.object_id)
+    end
+  end
+  
+  describe '#merge' do
+    before do
+      @ch = CouchClient::ConsistentHash.new({:a => "apple", :b => "banana"})
+    end
+    
+    it 'should return an new hash with fields from both hashs' do
+      @ch2 = @ch.merge({:b => "blueberry", :c => "cherry"})
+      
+      @ch.should eql({"a" => "apple", "b" => "banana"})
+      @ch2.should eql({"a"=>"apple", "b"=>"blueberry", "c"=>"cherry"})
+    end
+  end
+
+  describe '#delete' do
+    before do
+      @ch = CouchClient::ConsistentHash.new({:a => "apple"})
+    end
+    
+    it 'should delete the specified field' do
+      @ch.delete(:b)
+      @ch.should eql({"a" => "apple"})
+    end
+  end
+
+  describe '#to_hash' do
+    before do
+      @ch = CouchClient::ConsistentHash.new({:a => "apple"})
+    end
+    
+    it 'should return a regular hash' do
+      @h = @ch.to_hash
+      
+      @ch[:a].should eql("apple")
+      @h[:a].should be_nil
+      
+      @ch.should be_an_instance_of(CouchClient::ConsistentHash)
+      @h.should be_an_instance_of(Hash)
+    end
+  end
+end