ashikawa-core 0.8.0 → 0.9.0

data/spec/unit/database_spec.rb

@@ -1,232 +1,181 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/database'
 
 describe Ashikawa::Core::Database do
   subject { Ashikawa::Core::Database }
 
-  before :each do
-    double(Ashikawa::Core::Connection)
-    double(Ashikawa::Core::Collection)
-    double(Ashikawa::Core::Cursor)
-    double(Ashikawa::Core::Transaction)
-    @connection = double("connection", :host => "localhost", :port => 8529, :scheme => "http")
+  let(:url) { double }
+  let(:host) { double }
+  let(:port) { double }
+  let(:scheme) { double }
+  let(:connection) { double('connection', host: host, port: port, scheme: scheme) }
+  let(:js_function) { double }
+  let(:collections) { double }
+  let(:transaction) { double }
+  let(:logger) { double }
+  let(:adapter) { double }
+  let(:configuration) { double }
+
+  it 'should initialize with a configuration object' do
+    expect(Ashikawa::Core::Configuration).to receive(:new)
+      .and_return(configuration)
+    expect(configuration).to receive(:connection)
+    expect { |b| Ashikawa::Core::Database.new(&b) }.to yield_with_args(configuration)
   end
 
-  it "should initialize with a connection" do
-    @connection.stub(:host) { "localhost" }
-    @connection.stub(:port) { 8529 }
-
-    database = subject.new do |config|
-      config.connection = @connection
-    end
-    database.host.should == "localhost"
-    database.port.should == 8529
-  end
-
-  it "should initialize with a connection string" do
-    Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
-      :logger => nil,
-      :adapter => nil
-    }).and_return(double)
-    Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
-      :logger => nil,
-      :adapter => nil
-    })
-
-    subject.new do |config|
-      config.url = "http://localhost:8529"
-    end
-  end
-
-  it "should initialize with a connection string and logger" do
-    logger = double
-    Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
-      :logger => logger,
-      :adapter => nil
-    }).and_return(double)
-    Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
-      :logger => logger,
-      :adapter => nil
-    })
-
-    subject.new do |config|
-      config.url = "http://localhost:8529"
-      config.logger = logger
-    end
-  end
-
-  it "should initialize with a connection string and adapter" do
-    adapter = double
-    Ashikawa::Core::Connection.stub(:new).with("http://localhost:8529", {
-      :logger => nil,
-      :adapter => adapter
-    }).and_return(double)
-    Ashikawa::Core::Connection.should_receive(:new).with("http://localhost:8529", {
-      :logger => nil,
-      :adapter => adapter
-    })
-
-    subject.new do |config|
-      config.url = "http://localhost:8529"
-      config.adapter = adapter
-    end
-  end
-
-  it "should throw an argument error when neither url nor connection was provided" do
-    adapter = double
-    logger = double
-
-    expect {
-      subject.new do |config|
-        config.adapter = adapter
-        config.logger = logger
+  describe 'initialized database' do
+    subject do
+      Ashikawa::Core::Database.new do |config|
+        config.connection = connection
       end
-    }.to raise_error(ArgumentError, /either an url or a connection/)
-  end
-
-  it "should create a query" do
-    database = subject.new do |config|
-      config.connection = @connection
     end
 
-    double Ashikawa::Core::Query
-    Ashikawa::Core::Query.stub(:new)
-    Ashikawa::Core::Query.should_receive(:new).exactly(1).times.with(database)
-
-    database.query
-  end
+    it 'should create a query' do
+      expect(Ashikawa::Core::Query).to receive(:new)
+        .exactly(1).times
+        .with(subject)
 
-  describe "initialized database" do
-    subject {
-      Ashikawa::Core::Database.new do |config|
-        config.connection = @connection
-      end
-    }
+      subject.query
+    end
 
-    it "should delegate authentication to the connection" do
-      @connection.should_receive(:authenticate_with).with({ :username => "user", :password => "password" })
+    it 'should delegate authentication to the connection' do
+      expect(connection).to 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 non-system collections" do
-      @connection.stub(:send_request) {|path| server_response("collections/all") }
-      @connection.should_receive(:send_request).with("collection")
+    it 'should fetch all available non-system collections' do
+      expect(connection).to receive(:send_request)
+        .with('collection')
+        .and_return { server_response('collections/all') }
 
       (0..1).each do |k|
