ashikawa-core 0.8.0 → 0.9.0

data/spec/unit/edge_spec.rb

@@ -1,54 +1,66 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/edge'
 
 describe Ashikawa::Core::Edge do
   let(:database) { double }
-  let(:raw_data) {
+  let(:id) { 412 }
+  let(:path) { 'edge/412' }
+  let(:key) { double }
+  let(:revision) { double }
+  let(:from_id) { double }
+  let(:to_id) { double }
+  let(:first_name) { double }
+  let(:last_name) { double }
+  let(:raw_data) do
     {
-      "_id" => "1234567/2345678",
-      "_key" => "2345678",
-      "_rev" => "3456789",
-      "_from" => "7848004/9289796",
-      "_to" => "7848004/9355332",
-      "first_name" => "The",
-      "last_name" => "Dude"
+      '_id' => id,
+      '_key' => key,
+      '_rev' => revision,
+      '_from' => from_id,
+      '_to' => to_id,
+      'first_name' => first_name,
+      'last_name' => last_name
     }
-  }
-  subject { Ashikawa::Core::Edge }
-
-  it "should initialize data" do
-    document = subject.new(database, raw_data)
-    document.id.should == "1234567/2345678"
-    document.key.should == "2345678"
-    document.revision.should == "3456789"
   end
+  let(:new_last_name) { double }
+  let(:raw_data_without_meta_data_and_new_last_name) do
+    {
+      'first_name' => first_name,
+      'last_name' => new_last_name
+    }
+  end
+
+  describe 'initialized edge' do
+    subject { Ashikawa::Core::Edge.new(database, raw_data) }
 
-  describe "initialized edge" do
-    subject { Ashikawa::Core::Edge.new(database, raw_data)}
+    its(:id) { should be(id) }
+    its(:key) { should be(key) }
+    its(:revision) { should be(revision) }
+    its(:from_id) { should eq(from_id) }
+    its(:to_id) { should eq(to_id) }
 
-    it "should be deletable" do
-      database.should_receive(:send_request).with("edge/#{raw_data['_id']}",
-        { :delete => {} }
-      )
+    it 'should be deletable' do
+      expect(database).to receive(:send_request)
+        .with(path, { delete: {} })
 
       subject.delete
     end
 
-    it "should store changes to the database" do
-      database.should_receive(:send_request).with("edge/#{raw_data['_id']}",
-        { :put => { "first_name" => "The", "last_name" => "Other" } }
-      )
+    it 'should store changes to the database' do
+      expect(database).to receive(:send_request)
+        .with(path, { put: raw_data_without_meta_data_and_new_last_name })
 
-      subject["last_name"] = "Other"
+      subject['last_name'] = new_last_name
       subject.save
     end
+  end
 
-    it "should know the ID of the 'from' document" do
-      subject.from_id.should == "7848004/9289796"
-    end
+  describe 'initializing edge with additional data' do
+    let(:more_info) { double }
+    let(:additional_data) {{ more_info: more_info }}
+    subject { Ashikawa::Core::Edge.new(database, raw_data, additional_data) }
 
-    it "should know the ID of the 'to' document" do
-      subject.to_id.should == "7848004/9355332"
-    end
+    its(['more_info']) { should eq(more_info) }
   end
 end

data/spec/unit/exception_spec.rb

@@ -1,65 +1,55 @@
-require "ashikawa-core/exceptions/no_collection_provided"
-require "ashikawa-core/exceptions/client_error"
-require "ashikawa-core/exceptions/client_error/bad_syntax"
-require "ashikawa-core/exceptions/client_error/resource_not_found"
-require "ashikawa-core/exceptions/client_error/resource_not_found/document_not_found"
-require "ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found"
-require "ashikawa-core/exceptions/client_error/resource_not_found/index_not_found"
-require "ashikawa-core/exceptions/server_error"
-require "ashikawa-core/exceptions/server_error/json_error"
+# -*- encoding : utf-8 -*-
+require 'ashikawa-core/exceptions/no_collection_provided'
+require 'ashikawa-core/exceptions/client_error'
+require 'ashikawa-core/exceptions/client_error/authentication_failed'
+require 'ashikawa-core/exceptions/client_error/bad_syntax'
+require 'ashikawa-core/exceptions/client_error/resource_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/document_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/index_not_found'
+require 'ashikawa-core/exceptions/server_error'
+require 'ashikawa-core/exceptions/server_error/json_error'
 
 describe Ashikawa::Core::NoCollectionProvidedException do
