gimme 0.2.0 → 0.3.1

data/Gemfile

@@ -11,10 +11,11 @@ group :development, :test do
   gem "jeweler", "~> 1.5.2"
   gem "rspec"
   gem "rspec-given"
-  gem "guard-rspec", :require => false
   gem "cucumber"
-  gem "guard-cucumber", :require => false
   gem "simplecov", :require => false
+
+  gem "guard-cucumber", :require => false
+  gem "guard-rspec", :require => false
   if RUBY_PLATFORM =~ /darwin/i
     gem "growl"
     gem "rb-fsevent", :require => false

data/Guardfile

@@ -3,11 +3,10 @@
 
 guard 'rspec', :cli => '--color', :version => 2 do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
 end
 
-
 guard 'cucumber' do
   watch(%r{^features/.+\.feature$})
   watch(%r{^features/support/.+$})          { 'features' }

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Justin Searls
+Copyright (c) 2012 Justin Searls
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -136,7 +136,7 @@ In cases like these, a captor can be used to "capture" the real argument value t
     #arrange
     searches_system = gimme(SearchesSystem)
     sut = QueryExecutor.new(searches_sytem)
-    query_captor = Captor.new
+    query_captor = Gimme::Captor.new
 
     #act
     sut.submit_query_for_string("find dogs")

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.1

data/features/basics.feature

@@ -0,0 +1,66 @@
+Feature: basic usage
+
+  Gimme is designed for easy & reliable isolated unit testing of Ruby classes.
+
+  This example illustrates:
+    <ul>
+      <li>How to create a test double for a known class</li>
+      <li>Injecting that double into the subject code we're specifying</li>
+      <li>Stubbing a method on a test double to return a particular result</li>
+      <li>Verify that a method on a test double was called with a particular argument</li>
+    </ul>
+
+  So say we've got a Chef who's job is to take the work product of his Apprentice
+    and simmer it on the Stove. Here's how we might use gimme to write an isolation test
+    of the Chef's job without actually calling through to a real Apprentice or a real Stove.
+
+  Scenario:
+    Given we have this existing code:
+      """
+      class Apprentice
+        def slice(thing)
+          1000000.times.map do
+            Slice.new(thing)
+          end
+        end
+      end
+
+      class Stove
+        def simmer(stuff)
+        end
+      end
+
+      class Slice
+        def initialize(of)
+        end
+      end
+
+      class Chef
+        def initialize(slicer = Apprentice.new, stove = Stove.new)
+          @slicer = slicer
+          @stove = stove
+        end
+      end
+
+      """
+
+    When we want to write some tests to help us write this method:
+      """
+      class Chef
+        def cook
+          slices = @slicer.slice("tomato")
+          @stove.simmer(slices)
+        end
+      end
+      """
+
+    Then we can use gimme to isolate the unit under test:
+      """
+      slicer = gimme(Apprentice)
+      stove = gimme(Stove)
+      give(slicer).slice("tomato") { "some slices" }
+
+      Chef.new(slicer, stove).cook
+
+      verify(stove).simmer("some slices")
+      """

data/features/matchers.feature

