gimme 0.1.8 → 0.2.0

data/spec/gimme/matchers_spec.rb

@@ -6,120 +6,121 @@ RSpec::Matchers.define :match do |expected|
   end
 end
 
-describe Gimme::Matchers do
-  class Shoopuf
-  end
-
-  class BabyShoopuf < Shoopuf
-  end
-
-  describe Matcher do
-    context "a plain, default matcher" do
-      Given(:matcher) { Gimme::Matchers::Matcher.new }
-      Then { matcher.should_not match "anything" }
+module Gimme
+  describe Matchers do
+    class Shoopuf
     end
-  end
 
-  describe Anything do
-    shared_examples_for "an anything matcher" do
-      Then { matcher.should match "anything" }
+    class BabyShoopuf < Shoopuf
     end
 
-    context "class API" do
-      it_behaves_like "an anything matcher" do
-        Given(:matcher) { Anything.new }
+    describe Matcher do
+      context "a plain, default matcher" do
+        Given(:matcher) { Matchers::Matcher.new }
+        Then { matcher.should_not match "anything" }
       end
     end
 
-    context "gimme DSL" do
-      it_behaves_like "an anything matcher" do
-        Given(:matcher) { anything }
+    describe Anything do
+      shared_examples_for "an anything matcher" do
+        Then { matcher.should match "anything" }
       end
-    end
-  end
-
-  shared_examples_for "an identity matcher" do
-    Then { matcher.should match Shoopuf.new }
-    Then { matcher.should match BabyShoopuf.new }
-  end
-
-  shared_examples_for "a restrictive matcher" do
-    Then { matcher.should_not match nil }
-    Then { matcher.should_not match "Pandas" }
-    Then { matcher.should_not match Object.new }
-    Then { matcher.should_not match Class }
-  end
-
-  shared_examples_for "a relaxed matcher" do
-    Then { matcher.should match nil }
-  end
 
+      context "class API" do
+        it_behaves_like "an anything matcher" do
+          Given(:matcher) { Anything.new }
+        end
+      end
 
-  describe IsA do
-    context "class API" do
-      Given(:matcher) { IsA.new(Shoopuf) }
-      it_behaves_like "an identity matcher"
-      it_behaves_like "a restrictive matcher"
+      context "gimme DSL" do
+        it_behaves_like "an anything matcher" do
+          Given(:matcher) { anything }
+        end
+      end
     end
 
-    context "gimme DSL" do
-      Given(:matcher) { is_a(Shoopuf) }
-      it_behaves_like "an identity matcher"
-      it_behaves_like "a restrictive matcher"
+    shared_examples_for "an identity matcher" do
+      Then { matcher.should match Shoopuf.new }
+      Then { matcher.should match BabyShoopuf.new }
     end
-  end
 
-  describe Any do
-    context "class API" do
-      Given(:matcher) { Any.new(Shoopuf) }
-      it_behaves_like "an identity matcher"
-      it_behaves_like "a relaxed matcher"
+    shared_examples_for "a restrictive matcher" do
+      Then { matcher.should_not match nil }
+      Then { matcher.should_not match "Pandas" }
+      Then { matcher.should_not match Object.new }
+      Then { matcher.should_not match Class }
     end
 
-    context "gimme DSL" do
-      Given(:matcher) { any(Shoopuf) }
-      it_behaves_like "an identity matcher"
-      it_behaves_like "a relaxed matcher"
+    shared_examples_for "a relaxed matcher" do
+      Then { matcher.should match nil }
     end
-  end
 
-  describe Gimme::Matchers::Numeric do
-    shared_examples_for "a numeric matcher" do
-      Then { matcher.should match 5 }
-      Then { matcher.should match 5.5 }
-    end
 
-    context "class API" do
-      Given(:matcher) { Gimme::Matchers::Numeric.new }
-      it_behaves_like "a numeric matcher"
-      it_behaves_like "a restrictive matcher"
-    end
+    describe IsA do
+      context "class API" do
+        Given(:matcher) { IsA.new(Shoopuf) }
+        it_behaves_like "an identity matcher"
+        it_behaves_like "a restrictive matcher"
+      end
 
