verified_double 0.0.2 → 0.1.0

data/spec/unit_helper.rb

@@ -1,6 +1,5 @@
 require 'active_support/core_ext/string'
 require 'pry'
-require 'rspec/fire'
 
 require 'verified_double/boolean'
 
@@ -10,6 +9,8 @@ require 'verified_double/boolean'
 require "verified_double/method_signature"
 require "verified_double/method_signature_value"
 
+# Requiring because these are macros.
+require 'verified_double/relays_to_internal_double_returning_self'
+
 RSpec.configure do |config|
-  config.include(RSpec::Fire)
 end

data/spec/verified_double/matchers_spec.rb

@@ -0,0 +1,96 @@
+require 'unit_helper'
+require 'verified_double/matchers'
+
+describe VerifiedDouble::Matchers do
+  include VerifiedDouble::Matchers
+
+  describe "#verify_accessor_contract(contract)" do
+    class Collaborator
+      attr_accessor :value
+    end
+
+    let(:contract) { 'Collaborator#value()=>String' }
+
+    subject { Collaborator.new }
+
+    it "adds the method signature to the verified signatures from matchers" do
+      expect(subject).to verify_accessor_contract(contract)
+      expect(VerifiedDouble.verified_signatures_from_matchers.last.to_s).to eq(contract)
+    end
+
+    context "where the contract has multiple return values" do
+      let(:contract) { 'Collaborator#value=>String,Integer' }
+
+      it "complains that the matcher expects only one return value" do
+        expect { expect(subject).to verify_accessor_contract(contract) }
+          .to raise_error(described_class::CannotHandleMultipleReturnValues)
+      end
+    end
+
+    context "where the contract return value can be initialized" do
+      let(:contract) { 'Collaborator#value=>String' }
+
+      it "assigns the initialized value to the subject's writer and compares it to the subject's reader" do
+        expect(subject.value).to be_nil
+
+        expect(subject).to verify_accessor_contract(contract)
+        expect(subject.value).to eq(String.new)
+      end
+    end
+
+    context "where the contract return value is a class which cannot be initialized" do
+      let(:contract) { 'Collaborator#value=>Integer' }
+
+      it "assigns the a new object to the subject's writer and compares it to the subject's reader" do
+        expect(subject.value).to be_nil
+
+        expect(subject).to verify_accessor_contract(contract)
+        expect(subject.value.class).to eq(Object)
+      end
+    end
+
+    context "where the contract return value is an instance" do
+      let(:contract) { 'Collaborator#value=>1' }
+
+      it "assigns the instance to the subject's writer and compares it to the subject's reader" do
+        expect(subject.value).to be_nil
+
+        expect(subject).to verify_accessor_contract(contract)
+        expect(subject.value).to eq(1)
+      end
+    end
+  end
+
+  describe "#verify_reader_contract" do
+    class AnotherCollaborator
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+    end
+
+    let(:contract) { 'AnotherCollaborator#value()=>String' }
+    let(:value) { 'a string' }
+
+    subject { AnotherCollaborator.new(value) }
+
+    it "checks if the method being verified has the same class as the return value" do
+      expect(subject).to verify_reader_contract(contract)
+    end
+
+    it "adds the method signature to the verified signatures from matchers" do
+      expect(subject).to verify_reader_contract(contract)
+      expect(VerifiedDouble.verified_signatures_from_matchers.last.to_s).to eq(contract)
+    end
+
+    context "where the contract has multiple return values" do
+      let(:contract) { 'Collaborator#value=>String,Integer' }
+
+      it "complains that the matcher expects only one return value" do
+        expect { expect(subject).to verify_reader_contract(contract) }
+          .to raise_error(described_class::CannotHandleMultipleReturnValues)
+      end
+    end
+  end
+end

data/spec/verified_double/method_signature_value_spec.rb

@@ -53,6 +53,15 @@ describe VerifiedDouble::MethodSignatureValue do
   describe "#modified_class" do
     subject { method_signature_value.modified_class }
 
+    context "where the value is recording double" do
+      let(:recording_double){ VerifiedDouble.of_instance('Object') }
+      let(:method_signature_value) { described_class.new(recording_double) }
+
+      it "is the class represented by the class_name of the recording double" do
+        expect(subject).to eq(Object)
+      end
+    end
+
     context "where the value is true" do
       let(:method_signature_value) { described_class.new(true) }
       it { expect(subject).to eq(VerifiedDouble::Boolean) }
@@ -79,4 +88,30 @@ describe VerifiedDouble::MethodSignatureValue do
       expect(subject.recommended_value.value).to_not eq(subject)
     end
   end
+
+  describe "#as_instance" do
+    context "where the value is an instance" do
+      subject { described_class.new(:some_value) }
+
+      it "returns the value" do
+        expect(subject.as_instance).to eq(:some_value)
+      end
+    end
+
+    context "where the value is a class which can be initialized" do
+      subject { described_class.new(String) }
+
+      it "returns the initialized instance of the value " do
+        expect(subject.as_instance).to eq(String.new)
+      end
+    end
+
+    context "where the value is a class which cannot be initialized" do
+      subject { described_class.new(Integer) }
+
+      it "returns an object" do
+        expect(subject.as_instance).to be_an(Object)
+      end
+    end
+  end
 end

data/spec/verified_double/method_signatures_report_spec.rb

@@ -0,0 +1,214 @@
+require 'unit_helper'
+require 'verified_double'
+require 'verified_double/method_signatures_report'
+
+describe VerifiedDouble::MethodSignaturesReport do
+  describe "initialize", verifies_contract: 'VerifiedDouble::MethodSignaturesReport.new()=>VerifiedDouble::MethodSignaturesReport' do
+    it { expect(described_class.new).to be_a(VerifiedDouble::MethodSignaturesReport) }
+  end
+
+  describe "#set_registered_signatures", verifies_contract: 'VerifiedDouble::MethodSignaturesReport#set_registered_signatures()=>VerifiedDouble::MethodSignaturesReport' do
+
+    let(:recording_double_1) {
+      double('VerifiedDouble::RecordingDouble',
+        method_signatures: [method_signature_1]) }
+
+    let(:recording_double_2) {
+      double('VerifiedDouble::RecordingDouble',
+        method_signatures: [method_signature_2]) }
+
+    let(:method_signature_1) {
+      VerifiedDouble::MethodSignature.new(class_name: 'Object', method_operator: '#', method: 'to_s') }
+
+    let(:method_signature_2) {
+      VerifiedDouble::MethodSignature.new(class_name: 'Object', method_operator: '#', method: 'inspect') }
+
+    let(:verified_double_module){ VerifiedDouble.of_class('VerifiedDouble') }
+
+    context "with multiple recording doubles in the registry" do
+      it "maps and flattens the method signatures of the recording doubles" do
+        verified_double_module
+          .should_receive(:registry)
+          .and_return([recording_double_1, recording_double_2])
+
+        expect(subject.set_registered_signatures.registered_signatures).to eq(
+          [method_signature_1, method_signature_2])
+      end
+    end
+
+    context "with recording doubles with duplicate signatures" do
+      let(:recording_double_2) {
+        double('VerifiedDouble::RecordingDouble',
+          method_signatures: [method_signature_1]) }
+
+      it "returns distinct method signatures" do
+        verified_double_module
+          .should_receive(:registry)
+          .and_return([recording_double_1, recording_double_2])
+
+        expect(subject.set_registered_signatures.registered_signatures).to eq([method_signature_1])
+      end
+    end
+  end
+
+  describe "#set_verified_signatures_from_tags", verifies_contract: 'VerifiedDouble::MethodSignaturesReport#set_verified_signatures_from_tags()=>VerifiedDouble::MethodSignaturesReport' do
+    let(:method_signature) { VerifiedDouble::MethodSignature.new }
+
+    let(:nested_example_group){ double(:nested_example_group) }
+
+    let(:parse_method_signature_service) {
+      VerifiedDouble.of_instance('VerifiedDouble::ParseMethodSignature') }
+
+    let(:parse_method_signature_service_class) {
+      VerifiedDouble.of_class('VerifiedDouble::ParseMethodSignature') }
+
+    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 }) }
+
+    subject { described_class.new.set_verified_signatures_from_tags(nested_example_group) }
+
+    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])
+
+      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.verified_signatures_from_tags).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])
+
+      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.verified_signatures_from_tags).to eq([method_signature])
+    end
+  end
+
+  describe "#identify_unverified_signatures", verifies_contract: 'VerifiedDouble::MethodSignaturesReport#identify_unverified_signatures()=>VerifiedDouble::MethodSignaturesReport' 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
+
+      subject.registered_signatures = [registered_signature, registered_signature_without_match]
+      subject.verified_signatures = [verified_signature]
+
+      expect(subject.unverified_signatures).to be_empty
+      expect(subject.identify_unverified_signatures).to eq(subject)
+      expect(subject.unverified_signatures).to eq([registered_signature_without_match])
+    end
+  end
+
+  describe "#output_unverified_signatures", verifies_contract: 'VerifiedDouble::MethodSignaturesReport#output_unverified_signatures()=>VerifiedDouble::MethodSignaturesReport' do
+    class Dummy
+    end
+
+    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)]) ] }
+
+    context "where there are no unverified_signatures" do
+      it "should not output anything" do
+        subject.unverified_signatures = []
+        subject.should_not_receive(:puts)
+        expect(subject.output_unverified_signatures).to eq(subject)
+      end
+    end
+
+    context "where there are unverified_signatures" do
+      it "should output the recommended versions of the unverified_signatures" do
+        subject.unverified_signatures = unverified_signatures
+
+        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.output_unverified_signatures
+      end
+    end
+  end
+
+  describe "#set_verified_signatures_from_matchers", verifies_contract: 'VerifiedDouble::MethodSignaturesReport#set_verified_signatures_from_matchers()=>VerifiedDouble::MethodSignaturesReport' do
+    let(:verified_double_module){
+      VerifiedDouble.of_class('VerifiedDouble') }
+
+    let(:method_signature) { VerifiedDouble::MethodSignature.new }
+
+    it "works" do
+      verified_double_module
+        .should_receive(:verified_signatures_from_matchers)
+        .and_return([method_signature])
+
+      expect(subject.set_verified_signatures_from_matchers.verified_signatures_from_matchers)
+        .to eq([method_signature])
+    end
+  end
+
+  describe "#merge_verified_signatures", verifies_contract: 'VerifiedDouble::MethodSignaturesReport#merge_verified_signatures()=>VerifiedDouble::MethodSignaturesReport' do
+    let(:method_signature_from_tag) { VerifiedDouble::MethodSignature.new }
+    let(:method_signature_from_matcher) { VerifiedDouble::MethodSignature.new }
+
+    it "merges the verified signatures from the tags and the matchers" do
+      subject.verified_signatures_from_tags = [method_signature_from_tag]
+      subject.verified_signatures_from_matchers = [method_signature_from_matcher]
+
+      expect(subject.verified_signatures).to be_empty
+      expect(subject.merge_verified_signatures.verified_signatures).to eq([method_signature_from_tag, method_signature_from_matcher])
+    end
+  end
+end

