ashikawa-core 0.8.0 → 0.9.0

data/lib/ashikawa-core/key_options.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Ashikawa
   module Core
     # Options for controlling keys of a collection
@@ -44,10 +45,10 @@ module Ashikawa
       # @example Create a new KeyOptions object
       #   KeyOptions.new({ :type => :autoincrement })
       def initialize(raw_key_options)
-        @type = raw_key_options["type"]
-        @offset = raw_key_options["offset"]
-        @increment = raw_key_options["increment"]
-        @allow_user_keys = raw_key_options["allowUserKeys"]
+        @type = raw_key_options['type']
+        @offset = raw_key_options['offset']
+        @increment = raw_key_options['increment']
+        @allow_user_keys = raw_key_options['allowUserKeys']
       end
     end
   end

data/lib/ashikawa-core/query.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require 'ashikawa-core/cursor'
 require 'ashikawa-core/document'
 require 'ashikawa-core/exceptions/no_collection_provided'
@@ -11,14 +12,14 @@ module Ashikawa
       extend Forwardable
 
       ALLOWED_KEYS_FOR_PATH = {
-        "simple/all"           => [:limit, :skip, :collection],
-        "simple/by-example"    => [:limit, :skip, :example, :collection],
-        "simple/near"          => [:latitude, :longitude, :distance, :skip, :limit, :geo, :collection],
-        "simple/within"        => [:latitude, :longitude, :radius, :distance, :skip, :limit, :geo, :collection],
-        "simple/range"         => [:attribute, :left, :right, :closed, :limit, :skip, :collection],
-        "cursor"               => [:query, :count, :batch_size, :collection],
-        "query"                => [:query],
-        "simple/first-example" => [:example, :collection]
+        'simple/all'           => [:limit, :skip, :collection],
+        'simple/by-example'    => [:limit, :skip, :example, :collection],
+        'simple/near'          => [:latitude, :longitude, :distance, :skip, :limit, :geo, :collection],
+        'simple/within'        => [:latitude, :longitude, :radius, :distance, :skip, :limit, :geo, :collection],
+        'simple/range'         => [:attribute, :left, :right, :closed, :limit, :skip, :collection],
+        'cursor'               => [:query, :count, :batch_size, :collection],
+        'query'                => [:query],
+        'simple/first-example' => [:example, :collection]
       }
 
       # Delegate sending requests to the connection
@@ -48,7 +49,7 @@ module Ashikawa
       #   query = Ashikawa::Core::Query.new(collection)
       #   query.all # => #<Cursor id=33>
       def all(options = {})
-        simple_query_request("simple/all", options)
+        simple_query_request('simple/all', options)
       end
 
       # Looks for documents in a collection which match the given criteria
@@ -62,9 +63,9 @@ module Ashikawa
       # @api public
       # @example Find all documents in a collection that are red
       #   query = Ashikawa::Core::Query.new(collection)
-      #   query.by_example({ "color" => "red" }, :options => { :limit => 1 }) #=> #<Cursor id=2444>
+      #   query.by_example({ 'color' => 'red' }, :options => { :limit => 1 }) #=> #<Cursor id=2444>
       def by_example(example = {}, options = {})
-        simple_query_request("simple/by-example", { :example => example }.merge(options))
+        simple_query_request('simple/by-example', { example: example }.merge(options))
       end
 
       # Looks for one document in a collection which matches the given criteria
@@ -75,11 +76,11 @@ module Ashikawa
       # @api public
       # @example Find one document in a collection that is red
       #   query = Ashikawa::Core::Query.new(collection)
-      #   query.first_example({ "color" => "red"}) # => #<Document id=2444 color="red">
+      #   query.first_example({ 'color' => 'red'}) # => #<Document id=2444 color="red">
       def first_example(example = {})
-        request = prepare_request("simple/first-example", { :example => example, :collection => collection.name })
-        response = send_request("simple/first-example", { :put => request })
-        Document.new(database, response["document"])
+        request = prepare_request('simple/first-example', { example: example, collection: collection.name })
+        response = send_request('simple/first-example', { put: request })
+        Document.new(database, response['document'])
       end
 
       # Looks for documents in a collection based on location
