ashikawa-core 0.10.0 → 0.11.0

data/spec/acceptance/index_spec.rb

@@ -25,11 +25,11 @@ describe 'Indices' do
   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
+    expect(index.unique).to be_truthy
   end
 
   it 'should be possible to remove indices' do
-    pending 'See Bug #34'
+    skip 'See Bug #34'
 
     expect {
       index.delete

data/spec/acceptance/query_spec.rb

@@ -16,22 +16,22 @@ describe 'Queries' do
       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).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'
-      expect(database.query.valid?(valid_query)).to be_true
+      expect(database.query.valid?(valid_query)).to be_truthy
 
       invalid_query = 'FOR u IN my_collection FILTER u.bowling == true'
-      expect(database.query.valid?(invalid_query)).to be_false
+      expect(database.query.valid?(invalid_query)).to be_falsey
     end
   end
 
   describe 'simple query via collection object' do
     subject { collection }
-    before(:each) { subject.truncate! }
+    before(:each) { subject.truncate }
 
     it 'should return all documents of a collection' do
       subject.create_document({ name: 'testname', age: 27 })

data/spec/acceptance/spec_helper.rb

@@ -14,17 +14,32 @@ end
 
 require 'ashikawa-core'
 
-port = ENV.fetch('ARANGODB_PORT', 8529)
-username = ENV.fetch('ARANGODB_USERNAME', 'root')
-password = ENV.fetch('ARANGODB_PASSWORD', '')
-authentification_enabled = ENV['ARANGODB_DISABLE_AUTHENTIFICATION'] == 'false'
+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
+# System Database for general use in specs
 DATABASE = Ashikawa::Core::Database.new do |config|
-  config.url = "http://localhost:#{port}"
+  config.url = "http://localhost:#{PORT}"
 
-  if authentification_enabled
-    config.username = username
-    config.password = password
+  if AUTHENTIFICATION_ENABLED
+    config.username = USERNAME
+    config.password = PASSWORD
+  end
+end
+
+def database_with_random_name
+  # This results in a database that has a valid name according to:
+  # https://www.arangodb.org/manuals/2/NamingConventions.html#DatabaseNames
+  name = "a#{rand.to_s[2, 10]}"
+
+  Ashikawa::Core::Database.new do |config|
+    config.url = "http://localhost:#{PORT}/_db/#{name}"
+
+    if AUTHENTIFICATION_ENABLED
+      config.username = USERNAME
+      config.password = PASSWORD
+    end
   end
 end

data/spec/acceptance/transactions_spec.rb

@@ -12,8 +12,8 @@ describe 'Transactions' do
   end
 
   let(:js_function) { 'function (x) { return x.a; }' }
-  let(:write_collections) { %w{collection_1 collection_2} }
-  let(:read_collections) { %w{collection_2} }
+  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: write_collections, read: read_collections

data/spec/unit/collection_spec.rb

@@ -94,7 +94,7 @@ describe Ashikawa::Core::Collection do
       expect(database).to receive(:send_request)
         .with('collection/60768679/truncate', put: {})
 
-      subject.truncate!
+      subject.truncate
     end
 
     it 'should change its name' do
@@ -169,7 +169,7 @@ describe Ashikawa::Core::Collection do
       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
+            'type' => 'hash', 'fields' => %w(a b), 'unique' => false
           })
           .and_return(index_response)
         expect(Ashikawa::Core::Index).to receive(:new)
@@ -181,7 +181,7 @@ describe Ashikawa::Core::Collection do
       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
+            'type' => 'hash', 'fields' => %w(a b), 'unique' => true
           })
           .and_return(index_response)
         expect(Ashikawa::Core::Index).to receive(:new)

data/spec/unit/connection_spec.rb

@@ -42,7 +42,7 @@ describe Ashikawa::Core::Connection do
   end
 
   it 'should send a delete request' do
-    request_stub.delete('/_api/my/path') do |request|
+    request_stub.delete('/_api/my/path') do |_|
       [200, response_headers, JSON.generate({ 'name' => 'dude' })]
     end
 
@@ -50,20 +50,52 @@ describe Ashikawa::Core::Connection do
     request_stub.verify_stubbed_calls
   end
 
