fixturama 0.1.0 → 0.5.0

data/lib/fixturama/changes/chain.rb

@@ -0,0 +1,64 @@
+class Fixturama::Changes
+  #
+  # @private
+  # Stub a chain of messages
+  #
+  class Chain < Base
+    require_relative "chain/raise_action"
+    require_relative "chain/return_action"
+    require_relative "chain/actions"
+    require_relative "chain/arguments"
+
+    def key
+      @key ||= ["chain", @receiver.name, *@messages].join(".")
+    end
+
+    def merge(other)
+      return self unless other.instance_of?(self.class) && other.key == key
+
+      tap { @arguments = (other.arguments | arguments).sort_by(&:order) }
+    end
+
+    def call(example)
+      call_action = example.send(:receive_message_chain, *@messages) do |*real|
+        action = arguments.find { |expected| expected.match?(*real) }
+        action ? action.call : raise("Unexpected arguments: #{real}")
+      end
+
+      example.send(:allow, @receiver).to call_action
+    end
+
+    protected
+
+    attr_reader :arguments
+
+    private
+
+    def initialize(**options)
+      @receiver  = receiver_from(options)
+      @messages  = messages_from(options)
+      @arguments = [Arguments.new(options)]
+    end
+
+    def receiver_from(options)
+      case options.slice(:class, :object).keys
+      when %i[class]  then Kernel.const_get(options[:class])
+      when %i[object] then Object.send(:eval, options[:object])
+      else raise
+      end
+    rescue StandardError => err
+      raise Fixturama::FixtureError.new("a stabbed object", options, err)
+    end
+
+    def messages_from(options)
+      case value = options[:chain]
+      when Array  then value.map(&:to_sym)
+      when String then [value.to_sym]
+      when Symbol then value
+      else raise
+      end
+    rescue StandardError => err
+      raise Fixturama::FixtureError.new("a messages chain", options, err)
+    end
+  end
+end

data/lib/fixturama/changes/chain/actions.rb

@@ -0,0 +1,31 @@
+class Fixturama::Changes::Chain
+  #
+  # @private
+  # Keep arguments of a message chain along with the corresponding actions
+  #
+  class Actions
+    def next
+      @list.count > 1 ? @list.pop : @list.first
+    end
+
+    private
+
+    def initialize(*list)
+      list = [{ return: nil }] if list.empty?
+
+      @list = list.flatten.reverse.flat_map do |item|
+        action = build(item)
+        [action] * action.repeat
+      end
+    end
+
+    def build(item)
+      item = Hash(item).transform_keys(&:to_sym)
+      case item.slice(:return, :raise).keys
+      when %i[return] then ReturnAction.new(item)
+      when %i[raise]  then RaiseAction.new(item)
+      else raise Fixturama::FixtureError.new("an action", item)
+      end
+    end
+  end
+end

data/lib/fixturama/changes/chain/arguments.rb

@@ -0,0 +1,59 @@
+class Fixturama::Changes::Chain
+  #
+  # @private
+  # Keep a set of arguments along with the corresponding actions to be done
+  #
+  class Arguments
+    # @return [Array<Object>] the collection of arguments
+    attr_reader :arguments
+
+    # Order of comparing this set of arguments with the actual ones
+    # @return [Integer]
+    def order
+      -arguments.count
+    end
+
+    # Compare definitions by sets of arguments
+    # @param [Fixturama::Changes::Chain::Arguments] other
+    # @return [Boolean]
+    def ==(other)
+      other.arguments == arguments
+    end
+
+    # If actual arguments are covered by the current ones
+    def match?(*args, **opts)
+      return false if arguments.count > args.count + 1
+
+      arguments.first(args.count).zip(args).each do |(expected, actual)|
+        return false unless actual == expected
+      end
+
+      if arguments.count > args.count
+        Hash(arguments.last).transform_keys(&:to_sym).each do |k, v|
+          return false unless opts[k] == v
+        end
+      end
+
+      true
+    end
+
+    # Call the corresponding action if actual arguments are matched
+    def call
+      @actions.next.call
+    end
+
+    private
+
+    def initialize(options)
+      @arguments = extract(options, :arguments)
+      @actions = Actions.new(*extract(options, :actions))
+    end
+
+    def extract(options, key)
+      return [] unless options.key?(key)
+
+      source = options[key]
+      source.is_a?(Array) ? source : [source]
+    end
+  end
+end

