ashikawa-core 0.11.0 → 0.12.0

data/lib/ashikawa-core/faraday_factory.rb

@@ -0,0 +1,89 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'ashikawa-core/minimal_logger'
+
+module Ashikawa
+  module Core
+    # Create Faraday objects
+    class FaradayFactory
+      # Defaults for the options of create connection
+      DEFAULTS = {
+        additional_request_middlewares: [],
+        additional_response_middlewares: [],
+        additional_middlewares: [],
+        adapter: Faraday.default_adapter
+      }
+
+      # Request middlewares that will be prepended
+      DEFAULT_REQUEST_MIDDLEWARES = [:json]
+
+      # Response middlewares that will be prepended
+      DEFAULT_RESPONSE_MIDDLEWARES = [:error_response, :json]
+
+      # Create a Faraday object
+      #
+      # @param [String] url The complete URL of the ArangoDB instance
+      # @option options [Object] adapter The Faraday adapter you want to use. Defaults to Default Adapter
+      # @option options [Object] logger The logger you want to use. Defaults to no logger.
+      # @option options [Array] additional_request_middlewares Additional request middlewares
+      # @option options [Array] additional_response_middlewares Additional response middlewares
+      # @option options [Array] additional_middlewares Additional middlewares
+      # @api private
+      # @example Create a FaradayObject with the given configuration
+      #  faraday = FaradayFactory.new('http://localhost:8529/_db/mydb/_api', logger: my_logger)
+      def self.create_connection(url, options)
+        options = DEFAULTS.merge(options)
+        faraday = new(
+          options.fetch(:adapter),
+          options.fetch(:additional_request_middlewares),
+          options.fetch(:additional_response_middlewares),
+          options.fetch(:additional_middlewares)
+        )
+        faraday.debug_headers = options.fetch(:debug_headers) { false }
+        faraday.logger = options.fetch(:logger) if options.key?(:logger)
+        faraday.faraday_for(url)
+      end
+
+      # Debug headers to be used by Faraday
+      #
+      # @api private
+      attr_accessor :debug_headers
+
+      # Create a new Faraday Factory with additional middlewares
+      #
+      # @param [Adapter] adapter The adapter to use
+      # @param [Array] additional_request_middlewares Additional request middlewares
+      # @param [Array] additional_response_middlewares Additional response middlewares
+      # @param [Array] additional_middlewares Additional middlewares
+      # @api private
+      def initialize(adapter, additional_request_middlewares, additional_response_middlewares, additional_middlewares)
+        @adapter = adapter
+        @request_middlewares = DEFAULT_REQUEST_MIDDLEWARES + additional_request_middlewares
+        @response_middlewares = DEFAULT_RESPONSE_MIDDLEWARES + additional_response_middlewares
+        @additional_middlewares = additional_middlewares
+      end
+
+      # Logger to be used by Faraday
+      #
+      # @param [Logger] logger The logger you want to use
+      # @api private
+      def logger=(logger)
+        @response_middlewares << [:minimal_logger, logger, debug_headers: debug_headers]
+      end
+
+      # Create the Faraday for the given URL
+      #
+      # @param [String] url
+      # @return [Faraday]
+      # @api private
+      def faraday_for(url)
+        Faraday.new(url) do |connection|
+          @request_middlewares.each { |middleware| connection.request(*middleware) }
+          @response_middlewares.each { |middleware| connection.response(*middleware) }
+          @additional_middlewares.each { |middleware| connection.use(*middleware) }
+          connection.adapter(*@adapter)
+        end
+      end
+    end
+  end
+end

data/lib/ashikawa-core/minimal_logger.rb

@@ -0,0 +1,64 @@
+# -*- encoding : utf-8 -*-
+
+require 'faraday'
+require 'faraday_middleware'
+
+module Ashikawa
+  module Core
+    # A more minimal logger as replacement for the very chatty Faraday logger
+    class MinimalLogger < ::Faraday::Response::Middleware
+      # The logger to be used
+      #
+      # @api public
+      # @return [Logger] The configured logger
+      attr_reader :logger
+
+      # Should HTTP headers be logged
+      #
+      # @api public
+      # @return [Boolean] If the headers will be logged or not. Defaults to `false`
+      attr_reader :debug_headers
+
+      # Initialize the middleware
+      #
+      # @api public
+      # @param [Faraday::Middleware] app The middleware to nest this one in
+      # @param [Logger] logger The logger to be used
+      # @option options [Boolean] :debug_headers Should the headers be logged. Defaults to `false`
+      def initialize(app, logger, options = {})
+        super(app)
+        @logger        = logger
+        @debug_headers = options.fetch(:debug_headers) { false }
+      end
+
+      # Calls the this middleware and passes on to `super`
+      #
+      # @api public
+      # @param [Faraday::Env] env The current env object
+      def call(env)
+        logger.debug('request') { "#{env.method.upcase} #{env.url}#{dump_headers(env.request_headers)}" }
+        super
+      end
+
+      # The callback when the request was completed
+      #
+      # @api public
+      # @param [Faraday::Env] env The current env object
+      def on_complete(env)
+        logger.debug('response') { "#{env.method.upcase} #{env.url} #{env.status}#{dump_headers(env.response_headers)}" }
+      end
+
+      private
+
+      # Creates a one-liner out of headers
+      #
+      # @api private
+      # @params [Hash] headers A headers hash
+      def dump_headers(headers)
+        " #{headers.map { |field_name, field_value| "#{field_name}: #{field_value.inspect}" }.join(' ')}" if debug_headers
+      end
+    end
+
+    ::Faraday::Response.register_middleware minimal_logger: -> { MinimalLogger }
+  end
+end

data/lib/ashikawa-core/version.rb

@@ -2,6 +2,6 @@
 module Ashikawa
   module Core
     # Current version of Ashikawa::Core
-    VERSION = '0.11.0'
+    VERSION = '0.12.0'
   end
 end

data/spec/acceptance/basic_spec.rb

@@ -18,7 +18,7 @@ describe 'Basics' do
     it 'should have one more database if a database with random name is created' do
       expect {
         database_with_random_name.create
-      }.to change { DATABASE.all_databases.length }.by(1)
+      }.to change { SYSTEM_DATABASE.all_databases.length }.by(1)
     end
 
     it 'should create and delete collections' do
@@ -197,7 +197,7 @@ describe 'Basics' do
       changed_document.save
 
       expect(subject['name']).to eq('The Dude')
-      subject.refresh!
+      subject.refresh
       expect(subject['name']).to eq('New Name')
     end
   end

data/spec/acceptance/index_spec.rb

@@ -6,6 +6,11 @@ describe 'Indices' do
   subject { database['documenttest'] }
   let(:index) { subject.add_index(:skiplist, on: [:identifier]) }
 
+  it 'should accept a single attribute' do
+    single_attr_index = subject.add_index(:hash, on: :identifier)
+    expect(single_attr_index.on).to eq [:identifier]
+  end
+
   it 'should be possible to set indices' do
     index.delete
 

data/spec/acceptance/spec_helper.rb

@@ -2,44 +2,59 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $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
-
 require 'ashikawa-core'
+require 'logging'
 
 PORT = ENV.fetch('ARANGODB_PORT', 8529)
 USERNAME = ENV.fetch('ARANGODB_USERNAME', 'root')
 PASSWORD = ENV.fetch('ARANGODB_PASSWORD', '')
 AUTHENTIFICATION_ENABLED = ENV['ARANGODB_DISABLE_AUTHENTIFICATION'] == 'false'
 
-# System Database for general use in specs
-DATABASE = Ashikawa::Core::Database.new do |config|
-  config.url = "http://localhost:#{PORT}"
+def database_with_name(database_name = "_system")
+  Ashikawa::Core::Database.new do |config|
+    config.url    = "http://localhost:#{PORT}"
+    # Log to a file
+    logger = Logging.logger['ashikawa-logger']
+    logger.add_appenders(
+      Logging.appenders.file('log/acceptance.log')
+    )
+    logger.level = :debug
+
+    config.logger        = logger
+    config.database_name = database_name
 
-  if AUTHENTIFICATION_ENABLED
-    config.username = USERNAME
-    config.password = PASSWORD
+    if AUTHENTIFICATION_ENABLED
+      config.username = USERNAME
+      config.password = PASSWORD
+    end
   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]}"
+  database_with_name("a#{rand.to_s[2, 10]}")
+end
 
-  Ashikawa::Core::Database.new do |config|
-    config.url = "http://localhost:#{PORT}/_db/#{name}"
+# The database for the general specs
+DATABASE        = database_with_name('ashikawa-acceptance-specs')
+# Some specs require access to the _system database
+SYSTEM_DATABASE = database_with_name('_system')
 
-    if AUTHENTIFICATION_ENABLED
-      config.username = USERNAME
-      config.password = PASSWORD
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before(:each) do
+    begin
+      DATABASE.create
+    rescue Ashikawa::Core::ClientError
     end
+    DATABASE.truncate
   end
 end

data/spec/unit/collection_spec.rb

@@ -1,9 +1,10 @@
 # -*- encoding : utf-8 -*-
 require 'unit/spec_helper'
 require 'ashikawa-core/collection'
+require 'ashikawa-core/database'
 
 describe Ashikawa::Core::Collection do
