ashikawa-core 0.5.1 → 0.6.0

data/spec/unit/connection_spec.rb

@@ -24,7 +24,7 @@ describe Ashikawa::Core::Connection do
     subject { Ashikawa::Core::Connection.new "http://localhost:8529" }
 
     it "should send a get request" do
-      stub_request(:get, "http://localhost:8529/_api/my/path").to_return body: '{ "name": "dude" }'
+      stub_request(:get, "http://localhost:8529/_api/my/path").to_return :body => '{ "name": "dude" }'
 
       subject.send_request "/my/path"
 
@@ -32,31 +32,31 @@ describe Ashikawa::Core::Connection do
     end
 
     it "should send a post request" do
-      stub_request(:post, "http://localhost:8529/_api/my/path").with(:body => '{"name":"new_collection"}').to_return body: '{ "name": "dude" }'
+      stub_request(:post, "http://localhost:8529/_api/my/path").with(:body => '{"name":"new_collection"}').to_return :body => '{ "name": "dude" }'
 
-      subject.send_request "/my/path", post: { :name => 'new_collection' }
+      subject.send_request "/my/path", :post => { :name => 'new_collection' }
 
       WebMock.should have_requested(:post, "http://localhost:8529/_api/my/path").with :body => '{"name":"new_collection"}'
     end
 
     it "should send a put request" do
-      stub_request(:put, "http://localhost:8529/_api/my/path").with(:body => '{"name":"new_collection"}').to_return body: '{ "name": "dude" }'
+      stub_request(:put, "http://localhost:8529/_api/my/path").with(:body => '{"name":"new_collection"}').to_return :body => '{ "name": "dude" }'
 
-      subject.send_request "/my/path", put: { :name => 'new_collection' }
+      subject.send_request "/my/path", :put => { :name => 'new_collection' }
 
       WebMock.should have_requested(:put, "http://localhost:8529/_api/my/path").with :body => '{"name":"new_collection"}'
     end
 
     it "should send a delete request" do
-      stub_request(:delete, "http://localhost:8529/_api/my/path").to_return body: '{ "name": "dude" }'
+      stub_request(:delete, "http://localhost:8529/_api/my/path").to_return :body => '{ "name": "dude" }'
 
-      subject.send_request "/my/path", delete: { }
+      subject.send_request "/my/path", :delete => { }
 
       WebMock.should have_requested(:delete, "http://localhost:8529/_api/my/path")
     end
 
     it "should parse JSON" do
-      stub_request(:get, "http://localhost:8529/_api/my/path").to_return body: '{ "name": "dude" }'
+      stub_request(:get, "http://localhost:8529/_api/my/path").to_return :body => '{ "name": "dude" }'
 
       subject.send_request("/my/path").should == {"name" => "dude"}
     end
@@ -66,7 +66,7 @@ describe Ashikawa::Core::Connection do
     subject { Ashikawa::Core::Connection.new }
 
     it "should authenticate with username and password" do
-      subject.authenticate_with username: "testuser", password: "testpassword"
+      subject.authenticate_with :username => "testuser", :password => "testpassword"
 
       subject.username.should == "testuser"
       subject.password.should == "testpassword"
@@ -77,32 +77,63 @@ describe Ashikawa::Core::Connection do
     end
 
     it "should tell if authentication is enabled" do
-      subject.authenticate_with username: "testuser", password: "testpassword"
+      subject.authenticate_with :username => "testuser", :password => "testpassword"
       subject.authentication?.should be_true
     end
 
     it "should only accept a username & password pairs" do
       expect {
-        subject.authenticate_with username: "kitty"
+        subject.authenticate_with :username => "kitty"
       }.to raise_error(ArgumentError)
 
       expect {
-        subject.authenticate_with password: "cheezburger?"
+        subject.authenticate_with :password => "cheezburger?"
       }.to raise_error(ArgumentError)
     end
 
     it "should allow chaining" do
-      subject.authenticate_with(username: "a", password: "b").should == subject
+      subject.authenticate_with(:username => "a", :password => "b").should == subject
     end
 
     it "should send the authentication data with every GET request" do
