adequack 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6cbd122c01215eb0d14f941fc68ecb1f147bfe3b
+  data.tar.gz: 1dbcf7bc56ae09478d86f0ae47b6fe4f4db6040d
+SHA512:
+  metadata.gz: 93f3f69ffbfaf2c76ca608bcc3bf4d1c51e652f601e203d08f59b601dbe2d86b11669b55237cda7671dd800783d262ce28bde0df55fc66834d6750ce4e7ec49a
+  data.tar.gz: 13c964cd0d085001f92330d13468b149c49c2a820f756ca4ff2e571aaf369cdddad0057b41fe7266ae811129aac7e81b43f6386173b4e2540fc511f46fd6e75b

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-version
+.DS_Store
+*.sublime-*
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ilya Zayats
+
+MIT License
+
+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,229 @@
+# Adequack
+
+Everyone likes isolation testing now. And when you do it then you stubbing and mocking a lot.  
+But the main concern when you use this approach is that you stubs will be out of sync with the
+real objects.   
+Adequack addresses this issue.
+
+## Problem 1. Missing methods
+
+Let's dive into this toy code:
+```ruby
+class Dog
+  def eat_food
+    puts "delicious!"
+  end
+end
+
+class Owner
+  def initialize(dog)
+    @dog = dog
+  end
+  
+  def feed_animal
+    @dog.eat_food
+  end
+end
+```
+
+and we are going to spec things out:
+
+```ruby
+describe Owner do
+  let(:dog) { double }
+  subject { described_class.new dog }
+  
+  it "feeds animal" do
+    dog.should_receive(:eat_food)
+    subject.feed_animal
+  end
+end
+```
+
+And everything will pass.
+
+But let's imagine that a big dog food brand will come to us and pay a lot for branding:
+
+```ruby
+class Dog
+  def eat_chappi
+    puts "delicious chappi dog food! I will recommend it to all my buddies!"
+  end
+end
+```
+
+So we've changed our code and we should run the tests:
+
+```
+.
+
+Finished in 0.00051 seconds
+1 example, 0 failures
+```
+
+You are very confident about your test suite and you decide to deploy the changes to production.  
+After that big dog food brand will take that payment away because of:
+
+```ruby
+undefined method `eat_food' for #<Dog:0x99250dc>
+```
+
+### Solving this with adequack
+
+Let's replay the story again but with a happy end:
+
+```ruby
+require 'adequack'
+
+module DogInterface
+  def eat_food; end 
+end
+
+describe Dog do
+  subject { described_class }
+  it { should be_adequack_to DogInterface }
+end
+
+describe Owner do
+  let(:dog) { adequack_double double, DogInterface }
+  subject { described_class.new dog }
+  
+  it "feeds animal" do
+    dog.should_receive(:eat_food)
+    subject.feed_animal
+  end
+end
+```
+
+and we will have 2 passing dots:
+
+```
+.
+
+Finished in 0.00128 seconds
+2 examples, 0 failures
+```
+
+We should validate not only our mocks, but also that our core object really responds to the interface.  
+Use `be_adequack_to` matcher with a core class as an argument.
+
+And to create doubles and stubs use `adequack_double` helper. This will return a proxy object that  
+will translate all calls to the object that you'll pass first (plain `double` at the example).  
+
+Let's replay our changes again:
+```ruby
+class Dog
+  def eat_chappi
+    puts "delicious chappi dog food! I will recommend it to all my buddies!"
+  end
+end
+```
+
+and run our specs:
+```
+F.
+
+Failures:
+
+  1) Dog 
+     Failure/Error: it { should be_adequack_to DogInterface }
+     Adequack::InterfaceImplementationError:
+       object does not respond to 'eat_food' method
+
+```
+
+Here we gon an error at the dog spec, because our core object falls out of sync with our interface.  
+But big sponsor is paying, so we will change the interface too:
+
+```ruby
+module DogInterface
+  def eat_chappi; end 
+end
+```
+
+and rerun our tests:
+```
+.F
+
+Failures:
+
+  1) Owner feeds animal
+     Failure/Error: dog.should_receive(:eat_food)
+     Adequack::InterfaceImplementationError:
+       trying to stub nonexistent method
+
+```
+
+Another failure, we should change our stubs too! 
+
+And at this time we will ger our payment fully. 
+
+## Problem 2. Method signatures
+
+But what if method is there, but signature is changed?
+
+```ruby
+class Dog
+  def eat_food(brand)
+    puts "delicious #{brand} dog food! I will recommend it to all my buddies!"
+  end
+end
+```
+
+and our specs will tell you about that:
+
+```
+.F
+
+Failures:
+
+  1) Owner feeds animal
+     Failure/Error: @dog.eat_food
+     Adequack::InterfaceImplementationError:
+       definition of method 'eat_food' differs in parameters accepted.
+```
+
+## Installation
+
+Just install the gem
+```
+gem install adequack
+```
+
+and require it when you need it: `require 'adequack'`
+
+After that your rspec tests will have `be_adequack_to` matcher and `adequack_double` helper.
+
+## Usage
+
+TODO: Write full API definition here
+
+## Contributing
+
+This library is considered "experimental" quality.  
+Your feedback would be very welcome! Pull requests are great, but issues are good too.
+
+## Licence 
+
+Copyright (c) 2013 Ilya Zayats
+
+MIT License
+
+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/Rakefile

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

data/adequack.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'adequack/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "adequack"
+  spec.version       = Adequack::VERSION
+  spec.authors       = ["Ilya Zayats"]
+  spec.email         = ["somebody32@gmail.com"]
+  spec.description   = %q{Be sure that your mocks are adequate}
+  spec.summary       = %q{Be sure that your mocks are adequate}
+  spec.homepage      = "https://github.com/Somebody32/adequack"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rspec", "~> 2.13"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/adequack/core.rb

@@ -0,0 +1,43 @@
+module Adequack
+  class Core
+
+    def self.implements(object, interface)
+      new(object, interface).send(:validate_ducktype)
+    end
+
+    private
+
+    def initialize(duck, interface)
+      self.duck = duck
+      self.interface = interface
+    end
+
+    def validate_ducktype
+      check_method_implementation(get_methods interface.public_methods )
+      check_method_implementation(
+        get_methods(interface.public_instance_methods), true
+      )
+    end
+
+    def check_method_implementation(methods, instance = false)
+      methods.each do |method|
+        if instance
+          name = method
+          defined = duck.method_defined?(method)
+        else
+          name = "self.#{method}"
+          defined = duck.respond_to?(method)
+        end
+
+        raise InterfaceImplementationError,
+          "object does not respond to '#{name}' method" unless defined
+      end
+    end
+
+    attr_accessor :duck, :interface
+
+    def get_methods(methods)
+      methods - Object.methods
+    end
+  end
+end

data/lib/adequack/integration/rspec_setup.rb

@@ -0,0 +1,21 @@
+module Adequack
+  module Integration
+    module RSpecHelpers
+      def adequack_double(object, interface)
+        Adequack.double object, interface
+      end
+    end
+  end
+end
+
+RSpec::Matchers.define :be_adequack_to do |*expected_duck_types|
+  expected_duck_types.each do |expected_duck_type|
+    match do |actual|
+      Adequack.check_implementation(actual, expected_duck_type)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Adequack::Integration::RSpecHelpers
+end

data/lib/adequack/proxy.rb

@@ -0,0 +1,86 @@
+module Adequack
+  class Proxy
+
+    def initialize(target, interface)
+      self.target = target
+      self.interface = interface
+    end
+
+    def stub(message_or_hash, opts = {}, &block)
+      methods =
+        Hash === message_or_hash ? message_or_hash.keys : [message_or_hash]
+
+      methods.each { |m| check_method_existence m }
+
+      target.stub(message_or_hash, opts, &block)
+    end
+
+    alias_method :stub!, :stub
+
+    def stub_chain(*chain, &blk)
+      method =
+        String === chain.first ? chain.first.split(".").first : chain.first
+
+      check_method_existence method
+
+      target.stub_chain(*chain, &blk)
+    end
+
+    def should_receive(message, opts = {}, &block)
+      check_method_existence message
+
+      target.should_receive(message, opts, &block)
+    end
+
+    private
+
+    attr_accessor :target, :interface
+
+    def method_missing(name, *args, &block)
+      check_interface_implementation name, args
+      target.send name, *args, &block
+    end
+
+    def check_interface_implementation(name, args)
+      check_interface_signature(name, args) if method_in_interface?(name)
+    end
+
+    def check_interface_signature(name, args)
+      target_method = duck_type_methods.select { |m| m.name == name }.first
+      req_m = target_method.parameters.select { |m| m.first == :req }
+
+      if args.size < req_m.size
+        raise InterfaceImplementationError,
+          "definition of method '#{name}' differs in parameters accepted."
+      end
+
+      unless target_method.parameters.any? { |m| m.first == :rest }
+        opt_m = target_method.parameters.select { |m| m.first == :opt }
+
+        if args.size > (req_m.size + opt_m.size)
+          raise InterfaceImplementationError,
+            "definition of method '#{name}' differs in parameters accepted."
+        end
+      end
+    end
+
+    def check_method_existence(method)
+      unless method_in_interface? method
+        raise InterfaceImplementationError,
+          "trying to stub nonexistent method"
+      end
+    end
+
+    def method_in_interface?(method)
+      duck_type_methods.map(&:name).include? method.to_sym
+    end
+
+    def duck_type_methods
+      @duck_type_methods ||= (interface.instance_methods - Object.methods)
+      @duck_type_methods.map do |method_name|
+        interface.public_instance_method(method_name)
+      end
+    end
+  end
+end
+

data/lib/adequack/version.rb

@@ -0,0 +1,3 @@
+module Adequack
+  VERSION = "0.0.1"
+end

data/lib/adequack.rb

@@ -0,0 +1,16 @@
+require "adequack/version"
+require "adequack/core"
+require "adequack/proxy"
+require "adequack/integration/rspec_setup"
+
+module Adequack
+  InterfaceImplementationError = Class.new(::StandardError)
+
+  def self.check_implementation(duck, interface)
+    Core.implements duck, interface
+  end
+
+  def self.double(core, interface)
+    Proxy.new core, interface
+  end
+end

data/spec/adequack_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+
+describe Adequack do
+
+  let!(:interface) do
+    Class.new do
+      def self.evolutionize; end
+      def bark(what); end
+      def eat(tasty = true); end
+      def drink(what, many = true); end
+      def sleep(how_long, *places); end
+    end
+  end
+
+  before do
+    Object.send(:remove_const, :Animal) if Object.const_defined?(:Animal)
+  end
+
+  context "when checking interface implementation" do
+
+    it "passes when test class is ok" do
+      class Animal
+        def self.evolutionize; end
+        def bark(what); end
+        def eat(tasty = true); end
+        def drink(what, many = true); end
+        def sleep(how_long, *places); end
+      end
+
+      expect { described_class.check_implementation(Animal, interface) }.
+        not_to raise_error Adequack::InterfaceImplementationError
+    end
+
+    it "fails when no class method" do
+      class Animal
+        def bark(what); end
+        def eat(tasty = true); end
+        def drink(what, many = true); end
+        def sleep(how_long, *places); end
+      end
+
+      expect { described_class.check_implementation(Animal, interface) }.
+        to raise_error Adequack::InterfaceImplementationError,
+          "object does not respond to 'self.evolutionize' method"
+    end
+
+    it "will not take care about private and protected methods" do
+      class Animal
+        def bark(what); end
+      end
+
+      bad_interface = Class.new do
+        def bark(what); end
+
+        class << self
+          protected
+          def c_a; end
+        end
+
+        def self.c_b; end
+        private_class_method :c_b
+
+        protected
+        def a; end
+
+        private
+        def b; end
+      end
+
+      expect { described_class.check_implementation(Animal, bad_interface) }.
+        not_to raise_error Adequack::InterfaceImplementationError
+    end
+
+  end
+
+  context "when stubbing and mocking" do
+
+    let(:core) { double }
+    let(:subject) { Adequack.double core, interface }
+
+    it "let you stub methods that exists and return actual object" do
+      core.should_receive(:stub).with({ bark: "woof" }, {})
+      subject.stub(bark: "woof")
+    end
+
+    it "raises an error if trying to stub nonexistent method via hash" do
+      expect { subject.stub(muuuu: "hey hoo") }.
+        to raise_error Adequack::InterfaceImplementationError,
+          "trying to stub nonexistent method"
+    end
+
+    it "raises an error if trying to stub nonexistent method via message" do
+      expect { subject.stub(:muuuu) }.
+        to raise_error Adequack::InterfaceImplementationError,
+          "trying to stub nonexistent method"
+    end
+
+    it "works with chaining" do
+      core.should_receive(:stub_chain).with("bark.words")
+      subject.stub_chain("bark.words")
+    end
+
+    it "raises if chain in symbol form" do
+      expect { subject.stub_chain(:tongue, :skin) }.
+        to raise_error Adequack::InterfaceImplementationError,
+          "trying to stub nonexistent method"
+    end
+
+    it "raises if chain in string form" do
+      expect { subject.stub_chain("tongue.skin") }.
+        to raise_error Adequack::InterfaceImplementationError,
+          "trying to stub nonexistent method"
+    end
+
+    it "works with should receive too" do
+      expect { subject.should_receive(:muuuu) }.
+        to raise_error Adequack::InterfaceImplementationError,
+          "trying to stub nonexistent method"
+    end
+
+    it "tell you if you'r passing invalid arguments" do
+      expect {
+        core.should_not_receive(:bark)
+        subject.bark("woof", "not woof")
+      }.to raise_error Adequack::InterfaceImplementationError,
+        "definition of method 'bark' differs in parameters accepted."
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+module AnimalInterface
+  def self.evolutionize(from_what); end
+  def bark(what); end
+  def feed(what, many = false); end
+end
+
+class Animal
+  def initialize(name)
+    @name = name
+  end
+
+  def self.evolutionize(from_what)
+    new("next step from #{from_what}")
+  end
+
+  def bark(what)
+    puts what
+  end
+
+  def feed(what, many = false)
+    emotion = "So yammy #{what}"
+    emotion = [emotion, "I'm full up"].join(", ") if many
+
+    bark emotion
+  end
+end
+
+describe Animal do
+  subject { described_class }
+  it { should be_adequack_to AnimalInterface }
+end
+
+class Owner
+
+  def initialize(animal)
+    @animal = animal
+  end
+
+  def trick_animal
+    @animal.bark("woof")
+  end
+
+  def enormously_feed_animal
+    @animal.feed("chappy", true)
+  end
+
+end
+
+describe Owner do
+  let(:animal) { adequack_double double, AnimalInterface }
+  subject { described_class.new animal }
+
+  it "tricks animal" do
+    animal.should_receive(:bark).and_return("barked")
+    expect(subject.trick_animal).to eql "barked"
+  end
+
+  it "feeds animal" do
+    animal.should_receive(:feed).and_return("barked")
+    expect(subject.enormously_feed_animal).to eql "barked"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "adequack"

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: adequack
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ilya Zayats
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: Be sure that your mocks are adequate
+email:
+- somebody32@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- adequack.gemspec
+- lib/adequack.rb
+- lib/adequack/core.rb
+- lib/adequack/integration/rspec_setup.rb
+- lib/adequack/proxy.rb
+- lib/adequack/version.rb
+- spec/adequack_spec.rb
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Somebody32/adequack
+licenses:
+- MIT
+metadata: {}
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Be sure that your mocks are adequate
+test_files:
+- spec/adequack_spec.rb
+- spec/integration_spec.rb
+- spec/spec_helper.rb