ashikawa-core 0.4.1 → 0.5.1

data/spec/unit/collection_spec.rb

@@ -6,7 +6,6 @@ describe Ashikawa::Core::Collection do
 
   before :each do
     @database = double()
-    mock { Ashikawa::Core::Cursor }
   end
 
   it "should have a name" do
@@ -19,6 +18,16 @@ describe Ashikawa::Core::Collection do
     my_collection.id.should == 4588
   end
 
+  it "should create a query" do
+    collection = subject.new @database, server_response("/collections/4588")
+
+    mock Ashikawa::Core::Query
+    Ashikawa::Core::Query.stub(:new)
+    Ashikawa::Core::Query.should_receive(:new).exactly(1).times.with(collection)
+
+    collection.query
+  end
+
   describe "the status code" do
     it "should know if the collection is new born" do
       my_collection = subject.new @database, { "status" => "1" }
@@ -133,79 +142,55 @@ describe Ashikawa::Core::Collection do
       subject.name = "my_new_name"
     end
 
-    describe "working with documents" do
-
-      describe "add and get single documents" do
-        it "should receive a document by ID" do
-          @database.stub(:send_request).with("/document/4590/333").and_return { server_response('documents/4590-333') }
-          @database.should_receive(:send_request).with("/document/4590/333")
-
-          # Documents need to get initialized:
-          Ashikawa::Core::Document.should_receive(:new)
-
-          subject[333]
-        end
+    describe "add and get single documents" do
+      it "should receive a document by ID" do
+        @database.stub(:send_request).with("/document/4590/333").and_return { server_response('documents/4590-333') }
+        @database.should_receive(:send_request).with("/document/4590/333")
 
-        it "should replace a document by ID" do
-          @database.stub(:send_request).with("/document/4590/333", put: {"name" => "The Dude"})
-          @database.should_receive(:send_request).with("/document/4590/333", put: {"name" => "The Dude"})
+        # Documents need to get initialized:
+        Ashikawa::Core::Document.should_receive(:new)
 
-          subject[333] = {"name" => "The Dude"}
-        end
+        subject[333]
+      end
 
-        it "should create a new document" do
-          @database.stub(:send_request).with("/document?collection=4590", post: { "name" => "The Dude" }).and_return do
-            server_response('documents/new-4590-333')
-          end
-          @database.stub(:send_request).with("/document/4590/333", post: { "name" => "The Dude" }).and_return { server_response('documents/4590-333') }
+      it "should replace a document by ID" do
+        @database.stub(:send_request).with("/document/4590/333", put: {"name" => "The Dude"})
+        @database.should_receive(:send_request).with("/document/4590/333", put: {"name" => "The Dude"})
 
-          # Documents need to get initialized:
-          Ashikawa::Core::Document.should_receive(:new)
+        subject[333] = {"name" => "The Dude"}
+      end
 
-          subject.create({"name" => "The Dude"})
+      it "should create a new document" do
+        @database.stub(:send_request).with("/document?collection=4590", post: { "name" => "The Dude" }).and_return do
+          server_response('documents/new-4590-333')
         end
+        @database.stub(:send_request).with("/document/4590/333", post: { "name" => "The Dude" }).and_return { server_response('documents/4590-333') }
 
-        it "should create a new document with `<<`" do
-          @database.stub(:send_request).with("/document?collection=4590", post: { "name" => "The Dude" }).and_return do
-            server_response('documents/new-4590-333')
-          end
-          @database.stub(:send_request).with("/document/4590/333").and_return { server_response('documents/4590-333') }
+        # Documents need to get initialized:
+        Ashikawa::Core::Document.should_receive(:new)
 
-          # Documents need to get initialized:
-          Ashikawa::Core::Document.should_receive(:new)
-
-          subject << {"name" => "The Dude"}
-        end
+        subject.create({"name" => "The Dude"})
       end
 
-      describe "list all" do
-        it "should list all documents" do
-          @database.stub(:send_request).with("/simple/all", put: {"collection" => "example_1"}).and_return { server_response('simple-queries/all') }
-          @database.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1"})
-
-          # Documents need to get initialized:
-          Ashikawa::Core::Cursor.should_receive(:new)
-
-          subject.all
+      it "should create a new document with `<<`" do
+        @database.stub(:send_request).with("/document?collection=4590", post: { "name" => "The Dude" }).and_return do
+          server_response('documents/new-4590-333')
         end
