quacky 0.0.1

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/quacky.rb

@@ -0,0 +1,2 @@
+require 'quacky/quacky'
+require 'quacky/rspec_setup'

data/lib/quacky/quacky.rb

@@ -0,0 +1,191 @@
+require 'active_support/core_ext/module/aliasing'
+
+module Quacky
+  class DuckTypeVerificationFailure < RuntimeError; end
+
+  class DuckTypeVerifier
+    def initialize duck_type
+      @duck_type = duck_type
+    end
+
+    def verify!(object)
+      duck_type_methods.each do |method|
+        raise Quacky::DuckTypeVerificationFailure, "object does not respond to `#{method.name}'" unless object.respond_to?(method.name)
+
+        target_method = object.public_method(method.name)
+        if target_method.parameters.count != method.parameters.count ||
+           target_method.parameters.map {|p| p.first } != method.parameters.map {|p| p.first}
+          raise Quacky::DuckTypeVerificationFailure, "method signatures differ"
+        end
+
+        true
+      end
+    end
+
+    private
+    attr_reader :duck_type
+
+    def duck_type_methods
+      @duck_type_methods ||= (duck_type_object.methods - Object.methods).map do |method_name|
+        @duck_type_object.public_method(method_name)
+      end
+    end
+
+    def duck_type_object
+      return @duck_type_object if @duck_type_object 
+      duck_type_class = Class.new
+      duck_type_class.send :include, duck_type
+      @duck_type_object = duck_type_class.new
+    end
+  end
+end
+
+module Quacky
+  extend self
+  class Double; end
+
+  class NoMethodError < RuntimeError;             end
+  class MethodSignatureMismatch < ArgumentError;  end
+  class UnexpectedArguments < ArgumentError;      end
+  class UnsatisfiedExpectation < ArgumentError;      end
+
+  def expectations
+    @expectations ||= []
+  end
+
+  def clear_expectations!
+    @expectations = nil
+  end
+
+  class Stub
+    def initialize method
+      @method = method
+    end
+
+    def with *args
+      @expected_args = args
+      call_through *args
+      self
+    end
+
+    def and_return value=nil, &block
+      @return_value = value
+      @return_block = block
+    end
+
+    def call *args
+      @called_args = args
+      validate_expectation
+      call_through *args
+
+      if expected_args
+        return_value if (called_args == expected_args)
+      else
+        return_value
+      end
+    end
+
+    def validate_satisfaction!
+      if expected_args 
+        if called_args == expected_args
+          true
+        else
+          raise UnsatisfiedExpectation
+        end
+      else
+        was_called? || raise(UnsatisfiedExpectation)
+      end
+    end
+
+    private
+    attr_reader :called_args, :expected_args
+
+    def was_called?
+      !!called_args
+    end
+
+    def validate_expectation
+      if expected_args && called_args != expected_args
+        raise(
+          Quacky::UnexpectedArguments, 
+          "#{@method.name} was called with unexpected arguments: #{called_args.join ", "}"
+        )
+      end
+    end
+
+    def return_value
+      return @return_value if @return_value
+      @return_block.call if @return_block
+    end
+
+    def call_through *args
+      begin
+        @method.call *args
+      rescue ArgumentError => e
+        raise Quacky::MethodSignatureMismatch, e.message
+      end
+    end
+  end
+
+  module Expectations
+    def stub method_name
+      setup_expectation method_name
+    end
+
+    def should_receive method_name
+      stub(method_name).tap do |expectation|
+        Quacky.expectations << expectation
+      end
+    end
+
+    private
+    def setup_expectation method_name
+      raise Quacky::NoMethodError unless respond_to? method_name
+      instance_variable_set "@#{method_name}_expectation", Stub.new(public_method(method_name))
+
+      eval <<-EVAL
+        class << self
+          define_method("#{method_name}_with_expectation") do |*args|
+            @#{method_name}_expectation.call *args
+          end
+
+          alias_method_chain :#{method_name}, :expectation
+        end
+      EVAL
+
+      instance_variable_get "@#{method_name}_expectation"
+    end
+  end
+
+  def double duck_type
+    Double.new.tap do |object|
+      object.extend duck_type
+      object.extend Quacky::Expectations
+    end
+  end
+
+  def class_double options
+    class_modules, instance_modules = parse_class_double_options options
+
+    Class.new do
+      class_modules.each do |class_module|
+        extend class_module
+      end
+
+      instance_modules.each do |instance_module|
+        include instance_module
+      end
+    end
+  end
+
+  private
+  def parse_class_double_options options
+    class_modules    = options.fetch :class
+    instance_modules = options.fetch :instance
+
+    class_modules    = [class_modules] unless class_modules.respond_to? :each
+    instance_modules = [instance_modules] unless instance_modules.respond_to? :each
+
+    [class_modules, instance_modules]
+  end
+end

