quacky 0.2.2 → 0.2.3

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/lib/quacky.rb

@@ -1,2 +1,7 @@
 require 'quacky/quacky'
+require 'quacky/stub'
+require 'quacky/double'
+require 'quacky/expectations'
+require 'quacky/duck_type_verifier'
 require 'quacky/rspec_setup'
+require 'quacky/minitest_setup'

data/lib/quacky/double.rb

@@ -0,0 +1,14 @@
+module Quacky
+  class Double
+    def initialize(name)
+      @name = name
+    end
+
+    def inspect
+      "<Quacky::Double :#{name}>"
+    end
+
+    private
+    attr_reader :name
+  end
+end

data/lib/quacky/duck_type_verifier.rb

@@ -0,0 +1,39 @@
+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, "definitions of method `#{method.name}` differ in parameters accepted."
+        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

data/lib/quacky/expectations.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/module/aliasing'
+
+module Quacky
+  class NoMethodError < RuntimeError; end
+
+  module Expectations
+    def quacky_stub method_name
+      setup_expectation method_name
+    end
+
+    def should_receive method_name
+      quacky_stub(method_name).tap do |expectation|
+        Quacky.expectations << expectation
+      end
+    end
+
+    private
+
+    def quacky_expectations
+      @expectations ||= {}
+    end
+
+    def setup_expectation method_name
+      method_name = method_name.to_sym
+      raise Quacky::NoMethodError unless respond_to? method_name
+
+      quacky_expectations[method_name] = Stub.new(public_method(method_name))
+      sanitized_name, postpend = parse_method_name method_name
+
+      eval <<-EVAL
+        class << self
+          define_method("#{sanitized_name}_with_expectation#{postpend}") do |*args|
+            quacky_expectations[:#{method_name}].call *args
+          end
+
+          alias_method_chain :#{method_name}, :expectation
+        end
+      EVAL
+
+      quacky_expectations[method_name]
+    end
+
+    def parse_method_name method_name
+      method_name = method_name.to_s
+      eol_matcher = /([\!\?])$/
+      method_name_postpend = method_name.to_s.match(eol_matcher) ? $1 : ""
+      method_name_minus_postpend = method_name.to_s.gsub eol_matcher, ""
+      [method_name_minus_postpend, method_name_postpend]
+    end
+  end
+end

data/lib/quacky/minitest_setup.rb

@@ -0,0 +1,32 @@
+if defined? MiniTest
+  module Quacky
+    module MiniTest
+      module Matchers
+        def assert_quacks_like object, *modules
+          modules.each do |a_module|
+            Quacky::DuckTypeVerifier.new(a_module).verify! object
+          end
+        end
+      end
+    end
+  end
+
+  module Quacky
+    alias :mock :double
+    alias :class_mock :class_double
+
+    module Expectations
+      def expect method_name, return_value, with=[]
+        should_receive(method_name).and_return(return_value).tap do |expectation|
+          expectation.with(*with) unless with.empty?
+        end
+      end
+
+      def stub method_name, return_value, with=[]
+        quacky_stub(method_name).and_return(return_value).tap do |expectation|
+          expectation.with(*with) unless with.empty?
+        end
+      end
+    end
+  end
+end

data/lib/quacky/quacky.rb

@@ -1,66 +1,6 @@
-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, "definitions of method `#{method.name}` differ in parameters accepted."
-        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
-    def initialize(name)
-      @name = name
-    end
-
-    def inspect
-      "<Quacky::Double :#{name}>"
-    end
-
-    private
-    attr_reader :name
-  end
-
-  class NoMethodError < RuntimeError;             end
-  class MethodSignatureMismatch < ArgumentError;  end
-  class UnexpectedArguments < ArgumentError;      end
-  class UnsatisfiedExpectation < ArgumentError;      end
-
   def expectations
     @expectations ||= []
   end
@@ -69,128 +9,12 @@ module Quacky
     @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, "Expected `#{@method.name}` to be called.")