-      stub_request(:get, "http://user:pass@localhost:8529/_api/my/path").to_return body: '{ "name": "dude" }'
+      stub_request(:get, "http://user:pass@localhost:8529/_api/my/path").to_return :body => '{ "name": "dude" }'
 
-      subject.authenticate_with username: "user", password: "pass"
+      subject.authenticate_with :username => "user", :password => "pass"
       subject.send_request "/my/path"
 
       WebMock.should have_requested(:get, "http://user:pass@localhost:8529/_api/my/path")
     end
   end
 
+  describe "exception handling" do
+    subject { Ashikawa::Core::Connection.new }
+
+    it "should raise an exception if a document is not found" do
+      stub_request(:get, "http://localhost:8529/_api/document/4590/333").to_return do
+        raise RestClient::ResourceNotFound
+      end
+      expect { subject.send_request "/document/4590/333" }.to raise_error(Ashikawa::Core::DocumentNotFoundException)
+    end
+
+    it "should raise an exception if a collection is not found" do
+      stub_request(:get, "http://localhost:8529/_api/collection/4590").to_return do
+        raise RestClient::ResourceNotFound
+      end
+      expect { subject.send_request "/collection/4590" }.to raise_error(Ashikawa::Core::CollectionNotFoundException)
+    end
+
+    it "should raise an exception if an index is not found" do
+      stub_request(:get, "http://localhost:8529/_api/index/4590/333").to_return do
+        raise RestClient::ResourceNotFound
+      end
+      expect { subject.send_request "/index/4590/333" }.to raise_error(Ashikawa::Core::IndexNotFoundException)
+    end
+
+    it "should raise an exception for unknown pathes" do
+      stub_request(:get, "http://localhost:8529/_api/unknown_path/4590/333").to_return do
+        raise RestClient::ResourceNotFound
+      end
+      expect { subject.send_request "/unknown_path/4590/333" }.to raise_error(Ashikawa::Core::UnknownPath)
+    end
+  end
 end

data/spec/unit/cursor_spec.rb

@@ -29,7 +29,7 @@ describe Ashikawa::Core::Cursor do
     it "should iterate over all documents of a cursor" do
       first = true
 
-      @database.stub(:send_request).with("/cursor/26011191", put: {}) do
+      @database.stub(:send_request).with("/cursor/26011191", :put => {}) do
         if first
           first = false
           server_response("/cursor/26011191-2")
@@ -48,7 +48,7 @@ describe Ashikawa::Core::Cursor do
     it "should be deletable" do
       @database.stub(:send_request)
       @database.should_receive(:send_request).with("/cursor/26011191",
-        delete: {})
+        :delete => {})
 
       subject.delete
     end
@@ -56,7 +56,7 @@ describe Ashikawa::Core::Cursor do
     it "should be enumerable" do
       first = true
 
-      @database.stub(:send_request).with("/cursor/26011191", put: {}) do
+      @database.stub(:send_request).with("/cursor/26011191", :put => {}) do
         if first
           first = false
           server_response("/cursor/26011191-2")

data/spec/unit/database_spec.rb

@@ -41,9 +41,9 @@ describe Ashikawa::Core::Database do
     subject { Ashikawa::Core::Database.new @connection }
 
     it "should delegate authentication to the connection" do
-      @connection.should_receive(:authenticate_with).with({ username: "user", password: "password" })
+      @connection.should_receive(:authenticate_with).with({ :username => "user", :password => "password" })
 
-      subject.authenticate_with username: "user", password: "password"
+      subject.authenticate_with :username => "user", :password => "password"
     end
 
     it "should fetch all available collections" do
@@ -66,15 +66,16 @@ describe Ashikawa::Core::Database do
     end
 
     it "should create a single collection if it doesn't exist" do
-      @connection.stub :send_request do |path, method = {}|
+      @connection.stub :send_request do |path, method|
+        method ||= {}
         if method.has_key? :post
           server_response("collections/4590")
         else
-          raise RestClient::ResourceNotFound
+          raise Ashikawa::Core::CollectionNotFoundException
         end
       end
       @connection.should_receive(:send_request).with("/collection/new_collection")