-    context "gimme DSL" do
-      Given(:matcher) { numeric }
-      it_behaves_like "a numeric matcher"
-      it_behaves_like "a restrictive matcher"
+      context "gimme DSL" do
+        Given(:matcher) { is_a(Shoopuf) }
+        it_behaves_like "an identity matcher"
+        it_behaves_like "a restrictive matcher"
+      end
     end
-  end
 
-  describe Gimme::Matchers::Boolean do
-    shared_examples_for "a boolean matcher" do
-      Then { matcher.should match true }
-      Then { matcher.should match false }
-      Then { matcher.should_not match Boolean }
+    describe Any do
+      context "class API" do
+        Given(:matcher) { Any.new(Shoopuf) }
+        it_behaves_like "an identity matcher"
+        it_behaves_like "a relaxed matcher"
+      end
+
+      context "gimme DSL" do
+        Given(:matcher) { any(Shoopuf) }
+        it_behaves_like "an identity matcher"
+        it_behaves_like "a relaxed matcher"
+      end
     end
 
-    context "class API" do
-      Given(:matcher) { Gimme::Matchers::Boolean.new }
-      it_behaves_like "a boolean matcher"
-      it_behaves_like "a restrictive matcher"
+    describe Matchers::Numeric do
+      shared_examples_for "a numeric matcher" do
+        Then { matcher.should match 5 }
+        Then { matcher.should match 5.5 }
+      end
+
+      context "class API" do
+        Given(:matcher) { Matchers::Numeric.new }
+        it_behaves_like "a numeric matcher"
+        it_behaves_like "a restrictive matcher"
+      end
+
+      context "gimme DSL" do
+        Given(:matcher) { numeric }
+        it_behaves_like "a numeric matcher"
+        it_behaves_like "a restrictive matcher"
+      end
     end
 
-    context "gimme DSL" do
-      Given(:matcher) { boolean }
-      it_behaves_like "a boolean matcher"
-      it_behaves_like "a restrictive matcher"
+    describe Matchers::Boolean do
+      shared_examples_for "a boolean matcher" do
+        Then { matcher.should match true }
+        Then { matcher.should match false }
+        Then { matcher.should_not match Boolean }
+      end
+
+      context "class API" do
+        Given(:matcher) { Matchers::Boolean.new }
+        it_behaves_like "a boolean matcher"
+        it_behaves_like "a restrictive matcher"
+      end
+
+      context "gimme DSL" do
+        Given(:matcher) { boolean }
+        it_behaves_like "a boolean matcher"
+        it_behaves_like "a restrictive matcher"
+      end
     end
   end
-
 end

data/spec/gimme/resolves_methods_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+class Berry
+  def ferment
+  end
+
+  private
+
+  def grow
+  end
+end
+
+module Gimme
+  describe ResolvesMethods do
+    describe "#resolve" do
+      context "no class on the double" do
+        context "plain ol' method" do
+          subject { ResolvesMethods.new(nil,:foo,[]) }
+          Then { subject.resolve.should == :foo }
+        end
+
+        context "using send" do
+          subject { ResolvesMethods.new(nil,:send,[:foo]) }
+          Then { subject.resolve.should == :foo }
+        end
+      end
+
+      context "a class is provided" do
+        context "rigged to raise errors" do
+          context "method exists" do
+            subject { ResolvesMethods.new(Berry,:ferment,[]) }
+            Then { subject.resolve.should == :ferment }
+          end
+
+          context "method does not exist" do
+            subject { ResolvesMethods.new(Berry,:fooberry,[]) }
+            When(:invocation) { lambda { subject.resolve } }
+            Then { invocation.should raise_error NoMethodError, /may not know how to respond/ }
+          end
+
+          context "a private method" do
+            subject { ResolvesMethods.new(Berry,:grow,[]) }
+            When(:invocation) { lambda { subject.resolve } }
+            Then { invocation.should raise_error NoMethodError, /not be a great idea/ }
+          end
+
+        end
+
+        context "set up not to raise errors" do
+          context "method exists" do
+            subject { ResolvesMethods.new(Berry,:ferment,[]) }
+            When(:result) { subject.resolve(false) }
+            Then { result.should == :ferment }
+          end
+
+          context "method does not exist" do
+            subject { ResolvesMethods.new(Berry,:fooberry,[]) }
+            When(:result) { subject.resolve(false) }
+            Then { result.should == :fooberry }
+          end
+
+          context "a private methods" do
+            subject { ResolvesMethods.new(Berry,:grow,[]) }
+            When(:result) { subject.resolve(false) }
+            Then { result.should == :grow }
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/gimme/rspec_adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Gimme::RSpecAdapter
+  describe "subject" do
+    Then { setup_mocks_for_rspec }
+    Then { verify_mocks_for_rspec }
+
+    describe "#teardown_mocks_for_rspec" do
+      # Given { spy_on(Gimme).reset }
+      When { RSpecAdapter.teardown_mocks_for_rspec }
+      # Then { verify(Gimme).reset }
+    end
+  end
+end