-  it "should have a good explanation" do
-    subject.to_s.should include "without a collection"
-  end
+  its(:to_s) { should include 'without a collection' }
 end
 
 describe Ashikawa::Core::ClientError do
-  let(:error_message) { "error message" }
-  it "should have a good explanation" do
-    Ashikawa::Core::ClientError.new(error_message).to_s.should == error_message
-  end
+  let(:error_message) { double }
+  subject { Ashikawa::Core::ClientError.new(error_message) }
+  its(:to_s) { should be(error_message) }
 end
 
 describe Ashikawa::Core::BadSyntax do
-  it "should have a good explanation" do
-    subject.to_s.should include "syntax"
-  end
+  its(:to_s) { should include 'syntax' }
+end
+
+describe Ashikawa::Core::AuthenticationFailed do
+  its(:to_s) { should include 'Authentication failed' }
 end
 
 describe Ashikawa::Core::ResourceNotFound do
-  it "should have a good explanation" do
-    subject.to_s.should include "was not found"
-  end
+  its(:to_s) { should include 'was not found' }
 end
 
 describe Ashikawa::Core::DocumentNotFoundException do
-  it "should have a good explanation" do
-    subject.to_s.should include "does not exist"
-  end
+  its(:to_s) { should include 'does not exist' }
 end
 
 describe Ashikawa::Core::CollectionNotFoundException do
-  it "should have a good explanation" do
-    subject.to_s.should include "does not exist"
-  end
+  its(:to_s) { should include 'does not exist' }
 end
 
 describe Ashikawa::Core::IndexNotFoundException do
-  it "should have a good explanation" do
-    subject.to_s.should include "does not exist"
-  end
+  its(:to_s) { should include 'does not exist' }
 end
 
 describe Ashikawa::Core::ServerError do
-  let(:error_message) { "error message" }
-  it "should have a good explanation" do
-    Ashikawa::Core::ServerError.new(error_message).to_s.should == error_message
-  end
+  let(:error_message) { double }
+  subject { Ashikawa::Core::ServerError.new(error_message) }
+  its(:to_s) { should be(error_message) }
 end
 
 describe Ashikawa::Core::JsonError do
-  it "should have a good explanation" do
-    subject.to_s.should include "JSON from the server"
-  end
+  its(:to_s) { should include 'JSON from the server' }
 end

data/spec/unit/figure_spec.rb

@@ -1,61 +1,58 @@
-require "ashikawa-core/figure"
+# -*- encoding : utf-8 -*-
+require 'ashikawa-core/figure'
 
 describe Ashikawa::Core::Figure do