-        Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/all")["collections"][k])
+        expect(Ashikawa::Core::Collection).to receive(:new)
+          .with(subject, server_response('collections/all')['collections'][k])
       end
 
-      subject.collections.length.should == 2
+      expect(subject.collections.length).to eq(2)
     end
 
-    it "should fetch all available non-system collections" do
-      @connection.stub(:send_request) {|path| server_response("collections/all") }
-      @connection.should_receive(:send_request).with("collection")
+    it 'should fetch all available non-system collections' do
+      expect(connection).to receive(:send_request)
+        .with('collection')
+        .and_return { server_response('collections/all') }
 
-      Ashikawa::Core::Collection.should_receive(:new).exactly(5).times
+      expect(Ashikawa::Core::Collection).to receive(:new)
+        .exactly(5).times
 
-      subject.system_collections.length.should == 5
+      expect(subject.system_collections.length).to eq(5)
     end
 
-    it "should create a non volatile collection by default" do
-      @connection.stub(:send_request) { |path| server_response("collections/60768679") }
-      @connection.should_receive(:send_request).with("collection",
-        :post => { :name => "volatile_collection"})
+    it 'should create a non volatile collection by default' do
+      expect(connection).to receive(:send_request)
+        .with('collection', post: { name: 'volatile_collection' })
+        .and_return { server_response('collections/60768679') }
 
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+      expect(Ashikawa::Core::Collection).to receive(:new)
+        .with(subject, server_response('collections/60768679'))
 
-      subject.create_collection("volatile_collection")
+      subject.create_collection('volatile_collection')
     end
 
-    it "should create a volatile collection when asked" do
-      @connection.stub(:send_request) { |path| server_response("collections/60768679") }
-      @connection.should_receive(:send_request).with("collection",
-        :post => { :name => "volatile_collection", :isVolatile => true})
+    it 'should create a volatile collection when asked' do
+      expect(connection).to receive(:send_request)
+        .with('collection', post: { name: 'volatile_collection', isVolatile: true })
+        .and_return { |path| server_response('collections/60768679') }
 
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+      expect(Ashikawa::Core::Collection).to receive(:new)
+        .with(subject, server_response('collections/60768679'))
 
-      subject.create_collection("volatile_collection", :is_volatile => true)
+      subject.create_collection('volatile_collection', is_volatile: true)
     end
 