data/spec/gimme/shared_examples/shared_gives_examples.rb

@@ -0,0 +1,34 @@
+shared_examples_for "a normal stubbing" do
+  describe "stubbing an existing method" do
+    context "no args" do
+      When { gives.nibble() { "nom" } }
+      Then { subject.nibble.should == "nom" }
+    end
+
+    context "with args" do
+      When { gives.eat("carrot") { "crunch" } }
+      Then { subject.eat("carrot").should == "crunch" }
+      Then { subject.eat("apple").should == nil }
+        # Then { lambda{ subject.eat }.should raise_error ArgumentError } # <PENDING
+    end
+
+    context "with arg matchers" do
+      When { gives.eat(is_a(String)) { "yum" } }
+      Then { subject.eat("fooberry").should == "yum" }
+      Then { subject.eat(15).should == nil }
+    end
+  end
+
+  describe "stubbing a non-existent method" do
+    When(:stubbing) {  lambda { gives.bark { "woof" } } }
+    Then { stubbing.should raise_error NoMethodError  }
+  end
+end
+
+shared_examples_for "an overridden stubbing" do
+  context "configured to _not_ raise an error when stubbed method does not exist" do
+    Given { gives.raises_no_method_error =false }
+    When { gives.bark { "woof" } }
+    Then { subject.bark.should == "woof" }
+  end
+end

data/spec/gimme/test_double_spec.rb

@@ -1,25 +1,27 @@
 require 'spec_helper'
 
-describe Gimme::TestDouble do
-  class MassiveDamage
-    def boom
-      :asplode
+module Gimme
+  describe TestDouble do
+    class MassiveDamage
+      def boom
+        :asplode
+      end
     end
-  end
 
-  describe "#gimme_next" do
-    Given(:test_double) { gimme_next(MassiveDamage) }
-    Given(:subject) { MassiveDamage.new }
+    describe "#gimme_next" do
+      Given(:test_double) { gimme_next(MassiveDamage) }
+      Given(:subject) { MassiveDamage.new }
 
-    Given { give(test_double).boom { :kaboom } }
-    When(:result) { subject.boom }
-    Then { result.should == :kaboom }
+      Given { give(test_double).boom { :kaboom } }
+      When(:result) { subject.boom }
+      Then { result.should == :kaboom }
 
-    context "subsequent uses" do
-      Given(:next_subject) { MassiveDamage.new }
-      When(:next_result) { next_subject.boom }
-      Then { next_result.should == :asplode }
+      context "subsequent uses" do
+        Given(:next_subject) { MassiveDamage.new }
+        When(:next_result) { next_subject.boom }
+        Then { next_result.should == :asplode }
+      end
     end
-  end
 
+  end
 end

data/spec/gimme/verifies_spec.rb

