verified_double 0.0.1 → 0.0.2

data/.travis.yml

@@ -2,5 +2,5 @@ language: ruby
 rvm:
   - 1.9.3
 script:
-  - bundle exec rspec
+  - bundle exec rspec -r ./spec/spec_helper.rb
   - bundle exec cucumber

data/CHANGELOG.markdown

@@ -0,0 +1,12 @@
+0.0.2 - 2013-06-22
+------------------
+
+* Passes #1: Customizing arguments and return values.
+* Set rspec-fire to 1.1 for the meantime.
+
+0.0.1 - 2013-06-02
+------------------
+
+* Initial release. Passes "I want to be informed if the mocks I use are verified by contract tests" feature.
+
+

data/features/CHANGELOG.markdown

@@ -0,0 +1,12 @@
+0.0.2 - 2013-06-22
+------------------
+
+* Passes #1: Customizing arguments and return values.
+* Set rspec-fire to 1.1 for the meantime.
+
+0.0.1 - 2013-06-02
+------------------
+
+* Initial release. Passes "I want to be informed if the mocks I use are verified by contract tests" feature.
+
+

data/features/customizing_arguments_and_return_values.feature

@@ -0,0 +1,105 @@
+Feature: Customizing arguments and return values
+  As a developer
+  I want the ability to make contract arguments and return values more or less specific
+
+  Background:
+    Given the following classes:
+      """
+      class ObjectUnderTest
+        def do_something(collaborator, input)
+          collaborator.some_method(input)
+        end
+      end
+
+      class Collaborator
+        def some_method(input)
+        end
+      end
+      """
+
+    And the test suite has an after(:suite) callback asking VerifiedDouble to report unverified doubles:
+      """
+      require 'verified_double'
+      require 'main'
+
+      RSpec.configure do |config|
+        config.after :suite do
+          VerifiedDouble::ReportUnverifiedSignatures.new(VerifiedDouble.registry, self).execute
+        end
+      end
+      """
+
+    And a test that uses VerifiedDouble to mock an object:
+      """
+      require 'spec_helper'
+      describe ObjectUnderTest do
+        let(:input) { :input }
+        let(:output) { :output }
+        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
+      """
+
+  Scenario: More general argument
+    Given the test suite has a contract test for the mock:
+      """
+      require 'spec_helper'
+
+      describe 'Collaborator' do
+        it "tests something", verifies_contract: 'Collaborator#some_method(Object)=>Symbol' do
+          # do nothing
+        end
+      end
+      """
+
+    When I run the test suite
+    Then I should not see any output saying the mock is unverified
+
+  Scenario: More specific argument
+    Given the test suite has a contract test for the mock:
+      """
+      require 'spec_helper'
+
+      describe 'Collaborator' do
+        it "tests something", verifies_contract: 'Collaborator#some_method(:input)=>Symbol' do
+          # do nothing
+        end
+      end
+      """
+
+    When I run the test suite
+    Then I should not see any output saying the mock is unverified
+
+  Scenario: More general return value
+    Given the test suite has a contract test for the mock:
+      """
+      require 'spec_helper'
+
+      describe 'Collaborator' do
+        it "tests something", verifies_contract: 'Collaborator#some_method(Symbol)=>Object' do
+          # do nothing
+        end
+      end
+      """
+
+    When I run the test suite
+    Then I should not see any output saying the mock is unverified
+
+  Scenario: More specific return value
+    Given the test suite has a contract test for the mock:
+      """
+      require 'spec_helper'
+
+      describe 'Collaborator' do
+        it "tests something", verifies_contract: 'Collaborator#some_method(Symbol)=>:output' do
+          # do nothing
+        end
+      end
+      """
+
+    When I run the test suite
+    Then I should not see any output saying the mock is unverified

data/lib/verified_double.rb

@@ -1,10 +1,13 @@
 require 'rspec/fire'
 
+require 'verified_double/boolean'
 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/method_signature_value'
 require 'verified_double/output_unverified_signatures'