@@ -97,7 +98,7 @@ module Ashikawa
       #   query = Ashikawa::Core::Query.new(collection)
       #   query.near(:latitude => 37.331693, :longitude => -122.030468)
       def near(options = {})
-        simple_query_request("simple/near", options)
+        simple_query_request('simple/near', options)
       end
 
       # Looks for documents in a collection within a radius
@@ -116,7 +117,7 @@ module Ashikawa
       #   query = Ashikawa::Core::Query.new(collection)
       #   query.within(:latitude => 37.331693, :longitude => -122.030468, :radius => 100)
       def within(options = {})
-        simple_query_request("simple/within", options)
+        simple_query_request('simple/within', options)
       end
 
       # Looks for documents in a collection with an attribute between two values
@@ -124,7 +125,7 @@ module Ashikawa
       # @option options [Integer] :attribute The attribute path to check.
       # @option options [Integer] :left The lower bound
       # @option options [Integer] :right The upper bound
-      # @option options [Integer] :closed If true, use intervall including left and right, otherwise exclude right, but include left.
+      # @option options [Integer] :closed If true, the interval includes right
       # @option options [Integer] :skip The documents to skip in the query (optional).
       # @option options [Integer] :limit The maximal amount of documents to return (optional).
       # @return [Cursor]
@@ -134,7 +135,7 @@ module Ashikawa
       #   query = Ashikawa::Core::Query.new(collection)
       #   query.within(:latitude => 37.331693, :longitude => -122.030468, :radius => 100)
       def in_range(options = {})
-        simple_query_request("simple/range", options)
+        simple_query_request('simple/range', options)
       end
 
       # Send an AQL query to the database
@@ -146,9 +147,9 @@ module Ashikawa
       # @api public
       # @example Send an AQL query to the database
       #   query = Ashikawa::Core::Query.new(collection)
-      #   query.execute("FOR u IN users LIMIT 2") # => #<Cursor id=33>
+      #   query.execute('FOR u IN users LIMIT 2') # => #<Cursor id=33>
       def execute(query, options = {})
-        wrapped_request("cursor", :post, options.merge({ :query => query }))
+        wrapped_request('cursor', :post, options.merge({ query: query }))
       end
 
       # Test if an AQL query is valid
@@ -158,9 +159,9 @@ module Ashikawa
       # @api public
       # @example Validate an AQL query
       #   query = Ashikawa::Core::Query.new(collection)
-      #   query.valid?("FOR u IN users LIMIT 2") # => true
+      #   query.valid?('FOR u IN users LIMIT 2') # => true
       def valid?(query)
-        !!wrapped_request("query", :post, { :query => query })
+        !!wrapped_request('query', :post, { query: query })
       rescue Ashikawa::Core::BadSyntax
         false
       end
@@ -193,9 +194,19 @@ module Ashikawa
       def prepare_request(path, options)
         allowed_keys = ALLOWED_KEYS_FOR_PATH.fetch(path)
         options.keep_if { |key, _| allowed_keys.include?(key) }
-        Hash[options.map { |key, value|
-          [key.to_s.gsub(/_(.)/) { $1.upcase }, value]
-        }]
+        options.reduce({}) { |result, (key, value)|
+          result[snake_to_camel_case(key.to_s)] = value
+          result
+        }
+      end
+
+      # Translates Snake Case to Camel Case
+      #
+      # @param [String] str
+      # @return [String] The translated String
+      # @api private
+      def snake_to_camel_case(str)
+        str.gsub(/_(.)/) { |match| match[1].upcase }
       end
 
       # Send a simple query to the server
@@ -207,7 +218,7 @@ module Ashikawa
       # @raise [NoCollectionProvidedException] If you provided a database, no collection
       # @api private
       def simple_query_request(path, request)
-        wrapped_request(path, :put, request.merge({ :collection => collection.name }))
+        wrapped_request(path, :put, request.merge({ collection: collection.name }))
       end
 
       # Perform a wrapped request

data/lib/ashikawa-core/request_preprocessor.rb

@@ -1,5 +1,6 @@
-require "faraday"
-require "json"
+# -*- encoding : utf-8 -*-
+require 'faraday'
+require 'json'
 
 module Ashikawa
   module Core
