ashikawa-core 0.8.0 → 0.9.0

data/spec/unit/spec_helper.rb

@@ -1,5 +1,16 @@
+# -*- 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'))
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
 
 # Do not run SimpleCov in Guard
 unless defined?(Guard)
@@ -20,9 +31,9 @@ unless defined?(Guard)
 end
 
 # Helper to simulate Server Responses. Parses the fixtures in the spec folder
-require "json"
+require 'json'
 def server_response(path)
   JSON.parse(File.readlines("spec/fixtures/#{path}.json").join)
 end
 
-ARANGO_HOST = "http://localhost:8529"
+ARANGO_HOST = 'http://localhost:8529'

data/spec/unit/status_spec.rb

@@ -1,51 +1,51 @@
-require "ashikawa-core/status"
+# -*- encoding : utf-8 -*-
+require 'ashikawa-core/status'
 
 describe Ashikawa::Core::Status do
   subject { Ashikawa::Core::Status }
-  let(:status_codes) { (1..6).to_a }
 
-  it "should know if the collection is new born" do
-    status = subject.new 1
-    status.new_born?.should == true
-
-    (status_codes - [1]).each do |status_code|
-      status = subject.new status_code
-      status.new_born?.should == false
-    end
+  describe 'a new born collection' do
+    subject { Ashikawa::Core::Status.new(1) }
+    its(:new_born?) { should be_true }
+    its(:unloaded?) { should be_false }
+    its(:loaded?) { should be_false }
+    its(:being_unloaded?) { should be_false }
+    its(:corrupted?) { should be_false }
   end
 
-  it "should know if the collection is unloaded" do
-    status = subject.new 2
-    status.unloaded?.should == true
-
-    (status_codes - [2]).each do |status_code|
-      status = subject.new status_code
-      status.unloaded?.should == false
-    end
+  describe 'an unloaded collection' do
+    subject { Ashikawa::Core::Status.new(2) }
+    its(:new_born?) { should be_false }
+    its(:unloaded?) { should be_true }
+    its(:loaded?) { should be_false }
+    its(:being_unloaded?) { should be_false }
+    its(:corrupted?) { should be_false }
   end
 
-  it "should know if the collection is loaded" do
-    status = subject.new 3
-    status.loaded?.should == true
-
-    (status_codes - [3]).each do |status_code|
-      status = subject.new status_code
-      status.loaded?.should == false
-    end
+  describe 'a loaded collection' do
+    subject { Ashikawa::Core::Status.new(3) }
+    its(:new_born?) { should be_false }
+    its(:unloaded?) { should be_false }
+    its(:loaded?) { should be_true }
+    its(:being_unloaded?) { should be_false }
+    its(:corrupted?) { should be_false }
   end
 
-  it "should know if the collection is being unloaded" do
-    status = subject.new 4
-    status.being_unloaded?.should == true
-
-    (status_codes - [4]).each do |status_code|
-      status = subject.new status_code
-      status.being_unloaded?.should == false
-    end
+  describe 'a collection being unloaded' do
+    subject { Ashikawa::Core::Status.new(4) }
+    its(:new_born?) { should be_false }
+    its(:unloaded?) { should be_false }
+    its(:loaded?) { should be_false }
+    its(:being_unloaded?) { should be_true }
+    its(:corrupted?) { should be_false }
   end
 
-  it "should know if the collection is corrupted" do
-    status = subject.new 6
-    status.corrupted?.should == true
+  describe 'a corrupted collection' do
+    subject { Ashikawa::Core::Status.new(6) }
+    its(:new_born?) { should be_false }
+    its(:unloaded?) { should be_false }
+    its(:loaded?) { should be_false }
+    its(:being_unloaded?) { should be_false }
+    its(:corrupted?) { should be_true }
   end
 end

data/spec/unit/transaction_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/transaction'
 
@@ -5,147 +6,143 @@ describe Ashikawa::Core::Transaction do
   let(:db) { double }
   let(:action) { double }
 