-    it "should create an autoincrement collection when asked" do
-      @connection.should_receive(:send_request).with("collection",
-        :post => { :name => "autoincrement_collection", :keyOptions => {
-          :type => "autoincrement",
-          :offset => 0,
-          :increment => 10,
-          :allowUserKeys => false
+    it 'should create an autoincrement collection when asked' do
+      expect(connection).to receive(:send_request).with('collection',
+                                                        post: {
+          name: 'autoincrement_collection', keyOptions: {
+            type: 'autoincrement',
+            offset: 0,
+            increment: 10,
+            allowUserKeys: false
+          }
         }
-      })
+      )
 
-      Ashikawa::Core::Collection.should_receive(:new)
+      expect(Ashikawa::Core::Collection).to receive(:new)
 
-      subject.create_collection("autoincrement_collection", :key_options => {
-        :type => :autoincrement,
-        :offset => 0,
-        :increment => 10,
-        :allow_user_keys => false
+      subject.create_collection('autoincrement_collection', key_options: {
+        type: :autoincrement,
+        offset: 0,
+        increment: 10,
+        allow_user_keys: false
       })
     end
 
-    it "should create an edge collection when asked" do
-      @connection.stub(:send_request) { |path| server_response("collections/60768679") }
-      @connection.should_receive(:send_request).with("collection",
-        :post => { :name => "volatile_collection", :type => 3})
+    it 'should create an edge collection when asked' do
+      expect(connection).to receive(:send_request)
+        .with('collection', post: { name: 'volatile_collection', type: 3 })
+        .and_return { |path| server_response('collections/60768679') }
 
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+      expect(Ashikawa::Core::Collection).to receive(:new)
+        .with(subject, server_response('collections/60768679'))
 
-      subject.create_collection("volatile_collection", :content_type => :edge)
+      subject.create_collection('volatile_collection', content_type: :edge)
     end
 
-    it "should fetch a single collection if it exists" do
-      @connection.stub(:send_request) { |path| server_response("collections/60768679") }
-      @connection.should_receive(:send_request).with("collection/60768679")
+    it 'should fetch a single collection if it exists' do
+      expect(connection).to receive(:send_request)
+        .with('collection/60768679')
+        .and_return { |path| server_response('collections/60768679') }
 
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+      expect(Ashikawa::Core::Collection).to receive(:new)
+        .with(subject, server_response('collections/60768679'))
 
-      subject.collection(60768679)
+      subject.collection(60_768_679)
     end
 
-    it "should fetch a single collection with the array syntax" do
-      @connection.stub(:send_request) { |path| server_response("collections/60768679") }
-      @connection.should_receive(:send_request).with("collection/60768679")
+    it 'should fetch a single collection with the array syntax' do
+      expect(connection).to receive(:send_request)
+        .with('collection/60768679')
+        .and_return { |path| server_response('collections/60768679') }
 
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+      expect(Ashikawa::Core::Collection).to receive(:new)
+        .with(subject, server_response('collections/60768679'))
 
-      subject[60768679]
+      subject[60_768_679]
     end
 
     it "should create a single collection if it doesn't exist" do
-      @connection.stub :send_request do |path, method|
+      allow(connection).to receive :send_request do |path, method|
         method ||= {}
-        if method.has_key? :post
-          server_response("collections/60768679")
+        if method.key? :post
+          server_response('collections/60768679')
         else
           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"})
-
-      Ashikawa::Core::Collection.should_receive(:new).with(subject, server_response("collections/60768679"))
+      expect(connection).to receive(:send_request).with('collection/new_collection')
+      expect(connection).to receive(:send_request).with('collection', post: { name: 'new_collection' })
+      expect(Ashikawa::Core::Collection).to receive(:new).with(subject, server_response('collections/60768679'))
 
       subject['new_collection']
     end
 
-    it "should send a request via the connection object" do
-      @connection.should_receive(:send_request).with("my/path", :post => { :data => "mydata" })
+    it 'should send a request via the connection object' do
+      expect(connection).to 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
 
-    let(:js_function) { double }
-    let(:collections) { double }
-    let(:transaction) { double }
+    it 'should create a transaction' do
+      expect(Ashikawa::Core::Transaction).to receive(:new)
+        .with(subject, js_function, collections)
+        .and_return(transaction)
 
-    it "should create a transaction" do
-      Ashikawa::Core::Transaction.should_receive(:new).with(subject, js_function, collections).and_return { transaction }
-      subject.create_transaction(js_function, collections).should == transaction
+      expect(subject.create_transaction(js_function, collections)).to be(transaction)
     end
   end
 end

data/spec/unit/document_spec.rb

@@ -1,112 +1,116 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/document'
 
 describe Ashikawa::Core::Document do
   let(:database) { double }
-  let(:raw_data) {
+  let(:id) { 164 }
+  let(:path) { 'document/164' }
+  let(:key) { double }
+  let(:revision) { double }
+  let(:first_name) { double }
+  let(:last_name) { double }
+  let(:more_info) { double }
+  let(:delete_payload) {{ delete: {} }}
+  let(:raw_data) do
     {
-      "_id" => "1234567/2345678",
-      "_key" => "2345678",
-      "_rev" => "3456789",
-      "first_name" => "The",
-      "last_name" => "Dude"
+      '_id' => id,
+      '_key' => key,
+      '_rev' => revision,
+      'first_name' => first_name,
+      'last_name' => last_name
     }
-  }
-  let(:raw_data_without_id) {
+  end
+  let(:raw_data_without_id) do
     {
-      "first_name" => "The",
-      "last_name" => "Dude"
+      'first_name' => first_name,
+      'last_name' => last_name
     }
-  }
-  subject { Ashikawa::Core::Document }
-
-  it "should initialize data with ID" do
-    document = subject.new database, raw_data
-    document.id.should == "1234567/2345678"
-    document.key.should == "2345678"
-    document.revision.should == "3456789"
   end
 
-  it "should initialize data without ID" do
-    document = subject.new database, raw_data_without_id
-    document.id.should == :not_persisted
-    document.revision.should == :not_persisted
-  end
+  describe 'initializing' do
+    subject { Ashikawa::Core::Document }
 
-  describe "initialized document with ID" do
-    subject { Ashikawa::Core::Document.new database, raw_data }
+    let(:additional_data) do
+      {
+        more_info: more_info
+      }
+    end
 
-    it "should return the correct value for an existing attribute" do
-      subject["first_name"].should be(raw_data["first_name"])
+    it 'should initialize with data including ID' do
+      document = subject.new(database, raw_data)
+      expect(document.id).to eq(id)
+      expect(document.key).to eq(key)
+      expect(document.revision).to eq(revision)
     end
 
-    it "should return nil for an non-existing attribute" do
-      subject["no_name"].should be_nil
+    it 'should initialize with data not including ID' do
+      document = subject.new(database, raw_data_without_id)
+      expect(document.id).to eq(:not_persisted)
+      expect(document.revision).to eq(:not_persisted)
     end
 
-    it "should be deletable" do
-      database.should_receive(:send_request).with("document/#{raw_data['_id']}",
-        { :delete => {} }
-      )
+    it 'should initialize with additional data' do
+      document = subject.new(database, raw_data, additional_data)
+      expect(document['more_info']).to eq(more_info)
+    end
+  end
+
+  describe 'initialized document with ID' do
+    subject { Ashikawa::Core::Document.new(database, raw_data) }
+
+    let(:new_last_name) { double }
+    let(:raw_data_without_id_and_new_last_name) do
+      {
+        'first_name' => first_name,
+        'last_name' => new_last_name
+      }
+    end
 
+    its(['first_name']) { should be(first_name) }
+    its(['no_name']) { should be_nil }
+    its(:hash) { should be_instance_of Hash }
+    its(:hash) { should include('first_name' => first_name) }
+
+    it 'should be deletable' do
+      expect(database).to receive(:send_request).with(path, delete_payload)
       subject.delete
     end
 
-    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" } }
+    it 'should store changes to the database' do
+      expect(database).to receive(:send_request).with(path,
+                                                      { put: raw_data_without_id_and_new_last_name }
       )
 
-      subject["last_name"] = "Other"
+      subject['last_name'] = new_last_name
       subject.save
     end
 
-    it "should be convertable to a hash" do
-      hash = subject.hash
-      hash.should be_instance_of Hash
-      hash["first_name"].should == subject["first_name"]
-    end
-
-    it "should be refreshable" do
-      database.should_receive(:send_request).with("document/#{raw_data['_id']}", {}).and_return {
-        { "name" => "Jeff" }
+    it 'should be refreshable' do
+      expect(database).to receive(:send_request).with(path, {}).and_return {
+        { 'name' => 'Jeff' }
       }
 
       refreshed_subject = subject.refresh!
-      refreshed_subject.should == subject
-      subject["name"].should == "Jeff"
+      expect(refreshed_subject).to eq(subject)
+      expect(subject['name']).to eq('Jeff')
     end
   end
 
-  describe "initialized document without ID" do
+  describe 'initialized document without ID' do
     subject { Ashikawa::Core::Document.new database, raw_data_without_id }
 
-    it "should return the correct value for an existing attribute" do
-      subject["first_name"].should be(raw_data_without_id["first_name"])
-    end
-
-    it "should return nil for an non-existing attribute" do
-      subject["no_name"].should be_nil
-    end
+    its(['first_name']) { should be(first_name) }
+    its(['no_name']) { should be_nil }
 
-    it "should not be deletable" do
-      database.should_not_receive :send_request
+    it 'should not be deletable' do
+      expect(database).not_to receive :send_request
       expect { subject.delete }.to raise_error Ashikawa::Core::DocumentNotFoundException
     end
 
-    it "should not store changes to the database" do
-      database.should_not_receive :send_request
+    it 'should not store changes to the database' do
+      expect(database).not_to receive :send_request
       expect { subject.save }.to raise_error Ashikawa::Core::DocumentNotFoundException
     end
   end
-
-  describe "Deprecated methods" do
-    subject { Ashikawa::Core::Document.new database, raw_data_without_id }
-
-    it "should mark `to_hash` as deprecated" do
-      subject.should_receive(:hash)
-      subject.should_receive(:warn).with("`to_hash` is deprecated, please use `hash`")
-      subject.to_hash
-    end
-  end
 end