impersonator 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c27e2c12811df79ee6ecda2a617b9952ac98dff360ca3e08d725832d54cf5b03
+  data.tar.gz: d40825fb2fbbdc7ac842bf58864acc2c02f2dd72b3a228b1ee0ee9ded86f891b
+SHA512:
+  metadata.gz: e8039d138b2f899a27d9476873ce687586a5322a7d0846a2828207592f51fd6a80f134a54fc7dce99cc8ea1d8581cdae25f62382e2129054d2148d1d05360543
+  data.tar.gz: e39e557b268d09c24206d7db469fa7dd931002e0cf9b6b72b70e25ba2f87270f43b176170b43e83ae7b8fa0e26999c7e956afb1b5ac83a1fd2f0327359124e94

data/.circleci/config.yml

@@ -0,0 +1,71 @@
+version: 2.1
+defaults: &defaults
+  working_directory: ~/impersonator
+  docker:
+    - image: circleci/ruby:2.6.2-node-browsers
+      environment:
+        BUNDLE_PATH: vendor/bundle
+        PGHOST: 127.0.0.1
+        PGUSER: impersonator
+commands:
+  prepare:
+    description: "Common preparation steps"
+    steps:
+      - checkout
+
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "Gemfile.lock" }}
+            # fallback to using the latest cache if no exact match is found
+            - v1-dependencies-
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+jobs:
+  tests:
+    <<: *defaults
+    steps:
+      - prepare
+      - run:
+          name: run tests
+          command: |
+            mkdir /tmp/test-results
+            TEST_FILES="$(circleci tests glob "spec/**/*_spec.rb" | circleci tests split --split-by=timings)"
+
+            bundle exec rspec --format progress \
+                            --format RspecJunitFormatter \
+                            --out /tmp/test-results/rspec.xml \
+                            --tag ~type:performance \
+                            --format progress \
+                            $TEST_FILES
+
+      # collect reports
+      - store_test_results:
+          path: /tmp/test-results
+      - store_artifacts:
+          path: /tmp/test-results
+          destination: test-results
+  rubocop:
+    <<: *defaults
+    steps:
+      - prepare
+      - run:
+          name: Rubocop
+          command: bundle exec rubocop
+workflows:
+  version: 2
+  pipeline:
+    jobs:
+      - tests
+      - rubocop
+
+
+
+

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+spec/recordings

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,138 @@
+require: rubocop-rspec
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Naming/BinaryOperatorParameterName:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Naming/UncommunicativeMethodParamName:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+Naming/VariableNumber:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+RSpec/EmptyExampleGroup:
+  Enabled: false
+
+RSpec/FilePath:
+  Enabled: false
+
+Lint/UselessAccessModifier:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+RSpec/SubjectStub:
+  Enabled: false
+
+RSpec/MessageSpies:
+  Enabled: false
+
+RSpec/VerifiedDoubles:
+  Enabled: false
+
+RSpec/DescribeClass:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
+RSpec/LetSetup:
+  Enabled: false
+
+# Replace some legits include? usages
+RSpec/PredicateMatcher:
+  Enabled: false
+
+# For some algo tests we do want to use instance_vars to capture data within algos
+RSpec/InstanceVariable:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Lint/HandleExceptions:
+  Enabled: false
+
+RSpec/BeforeAfterAll:
+  Enabled: false
+
+Lint/Loop:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Naming/RescuedExceptionsVariableName:
+  Enabled: false
+
+Lint/UnusedMethodArgument:
+  AllowUnusedKeywordArguments: true
+  IgnoreEmptyMethods: true
+
+Lint/NestedMethodDefinition:
+  Enabled: false
+
+Style/MethodMissingSuper:
+  Enabled: false
+
+RSpec/MultipleDescribes:
+  Enabled: false
+
+AllCops:
+  Exclude:
+    - "**/*.sql"
+    - "recipes/**/*"
+    - "db/**/*"
+    - "tmp/**/*"
+    - "vendor/**/*"
+    - "bin/**/*"
+    - "log/**/*"
+    - "ansible/**/*"

data/.ruby-version