@@ -0,0 +1,126 @@
+Feature: argument matchers
+
+  By default, gimme will only stub and verify methods that are called with the same arguments
+    in your spec and your production code. But gimme also includes a number of argument matchers
+    that allow more flexible specifications, particularly when you don't care about or can't
+    know the <em>exact</em> arguments passed to a method on a test double.
+
+  This example illustrates:
+    <ul>
+      <li>How to use an argument matcher when stubbing a method</li>
+      <li>Using argument matchers when verifying a method</li>
+      <li>Using argument captors, a special sort of matcher</li>
+      <li>Defining your own matcher</li>
+    </ul>
+
+  In this example, we have a Mail object with a contents attribute. A DeliversMessages object adds Mail to     
+    Recipients' mailboxes and checks off each delivery on its Checklist.
+
+
+  Background:
+    Given we have this existing code:
+      """
+      class Mail
+        attr_reader :contents
+        def initialize(contents)
+          @contents = contents
+        end
+      end
+
+      class Recipient
+        def add_to_mailbox(thing)
+        end
+      end
+
+      class Checklist
+        def check_off(message_summary, recipient, timestamp)
+        end
+      end
+
+      class DeliversMessages
+        def initialize(checklist = Checklist.new)
+          @checklist = checklist
+        end
+      end
+      """
+    When we want to write some tests to help us write this method:
+      """
+      class DeliversMessages
+        def deliver(message, recipient = Recipient.new)
+          mail = Mail.new(message)
+          recipient.add_to_mailbox(mail)
+          @checklist.check_off(message[0..4], recipient, Time.now)
+        end
+      end
+      """
+
+  Scenario: using the is_a matcher to specify a type
+    Then we can use gimme to isolate the unit under test:
+      """
+      checklist = gimme(Checklist)
+      recipient = gimme(Recipient)
+
+      DeliversMessages.new(checklist).deliver("WHY HELLO GOOD SIR", recipient)
+
+      #without access (or interest in) the mail object, we can just check it was of type Mail
+      verify(recipient).add_to_mailbox(is_a(Mail))
+
+      # ^-- we could have also used any(Mail) to allow the argument to have been nil, as well.
+      """
+
+  Scenario: using the anything matcher to allow for any value
+
+    Then we can use gimme to isolate the unit under test:
+      """
+      checklist = gimme(Checklist)
+      recipient = gimme(Recipient)
+
+      DeliversMessages.new(checklist).deliver("WHY HELLO GOOD SIR", recipient)
+
+      #here we check the second param exactly, but allow the third to be anything
+      verify(checklist).check_off(any(String), recipient, anything)
+      """
+
+  Scenario: using an argument captor to grab what was passed
+    Then we can use gimme to isolate the unit under test:
+      """
+      checklist = gimme(Checklist)
+      recipient = gimme(Recipient)
+
+      DeliversMessages.new(checklist).deliver("WHY HELLO GOOD SIR", recipient)
+
+      mail_captor = Gimme::Captor.new
+      verify(recipient).add_to_mailbox(capture(mail_captor))
+      mail_captor.value.contents.should == "WHY HELLO GOOD SIR"
+      """
+
+  Scenario: writing a custom starts_with matcher
+    Then we can use gimme to isolate the unit under test:
+      """
+      checklist = gimme(Checklist)
+      recipient = gimme(Recipient)
+
+      DeliversMessages.new(checklist).deliver("WHY HELLO GOOD SIR", recipient)
+
+
+      class StartsWith
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          actual.start_with?(@expected)
+        end
+      end
+
+      verify(checklist).check_off(StartsWith.new("WHY"), anything, anything)
+
+      # or, of course, you could add a more natural method for your matcher
+
+      def starts_with(s)
+        StartsWith.new(s)
+      end
+
+      verify(checklist).check_off(starts_with("WHY"), anything, anything)
+
+      """

data/features/{stub_class_methods.feature → old/stub_class_methods.feature}

@@ -1,4 +1,3 @@
-@wip
 Feature: stubbing class methods
 
   In order to spec code that depends on Rails or other APIs that make

data/features/old/verify_no_args.feature

@@ -0,0 +1,23 @@
+Feature: verification of no-arg methods
+
+  As a test author
+  I want to verify my test double's no-arg method was invoked
+  So that I can specify its behavior
+
+  Scenario:
+    Given a new test double
+    But I do not invoke yawn
+    Then verifying yawn raises a Gimme::Errors::VerificationFailedError
+    But I can verify yawn has been invoked 0 times
+
+    When I invoke yawn
+    Then I can verify yawn has been invoked
+    And I can verify yawn has been invoked 1 time
+
+    When I invoke yawn
+    Then I can verify yawn has been invoked 2 times
+
+  Scenario: class methods
+    Given the ClassyPossum class
+    When I spy on ClassyPossum.yawn
+    Then it can verify no-arg methods too.