+  context 'with database suffix' do
+    let(:database_name) { 'ashikawa' }
+    subject do
+      Ashikawa::Core::Connection.new("#{ARANGO_HOST}/_db/#{database_name}", adapter: [:test, request_stub])
+    end
+
+    its(:database_name) { should eq database_name }
+
+    let(:options) { double('Options') }
+    it 'should be able to send a request without database suffix' do
+      expect(subject).to receive(:send_request)
+        .with("#{ARANGO_HOST}/_api/some_endpoint", options)
+
+      subject.send_request_without_database_suffix('some_endpoint', options)
+    end
+  end
+
+  context 'without database suffix' do
+    subject do
+      Ashikawa::Core::Connection.new(ARANGO_HOST, adapter: [:test, request_stub])
+    end
+
+    its(:database_name) { should eq '_system' }
+    let(:options) { double('Options') }
+    it 'should be able to send a request without database suffix' do
+      expect(subject).to receive(:send_request)
+        .with("#{ARANGO_HOST}/_api/some_endpoint", options)
+
+      subject.send_request_without_database_suffix('some_endpoint', options)
+    end
+  end
+
   describe 'authentication' do
     it 'should have authentication turned off by default' do
-      expect(subject.authentication?).to be_false
+      expect(subject.authentication?).to be_falsey
     end
 
     it 'should tell if authentication is enabled' do
       subject.authenticate_with('testuser', 'testpassword')
-      expect(subject.authentication?).to be_true
+      expect(subject.authentication?).to be_truthy
     end
 
     it 'should send the authentication data with every GET request' do
-      pending 'Find out how to check for basic auth via Faraday Stubs'
+      skip 'Find out how to check for basic auth via Faraday Stubs'
 
-      request_stub.get('/_api/my/path') do |request|
+      request_stub.get('/_api/my/path') do |_|
         [200, response_headers, JSON.generate({ 'name' => 'dude' })]
       end
 
@@ -96,7 +128,7 @@ describe Ashikawa::Core::Connection do
 
     it 'should throw its own exception when doing a bad request' do
       request_stub.get('/_api/bad/request') do
-        [400, response_headers, '']
+        [400, response_headers, '{}']
       end
 
       expect do

data/spec/unit/database_spec.rb

@@ -41,10 +41,52 @@ describe Ashikawa::Core::Database do
       subject.query
     end
 
+    let(:database_list) { double('DatabaseList') }
+
+    it 'should list all databases' do
+      expect(connection).to receive(:send_request)
+        .with('database')
+        .and_return({ 'result' => database_list, 'error' => false, 'code' => 200 })
+
+      expect(subject.all_databases).to be database_list
+    end
+
+    context "using a database called 'ashikawa'" do
+      before { allow(connection).to receive(:database_name).and_return('ashikawa') }
+
+      its(:name) { should eq 'ashikawa' }
+
+      describe 'create' do
+        it 'should be able to create itself' do
+          expect(connection).to receive(:send_request_without_database_suffix)
+            .with('database', post: { name: 'ashikawa' })
+
+          subject.create
+        end
+
+        it 'should return an error message if the database name is already taken' do
+          expect(connection).to receive(:send_request_without_database_suffix)
+            .with('database', post: { name: 'ashikawa' })
+            .and_raise(Ashikawa::Core::ClientError, '1207: duplicate name')
+
+          expect { subject.create }.to raise_error(Ashikawa::Core::ClientError, '1207: duplicate name')
+        end
+      end
+
+      describe 'drop' do
+        it 'should be able to drop itself' do
+          expect(connection).to receive(:send_request_without_database_suffix)
+            .with('database/ashikawa', delete: {})
+
+          subject.drop
+        end
+      end
+    end
+
     it 'should fetch all available non-system collections' do
       expect(connection).to receive(:send_request)
         .with('collection')
-        .and_return { server_response('collections/all') }
+        .and_return(server_response('collections/all'))
 
       (0..1).each do |k|
         expect(Ashikawa::Core::Collection).to receive(:new)
@@ -57,7 +99,7 @@ describe Ashikawa::Core::Database do
     it 'should fetch all available non-system collections' do
       expect(connection).to receive(:send_request)
         .with('collection')
-        .and_return { server_response('collections/all') }
+        .and_return(server_response('collections/all'))
 
       expect(Ashikawa::Core::Collection).to receive(:new)
         .exactly(5).times
@@ -65,10 +107,19 @@ describe Ashikawa::Core::Database do
       expect(subject.system_collections.length).to eq(5)
     end
 
+    it 'should truncate all documents in all collections' do
+      collection = double('Collection')
+      allow(subject).to receive(:collections)
+        .and_return([collection])
+      expect(collection).to receive(:truncate)
+
+      subject.truncate
+    end
+
     it 'should create a non volatile collection by default' do
       expect(connection).to receive(:send_request)
         .with('collection', post: { name: 'volatile_collection' })
