verified_double 0.1.1 → 0.2.0

data/lib/verified_double/stack_frame.rb

@@ -0,0 +1,11 @@
+module VerifiedDouble
+  class StackFrame
+    def initialize(string)
+      @string = string
+    end
+
+    def to_s
+      @string.gsub(%r{.*/spec/}, "./spec/")
+    end
+  end
+end

data/lib/verified_double/version.rb

@@ -1,3 +1,3 @@
 module VerifiedDouble
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'pry'
 require 'verified_double'
 
 # This file was generated by the `rspec --init` command. Conventionally, all

data/spec/verified_double/matchers_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_helper'
+require 'spec_helper'
 require 'verified_double/matchers'
 
 describe VerifiedDouble::Matchers do

data/spec/verified_double/method_signature/boolean_value_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe VerifiedDouble::MethodSignature::BooleanValue do
+  subject { described_class.new(true) }
+
+  describe "#content_class" do
+    it "should be VerifiedDouble::Boolean" do
+      expect(subject.content_class).to eq(VerifiedDouble::Boolean)
+    end
+  end
+end

data/spec/verified_double/method_signature/class_value_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe VerifiedDouble::MethodSignature::ClassValue do
+  subject { described_class.new(String) }
+
+  describe "#belongs_to?(other)" do
+    context "where the value and other have the same content" do
+      let(:other) { described_class.new(String) }
+      it { expect(subject.belongs_to?(other)).to be_true }
+    end
+
+    context "where the value and other do not have the same content" do
+      let(:other) { described_class.new(Object) }
+      it { expect(subject.belongs_to?(other)).to be_false }
+    end
+  end
+
+  describe "#content_as_instance" do
+    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.content_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.content_as_instance).to be_an(Object)
+      end
+    end
+  end
+end

data/spec/verified_double/method_signature/instance_double_value_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe VerifiedDouble::MethodSignature::InstanceDoubleValue do
+  class Item
+  end
+
+  let(:class_name){ 'Item' }
+  let(:some_instance_double){ double(class_name) }
+  let(:recording_instance_double) { VerifiedDouble::RecordingDouble.new(some_instance_double, class_name) }
+  subject { described_class.new(recording_instance_double) }
+
+  describe "#content_as_instance" do
+    it "is the equivalent content_as_instance of the content's class" do
+      expect(subject.content_as_instance).to be_a(Item)
+    end
+  end
+end

data/spec/verified_double/method_signature/instance_value_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe VerifiedDouble::MethodSignature::InstanceValue do
+  describe "#belongs_to?(other)" do
+    subject { this.belongs_to?(other) }
+
+    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 match 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){ VerifiedDouble::MethodSignature::ClassValue.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){ VerifiedDouble::MethodSignature::ClassValue.new(Float) }
+      it { expect(subject).to be_false }
+    end
+  end
+
+  describe "#content_as_instance" do
+    subject { described_class.new(:some_value) }
+
+    it "returns the value" do
+      expect(subject.content_as_instance).to eq(:some_value)
+    end
+  end
+end

data/spec/verified_double/method_signature/recording_double_class_value_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe VerifiedDouble::MethodSignature::RecordingDoubleClassValue do
+  class Dummy
+  end
+
+  let(:class_name) {  'Dummy' }
+  let(:some_class_double) { stub_const(class_name, Class.new) }
+  let(:recording_class_double) { VerifiedDouble::RecordingDouble.new(some_class_double, class_name) }
+
+  subject { described_class.new(recording_class_double) }
+
+  describe "#belongs_to(other)" do
+    context "where the doubled class of the recording double belongs to the other value" do
+      it { expect(subject.belongs_to?(VerifiedDouble::MethodSignature::ClassValue.new(Dummy))).to be_true }
+    end
+
+    context "where the doubled class of the recording double does not belong to the other value" do
+      it { expect(subject.belongs_to?(VerifiedDouble::MethodSignature::ClassValue.new(Object))).to be_false }
+    end
+  end
+
+end

data/spec/verified_double/method_signature/rspec_double_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe VerifiedDouble::MethodSignature::RspecDoubleValue do
+  let(:rspec_double) { double('Object') }
+  subject { described_class.new(rspec_double) }
+
+  describe "#content_class" do
+    context "where the value is a double" do
+      it "is the class represented by the class_name of the recording double" do
+        expect(subject.content_class).to eq(Object)
+      end
+    end
+  end
+end