data/features/readme.md

@@ -0,0 +1,3 @@
+# gimme
+
+Gimme is a test double library designed to help you write isolated unit specs for your Ruby code.

data/features/step_definitions/doc_steps.rb

@@ -0,0 +1,12 @@
+
+Given /^we have this existing code:$/ do |string|
+  eval(string)
+end
+
+When /^we want to write some tests to help us write this method:$/ do |string|
+  eval(string)
+end
+
+Then /^we can use gimme to isolate the unit under test:$/ do |string|
+  eval(string)
+end

data/features/step_definitions/gimme_steps.rb

@@ -75,6 +75,23 @@ Then /^I can verify! #{METHOD_PATTERN} has been invoked (\d+) times?$/ do |metho
   sendish(verify!(@double,times.to_i),method,args)
 end
 
+When /^I spy on ([^.]*)\.(.*)$/ do |cls, method|
+  spy_on(eval(cls), method.to_sym)
+end
+
+Then /^it can verify no\-arg methods too\.$/ do
+  step "I do not invoke yawn"
+  step "verifying yawn raises a Gimme::Errors::VerificationFailedError"
+  step "I can verify yawn has been invoked 0 times"
+
+  step "I invoke yawn"
+  step "I can verify yawn has been invoked"
+  step "I can verify yawn has been invoked 1 time"
+
+  step "I invoke yawn"
+  step "I can verify yawn has been invoked 2 times"
+end
+
 #Captors
 
 Given /^a new argument captor$/ do

data/features/support/animals.rb

@@ -16,6 +16,15 @@ class Possum
 
   def self.crawl_to(location)
   end
+
+  def yawn
+
+  end
+end
+
+class ClassyPossum
+  def self.yawn
+  end
 end
 
 class Dog < Animal

