ashikawa-core 0.8.0 → 0.9.0

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,64 @@
+# -*- encoding : utf-8 -*-
+require 'unit/spec_helper'
+require 'ashikawa-core/configuration'
+
+describe Ashikawa::Core::Configuration do
+  let(:url) { double }
+  let(:logger) { double }
+  let(:adapter) { double }
+  let(:connection) { double }
+  let(:username) { double }
+  let(:password) { double }
+
+  its(:url) { should be_nil }
+  its(:logger) { should be_nil }
+  its(:adapter) { should be_nil }
+
+  it 'should raise an Argument error if the URL is missing' do
+    expect do
+      subject.connection
+    end.to raise_error(ArgumentError, /either an url or a connection/)
+  end
+
+  describe 'provided with connection' do
+    before { subject.connection = connection }
+    its(:connection) { should be connection }
+  end
+
+  describe 'provided with url, logger and adapter' do
+    before do
+      subject.url = url
+      subject.logger = logger
+      subject.adapter = adapter
+    end
+
+    its(:url) { should be url }
+    its(:logger) { should be logger }
+    its(:adapter) { should be adapter }
+
+    it 'should construct a connection' do
+      expect(Ashikawa::Core::Connection).to receive(:new)
+        .with(url, { logger: logger, adapter: adapter })
+        .and_return(connection)
+      expect(subject.connection).to be connection
+    end
+  end
+
+  describe 'set up authentication' do
+    before do
+      subject.url = url
+      allow(Ashikawa::Core::Connection).to receive(:new)
+        .and_return(connection)
+    end
+
+    it 'should setup authentication' do
+      expect(connection).to receive(:authenticate_with)
+        .with({ username: username, password: password })
+        .and_return(connection)
+
+      subject.username = username
+      subject.password = password
+      subject.connection
+    end
+  end
+end

data/spec/unit/connection_spec.rb

@@ -1,248 +1,258 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/connection'
 
 describe Ashikawa::Core::Connection do
   let(:request_stub) { Faraday::Adapter::Test::Stubs.new }
-  let(:response_headers) { {"content-type" => "application/json; charset=utf-8" } }
-  subject { Ashikawa::Core::Connection.new(ARANGO_HOST, :adapter => [:test, request_stub]) }
+  let(:response_headers) { { 'content-type' => 'application/json; charset=utf-8' } }
+  subject { Ashikawa::Core::Connection.new(ARANGO_HOST, adapter: [:test, request_stub]) }
 
-  it "should have a scheme, hostname and port" do
-    subject.scheme.should == "http"
-    subject.host.should == "localhost"
-    subject.port.should == 8529
-  end
+  its(:scheme) { should eq('http') }
+  its(:host) { should eq('localhost') }
+  its(:port) { should eq(8529) }
 
-  it "should send a get request" do
-    request_stub.get("/_api/my/path") do
-      [200, response_headers, JSON.generate({ "name" => "dude" })]
+  it 'should send a get request' do
+    request_stub.get('/_api/my/path') do
+      [200, response_headers, JSON.generate({ 'name' => 'dude' })]
     end
 
-    subject.send_request "my/path"
+    subject.send_request 'my/path'
 
     request_stub.verify_stubbed_calls
   end
 
-  it "should send a post request" do
-    request_stub.post("/_api/my/path") do |request|
-      request[:body].should == "{\"name\":\"new_collection\"}"
-      [200, response_headers, JSON.generate({ "name" => "dude" })]
+  it 'should send a post request' do
+    request_stub.post('/_api/my/path') do |request|
+      expect(request[:body]).to eq("{\"name\":\"new_collection\"}")
+      [200, response_headers, JSON.generate({ 'name' => 'dude' })]
     end
 
-    subject.send_request "my/path", :post => { :name => 'new_collection' }
-
+    subject.send_request 'my/path', post: { name: 'new_collection' }
     request_stub.verify_stubbed_calls
   end
 
-  it "should send a put request" do
-    request_stub.put("/_api/my/path") do |request|
-      request[:body].should == '{"name":"new_collection"}'
-      [200, response_headers, JSON.generate({ "name" => "dude" })]
+  it 'should send a put request' do
+    request_stub.put('/_api/my/path') do |request|
+      expect(request[:body]).to eq('{"name":"new_collection"}')
+      [200, response_headers, JSON.generate({ 'name' => 'dude' })]
     end
 
-    subject.send_request "my/path", :put => { :name => 'new_collection' }
-
+    subject.send_request 'my/path', put: { name: 'new_collection' }
     request_stub.verify_stubbed_calls
   end
 