-        .and_return { raw_collection }
+        .and_return(raw_collection)
 
       expect(Ashikawa::Core::Collection).to receive(:new)
         .with(subject, raw_collection)
@@ -79,7 +130,7 @@ 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| raw_collection }
+        .and_return(raw_collection)
 
       expect(Ashikawa::Core::Collection).to receive(:new)
         .with(subject, raw_collection)
@@ -112,7 +163,7 @@ 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| raw_collection }
+        .and_return(raw_collection)
 
       expect(Ashikawa::Core::Collection).to receive(:new)
         .with(subject, raw_collection)
@@ -123,7 +174,7 @@ 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| raw_collection }
+        .and_return(raw_collection)
 
       expect(Ashikawa::Core::Collection).to receive(:new)
         .with(subject, raw_collection)
@@ -134,7 +185,7 @@ 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| raw_collection }
+        .and_return(raw_collection)
 
       expect(Ashikawa::Core::Collection).to receive(:new)
         .with(subject, raw_collection)

data/spec/unit/document_spec.rb

@@ -87,9 +87,9 @@ describe Ashikawa::Core::Document do
     end
 
     it 'should be refreshable' do
-      expect(database).to receive(:send_request).with(path, {}).and_return {
-        { 'name' => 'Jeff' }
-      }
+      expect(database).to receive(:send_request)
+        .with(path, {})
+        .and_return({ 'name' => 'Jeff' })
 
       refreshed_subject = subject.refresh!
       expect(refreshed_subject).to eq(subject)

data/spec/unit/exception_spec.rb

@@ -21,7 +21,11 @@ describe Ashikawa::Core::ClientError do
 end
 
 describe Ashikawa::Core::BadSyntax do
-  its(:to_s) { should include 'syntax' }
+  let(:error_message) { 'foo' }
+  let(:bad_syntax) { Ashikawa::Core::BadSyntax.new(error_message) }
+  it 'accepts an error message to be included in to_s' do
+    expect(bad_syntax.to_s).to include error_message
+  end
 end
 
 describe Ashikawa::Core::AuthenticationFailed do

data/spec/unit/index_spec.rb

@@ -29,7 +29,12 @@ describe Ashikawa::Core::Index do
 
     its(:id) { should be(id) }
     its(:type) { should be(type_as_sym) }
-    its(:on) { should include(field_as_sym) }
+
+    it 'should know which fields it is on' do
+      skip 'Currently not working on Rubinius'
+      expect(subject).to include(field_as_sym)
+    end
+
     its(:unique) { should be(unique) }
 
     it 'should be deletable' do

data/spec/unit/query_spec.rb

@@ -22,7 +22,7 @@ describe Ashikawa::Core::Query do
       it 'should list all documents' do
         expect(collection).to receive(:send_request)
           .with('simple/all', put: { 'collection' => name })
-          .and_return { server_response('simple-queries/all') }
+          .and_return(server_response('simple-queries/all'))
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
         subject.all
@@ -31,7 +31,7 @@ describe Ashikawa::Core::Query do
       it 'should be able to limit the number of documents' do
         expect(collection).to receive(:send_request)
           .with('simple/all', put: { 'collection' => name, 'limit' => limit })
-          .and_return { server_response('simple-queries/all_skip') }
+          .and_return(server_response('simple-queries/all_skip'))
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
         subject.all(limit: limit)
@@ -40,7 +40,7 @@ describe Ashikawa::Core::Query do
       it 'should be able to skip documents' do
         expect(collection).to receive(:send_request)
           .with('simple/all', put: { 'collection' => name, 'skip' => skip })
-          .and_return { server_response('simple-queries/all_limit') }
+          .and_return(server_response('simple-queries/all_limit'))
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
         subject.all(skip: skip)
@@ -48,52 +48,52 @@ describe Ashikawa::Core::Query do
     end
 
     describe 'first by example' do
-      let(:example) { double }
+      let(:example_document) { double }
       let(:response) { server_response('simple-queries/example') }
 
       it 'should find exactly one fitting document' do
         allow(collection).to receive(:database)
           .and_return(double)
         expect(collection).to receive(:send_request)
-          .with('simple/first-example', put: { 'collection' => name, 'example' => example })
+          .with('simple/first-example', put: { 'collection' => name, 'example' => example_document })
           .and_return(response)
         expect(Ashikawa::Core::Document).to receive(:new)
 
-        subject.first_example(example)
+        subject.first_example(example_document)
       end
     end
 
     describe 'all by example' do