+require 'verified_double/parse_method_signature'
 require 'verified_double/recording_double'
 require 'verified_double/report_unverified_signatures'
 

data/lib/verified_double/boolean.rb

@@ -0,0 +1,4 @@
+module VerifiedDouble
+  module Boolean
+  end
+end

data/lib/verified_double/get_registered_signatures.rb

@@ -5,7 +5,7 @@ module VerifiedDouble
     end
 
     def execute
-      @double_registry.map(&:method_signatures).flatten.map(&:to_s).uniq
+      @double_registry.map(&:method_signatures).flatten.uniq
     end
   end
 end

data/lib/verified_double/get_unverified_signatures.rb

@@ -5,7 +5,9 @@ module VerifiedDouble
     end
 
     def execute
-      @get_registered_signatures.execute - @get_verified_signatures.execute
+      @get_registered_signatures.execute.select{|registered_signature|
+       @get_verified_signatures.execute.all?{|verified_signature|
+        ! registered_signature.accepts?(verified_signature) } }
     end
   end
 end

data/lib/verified_double/get_verified_signatures.rb

@@ -11,6 +11,7 @@ module VerifiedDouble
         .map{|example| example.metadata[:verifies_contract] }
         .compact
         .uniq
+        .map{|method_signature_string| ParseMethodSignature.new(method_signature_string).execute }
     end
   end
 end

data/lib/verified_double/method_signature.rb

@@ -1,16 +1,55 @@
 module VerifiedDouble
   class MethodSignature
-    attr_accessor :args, :method, :recording_double, :return_value
+    attr_accessor :args, :class_name, :method, :method_operator, :return_values
 
-    def initialize(recording_double)
-      @recording_double = recording_double
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        self.send "#{name}=", value
+      end
+    end
+
+    def accepts?(other)
+      self.class_name == other.class_name &&
+      self.method_operator == other.method_operator &&
+      self.method == other.method &&
+      self.args.size == other.args.size &&
+      (0 ... args.size).all?{|i| self.args[i].accepts?(other.args[i]) } &&
+      self.return_values.size == other.return_values.size &&
+      (0 ... return_values.size).all?{|i| self.return_values[i].accepts?(other.return_values[i]) }
+    end
+
+    def args
+      @args ||= []
+    end
+
+    def eql?(other)
+      to_s.eql?(other.to_s)
+    end
+
+    def hash
+      to_s.hash
+    end
+
+    def recommended_verified_signature
+      self.clone.tap do |result|
+        result.args = result.args.map{|arg| arg.recommended_value }
+        result.return_values = result.return_values.map{|return_value| return_value.recommended_value }
+      end
+    end
+
+    def return_values
+      @return_values ||= []
     end
 
     def to_s
+      args_string = args.map(&:value).map{|v| v || 'nil'}.join(', ')
+      return_values_string = return_values.map(&:value).map{|v| v || 'nil'}.join(', ')
+      return_values_string = nil if return_values_string.empty?
+
       result = [
-        "#{recording_double.class_name}#{recording_double.method_operator}#{method}(#{args && args.map(&:class).join(', ')})",
-        return_value && return_value.class]
-      result.compact.join("=>")
+        "#{class_name}#{method_operator}#{method}(#{args_string})",
+        return_values_string]
+      result.flatten.compact.join("=>")
     end
   end
 end

data/lib/verified_double/method_signature_value.rb

@@ -0,0 +1,29 @@
+module VerifiedDouble
+  class MethodSignatureValue
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def accepts?(other)
+      if self.value.is_a?(Class) || ! other.value.is_a?(Class)
+        self.value == other.value
+      else
+        self.modified_class.ancestors.include?(other.value)
+      end
+    end
+
+    def modified_class
+      if value == true or value == false
+        VerifiedDouble::Boolean
+      else
+        value.class
+      end
+    end
+
+    def recommended_value
+      self.class.new(self.modified_class)
+    end
+  end
+end