-  it "should send a delete request" do
-    request_stub.delete("/_api/my/path") do |request|
-      [200, response_headers, JSON.generate({ "name" => "dude" })]
+  it 'should send a delete request' do
+    request_stub.delete('/_api/my/path') do |request|
+      [200, response_headers, JSON.generate({ 'name' => 'dude' })]
     end
 
-    subject.send_request "my/path", :delete => { }
-
+    subject.send_request 'my/path', delete: { }
     request_stub.verify_stubbed_calls
   end
 
-  it "should write JSON request" do
-    request_stub.post("/_api/my/path") do |req|
-      req[:body].should == "{\"test\":1}"
-      [200, response_headers, JSON.generate({ "name" => "dude" })]
+  it 'should write JSON request' do
+    request_stub.post('/_api/my/path') do |req|
+      expect(req[:body]).to eq('{"test":1}')
+      [200, response_headers, JSON.generate({ 'name' => 'dude' })]
     end
 
-    subject.send_request("my/path", :post => { "test" => 1})
+    subject.send_request('my/path', post: { 'test' => 1 })
     request_stub.verify_stubbed_calls
   end
 
-  it "should parse JSON response" do
-    request_stub.get("/_api/my/path") do
-      [200, response_headers, "{\"name\":\"dude\"}"]
+  it 'should parse JSON response' do
+    request_stub.get('/_api/my/path') do
+      [200, response_headers, '{"name":"dude"}']
     end
 
-    subject.send_request("my/path").should == {"name" => "dude"}
+    expect(subject.send_request('my/path')).to eq({ 'name' => 'dude' })
     request_stub.verify_stubbed_calls
   end
 
-  describe "authentication" do
-    it "should have authentication turned off by default" do
-      subject.authentication?.should be_false
+  describe 'authentication' do
+    it 'should have authentication turned off by default' do
+      expect(subject.authentication?).to be_false
     end
 
-    it "should tell if authentication is enabled" do
-      subject.authenticate_with :username => "testuser", :password => "testpassword"
-      subject.authentication?.should be_true
+    it 'should tell if authentication is enabled' do
+      subject.authenticate_with(username: 'testuser', password: 'testpassword')
+      expect(subject.authentication?).to be_true
     end
 
-    it "should only accept username & password pairs" do
-      expect {
-        subject.authenticate_with :username => "kitty"
-      }.to raise_error(ArgumentError)
+    it 'should only accept username & password pairs' do
+      expect do
+        subject.authenticate_with(username: 'kitty')
+      end.to raise_error(ArgumentError)
 
-      expect {
-        subject.authenticate_with :password => "cheezburger?"
-      }.to raise_error(ArgumentError)
+      expect do
+        subject.authenticate_with(password: 'cheezburger?')
+      end.to raise_error(ArgumentError)
     end
 
-    it "should allow chaining" do
-      subject.authenticate_with(:username => "a", :password => "b").should == subject
+    it 'should allow chaining' do
+      expect(subject.authenticate_with(username: 'a', password: 'b')).to eq(subject)
     end
 
-    it "should send the authentication data with every GET request" do
-      pending "Find out how to check for basic auth via Faraday Stubs"
+    it 'should send the authentication data with every GET request' do
+      pending 'Find out how to check for basic auth via Faraday Stubs'
 
-      request_stub.get("/_api/my/path") do |request|
-        [200, response_headers, JSON.generate({ "name" => "dude" })]
+      request_stub.get('/_api/my/path') do |request|
+        [200, response_headers, JSON.generate({ 'name' => 'dude' })]
       end
 
-      subject.authenticate_with :username => "user", :password => "pass"
-      subject.send_request "my/path"
+      subject.authenticate_with username: 'user', password: 'pass'
+      subject.send_request 'my/path'
 
       request_stub.verify_stubbed_calls
     end
   end
 
-  describe "exception handling" do
-    let(:error_message) { "cannot write file" }
+  describe 'exception handling' do
+    let(:error_message) { 'cannot write file' }
     let(:error_num) { 15 }
 
     it "should throw a general client error for I'm a teapot" do
-      request_stub.get("/_api/bad/request") do
+      request_stub.get('/_api/bad/request') do
         [
           418,
           response_headers,
-          JSON.generate({ "error" => true, "errorNum" => error_num, "errorMessage" => error_message })
+          JSON.generate({ 'error' => true, 'errorNum' => error_num, 'errorMessage' => error_message })
         ]
       end
 
       expect do