@@ -44,6 +45,6 @@ module Ashikawa
     end
 
     Faraday.register_middleware :request,
-      :ashikawa_request => lambda { RequestPreprocessor}
+                                ashikawa_request: -> { RequestPreprocessor}
   end
 end

data/lib/ashikawa-core/response_preprocessor.rb

@@ -1,22 +1,25 @@
-require "faraday"
-require "json"
-require "ashikawa-core/exceptions/client_error"
-require "ashikawa-core/exceptions/client_error/resource_not_found"
-require "ashikawa-core/exceptions/client_error/resource_not_found/index_not_found"
-require "ashikawa-core/exceptions/client_error/resource_not_found/document_not_found"
-require "ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found"
-require "ashikawa-core/exceptions/client_error/bad_syntax"
-require "ashikawa-core/exceptions/server_error"
-require "ashikawa-core/exceptions/server_error/json_error"
+# -*- encoding : utf-8 -*-
+require 'faraday'
+require 'json'
+require 'ashikawa-core/exceptions/client_error'
+require 'ashikawa-core/exceptions/client_error/resource_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/index_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/document_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found'
+require 'ashikawa-core/exceptions/client_error/bad_syntax'
+require 'ashikawa-core/exceptions/client_error/authentication_failed'
+require 'ashikawa-core/exceptions/server_error'
+require 'ashikawa-core/exceptions/server_error/json_error'
 
 module Ashikawa
   module Core
     # Preprocessor for Faraday Requests
     class ResponsePreprocessor < Faraday::Middleware
-      ClientErrorStatuses = 400...499
-      ServerErrorStatuses = 500...599
       BadSyntaxStatus = 400
-      ResourceNotFoundErrorError = 404
+      AuthenticationFailed = 401
+      ResourceNotFoundError = 404
+      ClientErrorStatuses = 405...499
+      ServerErrorStatuses = 500...599
 
       # Create a new Response Preprocessor
       #
@@ -51,20 +54,56 @@ module Ashikawa
       # @api private
       def resource_not_found_for(env)
         raise case env[:url].path
-              when /\A\/_api\/document/ then Ashikawa::Core::DocumentNotFoundException
-              when /\A\/_api\/collection/ then Ashikawa::Core::CollectionNotFoundException
-              when /\A\/_api\/index/ then Ashikawa::Core::IndexNotFoundException
+              when %r{\A(/_db/[^/]+)?/_api/document} then Ashikawa::Core::DocumentNotFoundException
+              when %r{\A(/_db/[^/]+)?/_api/collection} then Ashikawa::Core::CollectionNotFoundException
+              when %r{\A(/_db/[^/]+)?/_api/index} then Ashikawa::Core::IndexNotFoundException
               else Ashikawa::Core::ResourceNotFound
         end
       end
 
+      # Raise a Bad Syntax Error
+      #
+      # @raise [BadSyntax]
+      # @return nil
+      # @api private
+      def bad_syntax
+        raise Ashikawa::Core::BadSyntax
+      end
+
+      # Raise an Authentication Failed Error
+      #
+      # @raise [AuthenticationFailed]
+      # @return nil
+      # @api private
+      def authentication_failed
+        raise Ashikawa::Core::AuthenticationFailed
+      end
+
+      # Raise a Client Error for a given body
+      #
+      # @raise [ClientError]
+      # @return nil
+      # @api private
+      def client_error_status_for(body)
+        raise Ashikawa::Core::ClientError, error(body)
+      end
+
+      # Raise a Server Error for a given body
+      #
+      # @raise [ServerError]
+      # @return nil
+      # @api private
+      def server_error_status_for(body)
+        raise Ashikawa::Core::ServerError, error(body)
+      end
+
       # Parse the JSON
       #
       # @param [Hash] env Environment info
       # @return [Hash] The parsed body
       # @api private
       def parse_json(env)
-        raise JSON::ParserError unless json_content_type?(env[:response_headers]["content-type"])
+        fail JSON::ParserError unless json_content_type?(env[:response_headers]['content-type'])
         JSON.parse(env[:body])
       rescue JSON::ParserError
         raise Ashikawa::Core::JsonError