data/spec/verified_double/parse_method_signature_spec.rb

@@ -4,7 +4,11 @@ require 'verified_double/parse_method_signature'
 describe VerifiedDouble::ParseMethodSignature do
   subject { described_class.new(string) }
 
-  describe "#execute" do
+  describe "#initialize", verifies_contract: 'VerifiedDouble::ParseMethodSignature.new(String)=>VerifiedDouble::ParseMethodSignature' do
+    it { expect(described_class.new("Class#method(:arg_1, :arg_2)=>:return_value")).to be_a(VerifiedDouble::ParseMethodSignature) }
+  end
+
+  describe "#execute", verifies_contract: 'VerifiedDouble::ParseMethodSignature#execute()=>VerifiedDouble::MethodSignature' do
     let(:string){ "Class#method(:arg_1, :arg_2)=>:return_value" }
 
     subject { described_class.new(string).execute }

data/spec/verified_double/recording_double_spec.rb

@@ -5,12 +5,23 @@ describe VerifiedDouble::RecordingDouble do
   let(:class_name) {  'Object' }
   let(:internal_double) { double(class_name) }
 
-  subject { VerifiedDouble::RecordingDouble.new(internal_double) }
+  subject { VerifiedDouble::RecordingDouble.new(internal_double, class_name) }
 
   describe "#initialize" do
     it "requires a double" do
       expect(subject.double).to eq(internal_double)
     end
+
+    context "with method_stubs hash" do
+      let(:stubbed_method){ :some_method }
+      let(:assumed_output){ :some_output }
+
+      subject { VerifiedDouble::RecordingDouble.new(internal_double, class_name, some_method: assumed_output) }
+
+      it "stubs the methods of the instance" do
+        expect(subject.send(stubbed_method)).to eq(assumed_output)
+      end
+    end
   end
 
   it "delegates all unknown calls to its internal double" do
@@ -24,14 +35,14 @@ describe VerifiedDouble::RecordingDouble do
 
     context "where the internal double is a class" do
       let(:class_name) { 'Dummy' }
-      let(:internal_double) { fire_class_double(class_name).as_replaced_constant }
+      let(:internal_double) { stub_const(class_name, Class.new) }
 
       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) }
