mock_proxy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f0228b892195ffaa32f34dfb387245a871bde314
+  data.tar.gz: bbe3274ab88c596f0df31ad27544b723c5569d4a
+SHA512:
+  metadata.gz: c2fcbbfe5ebe19d46846c0ec49d1b959f8f40262a093050afcfa4f99ab76ff799e6fda25f4627e5206dc1e8cef3323c4fc15a58932c0aab3aed9eec0a18e2d48
+  data.tar.gz: 9ee1cb4c96d9b808d8a328204f81e261c4da70d3b7a2872931bb4166669e0c0cb7eeeb0412a0dc1997d2714bffbda91f8ef48b171ab6e01970427ae41c4a3a44

data/.gitignore

@@ -0,0 +1,31 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+/Gemfile.lock
+.ruby-version
+.ruby-gemset
+.rvmrc

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mock_proxy.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 
+
+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/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 matrinox
+
+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,75 @@
+# MockProxy
+
+A proxy that can be used to stub method chains and more!
+
+## Description
+
+Remember when RSpec had `stub_chain`? They removed it for good reasons but sometimes you just need it.
+Well, here it is, a proxy object. It doesn't actually mock anything for you (the name is just catchy) so you need to do that.
+But that actually comes with a lot of benefits:
+
+1. It's compatable with any testing framework
+2. You can use it for purposes other than testing, e.g. prototyping, code stubs
+3. Flexibility in how you use it without overloading the number of methods you have to remember
+
+Here's an example usage:
+
+```ruby
+let(:model_proxy) do
+  MockProxy.new(email_client: {
+    create_email: {
+      receive: proc {}
+    }
+  })
+end
+before { allow(Model).to receive(:new).and_return model_proxy }
+it 'should call receive' do
+  proc = MockProxy.get(model_proxy, 'email_client.create_email.receive')
+  expect(proc).to receive(:call)
+  run_system_under_test
+  MockProxy.update(mock_proxy, 'email_client.create_email.validate!') { true }
+  MockProxy.observe(mock_proxy, 'email_client.create_email.send') do |to|
+    expect(to).to eq 'stop@emailing.me'
+  end
+  run_system_under_test2
+end
+```
+
+As you can see, the proc - which ends the proxy by calling the proc - can be used for anything. You can spy on the
+call count and arguments, mock methods, or just stub out code you don't want executed. Because it doesn't make any
+assumptions, it becomes very flexible. Simple, yet powerful, it's uses are infinite. Enjoy
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mock_proxy'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mock_proxy
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/mock_proxy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mock_proxy"
+
+# 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

data/bin/setup

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

data/lib/mock_proxy.rb