-  describe "creating a transaction" do
+  describe 'creating a transaction' do
     subject { Ashikawa::Core::Transaction }
 
-    it "should be initialized with only write collections" do
-      transaction = subject.new(db, action, :write => [
-        "collection_1"
-      ])
-
-      transaction.write_collections.should == ["collection_1"]
+    it 'should be initialized with only write collections' do
+      transaction = subject.new(db, action, write: ['collection_1'])
+      expect(transaction.write_collections).to eq(['collection_1'])
     end
 
-    it "should be initialized with only read collections" do
-      transaction = subject.new(db, action, :read => [
-        "collection_1"
-      ])
-
-      transaction.read_collections.should == ["collection_1"]
+    it 'should be initialized with only read collections' do
+      transaction = subject.new(db, action, read: ['collection_1'])
+      expect(transaction.read_collections).to eq(['collection_1'])
     end
   end
 
-  describe "using a transaction" do
+  describe 'using a transaction' do
     let(:read_and_write_collections) do
-      { :read => ["collection_1"], :write => ["collection_2"] }
+      {
+        read: ['collection_1'],
+        write: ['collection_2']
+      }
     end
 
     let(:only_read_collection) do
-      { :read => ["collection_1"] }
+      {
+        read: ['collection_1']
+      }
     end
 
     let(:only_write_collection) do
-      { :write => ["collection_1"] }
+      {
+        write: ['collection_1']
+      }
     end
 
     subject { Ashikawa::Core::Transaction.new(db, action, read_and_write_collections) }
 
-    it "should be possible to activate waiting for sync" do
-      subject.wait_for_sync.should == false
+    it 'should be possible to activate waiting for sync' do
+      expect(subject.wait_for_sync).to be_false
       subject.wait_for_sync = true
-      subject.wait_for_sync.should == true
+      expect(subject.wait_for_sync).to be_true
     end
 
-    it "should be possible to set the lock timeout" do
-      subject.lock_timeout.should == nil
+    it 'should be possible to set the lock timeout' do
+      expect(subject.lock_timeout).to be_nil
       subject.lock_timeout = 30
-      subject.lock_timeout.should == 30
+      expect(subject.lock_timeout).to be 30
     end
 
-    describe "execute" do
+    describe 'execute' do
       let(:response) { double }
       let(:result) { double }
       let(:wait_for_sync) { double }
       let(:lock_timeout) { double }
       let(:action_params) { double }
 
-      before {
-        response.stub(:[])
-        db.stub(:send_request).and_return { response }
-      }
+      before do
+        allow(response).to receive(:[])
+        allow(db).to receive(:send_request)
+          .and_return { response }
+      end
 
-      it "should return the result from the database" do
-        response.should_receive(:[]).with("result").and_return { result }
-        db.should_receive(:send_request).and_return { response }
-        subject.execute.should == result
+      it 'should return the result from the database' do
+        expect(response).to receive(:[])
+          .with('result')
+          .and_return(result)
+        expect(db).to receive(:send_request)
+          .and_return { response }
+        expect(subject.execute).to eq(result)
       end
 
-      it "should post to `transaction` endpoint" do
-        db.should_receive(:send_request).with("transaction", :post => an_instance_of(Hash))
+      it 'should post to `transaction` endpoint' do
+        expect(db).to receive(:send_request)
+          .with('transaction', post: an_instance_of(Hash))
         subject.execute
       end
 
-      it "should only send the read collection if no write collection was provided" do
+      it 'should only send the read collection if no write collection was provided' do
         transaction = Ashikawa::Core::Transaction.new(db, action, only_read_collection)
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_including(:collections => only_read_collection)
-        })
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_including(collections: only_read_collection) })
         transaction.execute
       end
 
-      it "should send the information about the read and write collections" do
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_including(:collections => read_and_write_collections)
-        })
+      it 'should send the information about the read and write collections' do
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_including(collections: read_and_write_collections) })
         subject.execute
       end
 