data/lib/verified_double/output_unverified_signatures.rb

@@ -6,7 +6,7 @@ module VerifiedDouble
 
     def execute
       if unverified_signatures.any?
-        output = ["The following mocks are not verified:" ] + unverified_signatures
+        output = ["The following mocks are not verified:" ] + unverified_signatures.map(&:recommended_verified_signature)
         puts output.join("\n")
       end
     end

data/lib/verified_double/parse_method_signature.rb

@@ -0,0 +1,49 @@
+module VerifiedDouble
+  class ParseMethodSignature
+    attr_reader :string
+
+    def initialize(string)
+      @string = string
+    end
+
+    def args
+      results = string.scan(/\((.*)\)/)[0]
+      if results
+        results[0].split(',').map{|arg| MethodSignatureValue.new(eval(arg)) }
+      else
+        []
+      end
+    end
+
+    def class_name
+      string.scan(/(.*)[\.\#]/)[0][0]
+    end
+
+    def execute
+      MethodSignature.new(
+        class_name: class_name,
+        method_operator: method_operator,
+        method: method,
+        args: args,
+        return_values: return_values)
+    end
+
+    def method
+      string.scan(/[\.\#](.*?)(=>|\(|$)/)[0][0]
+    end
+
+    def method_operator
+      string.scan(/[\.\#]/)[0][0]
+    end
+
+    def return_values
+      results = string.scan(/=>(.*)/)[0]
+      if results
+        results[0].split(',').map{|return_value|
+          MethodSignatureValue.new(eval(return_value)) }
+      else
+        []
+      end
+    end
+  end
+end

data/lib/verified_double/recording_double.rb

@@ -8,7 +8,7 @@ module VerifiedDouble
     end
 
     def and_return(return_value)
-      self.method_signatures.last.return_value = return_value
+      self.method_signatures.last.return_values = [MethodSignatureValue.new(return_value)]
       @double_call.and_return(return_value)
       self
     end
@@ -38,8 +38,11 @@ module VerifiedDouble
     end
 
     def should_receive(method)
-      method_signature = MethodSignature.new(self)
-      method_signature.method = method
+      method_signature = MethodSignature.new(
+        class_name: class_name,
+        method_operator: method_operator,
+        method: method.to_s)
+
       self.method_signatures << method_signature
       @double_call = super(method)
       self
@@ -50,7 +53,8 @@ module VerifiedDouble
     end
 
     def with(*args)
-      self.method_signatures.last.args = args
+      self.method_signatures.last.args =
+        args.map{|arg| MethodSignatureValue.new(arg) }
       @double_call.with(*args)
       self
     end

data/lib/verified_double/version.rb

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

data/spec/unit_helper.rb

@@ -2,6 +2,14 @@ require 'active_support/core_ext/string'
 require 'pry'
 require 'rspec/fire'
 
+require 'verified_double/boolean'
+
+# Requiring because these are Value objects.
+# As value objects, we treat them as primitives.
+# Hence, there should be no need to mock or stub them.
+require "verified_double/method_signature"
+require "verified_double/method_signature_value"
+
 RSpec.configure do |config|
   config.include(RSpec::Fire)
 end

data/spec/verified_double/get_registered_signatures_spec.rb

@@ -3,10 +3,10 @@ require 'verified_double/get_registered_signatures'
 
 describe VerifiedDouble::GetRegisteredSignatures do
   let(:method_signature_1) {
-    fire_double('VerifiedDouble::MethodSignature', to_s: 'method_signature_1') }
+    VerifiedDouble::MethodSignature.new(class_name: 'Object', method_operator: '#', method: 'to_s') }
 
   let(:method_signature_2) {
-    fire_double('VerifiedDouble::MethodSignature', to_s: 'method_signature_2') }
+    VerifiedDouble::MethodSignature.new(class_name: 'Object', method_operator: '#', method: 'inspect') }
 
   let(:recording_double_1) {
     fire_double('VerifiedDouble::RecordingDouble',
@@ -23,7 +23,7 @@ describe VerifiedDouble::GetRegisteredSignatures 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'])
+        expect(subject.execute).to eq([method_signature_1, method_signature_2])
       end
     end
 
@@ -35,7 +35,7 @@ describe VerifiedDouble::GetRegisteredSignatures do
       let(:double_registry){ [recording_double_1, recording_double_2] }
 
       it "returns distinct method signatures" do
-        expect(subject.execute).to eq(['method_signature_1'])
+        expect(subject.execute).to eq([method_signature_1])
       end
     end
   end

data/spec/verified_double/get_unverified_signatures_spec.rb

@@ -11,16 +11,40 @@ describe VerifiedDouble::GetUnverifiedSignatures do
   subject { described_class.new(get_registered_signatures_service, get_verified_signatures_service) }
 
   describe "#execute" do
-    it "subtracts verified_signatures from registered_signatures" do
+    let(:registered_signature) {
+      VerifiedDouble::MethodSignature.new(
+        class_name: 'Person',
+        method: 'find',
+        method_operator: '.',
+        args: [VerifiedDouble::MethodSignatureValue.new(1)]) }
+
+    let(:registered_signature_without_match) {
+      VerifiedDouble::MethodSignature.new(
+        class_name: 'Person',
+        method: 'save!',
+        method_operator: '#') }
+
+    let(:verified_signature) {
+      VerifiedDouble::MethodSignature.new(
+        class_name: 'Person',
+        method: 'find',
+        method_operator: '.',
+        args: [VerifiedDouble::MethodSignatureValue.new(Object)]) }
+
+    it "retains registered signatures that cannot accept any of the verified_signatures" do
+      expect(registered_signature.accepts?(verified_signature)).to be_true
+      expect(registered_signature_without_match.accepts?(verified_signature)).to be_false
+
       get_registered_signatures_service
         .should_receive(:execute)
-        .and_return([:verified_signature, :unverified_signature])
+        .and_return([registered_signature, registered_signature_without_match])
 
       get_verified_signatures_service
         .should_receive(:execute)
-        .and_return([:verified_signature])
+        .at_least(:once)
+        .and_return([verified_signature])
 
-      expect(subject.execute).to eq([:unverified_signature])
+      expect(subject.execute).to eq([registered_signature_without_match])
     end
   end
 end

data/spec/verified_double/get_verified_signatures_spec.rb

@@ -2,7 +2,16 @@ require 'unit_helper'
 require 'verified_double/get_verified_signatures'
 
 describe VerifiedDouble::GetVerifiedSignatures do
+  let(:method_signature) { VerifiedDouble::MethodSignature.new }
+
   let(:nested_example_group){ double(:nested_example_group) }
+
+  let(:parse_method_signature_service) {
+    fire_double('VerifiedDouble::ParseMethodSignature') }
+
+  let(:parse_method_signature_service_class) {
+    fire_class_double('VerifiedDouble::ParseMethodSignature').as_replaced_constant }
+
   subject { described_class.new(nested_example_group) }
 
   describe "#execute" do
@@ -18,14 +27,35 @@ describe VerifiedDouble::GetVerifiedSignatures 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]])
+
+      parse_method_signature_service_class
+        .should_receive(:new)
+        .with(example_with_verified_contract_tag.metadata[:verifies_contract])
+        .and_return(parse_method_signature_service)
+
+      parse_method_signature_service
+        .should_receive(:execute)
+        .and_return(method_signature)
+
+      expect(subject.execute).to eq([method_signature])
     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]])
