verified_double 0.1.1 → 0.2.0

data/spec/verified_double/recorded_method_signature_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe VerifiedDouble::RecordedMethodSignature do
+  class Dummy
+  end
+
+  let(:stack_frame_string){ "./lib/verified_double/method_signature.rb:7:in `block in initialize'" }
+
+  let(:attributes){
+    { class_name:  'Dummy',
+      method_operator: '#',
+      stack_frame: VerifiedDouble::StackFrame.new(stack_frame_string) } }
+
+  subject {
+    described_class.new(attributes).tap {|method_signature|
+      method_signature.method = 'do_something' } }
+
+  describe "#to_s" do
+    it "includes the stack frame" do
+      expect(subject.to_s).to include(stack_frame_string)
+    end
+  end
+end

data/spec/verified_double/recording_double_spec.rb

@@ -1,194 +1,194 @@
-require 'unit_helper'
+require 'spec_helper'
 require "verified_double/recording_double"
 
 describe VerifiedDouble::RecordingDouble do
-  let(:class_name) {  'Object' }
-  let(:internal_double) { double(class_name) }
+  class Dummy
+  end
+
+  let(:class_name) {  'Dummy' }
+  let(:some_instance_double) { double(class_name) }
+  let(:some_class_double) { stub_const(class_name, Class.new) }
 
-  subject { VerifiedDouble::RecordingDouble.new(internal_double, class_name) }
+  let(:recording_instance_double) { VerifiedDouble::RecordingDouble.new(some_instance_double, class_name) }
+  let(:recording_class_double) { VerifiedDouble::RecordingDouble.new(some_class_double, class_name) }
 
   describe "#initialize" do
     it "requires a double" do
-      expect(subject.double).to eq(internal_double)
+      expect(recording_instance_double.double).to eq(some_instance_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) }
+      let(:recording_instance_double) {
+        VerifiedDouble::RecordingDouble.new(
+          some_instance_double,
+          class_name,
+          some_method: assumed_output) }
 
       it "stubs the methods of the instance" do
-        expect(subject.send(stubbed_method)).to eq(assumed_output)
+        expect(recording_instance_double.send(stubbed_method)).to eq(assumed_output)
       end
     end
   end
 
   it "delegates all unknown calls to its internal double" do