-        subject.send_request("bad/request")
+        subject.send_request('bad/request')
       end.to raise_error(Ashikawa::Core::ClientError, "#{error_num}: #{error_message}")
 
       request_stub.verify_stubbed_calls
     end
 
-    it "should throw its own exception when doing a bad request" do
-      request_stub.get("/_api/bad/request") do
-        [400, response_headers, ""]
+    it 'should throw its own exception when doing a bad request' do
+      request_stub.get('/_api/bad/request') do
+        [400, response_headers, '']
       end
 
       expect do
-        subject.send_request("bad/request")
+        subject.send_request('bad/request')
       end.to raise_error(Ashikawa::Core::BadSyntax)
 
       request_stub.verify_stubbed_calls
     end
 
-    it "should throw a general server error for the generic server error" do
-      request_stub.get("/_api/bad/request") do
+    it 'should throw its own exception when doing a bad request' do
+      request_stub.get('/_api/secret') do
+        [401, response_headers, '']
+      end
+
+      expect do
+        subject.send_request('secret')
+      end.to raise_error(Ashikawa::Core::AuthenticationFailed)
+
+      request_stub.verify_stubbed_calls
+    end
+
+    it 'should throw a general server error for the generic server error' do
+      request_stub.get('/_api/bad/request') do
         [
           500,
           response_headers,
-          JSON.generate({ "error" => true, "errorNum" => error_num, "errorMessage" => error_message })
+          JSON.generate({ 'error' => true, 'errorNum' => error_num, 'errorMessage' => error_message })
         ]
       end
 
       expect do
-        subject.send_request("bad/request")
+        subject.send_request('bad/request')
       end.to raise_error(Ashikawa::Core::ServerError, "#{error_num}: #{error_message}")
 
       request_stub.verify_stubbed_calls
     end
 
-    it "should raise an exception if a document is not found" do
-      request_stub.get("/_api/document/4590/333") do
-        [404, response_headers, ""]
+    it 'should raise an exception if a document is not found' do
+      request_stub.get('/_api/document/4590/333') do
+        [404, response_headers, '']
       end
 
-      expect { subject.send_request "document/4590/333" }.to raise_error(Ashikawa::Core::DocumentNotFoundException)
+      expect { subject.send_request 'document/4590/333' }.to raise_error(Ashikawa::Core::DocumentNotFoundException)
 
       request_stub.verify_stubbed_calls
     end
 
-    it "should raise an exception if a collection is not found" do
-      request_stub.get("/_api/collection/4590") do
-        [404, response_headers, ""]
+    it 'should raise an exception if a collection is not found' do
+      request_stub.get('/_api/collection/4590') do
+        [404, response_headers, '']
       end
 
-      expect { subject.send_request "collection/4590" }.to raise_error(Ashikawa::Core::CollectionNotFoundException)
+      expect { subject.send_request 'collection/4590' }.to raise_error(Ashikawa::Core::CollectionNotFoundException)
 
       request_stub.verify_stubbed_calls
     end
 
-    it "should raise an exception if an index is not found" do
-      request_stub.get("/_api/index/4590/333") do
-        [404, response_headers, ""]
+    it 'should raise an exception if an index is not found' do
+      request_stub.get('/_api/index/4590/333') do
+        [404, response_headers, '']
       end
 
-      expect { subject.send_request "index/4590/333" }.to raise_error(Ashikawa::Core::IndexNotFoundException)
+      expect { subject.send_request 'index/4590/333' }.to raise_error(Ashikawa::Core::IndexNotFoundException)
 
       request_stub.verify_stubbed_calls
     end
 
-    it "should raise an exception for unknown pathes" do
-      request_stub.get("/_api/unknown_path/4590/333") do
-        [404, response_headers, ""]
+    it 'should raise an exception for unknown pathes' do
+      request_stub.get('/_api/unknown_path/4590/333') do
+        [404, response_headers, '']
       end
 
-      expect { subject.send_request "unknown_path/4590/333" }.to raise_error(Ashikawa::Core::ResourceNotFound)
+      expect { subject.send_request 'unknown_path/4590/333' }.to raise_error(Ashikawa::Core::ResourceNotFound)
 
       request_stub.verify_stubbed_calls
     end
 
-    it "should raise an error if a malformed JSON was returned from the server" do
-      request_stub.get("/_api/document/4590/333") do
-        [200, response_headers, "{\"a\":1"]
+    it 'should raise an error if a malformed JSON was returned from the server' do
+      request_stub.get('/_api/document/4590/333') do
+        [200, response_headers, '{"a":1']
       end
 