data/spec/verified_double/method_signature/value_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'verified_double/method_signature/value'
+
+describe VerifiedDouble::MethodSignature::Value do
+  class Dummy
+  end
+
+  let(:class_name){ 'Dummy' }
+
+  let(:value){ :some_value }
+
+  describe ".from(content)" do
+    subject { described_class.from(content) }
+
+    context "where content is true" do
+      let(:content) { true }
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::BooleanValue) }
+    end
+
+    context "where content is false" do
+      let(:content) { false }
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::BooleanValue) }
+    end
+
+    context "where content is a class" do
+      let(:content) { String }
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::ClassValue) }
+    end
+
+    context "where content is a module" do
+      let(:content) { VerifiedDouble }
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::ClassValue) }
+    end
+
+    context "where content is an rspec mock" do
+      let(:content) { double(:stuff) }
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::RspecDoubleValue) }
+    end
+
+    context "where content is an class recording double" do
+      let(:class_double){ stub_const(class_name, Class.new, transfer_nested_constants: true) }
+      let(:content) { VerifiedDouble::RecordingDouble.new(class_double, class_name) }
+
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::RecordingDoubleClassValue) }
+    end
+
+    context "where content is an instance recording double" do
+      let(:some_instance_double){ double('Dummy') }
+      let(:content) { VerifiedDouble::RecordingDouble.new(some_instance_double, class_name) }
+
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::InstanceDoubleValue) }
+    end
+
+    context "where content is an instance" do
+      let(:content) { :some_symbol }
+
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::InstanceValue) }
+    end
+  end
+
+  describe "#content_class" do
+    subject { method_signature_value.content_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 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.content).to eq(subject.content_class)
+      expect(subject.recommended_value.content).to_not eq(subject)
+    end
+  end
+end

data/spec/verified_double/method_signature_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_helper'
+require 'spec_helper'
 require 'verified_double/method_signature'
 
 describe VerifiedDouble::MethodSignature do
@@ -21,7 +21,7 @@ describe VerifiedDouble::MethodSignature do
 
     context "when there are args" do
       it "includes the arg values in the result" do
-        subject.args = [VerifiedDouble::MethodSignatureValue.new(1), VerifiedDouble::MethodSignatureValue.new({})]
+        subject.args = [VerifiedDouble::MethodSignature::Value.from(1), VerifiedDouble::MethodSignature::Value.from({})]
         expect(subject.to_s).to eq("Dummy#do_something(1, {})")
       end
     end
@@ -35,14 +35,14 @@ describe VerifiedDouble::MethodSignature do
 
     context "when there is a nil arg" do
       it "displays nil for the arg of the result" do
-        subject.args = [VerifiedDouble::MethodSignatureValue.new(nil)]
+        subject.args = [VerifiedDouble::MethodSignature::Value.from(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_values = [VerifiedDouble::MethodSignatureValue.new(true)]
+        subject.return_values = [VerifiedDouble::MethodSignature::Value.from(true)]
         expect(subject.to_s).to eq("Dummy#do_something()=>true")
       end
     end
@@ -70,16 +70,16 @@ describe VerifiedDouble::MethodSignature do
     it { expect([method_signature, method_signature_with_same_to_s].uniq == [method_signature]).to be_true }
   end
 
-  describe "#accepts?(other)" do
+  describe "#belongs_to?(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)]) }
+        args: [VerifiedDouble::MethodSignature::Value.from(1)],
+        return_values: [VerifiedDouble::MethodSignature::Value.from(Dummy.new)]) }
 
-    subject { method_signature.accepts?(other) }
+    subject { method_signature.belongs_to?(other) }
 
     context "where self has same attributes as other" do
       let(:other){ method_signature.clone }
@@ -104,7 +104,7 @@ describe VerifiedDouble::MethodSignature do
     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)] } }
+          ms.args = [VerifiedDouble::MethodSignature::Value.from(1), VerifiedDouble::MethodSignature::Value.from(2)] } }
 
       it { expect(subject).to be_false }
     end
@@ -112,7 +112,7 @@ describe VerifiedDouble::MethodSignature do
     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)] } }
+          ms.args = [VerifiedDouble::MethodSignature::Value.from(2)] } }
 
       it { expect(subject).to be_false }
     end
@@ -120,7 +120,7 @@ describe VerifiedDouble::MethodSignature do
     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)] } }
+          ms.return_values = [VerifiedDouble::MethodSignature::Value.from(1), VerifiedDouble::MethodSignature::Value.from(2)] } }
 
       it { expect(subject).to be_false }
     end