-      let(:example) { { hello: 'world' } }
+      let(:example_document) { { hello: 'world' } }
       let(:response) { server_response('simple-queries/example') }
       let(:limit) { double }
       let(:skip) { double }
 
       it 'should find all fitting documents' do
         expect(collection).to receive(:send_request)
-          .with('simple/by-example', put: { 'collection' => name, 'example' => example })
+          .with('simple/by-example', put: { 'collection' => name, 'example' => example_document })
           .and_return(response)
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.by_example(example)
+        subject.by_example(example_document)
       end
 
       it 'should be able to limit the number of documents' do
         expect(collection).to receive(:send_request)
-          .with('simple/by-example', put: { 'collection' => name, 'limit' => limit, 'example' => example })
+          .with('simple/by-example', put: { 'collection' => name, 'limit' => limit, 'example' => example_document })
           .and_return(response)
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.by_example(example, limit: limit)
+        subject.by_example(example_document, limit: limit)
       end
 
       it 'should be able to skip documents' do
         expect(collection).to receive(:send_request)
-          .with('simple/by-example', put: { 'collection' => name, 'skip' => skip, 'example' => example })
+          .with('simple/by-example', put: { 'collection' => name, 'skip' => skip, 'example' => example_document })
           .and_return(response)
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
-        subject.by_example(example, skip: skip)
+        subject.by_example(example_document, skip: skip)
       end
     end
 
@@ -112,7 +112,7 @@ describe Ashikawa::Core::Query do
       it 'should find documents based on latitude/longitude' do
         expect(collection).to receive(:send_request)
           .with('simple/near', put: arguments)
-          .and_return { response }
+          .and_return(response)
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
         subject.near(latitude: latitude, longitude: longitude)
@@ -136,7 +136,7 @@ describe Ashikawa::Core::Query do
       it 'should look for documents based on latidude/longitude' do
         expect(collection).to receive(:send_request)
           .with('simple/within' , put: arguments)
-          .and_return { response }
+          .and_return(response)
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
         subject.within(latitude: latitude, longitude: longitude, radius: radius)
@@ -162,7 +162,7 @@ describe Ashikawa::Core::Query do
       it 'should look for documents with an attribute in that range' do
         expect(collection).to receive(:send_request)
           .with('simple/range' , put: arguments)
-          .and_return { response }
+          .and_return(response)
         expect(Ashikawa::Core::Cursor).to receive(:new)
 
         subject.in_range(attribute: attribute, left: left, right: right, closed: closed)
@@ -194,12 +194,22 @@ describe Ashikawa::Core::Query do
         subject.execute(query, count: count, batch_size: batch_size)
       end
 
+      it 'passes bound variables to the server' do
+        allow(collection).to receive(:database)
+          .and_return(double)
+        expect(collection).to receive(:send_request)
+          .with('cursor', post: { 'bindVars' => { 'foo' => 'bar' }, 'query' => query })
+          .and_return(response)
+
+        subject.execute(query, bind_vars: { 'foo' => 'bar' })
+      end
+
       it 'should return true when asked if a valid query is valid' do
         expect(collection).to receive(:send_request)
           .with('query', post: { 'query' => query })
-          .and_return { server_response('query/valid') }
+          .and_return(server_response('query/valid'))
 
-        expect(subject.valid?(query)).to be_true
+        expect(subject.valid?(query)).to be_truthy
       end
 
       it 'should return false when asked if an invalid query is valid' do
@@ -208,7 +218,7 @@ describe Ashikawa::Core::Query do
         expect(collection).to receive(:send_request)
           .with('query', post: { 'query' => query })
 
-        expect(subject.valid?(query)).to be_false
+        expect(subject.valid?(query)).to be_falsey
       end
     end
   end
@@ -249,9 +259,9 @@ describe Ashikawa::Core::Query do
       it 'should return true when asked if a valid query is valid' do
         expect(database).to receive(:send_request)
           .with('query', post: { 'query' => query })
-          .and_return { valid_response }
+          .and_return(valid_response)
 
-        expect(subject.valid?(query)).to be_true
+        expect(subject.valid?(query)).to be_truthy
       end
 
       it 'should return false when asked if an invalid query is valid' do
@@ -259,7 +269,7 @@ describe Ashikawa::Core::Query do
           .with('query', post: { 'query' => query })
           .and_raise(Ashikawa::Core::BadSyntax)
 
-        expect(subject.valid?(query)).to be_false
+        expect(subject.valid?(query)).to be_falsey
       end
     end
   end