-      it "should only send the write collection if no read collection was provided" do
+      it 'should only send the write collection if no read collection was provided' do
         transaction = Ashikawa::Core::Transaction.new(db, action, only_write_collection)
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_including(:collections => only_write_collection)
-        })
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_including(collections: only_write_collection) })
         transaction.execute
       end
 
-      it "should send the information about the action" do
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_including(:action => action)
-        })
+      it 'should send the information about the action' do
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_including(action: action) })
         subject.execute
       end
 
-      it "should send with wait for sync set to false by default" do
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_including(:waitForSync => false)
-        })
+      it 'should send with wait for sync set to false by default' do
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_including(waitForSync: false) })
         subject.execute
       end
 
-      it "should send with wait for sync set to the value provided by the user" do
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_including(:waitForSync => wait_for_sync)
-        })
+      it 'should send with wait for sync set to the value provided by the user' do
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_including(waitForSync: wait_for_sync) })
         subject.wait_for_sync = wait_for_sync
         subject.execute
       end
 
-      it "should not send lock timeout by default" do
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_not_including(:lockTimeout => anything)
-        })
+      it 'should not send lock timeout by default' do
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_not_including(lockTimeout: anything) })
         subject.execute
       end
 
-      it "should send the configured lock timeout" do
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_including(:lockTimeout => lock_timeout)
-        })
+      it 'should send the configured lock timeout' do
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_including(lockTimeout: lock_timeout) })
         subject.lock_timeout = lock_timeout
         subject.execute
       end
 
-      it "should send the arguments object if it was provided" do
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_including(:params => action_params)
-        })
+      it 'should send the arguments object if it was provided' do
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_including(params: action_params) })
         subject.execute(action_params)
       end
 
-      it "should not send params by default" do
-        db.should_receive(:send_request).with(anything, {
-          :post => hash_not_including(:params => anything)
-        })
+      it 'should not send params by default' do
+        expect(db).to receive(:send_request)
+          .with(anything, { post: hash_not_including(params: anything) })
         subject.execute
       end
     end

data/tasks/adjustments.rake

@@ -1,55 +1,31 @@
+# -*- encoding : utf-8 -*-
 ## Specs
 # Difference to Devtools:
 # * Acceptance, no integration tests
-# * Special Case: ArangoDB needed for Acceptance Tests
 
-Rake::Task["spec"].clear
-Rake::Task["spec:integration"].clear
+Rake::Task['spec'].clear
+Rake::Task['spec:integration'].clear
 
 desc 'Run all specs'
-task :spec => %w[ spec:unit spec:acceptance ]
+task spec: %w[ spec:unit spec:acceptance ]
 
 namespace :spec do
-  desc "Run the acceptance tests. Requires ArangoDB to be running."
+  desc 'Run the acceptance tests. Requires ArangoDB to be running.'
   RSpec::Core::RakeTask.new(:acceptance) do |spec|
-    spec.pattern = "spec/acceptance/*_spec.rb"
-  end
-
-  desc "Run the acceptance tests. Requires ArangoDB."
-  RSpec::Core::RakeTask.new(:start_arango_and_run_acceptance) do |spec|
-    spec.rspec_opts = "--require acceptance/arango_helper.rb"
-    spec.pattern = "spec/acceptance/*_spec.rb"
-  end
-
-  desc "Run the authentication acceptance tests. Requires ArangoDB."
-  RSpec::Core::RakeTask.new(:start_arango_and_run_acceptance_auth) do |spec|
-    spec.rspec_opts = "--require acceptance_auth/arango_helper.rb"
-    spec.pattern = "spec/acceptance_auth/*_spec.rb"
+    spec.pattern = 'spec/acceptance/*_spec.rb'
   end
 end
 
 ## Metrics
 # Differences to Devtools:
 # * Do not run mutant yet
-# * metrics task only runs metrics (and not specs)
 
-Rake::Task["ci"].clear
-Rake::Task["ci:metrics"].clear
-
-namespace :ci do
-  desc 'Run all metrics except mutant and reek'
-  task :metrics => %w[
-    metrics:coverage
-    metrics:yardstick:verify
-    metrics:rubocop
-    metrics:flog
-    metrics:flay
-    metrics:reek
-  ]
-end
+Rake::Task['ci'].clear
 
 desc 'Run all metrics and specs'