@@ -0,0 +1,199 @@
+require "mock_proxy/version"
+
+# A non-opinionated proxy object that has multiple uses. It can be used for mocking, spying,
+# stubbing. Use as a dummy, double, fake, etc. Every test double type possible. How? Let's see
+#
+# Example, say you want to stub this scenario: Model.new.generate_email.validate!.send(to: email)
+# That would have be 5-6 lines of stubbing. If this sounds like stub_chain, you're on the right track. It was removed in
+# RSpec 3 (or 2?). It's similar to that but it does things differently
+# First, it doesn't require you to use it in a stub
+# Second, it's use of procs means you can define anything, a stub or a mock (expectation) or a spy or whatever you want
+#
+# To use MockProxy, initialize it with a hash. Each key is a method call. Each call either returns a new proxy or calls
+# the proc. If the value is a proc, it calls it immediately with the args and block. If the value is a hash, it returns
+# a new proxy with the value as the hash. MockProxy will warn if you don't use hashes or procs and will also warn if
+# you did not define all the method calls (it won't automatically return itself for methods not defined in the hash)
+#
+# Example use:
+#   let(:model_proxy) { MockProxy.new(generate_email: { validate!: { send: proc { |to| email } } }) }
+#   before { allow(Model).to receive(:new).and_return model_proxy }
+#   # ...
+#   describe 'Model' do
+#     it 'model also receives email' do
+#       callback = proc { |message| expect(message).to eq 'message' }
+#       MockProxy.update_proxy(model_proxy, receive_email: callback)
+#       run_system_under_test
+#     end
+#   end
+#
+# NOTE: You don't have to use only one mock proxy for all calls. You can break it up if you want to have more control
+# over each method call
+#
+# Example:
+#   let(:model_proxy) do
+#     callback = proc do |type|
+#       MockProxy.update_proxy(generator_proxy, decorate: proc { |*args| method_call(type, *args) })
+#       generator_proxy
+#     end
+#     MockProxy.new(generate_email: callback)
+#   end
+#   let(:generator_proxy) { MockProxy.new(validate!: { send: proc { |to| email } }) }
+#
+#
+# @author Geoff Lee
+# @since 0.1.0
+#
+class MockProxy
+  # Deep merges the callback tree, replacing existing values with new values
+  #
+  # Use case: Reuse existing stub but with some different values
+  #
+  # @param [MockProxy] proxy existing proxy
+  # @param [Hash] new_callback_hash new partial callback tree
+  # @return [MockProxy] the original proxy object
+  def self.merge(proxy, new_callback_hash)
+    existing_callback_hash = proxy.instance_variable_get('@callback_hash')
+    new_callback_hash = new_callback_hash.deep_stringify_keys
+    new_callback_hash = existing_callback_hash.deep_merge(new_callback_hash).freeze
+    proxy.instance_variable_set('@callback_hash', new_callback_hash)
+    proxy
+  end
+
+  # Replaces the proc at the specified key path
+  #
+  # Use case: Reuse existing stub but modify a proc
+  #
+  # @param [MockProxy] proxy existing proxy
+  # @param [String, Array<String>] key_path the chain of methods or key path. Can be a
+  #        dot delimited key path or an array of method names as strings or symbols
+  # @return [MockProxy] the original proxy object
+  def self.replace_at(proxy, key_path, &block)
+    set_callback(proxy, key_path, block)
+    proxy
+  end
+
+  # Add an observer to an existing proxy
+  #
+  # Use case: Observe method call without changing the existing callback's stubbed return value
+  #
+  # @param [MockProxy] proxy existing proxy
+  # @param [String, Array<String>] key_path the chain of methods or key path. Can be a
+  #        dot delimited key path or an array of method names as strings or symbols
+  # @yieldparam [*args] args
+  # @yieldreturn [optional]
+  # @return [MockProxy] the original proxy object
+  def self.observe(proxy, key_path, &block)
+    callback = get_callback(proxy, key_path)
+    # Wrap existing callback, calling the provided block before it
+    # Multiple calls to .observe will create a pyramid of callbacks, calling the observers before
+    # eventually calling the existing callback
+    new_callback = proc do |*args|
+      block.call(*args)
+      callback.call(*args)
+    end
+    set_callback(proxy, key_path, new_callback)
+    proxy
+  end
+
+  # Wraps the existing callback with your block
+  #
+  # Use case: Get full control of the existing proc while running custom code
+  #
+  # @param [MockProxy] proxy existing proxy
+  # @param [String, Array<String>] key_path the chain of methods or key path. Can be a
+  #        dot delimited key path or an array of method names as strings or symbols
+  # @yieldparam [*args, &block] args, original callback
+  # @yieldreturn [optional]
+  # @return [MockProxy] the original proxy object
+  def self.wrap(proxy, key_path, &block)
+    callback = get_callback(proxy, key_path)
+    # Wrap existing callback, calling the provided block before it
+    # Multiple calls to .observe will create a pyramid of callbacks, calling the observers before
+    # eventually calling the existing callback
+    new_callback = proc do |*args|
+      block.call(*args, &callback)
+    end
+    set_callback(proxy, key_path, new_callback)
+    proxy
+  end
+
+  # @private
+  # @param [MockProxy] proxy existing proxy
+  # @param [String, Array<String>] key_path the chain of methods or key path. Can be a
+  #        dot delimited key path or an array of method names as strings or symbols
+  # @return [Proc] if proc found at key path
+  # @raise [ArgumentError] if proc not found or hash found at key path
+  def self.get_callback(proxy, key_path)
+    key_paths = key_path.is_a?(Array) ? key_path.map(&:to_s) :key_path.split('.')
+    existing_callback_hash = proxy.instance_variable_get('@callback_hash')
+    callback = key_paths.reduce(existing_callback_hash) do |callback_hash, key|
+      if callback_hash && callback_hash[key]
+        callback_hash[key]
+      else
+        fail ArgumentError, "The existing callback tree does not contain the full key path you provided. We stopped at #{key} and the callback tree looks like this: #{existing_callback_hash}"
+      end
+    end
+    if callback.is_a?(Proc)
+      callback
+    else
+      fail ArgumentError, "The existing callback tree contains the full key path you provided but continues going. If you want to shorten the callback tree, use MockProxy.update. The callback tree looks like this: #{existing_callback_hash}"
+    end
+  end
+  private_class_method :get_callback
+
+  # @private
+  # @param [MockProxy] proxy existing proxy
+  # @param [String, Array<String>] key_path the chain of methods or key path. Can be a
+  #        dot delimited key path or an array of method names as strings or symbols
+  # @param [Proc] proc the new proc to replace the existing proc
+  # @return [MockProxy] if proc existed at key path
+  # @raise [ArgumentError] if proc not found or hash found at key path
+  def self.set_callback(proxy, key_path, proc)
+    key_paths = key_path.is_a?(Array) ? key_path.map(&:to_s) :key_path.split('.')
+    copied_callback_hash = proxy.instance_variable_get('@callback_hash').clone
+    key_paths.reduce(copied_callback_hash) do |callback_hash, key|
+      if !callback_hash || !callback_hash[key]
+        fail ArgumentError, "The existing callback tree does not contain the full key path you provided. We stopped at #{key} and the callback tree looks like this: #{existing_callback_hash}"
+      end
+      if callback_hash[key].is_a?(Proc)
+        callback_hash[key] = proc
+      else
+        callback_hash[key]
+      end
+    end
+    proxy.instance_variable_set('@callback_hash', copied_callback_hash)
+  end
+  private_class_method :set_callback
+
+  # Retrieve the existing callback or callback tree at the specified key path
+  #
+  # NOTE: We freeze the hash so you cannot modify it
+  #
+  # Use case: Retrieve proc to mock or retrieve hash to reflect on what is currently being stubbed
+  #
+  # @param [MockProxy] proxy existing proxy
+  # @param [String, Array<String>] key_path the chain of methods or key path. Can be a
+  #        dot delimited key path or an array of method names as strings or symbols
+  # @return [Block, Hash]
+  def self.get(proxy, key_path)
+
+  end
+
+  # @param [Hash] callback_hash the tree of chained method calls
+  def initialize(callback_hash)
+    @callback_hash = callback_hash.deep_stringify_keys.freeze
+  end
+
+  # @private
+  def method_missing(name, *args, &block)
+    current = @callback_hash[name.to_s]
+    if current.is_a?(Proc)
+      current.call(*args, &block)
+    else
+      if !current.is_a?(Proc) && !current.is_a?(Hash)
+        fail "Missing method #{name}. Please add this definition to your mock proxy"
+      end
+      MockProxy.new(current.freeze)
+    end
+  end
+end