data/lib/quacky/rspec_setup.rb

@@ -0,0 +1,19 @@
+if defined? RSpec
+  RSpec::Matchers.define :quack_like do |*expected_duck_types|
+    expected_duck_types.each do |expected_duck_type|
+      match do |actual|
+        Quacky::DuckTypeVerifier.new(expected_duck_type).verify! actual
+      end
+    end
+  end
+
+  RSpec.configure do |config|
+    config.before(:each) do
+      Quacky.clear_expectations!
+    end
+
+    config.after(:each) do
+      Quacky.expectations.map &:validate_satisfaction!
+    end
+  end
+end

data/spec/lib/quacky_spec.rb

@@ -0,0 +1,238 @@
+require_relative '../../lib/quacky/quacky'
+
+module Duck
+  def duck arg; end
+end
+
+describe Quacky::DuckTypeVerifier do
+  let(:conforming_object) do
+    Class.new do
+      def quack arg1,arg2,arg3=nil; end
+    end.new
+  end
+
+  let(:duck_type_module) do
+    Module.new do
+      def quack a,b,c=nil; end
+    end
+  end
+
+  describe "#verify!" do
+    let(:verifier) { Quacky::DuckTypeVerifier.new(duck_type_module) }
+
+    context "non-conforming objects" do
+      context "an object that doesn't even respond to the same methods" do
+        let(:non_conforming_object) do
+          Class.new.new
+        end
+
+        it "should raise a Quacky::DuckTypeVerificationFailure" do
+          expect { verifier.verify! non_conforming_object }.to raise_exception Quacky::DuckTypeVerificationFailure
+        end
+      end
+
+      context "an object that has the methods but with different parameters" do
+        let(:non_conforming_object) do
+          Class.new do
+            def quack; end
+          end.new
+        end
+
+        it "should raise a Quacky::DuckTypeVerificationFailure" do
+          expect { verifier.verify! non_conforming_object }.to raise_exception Quacky::DuckTypeVerificationFailure
+        end
+      end
+    end
+
+    context "given a conforming object" do
+      let(:conforming_object) do
+        Class.new do
+          def quack arg1,arg2,arg3=nil; end
+        end.new
+      end
+
+      it "should return true" do
+        expect { verifier.verify! conforming_object }.not_to raise_exception Quacky::DuckTypeVerificationFailure
+      end
+    end
+  end
+end
+
+describe Quacky do
+
+  describe ".clear_expectations!" do
+    it "should reset .expecatations to an empty collection" do
+      Quacky.expectations.should be_empty
+      Quacky.expectations << "foo"
+      Quacky.clear_expectations!
+      Quacky.expectations.should be_empty
+    end
+  end
+
+  describe "#double" do
+    let(:eigenclass) { class << Quacky.double(Duck); self; end }
+
+    subject { eigenclass }
+
+    its(:included_modules) { should include Duck }
+  end
+
+  describe "#class_double" do
+    let(:class_double)  { Quacky.class_double class: class_ducks, instance: instance_ducks }
+    let(:class_eigenclass) { class << class_double; self; end }
+
+    shared_examples_for "quacky class double" do
+      context "instance methods" do
+        subject { class_double }
+        its(:ancestors) { should include *instance_ducks }
+      end
+
+      context "class methods" do
+        subject { class_eigenclass }
+        its(:included_modules) { should include *class_ducks }
+      end
+    end
+
+    context "single class and instance module" do
+      let(:class_ducks)    { Module.new }
+      let(:instance_ducks) { Module.new }
+
+      it_behaves_like "quacky class double"
+    end
+
+    context "multiple class and instance modules" do
+      let(:class_ducks)      { [ Module.new, Module.new ] }
+      let(:instance_ducks)   { [ Module.new, Module.new ] }
+
+      it_behaves_like "quacky class double"
+    end
+  end
+
+  describe Quacky::Double do
+    let(:q_double) { Quacky.double Duck }
+    let(:expectation) { double(:expectation) }
+
+    describe ".stub" do
+      it "should raise an exception if the method does not already exist on the double" do
+        expect { q_double.stub("random_method_#{rand 1000000}") }.to raise_exception Quacky::NoMethodError
+      end
+
+      it "should initialize and return a new Quacky::Stub otherwise" do
+        Quacky::Stub.should_receive(:new).with(q_double.public_method(:duck)).and_return expectation
+        q_double.stub(:duck).should == expectation
+      end
+
+      it "should reroute calls to the original method to call the expectation's call method" do
+        Quacky::Stub.stub(:new).with(q_double.public_method(:duck)).and_return expectation
+        q_double.stub(:duck)
+
+        argument = double :argument
+        expectation.should_receive(:call).with argument
+        q_double.duck(argument)
+      end
+    end
+
+    describe "should_receive" do
+      it "should raise an exception if the method does not already exist on the quacky double" do
+        expect { q_double.should_receive("random_method_#{rand 1000000}") }.to raise_exception Quacky::NoMethodError
+      end
+
+      it "should initialize and return a new QuackyStub otherwise" do
+        Quacky::Stub.should_receive(:new).with(q_double.public_method(:duck)).and_return expectation
+        q_double.should_receive(:duck).should == expectation
+      end
+
+      it "should add the generated expectation to the list of required expectations" do
+        Quacky::Stub.stub(:new).with(q_double.public_method(:duck)).and_return expectation
+        q_double.should_receive(:duck)    
+        Quacky.expectations.should include expectation
+      end
+    end
+  end
+end
+
+module Quacky
+  describe "mocks" do
+    let(:object) do
+      Class.new do
+        include Duck
+      end.new
+    end
+
+    describe Stub do
+      let(:q_expectation) { Quacky::Stub.new(object.public_method(:duck)) }
+
+      describe "#with" do
+        it "should raise an exception if the original method's signature mismatches" do
+          expect { q_expectation.with 1,2,3 }.to raise_exception Quacky::MethodSignatureMismatch
+        end
+      end
+
+      describe "#and_return" do
+        context "static value" do
+          it "should return the static value when called" do
+            return_value = double :return_value
+            q_expectation.and_return return_value
+            q_expectation.call(double :argument).should == return_value
+          end
+        end
+
+        context "block return value" do
+          it "should return the value returned by the block" do
+            return_value = double :return_value
+            q_expectation.and_return { return_value }
+            q_expectation.call(double :argument).should == return_value
+          end
+        end
+      end
+
+      describe "#call" do
+        subject { q_expectation }
+
+        context "with invalid arguments" do
+          it "should raise an exception" do
+            expect{ q_expectation.call(1,2,3)}.to raise_exception Quacky::MethodSignatureMismatch
+          end
+        end
+
+        context "called with unexpected arguments" do
+          it "should raise a Quacky::UnexpectedArguments exception" do
+            q_expectation.with double(:expected_argument)
+            expect { q_expectation.call double(:unexpected_arguments) }.to raise_exception Quacky::UnexpectedArguments
+          end
+        end
+
+        context "called with expected arguments" do
+          it "should return the configured return value" do
+            q_expectation.with("foo").and_return "bar"
+            q_expectation.call("foo").should == "bar"
+          end
+        end
+      end
+
+      describe "validate_satisfaction!" do
+        subject { q_expectation.validate_satisfaction! }
+
+        context "no with expectation" do
+          before { q_expectation.call double(:argument) }
+          specify { expect { subject }.not_to raise_exception }
+        end
+
+        context "not called at all" do
+          specify { expect { subject }.to raise_exception Quacky::UnsatisfiedExpectation }
+        end
+
+        context "with expectation" do
+          let(:argument) { double :argument }
+
+          before { q_expectation.with argument }
+
+          context "called with matching argument" do
+            before { q_expectation.call argument }
+            specify { expect { subject }.not_to raise_exception }
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: quacky
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Parker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70164230670820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70164230670820
+description: 
+email: moonmaster9000@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/quacky/quacky.rb
+- lib/quacky/rspec_setup.rb
+- lib/quacky.rb
+- VERSION
+- spec/lib/quacky_spec.rb
+homepage: https://github.com/moonmaster9000/quacky
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Ensure your test doubles quack like the real thing.
+test_files:
+- spec/lib/quacky_spec.rb