+
+      parse_method_signature_service_class
+        .should_receive(:new)
+        .with(example_with_verified_contract_tag.metadata[:verifies_contract])
+        .at_least(:once)
+        .and_return(parse_method_signature_service)
+
+      parse_method_signature_service
+        .should_receive(:execute)
+        .and_return(method_signature)
+
+      expect(subject.execute).to eq([method_signature])
     end
   end
 end

data/spec/verified_double/method_signature_spec.rb

@@ -2,49 +2,152 @@ 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: '#') }
+  class Dummy
+  end
+
+  let(:attributes){
+    { class_name:  'Dummy',
+      method_operator: '#' } }
+
+  describe "#initialize" do
+    it { expect(subject.return_values).to be_empty }
+    it { expect(subject.args).to be_empty }
+  end
 
+  describe "#to_s" do
     subject {
-      described_class.new(recording_double).tap {|method_signature|
+      described_class.new(attributes).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)")
+      it "includes the arg values in the result" do
+        subject.args = [VerifiedDouble::MethodSignatureValue.new(1), VerifiedDouble::MethodSignatureValue.new({})]
+        expect(subject.to_s).to eq("Dummy#do_something(1, {})")
       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.args).to be_empty
         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)")
+      it "displays nil for the arg of the result" do
+        subject.args = [VerifiedDouble::MethodSignatureValue.new(nil)]
+        expect(subject.to_s).to eq("Dummy#do_something(nil)")
       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")
