couchobject 0.0.1

data/spec/database_spec.rb

@@ -0,0 +1,143 @@
+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 url encode paths"
+end

data/spec/document_spec.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe CouchObject::Document do
+  
+  before(:each) do
+    @db = mock("CouchObject::Database mock")
+    @test_data = {
+      "_id" => "123", 
+      "_rev" => "666", 
+      "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))
+  end
+  
+  it "should initialize with a bunch of attributes" do
+    doc = CouchObject::Document.new({"foo" => "bar"})
+    doc.attributes.should == {"foo" => "bar"}
+  end
+  
+  it "should have an id from the attributes" do
+    doc = CouchObject::Document.new(@test_data)
+    doc.id.should == @test_data["_id"]
+  end
+  
+  it "should not have an id if not in attributes" do
+    doc = CouchObject::Document.new
+    doc.id.should == nil
+  end
+  
+  it "should have an assignable id if new document" do
+    doc = CouchObject::Document.new
+    doc.id = "fubar"
+    doc.id.should == "fubar"
+  end
+  
+  it "should should be new? if there's an id attribute" do
+    doc = CouchObject::Document.new(@test_data)
+    doc.new?.should == false
+  end
+  
+  it "should not be new if there's not original id" do
+    doc = CouchObject::Document.new({"foo" => "bar"})
+    doc.new?.should == true
+  end
+  
+  it "should be Enumerable on its attributes" do
+    CouchObject::Document.constants.should include("Enumerator")
+    doc = CouchObject::Document.new(@test_data)
+    doc.attributes.should_receive(:each)
+    doc.map {|attrib| attrib }
+  end
+  
+  it "should be JSONable" do
+    doc = CouchObject::Document.new({"foo" => "bar"})    
+    doc.to_json.should == JSON.unparse({"foo" => "bar"})
+  end
+  
+  it "should be JSONable and include _id if id= is set" do
+    doc = CouchObject::Document.new({"foo" => "bar"})    
+    doc.id = "quux"
+    doc.to_json.should == JSON.unparse({"foo" => "bar", "_id" => "quux"})
+  end
+  
+  it "should POST to the database with create" do
+    doc = CouchObject::Document.new({"foo" => "bar"})    
+    @db.should_receive(:post).with("", doc.to_json).and_return(@response)
+    doc.save(@db)
+  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.save(@db)
+  end
+  
+  it "should send the current revision along when updating a doc" do
+    doc = CouchObject::Document.new(@test_data)
+    @db.should_receive(:put).and_return(@response)
+    doc.should_receive(:to_json).with("_rev" => doc.revision)
+    doc.save(@db)
+  end
+  
+  it "should update its id when saving" do
+    @test_data.delete("_id")
+    @test_data.delete("_rev")
+    doc = CouchObject::Document.new(@test_data)
+    @db.should_receive(:post).and_return(@response)
+    doc.id.should be(nil)
+    doc.new?.should == true
+    doc.save(@db)
+    doc.id.should_not be(nil)
+  end
+  
+  it "should have a revision" do
+    doc = CouchObject::Document.new(@test_data)
+    doc.revision.should == @test_data["_rev"]    
+  end
+  
+  it "should lookup document attributes with []" do
+    doc = CouchObject::Document.new({"foo" => "bar"})
+    doc["foo"].should == "bar"
+  end
+  
+  it "should assign document attributes witih []=" do
+    doc = CouchObject::Document.new
+    doc["foo"].should == nil
+    doc["foo"] = "bar"
+    doc["foo"].should == "bar"
+  end
+  
+  it "should delegate missing methods to attributes" do
+    doc = CouchObject::Document.new({"foo" => "bar", "stuff" => true })
+    doc.foo.should == "bar"
+    doc.stuff?.should == true
+    proc{ doc.foo = "baz" }.should_not raise_error
+    doc.foo.should == "baz"
+  end
+  
+  it "should know if it has a given document key" do
+    doc = CouchObject::Document.new({"foo" => "bar"})
+    doc.has_key?("foo").should == true    
+    doc.has_key?("bar").should == false
+  end
+  
+  it "should know if it reponds to a key in the attributes" do
+    doc = CouchObject::Document.new({"foo" => "bar", "baz" => true})
+    doc.respond_to?(:foo).should == true    
+    doc.respond_to?(:bar).should == false
+    
+    doc.respond_to?(:baz?).should == true    
+    doc.respond_to?(:bar?).should == false
+    
+    doc.respond_to?(:foo=).should == true    
+    doc.respond_to?(:bar=).should == false
+  end
+  
+end

data/spec/integration/database_integration_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + "/integration_helper"
+
+describe "Database operations" do
+  include IntegrationSpecHelper
+  
+  before(:each) do
+    delete_test_db
+  end
+  
+  it "should create a database " do
+    all_dbs = proc{ CouchObject::Database.all_databases("http://localhost:8888") }
+    all_dbs.call.include?("couchobject_test").should == false
+    
+    create_test_db.should == {"ok" => true}
+    
+    all_dbs.call.include?("couchobject_test").should == true
+  end
+  
+  it "should delete a database" do
+    all_dbs = proc{ CouchObject::Database.all_databases("http://localhost:8888") }
+    all_dbs.call.include?("couchobject_test").should == false
+    
+    create_test_db.should == {"ok" => true}
+    CouchObject::Database.delete!(
+      "http://localhost:8888", 
+      "couchobject_test"
+    ).should == {"ok" => true}
+    
+    all_dbs.call.include?("couchobject_test").should == false
+  end
+  
+  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"
+  end
+  
+  it "should GET a non existing document and return 404" do
+    db = open_test_db
+    response = db.get("roflcopters")
+    response.code.should == 404
+  end
+  
+  it "should POST a new document successfully" do
+    db = create_and_open_test_db
+    response = db.post("", JSON.unparse({"foo" => ["bar", "baz"]}))
+    doc = response.to_document
+    doc.ok?.should == true
+    doc.id.should_not == nil
+  end
+  
+  it "should PUT to update and existing document" do
+    db = create_and_open_test_db
+    response = db.post("", JSON.unparse({"foo" => ["bar", "baz"]}))
+    created_doc = response.to_document
+    response = db.put(created_doc.id, JSON.unparse(
+      {"foo" => [1, 2]}.merge("_rev" => created_doc.revision)
+    ))
+    response.to_document.ok?.should == true
+    
+    updated_doc = db.get(created_doc.id).to_document
+    updated_doc.foo.should == [1,2]
+  end
+  
+  it "should DELETE to delete an existing document" do
+    db = create_and_open_test_db
+    response = db.post("", JSON.unparse({"foo" => ["bar", "baz"]}))
+    created_doc = response.to_document
+    
+    resp = db.delete(created_doc.id)
+    resp.code.should == 202
+    
+    resp = db.get(created_doc.id)
+    resp.code.should == 404
+  end
+  
+end

data/spec/integration/document_integration_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + "/integration_helper"
+
+describe "Document functionality" do
+  include IntegrationSpecHelper
+  
+  before(:each) do
+    delete_test_db
+    @db = create_and_open_test_db
+  end
+  
+  it "should create our document" do
+    doc = CouchObject::Document.new("foo" => [1,2])
+    resp = doc.save(@db)
+    resp.code.should == 201
+    @db.get(doc.id).code.should == 200
+  end
+  
+  it "should update a document" do
+    doc = CouchObject::Document.new("foo" => [1,2])
+    resp = doc.save(@db)
+    resp.code.should == 201
+    
+    doc = @db.get(doc.id).to_document
+    doc.foo = "bar"
+    doc.save(@db).parsed_body["ok"].should == true
+    
+    doc = @db.get(doc.id).to_document
+    doc.foo.should == "bar"
+  end
+  
+  it "should update itself properly" do
+    doc = CouchObject::Document.new("foo" => [1,2])
+    doc.save(@db)
+    @db.all_documents.size.should == 1
+    doc.foo = "bar"
+    doc.save(@db)
+    @db.all_documents.size.should == 1
+  end
+  
+end

data/spec/integration/integration_helper.rb

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

data/spec/model_spec.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe CouchObject::Model do
+  
+end

data/spec/persistable_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+class Bike
+  include CouchObject::Persistable
+  
+  def initialize
+    @wheels = 2
+  end
+  attr_accessor :wheels
+  
+  def to_couch
+    {:wheels => @wheels}
+  end
+  
+  def self.from_couch(attributes)
+    bike = new
+    bike.wheels = attributes["wheels"]
+    bike
+  end
+end
+
+describe CouchObject::Persistable, "when mixed into a Class" do
+  before(:each) do
+    @bike = Bike.new
+    @db = mock("mock db")
+    
+    @empty_response = {}    
+    @ok_response = {"ok" => true}
+    @document_response = {
+      "_id" => "123BAC", 
+      "_rev" => "946B7D1C", 
+      "attributes" => {
+        "wheels" => 3
+      }
+    }
+  end
+  
+  it "should give the class a save method that saves the object" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:post).with("", @bike.to_json).and_return(@empty_response)
+    @bike.save("foo")
+  end
+  
+  it "should raise if no to_couch on class" do
+    klass = Class.new{ include CouchObject::Persistable }
+    proc{ klass.new.to_json }.should raise_error(CouchObject::Persistable::NoToCouchMethodError)
+  end
+  
+  it "should raise if no to_couch on class" do
+    klass = Class.new{ 
+      include CouchObject::Persistable 
+      def to_couch() end
+    }
+    proc{ klass.get_by_id("foo", "bar") }.should raise_error(CouchObject::Persistable::NoFromCouchMethodError)
+  end
+  
+  it "should return the doc id on successfull save" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:post).with("", @bike.to_json).and_return(@document_response)
+    @bike.save("foo")["_id"].should == "123BAC"
+  end  
+  
+  it "should assign the returned id to itself on successful save" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:post).with("", @bike.to_json).and_return(@document_response)
+    @bike.save("foo")
+    @bike.id.should == "123BAC"
+  end
+  
+  it "should know if itself is a new object" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:post).with("", @bike.to_json).and_return(@document_response)
+    @bike.new?.should == true
+    @bike.save("foo")
+    @bike.new?.should == false
+  end
+  
+  it "should get document by id" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:get).with("123BAC").and_return(@document_response)
+    Bike.get_by_id("foo", "123BAC")
+  end
+  
+  it "should instantiate a new object based on their #to_couch" do
+    CouchObject::Database.should_receive(:open).and_return(@db)
+    @db.should_receive(:get).with("123BAC").and_return(@document_response)
+    bike = Bike.get_by_id("foo", "123BAC")
+    bike.class.should == Bike
+    bike.wheels.should == 3
+  end
+end