ashikawa-core 0.9.0 → 0.10.0

data/spec/acceptance/spec_helper.rb

@@ -14,15 +14,16 @@ end
 
 require 'ashikawa-core'
 
-port = ENV['ARANGODB_PORT'] || 8529
-username = ENV['ARANGODB_USERNAME'] || 'root'
-password = ENV['ARANGODB_PASSWORD'] || ''
+port = ENV.fetch('ARANGODB_PORT', 8529)
+username = ENV.fetch('ARANGODB_USERNAME', 'root')
+password = ENV.fetch('ARANGODB_PASSWORD', '')
+authentification_enabled = ENV['ARANGODB_DISABLE_AUTHENTIFICATION'] == 'false'
 
 # 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']
+  if authentification_enabled
     config.username = username
     config.password = password
   end

data/spec/setup/arangodb.sh

@@ -3,15 +3,15 @@
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 cd $DIR
 
-# VERSION=1.4.devel
 NAME=ArangoDB-$VERSION
 
 if [ ! -d "$DIR/$NAME" ]; then
   # download ArangoDB
-  echo "wget http://www.arangodb.org/travisCI/$NAME.tar.gz"
-  wget http://www.arangodb.org/travisCI/$NAME.tar.gz
+  echo "wget http://www.arangodb.org/repositories/travisCI/$NAME.tar.gz"
+  wget http://www.arangodb.org/repositories/travisCI/$NAME.tar.gz
   echo "tar zxf $NAME.tar.gz"
   tar zvxf $NAME.tar.gz
+  mv `find . -type d -name "ArangoDB-*"` $NAME
 fi
 
 ARCH=$(arch)
@@ -19,29 +19,24 @@ PID=$(echo $PPID)
 TMP_DIR="/tmp/arangodb.$PID"
 PID_FILE="/tmp/arangodb.$PID.pid"
 ARANGODB_DIR="$DIR/$NAME"
-
-ARANGOD="${ARANGODB_DIR}/bin/arangod"
-if [ "$ARCH" == "x86_64" ]; then
-  ARANGOD="${ARANGOD}_x86_64"
-fi
+ARANGOD="${ARANGODB_DIR}/bin/arangod_x86_64"
 
 # create database directory
 mkdir ${TMP_DIR}
 
-echo "Starting arangodb '${ARANGOD}'"
+echo "Starting ArangoDB '${ARANGOD}'"
 
 ${ARANGOD} \
-  --database.directory ${TMP_DIR}  \
-  --configuration none  \
+  --database.directory ${TMP_DIR} \
+  --configuration none \
   --server.endpoint tcp://127.0.0.1:8529 \
+  --javascript.app-path ${ARANGODB_DIR}/js/apps \
   --javascript.startup-directory ${ARANGODB_DIR}/js \
-  --server.admin-directory ${ARANGODB_DIR}/html/admin \
   --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules:${ARANGODB_DIR}/js/node \
   --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 ${ARANGODB_DISABLE_AUTHENTIFICATION} \
-  --server.disable-authentication true \
+  --javascript.action-directory ${ARANGODB_DIR}/js/actions \
+  --database.maximal-journal-size 1048576 \
+  --server.disable-authentication ${ARANGODB_DISABLE_AUTHENTIFICATION} \
   --javascript.gc-interval 1 &
 
 sleep 2
@@ -56,7 +51,7 @@ if [ "x$process" == "x" ]; then
 fi
 
 echo "Waiting until ArangoDB is ready on port 8529"
-while [[ -z `curl -s 'http://127.0.0.1:8529/_api/version' ` ]] ; do
+while [[ -z `curl --basic --user 'root:' -s 'http://127.0.0.1:8529/_api/version' ` ]] ; do
   echo -n "."
   sleep 2s
 done

data/spec/unit/collection_spec.rb

@@ -4,7 +4,16 @@ require 'ashikawa-core/collection'
 
 describe Ashikawa::Core::Collection do
   let(:database) { double }
-  let(:raw_document_collection) { server_response('collections/60768679') }
+  let(:raw_document_collection) do
+    {
+      'id' => '60768679',
+      'name' => 'example_1',
+      'status' => 3,
+      'type' => 2,
+      'error' => false,
+      'code' => 200
+    }
+  end
   let(:raw_edge_collection) do
     {
       'id' => '60768679',
@@ -223,29 +232,62 @@ describe Ashikawa::Core::Collection do
 
     its(:content_type) { should be(:document) }
 
-    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)
+    context 'when using the key' do
+      let(:key) { 333 }
 
-      subject.fetch(333)
-    end
+      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)
 
-    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)
+        subject.fetch(key)
+      end
 
-      subject[333]
+      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)
+
+        subject[key]
+      end
+
+      it 'should replace a document by ID' do
+        expect(database).to receive(:send_request)
+          .with('document/60768679/333', put: { 'name' => value })
+
+        subject.replace(key, { 'name' => value })
+      end
     end
 
