verified_double 0.0.1

data/.gitignore

@@ -0,0 +1,21 @@
+*.geany
+*.gem
+*.rbc
+.bundle
+.config
+.rspec
+.switch_file
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+gsmendoza/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+script:
+  - bundle exec rspec
+  - bundle exec cucumber

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 George Mendoza
+
+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,65 @@
+# VerifiedDouble
+
+VerifiedDouble would record any mock made in the test suite. It
+would then verify if the mock is valid by checking if there is a test
+against it.
+
+For example, let's say I mocked the save method of a model like so:
+
+    item = VerifiedDouble.of_instance(Item)
+    item.should_receive(:save).and_return(true)
+
+Calling `VerifiedDouble.of_instance` would record the :save interaction on
+item. When running the tests, the gem would look for a test that
+confirms if you can indeed call #save on Item. The test should also
+ensure that the method indeed returns a boolean value. Since this is hard
+to automate, the gem would just look for a test with the tag saying it
+verifies that contract:
+
+    it "tests something", verifies_contract: 'Item#save => Boolean' do
+      #...
+    end
+
+If this test does not exist, the gem would complain that the mock is not
+verified.
+
+This is an implementation of [contract tests](http://www.infoq.com/presentations/integration-tests-scam).
+Notes about the presentation [here](http://www.beletsky.net/2010/10/agileee-2010-j-b-rainsberger-integrated.html).
+
+There's already a gem that implements contract tests
+([bogus](https://www.relishapp.com/bogus/bogus/v/0-0-3/docs/contract-tests)).
+However, I think there's room for an alternative because:
+
+1. It's not clear from the Bogus [documentation](https://www.relishapp.com/bogus/bogus/v/0-0-3/docs/contract-tests/contract-tests-with-mocks)
+whether the gem verifies actual arguments/return values or just the types of those
+values. While the argument/return types are enough in most cases, sometimes
+the actual argument/return values are important. For example, if I mock
+Item.where(conditions), the actual conditions are important in
+verifying the validity of the where call.
+
+2. [By design](https://www.relishapp.com/bogus/bogus/v/0-0-3/docs/fakes/faking-existing-classes#fakes-have-null-object-semantics),
+a Bogus fake would return itself to all its methods. I prefer rspec-mock's
+approach of raising an error if a method is not declared as part of the
+double, since this raises errors earlier than later.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'verified_double'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install verified_double
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/features/readme.md

@@ -0,0 +1,65 @@
+# VerifiedDouble
+
+VerifiedDouble would record any mock made in the test suite. It
+would then verify if the mock is valid by checking if there is a test
+against it.
+
+For example, let's say I mocked the save method of a model like so:
+
+    item = VerifiedDouble.of_instance(Item)
+    item.should_receive(:save).and_return(true)
+
+Calling `VerifiedDouble.of_instance` would record the :save interaction on
+item. When running the tests, the gem would look for a test that
+confirms if you can indeed call #save on Item. The test should also
+ensure that the method indeed returns a boolean value. Since this is hard
+to automate, the gem would just look for a test with the tag saying it
+verifies that contract:
+
+    it "tests something", verifies_contract: 'Item#save => Boolean' do
+      #...
+    end
+
+If this test does not exist, the gem would complain that the mock is not
+verified.
+
+This is an implementation of [contract tests](http://www.infoq.com/presentations/integration-tests-scam).
+Notes about the presentation [here](http://www.beletsky.net/2010/10/agileee-2010-j-b-rainsberger-integrated.html).
+
+There's already a gem that implements contract tests
+([bogus](https://www.relishapp.com/bogus/bogus/v/0-0-3/docs/contract-tests)).
+However, I think there's room for an alternative because:
+
+1. It's not clear from the Bogus [documentation](https://www.relishapp.com/bogus/bogus/v/0-0-3/docs/contract-tests/contract-tests-with-mocks)
+whether the gem verifies actual arguments/return values or just the types of those
+values. While the argument/return types are enough in most cases, sometimes
+the actual argument/return values are important. For example, if I mock
+Item.where(conditions), the actual conditions are important in
+verifying the validity of the where call.
+
+2. [By design](https://www.relishapp.com/bogus/bogus/v/0-0-3/docs/fakes/faking-existing-classes#fakes-have-null-object-semantics),
+a Bogus fake would return itself to all its methods. I prefer rspec-mock's
+approach of raising an error if a method is not declared as part of the
+double, since this raises errors earlier than later.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'verified_double'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install verified_double
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/features/step_definitions/verified_double_steps.rb

@@ -0,0 +1,37 @@
+Given /^the following classes:$/ do |string|
+  write_file 'lib/main.rb', string
+end
+
+Given /^the test suite has an after\(:suite\) callback asking VerifiedDouble to report unverified doubles:$/ do |string|
+  write_file 'spec/spec_helper.rb', string
+end
+
+Given /^a test that uses VerifiedDouble to mock an object:$/ do |string|
+  write_file 'spec/main_spec.rb', string
+end
+
+Given /^a test that uses VerifiedDouble to mock a class:$/ do |string|
+  write_file 'spec/main_spec.rb', string
+end
+
+Given /^the test suite has a contract test for the mock:$/ do |string|
+  write_file 'spec/contract_test_for_main_spec.rb', string
+end
+
+Given /^the test suite does not have a contract test for the mock$/ do
+  # do nothing
+end
+
+When /^I run the test suite$/ do
+  run_simple(unescape("rspec"), false)
+end
+
+Then /^I should be informed that the mock is unverified:$/ do |string|
+  assert_partial_output(string, all_output)
+  assert_success('pass')
+end
+
+Then /^I should not see any output saying the mock is unverified$/ do
+  assert_no_partial_output("The following mocks are not verified", all_output)
+  assert_success('pass')
+end

data/features/support/requires.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/features/verified_double.feature

@@ -0,0 +1,152 @@
+Feature: Verified double
+  As a developer
+  I want to be informed if the mocks I use are verified by contract tests
+
+  Background:
+    Given the following classes:
+      """
+      class ObjectUnderTest
+        def do_something(collaborator, input)
+          collaborator.some_method(input)
+        end
+
+        def self.do_something(collaborator, input)
+          collaborator.some_method(input)
+        end
+      end
+
+      class Collaborator
+        def self.some_method(input)
+        end
+
+        def some_method(input)
+        end
+      end
+
+      class SomeInput
+      end
+
+      class SomeOutput
+      end
+      """
+
+    And the test suite has an after(:suite) callback asking VerifiedDouble to report unverified doubles:
+      """
+      require 'pry'
+      require 'verified_double'
+      require 'main'
+
+      RSpec.configure do |config|
+        config.after :suite do
+          VerifiedDouble::ReportUnverifiedSignatures.new(VerifiedDouble.registry, self).execute
+        end
+      end
+      """
+
+  Scenario: Verified instance doubles
+    Given a test that uses VerifiedDouble to mock an object:
+      """
+      require 'spec_helper'
+      describe ObjectUnderTest do
+        let(:input) { SomeInput.new }
+        let(:output) { SomeOutput.new }
+        let(:instance_double) { VerifiedDouble.of_instance('Collaborator') }
+
+        it "tests something" do
+          instance_double.should_receive(:some_method).with(input).and_return(output)
+          ObjectUnderTest.new.do_something(instance_double, input)
+        end
+      end
+      """
+
+    And the test suite has a contract test for the mock:
+      """
+      require 'spec_helper'
+
+      describe 'Collaborator' do
+        it "tests something", verifies_contract: 'Collaborator#some_method(SomeInput)=>SomeOutput' do
+          # do nothing
+        end
+      end
+      """
+
+    When I run the test suite
+    Then I should not see any output saying the mock is unverified
+
+  Scenario: Unverified instance doubles
+    Given a test that uses VerifiedDouble to mock an object:
+      """
+      require 'spec_helper'
+      describe ObjectUnderTest do
+        let(:input) { SomeInput.new }
+        let(:output) { SomeOutput.new }
+        let(:instance_double) { VerifiedDouble.of_instance('Collaborator') }
+
+        it "tests something" do
+          instance_double.should_receive(:some_method).with(input).and_return(output)
+          ObjectUnderTest.new.do_something(instance_double, input)
+        end
+      end
+      """
+
+    And the test suite does not have a contract test for the mock
+    When I run the test suite
+    Then I should be informed that the mock is unverified:
+      """
+      The following mocks are not verified:
+      Collaborator#some_method(SomeInput)=>SomeOutput
+      """
+
+  Scenario: Verified class doubles
+    Given a test that uses VerifiedDouble to mock a class:
+      """
+      require 'spec_helper'
+      describe ObjectUnderTest do
+        let(:input) { SomeInput.new }
+        let(:output) { SomeOutput.new }
+        let(:class_double) { VerifiedDouble.of_class('Collaborator') }
+
+        it "tests something" do
+          class_double.should_receive(:some_method).with(input).and_return(output)
+          ObjectUnderTest.new.do_something(class_double, input)
+        end
+      end
+      """
+
+    And the test suite has a contract test for the mock:
+      """
+      require 'spec_helper'
+
+      describe 'Collaborator' do
+        it "tests something", verifies_contract: 'Collaborator.some_method(SomeInput)=>SomeOutput' do
+          # do nothing
+        end
+      end
+      """
+
+    When I run the test suite
+    Then I should not see any output saying the mock is unverified
+
+  Scenario: Unverified class doubles
+    Given a test that uses VerifiedDouble to mock an object:
+      """
+      require 'spec_helper'
+      describe ObjectUnderTest do
+        let(:input) { SomeInput.new }
+        let(:output) { SomeOutput.new }
+        let(:class_double) { VerifiedDouble.of_class('Collaborator') }
+
+        it "tests something" do
+          class_double.should_receive(:some_method).with(input).and_return(output)
+          ObjectUnderTest.new.do_something(class_double, input)
+        end
+      end
+      """
+
+    And the test suite does not have a contract test for the mock
+    When I run the test suite
+    Then I should be informed that the mock is unverified:
+      """
+      The following mocks are not verified:
+      Collaborator.some_method(SomeInput)=>SomeOutput
+      """

data/lib/verified_double/get_registered_signatures.rb

@@ -0,0 +1,11 @@
+module VerifiedDouble
+  class GetRegisteredSignatures
+    def initialize(double_registry)
+      @double_registry = double_registry
+    end
+
+    def execute
+      @double_registry.map(&:method_signatures).flatten.map(&:to_s).uniq
+    end
+  end
+end

data/lib/verified_double/get_unverified_signatures.rb

@@ -0,0 +1,11 @@
+module VerifiedDouble
+  class GetUnverifiedSignatures
+    def initialize(get_registered_signatures, get_verified_signatures)
+      @get_registered_signatures, @get_verified_signatures = get_registered_signatures, get_verified_signatures
+    end
+
+    def execute
+      @get_registered_signatures.execute - @get_verified_signatures.execute
+    end
+  end
+end

data/lib/verified_double/get_verified_signatures.rb

@@ -0,0 +1,16 @@
+module VerifiedDouble
+  class GetVerifiedSignatures
+    def initialize(nested_example_group)
+      @nested_example_group = nested_example_group
+    end
+
+    def execute
+      results = @nested_example_group
+        .class
+        .descendant_filtered_examples
+        .map{|example| example.metadata[:verifies_contract] }
+        .compact
+        .uniq
+    end
+  end
+end

data/lib/verified_double/method_signature.rb

@@ -0,0 +1,16 @@
+module VerifiedDouble
+  class MethodSignature
+    attr_accessor :args, :method, :recording_double, :return_value
+
+    def initialize(recording_double)
+      @recording_double = recording_double
+    end
+
+    def to_s
+      result = [
+        "#{recording_double.class_name}#{recording_double.method_operator}#{method}(#{args && args.map(&:class).join(', ')})",
+        return_value && return_value.class]
+      result.compact.join("=>")
+    end
+  end
+end

data/lib/verified_double/output_unverified_signatures.rb

@@ -0,0 +1,18 @@
+module VerifiedDouble
+  class OutputUnverifiedSignatures
+    def initialize(get_unverified_signatures)
+      @get_unverified_signatures = get_unverified_signatures
+    end
+
+    def execute
+      if unverified_signatures.any?
+        output = ["The following mocks are not verified:" ] + unverified_signatures
+        puts output.join("\n")
+      end
+    end
+
+    def unverified_signatures
+      @unverified_signatures ||= @get_unverified_signatures.execute
+    end
+  end
+end

data/lib/verified_double/recording_double.rb

@@ -0,0 +1,58 @@
+require 'delegate'
+
+module VerifiedDouble
+  class RecordingDouble < ::SimpleDelegator
+    def initialize(double)
+      @double = double
+      super(@double)
+    end
+
+    def and_return(return_value)
+      self.method_signatures.last.return_value = return_value
+      @double_call.and_return(return_value)
+      self
+    end
+
+    def class_double?
+      ! double.is_a?(RSpec::Fire::FireObjectDouble)
+    end
+
+    def class_name
+      double.instance_variable_get('@name')
+    end
+
+    def double
+      __getobj__
+    end
+
+    def inspect
+      to_s
+    end
+
+    def method_operator
+      class_double? ? '.' : '#'
+    end
+
+    def method_signatures
+      @method_signatures ||= []
+    end
+
+    def should_receive(method)
+      method_signature = MethodSignature.new(self)
+      method_signature.method = method
+      self.method_signatures << method_signature
+      @double_call = super(method)
+      self
+    end
+
+    def to_s
+      "#{VerifiedDouble}.of_#{class_double? ? 'class' : 'instance' }('#{class_name}')"
+    end
+
+    def with(*args)
+      self.method_signatures.last.args = args
+      @double_call.with(*args)
+      self
+    end
+  end
+end

data/lib/verified_double/report_unverified_signatures.rb

@@ -0,0 +1,16 @@
+module VerifiedDouble
+  class ReportUnverifiedSignatures
+    attr_accessor :double_registry, :nested_example_group
+
+    def initialize(double_registry, nested_example_group)
+      @double_registry, @nested_example_group = double_registry, nested_example_group
+    end
+
+    def execute
+      VerifiedDouble::OutputUnverifiedSignatures.new(
+        VerifiedDouble::GetUnverifiedSignatures.new(
+          VerifiedDouble::GetRegisteredSignatures.new(double_registry),
+          VerifiedDouble::GetVerifiedSignatures.new(nested_example_group))).execute
+    end
+  end
+end

data/lib/verified_double/verify_doubles_service.rb

@@ -0,0 +1,15 @@
+module VerifiedDouble
+  class VerifyDoublesService
+    def initialize(world)
+      @world = world
+    end
+
+    def execute
+      unverified_method_signatures = @world.unverified_method_signatures
+      if unverified_method_signatures.any?
+        output = ["The following mocks are not verified:" ] + unverified_method_signatures
+        puts output.join("\n")
+      end
+    end
+  end
+end

data/lib/verified_double/version.rb

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

data/lib/verified_double.rb

@@ -0,0 +1,28 @@
+require 'rspec/fire'
+
+require 'verified_double/get_registered_signatures'
+require 'verified_double/get_unverified_signatures'
+require 'verified_double/get_verified_signatures'
+require 'verified_double/method_signature'
+require 'verified_double/output_unverified_signatures'
+require 'verified_double/recording_double'
+require 'verified_double/report_unverified_signatures'
+
+module VerifiedDouble
+  def self.of_class(class_name)
+    RecordingDouble.new(RSpec::Fire::FireClassDoubleBuilder.build(class_name).as_replaced_constant).tap do |double|
+      registry << double
+    end
+  end
+
+  def self.of_instance(class_name)
+    RecordingDouble.new(RSpec::Fire::FireObjectDouble.new(class_name)).tap do |double|
+      registry << double
+    end
+  end
+
+  def self.registry
+    @registry ||= []
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'verified_double'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.include(RSpec::Fire)
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+RSpec::Fire.configure do |config|
+  config.verify_constant_names = true
+end

data/spec/unit_helper.rb

@@ -0,0 +1,7 @@
+require 'active_support/core_ext/string'
+require 'pry'
+require 'rspec/fire'
+
+RSpec.configure do |config|
+  config.include(RSpec::Fire)
+end

data/spec/verified_double/get_registered_signatures_spec.rb

@@ -0,0 +1,42 @@
+require 'unit_helper'
+require 'verified_double/get_registered_signatures'
+
+describe VerifiedDouble::GetRegisteredSignatures do
+  let(:method_signature_1) {
+    fire_double('VerifiedDouble::MethodSignature', to_s: 'method_signature_1') }
+
+  let(:method_signature_2) {
+    fire_double('VerifiedDouble::MethodSignature', to_s: 'method_signature_2') }
+
+  let(:recording_double_1) {
+    fire_double('VerifiedDouble::RecordingDouble',
+      method_signatures: [method_signature_1]) }
+
+  let(:recording_double_2) {
+    fire_double('VerifiedDouble::RecordingDouble',
+      method_signatures: [method_signature_2]) }
+
+  subject { described_class.new(double_registry) }
+
+  describe "#execute" do
+    context "with multiple recording doubles in the registry" do
+      let(:double_registry){ [recording_double_1, recording_double_2] }
+
+      it "maps and flattens the method signatures of the recording doubles" do
+        expect(subject.execute).to eq(['method_signature_1', 'method_signature_2'])
+      end
+    end
+
+    context "with recording doubles with duplicate signatures" do
+      let(:recording_double_2) {
+        fire_double('VerifiedDouble::RecordingDouble',
+          method_signatures: [method_signature_1]) }
+
+      let(:double_registry){ [recording_double_1, recording_double_2] }
+
+      it "returns distinct method signatures" do
+        expect(subject.execute).to eq(['method_signature_1'])
+      end
+    end
+  end
+end

data/spec/verified_double/get_unverified_signatures_spec.rb

@@ -0,0 +1,28 @@
+require 'unit_helper'
+require 'verified_double/get_unverified_signatures'
+
+describe VerifiedDouble::GetUnverifiedSignatures do
+  let(:get_registered_signatures_service){
+    fire_double('VerifiedDouble::GetRegisteredSignatures') }
+
+  let(:get_verified_signatures_service){
+    fire_double('VerifiedDouble::GetVerifiedSignatures') }
+
+  subject { described_class.new(get_registered_signatures_service, get_verified_signatures_service) }
+
+  describe "#execute" do
+    it "subtracts verified_signatures from registered_signatures" do
+      get_registered_signatures_service
+        .should_receive(:execute)
+        .and_return([:verified_signature, :unverified_signature])
+
+      get_verified_signatures_service
+        .should_receive(:execute)
+        .and_return([:verified_signature])
+
+      expect(subject.execute).to eq([:unverified_signature])
+    end
+  end
+end
+
+

data/spec/verified_double/get_verified_signatures_spec.rb

@@ -0,0 +1,33 @@
+require 'unit_helper'
+require 'verified_double/get_verified_signatures'
+
+describe VerifiedDouble::GetVerifiedSignatures do
+  let(:nested_example_group){ double(:nested_example_group) }
+  subject { described_class.new(nested_example_group) }
+
+  describe "#execute" do
+    let(:example_with_verified_contract_tag){
+      double(:example_with_verified_contract_tag,
+        metadata: { verifies_contract: 'signature' }) }
+
+    let(:example_without_verified_contract_tag){
+      double(:example_without_verified_contract_tag,
+        metadata: { focus: true }) }
+
+    it "filters rspec examples with the tag 'verifies_contract'" do
+      nested_example_group
+        .stub_chain(:class, :descendant_filtered_examples)
+        .and_return([example_with_verified_contract_tag, example_without_verified_contract_tag])
+      expect(subject.execute).to eq([example_with_verified_contract_tag.metadata[:verifies_contract]])
+    end
+
+    it "returns unique signatures" do
+      nested_example_group
+        .stub_chain(:class, :descendant_filtered_examples)
+        .and_return([example_with_verified_contract_tag, example_with_verified_contract_tag])
+      expect(subject.execute).to eq([example_with_verified_contract_tag.metadata[:verifies_contract]])
+    end
+  end
+end
+
+

data/spec/verified_double/method_signature_spec.rb

@@ -0,0 +1,50 @@
+require 'unit_helper'
+require 'verified_double/method_signature'
+
+describe VerifiedDouble::MethodSignature do
+  describe "#to_s" do
+    let(:recording_double) {
+      fire_double('VerifiedDouble::RecordingDouble',
+        class_name: 'Dummy',
+        method_operator: '#') }
+
+    subject {
+      described_class.new(recording_double).tap {|method_signature|
+        method_signature.method = 'do_something' } }
+
+    context "when there are args" do
+      it "includes the args in the result" do
+        subject.args = [1, {}]
+        expect(subject.to_s).to eq("Dummy#do_something(Fixnum, Hash)")
+      end
+    end
+
+    context "when there are no args" do
+      it "displays an empty parenthesis for the args of the result" do
+        expect(subject.return_value).to be_nil
+        expect(subject.to_s).to eq("Dummy#do_something()")
+      end
+    end
+
+    context "when there is a nil arg" do
+      it "displays a nil class for the arg of the result" do
+        subject.args = [nil]
+        expect(subject.to_s).to eq("Dummy#do_something(NilClass)")
+      end
+    end
+
+    context "where there is a return value" do
+      it "displays the return value" do
+        subject.return_value = true
+        expect(subject.to_s).to eq("Dummy#do_something()=>TrueClass")
+      end
+    end
+
+    context "where there is no return value" do
+      it "does not include the hash rocket in the result" do
+        expect(subject.return_value).to be_nil
+        expect(subject.to_s).to eq("Dummy#do_something()")
+      end
+    end
+  end
+end

data/spec/verified_double/output_unverified_signatures_spec.rb

@@ -0,0 +1,38 @@
+require 'unit_helper'
+require 'verified_double/output_unverified_signatures'
+
+describe VerifiedDouble::OutputUnverifiedSignatures do
+  let(:get_unverified_signatures_service){
+    fire_double('VerifiedDouble::GetUnverifiedSignatures') }
+
+  let(:unverified_signatures){ %w(UNVERIFIED_SIGNATURES_1 UNVERIFIED_SIGNATURES_2) }
+
+  subject { described_class.new(get_unverified_signatures_service) }
+
+  describe "#execute" do
+    context "where there are no unverified_signatures" do
+      it "should not output anything" do
+        get_unverified_signatures_service.should_receive(:execute).and_return([])
+        subject.should_not_receive(:puts)
+
+        subject.execute
+      end
+    end
+
+    context "where there are unverified_signatures" do
+      it "should output the unverified_signatures" do
+        get_unverified_signatures_service.should_receive(:execute).and_return(unverified_signatures)
+        subject.should_receive(:puts).with("The following mocks are not verified:\nUNVERIFIED_SIGNATURES_1\nUNVERIFIED_SIGNATURES_2")
+
+        subject.execute
+      end
+    end
+  end
+
+  describe "#unverified_signatures" do
+    it "are the results of get_unverified_signatures.execute" do
+      get_unverified_signatures_service.should_receive(:execute).and_return(unverified_signatures)
+      expect(subject.unverified_signatures).to eq(unverified_signatures)
+    end
+  end
+end

data/spec/verified_double/recording_double_spec.rb

@@ -0,0 +1,133 @@
+require 'unit_helper'
+require "verified_double/recording_double"
+
+describe VerifiedDouble::RecordingDouble do
+  let(:class_name) {  'Object' }
+  let(:internal_double) { double(class_name) }
+
+  subject { VerifiedDouble::RecordingDouble.new(internal_double) }
+
+  describe "#initialize" do
+    it "requires a double" do
+      expect(subject.double).to eq(internal_double)
+    end
+  end
+
+  it "delegates all unknown calls to its internal double" do
+    internal_double.should_receive(:do_something)
+    subject.do_something
+  end
+
+  describe "#to_s" do
+    class Dummy
+    end
+
+    context "where the internal double is a class" do
+      let(:class_name) { 'Dummy' }
+      let(:internal_double) { fire_class_double(class_name).as_replaced_constant }
+
+      it { expect(subject.to_s).to eq("VerifiedDouble.of_class('#{class_name}')") }
+    end
+
+    context "where the internal double is an instance" do
+      let(:class_name) { 'Dummy' }
+      let(:internal_double) { fire_double(class_name) }
+
+      it { expect(subject.to_s).to eq("VerifiedDouble.of_instance('#{class_name}')") }
+    end
+  end
+
+  describe "#inspect" do
+    it "is human-readable representation of the recording double, NOT the internal double" do
+      expect(subject.inspect).to match("VerifiedDouble")
+    end
+  end
+
+  describe "#class_name" do
+    context "where the internal double is an RSpec::Fire::FireObjectDouble" do
+      it "is the name of the class represented by the FireObjectDouble" do
+        internal_double = fire_double('Object')
+        subject = described_class.new(internal_double)
+        expect(subject.class_name).to eq('Object')
+      end
+    end
+
+    context "where the internal double is an rspec fire class double" do
+      it "is the name of the class represented by the rspec fire class double" do
+        internal_double = fire_class_double('Object').as_replaced_constant
+        subject = described_class.new(internal_double)
+        expect(subject.class_name).to eq('Object')
+      end
+    end
+  end
+
+  describe "#class_double?" do
+    it "should be true if the internal double is an rspec fire class double" do
+      internal_double = fire_double('Object')
+      subject = described_class.new(internal_double)
+      expect(subject).to_not be_class_double
+    end
+
+    it "should be false if the internal double is not an rspec fire class double" do
+      internal_double = fire_class_double('Object').as_replaced_constant
+      subject = described_class.new(internal_double)
+      expect(subject).to be_class_double
+    end
+  end
+
+  describe "#method_operator" do
+    context "when the subject wraps an instance double" do
+      let(:internal_double) { fire_double('Object') }
+
+      subject { VerifiedDouble::RecordingDouble.new(internal_double) }
+
+      it "is #" do
+        expect(subject.method_operator).to eq("#")
+      end
+    end
+
+    context "when the subject wraps a class double" do
+      let(:internal_double) { fire_class_double('Object') }
+
+      subject { VerifiedDouble::RecordingDouble.new(internal_double) }
+
+      it "is '.'" do
+        expect(subject.method_operator).to eq(".")
+      end
+    end
+  end
+
+  describe "#should_receive(method)" do
+    it "appends a new method signature with the method to the recording double's method signatures" do
+      expect(subject.method_signatures).to be_empty
+
+      subject.should_receive(:to_s)
+      subject.should_receive(:inspect)
+
+      expect(subject.method_signatures.map(&:method)).to eq([:to_s, :inspect])
+
+      subject.to_s
+      subject.inspect
+    end
+  end
+
+  describe "#with(*args)" do
+    it "sets the args of the last method signature" do
+      subject.should_receive(:to_s).with(:arg_1, :arg_2)
+
+      expect(subject.method_signatures[0].args).to eq([:arg_1, :arg_2])
+
+      subject.to_s(:arg_1, :arg_2)
+    end
+  end
+
+  describe "#and_return(return_value)" do
+    it "sets the return value of the last method signature" do
+      subject.should_receive(:to_s).with(:arg_1, :arg_2).and_return(:return_value)
+
+      expect(subject.method_signatures[0].return_value).to eq(:return_value)
+
+      subject.to_s(:arg_1, :arg_2)
+    end
+  end
+end

data/spec/verified_double/report_unverified_signatures_spec.rb

@@ -0,0 +1,57 @@
+require 'unit_helper'
+require 'verified_double/report_unverified_signatures'
+
+describe VerifiedDouble::ReportUnverifiedSignatures do
+  let(:double_registry) { Set.new }
+  let(:nested_example_group) { double('nested_example_group') }
+
+  subject { described_class.new(double_registry, nested_example_group) }
+
+  describe "#initialize" do
+    it "requires a double registry and a nested example group" do
+      expect(subject.double_registry).to eq(double_registry)
+      expect(subject.nested_example_group).to eq(nested_example_group)
+    end
+  end
+
+  describe "#execute" do
+    service_names = [
+      :get_registered_signatures,
+      :get_verified_signatures,
+      :get_unverified_signatures,
+      :output_unverified_signatures]
+
+    service_names.each do |service_name|
+      service_class_name = "#{VerifiedDouble}::#{service_name.to_s.classify.pluralize}"
+      let("#{service_name}_class") { fire_class_double(service_class_name).as_replaced_constant }
+      let("#{service_name}_service") { fire_double(service_class_name) }
+    end
+
+    it "gets registered and verified signatures and then outputs the unverified signatures" do
+      get_registered_signatures_class
+        .should_receive(:new)
+        .with(double_registry)
+        .and_return(get_registered_signatures_service)
+
+      get_verified_signatures_class
+        .should_receive(:new)
+        .with(nested_example_group)
+        .and_return(get_verified_signatures_service)
+
+      get_unverified_signatures_class
+        .should_receive(:new)
+        .with(get_registered_signatures_service, get_verified_signatures_service)
+        .and_return(get_unverified_signatures_service)
+
+      output_unverified_signatures_class
+        .should_receive(:new)
+        .with(get_unverified_signatures_service)
+        .and_return(output_unverified_signatures_service)
+
+      output_unverified_signatures_service.should_receive(:execute)
+
+      subject.execute
+    end
+  end
+
+end

data/spec/verified_double/verify_doubles_service_spec.rb

@@ -0,0 +1,24 @@
+require 'verified_double/verify_doubles_service'
+
+describe VerifiedDouble::VerifyDoublesService do
+  let(:world) { double('VerifiedDouble::World') }
+
+  subject { described_class.new(world) }
+
+  describe "#execute" do
+    it "should output the unverified_method_signatures of the world if there are any" do
+      world.should_receive(:unverified_method_signatures).and_return(["Flight.find(Hash)=>Flight"])
+      subject.should_receive("puts")
+
+      subject.execute
+    end
+
+    it "should do nothing if there are no unverified_method_signatures" do
+      world.should_receive(:unverified_method_signatures).and_return([])
+      subject.should_not_receive("puts")
+
+      subject.execute
+    end
+  end
+end
+

data/spec/verified_double_spec.rb

@@ -0,0 +1,52 @@
+require 'unit_helper'
+require 'verified_double'
+
+describe VerifiedDouble do
+  describe ".registry" do
+    it "is a array by default" do
+      registry = VerifiedDouble.registry
+      expect(registry).to be_a(Array)
+    end
+
+    it "is memoized" do
+      expect(VerifiedDouble.registry).to equal(VerifiedDouble.registry)
+    end
+  end
+
+  describe ".of_instance(class_name)" do
+    let(:class_name){ 'Object' }
+
+    let(:subject) { described_class.of_instance(class_name) }
+
+    it "creates an instance recording double" do
+      expect(subject).to be_a(VerifiedDouble::RecordingDouble)
+      expect(subject).to_not be_class_double
+      expect(subject.class_name).to eq(class_name)
+    end
+
+    it "adds the double to the registry" do
+      described_class.registry.clear
+      recording_double = subject
+      expect(described_class.registry).to eq([recording_double])
+    end
+  end
+
+  describe ".of_class(class_name)" do
+    let(:class_name){ 'Object' }
+
+    let(:subject) { described_class.of_class(class_name) }
+
+    it "creates a class recording double" do
+      expect(subject).to be_a(VerifiedDouble::RecordingDouble)
+      expect(subject).to be_class_double
+      expect(subject.double).to be_a(Module)
+      expect(subject.class_name).to eq(class_name)
+    end
+
+    it "adds the double to the registry" do
+      described_class.registry.clear
+      recording_double = subject
+      expect(described_class.registry).to eq([recording_double])
+    end
+  end
+end

data/verified_double.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'verified_double/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "verified_double"
+  gem.version       = VerifiedDouble::VERSION
+  gem.authors       = ["George Mendoza"]
+  gem.email         = ["gsmendoza@gmail.com"]
+  gem.description   = %q{Contract tests for rspec}
+  gem.summary       = %q{VerifiedDouble would record any mock made in the test suite. It would then verify if the mock is valid by checking if there is a test against it.}
+  gem.homepage      = "https://www.relishapp.com/gsmendoza/verified-double"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency "rspec"
+  gem.add_runtime_dependency "rspec-fire"
+
+  gem.add_development_dependency "aruba"
+  gem.add_development_dependency "cucumber"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "activesupport"
+
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: verified_double
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors:
+- George Mendoza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec-fire
+- !ruby/object:Gem::Dependency
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: aruba
+- !ruby/object:Gem::Dependency
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: cucumber
+- !ruby/object:Gem::Dependency
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry
+- !ruby/object:Gem::Dependency
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: activesupport
+description: Contract tests for rspec
+email:
+- gsmendoza@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- features/readme.md
+- features/step_definitions/verified_double_steps.rb
+- features/support/requires.rb
+- features/verified_double.feature
+- lib/verified_double.rb
+- lib/verified_double/get_registered_signatures.rb
+- lib/verified_double/get_unverified_signatures.rb
+- lib/verified_double/get_verified_signatures.rb
+- lib/verified_double/method_signature.rb
+- lib/verified_double/output_unverified_signatures.rb
+- lib/verified_double/recording_double.rb
+- lib/verified_double/report_unverified_signatures.rb
+- lib/verified_double/verify_doubles_service.rb
+- lib/verified_double/version.rb
+- spec/spec_helper.rb
+- spec/unit_helper.rb
+- spec/verified_double/get_registered_signatures_spec.rb
+- spec/verified_double/get_unverified_signatures_spec.rb
+- spec/verified_double/get_verified_signatures_spec.rb
+- spec/verified_double/method_signature_spec.rb
+- spec/verified_double/output_unverified_signatures_spec.rb
+- spec/verified_double/recording_double_spec.rb
+- spec/verified_double/report_unverified_signatures_spec.rb
+- spec/verified_double/verify_doubles_service_spec.rb
+- spec/verified_double_spec.rb
+- verified_double.gemspec
+homepage: https://www.relishapp.com/gsmendoza/verified-double
+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.24
+signing_key: 
+specification_version: 3
+summary: VerifiedDouble would record any mock made in the test suite. It would then
+  verify if the mock is valid by checking if there is a test against it.
+test_files:
+- features/readme.md
+- features/step_definitions/verified_double_steps.rb
+- features/support/requires.rb
+- features/verified_double.feature
+- spec/spec_helper.rb
+- spec/unit_helper.rb
+- spec/verified_double/get_registered_signatures_spec.rb
+- spec/verified_double/get_unverified_signatures_spec.rb
+- spec/verified_double/get_verified_signatures_spec.rb
+- spec/verified_double/method_signature_spec.rb
+- spec/verified_double/output_unverified_signatures_spec.rb
+- spec/verified_double/recording_double_spec.rb
+- spec/verified_double/report_unverified_signatures_spec.rb
+- spec/verified_double/verify_doubles_service_spec.rb
+- spec/verified_double_spec.rb
+has_rdoc: