acfs 1.3.3 → 1.6.0

data/lib/acfs/service/middleware/stack.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Acfs
+  class Service
+    module Middleware
+      class Stack
+        include Enumerable
+
+        MUTEX = Mutex.new
+        IDENTITY = ->(i) { i }
+
+        attr_reader :middlewares
+
+        def initialize
+          @middlewares = []
+        end
+
+        def call(request)
+          build! unless @app
+
+          @app.call request
+        end
+
+        def build!
+          return if @app
+
+          MUTEX.synchronize do
+            return if @app
+
+            @app = build
+          end
+        end
+
+        def build(app = IDENTITY)
+          middlewares.reverse.inject(app) do |next_middleware, current_middleware|
+            klass, args, block = current_middleware
+            args ||= []
+
+            if klass.is_a?(Class)
+              klass.new(next_middleware, *args, &block)
+            elsif klass.respond_to?(:call)
+              lambda do |env|
+                next_middleware.call(klass.call(env, *args))
+              end
+            else
+              raise "Invalid middleware, doesn't respond to `call`: #{klass.inspect}"
+            end
+          end
+        end
+
+        def insert(index, klass, *args, &block)
+          middlewares.insert(index, [klass, args, block])
+        end
+
+        def each
+          middlewares.each {|x| yield x.first }
+        end
+
+        def clear
+          middlewares.clear
+        end
+      end
+    end
+  end
+end

data/lib/acfs/singleton_resource.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Acfs
+  # Acfs SingletonResources
+  #
+  # Usage explanation:
+  #   Single.find      => sends GET    request to http://service:port/single
+  #   my_single.save   => sends POST   request to http://service:port/single
+  #                                    if my_single is a new object
+  #                    or sends PUT    request to http://service:port/single
+  #                                    if my_single has been requested before
+  #   my_single.delete => sends DELETE request to http://service:port/single
+  #
+  # SingletonResources do not support the Resource method :all, since
+  # always only a single instance of the resource is being returned
+  #
+  class SingletonResource < Acfs::Resource
+    # @api public
+    #
+    # Destroy resource by sending a DELETE request.
+    # Will raise an error in case something goes wrong.
+    #
+    # Deleting a resource is a synchronous operation.
+    #
+    # @raise [Acfs::ErroneousResponse]
+    #   If remote service respond with not successful response.
+    # @return [undefined]
+    # @see #delete
+    #
+    def delete!(**opts)
+      opts[:params] ||= {}
+
+      operation(:delete, **opts) do |data|
+        update_with data
+        freeze
+      end
+    end
+
+    # @api private
+    def need_primary_key?
+      false
+    end
+
+    class << self
+      # @api public
+      #
+      # @overload find(id, opts = {})
+      #   Find a singleton resource, optionally with params.
+      #
+      #   @example
+      #     single = Singleton.find # Will query `http://base.url/singletons/`
+      #
+      #   @param [ Hash ] opts Additional options.
+      #   @option opts [ Hash ] :params Additional parameters added to request.
+      #
+      #   @yield [ resource ] Callback block to be executed after
+      #     resource was fetched successfully.
+      #   @yieldparam resource [ self ] Fetched resources.
+      #
+      #   @return [ self ] Resource object.
+      #
+      def find(*attrs, &block)
+        find_single nil, params: attrs.extract_options!, &block
+      end
+
+      # @api public
+      #
+      # Undefined, raises NoMethodError.
+      # A singleton always only returns one object, therefore the
+      # methods :all and :where are not defined.
+      # :find_by is not defined on singletons, use :find instead
+      #
+      def all
+        raise ::Acfs::UnsupportedOperation.new
+      end
+      alias find_by all
+      alias find_by! all
+
+      # @api private
+      def location_default_path(_, path)
+        path
+      end
+    end
+  end
+end

data/lib/acfs/stub.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'rack/utils'
+
+module Acfs
+  # Global handler for stubbing resources.
+  #
+  class Stub
+    ACTIONS = %i[read create update delete list].freeze
+
+    attr_reader :opts
+
+    def initialize(opts)
+      @opts = opts
+
+      @opts[:with].stringify_keys! if @opts[:with].is_a? Hash
+      @opts[:return].stringify_keys! if @opts[:return].is_a? Hash
+
+      if @opts[:return].is_a?(Array) # rubocop:disable Style/GuardClause
+        @opts[:return].map! {|h| h.stringify_keys! if h.is_a? Hash }
+      end
+    end
+
+    def accept?(op)
+      return opts[:with].call(op) if opts[:with].respond_to?(:call)
+
+      params = op.full_params.stringify_keys
+      data   = op.data.stringify_keys
+      with   = opts[:with]
+
+      return true if with.nil?
+
+      case opts.fetch(:match, :inclusion)
+        when :legacy
+          return true if with.empty? && params.empty? && data.empty?
+          if with.reject {|_, v| v.nil? } == params.reject {|_, v| v.nil? }
+            return true
+          end
+          if with.reject {|_, v| v.nil? } == data.reject {|_, v| v.nil? }
+            return true
+          end
+
+          false
+        when :inclusion
+          with.each_pair.all? do |k, v|
+            (params.key?(k) && params[k] == v) || (data.key?(k) && data[k] == v)
+          end
+      end
+    end
+
+    def calls
+      @calls ||= []
+    end
+
+    def called?(count = nil)
+      count = count.count if count.respond_to?(:count)
+
+      count.nil? ? calls.any? : calls.size == count
+    end
+
+    def call(op)
+      calls << op
+
+      err  = opts[:raise]
+      data = opts[:return]
+
+      if err
+        raise_error op, err, opts[:return]
+      elsif data
+        data = data.call(op) if data.respond_to?(:call)
+
+        response = Acfs::Response.new op.request,
+          headers: opts[:headers] || {},
+          status: opts[:status] || 200,
+          data: data || {}
+        op.call data, response
+      else
+        raise ArgumentError.new 'Unsupported stub.'
+      end
+    end
+
+    private
+
+    def raise_error(op, name, data)
+      raise name if name.is_a? Class
+
+      data.stringify_keys! if data.respond_to?(:stringify_keys!)
+
+      op.handle_failure ::Acfs::Response.new(
+        op.request,
+        status: Rack::Utils.status_code(name),
+        data: data
+      )
+    end
+
+    class << self
+      # Stub a resource with given handler block. An already created handler
+      # for same resource class will be overridden.
+      #
+      def resource(klass, action, opts = {}, &_block)
+        action = action.to_sym
+        unless ACTIONS.include? action
+          raise ArgumentError.new "Unknown action `#{action}`."
+        end
+
+        Stub.new(opts).tap do |stub|
+          stubs[klass]         ||= {}
+          stubs[klass][action] ||= []
+          stubs[klass][action] << stub
+        end
+      end
+
+      def allow_requests=(allow)
+        @allow_requests = allow ? true : false
+      end
+
+      def allow_requests?
+        @allow_requests ||= false
+      end
+
+      def enabled?
+        @enabled ||= false
+      end
+
+      def enable
+        @enabled = true
+      end
+
+      def disable
+        @enabled = false
+      end
+
+      # Clear all stubs.
+      #
+      def clear(klass = nil)
+        klass.nil? ? stubs.clear : stubs[klass].try(:clear)
+      end
+
+      def stubs
+        @stubs ||= {}
+      end
+
+      def stub_for(op)
+        return false unless (classes = stubs[op.resource])
+        return false unless (stubs = classes[op.action])
+
+        accepted_stubs = stubs.select {|stub| stub.accept? op }
+
+        if accepted_stubs.size > 1
+          raise AmbiguousStubError.new stubs: accepted_stubs, operation: op
+        end
+
+        accepted_stubs.first
+      end
+
+      def stubbed(op)
+        stub = stub_for op
+        unless stub
+          return false if allow_requests?
+
+          raise RealRequestsNotAllowedError.new <<~ERROR
+            No stub found for `#{op.action}' on `#{op.resource.name}' \
+            with params `#{op.full_params.inspect}', data `#{op.data.inspect}' \
+            and id `#{op.id}'.
+
+            Available stubs:
+            #{pretty_print}
+          ERROR
+        end
+
+        stub.call op
+        true
+      end
+
+      private
+
+      def pretty_print
+        out = ''
+        stubs.each do |klass, actions|
+          out << '  ' << klass.name << ":\n"
+          actions.each do |action, stubs|
+            stubs.each do |stub|
+              out << "    #{action}"
+              out << " with #{stub.opts[:with].inspect}" if stub.opts[:with]
+              if stub.opts[:return]
+                out << " and return #{stub.opts[:return].inspect}"
+              end
+              if stub.opts[:raise]
+                out << " and raise #{stub.opts[:raise].inspect}"
+              end
+              out << "\n"
+            end
+          end
+        end
+        out
+      end
+    end
+  end
+end

data/lib/acfs/util.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Acfs
+  module Util
+    # TODO: Merge wit features in v1.0
+    module Callbacks
+      def __callbacks__
+        @__callbacks__ ||= []
+      end
+
+      def __invoke__
+        __callbacks__.each {|c| c.call self }
+      end
+    end
+
+    # TODO: Replace delegator with promise or future for the long run.
+    class ResourceDelegator < SimpleDelegator
+      delegate :class, :is_a?, :kind_of?, :nil?, to: :__getobj__
+      include Callbacks
+    end
+  end
+end

data/lib/acfs/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Acfs
+  module VERSION
+    MAJOR = 1
+    MINOR = 6
+    PATCH = 0
+    STAGE = nil
+
+    STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.')
+
+    def self.to_s
+      STRING
+    end
+  end
+end

data/lib/acfs/yard.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# YARD macros
+
+# @!macro [new] experimental
+#   @api experimental
+#   @note This class or method is *experimental*. It may change without further notice or major version bump.

data/spec/acfs/adapter/typhoeus_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Adapter::Typhoeus do
+  let(:adapter) { described_class.new }
+
+  before do
+    stub_request(:any, 'http://example.org').to_return status: 200
+  end
+
+  it 'raises an error' do
+    request1 = Acfs::Request.new 'http://example.org' do |_rsp|
+      raise '404-1'
+    end
+    request2 = Acfs::Request.new 'http://example.org' do |_rsp|
+      raise '404-2'
+    end
+    adapter.queue request1
+    adapter.queue request2
+
+    expect { adapter.start }.to raise_error(/404-[12]/)
+    expect { adapter.start }.to_not raise_error
+  end
+
+  it 'raises timeout' do
+    stub_request(:any, 'http://example.org').to_timeout
+
+    request = Acfs::Request.new 'http://example.org'
+    adapter.queue request
+
+    expect { adapter.run(request) }.to raise_error(::Acfs::TimeoutError) do |err|
+      expect(err.message).to eq 'Timeout reached: GET http://example.org'
+    end
+  end
+
+  it 'raises connection errors' do
+    WebMock.allow_net_connect!
+
+    request = Acfs::Request.new 'http://should-never-exists.example.org'
+    adapter.queue request
+
+    expect { adapter.run(request) }.to raise_error(::Acfs::RequestError) do |err|
+      expect(err.message).to eq 'Couldn\'t resolve host name: GET http://should-never-exists.example.org'
+    end
+  end
+
+  it 'passes arguments to typhoeus hydra' do
+    value = {key: 1, key2: 2}
+
+    expect(::Typhoeus::Hydra).to receive(:new).with(value)
+
+    described_class.new(**value).send :hydra
+  end
+end