-      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.map(&:inspect).join ", "}. expected: #{expected_args.map(&:inspect).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, "#{@method.receiver}##{@method.name} was called with the #{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 quacky_expectations
-      @expectations ||= {}
-    end
-
-    def setup_expectation method_name
-      method_name = method_name.to_sym
-      raise Quacky::NoMethodError unless respond_to? method_name
-
-      quacky_expectations[method_name] = Stub.new(public_method(method_name))
-      sanitized_name, postpend = parse_method_name method_name
-
-      eval <<-EVAL
-        class << self
-          define_method("#{sanitized_name}_with_expectation#{postpend}") do |*args|
-            quacky_expectations[:#{method_name}].call *args
-          end
-
-          alias_method_chain :#{method_name}, :expectation
-        end
-      EVAL
-
-      quacky_expectations[method_name]
-    end
-
-    def parse_method_name method_name
-      method_name = method_name.to_s
-      eol_matcher = /([\!\?])$/
-      method_name_postpend = method_name.to_s.match(eol_matcher) ? $1 : ""
-      method_name_minus_postpend = method_name.to_s.gsub eol_matcher, ""
-      [method_name_minus_postpend, method_name_postpend]
-    end
-  end
-
   def double(name, *duck_types)
     Double.new(name).tap do |object|
       duck_types.each do |duck_type|
         object.extend duck_type
       end
-      object.extend Quacky::Expectations
+      object.extend Expectations
     end
   end
 
@@ -216,6 +40,7 @@ module Quacky
     class_modules, instance_modules = parse_class_double_options options
 
     Class.new do
+      extend Expectations
       extend ClassInspect
       include InstanceInspect
       name_class_double name

data/lib/quacky/rspec_setup.rb

@@ -2,6 +2,12 @@ if defined? RSpec
   require 'rspec'
   require 'rspec/matchers'
 
+  module Quacky
+    module Expectations
+      alias :stub :quacky_stub
+    end
+  end
+
   RSpec::Matchers.define :quack_like do |*expected_duck_types|
     expected_duck_types.each do |expected_duck_type|
       match do |actual|

data/lib/quacky/stub.rb

@@ -0,0 +1,76 @@
+module Quacky
+  class UnexpectedArguments < ArgumentError;    end
+  class UnsatisfiedExpectation < ArgumentError; end
+  class MethodSignatureMismatch < ArgumentError;  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
+      self
+    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, "Expected `#{@method.name}` to be called.")
+      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.map(&:inspect).join ", "}. expected: #{expected_args.map(&:inspect).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, "#{@method.receiver}##{@method.name} was called with the #{e.message}"
+      end
+    end
+  end
+end

data/spec/lib/double_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Quacky::Double do
+  describe ".inspect" do
+    it "should be formatted like `<Quacky::Double :<double_name>>`" do
+      Quacky::Double.new(:test).inspect.should == "<Quacky::Double :test>"
+    end
+  end
+end

data/spec/lib/duck_type_verifier_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+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, "definitions of method `quack` differ in parameters accepted." 
+        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

