RubyGems - sr-couchy - Versions diffs - 0.0.2 - Mend

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/test_helper'
+describe 'Couchy#new' do
+  it 'creates a new Server with the given server URI' do
+    Couchy::Server.expects(:new).with('uri')
+    Couchy.new('uri')
+  end
+  specify 'uri default to http://localhost:5984/' do
+    server = Couchy.new
+    server.uri.to_s.should.equal 'http://localhost:5984/'
+  end
+end

data/test/database_test.rb ADDED

@@ -0,0 +1,193 @@
+require File.dirname(__FILE__) + '/test_helper'
+describe 'Database' do
+  before(:each) do
+    @server = stub('server', :get => '', :post => '', :put => '', :delete => '')
+    @database = Couchy::Database.new(@server, TestDatabase)
+  end
+  it 'has an accessor on its name' do
+    @database.name.should.equal TestDatabase
+  end
+  it 'has an accessor on the server instance' do
+    @database.server.should.equal @server
+  end
+  specify '#base64 removes new lines to workaround <https://issues.apache.org/jira/browse/COUCHDB-19>' do
+    @database.send(:base64, 'foo').should.equal 'Zm9v'
+  end
+  describe 'Encoding attachments of a document' do
+    setup do
+      Couchy::Database.class_eval { public :encode_attachments_of }
+      @server.stubs(:base64).returns('')
+      @database = Couchy::Database.new(@server, TestDatabase)
+      @attachments = { 'foo' => { 'type' => 'text/plain', 'data' => 'some text' },
+                       'bar' => { 'type' => 'text/plain', 'data' => 'same here' }}
+      @doc = {:foo => 'bar', '_attachments' => @attachments}
+    end
+    it 'returns the doc as is if there is no attachment' do
+      @database.encode_attachments_of(:foo => 'bar').should.equal(:foo => 'bar')
+    end
+    it 'encodes the data of each attachment in base64' do
+      @database.expects(:base64).with('some text').returns('')
+      @database.expects(:base64).with('same here').returns('')
+      @database.encode_attachments_of(@doc)
+    end
+    it 'returns the document with the attachments encoded' do
+      doc = @database.encode_attachments_of(@doc)
+      doc['_attachments']['foo']['data'].should.equal 'c29tZSB0ZXh0'
+      doc['_attachments']['bar']['data'].should.equal 'c2FtZSBoZXJl'
+    end
+  end
+  describe 'Deleting itselfs' do
+    it 'DELETE $database_name' do
+      @server.expects(:delete).with(TestDatabase)
+      @database.delete!
+    end
+  end
+  describe 'Getting a list of documents' do
+    it 'GET $database_name/_all_docs' do
+      @server.expects(:get).with(TestDatabase + '/_all_docs', {})
+      @database.documents
+    end
+    it 'uses given parameters' do
+      @server.expects(:get).with(TestDatabase + '/_all_docs', :startkey => 'somedoc', :count => 3)
+      @database.documents(:startkey => 'somedoc', :count => 3)
+    end
+  end
+  describe 'Getting a document' do
+    it 'GET $database_name/$document_id' do
+      @server.expects(:get).with("#{TestDatabase}/foobar")
+      @database.get('foobar')
+    end
+    it 'escapes the given document id' do
+      CGI.expects(:escape).with('foobar')
+      @database.get('foobar')
+    end
+  end
+  describe 'Saving a document' do
+    it 'encodes attachments of the given document' do
+      doc = {:foo => 'bar'}
+      @database.expects(:encode_attachments_of).with(doc).returns({})
+      @database.save(doc)
+    end
+    it 'POST the document to $database_name when no document id is specified' do
+      doc = {:foo => 'bar'}
+      @server.expects(:post).with(TestDatabase, doc)
+      @database.save(doc)
+    end
+    describe 'When a document id was specified' do
+      it 'PUT the document to $database_name/$document_id' do
+        doc = {'_id' => 'mydocid', 'foo' => 'bar'}
+        @server.expects(:put).with("#{TestDatabase}/#{doc['_id']}", doc)
+        @database.save(doc)
+      end
+      it 'escapes the given document id' do
+        CGI.expects(:escape).with('mydocid')
+        @database.save('_id' => 'mydocid')
+      end
+    end
+  end
+  describe 'Bulk saving a bunch of documents' do
+    it 'POST the documents to $database_name/_bulk_docs' do
+      @server.expects(:post).with("#{TestDatabase}/_bulk_docs", :docs => ['doc1', 'doc2'])
+      @database.bulk_save(['doc1', 'doc2'])
+    end
+  end
+  describe 'Fetching an attachment' do
+    it 'GET $database_name/$document_id/$attachment_id' do
+      @server.expects(:get).with("#{TestDatabase}/my-doc/foo", anything)
+      @database.fetch_attachment('my-doc', 'foo')
+    end
+    it 'escapes the document id and the attachement id' do
+      CGI.expects(:escape).with('my-doc')
+      CGI.expects(:escape).with('foo')
+      @database.fetch_attachment('my-doc', 'foo')
+    end
+  end
+  describe 'Deleting a document' do
+    describe 'When given the document id and the revision' do
+      it 'DELETE $database_name/$document_id?rev=$revision' do
+        @server.expects(:delete).with("#{TestDatabase}/mydocid", :rev => 2800624930)
+        @database.delete('mydocid', 2800624930)
+      end
+      it 'escapes the document id' do
+        CGI.expects(:escape).with('mydocid')
+        @database.delete('mydocid', 2800624930)
+      end
+    end
+    describe 'When given an Hash representing a document' do
+      it 'raises ArgumentError if the doc doesnt have an _id' do
+        lambda { @database.delete('foo' => 'bar') }.should.raise(ArgumentError)
+      end
+      it 'raises ArgumentError if the doc doesnt have a _rev' do
+        lambda { @database.delete('_id' => 'foo') }.should.raise(ArgumentError)
+      end
+      it 'DELETE $database_name/$document_id?rev=$revision' do
+        @server.expects(:delete).with("#{TestDatabase}/mydocid", :rev => 2800624930)
+        @database.delete('_id' => 'mydocid', '_rev' => 2800624930)
+      end
+      it 'escapes the document id' do
+        CGI.expects(:escape).with('mydocid')
+        @database.delete('_id' => 'mydocid', '_rev' => 286633)
+      end
+    end
+    it 'raises ArgumentError if the given argument is neither a document id nor a document' do
+      lambda { @database.delete(:fooo) }.should.raise(ArgumentError)
+    end
+  end
+  describe 'Creating a temporary view' do
+    it 'POST $database_name/_temp_view with the given fonction' do
+      @server.expects(:post).with(TestDatabase + '/_temp_view', 'js function', anything)
+      @database.temp_view('js function')
+    end
+    it "sets the request's Content-Type to application/json" do
+      @server.expects(:post).with(anything, anything,
+        has_entries(:headers => {'Content-Type' => 'application/json'}))
+      @database.temp_view('foo')
+    end
+    it 'uses the given parameters' do
+      @server.expects(:post).with(anything, 'foo', has_entries(:startkey => 'foo'))
+      @database.temp_view('foo', :startkey => 'foo')
+    end
+  end
+  describe 'Getting a view' do
+    it 'GET $database_name/_view/$view_name' do
+      @server.expects(:get).with("#{TestDatabase}/_view/my-view", {})
+      @database.view('my-view')
+    end
+    it 'uses the given parameters' do
+      @server.expects(:get).with(anything, :count => 100)
+      @database.view('my-view', :count => 100)
+    end
+  end
+end