data/lib/fixturama/changes/chain/raise_action.rb

@@ -0,0 +1,43 @@
+class Fixturama::Changes::Chain
+  #
+  # @private
+  # Raise a specified exception as a result of stubbing
+  #
+  class RaiseAction
+    attr_reader :repeat
+
+    def call
+      raise @error
+    end
+
+    private
+
+    def initialize(**options)
+      @error  = error_from options
+      @repeat = repeat_from options
+    rescue StandardError => err
+      raise Fixturama::FixtureError.new("an exception class", options, err)
+    end
+
+    def error_from(options)
+      klass  = klass_from(options)
+      params = options[:arguments]
+      params.is_a?(Array) ? klass.new(*params) : klass
+    end
+
+    def klass_from(options)
+      klass = case value = options[:raise]
+              when NilClass, TrueClass, "true" then StandardError
+              when Class then value
+      else Kernel.const_get(value)
+      end
+
+      klass < Exception ? klass : raise("#{klass} is not an exception")
+    end
+
+    def repeat_from(options)
+      options.fetch(:repeat, 1).to_i.tap { |val| return val if val.positive? }
+      raise Fixturama::FixtureError.new("a number of repeats", options)
+    end
+  end
+end

data/lib/fixturama/changes/chain/return_action.rb

@@ -0,0 +1,33 @@
+class Fixturama::Changes::Chain
+  #
+  # @private
+  # Return a specified value as a result of stubbing
+  #
+  class ReturnAction
+    attr_reader :repeat
+
+    def call
+      @value
+    end
+
+    private
+
+    def initialize(**options)
+      @value  = value_from(options)
+      @repeat = repeat_from(options)
+    end
+
+    def value_from(options)
+      value = options[:return]
+      value.respond_to?(:dup) ? value.dup : value
+    rescue TypeError
+      # in the Ruby 2.3.0 Fixnum#dup is defined, but raises TypeError
+      value
+    end
+
+    def repeat_from(options)
+      options.fetch(:repeat, 1).to_i.tap { |val| return val if val.positive? }
+      raise Fixturama::FixtureError.new("a number of repeats", options)
+    end
+  end
+end

data/lib/fixturama/changes/const.rb

@@ -0,0 +1,30 @@
+class Fixturama::Changes
+  #
+  # @private
+  # Stub a constant
+  #
+  class Const < Base
+    def key
+      name
+    end
+
+    def call(example)
+      example.send(:stub_const, name, value)
+      self
+    end
+
+    private
+
+    def initialize(**options)
+      @options = options
+    end
+
+    def name
+      @options[:const]
+    end
+
+    def value
+      @options[:value]
+    end
+  end
+end

data/lib/fixturama/changes/env.rb

@@ -0,0 +1,35 @@
+class Fixturama::Changes
+  #
+  # @private
+  # Stub an environment variable
+  #
+  class Env < Base
+    # All changes has the same +key+
+    # They will be merged before stubbing (see +call+)
+    def key
+      "ENV"
+    end
+
+    # When we merge 2 env-s, we just merge their options
+    def merge(other)
+      return self unless other.is_a?(self.class)
+      dup.tap { |env| env.options.update(other.options) }
+    end
+
+    def call(example)
+      original = Hash ENV
+      example.send(:stub_const, "ENV", original.merge(options))
+      self
+    end
+
+    protected
+
+    attr_reader :options
+
+    private
+
+    def initialize(**options)
+      @options = { options[:env].to_s => options[:value].to_s }
+    end
+  end
+end

data/lib/fixturama/changes/request.rb