-  let(:raw_figures) {
+  let(:alive_size) { double }
+  let(:alive_count) { double }
+  let(:dead_size) { double }
+  let(:dead_count) { double }
+  let(:dead_deletion) { double }
+  let(:datafiles_count) { double }
+  let(:datafiles_file_size) { double }
+  let(:journals_count) { double }
+  let(:journals_file_size) { double }
+  let(:shapes_count) { double }
+  let(:attributes_count) { double }
+
+  let(:raw_figures) do
     {
-      "alive" => {
-        "size" => 0,
-        "count" => 0
+      'alive' => {
+        'size' => alive_size,
+        'count' => alive_count
       },
-      "dead" => {
-        "size" => 2384,
-        "count" => 149,
-        "deletion" => 0
+      'dead' => {
+        'size' => dead_size,
+        'count' => dead_count,
+        'deletion' => dead_deletion
       },
-      "datafiles" => {
-        "count" => 1,
-        "fileSize" => 124
+      'datafiles' => {
+        'count' => datafiles_count,
+        'fileSize' => datafiles_file_size
       },
-      "journals" => {
-        "count" => 1,
-        "fileSize" => 124
+      'journals' => {
+        'count' => journals_count,
+        'fileSize' => journals_file_size
       },
-      "shapes" => {
-        "count" => 2
+      'shapes' => {
+        'count' => shapes_count
       },
-      "attributes" => {
-        "count" => 12
+      'attributes' => {
+        'count' => attributes_count
       }
     }
-  }
-  subject { Ashikawa::Core::Figure.new(raw_figures) }
-
-  it "should check for the alive figures" do
-    subject.alive_size.should == 0
-    subject.alive_count.should == 0
-  end
-
-  it "should check for the dead figures" do
-    subject.dead_size.should == 2384
-    subject.dead_count.should == 149
-    subject.dead_deletion.should == 0
-  end
-
-  it "should check for the datafiles figures" do
-    subject.datafiles_count.should == 1
-    subject.datafiles_file_size.should == 124
-  end
-
-  it "should check for the journal figures" do
-    subject.journals_count.should == 1
-    subject.journals_file_size.should == 124
   end
 
-  it "should check for the shapes figure" do
-    subject.shapes_count.should == 2
-  end
+  subject { Ashikawa::Core::Figure.new(raw_figures) }
 
-  it "should check for the attributes_count figure" do
-    subject.attributes_count.should == 12
-  end
+  its(:alive_size)          { should be(alive_size) }
+  its(:alive_count)         { should be(alive_count) }
+  its(:dead_size)           { should be(dead_size) }
+  its(:dead_count)          { should be(dead_count) }
+  its(:dead_deletion)       { should be(dead_deletion) }
+  its(:datafiles_count)     { should be(datafiles_count) }
+  its(:datafiles_file_size) { should be(datafiles_file_size) }
+  its(:journals_count)      { should be(journals_count) }
+  its(:journals_file_size)  { should be(journals_file_size) }
+  its(:shapes_count)        { should be(shapes_count) }
+  its(:attributes_count)    { should be(attributes_count) }
 end

data/spec/unit/index_spec.rb

@@ -1,37 +1,40 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/index'
 
 describe Ashikawa::Core::Index do
   let(:collection) { double }
-  let(:raw_data) {
+  let(:id) { '167137465/168054969' }
+  let(:path) { 'index/167137465/168054969' }
+  let(:delete_payload) {{ delete: {} }}
+  let(:type_as_sym) { double }
+  let(:type) { double(to_sym: type_as_sym) }
+  let(:field_as_sym) { double }
+  let(:field) { double(to_sym: field_as_sym) }
+  let(:unique) { double }
+  let(:raw_data) do
     {
-      "code" => 201,
-      "fields" => [
-        "something"
-      ],
-      "id" => "167137465/168054969",
-      "type" => "hash",
-      "isNewlyCreated" => true,
-      "unique" => true,
-      "error" => false
+      'code' => 201,
+      'fields' => [field],
+      'id' => id,
+      'type' => type,
+      'isNewlyCreated' => true,
+      'unique' => unique,
+      'error' => false
     }
-  }
-  subject { Ashikawa::Core::Index }
-
-  it "should initialize an Index" do
-    index = subject.new collection, raw_data
-    index.id.should == "167137465/168054969"
-    index.type.should == :hash
-    index.on.should == [:something]
-    index.unique.should == true
   end
 
-  describe "initialized index" do
-    subject { Ashikawa::Core::Index.new collection, raw_data }
+  describe 'initialized index' do
+    subject { Ashikawa::Core::Index.new(collection, raw_data) }
+
+    its(:id) { should be(id) }
+    its(:type) { should be(type_as_sym) }
+    its(:on) { should include(field_as_sym) }
+    its(:unique) { should be(unique) }
 
-    it "should be deletable" do
-      collection.should_receive(:send_request).with("index/167137465/168054969",
-        :delete => {})
+    it 'should be deletable' do
+      expect(collection).to receive(:send_request)
+        .with(path, delete_payload)
 
       subject.delete
     end

data/spec/unit/key_options_spec.rb

@@ -1,25 +1,27 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/key_options'
 
 describe Ashikawa::Core::KeyOptions do
-  subject { Ashikawa::Core::KeyOptions }
-
-  it "should parse the key options" do
-    type = double
-    offset = double
-    increment = double
-    allow_user_keys = double
+  let(:type) { double }
+  let(:offset) { double }
+  let(:increment) { double }
+  let(:allow_user_keys) { double }
+  let(:raw_key_options) do
+    {
+      'type' => type,
+      'offset' => offset,
+      'increment' => increment,
+      'allowUserKeys' => allow_user_keys
+    }
+  end
 
-    key_options = subject.new({
-      "type" => type,
-      "offset" => offset,
-      "increment" => increment,
-      "allowUserKeys" => allow_user_keys
-    })
+  describe 'initialized key options' do
+    subject { Ashikawa::Core::KeyOptions.new(raw_key_options) }
 
-    key_options.type.should == type
-    key_options.offset.should == offset
-    key_options.increment.should == increment
-    key_options.allow_user_keys.should == allow_user_keys
+    its(:type) { should eq(type) }
+    its(:offset) { should eq(offset) }
+    its(:increment) { should eq(increment) }
+    its(:allow_user_keys) { should eq(allow_user_keys) }
   end
 end

data/spec/unit/query_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/query'
 
@@ -5,210 +6,260 @@ describe Ashikawa::Core::Query do
   let(:collection) { double }
   let(:database) { double }
 
-  describe "initialized with collection" do
-    subject { Ashikawa::Core::Query.new collection }
+  describe 'initialized with collection' do
+    subject { Ashikawa::Core::Query.new(collection) }
+    let(:name) { double }
 
     before do
-      collection.stub(:name).and_return "example_1"
-      collection.stub(:database).and_return double
+      allow(collection).to receive(:name).and_return(name)
+      allow(collection).to receive(: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"})
+    describe 'get all' do
+      let(:limit) { double }
+      let(:skip) { double }
 
-        Ashikawa::Core::Cursor.should_receive(:new)
+      it 'should list all documents' do
+        expect(collection).to receive(:send_request)
+          .with('simple/all', put: { 'collection' => name })
+          .and_return { server_response('simple-queries/all') }
+        expect(Ashikawa::Core::Cursor).to 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})
+      it 'should be able to limit the number of documents' do
+        expect(collection).to receive(:send_request)
+          .with('simple/all', put: { 'collection' => name, 'limit' => limit })
+          .and_return { server_response('simple-queries/all_skip') }
+        expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        Ashikawa::Core::Cursor.should_receive(:new)
-
-        subject.all :limit => 1
+        subject.all(limit: limit)
       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)
+      it 'should be able to skip documents' do
+        expect(collection).to receive(:send_request)
+          .with('simple/all', put: { 'collection' => name, 'skip' => skip })
+          .and_return { server_response('simple-queries/all_limit') }
+        expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.all :skip => 1
+        subject.all(skip: skip)
       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 }
+    describe 'first by example' do
+      let(:example) { double }
+      let(:response) { server_response('simple-queries/example') }
 
-        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"}})
+      it 'should find exactly one fitting document' do
+        allow(collection).to receive(:database)
+          .and_return(double)
+        expect(collection).to receive(:send_request)
+          .with('simple/first-example', put: { 'collection' => name, 'example' => example })
+          .and_return(response)
+        expect(Ashikawa::Core::Document).to receive(:new)
 
-        Ashikawa::Core::Document.should_receive(:new)
-
-        subject.first_example example
+        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"}})
+    describe 'all by example' do
+      let(:example) {{ hello: 'world' }}
+      let(:response) { server_response('simple-queries/example') }
+      let(:limit) { double }
+      let(:skip) { double }
 
-        Ashikawa::Core::Cursor.should_receive(:new)
+      it 'should find all fitting documents' do
+        expect(collection).to receive(:send_request)
+          .with('simple/by-example', put: { 'collection' => name, 'example' => example })
+          .and_return(response)
+        expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.by_example example
+        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"}})
+      it 'should be able to limit the number of documents' do
+        expect(collection).to receive(:send_request)
+          .with('simple/by-example', put: { 'collection' => name, 'limit' => limit, 'example' => example })
+          .and_return(response)
+        expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        Ashikawa::Core::Cursor.should_receive(:new)
-
-        subject.by_example example, :limit => 2
+        subject.by_example(example, limit: limit)
       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)
+      it 'should be able to skip documents' do
+        expect(collection).to receive(:send_request)
+          .with('simple/by-example', put: { 'collection' => name, 'skip' => skip, 'example' => example })
+          .and_return(response)
+        expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.by_example example, :skip => 1
+        subject.by_example(example, skip: skip)
       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 })