@@ -76,7 +115,7 @@ module Ashikawa
       # @return [Boolean]
       # @api private
       def json_content_type?(content_type)
-        content_type == "application/json; charset=utf-8"
+        content_type == 'application/json; charset=utf-8'
       end
 
       # Handle the status code
@@ -86,10 +125,11 @@ module Ashikawa
       # @api private
       def handle_status(env)
         case env[:status]
-        when BadSyntaxStatus then raise Ashikawa::Core::BadSyntax
-        when ResourceNotFoundErrorError then raise resource_not_found_for(env)
-        when ClientErrorStatuses then raise Ashikawa::Core::ClientError, error(env[:body])
-        when ServerErrorStatuses then raise Ashikawa::Core::ServerError, error(env[:body])
+        when BadSyntaxStatus then bad_syntax
+        when AuthenticationFailed then authentication_failed
+        when ResourceNotFoundError then resource_not_found_for(env)
+        when ClientErrorStatuses then client_error_status_for(env[:body])
+        when ServerErrorStatuses then server_error_status_for(env[:body])
         end
       end
 
@@ -110,11 +150,11 @@ module Ashikawa
       # @api private
       def error(body)
         parsed_body = JSON.parse(body)
-        "#{parsed_body["errorNum"]}: #{parsed_body["errorMessage"]}"
+        "#{parsed_body['errorNum']}: #{parsed_body["errorMessage"]}"
       end
     end
 
     Faraday.register_middleware :response,
-      :ashikawa_response => lambda { ResponsePreprocessor}
+                                ashikawa_response: -> { ResponsePreprocessor}
   end
 end

data/lib/ashikawa-core/status.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Ashikawa
   module Core
     # Wrapper around the status of a collection

data/lib/ashikawa-core/transaction.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Ashikawa
   module Core
     # A JavaScript Transaction on the database
@@ -7,7 +8,7 @@ module Ashikawa
       # @return [Array<String>]
       # @api public
       # @example Get the collections that the transaction writes to
-      #   transaction.write_collections # => ["collection_1"]
+      #   transaction.write_collections # => ['collection_1']
       def write_collections
         @request_parameters[:collections][:write]
       end
@@ -17,7 +18,7 @@ module Ashikawa
       # @return [Array<String>]
       # @api public
       # @example Get the collections that the transaction reads from
-      #   transaction.read_collections # => ["collection_1"]
+      #   transaction.read_collections # => ['collection_1']
       def read_collections
         @request_parameters[:collections][:read]
       end
@@ -70,14 +71,14 @@ module Ashikawa
       # @option options [Array<String>] :read The collections you want to read from
       # @api public
       # @example Create a Transaction
-      #   transaction = Ashikawa::Core::Transaction.new(database, "function () { return 5; }",
-      #     :read => ["collection_1"]
+      #   transaction = Ashikawa::Core::Transaction.new(database, 'function () { return 5; }',
+      #     :read => ['collection_1']
       def initialize(database, action, options)
         @database = database
         @request_parameters = {
-          :action => action,
-          :collections => parse_options(options),
-          :waitForSync => false
+          action: action,
+          collections: parse_options(options),
+          waitForSync: false
         }
       end
 
@@ -90,8 +91,8 @@ module Ashikawa
       #   transaction.execute({ :a => 5 })
       def execute(action_parameters = :no_params_provided)
         @request_parameters[:params] = action_parameters unless action_parameters == :no_params_provided
-        response = @database.send_request("transaction", :post => @request_parameters)
-        response["result"]
+        response = @database.send_request('transaction', post: @request_parameters)
+        response['result']
       end
 
       private
@@ -104,8 +105,8 @@ module Ashikawa
       # @api private
       def parse_options(options)
         collections = {}
-        collections[:write] = options[:write] if options.has_key? :write
-        collections[:read] = options[:read] if options.has_key? :read
+        collections[:write] = options[:write] if options.key? :write
+        collections[:read] = options[:read] if options.key? :read
         collections
       end
     end

data/lib/ashikawa-core/version.rb

@@ -1,6 +1,7 @@
+# -*- encoding : utf-8 -*-
 module Ashikawa
   module Core
     # Current version of Ashikawa::Core
-    VERSION = "0.8.0"
+    VERSION = '0.9.0'
   end
 end