data/lib/mock_proxy/version.rb

@@ -0,0 +1,4 @@
+class MockProxy
+  # The version number
+  VERSION = '0.1.0'
+end

data/mock_proxy.gemspec

@@ -0,0 +1,61 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mock_proxy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mock_proxy"
+  spec.version       = MockProxy::VERSION
+  spec.authors       = ["matrinox"]
+  spec.email         = ["geofflee25@gmail.com"]
+
+  spec.summary       = "A proxy that can be used to stub method chains and more!"
+  spec.description   = "Remember when RSpec had stub_chain? They removed it for good reasons but sometimes you just need it.
+  Well, here it is, a proxy object. It doesn't actually mock anything for you (the name is just catchy) so you need to do that.
+  But that actually comes with a lot of benefits:
+  1) It's compatable with any testing framework
+  2) You can use it for purposes other than testing, e.g. prototyping, code stubs
+  3) Flexibility in how you use it without overloading the number of methods you have to remember
+
+  Here's an example usage:
+  let(:model_proxy) do
+    MockProxy.new(email_client: {
+      create_email: {
+        receive: proc {}
+      }
+    })
+  end
+  before { allow(Model).to receive(:new).and_return model_proxy }
+  it 'should call receive' do
+    proc = MockProxy.get(model_proxy, 'email_client.create_email.receive')
+    expect(proc).to receive(:call)
+    run_system_under_test
+    MockProxy.update(mock_proxy, 'email_client.create_email.validate!') { true }
+    MockProxy.observe(mock_proxy, 'email_client.create_email.send') do |to|
+      expect(to).to eq 'stop@emailing.me'
+    end
+    run_system_under_test2
+  end
+
+  As you can see, the proc - which ends the proxy by calling the proc - can be used for anything. You can spy on the
+  call count and arguments, mock methods, or just stub out code you don't want executed. Because it doesn't make any
+  assumptions, it becomes very flexible. Simple, yet powerful, it's uses are infinite. Enjoy"
+  spec.homepage      = "https://github.com/matrinox/MockProxy"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: mock_proxy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- matrinox
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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'
+description: |-
+  Remember when RSpec had stub_chain? They removed it for good reasons but sometimes you just need it.
+    Well, here it is, a proxy object. It doesn't actually mock anything for you (the name is just catchy) so you need to do that.
+    But that actually comes with a lot of benefits:
+    1) It's compatable with any testing framework
+    2) You can use it for purposes other than testing, e.g. prototyping, code stubs
+    3) Flexibility in how you use it without overloading the number of methods you have to remember
+
+    Here's an example usage:
+    let(:model_proxy) do
+      MockProxy.new(email_client: {
+        create_email: {
+          receive: proc {}
+        }
+      })
+    end
+    before { allow(Model).to receive(:new).and_return model_proxy }
+    it 'should call receive' do
+      proc = MockProxy.get(model_proxy, 'email_client.create_email.receive')
+      expect(proc).to receive(:call)
+      run_system_under_test
+      MockProxy.update(mock_proxy, 'email_client.create_email.validate!') { true }
+      MockProxy.observe(mock_proxy, 'email_client.create_email.send') do |to|
+        expect(to).to eq 'stop@emailing.me'
+      end
+      run_system_under_test2
+    end
+
+    As you can see, the proc - which ends the proxy by calling the proc - can be used for anything. You can spy on the
+    call count and arguments, mock methods, or just stub out code you don't want executed. Because it doesn't make any
+    assumptions, it becomes very flexible. Simple, yet powerful, it's uses are infinite. Enjoy
+email:
+- geofflee25@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mock_proxy.rb
+- lib/mock_proxy/version.rb
+- mock_proxy.gemspec
+homepage: https://github.com/matrinox/MockProxy
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A proxy that can be used to stub method chains and more!
+test_files: []