+        @database.stub(:send_request).with("/document/4590/333").and_return { server_response('documents/4590-333') }
 
-        it "should limit to a certain amount" do
-          @database.stub(:send_request).with("/simple/all", put: {"collection" => "example_1", "limit" => 1}).and_return { server_response('simple-queries/all_skip') }
-          @database.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1", "limit" => 1})
+        # Documents need to get initialized:
+        Ashikawa::Core::Document.should_receive(:new)
 
-          Ashikawa::Core::Cursor.should_receive(:new)
+        subject << {"name" => "The Dude"}
+      end
 
-          subject.all :limit => 1
+      it "should raise an exception if a document is not found" do
+        @database.stub(:send_request).with("/document/4590/333") do
+          raise RestClient::ResourceNotFound
         end
+        @database.should_receive(:send_request).with("/document/4590/333")
 
-        it "should skip documents" do
-          @database.stub(:send_request).with("/simple/all", put: {"collection" => "example_1", "skip" => 1}).and_return { server_response('simple-queries/all_limit') }
-          @database.should_receive(:send_request).with("/simple/all", put: {"collection" => "example_1", "skip" => 1})
-
-          Ashikawa::Core::Cursor.should_receive(:new)
-
-          subject.all :skip => 1
-        end
+        expect { subject[333] }.to raise_error(Ashikawa::Core::DocumentNotFoundException)
       end
 
       describe "indices" do
@@ -245,91 +230,6 @@ describe Ashikawa::Core::Collection do
           indices.length.should == 1
         end
       end
-
-      describe "by example" do
-        before(:each) do
-          @example = { :hello => "world" }
-        end
-
-        it "should find documents by example" do
-          @database.stub(:send_request).with("/simple/by-example", put:
-            {"collection" => "example_1", "example" => { :hello => "world"}}
-          ).and_return { server_response('simple-queries/example') }
-          @database.should_receive(:send_request).with("/simple/by-example", put:
-            {"collection" => "example_1", "example" => { :hello => "world"}})
-
-          Ashikawa::Core::Cursor.should_receive(:new)
-
-          subject.by_example example: @example
-        end
-
-        it "should find one document by example" do
-          @database.stub(:send_request).with("/simple/first-example", put:
-            {"collection" => "example_1", "example" => { :hello => "world"}}
-          ).and_return { server_response('simple-queries/example') }
-          @database.should_receive(:send_request).with("/simple/first-example", put:
-            {"collection" => "example_1", "example" => { :hello => "world"}})
-
-          Ashikawa::Core::Document.should_receive(:new)
-
-          subject.first_example @example
-        end
-
-        it "should skip documents" do
-          @database.stub(:send_request).with("/simple/by-example", put:
-            {"collection" => "example_1", "skip" => 1, "example" => { :hello => "world"}}
-          ).and_return { server_response('simple-queries/example') }
-          @database.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: @example, :skip => 1
-        end
-
-        it "should limit documents" do
-          @database.stub(:send_request).with("/simple/by-example", put: {"collection" => "example_1", "limit" => 2, "example" => { :hello => "world"}}).and_return { server_response('simple-queries/example') }
-          @database.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: @example, :limit => 2
-        end
-      end
-
-      describe "near" do
-        it "should look for documents based on latitude/longitude" do
-          @database.stub(:send_request).with("/simple/near", put: { "collection" => "example_1", "latitude" => 0, "longitude" => 0 }).and_return { server_response('simple-queries/near') }
-          @database.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
-        end
-      end
-
-      describe "within" do
-        it "should look for documents within a certain radius" do
-          @database.stub(:send_request).with("/simple/within", put: { "collection" => "example_1", "latitude" => 0, "longitude" => 0, "radius" => 2 }).and_return { server_response('simple-queries/within') }
-          @database.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
-        end
-      end
-
-      describe "in range" do
-        it "should look for documents with an attribute within a certain range" do
-          arguments = { "collection" => "example_1", "attribute" => "age", "left" => 50, "right" => 60, "closed" => false}
-          @database.stub(:send_request).with("/simple/range", put: arguments).and_return { server_response('simple-queries/range') }
-          @database.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
-        end
-      end
     end
   end
 end

data/spec/unit/database_spec.rb

@@ -27,6 +27,16 @@ describe Ashikawa::Core::Database do
     database = subject.new "http://localhost:8529"
   end
 