-    it 'should replace a document by ID' do
-      expect(database).to receive(:send_request)
-        .with('document/60768679/333', put: { 'name' => value })
+    context 'when using the ID' do
+      let(:id) { '60768679/333' }
+
+      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)
 
-      subject.replace(333, { 'name' => value })
+        subject.fetch(id)
+      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)
+
+        subject[id]
+      end
+
+      it 'should replace a document by ID' do
+        expect(database).to receive(:send_request)
+          .with('document/60768679/333', put: { 'name' => value })
+
+        subject.replace(id, { 'name' => value })
+      end
     end
 
     it 'should create a new document' do

data/spec/unit/configuration_spec.rb

@@ -20,12 +20,12 @@ describe Ashikawa::Core::Configuration do
     end.to raise_error(ArgumentError, /either an url or a connection/)
   end
 
-  describe 'provided with connection' do
+  context 'provided with connection' do
     before { subject.connection = connection }
     its(:connection) { should be connection }
   end
 
-  describe 'provided with url, logger and adapter' do
+  context 'provided with url, logger and adapter' do
     before do
       subject.url = url
       subject.logger = logger
@@ -44,6 +44,23 @@ describe Ashikawa::Core::Configuration do
     end
   end
 
+  context 'provided with url' do
+    before do
+      subject.url = url
+    end
+
+    its(:url) { should be url }
+    its(:logger) { should be nil }
+    its(:adapter) { should be nil }
+
+    it 'should construct a connection' do
+      expect(Ashikawa::Core::Connection).to receive(:new)
+        .with(url, {})
+        .and_return(connection)
+      expect(subject.connection).to be connection
+    end
+  end
+
   describe 'set up authentication' do
     before do
       subject.url = url
@@ -51,14 +68,28 @@ describe Ashikawa::Core::Configuration do
         .and_return(connection)
     end
 
-    it 'should setup authentication' do
+    it 'should setup authentication when username and password were provided' do
       expect(connection).to receive(:authenticate_with)
-        .with({ username: username, password: password })
+        .with(username, password)
         .and_return(connection)
 
       subject.username = username
       subject.password = password
       subject.connection
     end
+
+    it 'should not setup authentication when only username was provided' do
+      expect(connection).to_not receive(:authenticate_with)
+
+      subject.username = username
+      subject.connection
+    end
+
+    it 'should not setup authentication when only password was provided' do
+      expect(connection).to_not receive(:authenticate_with)
+
+      subject.password = password
+      subject.connection
+    end
   end
 end

data/spec/unit/connection_spec.rb

@@ -46,26 +46,7 @@ describe Ashikawa::Core::Connection do
       [200, response_headers, JSON.generate({ 'name' => 'dude' })]
     end
 
-    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|
-      expect(req[:body]).to eq('{"test":1}')
-      [200, response_headers, JSON.generate({ 'name' => 'dude' })]
-    end
-
-    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"}']
-    end
-
-    expect(subject.send_request('my/path')).to eq({ 'name' => 'dude' })
+    subject.send_request 'my/path', delete: {}
     request_stub.verify_stubbed_calls
   end
 
@@ -75,24 +56,10 @@ describe Ashikawa::Core::Connection do
     end
 
     it 'should tell if authentication is enabled' do
-      subject.authenticate_with(username: 'testuser', password: 'testpassword')
+      subject.authenticate_with('testuser', 'testpassword')
       expect(subject.authentication?).to be_true
     end
 
-    it 'should only accept username & password pairs' do
-      expect do
-        subject.authenticate_with(username: 'kitty')
-      end.to raise_error(ArgumentError)
-
-      expect do
-        subject.authenticate_with(password: 'cheezburger?')
-      end.to raise_error(ArgumentError)
-    end
-
-    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'
 
@@ -216,43 +183,34 @@ describe Ashikawa::Core::Connection do
 
       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' }, '']
-      end
-
-      expect { subject.send_request 'document/4590/333' }.to raise_error(Ashikawa::Core::JsonError)
-
-      request_stub.verify_stubbed_calls
-    end
   end
 
-  describe 'logging' do
-    let(:request_stub) { Faraday::Adapter::Test::Stubs.new }
-    let(:logger) { double }
-    subject do
-      Ashikawa::Core::Connection.new(ARANGO_HOST, adapter: [:test, request_stub], logger: logger)
-    end
+  describe 'initializing Faraday' do
+    subject { Ashikawa::Core::Connection }
+    let(:adapter) { double('Adapter') }
+    let(:logger) { double('Logger') }
+    let(:blocky) { double('Block') }
 
-    it 'should log a get request' do
-      request_stub.get('/_api/test') do
-        [200, response_headers, JSON.generate({ a: 1 })]
-      end
-      expect(logger).to receive(:info).with("GET #{ARANGO_HOST}/_api/test ")
-      expect(logger).to receive(:info).with('200 {"a":1}')
+    it 'should initalize with specific logger and adapter' do
+      expect(Faraday).to receive(:new).with("#{ARANGO_HOST}/_api").and_yield(blocky)
+      expect(blocky).to receive(:request).with(:json)
+      expect(blocky).to receive(:response).with(:logger, logger)
+      expect(blocky).to receive(:response).with(:error_response)
+      expect(blocky).to receive(:response).with(:json)
+      expect(blocky).to receive(:adapter).with(adapter)
 