+        subject.return_values = [VerifiedDouble::MethodSignatureValue.new(true)]
+        expect(subject.to_s).to eq("Dummy#do_something()=>true")
       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.return_values).to be_empty
         expect(subject.to_s).to eq("Dummy#do_something()")
       end
     end
   end
+
+  context "multiple method signatures with the same #to_s" do
+    let(:method_signature){
+      described_class.new(attributes).tap {|method_signature|
+        method_signature.method = 'do_something' } }
+
+    let(:method_signature_with_same_to_s){
+      described_class.new(attributes).tap {|method_signature|
+        method_signature.method = 'do_something' } }
+
+    it { expect(method_signature.to_s).to eq(method_signature_with_same_to_s.to_s) }
+    it { expect(method_signature.hash).to eq(method_signature_with_same_to_s.hash) }
+    it { expect(method_signature.eql?(method_signature_with_same_to_s)).to be_true }
+    it { expect([method_signature, method_signature_with_same_to_s].uniq == [method_signature]).to be_true }
+  end
+
+  describe "#accepts?(other)" do
+    let(:method_signature){
+      described_class.new(
+        class_name: 'Dummy',
+        method_operator: '.',
+        method: 'find',
+        args: [VerifiedDouble::MethodSignatureValue.new(1)],
+        return_values: [VerifiedDouble::MethodSignatureValue.new(Dummy.new)]) }
+
+    subject { method_signature.accepts?(other) }
+
+    context "where self has same attributes as other" do
+      let(:other){ method_signature.clone }
+      it { expect(subject).to be_true }
+    end
+
+    context "where self and other have different class names" do
+      let(:other){ method_signature.clone.tap{|ms| ms.class_name = 'Object' } }
+      it { expect(subject).to be_false }
+    end
+
+    context "where self and other have different method operators" do
+      let(:other){ method_signature.clone.tap{|ms| ms.method_operator = '#' } }
+      it { expect(subject).to be_false }
+    end
+
+    context "where self and other have different methods" do
+      let(:other){ method_signature.clone.tap{|ms| ms.method = 'destroy' } }
+      it { expect(subject).to be_false }
+    end
+
+    context "where self and other have different number of args" do
+      let(:other){
+        method_signature.clone.tap{|ms|
+          ms.args = [VerifiedDouble::MethodSignatureValue.new(1), VerifiedDouble::MethodSignatureValue.new(2)] } }
+
+      it { expect(subject).to be_false }
+    end
+
+    context "where not all of self's args accept the args of other" do
+      let(:other){
+        method_signature.clone.tap{|ms|
+          ms.args = [VerifiedDouble::MethodSignatureValue.new(2)] } }
+
+      it { expect(subject).to be_false }
+    end
+
+    context "where self and other have different number of return values" do
+      let(:other){
+        method_signature.clone.tap{|ms|
+          ms.return_values = [VerifiedDouble::MethodSignatureValue.new(1), VerifiedDouble::MethodSignatureValue.new(2)] } }
+
+      it { expect(subject).to be_false }
+    end
+
+    context "where not all of self's return values accept the return values of other" do
+      let(:other){
+        method_signature.clone.tap{|ms|
+          ms.return_values = [VerifiedDouble::MethodSignatureValue.new(Symbol)] } }
+
+      it { expect(subject).to be_false }
+    end
+  end
+
+  describe "#recommended_verified_signature" do
+    let(:method_signature){
+      described_class.new(
+        class_name: 'Dummy',
+        method_operator: '.',
+        method: 'find',
+        args: [VerifiedDouble::MethodSignatureValue.new(1)],
+        return_values: [VerifiedDouble::MethodSignatureValue.new(Dummy.new)]) }
+
+    subject { method_signature.recommended_verified_signature }
+
+    it "is a method signature that is recommended for the user to verify" do
+      expect(subject.args[0].value).to eq(method_signature.args[0].recommended_value.value)
+      expect(subject.return_values[0].value).to eq(method_signature.return_values[0].recommended_value.value)
+    end
+  end
 end