@@ -1,120 +1,121 @@
 require 'spec_helper'
 
-describe Gimme::Verifies do
-  class Natto
-    def ferment(beans=nil,time=nil)
-    end
+class Natto
+  def ferment(beans=nil,time=nil)
   end
-  Given(:test_double) { gimme(Natto) }
+end
 
-  shared_examples_for "a verifier" do
+module Gimme
+  describe Verifies do
 
-    context "invoked once when expected once" do
-      Given { test_double.ferment }
-      When(:result) { lambda { verifier.ferment } }
-      Then { result.should_not raise_error }
-    end
+    Given(:test_double) { gimme(Natto) }
 
-    context "never invoked" do
-      When(:result) { lambda { verifier.ferment } }
-      Then { result.should raise_error Errors::VerificationFailedError }
-      Then do result.should raise_error Errors::VerificationFailedError,
-        "expected Natto#ferment to have been called with arguments #{[]}\n"+
-        "  but was never called"
+    shared_examples_for "a verifier" do
+
+      context "invoked once when expected once" do
+        Given { test_double.ferment }
+        When(:result) { lambda { verifier.ferment } }
+        Then { result.should_not raise_error }
       end
-    end
 
-    context "invoked with incorrect args" do
-      Given { test_double.ferment(5) }
-      When(:result) { lambda { verifier.ferment(4) } }
-      Then do result.should raise_error Errors::VerificationFailedError,
-        "expected Natto#ferment to have been called with arguments #{[4]}\n"+
-        "  was actually called 1 times with arguments #{[5]}"
+      context "never invoked" do
+        When(:result) { lambda { verifier.ferment } }
+        Then { result.should raise_error Errors::VerificationFailedError }
+        Then do result.should raise_error Errors::VerificationFailedError,
+          "expected Natto#ferment to have been called with arguments #{[]}\n"+
+          "  but was never called"
+        end
       end
-    end
 
-    context "invoked incorrectly a whole bunch" do
-      Given { test_double.ferment(5) }
-      Given { test_double.ferment(5) }
-      Given { test_double.ferment(3) }
-      When(:result) { lambda { verifier.ferment(4) } }
-      Then do result.should raise_error Errors::VerificationFailedError,
-        /.*  was actually called 2 times with arguments #{Regexp.escape([5].to_s)}.*/m
+      context "invoked with incorrect args" do
+        Given { test_double.ferment(5) }
+        When(:result) { lambda { verifier.ferment(4) } }
+        Then do result.should raise_error Errors::VerificationFailedError,
+          "expected Natto#ferment to have been called with arguments #{[4]}\n"+
+          "  was actually called 1 times with arguments #{[5]}"
+        end
       end
-      Then do result.should raise_error Errors::VerificationFailedError,
-        /.*  was actually called 1 times with arguments #{Regexp.escape([3].to_s)}.*/m
+
+      context "invoked incorrectly a whole bunch" do
+        Given { test_double.ferment(5) }
+        Given { test_double.ferment(5) }
+        Given { test_double.ferment(3) }
+        When(:result) { lambda { verifier.ferment(4) } }
+        Then do result.should raise_error Errors::VerificationFailedError,
+          /.*  was actually called 2 times with arguments #{Regexp.escape([5].to_s)}.*/m
+        end
+        Then do result.should raise_error Errors::VerificationFailedError,
+          /.*  was actually called 1 times with arguments #{Regexp.escape([3].to_s)}.*/m
+        end
       end
-    end
 
-    context "invoked too few times" do
-      Given(:verifier) { Verifies.new(test_double,3) }
-      Given { 2.times { test_double.ferment } }
-      When(:result) { lambda { verifier.ferment } }
-      Then { result.should raise_error Errors::VerificationFailedError }
-    end
+      context "invoked too few times" do
+        Given(:verifier) { Verifies.new(test_double,3) }
+        Given { 2.times { test_double.ferment } }
+        When(:result) { lambda { verifier.ferment } }
+        Then { result.should raise_error Errors::VerificationFailedError }
+      end
 