data/test/server_test.rb ADDED

@@ -0,0 +1,211 @@
+require File.dirname(__FILE__) + '/test_helper'
+describe 'Server' do
+  setup do
+    @server = Couchy::Server.new('http://localhost:5984/')
+  end
+  it 'has an accessor on its uri' do
+    server = Couchy::Server.new('foo')
+    server.uri.to_s.should.equal 'foo'
+  end
+  describe 'Various utility methods' do
+    setup do
+      Couchy::Server.class_eval { public :uri_for, :json, :stringify_keys_and_jsonify_values }
+      @server = Couchy::Server.new('http://foo.org/')
+    end
+    specify '#json parse the given json string with the given options' do
+      JSON.expects(:parse).with('foo', :bar => :spam)
+      @server.send(:json, 'foo', :bar => :spam)
+    end
+    describe '#uri_for' do
+      setup do
+        @uri = stub('server uri joined with given path', :query_values= => '')
+        @server.uri.stubs(:join).returns(@uri)
+      end
+      it 'joins the given path with the URI of the server' do
+        @server.uri.expects(:join).with('bar/spam')
+        @server.uri_for('bar/spam')
+      end
+      it 'stringifys keys and jsonifys values of the given parameters' do
+        @server.expects(:stringify_keys_and_jsonify_values).with(:is => 'awesome').returns({})
+        @server.uri_for('group/home', {:is => 'awesome'})
+      end
+      it 'sets the query to the given parameters' do
+        params = {:foo => 'bar'}
+        @uri.expects(:query_values=).with('stringified keys')
+        @server.stubs(:stringify_keys_and_jsonify_values).with(params).returns('stringified keys')
+        @server.uri_for('dj/premier', params)
+      end
+      it 'do not set the query if no parameters' do
+        @uri.expects(:query_values=).never
+        @server.uri_for('primo')
+      end
+      it 'returns the resulting URI as a string' do
+        @uri.expects(:to_s).returns('resulting uri as a string')
+        @server.uri_for('supa/star').should.equal 'resulting uri as a string'
+      end
+    end
+    describe '#stringify_keys_and_jsonify_values' do
+      it 'stringifys keys' do
+        @server.stringify_keys_and_jsonify_values(:foo => 'bar').should.equal('foo' => 'bar')
+      end
+      it 'jsonifys value if key is "key"' do
+        @server.stringify_keys_and_jsonify_values(:key => {'foo' => 'bar'}).should.
+          equal('key' => '{"foo":"bar"}')
+      end
+      it 'jsonifys value if key is "startkey"' do
+        @server.stringify_keys_and_jsonify_values(:startkey => {'foo' => 'bar'}).should.
+          equal('startkey' => '{"foo":"bar"}')
+      end
+      it 'jsonifys value if key is "endkey"' do
+        @server.stringify_keys_and_jsonify_values(:endkey => {'foo' => 'bar'}).should.
+          equal('endkey' => '{"foo":"bar"}')
+      end
+    end
+  end
+  describe 'HTTP requests utility methods' do
+    describe 'GET' do
+      it "appends the given path to the server's URI" do
+        @server.stubs(:json)
+        RestClient.expects(:get).with('http://localhost:5984/foo/bar')
+        @server.get('foo/bar')
+      end
+      it 'appends the given parameters as the query string' do
+        @server.stubs(:json)
+        RestClient.expects(:get).with('http://localhost:5984/foo?bar=spam')
+        @server.get('foo', :bar => 'spam')
+      end
+      it 'parses the server response as json with :max_nesting set to false' do
+        RestClient.stubs(:get).returns('some json')
+        @server.expects(:json).with('some json', :max_nesting => false).returns([])
+        @server.get('give_me_some_json')
+      end
+      it 'do not parse the result as json if :no_json is specified' do
+        RestClient.stubs(:get)
+        @server.expects(:json).never
+        @server.get('foo', :no_json => true)
+      end
+    end
+    describe 'POST' do
+      setup do
+        @server.stubs(:json)
+      end
+      it "appends the given path to server's URI" do
+        RestClient.expects(:post).with('http://localhost:5984/a/b', nil, anything)
+        @server.post('a/b')
+      end
+      it 'appends the given parameters as the query string' do
+        RestClient.expects(:post).with('http://localhost:5984/foo?bar=spam', nil, anything)
+        @server.post('foo', nil, :bar => 'spam')
+      end
+      it 'jsonify the given body and post it' do
+        body = {:foo => 'bar'}
+        body.expects(:to_json).returns('some json')
+        RestClient.expects(:post).with(anything, 'some json', anything)
+        @server.post('foo', body)
+      end
+      it 'passes given headers to RestClient' do
+        RestClient.expects(:post).with(anything, anything, {'Content-Type' => 'application/json'})
+        @server.post('foo', nil, :headers => {'Content-Type' => 'application/json'})
+      end
+    end
+    describe 'PUT' do
+      setup do
+        @server.stubs(:json)
+      end
+      it "appends the given path to the server's URI" do
+        RestClient.expects(:put).with('http://localhost:5984/a/b', anything)
+        @server.put('a/b')
+      end
+      it 'jsonify and PUT the given body' do
+        body = {:foo => 'bar'}
+        body.expects(:to_json).returns('some json')
+        RestClient.expects(:put).with(anything, 'some json')
+        @server.put('foo', body)
+      end
+    end
+    describe 'DELETE' do
+      it "appends the given path to the server's URI" do
+        @server.stubs(:json).returns('')
+        RestClient.expects(:delete).with('http://localhost:5984/a/b')
+        @server.delete('a/b')
+      end
+      it 'appends the given parameters as the query string' do
+        @server.stubs(:json)
+        RestClient.expects(:delete).with('http://localhost:5984/foo/bar?a=b')
+        @server.delete('foo/bar', :a => :b)
+      end
+    end
+  end
+  describe 'Getting a list of all the databases' do
+    it 'GET _all_dbs' do
+      @server.expects(:get).with('_all_dbs')
+      @server.databases
+    end
+  end
+  describe 'Getting a database' do
+    it 'creates a new Database object with the given name and itselfs' do
+      Couchy::Database.expects(:new).with(@server, 'mydb')
+      @server.database('mydb')
+    end
+    it 'returns a Database object' do
+      @server.database('mydb').should.be.an.instance_of Couchy::Database
+    end
+  end
+  describe 'Getting info on the server' do
+    it 'GET the server URI' do
+      @server.expects(:get).with('/')
+      @server.info
+    end
+  end
+  describe 'Restarting the server' do
+    it 'POST _restart' do
+      @server.expects(:post).with('_restart')
+      @server.restart!
+    end
+  end
+  describe 'Creating a new database' do
+    it 'PUT to database_name' do
+      @server.expects(:put).with('mydb')
+      @server.create_db('mydb')
+    end
+    it 'returns a Database object' do
+      @server.stubs(:put)
+      @server.create_db('mydb').should.be.an.instance_of Couchy::Database
+    end
+  end
+end