-      @connection.should_receive(:send_request).with("/collection", post: { name: "new_collection"} )
+      @connection.should_receive(:send_request).with("/collection", :post => { :name => "new_collection"} )
 
       Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/4590"))
 
@@ -82,9 +83,9 @@ describe Ashikawa::Core::Database do
     end
 
     it "should send a request via the connection object" do
-      @connection.should_receive(:send_request).with("/my/path", post: { data: "mydata" })
+      @connection.should_receive(:send_request).with("/my/path", :post => { :data => "mydata" })
 
-      subject.send_request "/my/path", post: { data: "mydata" }
+      subject.send_request "/my/path", :post => { :data => "mydata" }
     end
   end
 end

data/spec/unit/document_spec.rb

@@ -44,7 +44,7 @@ describe Ashikawa::Core::Document do
 
     it "should be deletable" do
       database.should_receive(:send_request).with("document/#{raw_data['_id']}",
-        { delete: {} }
+        { :delete => {} }
       )
 
       subject.delete
@@ -52,7 +52,7 @@ describe Ashikawa::Core::Document do
 
     it "should store changes to the database" do
       database.should_receive(:send_request).with("document/#{raw_data['_id']}",
-        { put: { "first_name" => "The", "last_name" => "Other" } }
+        { :put => { "first_name" => "The", "last_name" => "Other" } }
       )
 
       subject["last_name"] = "Other"

data/spec/unit/exception_spec.rb

@@ -1,5 +1,8 @@
 require "ashikawa-core/exceptions/document_not_found"
+require "ashikawa-core/exceptions/collection_not_found"
+require "ashikawa-core/exceptions/index_not_found"
 require "ashikawa-core/exceptions/no_collection_provided"
+require "ashikawa-core/exceptions/unknown_path"
 
 describe Ashikawa::Core::DocumentNotFoundException do
   it "should have a good explanation" do
@@ -7,8 +10,26 @@ describe Ashikawa::Core::DocumentNotFoundException do
   end
 end
 
+describe Ashikawa::Core::CollectionNotFoundException do
+  it "should have a good explanation" do
+    subject.to_s.should include "does not exist"
+  end
+end
+
+describe Ashikawa::Core::IndexNotFoundException do
+  it "should have a good explanation" do
+    subject.to_s.should include "does not exist"
+  end
+end
+
 describe Ashikawa::Core::NoCollectionProvidedException do
   it "should have a good explanation" do
     subject.to_s.should include "without a collection"
   end
 end
+
+describe Ashikawa::Core::UnknownPath do
+  it "should have a good explanation" do
+    subject.to_s.should include "path is unknown"
+  end
+end

data/spec/unit/figure_spec.rb

@@ -0,0 +1,28 @@
+require "ashikawa-core/figure"
+
+describe Ashikawa::Core::Figure do
+  let(:raw_figures) {
+    {
+      "datafiles" => {
+        "count" => 1
+      },
+      "alive" => {
+        "size" => 0,
+        "count" => 0
+      },
+      "dead" => {
+        "size" => 2384,
+        "count" => 149
+      }
+    }
+  }
+  subject { Ashikawa::Core::Figure.new raw_figures }
+
+  it "should check for the figures" do
+    subject.datafiles_count.should == 1
+    subject.alive_size.should == 0
+    subject.alive_count.should == 0
+    subject.dead_size.should == 2384
+    subject.dead_count.should == 149
+  end
+end

data/spec/unit/index_spec.rb

@@ -30,7 +30,7 @@ describe Ashikawa::Core::Index do
 
     it "should be deletable" do
       collection.should_receive(:send_request).with("index/167137465/168054969",
-        delete: {})
+        :delete => {})
       collection.should_receive(:id).and_return(167137465)
 
       subject.delete

data/spec/unit/query_spec.rb

@@ -16,7 +16,7 @@ describe Ashikawa::Core::Query do
     describe "get all" do
       it "should list all documents" do
         collection.stub(:send_request).and_return { server_response('simple-queries/all') }