+    describe 'near a geolocation' do
+      let(:latitude) { double }
+      let(:longitude) { double }
+      let(:arguments) do
+        {
+          'collection' => name,
+          'latitude' => latitude,
+          'longitude' => longitude
+        }
+      end
+      let(:response) { server_response('simple-queries/near') }
 
-        Ashikawa::Core::Cursor.should_receive(:new)
+      it 'should find documents based on latitude/longitude' do
+        expect(collection).to receive(:send_request)
+          .with('simple/near', put: arguments)
+          .and_return { response }
+        expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.near :latitude => 0, :longitude => 0
+        subject.near(latitude: latitude, longitude: longitude)
       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 })
+    describe 'within a radius of a geolocation' do
+      let(:latitude) { double }
+      let(:longitude) { double }
+      let(:radius) { double }
+      let(:arguments) do
+        {
+          'collection' => name,
+          'latitude' => latitude,
+          'longitude' => longitude,
+          'radius' => radius
+        }
+      end
+      let(:response) { server_response('simple-queries/within') }
 
-        Ashikawa::Core::Cursor.should_receive(:new)
+      it 'should look for documents based on latidude/longitude' do
+        expect(collection).to receive(:send_request)
+          .with('simple/within' , put: arguments)
+          .and_return { response }
+        expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.within :latitude => 0, :longitude => 0, :radius => 2
+        subject.within(latitude: latitude, longitude: longitude, radius: radius)
       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)