data/spec/verified_double/method_signature_value_spec.rb

@@ -0,0 +1,82 @@
+require 'unit_helper'
+require 'verified_double/method_signature_value'
+
+describe VerifiedDouble::MethodSignatureValue do
+  let(:value){ :some_value }
+
+  describe "#initialize" do
+    it "requires a value from a method signature" do
+      described_class.new(value)
+    end
+  end
+
+  describe "#accepts?(other)" do
+    subject { this.accepts?(other) }
+
+    context "where self's value is an actual class and other's value matches it" do
+      let(:this){ described_class.new(Fixnum) }
+      let(:other){ described_class.new(Fixnum) }
+      it { expect(subject).to be_true }
+    end
+
+    context "where self's value is an actual class and other's value does not match it" do
+      let(:this){ described_class.new(Fixnum) }
+      let(:other){ described_class.new(Object) }
+      it { expect(subject).to be_false }
+    end
+
+    context "where the other value is an instance and self's value matches it" do
+      let(:this){ described_class.new(1) }
+      let(:other){ described_class.new(1) }
+      it { expect(subject).to be_true }
+    end
+
+    context "where the other value is an instance and self's value does not it" do
+      let(:this){ described_class.new(2) }
+      let(:other){ described_class.new(1) }
+      it { expect(subject).to be_false }
+    end
+
+    context "where self is an instance and the other's class is an ancestor of self's modified class" do
+      let(:this){ described_class.new(1) }
+      let(:other){ described_class.new(Object) }
+      it { expect(subject).to be_true }
+    end
+
+    context "where self is an instance and the other's class is not an ancestor of self's modified class" do
+      let(:this){ described_class.new(1) }
+      let(:other){ described_class.new(Float) }
+      it { expect(subject).to be_false }
+    end
+  end
+
+  describe "#modified_class" do
+    subject { method_signature_value.modified_class }
+
+    context "where the value is true" do
+      let(:method_signature_value) { described_class.new(true) }
+      it { expect(subject).to eq(VerifiedDouble::Boolean) }
+    end
+
+    context "where the value is false" do
+      let(:method_signature_value) { described_class.new(false) }
+      it { expect(subject).to eq(VerifiedDouble::Boolean) }
+    end
+
+    context "where the value is not true or false" do
+      let(:method_signature_value) { described_class.new(1) }
+      it "is the class of the value" do
+        expect(subject).to eq(Fixnum)
+      end
+    end
+  end
+
+  describe "#recommended_value" do
+    subject { described_class.new(value) }
+
+    it "is a version of self that will be recommended to users to verify" do
+      expect(subject.recommended_value.value).to eq(subject.modified_class)
+      expect(subject.recommended_value.value).to_not eq(subject)
+    end
+  end
+end

data/spec/verified_double/output_unverified_signatures_spec.rb