-        collection.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1"})
+        collection.should_receive(:send_request).with("/simple/all", :put => {"collection" => "example_1"})
 
         Ashikawa::Core::Cursor.should_receive(:new)
 
@@ -25,20 +25,20 @@ describe Ashikawa::Core::Query do
 
       it "should be able to limit the number of documents" do
         collection.stub(:send_request).and_return { server_response('simple-queries/all_skip') }
-        collection.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1", "limit" => 1})
+        collection.should_receive(:send_request).with("/simple/all", :put => {"collection" => "example_1", "limit" => 1})
 
         Ashikawa::Core::Cursor.should_receive(:new)
 
-        subject.all limit: 1
+        subject.all :limit => 1
       end
 
       it "should be able to skip documents" do
         collection.stub(:send_request).and_return { server_response('simple-queries/all_limit') }
-        collection.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1", "skip" => 1})
+        collection.should_receive(:send_request).with("/simple/all", :put => {"collection" => "example_1", "skip" => 1})
 
         Ashikawa::Core::Cursor.should_receive(:new)
 
-        subject.all skip: 1
+        subject.all :skip => 1
       end
     end
 
@@ -49,7 +49,7 @@ describe Ashikawa::Core::Query do
         collection.stub(:database).and_return { double }
 
         collection.stub(:send_request).and_return { server_response('simple-queries/example') }