data/gimme.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gimme}
-  s.version = "0.2.0"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Justin Searls}]
-  s.date = %q{2012-02-27}
+  s.date = %q{2012-03-03}
   s.description = %q{gimme attempts to bring to Ruby a test double workflow akin to Mockito in Java. Major distinctions include preserving arrange-act-assert in tests, fast feedback for methods the double's real counterpart may not know how to respond to, no string/symbolic representations of methods, argument captors, and strong opinions (weakly held). }
   s.email = %q{searls@gmail.com}
   s.extra_rdoc_files = [
@@ -28,34 +28,45 @@ Gem::Specification.new do |s|
     "README.rdoc",
     "Rakefile",
     "VERSION",
-    "features/argument_captors.feature",
-    "features/gimme_next.feature",
+    "features/basics.feature",
+    "features/matchers.feature",
+    "features/old/argument_captors.feature",
+    "features/old/gimme_next.feature",
+    "features/old/stub_basic.feature",
+    "features/old/stub_class_methods.feature",
+    "features/old/stub_matchers.feature",
+    "features/old/stub_sensible_defaults.feature",
+    "features/old/unknown_methods.feature",
+    "features/old/verify_matcher_anything.feature",
+    "features/old/verify_no_args.feature",
+    "features/old/verify_with_args.feature",
+    "features/readme.md",
+    "features/step_definitions/doc_steps.rb",
     "features/step_definitions/gimme_steps.rb",
-    "features/stub_basic.feature",
-    "features/stub_class_methods.feature",
-    "features/stub_matchers.feature",
-    "features/stub_sensible_defaults.feature",
     "features/support/animals.rb",
     "features/support/env.rb",
-    "features/unknown_methods.feature",
-    "features/verify_matcher_anything.feature",
-    "features/verify_no_args.feature",
-    "features/verify_with_args.feature",
     "gimme.gemspec",
     "lib/gimme-double.rb",
     "lib/gimme.rb",
     "lib/gimme/captor.rb",
     "lib/gimme/dsl.rb",
+    "lib/gimme/ensures_class_method_restoration.rb",
     "lib/gimme/errors.rb",
     "lib/gimme/gives.rb",
     "lib/gimme/gives_class_methods.rb",
+    "lib/gimme/invocation_store.rb",
     "lib/gimme/invokes_satisfied_stubbing.rb",
     "lib/gimme/matchers.rb",
+    "lib/gimme/method_store.rb",
     "lib/gimme/reset.rb",
     "lib/gimme/resolves_methods.rb",
     "lib/gimme/rspec_adapter.rb",
+    "lib/gimme/spies_on_class_methods.rb",
+    "lib/gimme/store.rb",
+    "lib/gimme/stubbing_store.rb",
     "lib/gimme/test_double.rb",
     "lib/gimme/verifies.rb",
+    "lib/gimme/verifies_class_methods.rb",
     "spec/gimme/captor_spec.rb",
     "spec/gimme/errors_spec.rb",
     "spec/gimme/gives_class_methods_spec.rb",
@@ -64,7 +75,10 @@ Gem::Specification.new do |s|
     "spec/gimme/resolves_methods_spec.rb",
     "spec/gimme/rspec_adapter_spec.rb",
     "spec/gimme/shared_examples/shared_gives_examples.rb",
+    "spec/gimme/shared_examples/shared_verifies_examples.rb",
+    "spec/gimme/spies_on_class_method_spec.rb",
     "spec/gimme/test_double_spec.rb",
+    "spec/gimme/verifies_class_methods_spec.rb",
     "spec/gimme/verifies_spec.rb",
     "spec/spec_helper.rb"
   ]
@@ -82,7 +96,10 @@ Gem::Specification.new do |s|
     "spec/gimme/resolves_methods_spec.rb",
     "spec/gimme/rspec_adapter_spec.rb",
     "spec/gimme/shared_examples/shared_gives_examples.rb",
+    "spec/gimme/shared_examples/shared_verifies_examples.rb",
+    "spec/gimme/spies_on_class_method_spec.rb",
     "spec/gimme/test_double_spec.rb",
+    "spec/gimme/verifies_class_methods_spec.rb",
     "spec/gimme/verifies_spec.rb",
     "spec/spec_helper.rb"
   ]
@@ -96,10 +113,10 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<rspec-given>, [">= 0"])
-      s.add_development_dependency(%q<guard-rspec>, [">= 0"])
       s.add_development_dependency(%q<cucumber>, [">= 0"])
-      s.add_development_dependency(%q<guard-cucumber>, [">= 0"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<guard-cucumber>, [">= 0"])
+      s.add_development_dependency(%q<guard-rspec>, [">= 0"])
       s.add_development_dependency(%q<growl>, [">= 0"])
       s.add_development_dependency(%q<rb-fsevent>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 1.3.1"])
@@ -110,10 +127,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
       s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<rspec-given>, [">= 0"])
-      s.add_dependency(%q<guard-rspec>, [">= 0"])
       s.add_dependency(%q<cucumber>, [">= 0"])
-      s.add_dependency(%q<guard-cucumber>, [">= 0"])
       s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<guard-cucumber>, [">= 0"])
+      s.add_dependency(%q<guard-rspec>, [">= 0"])
       s.add_dependency(%q<growl>, [">= 0"])
       s.add_dependency(%q<rb-fsevent>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 1.3.1"])
@@ -125,10 +142,10 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
     s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<rspec-given>, [">= 0"])
-    s.add_dependency(%q<guard-rspec>, [">= 0"])
     s.add_dependency(%q<cucumber>, [">= 0"])
-    s.add_dependency(%q<guard-cucumber>, [">= 0"])
     s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<guard-cucumber>, [">= 0"])
+    s.add_dependency(%q<guard-rspec>, [">= 0"])
     s.add_dependency(%q<growl>, [">= 0"])
     s.add_dependency(%q<rb-fsevent>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 1.3.1"])