-task :ci => %w[
+task ci: %w[
   spec
   ci:metrics
 ]
+
+task default: :ci

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ashikawa-core
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - moonglum
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-22 00:00:00.000000000 Z
+date: 2013-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.0.5
 description: Ashikawa Core is a wrapper around the ArangoDB REST API. It provides
-  low level access and will be used in different ArangoDB ODMs and other tools.
+  low level access and is intended to be used in ArangoDB ODMs and other tools.
 email:
 - me@moonglum.net
 executables: []
@@ -79,6 +79,7 @@ files:
 - .rspec
 - .ruby-version
 - .travis.yml
+- CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
 - Gemfile.devtools
@@ -87,6 +88,8 @@ files:
 - README.md
 - Rakefile
 - ashikawa-core.gemspec
+- cache/Mac_applications
+- config/devtools.yml
 - config/flay.yml
 - config/flog.yml
 - config/mutant.yml
@@ -102,6 +105,7 @@ files:
 - lib/ashikawa-core/document.rb
 - lib/ashikawa-core/edge.rb
 - lib/ashikawa-core/exceptions/client_error.rb
+- lib/ashikawa-core/exceptions/client_error/authentication_failed.rb
 - lib/ashikawa-core/exceptions/client_error/bad_syntax.rb
 - lib/ashikawa-core/exceptions/client_error/resource_not_found.rb
 - lib/ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found.rb
@@ -119,15 +123,11 @@ files:
 - lib/ashikawa-core/status.rb
 - lib/ashikawa-core/transaction.rb
 - lib/ashikawa-core/version.rb
-- spec/acceptance/arango_helper.rb
 - spec/acceptance/basic_spec.rb
 - spec/acceptance/index_spec.rb
 - spec/acceptance/query_spec.rb
 - spec/acceptance/spec_helper.rb
 - spec/acceptance/transactions_spec.rb
-- spec/acceptance_auth/arango_helper.rb
-- spec/acceptance_auth/auth_spec.rb
-- spec/acceptance_auth/spec_helper.rb
 - spec/fixtures/collections/60768679-count.json
 - spec/fixtures/collections/60768679-figures.json
 - spec/fixtures/collections/60768679-properties-volatile.json
@@ -155,6 +155,7 @@ files:
 - spec/fixtures/simple-queries/within.json
 - spec/setup/arangodb.sh
 - spec/unit/collection_spec.rb
+- spec/unit/configuration_spec.rb
 - spec/unit/connection_spec.rb
 - spec/unit/cursor_spec.rb
 - spec/unit/database_spec.rb
@@ -188,22 +189,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- ArangoDB, v1.3
+- ArangoDB, v1.4
 rubyforge_project: ashikawa-core
-rubygems_version: 2.0.3
+rubygems_version: 2.1.1
 signing_key: 
 specification_version: 4
 summary: Ashikawa Core is a wrapper around the ArangoDB REST API
 test_files:
-- spec/acceptance/arango_helper.rb
 - spec/acceptance/basic_spec.rb
 - spec/acceptance/index_spec.rb
 - spec/acceptance/query_spec.rb
 - spec/acceptance/spec_helper.rb
 - spec/acceptance/transactions_spec.rb
-- spec/acceptance_auth/arango_helper.rb
-- spec/acceptance_auth/auth_spec.rb
-- spec/acceptance_auth/spec_helper.rb
 - spec/fixtures/collections/60768679-count.json
 - spec/fixtures/collections/60768679-figures.json
 - spec/fixtures/collections/60768679-properties-volatile.json
@@ -231,6 +228,7 @@ test_files:
 - spec/fixtures/simple-queries/within.json
 - spec/setup/arangodb.sh
 - spec/unit/collection_spec.rb
+- spec/unit/configuration_spec.rb
 - spec/unit/connection_spec.rb
 - spec/unit/cursor_spec.rb
 - spec/unit/database_spec.rb