ashikawa-core 0.8.0 → 0.9.0

data/spec/acceptance/index_spec.rb

@@ -1,32 +1,35 @@
+# -*- encoding : utf-8 -*-
 require 'acceptance/spec_helper'
 
-describe "Indices" do
-  let(:database) {
-    Ashikawa::Core::Database.new do |config|
-      config.url = ARANGO_HOST
-    end
-  }
-  subject { database["documenttest"] }
-  let(:index) { subject.add_index(:skiplist, :on => [:identifier]) }
+describe 'Indices' do
+  let(:database) { DATABASE }
+  subject { database['documenttest'] }
+  let(:index) { subject.add_index(:skiplist, on: [:identifier]) }
 
-  it "should be possible to set indices" do
+  it 'should be possible to set indices' do
     index.delete
 
     expect {
-      subject.add_index :skiplist, :on => [:identifier]
+      subject.add_index :skiplist, on: [:identifier]
     }.to change { subject.indices.length }.by(1)
   end
 
-  it "should be possible to get an index by ID" do
+  it 'should be possible to get an index by ID' do
     # This is temporary until Index has a key
     index_key = index.id.split('/')[1]
 
-    subject.index(index_key).id.should == index.id
-    subject.indices[0].class.should == Ashikawa::Core::Index
+    expect(subject.index(index_key).id).to eq(index.id)
+    expect(subject.indices[0].class).to eq(Ashikawa::Core::Index)
   end
 