-    context "juggling multiple verifiers for the same method" do
-      Given(:multi_verifier) { Verifies.new(test_double,2) }
-      Given { test_double.ferment(:panda,:sauce) }
-      Given { 2.times { test_double.ferment(2,3) } }
-      When(:result) do
-        lambda do
-          multi_verifier.ferment(2,3)
-          verifier.ferment(:panda,:sauce)
+      context "juggling multiple verifiers for the same method" do
+        Given(:multi_verifier) { Verifies.new(test_double,2) }
+        Given { test_double.ferment(:panda,:sauce) }
+        Given { 2.times { test_double.ferment(2,3) } }
+        When(:result) do
+          lambda do
+            multi_verifier.ferment(2,3)
+            verifier.ferment(:panda,:sauce)
+          end
         end
+        Then { result.should_not raise_error }
       end
-      Then { result.should_not raise_error }
-    end
 
-    context "a method not on the test_double" do
-      When(:result) { lambda { verifier.eat } }
-      Then { result.should raise_error NoMethodError }
-    end
+      context "a method not on the test_double" do
+        When(:result) { lambda { verifier.eat } }
+        Then { result.should raise_error NoMethodError }
+      end
 
-    context "a satisfied argument matcher" do
-      Given { test_double.ferment(5) }
-      When(:result) { lambda { verifier.ferment(numeric) } }
-      Then { result.should_not raise_error }
-    end
+      context "a satisfied argument matcher" do
+        Given { test_double.ferment(5) }
+        When(:result) { lambda { verifier.ferment(numeric) } }
+        Then { result.should_not raise_error }
+      end
 
-    context "an unsatisifed argument matcher" do
-      Given { test_double.ferment("True") }
-      When(:result) { lambda { verifier.ferment(boolean) } }
-      Then { result.should raise_error Errors::VerificationFailedError }
+      context "an unsatisifed argument matcher" do
+        Given { test_double.ferment("True") }
+        When(:result) { lambda { verifier.ferment(boolean) } }
+        Then { result.should raise_error Errors::VerificationFailedError }
+      end
     end
-  end
 
-  shared_examples_for "an overridden verifier" do
-    context "a method not on the double that is invoked" do
-      Given { test_double.eat }
-      When(:result) { lambda { verifier.eat } }
-      Then { result.should_not raise_error }
-    end
+    shared_examples_for "an overridden verifier" do
+      context "a method not on the double that is invoked" do
+        Given { test_double.eat }
+        When(:result) { lambda { verifier.eat } }
+        Then { result.should_not raise_error }
+      end
 
-    context "a method not on the test_double that is _not_ invoked" do
-      When(:result) { lambda { verifier.eat } }
-      Then { result.should raise_error Errors::VerificationFailedError }
+      context "a method not on the test_double that is _not_ invoked" do
+        When(:result) { lambda { verifier.eat } }
+        Then { result.should raise_error Errors::VerificationFailedError }
+      end
     end
-  end
 
-  context "class API" do
-    Given(:verifier) { Verifies.new(test_double) }
-    it_behaves_like "a verifier"
-    it_behaves_like "an overridden verifier" do
-      Given { verifier.raises_no_method_error = false }
+    context "class API" do
+      Given(:verifier) { Verifies.new(test_double) }
+      it_behaves_like "a verifier"
+      it_behaves_like "an overridden verifier" do
+        Given { verifier.raises_no_method_error = false }
+      end
     end
-  end
 
-  context "gimme DSL" do
-    it_behaves_like "a verifier" do
-      Given(:verifier) { verify(test_double) }
-    end
+    context "gimme DSL" do
+      it_behaves_like "a verifier" do
+        Given(:verifier) { verify(test_double) }
+      end
 
-    it_behaves_like "an overridden verifier" do
-      Given(:verifier) { verify!(test_double) }
+      it_behaves_like "an overridden verifier" do
+        Given(:verifier) { verify!(test_double) }
+      end
     end
   end
-
-
-
-end
+end