@@ -2,10 +2,25 @@ require 'unit_helper'
 require 'verified_double/output_unverified_signatures'
 
 describe VerifiedDouble::OutputUnverifiedSignatures do
+  class Dummy
+  end
+
   let(:get_unverified_signatures_service){
     fire_double('VerifiedDouble::GetUnverifiedSignatures') }
 
-  let(:unverified_signatures){ %w(UNVERIFIED_SIGNATURES_1 UNVERIFIED_SIGNATURES_2) }
+  let(:unverified_signatures){ [
+    VerifiedDouble::MethodSignature.new(
+      class_name: 'Dummy',
+      method_operator: '.',
+      method: 'find',
+      args: [VerifiedDouble::MethodSignatureValue.new(1)],
+      return_values: [VerifiedDouble::MethodSignatureValue.new(Dummy.new)]),
+    VerifiedDouble::MethodSignature.new(
+      class_name: 'Dummy',
+      method_operator: '.',
+      method: 'where',
+      args: [VerifiedDouble::MethodSignatureValue.new(id: 1)],
+      return_values: [VerifiedDouble::MethodSignatureValue.new(Dummy.new)]) ] }
 
   subject { described_class.new(get_unverified_signatures_service) }
 
@@ -20,10 +35,15 @@ describe VerifiedDouble::OutputUnverifiedSignatures do
     end
 
     context "where there are unverified_signatures" do
-      it "should output the unverified_signatures" do
+      it "should output the recommended versions of 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")
 
+        lines = [
+          "The following mocks are not verified:",
+          unverified_signatures[0].recommended_verified_signature,
+          unverified_signatures[1].recommended_verified_signature ]
+
+        subject.should_receive(:puts).with(lines.join("\n"))
         subject.execute
       end
     end

data/spec/verified_double/parse_method_signature_spec.rb

@@ -0,0 +1,95 @@
+require 'unit_helper'
+require 'verified_double/parse_method_signature'
+
+describe VerifiedDouble::ParseMethodSignature do
+  subject { described_class.new(string) }
+
+  describe "#execute" do
+    let(:string){ "Class#method(:arg_1, :arg_2)=>:return_value" }
+
+    subject { described_class.new(string).execute }
+
+    it "returns a method signature from the signature string" do
+      expect(subject).to be_a(VerifiedDouble::MethodSignature)
+      expect(subject.class_name).to eq(subject.class_name)
+      expect(subject.method_operator).to eq(subject.method_operator)
+      expect(subject.method).to eq(subject.method)
+      expect(subject.args).to eq(subject.args)
+      expect(subject.return_values).to eq(subject.return_values)
+    end
+  end
+
+  describe "#method_operator" do
+    context "for Class.method" do
+      let(:string){ "Class.method" }
+      it { expect(subject.method_operator).to eq('.') }
+    end
+
+    context "for Class#method" do
+      let(:string){ "Class#method" }
+      it { expect(subject.method_operator).to eq('#') }
+    end
+  end
+
+  describe "#class_name" do
+    context "for Class.method" do
+      let(:string){ "Class.method" }
+      it { expect(subject.class_name).to eq('Class') }
+    end
+  end
+
+  describe "#method" do
+    context "for Class.method" do
+      let(:string){ "Class.method_1!?" }
+      it { expect(subject.method).to eq('method_1!?') }
+    end
+
+    context "for Class.method(:arg_1, :arg_2)" do
+      let(:string){ "Class.method_1!?(:arg_1, :arg_2)" }
+      it { expect(subject.method).to eq('method_1!?') }
+    end
+
+    context "for Class.method=>return_value" do
+      let(:string){ "Class.method_1!?=>return_value" }
+      it { expect(subject.method).to eq('method_1!?') }
+    end
+  end
+
+
+  describe "#args" do
+    context "for Class.method(:arg_1, :arg_2)" do
+      let(:string){ "Class.method(:arg_1, :arg_2)" }
+
+      it "builds method signature values from the evals of the args" do
+        expect(subject.args.map(&:value)).to eq([:arg_1, :arg_2])
+      end
+    end
+
+    context "for Class.method" do
+      let(:string){ "Class.method" }
+      it { expect(subject.args).to eq([]) }
+    end
+
+    context "for Class.method=>:return_value" do
+      let(:string){ "Class.method=>:return_value" }
+      it { expect(subject.args).to eq([]) }
+    end
+  end
+
+  describe "#return_values" do
+    context "for Class.method=>:return_value" do
+      let(:string){ "Class.method=>:return_value" }
+      it { expect(subject.return_values.map(&:value)).to eq([:return_value]) }
+    end
+
+    context "for Class.method" do
+      let(:string){ "Class.method" }
+      it { expect(subject.return_values).to be_empty }
+    end
+
+    context "for Class.method(:arg_1, :arg_2)" do
+      let(:string){ "Class.method(:arg_1, :arg_2)" }
+      it { expect(subject.return_values).to be_empty }
+    end
+  end
+end

