fixturama 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bfb62ba99d427f8a3f03b6d46a0fb7e6712dd31bfff6da7c17fb075cfa930f0
-  data.tar.gz: fa1b0359c0681a73723a915dd499945602b350b3b802b68e6962a66753a5d208
+  metadata.gz: ed87b651886697aaea8b0a79ddbf5b875372ca382926f3dc07d8f3bec2a4d07d
+  data.tar.gz: 76248c5bb6b75d335c80387d11b6446cee23829bf1ca8f6fb319c12a1b5f0e52
 SHA512:
-  metadata.gz: 987b0cf303e78879b18278d85ace7cf26261e6c76000b0081571cb40a3dcf763435cb5560de122bf3a466b9c781684c8ed8d183697fbd1b84aa619c8409e34c8
-  data.tar.gz: d85486458d90dbff1e3f2136c5862e081aa1a1861bb5e6320fb68bbc258d11ce1e978de5603c900080ef719809e97a4d0bf793a46c8f90af33e7a6626d258835
+  metadata.gz: 20607f5c8bc2ed14ac8bef4bf207495946a02f4a39e2d6d77661b4fa154c01b3f4072e62aaf9083509369eb4b9fe01b2c9dfe1aa4e87b7bf2bb9a3b31b0a1827
+  data.tar.gz: baf0b2716a960d8885dda3dde622009ebf8a1335912358898283b42b7beea04137e9d2ee1bcc58d305b8cdf14c21f3bdfa4442674a4dbb780aad61486b0e2682

data/CHANGELOG.md

@@ -5,6 +5,34 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.2.0] - [2020-02-17]
+
+### Added
+
+- Stubbing and seeding from the same source file via the `call_fixture` method (nepalez)
+
+```yaml
+# ./changes.yml
+---
+- type: user
+  params:
+    id: 1
+
+- const: DEFAULT_USER_ID
+  value: 1
+
+- url: https://example.com/users/default
+  method: get
+  responses:
+    - body:
+        id: 1
+        name: Andrew
+```
+
+```ruby
+before { call_fixture "#{__dir__}/changes.yml" }
+```
+
 ## [0.1.0] - [2020-02-09]
 
 ### Added
@@ -200,3 +228,4 @@ This is a first public release with features extracted from production app.
 [0.0.6]: https://github.com/nepalez/fixturama/compare/v0.0.5...v0.0.6
 [0.0.7]: https://github.com/nepalez/fixturama/compare/v0.0.6...v0.0.7
 [0.1.0]: https://github.com/nepalez/fixturama/compare/v0.0.7...v0.1.0
+[0.2.0]: https://github.com/nepalez/fixturama/compare/v0.1.0...v0.2.0

data/README.md

@@ -124,16 +124,17 @@ Use the `count: 2` key to create more objects at once.
 
 ### Stubbing
 
-Another opinionated format we use for stubs (`stub_fixture`). The gem supports stubbing both message chains and constants.
+The gem supports stubbing message chains, constants and http requests with the following keys.
 
 For message chains:
 
 - `class` for stubbed class
 - `chain` for messages chain
 - `arguments` (optional) for specific arguments
-- `actions` for an array of actions for consecutive invocations of the chain
-
-Every action either `return` some value, or `raise` some exception
+- `actions` for an array of actions for consecutive invocations of the chain with keys
+    - `return` for a value to be returned
+    - `raise` for an exception to be risen
+    - `repeate` for a number of invocations with this action
 
 For constants:
 
@@ -152,6 +153,7 @@ For http requests:
     - `status`
     - `body`
     - `headers`