-      expect { subject.send_request "document/4590/333" }.to raise_error(Ashikawa::Core::JsonError)
+      expect { subject.send_request 'document/4590/333' }.to raise_error(Ashikawa::Core::JsonError)
 
       request_stub.verify_stubbed_calls
     end
 
-    it "should raise an error if the content type of the response is not JSON" do
-      request_stub.get("/_api/document/4590/333") do
-        [200, {"content-type" => "text/html; charset=utf-8"}, ""]
+    it 'should raise an error if the content type of the response is not JSON' do
+      request_stub.get('/_api/document/4590/333') do
+        [200, { 'content-type' => 'text/html; charset=utf-8' }, '']
       end
 
-      expect { subject.send_request "document/4590/333" }.to raise_error(Ashikawa::Core::JsonError)
+      expect { subject.send_request 'document/4590/333' }.to raise_error(Ashikawa::Core::JsonError)
 
       request_stub.verify_stubbed_calls
     end
   end
 
-  describe "logging" do
+  describe 'logging' do
     let(:request_stub) { Faraday::Adapter::Test::Stubs.new }
     let(:logger) { double }
-    subject {
-      Ashikawa::Core::Connection.new(ARANGO_HOST, :adapter => [:test, request_stub], :logger => logger)
-    }
+    subject do
+      Ashikawa::Core::Connection.new(ARANGO_HOST, adapter: [:test, request_stub], logger: logger)
+    end
 
-    it "should log a get request" do
-      request_stub.get("/_api/test") do
-        [200, response_headers, JSON.generate({:a => 1})]
+    it 'should log a get request' do
+      request_stub.get('/_api/test') do
+        [200, response_headers, JSON.generate({ a: 1 })]
       end
-      logger.should_receive(:info).with("GET #{ARANGO_HOST}/_api/test ")
-      logger.should_receive(:info).with("200 {\"a\":1}")
-      subject.send_request("test")
+      expect(logger).to receive(:info).with("GET #{ARANGO_HOST}/_api/test ")
+      expect(logger).to receive(:info).with('200 {"a":1}')
+
+      subject.send_request('test')
     end
 
-    it "should log a post request" do
-      request_stub.post("/_api/test") do
-        [201, response_headers, JSON.generate({:b => 2})]
+    it 'should log a post request' do
+      request_stub.post('/_api/test') do
+        [201, response_headers, JSON.generate({ b: 2 })]
       end
-      logger.should_receive(:info).with("POST #{ARANGO_HOST}/_api/test {:a=>2}")
-      logger.should_receive(:info).with("201 {\"b\":2}")
-      subject.send_request("test", :post => { :a => 2})
+      expect(logger).to receive(:info).with("POST #{ARANGO_HOST}/_api/test {:a=>2}")
+      expect(logger).to receive(:info).with('201 {"b":2}')
+
+      subject.send_request('test', post: { a: 2 })
     end
   end
 end

data/spec/unit/cursor_spec.rb

@@ -1,65 +1,76 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/cursor'
 
 describe Ashikawa::Core::Cursor do
   subject { Ashikawa::Core::Cursor }
+  let(:database) { double }
+
+  describe 'cursor for a non-complete batch' do
+    let(:response) { server_response('cursor/26011191') }
+    let(:cursor_containing_string) do
+      {
+        'hasMore' => false,
+        'error' => false,
+        'result' => [
+          'test'
+        ],
+        'code' => 200,
+        'count' => 1
+      }
+    end
+    subject { Ashikawa::Core::Cursor.new(database, response) }
 
-  before :each do
-    @database = double
-    double Ashikawa::Core::Document
-  end
-
-  it "should create a cursor for a non-complete batch" do
-    my_cursor = subject.new @database, server_response("cursor/26011191")
-    my_cursor.id.should        == "26011191"
-    my_cursor.length.should    == 5
-  end
-
-  it "should create a cursor for the last batch" do
-    my_cursor = subject.new @database, server_response("cursor/26011191-3")
-    my_cursor.id.should be_nil
-    my_cursor.length.should == 5
-  end
+    its(:id) { should eq('26011191') }
+    its(:length) { should eq(5) }
 
-  describe "existing cursor" do
-    subject { Ashikawa::Core::Cursor.new @database,
-      server_response("cursor/26011191")
-    }
+    it 'should be deletable' do
+      expect(database).to receive(:send_request).with('cursor/26011191', delete: {})
+      subject.delete
+    end
 