data/spec/verified_double/recording_double_spec.rb

@@ -104,7 +104,7 @@ describe VerifiedDouble::RecordingDouble do
       subject.should_receive(:to_s)
       subject.should_receive(:inspect)
 
-      expect(subject.method_signatures.map(&:method)).to eq([:to_s, :inspect])
+      expect(subject.method_signatures.map(&:method)).to eq(['to_s', 'inspect'])
 
       subject.to_s
       subject.inspect
@@ -115,7 +115,8 @@ describe VerifiedDouble::RecordingDouble 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])
+      expect(subject.method_signatures[0].args).to be_all{|arg| arg.is_a?(VerifiedDouble::MethodSignatureValue) }
+      expect(subject.method_signatures[0].args.map(&:value)).to eq([:arg_1, :arg_2])
 
       subject.to_s(:arg_1, :arg_2)
     end
@@ -125,7 +126,10 @@ describe VerifiedDouble::RecordingDouble 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)
+      return_values = subject.method_signatures[0].return_values
+      expect(return_values).to have(1).return_value
+      expect(return_values.first).to be_a(VerifiedDouble::MethodSignatureValue)
+      expect(return_values.first.value).to eq(:return_value)
 
       subject.to_s(:arg_1, :arg_2)
     end

data/verified_double.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_runtime_dependency "rspec"
-  gem.add_runtime_dependency "rspec-fire"
+  gem.add_runtime_dependency "rspec-fire", '~> 1.1.3'
 
   gem.add_development_dependency "aruba"
   gem.add_development_dependency "cucumber"

metadata

@@ -2,14 +2,14 @@
 name: verified_double
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - George Mendoza
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-02 00:00:00.000000000 Z
+date: 2013-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   type: :runtime
@@ -32,16 +32,16 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.3
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.3
   name: rspec-fire
 - !ruby/object:Gem::Dependency
   type: :development
@@ -116,20 +116,26 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- CHANGELOG.markdown
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- features/CHANGELOG.markdown
+- features/customizing_arguments_and_return_values.feature
 - 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/boolean.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/method_signature_value.rb
 - lib/verified_double/output_unverified_signatures.rb
+- lib/verified_double/parse_method_signature.rb
 - lib/verified_double/recording_double.rb
 - lib/verified_double/report_unverified_signatures.rb
 - lib/verified_double/verify_doubles_service.rb
@@ -140,7 +146,9 @@ files:
 - 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/method_signature_value_spec.rb
 - spec/verified_double/output_unverified_signatures_spec.rb
+- spec/verified_double/parse_method_signature_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
@@ -172,6 +180,8 @@ 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/CHANGELOG.markdown
+- features/customizing_arguments_and_return_values.feature
 - features/readme.md
 - features/step_definitions/verified_double_steps.rb
 - features/support/requires.rb
@@ -182,7 +192,9 @@ test_files:
 - 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/method_signature_value_spec.rb
 - spec/verified_double/output_unverified_signatures_spec.rb
+- spec/verified_double/parse_method_signature_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