+    - `repeate` for the number of times this response should be returned before switching to the next one
 
 ```yaml
 # ./stubs.yml
@@ -179,6 +181,7 @@ For http requests:
     - <%= profile_id %>
   actions:
     - return: true
+      repeate: 1 # this is the default value
     - raise: ActiveRecord::RecordNotFound
 
 - const: NOTIFIER_TIMEOUT_SEC
@@ -192,6 +195,7 @@ For http requests:
     password: bar
   responses:
     - status: 200 # for the first call
+      repeate: 1   # this is the default value, but you can set another one
     - status: 404 # for any other call
 
 - uri: htpps://example.com/foo # exact string!
@@ -231,6 +235,30 @@ I find it especially helpful when I need to check different edge cases. Instead
 
 Looking at the spec I can easily figure out the "structure" of expectation, while looking at fixtures I can check the concrete corner cases.
 
+## Single Source of Changes
+
+If you will, you can list all stubs and seeds at the one single file like
+
+```yaml
+# ./changes.yml
+---
+- type: user
+  params:
+    id: 1
+    name: Andrew
+
+- const: DEFAULT_USER_ID
+  value: 1
+```
+
+This fixture can be applied via `call_fixture` method just like we did above with `seed_fixture` and `stub_fixture`:
+
+```ruby
+before { call_fixture "#{__dir__}/changes.yml" }
+```
+
+In fact, since the `v0.2.0` all those methods are just the aliases of the `call_fixture`.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License][license].

data/fixturama.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name     = "fixturama"
-  gem.version  = "0.1.0"
+  gem.version  = "0.2.0"
   gem.author   = "Andrew Kozin (nepalez)"
   gem.email    = "andrew.kozin@gmail.com"
   gem.homepage = "https://github.com/nepalez/fixturama"

data/lib/fixturama.rb

@@ -6,44 +6,72 @@ require "rspec"
 require "webmock/rspec"
 require "yaml"
 
+#
+# A set of helpers to prettify specs with fixtures
+#
 module Fixturama
+  require_relative "fixturama/fixture_error"
   require_relative "fixturama/config"
-  require_relative "fixturama/utils"
   require_relative "fixturama/loader"
-  require_relative "fixturama/stubs"
-  require_relative "fixturama/seed"
+  require_relative "fixturama/changes"
 
+  # Set the initial value for database-generated IDs
+  # @param [#to_i] value
+  # @return [Fixturama]
   def self.start_ids_from(value)
     Config.start_ids_from(value)
+    self
   end
 
-  def stub_fixture(path, **opts)
-    items = load_fixture(path, **opts)
-    raise "The fixture should contain an array" unless items.is_a?(Array)
+  # @!method read_fixture(path, options)
+  # Read the text content of the fixture
+  # @param [#to_s] path The path to the fixture file
+  # @param [Hash<Symbol, _>] options
+  #   The list of options to be accessible in the fixture
+  # @return [String]
+  def read_fixture(path, **options)
+    content  = File.read(path)
+    hashie   = Hashie::Mash.new(options)
+    bindings = hashie.instance_eval { binding }
 
-    items.each { |item| fixturama_stubs.add(item) }
-    fixturama_stubs.apply(self)
+    ERB.new(content).result(bindings)
   end
 
-  def seed_fixture(path, **opts)
-    Array(load_fixture(path, **opts)).each { |item| Seed.call(item) }
+  # @!method load_fixture(path, options)
+  # Load data from a fixture
+  # @param (see #read_fixture)
+  # @return [Object]
+  def load_fixture(path, **options)
+    Loader.new(path, options).call
   end
 
-  def load_fixture(path, **opts)
-    Loader.new(path, opts).call
+  # @!method call_fixture(path, options)
+  # Stub different objects and seed the database from a fixture
+  # @param (see #read_fixture)
+  # @return [RSpec::Core::Example] the current example
+  def call_fixture(path, **options)
+    items = Array load_fixture(path, **options)
+    items.each { |item| changes.add(item) }
+    tap { changes.call(self) }
+  rescue FixtureError => err
+    raise err.with_file(path)
   end
 
-  def read_fixture(path, **opts)
-    content  = File.read(path)
-    hashie   = Hashie::Mash.new(opts)
-    bindings = hashie.instance_eval { binding }
+  # @!method seed_fixture(path, options)
+  # The alias for the +call_fixture+
+  # @param (see #call_fixture)
+  # @return (see #call_fixture)
+  alias seed_fixture call_fixture
 
-    ERB.new(content).result(bindings)
-  end
+  # @!method stub_fixture(path, options)
+  # The alias for the +call_fixture+
+  # @param (see #call_fixture)
+  # @return (see #call_fixture)
+  alias stub_fixture call_fixture
 
   private
 
-  def fixturama_stubs
-    @fixturama_stubs ||= Stubs.new
+  def changes
+    @changes ||= Changes.new
   end
 end

data/lib/fixturama/changes.rb

@@ -0,0 +1,71 @@
+module Fixturama
+  #
+  # @private
+  # Registry of changes (stubs and seeds)
+  #
+  class Changes
+    require_relative "changes/base"
+    require_relative "changes/chain"
+    require_relative "changes/const"
+    require_relative "changes/request"
+    require_relative "changes/seed"
+
+    # Match option keys to the type of an item
+    TYPES = {
+      actions: Chain,
+      arguments: Chain,
+      basic_auth: Request,
+      body: Request,
+      chain: Chain,
+      class: Chain,
+      const: Const,
+      count: Seed,
+      headers: Request,
+      http_method: Request,
+      object: Chain,
+      params: Seed,
+      query: Request,
+      response: Request,
+      responses: Request,
+      traits: Seed,
+      type: Seed,
+      uri: Request,
+      url: Request,
+      value: Const,
+    }.freeze
+
+    # Adds new change to the registry
+    # @param [Hash] options
+    # @return [Fixturama::Changes]
+    # @raise [Fixturama::FixtureError] if the options cannot be processed
+    def add(options)
+      options = Hash(options).transform_keys(&:to_sym)
+      types = options.keys.map { |key| TYPES[key] }.compact.uniq
+      raise "Wrong count" unless types.count == 1
+
+      @changes << types.first.new(options)
+      self
+    rescue FixtureError => err
+      raise err
+    rescue StandardError => err
+      raise FixtureError.new("an operation", options, err)
+    end
+
+    # Apply all registered changes to the RSpec example
+    # @param [RSpec::Core::Example] example
+    # @return [self]
+    def call(example)
+      @changes
+        .group_by(&:key)
+        .values
+        .map { |changes| changes.reduce :merge }
+        .each { |change| change.call(example) }
+    end
+
+    private
+
+    def initialize
+      @changes = []
+    end
+  end
+end

data/lib/fixturama/changes/base.rb

@@ -0,0 +1,28 @@
+class Fixturama::Changes
+  #
+  # @private
+  # @abstract
+  # Base class for changes downloaded from a fixture
+  #
+  class Base
+    # @!attribute [r] key The key identifier of the change
+    # @return [String]
+    alias key hash
+
+    # Merge the other change into the current one
+    # @param [Fixturama::Changes::Base] other
+    # @return [Fixturama::Changes::Base]
+    def merge(other)
+      # By default just take the other change if applicable
+      other.class == self.class && other.key == key ? other : self
+    end
+
+    # @abstract
+    # Call the corresponding change (either a stub or a seed)
+    # @param [RSpec::Core::Example] _example The RSpec example
+    # @return [self]
+    def call(_example)
+      self
+    end
+  end
+end

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.class == 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