-    it "should iterate over all documents of a cursor when given a block" do
+    it 'should iterate over all documents of a cursor when given a block' do
       first = true
 
-      @database.stub(:send_request).with("cursor/26011191", :put => {}) do
+      allow(database).to receive(:send_request).with('cursor/26011191', put: {}) do
         if first
           first = false
-          server_response("cursor/26011191-2")
+          server_response('cursor/26011191-2')
         else
-          server_response("cursor/26011191-3")
+          server_response('cursor/26011191-3')
         end
       end
-      @database.should_receive(:send_request).twice
+      expect(database).to receive(:send_request)
+        .twice
+      expect(Ashikawa::Core::Document).to receive(:new)
+        .exactly(5).times
+
+      subject.each { }
+    end
 
-      Ashikawa::Core::Document.stub(:new)
-      Ashikawa::Core::Document.should_receive(:new).exactly(5).times
+    it 'should return the raw string when the response consists of strings' do
+      allow(database).to receive(:send_request)
+        .with('cursor/26011191', put: {})
+        .and_return(cursor_containing_string)
 
-      subject.each { |document| }
+      expect(subject.to_a).to include 'test'
     end
 
-    it "should return an enumerator to go over all documents of a cursor when given no block" do
+    it 'should return an enumerator to go over all documents of a cursor when given no block' do
       first = true
 
-      @database.stub(:send_request).with("cursor/26011191", :put => {}) do
+      allow(database).to receive(:send_request).with('cursor/26011191', put: {}) do
         if first
           first = false
-          server_response("cursor/26011191-2")
+          server_response('cursor/26011191-2')
         else
-          server_response("cursor/26011191-3")
+          server_response('cursor/26011191-3')
         end
       end
-      @database.should_receive(:send_request).twice
-
-      Ashikawa::Core::Document.stub(:new)
-      Ashikawa::Core::Document.should_receive(:new).exactly(5).times
+      expect(database).to receive(:send_request)
+        .twice
+      expect(Ashikawa::Core::Document).to receive(:new)
+        .exactly(5).times
 
       enumerator = subject.each
       enumerator.next
@@ -70,44 +81,46 @@ describe Ashikawa::Core::Cursor do
       expect { enumerator.next }.to raise_exception(StopIteration)
     end
 
-    it "should be deletable" do
-      @database.stub(:send_request)
-      @database.should_receive(:send_request).with("cursor/26011191",
-        :delete => {})
-
-      subject.delete
-    end
-
-    it "should be enumerable" do
+    it 'should be enumerable' do
       first = true
-
-      @database.stub(:send_request).with("cursor/26011191", :put => {}) do
-        if first
-          first = false
-          server_response("cursor/26011191-2")
-        else
-          server_response("cursor/26011191-3")
+      result = double
+
+      expect(database).to receive(:send_request)
+        .twice
+        .with('cursor/26011191', put: {}) do
+          if first
+            first = false
+            server_response('cursor/26011191-2')
+          else
+            server_response('cursor/26011191-3')
+          end
         end
-      end
-      @database.should_receive(:send_request).twice
 
-      Ashikawa::Core::Document.stub(:new).and_return { 1 }
-      Ashikawa::Core::Document.should_receive(:new).exactly(5).times
+      expect(Ashikawa::Core::Document).to receive(:new)
+        .exactly(5).times
+        .and_return(result)
 
-      subject.map{|i| i}[0].should == 1
+      expect(subject.map { |i| i }[0]).to eq(result)
     end
 
-    it "should return edge objects when recieving data from an edge collection" do
-      @database.stub(:send_request).with("cursor/26011191", :put => {}) do
-        server_response("cursor/edges")
-      end
-      @database.should_receive(:send_request).once
+    it 'should return edge objects when recieving data from an edge collection' do
+      expect(database).to receive(:send_request)
+        .once
+        .with('cursor/26011191', put: {})
+        .and_return(server_response('cursor/edges'))
 
-      Ashikawa::Core::Edge.stub(:new).and_return { 1 }
-      Ashikawa::Core::Edge.should_receive(:new).exactly(2).times
+      expect(Ashikawa::Core::Edge).to receive(:new)
+        .exactly(2).times
 
-      subject.each { |document| }
+      subject.each { }
     end
+  end
+
+  describe 'cursor for the last batch' do
+    let(:response) { server_response('cursor/26011191-3') }
+    subject { Ashikawa::Core::Cursor.new(database, response) }
 
+    its(:id) { should be_nil }
+    its(:length) { should eq(5) }
   end
 end