-        collection.should_receive(:send_request).with("/simple/first-example", put:
+        collection.should_receive(:send_request).with("/simple/first-example", :put =>
           {"collection" => "example_1", "example" => { :hello => "world"}})
 
         Ashikawa::Core::Document.should_receive(:new)
@@ -63,7 +63,7 @@ describe Ashikawa::Core::Query do
 
       it "should find all fitting documents" do
         collection.stub(:send_request).and_return { server_response('simple-queries/example') }
-        collection.should_receive(:send_request).with("/simple/by-example", put:
+        collection.should_receive(:send_request).with("/simple/by-example", :put =>
           {"collection" => "example_1", "example" => { :hello => "world"}})
 
         Ashikawa::Core::Cursor.should_receive(:new)
@@ -73,43 +73,43 @@ describe Ashikawa::Core::Query do
 
       it "should be able to limit the number of documents" do
         collection.stub(:send_request).and_return { server_response('simple-queries/example') }
-        collection.should_receive(:send_request).with("/simple/by-example", put: {"collection" => "example_1", "limit" => 2, "example" => { :hello => "world"}})
+        collection.should_receive(:send_request).with("/simple/by-example", :put => {"collection" => "example_1", "limit" => 2, "example" => { :hello => "world"}})
 
         Ashikawa::Core::Cursor.should_receive(:new)
 
-        subject.by_example example, limit: 2
+        subject.by_example example, :limit => 2
       end
 
       it "should be able to skip documents" do
         collection.stub(:send_request).and_return { server_response('simple-queries/example') }
-        collection.should_receive(:send_request).with("/simple/by-example", put:
+        collection.should_receive(:send_request).with("/simple/by-example", :put =>
           {"collection" => "example_1", "skip" => 1, "example" => { :hello => "world"}})
 
         Ashikawa::Core::Cursor.should_receive(:new)
 
-        subject.by_example example, skip: 1
+        subject.by_example example, :skip => 1
       end
     end
 
     describe "near a geolocation" do
       it "should find documents based on latitude/longitude" do
         collection.stub(:send_request).and_return { server_response('simple-queries/near') }
-        collection.should_receive(:send_request).with("/simple/near", put: { "collection" => "example_1", "latitude" => 0, "longitude" => 0 })
+        collection.should_receive(:send_request).with("/simple/near", :put => { "collection" => "example_1", "latitude" => 0, "longitude" => 0 })
 
         Ashikawa::Core::Cursor.should_receive(:new)
 
-        subject.near latitude: 0, longitude: 0
+        subject.near :latitude => 0, :longitude => 0
       end
     end
 
     describe "within a radious of a geolocation" do
       it "should look for documents based on latidude/longitude" do
         collection.stub(:send_request).and_return { server_response('simple-queries/within') }
-        collection.should_receive(:send_request).with("/simple/within" , put: { "collection" => "example_1", "latitude" => 0, "longitude" => 0, "radius" => 2 })
+        collection.should_receive(:send_request).with("/simple/within" , :put => { "collection" => "example_1", "latitude" => 0, "longitude" => 0, "radius" => 2 })
 
         Ashikawa::Core::Cursor.should_receive(:new)
 
-        subject.within latitude: 0, longitude: 0, radius: 2
+        subject.within :latitude => 0, :longitude => 0, :radius => 2
       end
     end
 
@@ -117,11 +117,11 @@ describe Ashikawa::Core::Query do
       it "should look for documents with an attribute in that range" do
         arguments = { "collection" => "example_1", "attribute" => "age", "left" => 50, "right" => 60, "closed" => false}
         collection.stub(:send_request).and_return { server_response('simple-queries/range') }
-        collection.should_receive(:send_request).with("/simple/range" , put: arguments)
+        collection.should_receive(:send_request).with("/simple/range" , :put => arguments)
 
         Ashikawa::Core::Cursor.should_receive(:new)
 
-        subject.in_range attribute: "age", left: 50, right: 60, closed: false
+        subject.in_range :attribute => "age", :left => 50, :right => 60, :closed => false
       end
     end
 
@@ -129,21 +129,21 @@ describe Ashikawa::Core::Query do
       it "should be able to execute it" do
         collection.stub(:database).and_return double
         collection.stub(:send_request).and_return { server_response("cursor/query") }
-        collection.should_receive(:send_request).with("/cursor", post: {
+        collection.should_receive(:send_request).with("/cursor", :post => {
           "query" => "FOR u IN users LIMIT 2 RETURN u",
           "count" => true,
           "batchSize" => 2
         })
         Ashikawa::Core::Cursor.should_receive(:new).with(collection.database, server_response("cursor/query"))
 
-        subject.execute "FOR u IN users LIMIT 2 RETURN u", count: true, batch_size: 2
+        subject.execute "FOR u IN users LIMIT 2 RETURN u", :count => true, :batch_size => 2
       end
 
       it "should return true when asked if a valid query is valid" do
         query = "FOR u IN users LIMIT 2 RETURN u"
 
         collection.stub(:send_request).and_return { server_response("query/valid") }
-        collection.should_receive(:send_request).with("/query", post: {
+        collection.should_receive(:send_request).with("/query", :post => {
           "query" => query
         })
 
@@ -156,7 +156,7 @@ describe Ashikawa::Core::Query do
         collection.stub(:send_request) do
           raise RestClient::BadRequest
         end
-        collection.should_receive(:send_request).with("/query", post: {
+        collection.should_receive(:send_request).with("/query", :post => {
           "query" => query
         })
 
@@ -177,21 +177,21 @@ describe Ashikawa::Core::Query do
     describe "with an AQL query" do
       it "should be able to execute it" do
         database.stub(:send_request).and_return { server_response("cursor/query") }
-        database.should_receive(:send_request).with("/cursor", post: {
+        database.should_receive(:send_request).with("/cursor", :post => {
           "query" => "FOR u IN users LIMIT 2 RETURN u",
           "count" => true,
           "batchSize" => 2
         })
         Ashikawa::Core::Cursor.should_receive(:new).with(database, server_response("cursor/query"))
 
-        subject.execute "FOR u IN users LIMIT 2 RETURN u", count: true, batch_size: 2
+        subject.execute "FOR u IN users LIMIT 2 RETURN u", :count => true, :batch_size => 2
       end
 
       it "should return true when asked if a valid query is valid" do
         query = "FOR u IN users LIMIT 2 RETURN u"
 
         database.stub(:send_request).and_return { server_response("query/valid") }
-        database.should_receive(:send_request).with("/query", post: {
+        database.should_receive(:send_request).with("/query", :post => {
           "query" => query
         })
 
@@ -204,7 +204,7 @@ describe Ashikawa::Core::Query do
         database.stub(:send_request) do
           raise RestClient::BadRequest
         end
-        database.should_receive(:send_request).with("/query", post: {
+        database.should_receive(:send_request).with("/query", :post => {
           "query" => query
         })