@@ -0,0 +1 @@
+2.6.3

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 1.17.2

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in impersonator.gemspec
+gemspec
+
+gem 'rubocop', require: false
+gem 'rubocop-rspec', require: false

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    impersonator (0.1.1)
+      zeitwerk (~> 2.1.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.0)
+    diff-lcs (1.3)
+    jaro_winkler (1.5.2)
+    parallel (1.17.0)
+    parser (2.6.3.0)
+      ast (~> 2.4.0)
+    rainbow (3.0.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rspec_junit_formatter (0.4.1)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    rubocop (0.71.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.6)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    rubocop-rspec (1.33.0)
+      rubocop (>= 0.60.0)
+    ruby-progressbar (1.10.1)
+    unicode-display_width (1.6.0)
+    zeitwerk (2.1.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  impersonator!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  rspec_junit_formatter
+  rubocop
+  rubocop-rspec
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Jorge Manrubia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,200 @@
+[![CircleCI](https://circleci.com/gh/jorgemanrubia/impersonator.svg?style=svg)](https://circleci.com/gh/jorgemanrubia/impersonator)
+
+# Impersonator
+
+Impersonator is a Ruby library to record and replay object interactions. 
+
+When testing, you often find services that are expensive to invoke, and you need to use a [double](https://martinfowler.com/bliki/TestDouble.html) instead. Creating stubs and mocks for simple scenarios is easy, but, for complex interactions, things get messy fast. Stubbing elaborated canned response and orchestrating multiple expectations quickly degenerates in brittle tests that are hard to write and maintain.
+
+Impersonator comes to the rescue. Given an object and a list of methods to impersonate:
+
+- The first time each method is invoked, it will record its invocations, including passed arguments, return values, and yielded values. This is known as *record mode*.
+- The next times, it will reproduce the recorded values and will validate that the method was invoked with the same arguments, in a specific order and the exact number of times. This is known as *replay mode*.
+
+Impersonator only focuses on validating invocation signature and reproducing output values, which is perfect for many services. It won't work for services that trigger additional logic that is relevant to the test (e.g., if the method sends an email, the impersonated method won't send it). 
+
+Familiar with [VCR](https://github.com/vcr/vcr)? Impersonator is like VCR but for ruby objects instead of HTTP.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'impersonator', group: :test
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Use `Impersonator.impersonate` passing in a list of methods to impersonate and a block that will instantiate the object at record time:
+
+```ruby
+Impersonator.impersonate(:add, :divide) { Calculator.new }
+```
+
+* At record time, `Calculator` will be instantiated and their methods normally invoked, recording the returned values (and yielded values if any).
+* At replay time, `Calculator` won't be instantiated. Instead, a double object will be generated on the fly that will replay the recorded values.
+
+```ruby
+class Calculator
+  def add(number_1, number_2)
+    number_1 + number_2
+  end
+end
+
+# The first time it records...
+Impersonator.recording('calculator add') do
+  impersonated_calculator = Impersonator.impersonate(:add) { Calculator.new }
+  puts impersonated_calculator.add(2, 3) # 5
+end
+
+# The next time it replays
+Object.send :remove_const, :Calculator # Calculator does not even have to exist now
+Impersonator.recording('calculator add') do
+  impersonated_calculator = Impersonator.impersonate(:add) { Calculator.new }
+  puts impersonated_calculator.add(2, 3) # 5
+end
+```
+
+Typically you will use `impersonate` for testing, so this is how your test will look:
+
+```ruby
+# The second time the test runs, impersonator will replay the
+# recorded results
+test 'sums the numbers' do
+  Impersonator.recording('calculator add') do
+    calculator = Impersonator.impersonate(:add){ Calculator.new }
+    assert_equal 5, calculator.add(2, 3)
+  end
+end
+```
+
+Impersonated methods will record and replay:
+
+- Arguments
+- Return values
+- Yielded values
+
+### Impersonate certain methods only
+
+Use `Impersonator#impersonate_methods` to impersonate certain methods only. At replay time, the impersonated object will delegate to the actual object all the methods except the impersonated ones. 
+
+```ruby
+actual_calculator = Calculator.new
+impersonator = Impersonator.impersonate(actual_calculator, :add)
+```
+
+In this case, in replay mode, `Calculator` gets instantiated normally and any method other than `#add`  will be delegated to `actual_calculator`.
+
+## Configuration
+
+### Recordings path
+
+`Impersonator` works by recording method invocations in `YAML` format. By default, recordings are saved in:
+
+- `spec/recordings` if a `spec` folder is present in the project
+- `test/recordings` otherwise
+
+You can configure this path with:
+
+```ruby
+Impersonator.configure do |config|
+  config.recordings_path = 'my/own/recording/path'
+end
+```
+
+### Ignore arguments when matching methods
+
+By default, to determine if a method invocation was right, the list of arguments will be matched with `==`. You can configure how this work by providing a list of argument indexes to ignore.
+
+```ruby
+impersonator = Impersonator.impersonate(:add){ Test::Calculator.new }
+impersonator.configure_method_matching_for(:add) do |config|
+  config.ignore_arguments_at 0
+end
+
+# Now the first parameter of #add will be ignored.
+#
+# In record mode:
+impersonator.add(1, 2) # 3
+
+# In replay mode
+impersonator.add(9999, 2) # will still return 3 and won't fail because the first argument is ignored
+```
+
+### Disabling record mode
+
+You can disable `impersonator` by passing `disable: true` to `Impersonator.recording`:
+
+```ruby
+Impersonator.recording('test recording', disabled: true) do
+  # ...
+end
+```
+
+This will effectively force record mode at all times. This is handy while you are figuring out how interactions with the mocked service go. It will save the recordings, but it will never use them.
+
+### Configuring attributes to serialize
+
+`Impersonator` relies on Ruby standard `YAML` library for serializing/deserializing data. It works with simple attributes, arrays, hashes and objects which attributes are serializable in a recurring way. This means that you don't have to care when interchanging value objects, which is a common scenario when impersonating RPC-like clients.
+
+However, there are some types, like `Proc`, anonymous classes, or `IO` classes like `File`, that will make the serialization process fail. You can customize which attributes are serialized by overriding `init_with` and `encode_with` in the class you want to serialize. You will typically exclude the problematic attributes by including only the compatible ones.
+
+```ruby
+class MyClass
+  # ...
+  
+  def init_with(coder)
+    self.name = coder['name']
+  end
+
+  def encode_with(coder)
+    coder['name'] = name
+  end
+end
+```
+
+### RSpec configuration
+
+`Impersonator` is test-framework agnostic. If you are using [RSpec](https://rspec.info), you can configure an `around` hook that will start a recording session automatically for each example that has an `impersonator` tag:
+
+```ruby
+RSpec.configure do |config|
+  config.around(:example, :impersonator) do |example|
+    Impersonator.recording(example.full_description) do
+      example.run
+    end
+  end
+end
+```
+
+Now you can just tag your tests with `impersonator` and an implicit recording named after the example will be available automatically, so you don't have to invoke `Impersonator.recording` anymore.
+
+```ruby
+describe Calculator, :impersonator do
+  it 'sums numbers' do
+    # there is an implicit recording stored in 'calculator-sums-numbers.yaml'
+    impersonator = Impersonator.impersonate(:add){ Calculator.new }
+    expect(impersonator.add(1, 2)).to eq(3)
+  end
+end
+```
+
+## Thanks
+
+- This library was heavily inspired by [VCR](https://github.com/vcr/vcr). A gem that blew my mind years ago and that has been in my toolbox since then.
+
+## Links
+
+- [Blog post](https://www.jorgemanrubia.com/2019/06/16/impersonator-a-ruby-library-to-record-and-replay-object-interactions/)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jorgemanrubia/impersonator.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).`

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "impersonator"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/impersonator.gemspec

@@ -0,0 +1,40 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'impersonator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'impersonator'
+  spec.version       = Impersonator::VERSION
+  spec.authors       = ['Jorge Manrubia']
+  spec.email         = ['jorge.manrubia@gmail.com']
+
+  spec.summary       = 'Generate test stubs that replay recorded interactions'
+  spec.description   = 'Record and replay object interactions. Ideal for mocking not-http services when testing (just because, for http, VCR is probably what you want)'
+  spec.homepage      = 'https://github.com/jorgemanrubia/impersonator'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/jorgemanrubia/impersonator'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'zeitwerk', '~> 2.1.6'
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec_junit_formatter'
+end

data/lib/impersonator.rb

@@ -0,0 +1,20 @@
+require 'impersonator/version'
+
+require 'zeitwerk'
+require 'logger'
+require 'fileutils'
+require 'yaml'
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module Impersonator
+  extend Api
+
+  def self.logger
+    @logger ||= ::Logger.new(STDOUT).tap do |logger|
+      logger.level = Logger::WARN
+      logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+    end
+  end
+end

data/lib/impersonator/api.rb

@@ -0,0 +1,68 @@
+module Impersonator
+  module Api
+    def recording(label, disabled: false)
+      @current_recording = ::Impersonator::Recording.new(label, disabled: disabled, recordings_path: configuration.recordings_path)
+      @current_recording.start
+      yield
+      @current_recording.finish
+    ensure
+      @current_recording = nil
+    end
+
+    def current_recording
+      @current_recording
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Reset configuration and other global state.
+    #
+    # It is meant to be used internally by tests.
+    def reset
+      @current_recording = nil
+      @configuration = nil
+    end
+
+    # Receives a list of methods to impersonate and a block that will be used, at record time, to
+    # instantiate the object to impersonate. At replay time, it will generate a double that will
+    # replay the methods.
+    #
+    #   impersonator = Impersonator.impersonate(:add, :subtract) { Calculator.new }
+    #   impersonator.add(3, 4)
+    #
+    # Notice that the actual object won't be instantiated in record mode. For that reason, the impersonated
+    # object will only respond to the list of impersonated methods.
+    #
+    # If you need to invoke other (not impersonated) methods see #impersonate_method instead.
+    #
+    # @return [Object] the impersonated object
+    def impersonate(*methods)
+      raise ArgumentError, 'Provide a block to instantiate the object to impersonate in record mode' unless block_given?
+
+      object_to_impersonate = if current_recording&.record_mode?
+                                yield
+                              else
+                                Double.new(*methods)
+                              end
+      impersonate_methods(object_to_impersonate, *methods)
+    end
+
+    # Impersonates a list of methods of a given object
+    #
+    # The returned object will impersonate the list of methods and will delegate the rest of method calls
+    # to the actual object.
+    #
+    # @return [Object] the impersonated object
+    def impersonate_methods(actual_object, *methods)
+      raise Impersonator::Errors::ConfigurationError, 'You must start a recording to impersonate objects. Use Impersonator.recording {}' unless @current_recording
+
+      ::Impersonator::Proxy.new(actual_object, recording: current_recording, impersonated_methods: methods)
+    end
+  end
+end

data/lib/impersonator/block_invocation.rb

@@ -0,0 +1,3 @@
+module Impersonator
+  BlockInvocation = Struct.new(:arguments, keyword_init: true)
+end

data/lib/impersonator/block_spy.rb

@@ -0,0 +1,20 @@
+module Impersonator
+  BlockSpy = Struct.new(:block_invocations, :actual_block, keyword_init: true) do
+    def block
+      @block ||= proc do |*arguments|
+        self.block_invocations ||= []
+        self.block_invocations << BlockInvocation.new(arguments: arguments)
+        return_value = actual_block.call(*arguments)
+        return_value
+      end
+    end
+
+    def init_with(coder)
+      self.block_invocations = coder['block_invocations']
+    end
+
+    def encode_with(coder)
+      coder['block_invocations'] = block_invocations
+    end
+  end
+end

data/lib/impersonator/configuration.rb

@@ -0,0 +1,17 @@
+module Impersonator
+  Configuration = Struct.new(:recordings_path, keyword_init: true) do
+    DEFAULT_RECORDINGS_FOLDER = 'recordings'.freeze
+
+    def initialize(*)
+      super
+      self.recordings_path ||= detect_default_recordings_path
+    end
+
+    private
+
+    def detect_default_recordings_path
+      base_path = File.exist?('spec') ? 'spec' : 'test'
+      File.join(base_path, DEFAULT_RECORDINGS_FOLDER)
+    end
+  end
+end

data/lib/impersonator/double.rb

@@ -0,0 +1,15 @@
+module Impersonator
+  class Double
+    def initialize(*methods)
+      define_methods(methods)
+    end
+
+    private
+
+    def define_methods(methods)
+      methods.each do |method|
+        self.class.define_method(method) {}
+      end
+    end
+  end
+end

data/lib/impersonator/errors/configuration_error.rb

@@ -0,0 +1,6 @@
+module Impersonator
+  module Errors
+    class ConfigurationError < StandardError
+    end
+  end
+end

data/lib/impersonator/errors/method_invocation_error.rb

@@ -0,0 +1,6 @@
+module Impersonator
+  module Errors
+    class MethodInvocationError < StandardError
+    end
+  end
+end

data/lib/impersonator/has_logger.rb

@@ -0,0 +1,7 @@
+module Impersonator
+  module HasLogger
+    def logger
+      ::Impersonator.logger
+    end
+  end
+end

data/lib/impersonator/method.rb

@@ -0,0 +1,44 @@
+module Impersonator
+  Method = Struct.new(:name, :arguments, :block, :matching_configuration, keyword_init: true) do
+    def to_s
+      string = name.to_s
+
+      arguments_string = arguments&.collect(&:to_s)&.join(', ')
+
+      string << "(#{arguments_string})"
+      string << ' {with block}' if block
+      string
+    end
+
+    def block_spy
+      return nil if !@block_spy && !block
+
+      @block_spy ||= BlockSpy.new(actual_block: block)
+    end
+
+    def init_with(coder)
+      self.name = coder['name']
+      self.arguments = coder['arguments']
+      self.matching_configuration = coder['matching_configuration']
+      @block_spy = coder['block_spy']
+    end
+
+    def encode_with(coder)
+      coder['name'] = name
+      coder['arguments'] = arguments
+      coder['block_spy'] = block_spy
+      coder['matching_configuration'] = matching_configuration
+    end
+
+    def ==(other_method)
+      my_arguments = arguments.dup
+      other_arguments = other_method.arguments.dup
+      matching_configuration&.ignored_positions&.each do |ignored_position|
+        my_arguments.delete_at(ignored_position)
+        other_arguments.delete_at(ignored_position)
+      end
+
+      name == other_method.name && my_arguments == other_arguments && !block_spy == !other_method.block_spy
+    end
+  end
+end

data/lib/impersonator/method_invocation.rb

@@ -0,0 +1,3 @@
+module Impersonator
+  MethodInvocation = Struct.new(:method_instance, :return_value, keyword_init: true)
+end

data/lib/impersonator/method_matching_configuration.rb

@@ -0,0 +1,13 @@
+module Impersonator
+  class MethodMatchingConfiguration
+    attr_reader :ignored_positions
+
+    def initialize
+      @ignored_positions = []
+    end
+
+    def ignore_arguments_at(*positions)
+      ignored_positions.push(*positions)
+    end
+  end
+end

data/lib/impersonator/proxy.rb

@@ -0,0 +1,56 @@
+module Impersonator
+  class Proxy
+    include HasLogger
+
+    attr_reader :impersonated_object
+
+    def initialize(impersonated_object, recording:, impersonated_methods:)
+      validate_object_has_methods_to_impersonate!(impersonated_object, impersonated_methods)
+
+      @impersonated_object = impersonated_object
+      @impersonated_methods = impersonated_methods.collect(&:to_sym)
+      @recording = recording
+      @method_matching_configurations_by_method = {}
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @impersonated_methods.include?(method_name.to_sym)
+        invoke_impersonated_method(method_name, *args, &block)
+      else
+        @impersonated_object.send(method_name, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method_name, *args)
+      impersonated_object.respond_to_missing?(method_name, *args)
+    end
+
+    def configure_method_matching_for(method)
+      method_matching_configurations_by_method[method.to_sym] ||= MethodMatchingConfiguration.new
+      yield method_matching_configurations_by_method[method]
+    end
+
+    private
+
+    attr_reader :recording, :impersonated_methods, :method_matching_configurations_by_method
+
+    def validate_object_has_methods_to_impersonate!(object, methods_to_impersonate)
+      missing_methods = methods_to_impersonate.find_all do |method|
+        !object.respond_to?(method.to_sym)
+      end
+
+      raise Impersonator::Errors::ConfigurationError, "These methods to impersonate does not exist: #{missing_methods.inspect}" unless missing_methods.empty?
+    end
+
+    def invoke_impersonated_method(method_name, *args, &block)
+      method = Method.new(name: method_name, arguments: args, block: block, matching_configuration: method_matching_configurations_by_method[method_name.to_sym])
+      if recording.replay_mode?
+        recording.replay(method)
+      else
+        @impersonated_object.send(method_name, *args, &method&.block_spy&.block).tap do |return_value|
+          recording.record(method, return_value)
+        end
+      end
+    end
+  end
+end

data/lib/impersonator/recording.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Impersonator
+  class Recording
+    include HasLogger
+
+    attr_reader :label
+
+    def initialize(label, disabled: false, recordings_path:)
+      @label = label
+      @recordings_path = recordings_path
+      @disabled = disabled
+    end
+
+    def start
+      logger.debug "Starting recording #{label}..."
+      if can_replay?
+        start_in_replay_mode
+      else
+        start_in_record_mode
+      end
+    end
+
+    def record(method, return_value)
+      method_invocation = MethodInvocation.new(method_instance: method, return_value: return_value)
+
+      @method_invocations << method_invocation
+    end
+
+    def replay(method)
+      method_invocation = @method_invocations.shift
+      raise Impersonator::Errors::MethodInvocationError, "Unexpected method invocation received: #{method}" unless method_invocation
+
+      validate_method_signature!(method, method_invocation.method_instance)
+      replay_block(method_invocation, method)
+
+      method_invocation.return_value
+    end
+
+    def finish
+      logger.debug "Recording #{label} finished"
+      if record_mode?
+        finish_in_record_mode
+      else
+        finish_in_replay_mode
+      end
+    end
+
+    def replay_mode?
+      @replay_mode
+    end
+
+    def record_mode?
+      !replay_mode?
+    end
+
+    private
+
+    def can_replay?
+      !@disabled && File.exist?(file_path)
+    end
+
+    def replay_block(recorded_method_invocation, method_to_replay)
+      block_spy = recorded_method_invocation.method_instance.block_spy
+      block_spy&.block_invocations&.each do |block_invocation|
+        method_to_replay.block.call(*block_invocation.arguments)
+      end
+    end
+
+    def start_in_replay_mode
+      logger.debug 'Replay mode'
+      @replay_mode = true
+      @method_invocations = YAML.load_file(file_path)
+    end
+
+    def start_in_record_mode
+      logger.debug 'Recording mode'
+      @replay_mode = false
+      make_sure_recordings_dir_exists
+      @method_invocations = []
+    end
+
+    def finish_in_record_mode
+      File.open(file_path, 'w') do |file|
+        YAML.dump(@method_invocations, file)
+      end
+    end
+
+    def finish_in_replay_mode
+      unless @method_invocations.empty?
+        raise Impersonator::Errors::MethodInvocationError, "Expecting #{@method_invocations.length} method invocations"\
+                                                            " that didn't happen: #{@method_invocations.inspect}"
+      end
+    end
+
+    def file_path
+      File.join(@recordings_path, "#{label_as_file_name}.yml")
+    end
+
+    def label_as_file_name
+      label.downcase.gsub(/[\(\)\s \#:]/, '-').gsub(/[\-]+/, '-').gsub(/(^-)|(-$)/, '')
+    end
+
+    def make_sure_recordings_dir_exists
+      dirname = File.dirname(file_path)
+      FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+    end
+
+    def validate_method_signature!(expected_method, actual_method)
+      unless actual_method == expected_method
+        raise Impersonator::Errors::MethodInvocationError, <<~ERROR
+          Expecting:
+            #{expected_method}
+          But received:
+            #{actual_method}
+        ERROR
+      end
+    end
+  end
+end

data/lib/impersonator/version.rb

@@ -0,0 +1,3 @@
+module Impersonator
+  VERSION = '0.1.1'.freeze
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: impersonator
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Jorge Manrubia
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.6
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Record and replay object interactions. Ideal for mocking not-http services
+  when testing (just because, for http, VCR is probably what you want)
+email:
+- jorge.manrubia@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- impersonator.gemspec
+- lib/impersonator.rb
+- lib/impersonator/api.rb
+- lib/impersonator/block_invocation.rb
+- lib/impersonator/block_spy.rb
+- lib/impersonator/configuration.rb
+- lib/impersonator/double.rb
+- lib/impersonator/errors/configuration_error.rb
+- lib/impersonator/errors/method_invocation_error.rb
+- lib/impersonator/has_logger.rb
+- lib/impersonator/method.rb
+- lib/impersonator/method_invocation.rb
+- lib/impersonator/method_matching_configuration.rb
+- lib/impersonator/proxy.rb
+- lib/impersonator/recording.rb
+- lib/impersonator/version.rb
+homepage: https://github.com/jorgemanrubia/impersonator
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jorgemanrubia/impersonator
+  source_code_uri: https://github.com/jorgemanrubia/impersonator
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Generate test stubs that replay recorded interactions
+test_files: []