+    describe 'in a certain range' do
+      let(:attribute) { double }
+      let(:left) { double }
+      let(:right) { double }
+      let(:closed) { double }
+      let(:arguments) do
+        {
+          'collection' => name,
+          'attribute' => attribute,
+          'left' => left,
+          'right' => right,
+          'closed' => closed
+        }
+      end
+      let(:response) { server_response('simple-queries/range') }
 
-        Ashikawa::Core::Cursor.should_receive(:new)
+      it 'should look for documents with an attribute in that range' do
+        expect(collection).to receive(:send_request)
+          .with('simple/range' , put: arguments)
+          .and_return { response }
+        expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.in_range :attribute => "age", :left => 50, :right => 60, :closed => false
+        subject.in_range(attribute: attribute, left: left, right: right, closed: closed)
       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
+    describe 'with an AQL query' do
+      let(:query) { double }
+      let(:count) { double }
+      let(:batch_size) { double }
+      let(:arguments) do
+        {
+          'query' => query,
+          'count' => count,
+          'batchSize' => batch_size
+        }
+      end
+      let(:response) { server_response('cursor/query') }
+
+      it 'should be able to execute it' do
+        allow(collection).to receive(:database)
+          .and_return(double)
+        expect(collection).to receive(:send_request)
+          .with('cursor', post: arguments)
+          .and_return(response)
+        expect(Ashikawa::Core::Cursor).to receive(:new)
+          .with(collection.database, response)
+
+        subject.execute(query, count: count, batch_size: batch_size)
       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
-        })
+      it 'should return true when asked if a valid query is valid' do
+        expect(collection).to receive(:send_request)
+          .with('query', post: { 'query' => query })
+          .and_return { server_response('query/valid') }
 
-        subject.valid?(query).should be_true
+        expect(subject.valid?(query)).to 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 Ashikawa::Core::BadSyntax
-        end
-        collection.should_receive(:send_request).with("query", :post => {
-          "query" => query
-        })
+      it 'should return false when asked if an invalid query is valid' do
+        allow(collection).to receive(:send_request)
+          .and_raise(Ashikawa::Core::BadSyntax)
+        expect(collection).to receive(:send_request)
+          .with('query', post: { 'query' => query })
 
-        subject.valid?(query).should be_false
+        expect(subject.valid?(query)).to be_false
       end
     end
   end
 
-  describe "initialized with database" do
-    subject { Ashikawa::Core::Query.new database}
+  describe 'initialized with database' do
+    subject { Ashikawa::Core::Query.new(database) }
 
-    it "should throw an exception when a simple query is executed" do
+    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
+        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
+    describe 'with an AQL query' do
+      let(:query) { double }
+      let(:count) { double }
+      let(:batch_size) { double }
+      let(:arguments) do
+        {
+          'query' => query,
+          'count' => count,
+          'batchSize' => batch_size
+        }
       end
+      let(:query_response) { server_response('cursor/query') }
+      let(:valid_response) { server_response('cursor/query') }
 
-      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
-        })
+      it 'should be able to execute it' do
+        expect(database).to receive(:send_request)
+          .with('cursor', post: arguments)
+          .and_return(query_response)
+        expect(Ashikawa::Core::Cursor).to receive(:new)
+          .with(database, query_response)
 
-        subject.valid?(query).should be_true
+        subject.execute(query, count: count, batch_size: batch_size)
       end
 
-      it "should return false when asked if an invalid query is valid" do
-        query = "FOR u IN users LIMIT 2"
+      it 'should return true when asked if a valid query is valid' do
+        expect(database).to receive(:send_request)
+          .with('query', post: { 'query' => query })
+          .and_return { valid_response }
+
+        expect(subject.valid?(query)).to be_true
+      end
 
-        database.stub(:send_request) do
-          raise Ashikawa::Core::BadSyntax
-        end
-        database.should_receive(:send_request).with("query", :post => {
-          "query" => query
-        })
+      it 'should return false when asked if an invalid query is valid' do
+        expect(database).to receive(:send_request)
+          .with('query', post: { 'query' => query })
+          .and_raise(Ashikawa::Core::BadSyntax)
 
-        subject.valid?(query).should be_false
+        expect(subject.valid?(query)).to be_false
       end
     end
   end