-    internal_double.should_receive(:do_something)
-    subject.do_something
+    some_instance_double.should_receive(:do_something)
+    recording_instance_double.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) { stub_const(class_name, Class.new) }
-
-      it { expect(subject.to_s).to eq("VerifiedDouble.of_class('#{class_name}')") }
+      it { expect(recording_class_double.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) { double(class_name) }
+      let(:some_instance_double) { double(class_name) }
 
-      it { expect(subject.to_s).to eq("VerifiedDouble.of_instance('#{class_name}')") }
+      it { expect(recording_instance_double.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")
+      expect(recording_instance_double.inspect).to match("VerifiedDouble")
     end
   end
 
   describe "#class_name" do
     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')
+        expect(recording_instance_double.class_name).to eq(class_name)
       end
     end
 
     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')
+        expect(recording_class_double.class_name).to eq(class_name)
       end
     end
   end
 
   describe "#class_double?" do
     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
+      expect(recording_instance_double).to_not be_class_double
     end
 
     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
+      expect(recording_class_double).to be_class_double
     end
   end
 
   describe "#method_operator" do
-    context "when the subject wraps an instance double" do
-      let(:internal_double) { double(class_name) }
-
-      subject { VerifiedDouble::RecordingDouble.new(internal_double, class_name) }
-
+    context "when the recording_instance_double wraps an instance double" do
       it "is #" do
-        expect(subject.method_operator).to eq("#")
+        expect(recording_instance_double.method_operator).to eq("#")
       end
     end
 
-    context "when the subject wraps a class double" do
-      let(:internal_double) { stub_const(class_name, Class.new) }
-
-      subject { VerifiedDouble::RecordingDouble.new(internal_double, class_name) }
-
+    context "when the recording_instance_double wraps a class double" do
       it "is '.'" do
-        expect(subject.method_operator).to eq(".")
+        expect(recording_class_double.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
+      expect(recording_instance_double.method_signatures).to be_empty
+
+      recording_instance_double.should_receive(:fake_to_s)
+      recording_instance_double.should_receive(:fake_inspect)
 
-      subject.should_receive(:fake_to_s)
-      subject.should_receive(:fake_inspect)
+      expect(recording_instance_double.method_signatures.map(&:method)).to eq(['fake_to_s', 'fake_inspect'])
 
-      expect(subject.method_signatures.map(&:method)).to eq(['fake_to_s', 'fake_inspect'])
+      recording_instance_double.fake_to_s
+      recording_instance_double.fake_inspect
+    end
 
-      subject.fake_to_s
-      subject.fake_inspect
+    it "records the stack frames of the recording double's caller" do
+      recording_instance_double.should_receive(:fake_to_s)
+      recording_instance_double.fake_to_s
+      expect(recording_instance_double.method_signatures.first.stack_frame.to_s)
+        .to include("spec/verified_double/recording_double_spec.rb")
     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
+      expect(recording_instance_double.method_signatures).to be_empty
+
+      recording_instance_double.stub(:fake_to_s)
+      recording_instance_double.stub(:fake_inspect)
 
-      subject.stub(:fake_to_s)
-      subject.stub(:fake_inspect)
+      expect(recording_instance_double.method_signatures.map(&:method)).to eq(['fake_to_s', 'fake_inspect'])
+    end
+
+    it "records the stack frames of the recording double's caller" do
+      recording_instance_double.stub(:fake_to_s)
 
-      expect(subject.method_signatures.map(&:method)).to eq(['fake_to_s', 'fake_inspect'])
+      expect(recording_instance_double.method_signatures.first.stack_frame.to_s)
+        .to include("spec/verified_double/recording_double_spec.rb")
     end
   end
 
   describe "#with(*args)" do
     it "sets the args of the last method signature" do
-      subject.should_receive(:fake_to_s).with(:arg_1, :arg_2)
+      recording_instance_double.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])
+      expect(recording_instance_double.method_signatures[0].args).to be_all{|arg| arg.is_a?(VerifiedDouble::MethodSignature::Value) }
+      expect(recording_instance_double.method_signatures[0].args.map(&:content)).to eq([:arg_1, :arg_2])
 
-      subject.fake_to_s(:arg_1, :arg_2)
+      recording_instance_double.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(:fake_to_s).with(:arg_1, :arg_2).and_return(:return_value)
+      recording_instance_double.should_receive(:fake_to_s).with(:arg_1, :arg_2).and_return(:return_value)
 
-      return_values = subject.method_signatures[0].return_values
+      return_values = recording_instance_double.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)
+      expect(return_values.first).to be_a(VerifiedDouble::MethodSignature::Value)
+      expect(return_values.first.content).to eq(:return_value)
 
-      subject.fake_to_s(:arg_1, :arg_2)
+      recording_instance_double.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
+      expect(recording_instance_double.should_receive(:fake_to_s).once).to be_a(described_class)
+      recording_instance_double.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
+      expect(recording_instance_double.should_receive(:fake_to_s).twice).to be_a(described_class)
+      recording_instance_double.fake_to_s
+      recording_instance_double.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
+      expect(recording_instance_double.should_receive(:fake_to_s).at_least(:once)).to be_a(described_class)
+      recording_instance_double.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
+      expect(recording_instance_double.should_receive(:fake_to_s).at_most(:once)).to be_a(described_class)
+      recording_instance_double.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)
+      expect(recording_instance_double.should_receive(:fake_to_s).any_number_of_times).to be_a(described_class)
     end
   end
 
@@ -196,15 +196,41 @@ describe VerifiedDouble::RecordingDouble 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)
+      expect(recording_instance_double.should_receive(:fake_to_s).and_raise(some_error)).to be_a(described_class)
+      expect { recording_instance_double.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)
+      expect(recording_instance_double.should_receive(:fake_to_s).and_throw(:some_error)).to be_a(described_class)
+      expect { recording_instance_double.fake_to_s }.to throw_symbol(:some_error)
+    end
+  end
+
+  describe "#class" do
+    context "where the internal double is an instance" do
+      it "is the constant matching the class name" do
+        expect(recording_instance_double.class).to eq(Dummy)
+      end
+    end
+
+    context "where the internal double is a class" do
+      it { expect(recording_class_double.class).to eq(Class) }
+    end
+  end
+
+  describe "#doubled_class" do
+    context "where the internal double is an instance" do
+      it "is the constant matching the class name" do
+        expect(recording_instance_double.doubled_class).to eq(Dummy)
+      end
+    end
+
+    context "where the internal double is a class" do
+      it "is the constant matching the class name" do
+        expect(recording_class_double.doubled_class).to eq(Dummy)
+      end
     end
   end
 end