@@ -0,0 +1,91 @@
+class Fixturama::Changes
+  #
+  # @private
+  # Stub an HTTP(S) request using +Webmock+
+  #
+  class Request < Base
+    require_relative "request/response"
+    require_relative "request/responses"
+
+    def call(example)
+      stub = example.stub_request(http_method, uri)
+      stub = stub.with(request) if request.any?
+      stub.to_return { |_| responses.next }
+      self
+    end
+
+    private
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+      with_error { @options = Hash(@options).transform_keys(&:to_sym) }
+    end
+
+    HTTP_METHODS = %i[get post put patch delete head options any].freeze
+
+    def http_method
+      with_error("http method") do
+        value = with_error("method") { options[:method]&.to_sym&.downcase }
+        value ||= :any
+        raise("Invalid HTTP method") unless HTTP_METHODS.include?(value)
+        value
+      end
+    end
+
+    def uri
+      with_error("uri") { maybe_regexp(options[:uri] || options[:url]) }
+    end
+
+    def headers
+      with_error("headers") do
+        Hash(options[:headers]).transform_keys(&:to_s) if options.key? :headers
+      end
+    end
+
+    def query
+      with_error("query") do
+        Hash(options[:query]).transform_keys(&:to_s) if options.key?(:query)
+      end
+    end
+
+    def body
+      with_error("body") { maybe_regexp options[:body] }
+    end
+
+    def basic_auth
+      with_error("basic auth") do
+        value = options[:auth] || options[:basic_auth]
+        Hash(value).transform_keys(&:to_s).values_at("user", "pass") if value
+      end
+    end
+
+    def request
+      @request ||= {
+        headers: headers,
+        body: body,
+        query: query,
+        basic_auth: basic_auth
+      }.select { |_, val| val }
+    end
+
+    def responses
+      @responses ||= Responses.new(options[:response] || options[:responses])
+    end
+
+    def with_error(part = nil)
+      yield
+    rescue StandardError => err
+      part = ["a valid request", part].compact.join(" ")
+      raise Fixturama::FixtureError.new(part, options, err)
+    end
+
+    def maybe_regexp(str)
+      return unless str
+
+      str = str.to_s
+      str[%r{\A/.*/\z}] ? Regexp.new(str[1..-2]) : str
+    end
+  end
+end

data/lib/fixturama/changes/request/response.rb

@@ -0,0 +1,62 @@
+class Fixturama::Changes::Request
+  #
+  # @private
+  # Store data for a response to the corresponding request
+  #
+  class Response
+    # @!attribute [r] repeat A number of times the response to be repeated
+    # @return [Integer]
+    attr_reader :repeat
+
+    # @!attribute [r] to_h A hash for the +to_respond(...)+ part of the stub
+    # @return [Hash<Symbol, Object>]
+    attr_reader :to_h
+
+    private
+
+    def initialize(options)
+      @options = options
+      @options = with_error { Hash(options).transform_keys(&:to_sym) }
+      @to_h    = build_hash
+      @repeat  = build_repeat
+    end
+
+    def build_repeat
+      with_error("number of repeats") do
+        value = @options.fetch(:repeat, 1).to_i
+        value.positive? ? value : raise("Wrong value")
+      end
+    end
+
+    def build_hash
+      { status: status, body: body, headers: headers }.select { |_, v| v }
+    end
+
+    def status
+      with_error("status") { @options[:status]&.to_i } || 200
+    end
+
+    def body
+      with_error("body") do
+        case @options[:body]
+        when NilClass then nil
+        when Hash then JSON.dump(@options[:body])
+        else @options[:body].to_s
+        end
+      end
+    end
+
+    def headers
+      with_error("headers") do
+        Hash(@options[:headers]).map { |k, v| [k.to_s, v.to_s] }.to_h
+      end
+    end
+
+    def with_error(part = nil)
+      yield
+    rescue StandardError => err
+      object = ["a response", part].compact.join(" ")
+      raise Fixturama::FixtureError.new(object, options, err)
+    end
+  end
+end