@@ -128,7 +128,7 @@ describe VerifiedDouble::MethodSignature do
     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)] } }
+          ms.return_values = [VerifiedDouble::MethodSignature::Value.from(Symbol)] } }
 
       it { expect(subject).to be_false }
     end
@@ -140,14 +140,14 @@ describe VerifiedDouble::MethodSignature do
         class_name: 'Dummy',
         method_operator: '.',
         method: 'find',
-        args: [VerifiedDouble::MethodSignatureValue.new(1)],
-        return_values: [VerifiedDouble::MethodSignatureValue.new(Dummy.new)]) }
+        args: [VerifiedDouble::MethodSignature::Value.from(1)],
+        return_values: [VerifiedDouble::MethodSignature::Value.from(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)
+      expect(subject.args[0].content).to eq(method_signature.args[0].recommended_value.content)
+      expect(subject.return_values[0].content).to eq(method_signature.return_values[0].recommended_value.content)
     end
   end
 end

data/spec/verified_double/method_signatures_report_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_helper'
+require 'spec_helper'
 require 'verified_double'
 require 'verified_double/method_signatures_report'
 
@@ -114,7 +114,7 @@ describe VerifiedDouble::MethodSignaturesReport do
         class_name: 'Person',
         method: 'find',
         method_operator: '.',
-        args: [VerifiedDouble::MethodSignatureValue.new(1)]) }
+        args: [VerifiedDouble::MethodSignature::Value.from(1)]) }
 
     let(:registered_signature_without_match) {
       VerifiedDouble::MethodSignature.new(
@@ -127,11 +127,11 @@ describe VerifiedDouble::MethodSignaturesReport do
         class_name: 'Person',
         method: 'find',
         method_operator: '.',
-        args: [VerifiedDouble::MethodSignatureValue.new(Object)]) }
+        args: [VerifiedDouble::MethodSignature::Value.from(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
+      expect(registered_signature.belongs_to?(verified_signature)).to be_true
+      expect(registered_signature_without_match.belongs_to?(verified_signature)).to be_false
 
       subject.registered_signatures = [registered_signature, registered_signature_without_match]
       subject.verified_signatures = [verified_signature]
@@ -151,14 +151,14 @@ describe VerifiedDouble::MethodSignaturesReport do
         class_name: 'Dummy',
         method_operator: '.',
         method: 'find',
-        args: [VerifiedDouble::MethodSignatureValue.new(1)],
-        return_values: [VerifiedDouble::MethodSignatureValue.new(Dummy.new)]),
+        args: [VerifiedDouble::MethodSignature::Value.from(1)],
+        return_values: [VerifiedDouble::MethodSignature::Value.from(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)]) ] }
+        args: [VerifiedDouble::MethodSignature::Value.from(id: 1)],
+        return_values: [VerifiedDouble::MethodSignature::Value.from(Dummy.new)]) ] }
 
     context "where there are no unverified_signatures" do
       it "should not output anything" do
@@ -173,11 +173,13 @@ describe VerifiedDouble::MethodSignaturesReport do
         subject.unverified_signatures = unverified_signatures
 
         lines = [
+          nil,
           "The following mocks are not verified:",
-          unverified_signatures[0].recommended_verified_signature,
-          unverified_signatures[1].recommended_verified_signature ]
+          "1. #{unverified_signatures[0].recommended_verified_signature}",
+          "2. #{unverified_signatures[1].recommended_verified_signature}",
+          "For more info, check out https://www.relishapp.com/gsmendoza/verified-double." ]
 
-        subject.should_receive(:puts).with(lines.join("\n"))
+        subject.should_receive(:puts).with(lines.join("\n\n"))
         subject.output_unverified_signatures
       end
     end

data/spec/verified_double/parse_method_signature_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_helper'
+require 'spec_helper'
 require 'verified_double/parse_method_signature'
 
 describe VerifiedDouble::ParseMethodSignature do
@@ -65,7 +65,7 @@ describe VerifiedDouble::ParseMethodSignature 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])
+        expect(subject.args.map(&:content)).to eq([:arg_1, :arg_2])
       end
     end
 
@@ -83,7 +83,7 @@ describe VerifiedDouble::ParseMethodSignature do
   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]) }
+      it { expect(subject.return_values.map(&:content)).to eq([:return_value]) }
     end
 
     context "for Class.method" do