data/spec/verified_double/stack_frame_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe VerifiedDouble::RecordedMethodSignature do
+  let(:relative_stack_frame_string){ "spec/verified_double/method_signatures_report_spec.rb:31:in `block (4 levels) in <top (required)>'" }
+
+  let(:stack_frame_string){ "/verified_double/#{relative_stack_frame_string}" }
+
+  subject { VerifiedDouble::StackFrame.new(stack_frame_string) }
+
+  describe "#to_s" do
+    it "strips the parent dir of spec from the string" do
+      expect(subject.to_s).to eq("./#{relative_stack_frame_string}")
+    end
+  end
+end

data/spec/verified_double_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_helper'
+require 'spec_helper'
 require 'verified_double'
 
 describe VerifiedDouble do

metadata

@@ -2,14 +2,14 @@
 name: verified_double
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - George Mendoza
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2013-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   type: :runtime
@@ -118,20 +118,35 @@ files:
 - lib/verified_double/boolean.rb
 - lib/verified_double/matchers.rb
 - lib/verified_double/method_signature.rb
-- lib/verified_double/method_signature_value.rb
+- lib/verified_double/method_signature/boolean_value.rb
+- lib/verified_double/method_signature/class_value.rb
+- lib/verified_double/method_signature/instance_double_value.rb
+- lib/verified_double/method_signature/instance_value.rb
+- lib/verified_double/method_signature/recording_double_class_value.rb
+- lib/verified_double/method_signature/rspec_double_value.rb
+- lib/verified_double/method_signature/value.rb
 - lib/verified_double/method_signatures_report.rb
 - lib/verified_double/parse_method_signature.rb
+- lib/verified_double/recorded_method_signature.rb
 - lib/verified_double/recording_double.rb
 - lib/verified_double/relays_to_internal_double_returning_self.rb
+- lib/verified_double/stack_frame.rb
 - lib/verified_double/version.rb
 - spec/spec_helper.rb
-- spec/unit_helper.rb
 - spec/verified_double/matchers_spec.rb
+- spec/verified_double/method_signature/boolean_value_spec.rb
+- spec/verified_double/method_signature/class_value_spec.rb
+- spec/verified_double/method_signature/instance_double_value_spec.rb
+- spec/verified_double/method_signature/instance_value_spec.rb
+- spec/verified_double/method_signature/recording_double_class_value_spec.rb
+- spec/verified_double/method_signature/rspec_double_spec.rb
+- spec/verified_double/method_signature/value_spec.rb
 - spec/verified_double/method_signature_spec.rb
-- spec/verified_double/method_signature_value_spec.rb
 - spec/verified_double/method_signatures_report_spec.rb
 - spec/verified_double/parse_method_signature_spec.rb
+- spec/verified_double/recorded_method_signature_spec.rb
 - spec/verified_double/recording_double_spec.rb
+- spec/verified_double/stack_frame_spec.rb
 - spec/verified_double_spec.rb
 - verified_double.gemspec
 homepage: https://www.relishapp.com/gsmendoza/verified-double
@@ -170,12 +185,19 @@ test_files:
 - features/verified_mocks.feature
 - features/verified_stubs.feature
 - spec/spec_helper.rb
-- spec/unit_helper.rb
 - spec/verified_double/matchers_spec.rb
+- spec/verified_double/method_signature/boolean_value_spec.rb
+- spec/verified_double/method_signature/class_value_spec.rb
+- spec/verified_double/method_signature/instance_double_value_spec.rb
+- spec/verified_double/method_signature/instance_value_spec.rb
+- spec/verified_double/method_signature/recording_double_class_value_spec.rb
+- spec/verified_double/method_signature/rspec_double_spec.rb
+- spec/verified_double/method_signature/value_spec.rb
 - spec/verified_double/method_signature_spec.rb
-- spec/verified_double/method_signature_value_spec.rb
 - spec/verified_double/method_signatures_report_spec.rb
 - spec/verified_double/parse_method_signature_spec.rb
+- spec/verified_double/recorded_method_signature_spec.rb
 - spec/verified_double/recording_double_spec.rb
+- spec/verified_double/stack_frame_spec.rb
 - spec/verified_double_spec.rb
 has_rdoc: 

data/lib/verified_double/method_signature_value.rb

@@ -1,45 +0,0 @@
-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 as_instance
-      if self.value.is_a?(Class)
-        begin
-          value.new
-        rescue NoMethodError
-          Object.new
-        end
-      else
-        self.value
-      end
-    end
-
-    def modified_class
-      if value.is_a?(RSpec::Mocks::Mock)
-        value.instance_variable_get('@name').constantize
-      elsif value.is_a?(VerifiedDouble::RecordingDouble)
-        value.class_name.constantize
-      elsif value == true or value == false
-        VerifiedDouble::Boolean
-      else
-        value.class
-      end
-    end
-
-    def recommended_value
-      self.class.new(self.modified_class)
-    end
-  end
-end