-  it "should be possible to remove indices" do
-    pending "See Bug #34"
+  it 'should be possible to create an unique index' do
+    index = subject.add_index :skiplist, on: [:identifier], unique: true
+
+    expect(index.unique).to be_true
+  end
+
+  it 'should be possible to remove indices' do
+    pending 'See Bug #34'
 
     expect {
       index.delete

data/spec/acceptance/query_spec.rb

@@ -1,98 +1,95 @@
+# -*- encoding : utf-8 -*-
 require 'acceptance/spec_helper'
 
-describe "Queries" do
-  let(:database) {
-    Ashikawa::Core::Database.new do |config|
-      config.url = ARANGO_HOST
-    end
-  }
-  let(:collection) { database["my_collection"] }
-
-  describe "AQL query via the database" do
-    it "should return the documents" do
-      query = "FOR u IN my_collection FILTER u.bowling == true RETURN u"
-      options = { :batch_size => 2, :count => true }
-
-      collection.create_document({ "name" => "Jeff Lebowski",    "bowling" => true })
-      collection.create_document({ "name" => "Walter Sobchak",   "bowling" => true })
-      collection.create_document({ "name" => "Donny Kerabatsos", "bowling" => true })
-      collection.create_document({ "name" => "Jeffrey Lebowski", "bowling" => false })
-
-      names = database.query.execute(query, options).map { |person| person["name"] }
-      names.should     include "Jeff Lebowski"
-      names.should_not include "Jeffrey Lebowski"
+describe 'Queries' do
+  let(:database) { DATABASE }
+  let(:collection) { database['my_collection'] }
+
+  describe 'AQL query via the database' do
+    it 'should return the documents' do
+      query = 'FOR u IN my_collection FILTER u.bowling == true RETURN u'
+      options = { batch_size: 2, count: true }
+
+      collection.create_document({ 'name' => 'Jeff Lebowski',    'bowling' => true })
+      collection.create_document({ 'name' => 'Walter Sobchak',   'bowling' => true })
+      collection.create_document({ 'name' => 'Donny Kerabatsos', 'bowling' => true })
+      collection.create_document({ 'name' => 'Jeffrey Lebowski', 'bowling' => false })
+
+      names = database.query.execute(query, options).map { |person| person['name'] }
+      expect(names).to     include 'Jeff Lebowski'
+      expect(names).not_to include 'Jeffrey Lebowski'
     end
 
-    it "should be possible to validate" do
-      valid_query = "FOR u IN my_collection FILTER u.bowling == true RETURN u"
-      database.query.valid?(valid_query).should be_true
+    it 'should be possible to validate' do
+      valid_query = 'FOR u IN my_collection FILTER u.bowling == true RETURN u'
+      expect(database.query.valid?(valid_query)).to be_true
 
-      invalid_query = "FOR u IN my_collection FILTER u.bowling == true"
-      database.query.valid?(invalid_query).should be_false
+      invalid_query = 'FOR u IN my_collection FILTER u.bowling == true'
+      expect(database.query.valid?(invalid_query)).to be_false
     end
   end
 
-  describe "simple query via collection object" do
+  describe 'simple query via collection object' do
     subject { collection }
     before(:each) { subject.truncate! }
 
-    it "should return all documents of a collection" do
-      subject.create_document({ :name => "testname", :age => 27})
-      subject.query.all.first["name"].should == "testname"
+    it 'should return all documents of a collection' do
+      subject.create_document({ name: 'testname', age: 27 })
+      expect(subject.query.all.first['name']).to eq('testname')
     end
 
-    it "should be possible to limit and skip results" do
-      subject.create_document({ :name => "test1"})
-      subject.create_document({ :name => "test2"})
-      subject.create_document({ :name => "test3"})
+    it 'should be possible to limit and skip results' do
+      subject.create_document({ name: 'test1' })
+      subject.create_document({ name: 'test2' })
+      subject.create_document({ name: 'test3' })
 
-      subject.query.all(:limit => 2).length.should == 2
-      subject.query.all(:skip => 2).length.should == 1
+      expect(subject.query.all(limit: 2).length).to eq(2)
+      expect(subject.query.all(skip: 2).length).to eq(1)
     end
 
-    it "should be possible to query documents by example" do
-      subject.create_document({ "name" => "Random Document" })
-      result = subject.query.by_example :name => "Random Document"
-      result.length.should == 1
+    it 'should be possible to query documents by example' do
+      subject.create_document({ 'name' => 'Random Document' })
+      result = subject.query.by_example name: 'Random Document'
+      expect(result.length).to eq(1)
     end
 
-    it "should be possible to query first document by example" do
-      subject.create_document({ "name" => "Single Document" })
-      result = subject.query.first_example :name => "Single Document"
-      result["name"].should == "Single Document"
+    it 'should be possible to query first document by example' do
+      subject.create_document({ 'name' => 'Single Document' })
+      result = subject.query.first_example name: 'Single Document'
+      expect(result['name']).to eq('Single Document')
     end
 
-    describe "query by geo coordinates" do
+    describe 'query by geo coordinates' do
       before :each do
-        subject.add_index :geo, :on => [:latitude, :longitude]
-        subject.create_document({ "name" => "cologne", "latitude" => 50.948045, "longitude" => 6.961212 })
-        subject.create_document({ "name" => "san francisco", "latitude" => -122.395899, "longitude" => 37.793621 })
+        subject.add_index :geo, on: [:latitude, :longitude]
+        subject.create_document({ 'name' => 'cologne', 'latitude' => 50.948045, 'longitude' => 6.961212 })
+        subject.create_document({ 'name' => 'san francisco', 'latitude' => -122.395899, 'longitude' => 37.793621 })
       end
 
-      it "should be possible to query documents near a certain location" do
-        found_places = subject.query.near :latitude => 50, :longitude => 6
-        found_places.first["name"].should == "cologne"
+      it 'should be possible to query documents near a certain location' do
+        found_places = subject.query.near latitude: 50, longitude: 6
+        expect(found_places.first['name']).to eq('cologne')
       end
 
-      it "should be possible to query documents within a certain range" do
-        found_places = subject.query.within :latitude => 50.948040, :longitude => 6.961210, :radius => 2
-        found_places.length.should == 1
-        found_places.first["name"].should == "cologne"
+      it 'should be possible to query documents within a certain range' do
+        found_places = subject.query.within latitude: 50.948040, longitude: 6.961210, radius: 2
+        expect(found_places.length).to eq(1)
+        expect(found_places.first['name']).to eq('cologne')
       end
     end
 
-    describe "queries by integer ranges" do
+    describe 'queries by integer ranges' do
       before :each do
-        subject.add_index :skiplist, :on => [:age]
-        subject.create_document({ "name" => "Georg", "age" => 12 })
-        subject.create_document({ "name" => "Anne", "age" => 21 })
-        subject.create_document({ "name" => "Jens", "age" => 49 })
+        subject.add_index :skiplist, on: [:age]
+        subject.create_document({ 'name' => 'Georg', 'age' => 12 })
+        subject.create_document({ 'name' => 'Anne', 'age' => 21 })
+        subject.create_document({ 'name' => 'Jens', 'age' => 49 })
       end
 
-      it "should be possible to query documents for numbers in a certain range" do
-        found_people = subject.query.in_range :attribute => "age", :left => 20, :right => 30, :closed => true
-        found_people.length.should == 1
-        found_people.first["name"].should == "Anne"
+      it 'should be possible to query documents for numbers in a certain range' do
+        found_people = subject.query.in_range attribute: 'age', left: 20, right: 30, closed: true
+        expect(found_people.length).to eq(1)
+        expect(found_people.first['name']).to eq('Anne')
       end
     end
   end

data/spec/acceptance/spec_helper.rb

@@ -1,6 +1,29 @@
+# -*- encoding : utf-8 -*-
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-require "ashikawa-core"
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 
-ARANGO_HOST = "http://localhost:8529"
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+require 'ashikawa-core'
+
+port = ENV['ARANGODB_PORT'] || 8529
+username = ENV['ARANGODB_USERNAME'] || 'root'
+password = ENV['ARANGODB_PASSWORD'] || ''
+
+# The database instance to use for all specs
+DATABASE = Ashikawa::Core::Database.new do |config|
+  config.url = "http://localhost:#{port}"
+
+  unless ENV['ARANGODB_DISABLE_AUTHENTIFICATION']
+    config.username = username
+    config.password = password
+  end
+end

data/spec/acceptance/transactions_spec.rb

@@ -1,30 +1,26 @@
+# -*- encoding : utf-8 -*-
 require 'acceptance/spec_helper'
 
-describe "Transactions" do
-  subject {
-    Ashikawa::Core::Database.new do |config|
-      config.url = ARANGO_HOST
-    end
-  }
+describe 'Transactions' do
+  subject { DATABASE }
 
   before :each do
     subject.collections.each { |collection| collection.delete }
-    subject["collection_1"]
-    subject["collection_2"]
-    subject["collection_3"]
+    subject['collection_1']
+    subject['collection_2']
+    subject['collection_3']
   end
 
-  let(:js_function) { "function (x) { return x.a; }" }
+  let(:js_function) { 'function (x) { return x.a; }' }
+  let(:write_collections) { %w{collection_1 collection_2} }
+  let(:read_collections) { %w{collection_2} }
 
-  it "should create and execute a transaction" do
-    transaction = subject.create_transaction(js_function,
-      :write => ["collection_1", "collection_2"],
-      :read =>  ["collection_3"]
-    )
+  it 'should create and execute a transaction' do
+    transaction = subject.create_transaction js_function, write: write_collections, read: read_collections
 
     transaction.wait_for_sync = true
     transaction.lock_timeout = 14
 
-    transaction.execute({ :a => 5 }).should == 5
+    expect(transaction.execute({ a: 5 })).to eq(5)
   end
 end

data/spec/setup/arangodb.sh

@@ -3,7 +3,7 @@
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 cd $DIR
 
-VERSION=1.3.0
+# VERSION=1.4.devel
 NAME=ArangoDB-$VERSION
 
 if [ ! -d "$DIR/$NAME" ]; then
@@ -40,7 +40,7 @@ ${ARANGOD} \
   --javascript.package-path ${ARANGODB_DIR}/js/npm:${ARANGODB_DIR}/js/common/test-data/modules \
   --javascript.action-directory ${ARANGODB_DIR}/js/actions  \
   --database.maximal-journal-size 1048576  \
-  --server.disable-admin-interface true \
+  --server.disable-admin-interface ${ARANGODB_DISABLE_AUTHENTIFICATION} \
   --server.disable-authentication true \
   --javascript.gc-interval 1 &
 

data/spec/unit/collection_spec.rb

@@ -1,338 +1,320 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/collection'
 
 describe Ashikawa::Core::Collection do
-  subject { Ashikawa::Core::Collection }
-
-  before :each do
-    @database = double
+  let(:database) { double }
+  let(:raw_document_collection) { server_response('collections/60768679') }
+  let(:raw_edge_collection) do
+    {
+      'id' => '60768679',
+      'name' => 'example_1',
+      'type' => 3
+    }
   end
 
-  it "should have a name" do
-    my_collection = subject.new @database, server_response("collections/60768679")
-    my_collection.name.should == "example_1"
-  end
+  describe 'an initialized collection' do
+    subject { Ashikawa::Core::Collection.new(database, raw_document_collection) }
 
-  it "should accept an ID" do
-    my_collection = subject.new @database, server_response("collections/60768679")
-    my_collection.id.should == "60768679"
-  end
+    let(:raw_key_options) { double }
+    let(:key_options) { double }
+    let(:response) { double }
+    let(:value) { double }
+    let(:figure) { double }
 
-  it "should create a query" do
-    collection = subject.new @database, server_response("collections/60768679")
+    its(:name) { should eq('example_1') }
+    its(:id) { should eq('60768679') }
 
-    double Ashikawa::Core::Query
-    Ashikawa::Core::Query.stub(:new)
-    Ashikawa::Core::Query.should_receive(:new).exactly(1).times.with(collection)
+    it 'should know how many documents the collection has' do
+      allow(response).to receive(:[])
+        .with('count')
+        .and_return(value)
+      expect(database).to receive(:send_request)
+        .with('collection/60768679/count', {})
+        .and_return(response)
 
-    collection.query
-  end
-
-  describe "attributes of a collection" do
-    it "should check if the collection waits for sync" do
-      @database.stub(:send_request).with("collection/60768679/properties", {}).and_return { server_response("collections/60768679-properties") }
-      @database.should_receive(:send_request).with("collection/60768679/properties", {})
-
-      my_collection = subject.new @database, { "id" => "60768679" }
-      my_collection.wait_for_sync?.should be_true
+      expect(subject.length).to be(value)
     end
 
-    it "should know how many documents the collection has" do
-      @database.stub(:send_request).with("collection/60768679/count", {}).and_return { server_response("collections/60768679-count") }
-      @database.should_receive(:send_request).with("collection/60768679/count", {})
+    it 'should check for the figures' do
+      allow(response).to receive(:[])
+        .with('figures')
+        .and_return(value)
+      expect(database).to receive(:send_request)
+        .with('collection/60768679/figures', {})
+        .and_return(response)
 
-      my_collection = subject.new @database, { "id" => "60768679" }
-      my_collection.length.should == 54
-    end
+      expect(Ashikawa::Core::Figure).to receive(:new)
+        .exactly(1).times
+        .with(value)
+        .and_return(figure)
 
-    it "should know if the collection is volatile" do
-      @database.stub(:send_request).with("collection/60768679/properties", {}).and_return { server_response("collections/60768679-properties-volatile") }
-      @database.should_receive(:send_request).with("collection/60768679/properties", {})
-
-      my_collection = subject.new(@database, { "id" => "60768679" })
-      my_collection.volatile?.should == true
-    end
-
-    it "should know if the collection is not volatile" do
-      @database.stub(:send_request).with("collection/60768679/properties", {}).and_return { server_response("collections/60768679-properties") }
-      @database.should_receive(:send_request).with("collection/60768679/properties", {})
-
-      my_collection = subject.new(@database, { "id" => "60768679" })
-      my_collection.volatile?.should == false
+      expect(subject.figure).to be(figure)
     end
 
-    it "should know that a collection is from type 'document'" do
-      my_collection = subject.new(@database, { "id" => "60768679", "type" => 2 })
-      my_collection.content_type.should == :document
-    end
+    it 'should create a query' do
+      expect(Ashikawa::Core::Query).to receive(:new)
+        .exactly(1).times
+        .with(subject)
 
-    it "should know that a collection is from type 'edge'" do
-      my_collection = subject.new(@database, { "id" => "60768679", "type" => 3 })
-      my_collection.content_type.should == :edge
+      subject.query
     end
 
-    it "should check for the figures" do
-      @database.stub(:send_request).with("collection/60768679/figures", {}).and_return { server_response("collections/60768679-figures") }
-      @database.should_receive(:send_request).with("collection/60768679/figures", {}).at_least(1).times
-
-      double Ashikawa::Core::Figure
-      Ashikawa::Core::Figure.stub(:new)
-      Ashikawa::Core::Figure.should_receive(:new).exactly(1).times.with(server_response("collections/60768679-figures")["figures"])
-
-      my_collection = subject.new @database, { "id" => "60768679" }
-      my_collection.figure
-    end
-  end
-
-  describe "an initialized collection" do
-    subject { Ashikawa::Core::Collection.new @database, { "id" => "60768679", "name" => "example_1" } }
-
-    it "should get deleted" do
-      @database.stub(:send_request).with("collection/60768679/", :delete => {})
-      @database.should_receive(:send_request).with("collection/60768679/", :delete => {})
+    it 'should get deleted' do
+      expect(database).to receive(:send_request)
+        .with('collection/60768679/', delete: {})
 
       subject.delete
     end
 
-    it "should get loaded" do
-      @database.stub(:send_request).with("collection/60768679/load", :put => {})
-      @database.should_receive(:send_request).with("collection/60768679/load", :put => {})
+    it 'should get loaded' do
+      expect(database).to receive(:send_request)
+        .with('collection/60768679/load', put: {})
 
       subject.load
     end
 
-    it "should get unloaded" do
-      @database.stub(:send_request).with("collection/60768679/unload", :put => {})
-      @database.should_receive(:send_request).with("collection/60768679/unload", :put => {})
+    it 'should get unloaded' do
+      expect(database).to receive(:send_request)
+        .with('collection/60768679/unload', put: {})
 
       subject.unload
     end
 
-    it "should get truncated" do
-      @database.stub(:send_request).with("collection/60768679/truncate", :put => {})
-      @database.should_receive(:send_request).with("collection/60768679/truncate", :put => {})
+    it 'should get truncated' do
+      expect(database).to receive(:send_request)
+        .with('collection/60768679/truncate', put: {})
 
       subject.truncate!
     end
 
-    it "should change if it waits for sync" do
-      @database.stub(:send_request).with("collection/60768679/properties", :put => {"waitForSync" => true})
-      @database.should_receive(:send_request).with("collection/60768679/properties", :put => {"waitForSync" => true})
+    it 'should change its name' do
+      expect(database).to receive(:send_request)
+        .with('collection/60768679/rename', put: { 'name' => value })
 
-      subject.wait_for_sync = true
+      subject.name = value
     end
 
-    it "should check for the key options" do
-      raw_key_options = double
-      @database.should_receive(:send_request).with("collection/60768679/properties", {}).and_return { { "keyOptions" => raw_key_options } }
-
-      key_options = double
-      Ashikawa::Core::KeyOptions.stub(:new).with(raw_key_options).and_return { key_options }
+    it 'should change if it waits for sync' do
+      expect(database).to receive(:send_request)
+        .with('collection/60768679/properties', put: { 'waitForSync' => value })
 
-      subject.key_options.should == key_options
+      subject.wait_for_sync = value
     end
 
-    it "should change its name" do
-      @database.stub(:send_request).with("collection/60768679/rename", :put => {"name" => "my_new_name"})
-      @database.should_receive(:send_request).with("collection/60768679/rename", :put => {"name" => "my_new_name"})
+    describe 'properties' do
+      before do
+        expect(database).to receive(:send_request)
+          .with('collection/60768679/properties', {})
+          .and_return(response)
+      end
 
-      subject.name = "my_new_name"
-    end
+      it 'should check if the collection waits for sync' do
+        allow(response).to receive(:[])
+          .with('waitForSync')
+          .and_return(value)
 
-    describe "add and get single documents" do
-      it "should receive a document by ID via fetch" do
-        @database.stub(:send_request).with("document/60768679/333", {}).and_return { server_response('documents/example_1-137249191') }
-        @database.should_receive(:send_request).with("document/60768679/333", {})
+        expect(subject.wait_for_sync?).to be(value)
+      end
 
-        # Documents need to get initialized:
-        Ashikawa::Core::Document.should_receive(:new)
+      it 'should know if the collection is volatile' do
+        allow(response).to receive(:[])
+          .with('isVolatile')
+          .and_return(value)
 
-        subject.fetch(333)
+        expect(subject.volatile?).to be(value)
       end
 
-      it "should receive a document by ID via []" do
-        @database.stub(:send_request).with("document/60768679/333", {}).and_return { server_response('documents/example_1-137249191') }
-        @database.should_receive(:send_request).with("document/60768679/333", {})
+      it 'should check for the key options' do
+        allow(response).to receive(:[])
+          .with('keyOptions')
+          .and_return(value)
+        expect(Ashikawa::Core::KeyOptions).to receive(:new)
+          .with(value)
+          .and_return(key_options)
 
-        # Documents need to get initialized:
-        Ashikawa::Core::Document.should_receive(:new)
-
-        subject[333]
+        expect(subject.key_options).to eq(key_options)
       end
+    end
 
-      it "should throw an exception when the document was not found during a fetch" do
-        @database.stub(:send_request).and_return {
-          raise Ashikawa::Core::DocumentNotFoundException
-        }
+    describe 'non-existing documents' do
+      before do
+        allow(database).to receive(:send_request)
+          .and_raise(Ashikawa::Core::DocumentNotFoundException)
+      end
 
-        expect {
+      it 'should throw an exception when using fetch' do
+        expect do
           subject.fetch(123)
-        }.to raise_exception Ashikawa::Core::DocumentNotFoundException
+        end.to raise_exception Ashikawa::Core::DocumentNotFoundException
       end
 
-      it "should return nil when the document was not found when using []" do
-        @database.stub(:send_request).and_return {
-          raise Ashikawa::Core::DocumentNotFoundException
-        }
+      it 'should return nil when using []' do
+        expect(subject[123]).to be_nil
+      end
+    end
 
-        subject[123].should == nil
+    describe 'indexes' do
+      let(:index_response) { double }
+
+      it 'should add a new index' do
+        expect(database).to receive(:send_request)
+          .with('index?collection=60768679', post: {
+            'type' => 'hash', 'fields' => %w{a b}, 'unique' => false
+          })
+          .and_return(index_response)
+        expect(Ashikawa::Core::Index).to receive(:new)
+          .with(subject, index_response)
+
+        subject.add_index(:hash, on: [:a, :b])
       end
 
-      it "should replace a document by ID" do
-        @database.stub(:send_request).with("document/60768679/333", :put => {"name" => "The Dude"})
-        @database.should_receive(:send_request).with("document/60768679/333", :put => {"name" => "The Dude"})
+      it 'should add a new unique index' do
+        expect(database).to receive(:send_request)
+          .with('index?collection=60768679', post: {
+            'type' => 'hash', 'fields' => %w{a b}, 'unique' => true
+          })
+          .and_return(index_response)
+        expect(Ashikawa::Core::Index).to receive(:new)
+          .with(subject, index_response)
 
-        subject.replace(333, {"name" => "The Dude"})
+        subject.add_index(:hash, on: [:a, :b], unique: true)
       end
 
-      it "should create a new document" do
-        @database.stub(:send_request).with("document?collection=60768679", :post => { "name" => "The Dude" }).and_return do
-          server_response('documents/new-example_1-137249191')
-        end
-        @database.stub(:send_request).with("document/60768679/333", :post => {
-          "name" => "The Dude"
-        }).and_return {
-          {
-            "_id" => "example_1/137249191",
-            "_rev" => "137249191",
-            "_key" => "137249191"
-          }
-        }
-        @database.stub(:send_request).with("document/60768679/333", {}).and_return { server_response('documents/example_1-137249191') }
-
-        # Documents need to get initialized:
-        Ashikawa::Core::Document.should_receive(:new).and_return {
-          document = double
-          document.should_receive(:refresh!)
-          document
-        }
-
-        subject.create_document({"name" => "The Dude"})
+      it 'should get an index by ID' do
+        allow(database).to receive(:send_request)
+          .with('index/example_1/168054969')
+          .and_return(index_response)
+        expect(Ashikawa::Core::Index).to receive(:new)
+          .with(subject, index_response)
+
+        subject.index(168_054_969)
       end
 
-      it "should create a new document" do
-        @database.stub(:send_request).with("document?collection=60768679", :post => { "name" => "The Dude" }).and_return do
-          server_response('documents/example_1-137249191')
-        end
-        @database.stub(:send_request).with("document/60768679/333").and_return { server_response('documents/example_1-137249191') }
+      it 'should get all indexes' do
+        multi_index_response = double
+        allow(multi_index_response).to receive(:map)
+          .and_yield(index_response)
 
-        # Documents need to get initialized:
-        Ashikawa::Core::Document.should_receive(:new).and_return {
-          document = double
-          document.should_receive(:refresh!)
-          document
-        }
+        cursor = double
+        allow(cursor).to receive(:[])
+          .with('indexes')
+          .and_return(multi_index_response)
 
-        subject.create_document("name" => "The Dude")
-      end
+        allow(database).to receive(:send_request)
+          .with('index?collection=60768679')
+          .and_return(cursor)
+
+        expect(Ashikawa::Core::Index).to receive(:new)
+          .with(subject, index_response)
 
-      it "should not create a new document" do
-        expect {
-          subject.create_edge(nil, nil, {"quote" => "D'ya have to use s'many cuss words?"})
-        }.to raise_exception(RuntimeError, "Can't create an edge in a document collection")
+        subject.indices
       end
+    end
+  end
 
-      describe "indices" do
-        it "should add a new index" do
-          @database.stub(:send_request).with("index?collection=60768679", :post => {
-            "type" => "hash", "fields" => [ "a", "b" ]
-          }).and_return { server_response('indices/new-hash-index') }
-          @database.should_receive(:send_request).with("index?collection=60768679", :post => {
-            "type" => "hash", "fields" => [ "a", "b" ]
-          })
+  describe 'an initialized document collection' do
+    subject { Ashikawa::Core::Collection.new database, raw_document_collection }
 
-          Ashikawa::Core::Index.should_receive(:new).with(subject,
-            server_response('indices/new-hash-index'))
+    let(:document) { double }
+    let(:response) { double }
+    let(:raw_document) { double }
+    let(:value) { double }
 
-          subject.add_index :hash, :on => [ :a, :b ]
-        end
+    its(:content_type) { should be(:document) }
 
-        it "should get an index by ID" do
-          @database.stub(:send_request).with(
-            "index/example_1/168054969"
-          ).and_return { server_response('indices/hash-index') }
+    it 'should receive a document by ID via fetch' do
+      expect(database).to receive(:send_request)
+        .with('document/60768679/333', {})
+        .and_return(double)
+      expect(Ashikawa::Core::Document).to receive(:new)
 
-          Ashikawa::Core::Index.should_receive(:new).with(subject,
-            server_response('indices/hash-index'))
+      subject.fetch(333)
+    end
 
-          subject.index 168054969
-        end
+    it 'should receive a document by ID via []' do
+      expect(database).to receive(:send_request)
+        .with('document/60768679/333', {})
+        .and_return(double)
+      expect(Ashikawa::Core::Document).to receive(:new)
 
-        it "should get all indices" do
-          @database.stub(:send_request).with(
-            "index?collection=60768679"
-          ).and_return { server_response('indices/all') }
+      subject[333]
+    end
 
-          Ashikawa::Core::Index.should_receive(:new).exactly(1).times
+    it 'should replace a document by ID' do
+      expect(database).to receive(:send_request)
+        .with('document/60768679/333', put: { 'name' => value })
 
-          indices = subject.indices
-          indices.length.should == 1
-        end
-      end
+      subject.replace(333, { 'name' => value })
+    end
+
+    it 'should create a new document' do
+      allow(database).to receive(:send_request)
+        .with('document?collection=60768679', post: raw_document)
+        .and_return(response)
+      expect(Ashikawa::Core::Document).to receive(:new)
+        .with(database, response, raw_document)
+        .and_return(document)
+
+      subject.create_document(raw_document)
+    end
+
+    it 'should not create a new edge' do
+      expect do
+        subject.create_edge(double, double, { 'quote' => "D'ya have to use s'many cuss words?" })
+      end.to raise_exception(RuntimeError, "Can't create an edge in a document collection")
     end
   end
 
-  describe "an initialized edge collection" do
-    subject { Ashikawa::Core::Collection.new @database, { "id" => "60768679", "name" => "example_1", "type" => 3 } }
+  describe 'an initialized edge collection' do
+    subject { Ashikawa::Core::Collection.new database, raw_edge_collection }
+
+    let(:document) { double }
+    let(:response) { double }
+    let(:raw_document) { double }
 
-    it "should receive an edge by ID" do
-      @database.stub(:send_request).with("edge/60768679/333", {}).and_return { server_response('documents/example_1-137249191') }
-      @database.should_receive(:send_request).with("edge/60768679/333", {})
+    its(:content_type) { should be(:edge) }
 
-      # Documents need to get initialized:
-      Ashikawa::Core::Edge.should_receive(:new)
+    it 'should receive an edge by ID via fetch' do
+      expect(database).to receive(:send_request)
+        .with('edge/60768679/333', {})
+        .and_return(double)
+      expect(Ashikawa::Core::Edge).to receive(:new)
 
       subject.fetch(333)
     end
 
-    it "should replace an edge by ID" do
-      @database.stub(:send_request).with("edge/60768679/333", :put => {"name" => "The Dude"})
-      @database.should_receive(:send_request).with("edge/60768679/333", :put => {"name" => "The Dude"})
+    it 'should receive an edge by ID via []' do
+      expect(database).to receive(:send_request)
+        .with('edge/60768679/333', {})
+        .and_return(double)
+      expect(Ashikawa::Core::Edge).to receive(:new)
 
-      subject.replace(333, {"name" => "The Dude"})
+      subject[333]
     end
 
-    it "should create a new edge" do
-      @database.stub(:send_request).with("edge?collection=60768679&from=1&to=2", :post => { "name" => "The Dude" }).and_return do
-        server_response('documents/new-example_1-137249191')
-      end
-      @database.stub(:send_request).with("edge?collection=60768679&from=1&to=2", :post => { "name" => "The Dude" }).and_return { server_response('documents/example_1-137249191') }
-      from_double = double
-      from_double.stub(:id => "1")
-      to_double = double
-      to_double.stub(:id => "2")
-
-      # Documents need to get initialized:
-      Ashikawa::Core::Edge.should_receive(:new).and_return {
-        document = double
-        document.should_receive(:refresh!)
-        document
-      }
-
-      subject.create_edge(from_double, to_double, {"name" => "The Dude"})
-    end
+    it 'should replace an edge by ID' do
+      expect(database).to receive(:send_request)
+        .with('edge/60768679/333', put: { 'name' => 'The Dude' })
 
-    it "should not create a new document" do
-      expect {
-        subject.create_document({"quote" => "D'ya have to use s'many cuss words?"})
-      }.to raise_exception(RuntimeError, "Can't create a document in an edge collection")
+      subject.replace(333, { 'name' => 'The Dude' })
     end
-  end
 
-  describe "Deprecated methods" do
-    subject { Ashikawa::Core::Collection.new @database, { "id" => "60768679", "name" => "example_1" } }
-    let(:attributes) { { "test" => 123 } }
+    it 'should create a new edge' do
+      allow(database).to receive(:send_request)
+        .with('edge?collection=60768679&from=1&to=2', post: raw_document)
+        .and_return(response)
+      expect(Ashikawa::Core::Edge).to receive(:new)
+        .with(database, response, raw_document)
+        .and_return(document)
 
-    it "should mark `<<` as deprecated" do
-      subject.should_receive(:create_document).with(attributes).and_return nil
-      subject.should_receive(:warn).with("`<<` is deprecated, please use `create_document`")
-      subject << attributes
+      subject.create_edge(double(id: '1'), double(id: '2'), raw_document)
     end
 
-    it "should mark `[]=` as deprecated" do
-      subject.should_receive(:replace).with(121, attributes).and_return nil
-      subject.should_receive(:warn).with("`[]=` is deprecated, please use `replace`")
-      subject[121] = attributes
+    it 'should not create a new document' do
+      expect do
+        subject.create_document({ 'quote' => "D'ya have to use s'many cuss words?" })
+      end.to raise_exception(RuntimeError, "Can't create a document in an edge collection")
     end
   end
 end