data/spec/lib/expectations_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe "Quacky::Double created with Quacky.double" do
+  let(:q_double) { Quacky.double :duck, 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.quacky_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.quacky_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.quacky_stub(:duck!)
+
+      argument = double :argument
+      expectation.should_receive(:call).with argument
+      q_double.duck!(argument)
+    end
+
+    it "should support methods ending in !, ?, and regular letters" do
+      q_double = Quacky.double(:quacky_double, Module.new do 
+        def bang!; end
+        def question?; end
+        def regular; end
+      end)
+
+      q_double.should_receive(:bang!).and_return "bang"
+      q_double.should_receive(:question?).and_return "question"
+      q_double.should_receive(:regular).and_return "regular"
+
+      q_double.bang!.should == "bang"
+      q_double.question?.should == "question"
+      q_double.regular.should == "regular"
+    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

data/spec/lib/quacky/minitest_setup_spec.rb

@@ -0,0 +1,14 @@
+module MiniTest; end
+
+require_relative '../../../lib/quacky/minitest_setup'
+require_relative '../../../lib/quacky/quacky'
+
+describe Quacky do
+  describe ".mock" do
+    it "should be an alias for .double" do
+      Quacky.public_method(:mock).should == Quacky.public_method(:double)
+    end
+  end
+end
+
+Object.send(:remove_const, :MiniTest)

data/spec/lib/quacky_spec.rb

@@ -1,65 +1,6 @@
-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, "definitions of method `quack` differ in parameters accepted." 
-        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
+require 'spec_helper'
 
 describe Quacky do
-
   describe ".clear_expectations!" do
     it "should reset .expecatations to an empty collection" do
       Quacky.expectations.should be_empty
@@ -132,154 +73,4 @@ describe Quacky do
       it_behaves_like "quacky class double"
     end
   end
-
-  describe Quacky::Double do
-    let(:q_double) { Quacky.double :duck, Duck }
-    let(:expectation) { double(:expectation) }
-
-    describe ".inspect" do
-      it "should be formatted like `<Quacky::Double :<double_name>>`" do
-        Quacky::Double.new(:test).inspect.should == "<Quacky::Double :test>"
-      end
-    end
-
-    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
-
-      it "should support methods ending in !, ?, and regular letters" do
-        q_double = Quacky.double(:quacky_double, Module.new do 
-          def bang!; end
-          def question?; end
-          def regular; end
-        end)
-
-        q_double.should_receive(:bang!).and_return "bang"
-        q_double.should_receive(:question?).and_return "question"
-        q_double.should_receive(:regular).and_return "regular"
-
-        q_double.bang!.should == "bang"
-        q_double.question?.should == "question"
-        q_double.regular.should == "regular"
-      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, "#{object.inspect}#duck! was called with the wrong number of arguments (3 for 1)"
-        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, "Expected `duck!` to be called." }
-        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

data/spec/lib/stub_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+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, "#{object.inspect}#duck! was called with the wrong number of arguments (3 for 1)"
+        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, "Expected `duck!` to be called." }
+        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

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift '.'
+require 'quacky/quacky'
+require 'quacky/stub'
+require 'quacky/double'
+require 'quacky/expectations'
+require 'quacky/duck_type_verifier'
+
+module Duck
+  def duck! arg; end
+end
+
+RSpec.configure do |c|
+  c.before do
+    Quacky.clear_expectations!
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quacky
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-03 00:00:00.000000000 Z
+date: 2012-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70131385524940 !ruby/object:Gem::Requirement
+  requirement: &70238192808080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.2.5
   type: :runtime
   prerelease: false
-  version_requirements: *70131385524940
+  version_requirements: *70238192808080
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70131385524500 !ruby/object:Gem::Requirement
+  requirement: &70238192807680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131385524500
+  version_requirements: *70238192807680
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70131385391320 !ruby/object:Gem::Requirement
+  requirement: &70238192805940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131385391320
+  version_requirements: *70238192805940
 - !ruby/object:Gem::Dependency
   name: specdown
-  requirement: &70131385390880 !ruby/object:Gem::Requirement
+  requirement: &70238192805520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131385390880
+  version_requirements: *70238192805520
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70131385390460 !ruby/object:Gem::Requirement
+  requirement: &70238192805080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,18 +65,29 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131385390460
+  version_requirements: *70238192805080
 description: 
 email: moonmaster9000@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/quacky/double.rb
+- lib/quacky/duck_type_verifier.rb
+- lib/quacky/expectations.rb
+- lib/quacky/minitest_setup.rb
 - lib/quacky/quacky.rb
 - lib/quacky/rspec_setup.rb
+- lib/quacky/stub.rb
 - lib/quacky.rb
 - VERSION
+- spec/lib/double_spec.rb
+- spec/lib/duck_type_verifier_spec.rb
+- spec/lib/expectations_spec.rb
+- spec/lib/quacky/minitest_setup_spec.rb
 - spec/lib/quacky_spec.rb
+- spec/lib/stub_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/moonmaster9000/quacky
 licenses: []
 post_install_message: 
@@ -102,4 +113,10 @@ signing_key:
 specification_version: 3
 summary: Ensure your test doubles quack like the real thing.
 test_files:
+- spec/lib/double_spec.rb
+- spec/lib/duck_type_verifier_spec.rb
+- spec/lib/expectations_spec.rb
+- spec/lib/quacky/minitest_setup_spec.rb
 - spec/lib/quacky_spec.rb
+- spec/lib/stub_spec.rb
+- spec/spec_helper.rb