-  let(:database) { double }
+  let(:database) { instance_double('Ashikawa::Core::Database') }
   let(:raw_document_collection) do
     {
       'id' => '60768679',
@@ -25,11 +26,10 @@ describe Ashikawa::Core::Collection do
   describe 'an initialized collection' do
     subject { Ashikawa::Core::Collection.new(database, raw_document_collection) }
 
-    let(:raw_key_options) { double }
-    let(:key_options) { double }
-    let(:response) { double }
-    let(:value) { double }
-    let(:figure) { double }
+    let(:key_options) { instance_double('Ashikawa::Core::KeyOptions') }
+    let(:response) { instance_double('Hash') }
+    let(:value) { double('Value') }
+    let(:figure) { instance_double('Ashikawa::Core::Figure') }
 
     its(:name) { should eq('example_1') }
     its(:id) { should eq('60768679') }
@@ -164,7 +164,7 @@ describe Ashikawa::Core::Collection do
     end
 
     describe 'indexes' do
-      let(:index_response) { double }
+      let(:index_response) { instance_double('Hash') }
 
       it 'should add a new index' do
         expect(database).to receive(:send_request)
@@ -190,6 +190,18 @@ describe Ashikawa::Core::Collection do
         subject.add_index(:hash, on: [:a, :b], unique: true)
       end
 
+      it 'should accept a single attribute for indexing' do
+        expect(database).to receive(:send_request)
+          .with('index?collection=60768679', post: {
+            'type' => 'hash', 'fields' => %w(a), 'unique' => true
+          })
+          .and_return(index_response)
+        expect(Ashikawa::Core::Index).to receive(:new)
+          .with(subject, index_response)
+
+        subject.add_index(:hash, on: :a, unique: true)
+      end
+
       it 'should get an index by ID' do
         allow(database).to receive(:send_request)
           .with('index/example_1/168054969')
@@ -201,18 +213,9 @@ describe Ashikawa::Core::Collection do
       end
 
       it 'should get all indexes' do
-        multi_index_response = double
-        allow(multi_index_response).to receive(:map)
-          .and_yield(index_response)
-
-        cursor = double
-        allow(cursor).to receive(:[])
-          .with('indexes')
-          .and_return(multi_index_response)
-
         allow(database).to receive(:send_request)
           .with('index?collection=60768679')
-          .and_return(cursor)
+          .and_return('indexes' => [index_response])
 
         expect(Ashikawa::Core::Index).to receive(:new)
           .with(subject, index_response)
@@ -223,12 +226,12 @@ describe Ashikawa::Core::Collection do
   end
 
   describe 'an initialized document collection' do
-    subject { Ashikawa::Core::Collection.new database, raw_document_collection }
+    subject { Ashikawa::Core::Collection.new(database, raw_document_collection) }
 
-    let(:document) { double }
-    let(:response) { double }
-    let(:raw_document) { double }
-    let(:value) { double }
+    let(:document) { instance_double('Ashikawa::Core::Document') }
+    let(:response) { double('Response') }
+    let(:raw_document) { double('RawDocument') }
+    let(:value) { double('Value') }
 
     its(:content_type) { should be(:document) }
 
@@ -238,7 +241,6 @@ describe Ashikawa::Core::Collection do
       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.fetch(key)
@@ -247,7 +249,6 @@ describe Ashikawa::Core::Collection do
       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]
@@ -267,7 +268,6 @@ describe Ashikawa::Core::Collection do
       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.fetch(id)
@@ -276,7 +276,6 @@ describe Ashikawa::Core::Collection do
       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]
@@ -302,8 +301,10 @@ describe Ashikawa::Core::Collection do
     end
 
     it 'should not create a new edge' do
+      from = instance_double('Ashikawa::Core::Document')
+      to = instance_double('Ashikawa::Core::Document')
       expect do
-        subject.create_edge(double, double, { 'quote' => "D'ya have to use s'many cuss words?" })
+        subject.create_edge(from, to, { 'quote' => "D'ya have to use s'many cuss words?" })
       end.to raise_exception(RuntimeError, "Can't create an edge in a document collection")
     end
   end
@@ -311,16 +312,15 @@ describe Ashikawa::Core::Collection do
   describe 'an initialized edge collection' do
     subject { Ashikawa::Core::Collection.new database, raw_edge_collection }
 
-    let(:document) { double }
-    let(:response) { double }
-    let(:raw_document) { double }
+    let(:document) { instance_double('Ashikawa::Core::Document') }
+    let(:response) { double('Response') }
+    let(:raw_document) { double('RawDocument') }
 
     its(:content_type) { should be(:edge) }
 
     it 'should receive an edge by ID via fetch' do
       expect(database).to receive(:send_request)
         .with('edge/60768679/333', {})
-        .and_return(double)
       expect(Ashikawa::Core::Edge).to receive(:new)
 
       subject.fetch(333)
@@ -329,7 +329,6 @@ describe Ashikawa::Core::Collection do
     it 'should receive an edge by ID via []' do
       expect(database).to receive(:send_request)
         .with('edge/60768679/333', {})
-        .and_return(double)
       expect(Ashikawa::Core::Edge).to receive(:new)
 
       subject[333]
@@ -350,7 +349,9 @@ describe Ashikawa::Core::Collection do
         .with(database, response, raw_document)
         .and_return(document)
 
-      subject.create_edge(double(id: '1'), double(id: '2'), raw_document)
+      from = instance_double('Ashikawa::Core::Document', id: 1)
+      to = instance_double('Ashikawa::Core::Document', id: 2)
+      subject.create_edge(from, to, raw_document)
     end
 
     it 'should not create a new document' do