+  it "should create a query" do
+    database = subject.new @connection
+
+    mock Ashikawa::Core::Query
+    Ashikawa::Core::Query.stub(:new)
+    Ashikawa::Core::Query.should_receive(:new).exactly(1).times.with(database)
+
+    database.query
+  end
+
   describe "initialized database" do
     subject { Ashikawa::Core::Database.new @connection }
 
@@ -76,19 +86,5 @@ describe Ashikawa::Core::Database do
 
       subject.send_request "/my/path", post: { data: "mydata" }
     end
-
-    describe "handling queries" do
-      it "should send a query to the server" do
-        @connection.stub(:send_request).and_return { server_response("cursor/query") }
-        @connection.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(subject, server_response("cursor/query"))
-
-        subject.query "FOR u IN users LIMIT 2 RETURN u", count: true, batch_size: 2
-      end
-    end
   end
 end

data/spec/unit/exception_spec.rb

@@ -0,0 +1,14 @@
+require "ashikawa-core/exceptions/document_not_found"
+require "ashikawa-core/exceptions/no_collection_provided"
+
+describe Ashikawa::Core::DocumentNotFoundException 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

data/spec/unit/query_spec.rb

@@ -0,0 +1,215 @@
+require 'unit/spec_helper'
+require 'ashikawa-core/query'
+
+describe Ashikawa::Core::Query do
+  let(:collection) { double }
+  let(:database) { double }
+
+  describe "initialized with collection" do
+    subject { Ashikawa::Core::Query.new collection }
+
+    before do
+      collection.stub(:name).and_return "example_1"
+      collection.stub(:database).and_return double
+    end
+
+    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"})
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        subject.all
+      end
+
+      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})
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        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})
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        subject.all skip: 1
+      end
+    end
+
+    describe "first by example" do
+      let(:example) { {:hello => "world"} }
+
+      it "should find exactly one fitting document" 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" => "example_1", "example" => { :hello => "world"}})
+
+        Ashikawa::Core::Document.should_receive(:new)
+
+        subject.first_example example
+      end
+    end
+
+    describe "all by example" do
+      let(:example) { {:hello => "world"} }
+
+      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" => "example_1", "example" => { :hello => "world"}})
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        subject.by_example example
+      end
+
+      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"}})
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        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" => "example_1", "skip" => 1, "example" => { :hello => "world"}})
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        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 })
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        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 })
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        subject.within latitude: 0, longitude: 0, radius: 2
+      end
+    end
+
+    describe "in a certain range" 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)
+
+        Ashikawa::Core::Cursor.should_receive(:new)
+
+        subject.in_range attribute: "age", left: 50, right: 60, closed: false
+      end
+    end
+
+    describe "with an AQL 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: {
+          "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
+      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: {
+          "query" => query
+        })
+
+        subject.valid?(query).should be_true
+      end
+
+      it "should return false when asked if an invalid query is valid" do
+        query = "FOR u IN users LIMIT 2"
+
+        collection.stub(:send_request) do
+          raise RestClient::BadRequest
+        end
+        collection.should_receive(:send_request).with("/query", post: {
+          "query" => query
+        })
+
+        subject.valid?(query).should be_false
+      end
+    end
+  end
+
+  describe "initialized with database" do
+    subject { Ashikawa::Core::Query.new database}
+
+    it "should throw an exception when a simple query is executed" do
+      [:all, :by_example, :first_example, :near, :within, :in_range].each do |method|
+        expect { subject.send method }.to raise_error Ashikawa::Core::NoCollectionProvidedException
+      end
+    end
+
+    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: {
+          "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
+      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: {
+          "query" => query
+        })
+
+        subject.valid?(query).should be_true
+      end
+
+      it "should return false when asked if an invalid query is valid" do
+        query = "FOR u IN users LIMIT 2"
+
+        database.stub(:send_request) do
+          raise RestClient::BadRequest
+        end
+        database.should_receive(:send_request).with("/query", post: {
+          "query" => query
+        })
+
+        subject.valid?(query).should be_false
+      end
+    end
+  end
+end

data/spec/unit/spec_helper.rb

@@ -1,6 +1,12 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
+require 'simplecov'
+SimpleCov.start do
+    add_filter "spec/"
+end
+SimpleCov.minimum_coverage 100
+
 # For HTTP Testing
 require 'webmock/rspec'
 require 'json'
@@ -8,4 +14,4 @@ require 'json'
 # Helper to simulate Server Responses. Parses the fixtures in the spec folder
 def server_response(path)
   return JSON.parse(File.readlines("spec/fixtures/#{path}.json").join)
-end
+end