data/spec/acceptance/basic_spec.rb

@@ -1,174 +1,175 @@
+# -*- encoding : utf-8 -*-
 require 'acceptance/spec_helper'
 
-describe "Basics" do
-  describe "for an initialized database" do
-    subject {
-      Ashikawa::Core::Database.new do |config|
-        config.url = ARANGO_HOST
-      end
-    }
+describe 'Basics' do
+  describe 'for an initialized database' do
+    subject { DATABASE }
 
     after :each do
       subject.collections.each { |collection| collection.delete }
     end
 
-    it "should do what the README describes" do
-      subject["my_collection"]
-      subject["my_collection"].name = "new_name"
-      subject["new_name"].delete
+    it 'should do what the README describes' do
+      subject['my_collection']
+      subject['my_collection'].name = 'new_name'
+      subject['new_name'].delete
     end
 
-    it "should create and delete collections" do
+    it 'should create and delete collections' do
       subject.collections.each { |collection| collection.delete }
-      subject["collection_1"]
-      subject["collection_2"]
-      subject["collection_3"]
-      subject.collections.length.should == 3
-      subject["collection_3"].delete
-      subject.collections.length.should == 2
+      subject['collection_1']
+      subject['collection_2']
+      subject['collection_3']
+      expect(subject.collections.length).to eq(3)
+      subject['collection_3'].delete
+      expect(subject.collections.length).to eq(2)
     end
 
-    it "should create a non-volatile collection by default" do
-      subject.create_collection("nonvolatile_collection")
-      subject["nonvolatile_collection"].volatile?.should be_false
+    it 'should create a non-volatile collection by default' do
+      subject.create_collection('nonvolatile_collection')
+      expect(subject['nonvolatile_collection'].volatile?).to be_false
     end
 
-    it "should create a volatile collection" do
-      subject.create_collection("volatile_collection", :is_volatile => true)
-      subject["volatile_collection"].volatile?.should be_true
+    it 'should create a volatile collection' do
+      subject.create_collection('volatile_collection', is_volatile: true)
+      expect(subject['volatile_collection'].volatile?).to be_true
     end
 