+      let(:internal_double) { double(class_name) }
 
       it { expect(subject.to_s).to eq("VerifiedDouble.of_instance('#{class_name}')") }
     end
@@ -44,42 +55,42 @@ describe VerifiedDouble::RecordingDouble do
   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)
+    context "where the internal double is a double" do
+      it "is the name of the class represented by the double" do
+        internal_double = double('Object')
+        subject = described_class.new(internal_double, 'Object')
         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)
+    context "where the internal double is a stub const" do
+      it "is the name of the class represented by the class double" do
+        internal_double = stub_const('Object', Class.new)
+        subject = described_class.new(internal_double, 'Object')
         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)
+    it "should be true if the internal double is a class double" do
+      internal_double = double('Object')
+      subject = described_class.new(internal_double, 'Object')
       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)
+    it "should be false if the internal double is not an class double" do
+      internal_double = stub_const('Object', Class.new)
+      subject = described_class.new(internal_double, 'Object')
       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') }
+      let(:internal_double) { double(class_name) }
 
-      subject { VerifiedDouble::RecordingDouble.new(internal_double) }
+      subject { VerifiedDouble::RecordingDouble.new(internal_double, class_name) }
 
       it "is #" do
         expect(subject.method_operator).to eq("#")
@@ -87,9 +98,9 @@ describe VerifiedDouble::RecordingDouble do
     end
 
     context "when the subject wraps a class double" do
-      let(:internal_double) { fire_class_double('Object') }
+      let(:internal_double) { stub_const(class_name, Class.new) }
 
-      subject { VerifiedDouble::RecordingDouble.new(internal_double) }
+      subject { VerifiedDouble::RecordingDouble.new(internal_double, class_name) }
 
       it "is '.'" do
         expect(subject.method_operator).to eq(".")
@@ -101,37 +112,99 @@ describe VerifiedDouble::RecordingDouble 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)
+      subject.should_receive(:fake_to_s)
+      subject.should_receive(:fake_inspect)
 
-      expect(subject.method_signatures.map(&:method)).to eq(['to_s', 'inspect'])
+      expect(subject.method_signatures.map(&:method)).to eq(['fake_to_s', 'fake_inspect'])
 
-      subject.to_s
-      subject.inspect
+      subject.fake_to_s
+      subject.fake_inspect
+    end
+  end
+
+  describe "#stub(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.stub(:fake_to_s)
+      subject.stub(:fake_inspect)
+
+      expect(subject.method_signatures.map(&:method)).to eq(['fake_to_s', 'fake_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)
+      subject.should_receive(:fake_to_s).with(: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)
+      subject.fake_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)
+      subject.should_receive(:fake_to_s).with(:arg_1, :arg_2).and_return(: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)
+      subject.fake_to_s(:arg_1, :arg_2)
+    end
+  end
+
+  describe "#once" do
+    it "is relayed to the internal double and returns the recording double" do
+      expect(subject.should_receive(:fake_to_s).once).to be_a(described_class)
+      subject.fake_to_s
+    end
+  end
+
+  describe "#twice" do
+    it "is relayed to the internal double and returns the recording double" do
+      expect(subject.should_receive(:fake_to_s).twice).to be_a(described_class)
+      subject.fake_to_s
+      subject.fake_to_s
+    end
+  end
+
+  describe "#at_least" do
+    it "is relayed to the internal double and returns the recording double" do
+      expect(subject.should_receive(:fake_to_s).at_least(:once)).to be_a(described_class)
+      subject.fake_to_s
+    end
+  end
+
+  describe "#at_most" do
+    it "is relayed to the internal double and returns the recording double" do
+      expect(subject.should_receive(:fake_to_s).at_most(:once)).to be_a(described_class)
+      subject.fake_to_s
+    end
+  end
+
+  describe "#any_number_of_times" do
+    it "is relayed to the internal double and returns the recording double" do
+      expect(subject.should_receive(:fake_to_s).any_number_of_times).to be_a(described_class)
+    end
+  end
+
+  describe "#and_raise" do
+    let(:some_error){ Exception.new }
+
+    it "is relayed to the internal double and returns the recording double" do
+      expect(subject.should_receive(:fake_to_s).and_raise(some_error)).to be_a(described_class)
+      expect { subject.fake_to_s }.to raise_error(some_error)
+    end
+  end
+
+  describe "#and_raise" do
+    it "is relayed to the internal double and returns the recording double" do
+      expect(subject.should_receive(:fake_to_s).and_throw(:some_error)).to be_a(described_class)
+      expect { subject.fake_to_s }.to throw_symbol(:some_error)
     end
   end
 end