-      subject.send_request('test')
+      subject.new(ARANGO_HOST, adapter: adapter, logger: logger)
     end
 
-    it 'should log a post request' do
-      request_stub.post('/_api/test') do
-        [201, response_headers, JSON.generate({ b: 2 })]
-      end
-      expect(logger).to receive(:info).with("POST #{ARANGO_HOST}/_api/test {:a=>2}")
-      expect(logger).to receive(:info).with('201 {"b":2}')
+    it 'should initialize with defaults when no specific logger and adapter was given' do
+      expect(Faraday).to receive(:new).with("#{ARANGO_HOST}/_api").and_yield(blocky)
+      expect(blocky).to receive(:request).with(:json)
+      expect(blocky).to receive(:response).with(:logger, NullLogger.instance)
+      expect(blocky).to receive(:response).with(:error_response)
+      expect(blocky).to receive(:response).with(:json)
+      expect(blocky).to receive(:adapter).with(Faraday.default_adapter)
 
-      subject.send_request('test', post: { a: 2 })
+      subject.new(ARANGO_HOST)
     end
   end
 end

data/spec/unit/cursor_spec.rb

@@ -45,7 +45,7 @@ describe Ashikawa::Core::Cursor do
       expect(Ashikawa::Core::Document).to receive(:new)
         .exactly(5).times
 
-      subject.each { }
+      subject.each {}
     end
 
     it 'should return the raw string when the response consists of strings' do
@@ -112,7 +112,7 @@ describe Ashikawa::Core::Cursor do
       expect(Ashikawa::Core::Edge).to receive(:new)
         .exactly(2).times
 
-      subject.each { }
+      subject.each {}
     end
   end
 

data/spec/unit/database_spec.rb

@@ -16,6 +16,8 @@ describe Ashikawa::Core::Database do
   let(:logger) { double }
   let(:adapter) { double }
   let(:configuration) { double }
+  let(:raw_collection) { double }
+  let(:collection) { double }
 
   it 'should initialize with a configuration object' do
     expect(Ashikawa::Core::Configuration).to receive(:new)
@@ -33,19 +35,12 @@ describe Ashikawa::Core::Database do
 
     it 'should create a query' do
       expect(Ashikawa::Core::Query).to receive(:new)
-        .exactly(1).times
+        .once
         .with(subject)
 
       subject.query
     end
 
-    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'
-    end
-
     it 'should fetch all available non-system collections' do
       expect(connection).to receive(:send_request)
         .with('collection')
@@ -73,10 +68,10 @@ describe Ashikawa::Core::Database do
     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') }
+        .and_return { raw_collection }
 
       expect(Ashikawa::Core::Collection).to receive(:new)
-        .with(subject, server_response('collections/60768679'))
+        .with(subject, raw_collection)
 
       subject.create_collection('volatile_collection')
     end
@@ -84,10 +79,10 @@ describe Ashikawa::Core::Database do
     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') }
+        .and_return { |path| raw_collection }
 
       expect(Ashikawa::Core::Collection).to receive(:new)
-        .with(subject, server_response('collections/60768679'))
+        .with(subject, raw_collection)
 
       subject.create_collection('volatile_collection', is_volatile: true)
     end
@@ -117,10 +112,10 @@ describe Ashikawa::Core::Database do
     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') }
+        .and_return { |path| raw_collection }
 
       expect(Ashikawa::Core::Collection).to receive(:new)
-        .with(subject, server_response('collections/60768679'))
+        .with(subject, raw_collection)
 
       subject.create_collection('volatile_collection', content_type: :edge)
     end
@@ -128,10 +123,10 @@ describe Ashikawa::Core::Database do
     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') }
+        .and_return { |path| raw_collection }
 
       expect(Ashikawa::Core::Collection).to receive(:new)
-        .with(subject, server_response('collections/60768679'))
+        .with(subject, raw_collection)
 
       subject.collection(60_768_679)
     end
@@ -139,26 +134,19 @@ describe Ashikawa::Core::Database do
     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') }
+        .and_return { |path| raw_collection }
 
       expect(Ashikawa::Core::Collection).to receive(:new)
-        .with(subject, server_response('collections/60768679'))
+        .with(subject, raw_collection)
 
       subject[60_768_679]
     end
 
     it "should create a single collection if it doesn't exist" do
-      allow(connection).to receive :send_request do |path, method|
-        method ||= {}
-        if method.key? :post
-          server_response('collections/60768679')
-        else
-          raise Ashikawa::Core::CollectionNotFoundException
-        end
+      expect(connection).to receive(:send_request).with('collection/new_collection') do
+        raise Ashikawa::Core::CollectionNotFoundException
       end
-      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'))
+      expect(subject).to receive(:create_collection).with('new_collection').and_return(collection)
 
       subject['new_collection']
     end