-    it "should create an autoincrementing collection" do
-      subject.create_collection("autoincrement_collection", :is_volatile => true, :key_options => {
-        :type => :autoincrement,
-        :increment => 10,
-        :allow_user_keys => false
+    it 'should create an autoincrementing collection' do
+      subject.create_collection('autoincrement_collection', is_volatile: true, key_options: {
+        type: :autoincrement,
+        increment: 10,
+        allow_user_keys: false
       })
-      key_options = subject["autoincrement_collection"].key_options
+      key_options = subject['autoincrement_collection'].key_options
 
-      key_options.type.should == "autoincrement"
-      key_options.offset.should == 0
-      key_options.increment.should == 10
-      key_options.allow_user_keys.should == false
+      expect(key_options.type).to eq('autoincrement')
+      expect(key_options.offset).to eq(0)
+      expect(key_options.increment).to eq(10)
+      expect(key_options.allow_user_keys).to eq(false)
     end
 
-    it "should be possible to create an edge collection" do
-      subject.create_collection("edge_collection", :content_type => :edge)
-      subject["edge_collection"].content_type.should == :edge
+    it 'should be possible to create an edge collection' do
+      subject.create_collection('edge_collection', content_type: :edge)
+      expect(subject['edge_collection'].content_type).to eq(:edge)
     end
 
-    it "should be possible to change the name of a collection" do
-      my_collection = subject["test_collection"]
-      my_collection.name.should == "test_collection"
-      my_collection.name = "my_new_name"
-      my_collection.name.should == "my_new_name"
+    it 'should be possible to change the name of a collection' do
+      my_collection = subject['test_collection']
+      expect(my_collection.name).to eq('test_collection')
+      my_collection.name = 'my_new_name'
+      expect(my_collection.name).to eq('my_new_name')
     end
 
-    it "should be possible to find a collection by ID" do
-      my_collection = subject["test_collection"]
-      subject[my_collection.id].name.should == "test_collection"
+    it 'should be possible to find a collection by ID' do
+      my_collection = subject['test_collection']
+      expect(subject[my_collection.id].name).to eq('test_collection')
     end
 
-    it "should be possible to list all system collections" do
-      subject.system_collections.length.should > 0
+    it 'should be possible to list all system collections' do
+      expect(subject.system_collections.length).to be > 0
     end
 
-    it "should be possible to load and unload collections" do
-      my_collection = subject["test_collection"]
-      my_collection.status.loaded?.should be_true
+    it 'should be possible to load and unload collections' do
+      my_collection = subject['test_collection']
+      expect(my_collection.status.loaded?).to be_true
       my_collection.unload
       my_id = my_collection.id
-      my_collection = subject[my_id]
-      subject[my_id].status.loaded?.should be_false
-    end
-
-    it "should be possible to get figures" do
-      my_collection = subject["test_collection"]
-      my_collection.figure.alive_size.class.should == Fixnum
-      my_collection.figure.alive_count.class.should == Fixnum
-      my_collection.figure.dead_size.class.should == Fixnum
-      my_collection.figure.dead_count.class.should == Fixnum
-      my_collection.figure.dead_deletion.class.should == Fixnum
-      my_collection.figure.datafiles_count.class.should == Fixnum
-      my_collection.figure.datafiles_file_size.class.should == Fixnum
-      my_collection.figure.journals_count.class.should == Fixnum
-      my_collection.figure.journals_file_size.class.should == Fixnum
-      my_collection.figure.shapes_count.class.should == Fixnum
-    end
-
-    it "should change and receive information about waiting for sync" do
-      my_collection = subject["my_collection"]
+      subject[my_id]
+      expect(subject[my_id].status.loaded?).to be_false
+    end
+
+    it 'should be possible to get figures' do
+      my_collection = subject['test_collection']
+      expect(my_collection.figure.alive_size.class).to eq(Fixnum)
+      expect(my_collection.figure.alive_count.class).to eq(Fixnum)
+      expect(my_collection.figure.dead_size.class).to eq(Fixnum)
+      expect(my_collection.figure.dead_count.class).to eq(Fixnum)
+      expect(my_collection.figure.dead_deletion.class).to eq(Fixnum)
+      expect(my_collection.figure.datafiles_count.class).to eq(Fixnum)
+      expect(my_collection.figure.datafiles_file_size.class).to eq(Fixnum)
+      expect(my_collection.figure.journals_count.class).to eq(Fixnum)
+      expect(my_collection.figure.journals_file_size.class).to eq(Fixnum)
+      expect(my_collection.figure.shapes_count.class).to eq(Fixnum)
+    end
+
+    it 'should change and receive information about waiting for sync' do
+      my_collection = subject['my_collection']
       my_collection.wait_for_sync = false
-      my_collection.wait_for_sync?.should be_false
+      expect(my_collection.wait_for_sync?).to be_false
       my_collection.wait_for_sync = true
-      my_collection.wait_for_sync?.should be_true
+      expect(my_collection.wait_for_sync?).to be_true
     end
 
-    it "should be possible to get information about the number of documents" do
-      empty_collection = subject["empty_collection"]
-      empty_collection.length.should == 0
-      empty_collection.create_document({ :name => "testname", :age => 27})
-      empty_collection.create_document({ :name => "anderer name", :age => 28})
-      empty_collection.length.should == 2
+    it 'should be possible to get information about the number of documents' do
+      empty_collection = subject['empty_collection']
+      expect(empty_collection.length).to eq(0)
+      empty_collection.create_document(name: 'testname', age: 27)
+      empty_collection.create_document(name: 'anderer name', age: 28)
+      expect(empty_collection.length).to eq(2)
       empty_collection.truncate!
-      empty_collection.length.should == 0
+      expect(empty_collection.length).to eq(0)
     end
 
-    it "should be possible to update the attributes of a document" do
-      collection = subject["documenttests"]
+    it 'should be possible to update the attributes of a document' do
+      collection = subject['documenttests']
 
-      document = collection.create_document(:name => "The Dude", :bowling => true)
+      document = collection.create_document(name: 'The Dude', bowling: true)
       document_key = document.key
-      document["name"] = "Other Dude"
+      document['name'] = 'Other Dude'
       document.save
 
-      collection.fetch(document_key)["name"].should == "Other Dude"
+      expect(collection.fetch(document_key)['name']).to eq('Other Dude')
     end
 
-    it "should be possible to access and create documents from a collection" do
-      collection = subject["documenttests"]
+    it 'should be possible to access and create documents from a collection' do
+      collection = subject['documenttests']
 
-      document = collection.create_document(:name => "The Dude", :bowling => true)
+      document = collection.create_document(name: 'The Dude', bowling: true)
       document_key = document.key
-      collection.fetch(document_key)["name"].should == "The Dude"
+      expect(collection.fetch(document_key)['name']).to eq('The Dude')
 
-      collection.replace(document_key, { :name => "Other Dude", :bowling => true })
-      collection.fetch(document_key)["name"].should == "Other Dude"
+      collection.replace(document_key, { name: 'Other Dude', bowling: true })
+      expect(collection.fetch(document_key)['name']).to eq('Other Dude')
     end
 
-    it "should be possible to create an edge between two documents" do
-      nodes = subject.create_collection("nodecollection")
-      edges = subject.create_collection("edgecollection", :content_type => :edge)
+    it 'should be possible to create an edge between two documents' do
+      nodes = subject.create_collection('nodecollection')
+      edges = subject.create_collection('edgecollection', content_type: :edge)
 
-      a = nodes.create_document({:name => "a"})
-      b = nodes.create_document({:name => "b"})
-      e = edges.create_edge(a, b, {:name => "fance_edge"})
+      a = nodes.create_document(name: 'a')
+      b = nodes.create_document(name: 'b')
+      e = edges.create_edge(a, b, { name: 'fance_edge' })
 
       e = edges.fetch(e.key)
-      e.from_id.should == a.id
-      e.to_id.should == b.id
+      expect(e.from_id).to eq(a.id)
+      expect(e.to_id).to eq(b.id)
+    end
+
+    it 'should be possible to get a single attribute by AQL query' do
+      collection = subject['documenttests']
+      collection.truncate!
+      collection.create_document(name: 'The Dude', bowling: true)
+
+      expect(subject.query.execute('FOR doc IN documenttests RETURN doc.name').to_a.first). to eq 'The Dude'
     end
   end
 
-  describe "for a created document" do
-    let(:database) {
-      Ashikawa::Core::Database.new do |config|
-        config.url = ARANGO_HOST
-      end
-    }
-    let(:collection) { database["documenttests"] }
-    subject { collection.create_document(:name => "The Dude") }
+  describe 'for a created document' do
+    let(:database) { DATABASE }
+    let(:collection) { database['documenttests'] }
+    subject { collection.create_document(name: 'The Dude') }
     let(:document_key) { subject.key }
 
-    it "should be possible to manipulate documents and save them" do
-      subject["name"] = "Jeffrey Lebowski"
-      subject["name"].should == "Jeffrey Lebowski"
-      collection.fetch(document_key)["name"].should == "The Dude"
+    it 'should be possible to manipulate documents and save them' do
+      subject['name'] = 'Jeffrey Lebowski'
+      expect(subject['name']).to eq('Jeffrey Lebowski')
+      expect(collection.fetch(document_key)['name']).to eq('The Dude')
       subject.save
-      collection.fetch(document_key)["name"].should == "Jeffrey Lebowski"
+      expect(collection.fetch(document_key)['name']).to eq('Jeffrey Lebowski')
     end
 
-    it "should be possible to delete a document" do
+    it 'should be possible to delete a document' do
       collection.fetch(document_key).delete
       expect {
         collection.fetch(document_key)
@@ -181,14 +182,14 @@ describe "Basics" do
       }.to raise_exception Ashikawa::Core::DocumentNotFoundException
     end
 
-    it "should be possible to refresh a document" do
+    it 'should be possible to refresh a document' do
       changed_document = collection.fetch(document_key)
-      changed_document["name"] = "New Name"
+      changed_document['name'] = 'New Name'
       changed_document.save
 
-      subject["name"].should == "The Dude"
+      expect(subject['name']).to eq('The Dude')
       subject.refresh!
-      subject["name"].should == "New Name"
+      expect(subject['name']).to eq('New Name')
     end
   end
 end