verified_double 0.2.0 → 0.3.0

data/CHANGELOG.markdown

@@ -1,3 +1,8 @@
+0.3.0 - 2013-07-19
+
+* [#17] Major refactor: extend RSpec doubles with VerifiedDouble recording
+  functionality. No more need for RecordingDouble.
+
 0.2.0 - 2013-06-30
 ------------------
 

data/features/CHANGELOG.markdown

@@ -1,3 +1,8 @@
+0.3.0 - 2013-07-19
+
+* [#17] Major refactor: extend RSpec doubles with VerifiedDouble recording
+  functionality. No more need for RecordingDouble.
+
 0.2.0 - 2013-06-30
 ------------------
 

data/lib/verified_double/can_record_interactions.rb

@@ -0,0 +1,24 @@
+module VerifiedDouble
+  module CanRecordInteractions
+    def and_return(*return_values)
+      VerifiedDouble.registry.last.return_values = [MethodSignature::Value.from(return_values[0])]
+      super(*return_values)
+    end
+
+    def should_receive(*args)
+      VerifiedDouble.registry.add_method_signature(self, args[0])
+      super(*args).tap {|result| result.extend(VerifiedDouble::CanRecordInteractions) }
+    end
+
+    def stub(*args)
+      VerifiedDouble.registry.add_method_signature(self, args[0])
+      super(*args).tap {|result| result.extend(VerifiedDouble::CanRecordInteractions) }
+    end
+
+    def with(*args)
+      VerifiedDouble.registry.last.args =
+        args.map{|arg| MethodSignature::Value.from(arg) }
+      super(*args)
+    end
+  end
+end

data/lib/verified_double/method_signature/rspec_double_value.rb

@@ -1,6 +1,10 @@
 module VerifiedDouble
   class MethodSignature
-    class RspecDoubleValue <  InstanceDoubleValue
+    class RspecDoubleValue <  InstanceValue
+      def content_as_instance
+        Value.from(content_class).content_as_instance
+      end
+
       def content_class
         content.instance_variable_get('@name').constantize
       end

data/lib/verified_double/method_signature/value.rb

@@ -8,12 +8,6 @@ module VerifiedDouble
           BooleanValue.new(content)
         elsif content.is_a?(RSpec::Mocks::Mock)
           RspecDoubleValue.new(content)
-        elsif content.respond_to?(:doubled_class)
-          if content.class_double?
-            RecordingDoubleClassValue.new(content)
-          else
-            InstanceDoubleValue.new(content)
-          end
         elsif content.is_a?(Module)
           ClassValue.new(content)
         else

data/lib/verified_double/method_signatures_report.rb

@@ -39,7 +39,7 @@ module VerifiedDouble
     end
 
     def set_registered_signatures
-      @registered_signatures = VerifiedDouble.registry.map(&:method_signatures).flatten.uniq
+      @registered_signatures = VerifiedDouble.registry.uniq
       self
     end
 

data/lib/verified_double/recorded_method_signature_registry.rb

@@ -0,0 +1,13 @@
+module VerifiedDouble
+  class RecordedMethodSignatureRegistry < Array
+    def add_method_signature(a_double, method)
+      simple_double = SimpleDouble.new(a_double)
+
+      self << RecordedMethodSignature.new(
+        class_name: simple_double.class_name,
+        method_operator: simple_double.method_operator,
+        method: method.to_s,
+        stack_frame: StackFrame.new(caller(0).detect{|line| line =~ /_spec\.rb/ }))
+    end
+  end
+end

data/lib/verified_double/simple_double.rb

@@ -0,0 +1,21 @@
+module VerifiedDouble
+  class SimpleDouble
+    attr_reader :internal
+
+    def initialize(internal)
+      @internal = internal
+    end
+
+    def class_name
+      class_double? ? internal.name : internal.instance_variable_get('@name')
+    end
+
+    def class_double?
+      internal.is_a?(Class)
+    end
+
+    def method_operator
+      class_double? ? '.' : '#'
+    end
+  end
+end

data/lib/verified_double/version.rb

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

data/lib/verified_double.rb

@@ -2,40 +2,40 @@ require 'active_support/core_ext/string'
 require 'rspec/mocks'
 
 require 'verified_double/boolean'
+require 'verified_double/can_record_interactions'
 require 'verified_double/matchers'
 require 'verified_double/method_signature'
 require 'verified_double/method_signature/value'
 require 'verified_double/method_signature/instance_value'
 require 'verified_double/method_signature/boolean_value'
 require 'verified_double/method_signature/class_value'
-require 'verified_double/method_signature/instance_double_value'
-require 'verified_double/method_signature/recording_double_class_value'
 require 'verified_double/method_signature/rspec_double_value'
 require 'verified_double/method_signatures_report'
 require 'verified_double/parse_method_signature'
 require 'verified_double/recorded_method_signature'
-require 'verified_double/recording_double'
-require 'verified_double/relays_to_internal_double_returning_self'
+require 'verified_double/recorded_method_signature_registry'
+require 'verified_double/simple_double'
 require 'verified_double/stack_frame'
 
 module VerifiedDouble
   extend RSpec::Mocks::ExampleMethods
 
-  def self.of_class(class_name, method_stubs = {})
-    class_double = stub_const(class_name, Class.new, transfer_nested_constants: true)
-    RecordingDouble.new(class_double, class_name, method_stubs).tap do |double|
-      registry << double
-    end
+  def self.of_class(class_name, options = {})
+    options[:transfer_nested_constants] = true if options[:transfer_nested_constants].nil?
+    VerifiedDouble.record(stub_const(class_name, Class.new, options))
   end
 
-  def self.of_instance(class_name, method_stubs = {})
-    RecordingDouble.new(double(class_name), class_name, method_stubs).tap do |double|
-      registry << double
-    end
+  def self.of_instance(*args)
+    VerifiedDouble.record(double(*args))
+  end
+
+  def self.record(a_double)
+    a_double.extend(VerifiedDouble::CanRecordInteractions)
+    a_double
   end
 
   def self.registry
-    @registry ||= []
+    @registry ||= RecordedMethodSignatureRegistry.new
   end
 
   def self.report_unverified_signatures(nested_example_group)

data/spec/verified_double/can_record_interactions_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe VerifiedDouble::CanRecordInteractions do
+  let(:a_double){ double('Object') }
+
+  before do
+    a_double.extend(VerifiedDouble::CanRecordInteractions)
+  end
+
+  describe "#should_receive(method)" do
+    it "appends a new method signature with the method to the registry", verifies_contract: 'Object#mocked_fake_to_s()' do
+      a_double.should_receive(:mocked_fake_to_s)
+      expect(VerifiedDouble.registry.last.method).to eq('mocked_fake_to_s')
+      a_double.mocked_fake_to_s
+    end
+  end    
+
+  describe "#stub(method)" do
+    it "appends a new method signature with the method to the registry", verifies_contract: 'Object#stubbed_fake_to_s()' do
+      a_double.stub(:stubbed_fake_to_s)
+      expect(VerifiedDouble.registry.last.method).to eq('stubbed_fake_to_s')
+    end
+  end
+
+  describe "#with(*args)" do
+    it "sets the args of the last method signature", verifies_contract: 'Object#fake_to_s(Symbol, Symbol)' do
+      a_double.should_receive(:fake_to_s).with(:arg_1, :arg_2)
+
+      expect(VerifiedDouble.registry.last.args).to be_all{|arg| arg.is_a?(VerifiedDouble::MethodSignature::Value) }
+      expect(VerifiedDouble.registry.last.args.map(&:content)).to eq([:arg_1, :arg_2])
+
+      a_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", verifies_contract: 'Object#fake_to_s(Symbol, Symbol)=>Symbol' do
+      a_double.should_receive(:fake_to_s).with(:arg_1, :arg_2).and_return(:return_value)
+
+      expect(VerifiedDouble.registry.last.return_values).to have(1).return_value
+      expect(VerifiedDouble.registry.last.return_values.first).to be_a(VerifiedDouble::MethodSignature::Value)
+      expect(VerifiedDouble.registry.last.return_values.first.content).to eq(:return_value)
+
+      a_double.fake_to_s(:arg_1, :arg_2)
+    end
+  end
+end

data/spec/verified_double/method_signature/rspec_double_spec.rb

@@ -1,14 +1,25 @@
 require 'spec_helper'
 
 describe VerifiedDouble::MethodSignature::RspecDoubleValue do
-  let(:rspec_double) { double('Object') }
+  class Item
+  end
+
+  let(:class_name){ 'Item' }
+
+  let(:rspec_double) { double(class_name) }
   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)
+        expect(subject.content_class).to eq(Item)
       end
     end
   end
+
+  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/value_spec.rb

@@ -37,18 +37,10 @@ describe VerifiedDouble::MethodSignature::Value do
       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) }
+    context "where content is a class double" do
+      let(:content){ stub_const(class_name, Class.new, transfer_nested_constants: true) }
 
-      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) }
+      it { expect(subject).to be_a(VerifiedDouble::MethodSignature::ClassValue) }
     end
 
     context "where content is an instance" do
@@ -61,15 +53,6 @@ describe VerifiedDouble::MethodSignature::Value do
   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

data/spec/verified_double/method_signatures_report_spec.rb

@@ -9,42 +9,31 @@ describe VerifiedDouble::MethodSignaturesReport do
 
   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') }
+    let(:verified_double_module){
+      stub_const('VerifiedDouble', Class.new, transfer_nested_constants: true) }
 
-    context "with multiple recording doubles in the registry" do
-      it "maps and flattens the method signatures of the recording doubles" do
+    context "with multiple signatures in the registry" do
+      it "sets the signatures from the registry" do
         verified_double_module
           .should_receive(:registry)
-          .and_return([recording_double_1, recording_double_2])
+          .and_return([method_signature_1, method_signature_2])
 
-        expect(subject.set_registered_signatures.registered_signatures).to eq(
+        expect(subject.set_registered_signatures.registered_signatures.to_a).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]) }
-
+    context "with duplicate signatures" do
       it "returns distinct method signatures" do
         verified_double_module
           .should_receive(:registry)
-          .and_return([recording_double_1, recording_double_2])
+          .and_return([method_signature_1, method_signature_1])
 
         expect(subject.set_registered_signatures.registered_signatures).to eq([method_signature_1])
       end
@@ -187,7 +176,7 @@ describe VerifiedDouble::MethodSignaturesReport do
 
   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') }
+      stub_const('VerifiedDouble', Class.new, transfer_nested_constants: true) }
 
     let(:method_signature) { VerifiedDouble::MethodSignature.new }
 

data/spec/verified_double/recorded_method_signature_registry_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe VerifiedDouble::RecordedMethodSignatureRegistry do
+  describe "#add_method_signature(a_double, method)" do
+    let(:class_name){ 'Object' }
+    let(:a_double){ double(class_name) }
+    let(:method){ :fake_to_s }
+    
+    it "adds a method signture matching the method to itself" do
+      expect(subject).to be_empty
+      
+      subject.add_method_signature(a_double, method)
+
+      expect(subject).to have(1).method_signature
+      method_signature = subject[0]
+      expect(method_signature.class_name).to eq(class_name)
+      expect(method_signature.method_operator).to eq('#')
+      expect(method_signature.method).to eq(method.to_s)
+    end
+
+    it "records the stack frames of the double's caller" do
+      subject.add_method_signature(a_double, method)
+      expect(subject.first.stack_frame.to_s)
+        .to include("./spec/verified_double/recorded_method_signature_registry_spec.rb")
+    end
+  end
+end

data/spec/verified_double/simple_double_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe VerifiedDouble::SimpleDouble do
+  class Dummy
+  end
+
+  let(:class_name) {  'Dummy' }
+  let(:some_instance_double) { double(class_name) }
+  let(:some_class_double) { stub_const(class_name, Class.new) }
+
+  let(:simple_instance_double) { described_class.new(some_instance_double) }
+  let(:simple_class_double) { described_class.new(some_class_double) }
+
+  describe "#initialize" do
+    it "requires a double" do
+      expect(simple_instance_double.internal).to eq(some_instance_double)
+    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
+        expect(simple_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
+        expect(simple_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
+      expect(simple_instance_double).to_not be_class_double
+    end
+
+    it "should be false if the internal double is not an class double" do
+      expect(simple_class_double).to be_class_double
+    end
+  end
+
+  describe "#method_operator" do
+    context "when the simple_instance_double wraps an instance double" do
+      it "is #" do
+        expect(simple_instance_double.method_operator).to eq("#")
+      end
+    end
+
+    context "when the simple_instance_double wraps a class double" do
+      it "is '.'" do
+        expect(simple_class_double.method_operator).to eq(".")
+      end
+    end
+  end
+end

data/spec/verified_double_spec.rb

@@ -3,9 +3,9 @@ require 'verified_double'
 
 describe VerifiedDouble do
   describe ".registry" do
-    it "is a array", verifies_contract: 'VerifiedDouble.registry()=>Array' do
+    it "is an RecordedMethodSignatureRegistry", verifies_contract: 'VerifiedDouble.registry()=>RecordedMethodSignatureRegistry' do
       registry = VerifiedDouble.registry
-      expect(registry).to be_an(Array)
+      expect(registry).to be_an(described_class::RecordedMethodSignatureRegistry)
     end
 
     it "is memoized" do
@@ -29,15 +29,14 @@ describe VerifiedDouble do
 
     let(:subject) { described_class.of_instance(class_name) }
 
-    it "creates an instance recording double" do
-      expect(subject).to be_a(VerifiedDouble::RecordingDouble)
-      expect(subject).to_not be_class_double
-      expect(subject.class_name).to eq(class_name)
+    it "extends the double with VerifiedDouble::CanRecordInteractions" do
+      subject = described_class.of_instance(class_name)
+      expect(subject).to be_a(VerifiedDouble::CanRecordInteractions)
     end
 
-    it "adds the double to the registry" do
-      recording_double = subject
-      expect(described_class.registry.last).to eq(recording_double)
+    it "returns the double" do
+      subject = described_class.of_instance(class_name)
+      expect(subject).to be_a(RSpec::Mocks::Mock)
     end
 
     context "with method_stubs hash", verifies_contract: 'Object#some_method()=>Symbol' do
@@ -57,27 +56,14 @@ describe VerifiedDouble do
 
     let(:subject) { described_class.of_class(class_name) }
 
-    it "creates a class recording double" do
-      expect(subject).to be_a(VerifiedDouble::RecordingDouble)
-      expect(subject).to be_class_double
-      expect(subject.double).to be_a(Module)
-      expect(subject.class_name).to eq(class_name)
+    it "extends the double with VerifiedDouble::CanRecordInteractions" do
+      the_double = subject
+      expect(the_double).to be_a(VerifiedDouble::CanRecordInteractions)
     end
 
-    it "adds the double to the registry" do
-      recording_double = subject
-      expect(described_class.registry.last).to eq(recording_double)
-    end
-
-    context "with methods hash", verifies_contract: 'Object.some_method()=>Symbol' do
-      let(:stubbed_method){ :some_method }
-      let(:assumed_output){ :some_output }
-
-      subject { described_class.of_class(class_name, some_method: assumed_output) }
-
-      it "stubs the methods of the class" do
-        expect(subject.send(stubbed_method)).to eq(assumed_output)
-      end
+    it "returns the double" do
+      subject = described_class.of_class(class_name)
+      expect(subject).to eq(class_name.constantize)
     end
   end
 
@@ -112,4 +98,17 @@ describe VerifiedDouble do
       described_class.report_unverified_signatures(nested_example_group)
     end
   end
+
+  describe ".record(double)" do
+    let(:the_double){ double }
+
+    it "extends the double with VerifiedDouble::CanRecordInteractions" do
+      described_class.record(the_double)
+      expect(the_double).to be_a(VerifiedDouble::CanRecordInteractions)
+    end
+
+    it "returns the double" do
+      expect(described_class.record(the_double)).to eq(the_double)
+    end
+  end
 end

metadata

@@ -2,14 +2,14 @@
 name: verified_double
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - George Mendoza
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-30 00:00:00.000000000 Z
+date: 2013-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   type: :runtime
@@ -116,36 +116,35 @@ files:
 - features/verified_stubs.feature
 - lib/verified_double.rb
 - lib/verified_double/boolean.rb
+- lib/verified_double/can_record_interactions.rb
 - lib/verified_double/matchers.rb
 - lib/verified_double/method_signature.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/recorded_method_signature_registry.rb
+- lib/verified_double/simple_double.rb
 - lib/verified_double/stack_frame.rb
 - lib/verified_double/version.rb
 - spec/spec_helper.rb
+- spec/verified_double/can_record_interactions_spec.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_signatures_report_spec.rb
 - spec/verified_double/parse_method_signature_spec.rb
+- spec/verified_double/recorded_method_signature_registry_spec.rb
 - spec/verified_double/recorded_method_signature_spec.rb
-- spec/verified_double/recording_double_spec.rb
+- spec/verified_double/simple_double_spec.rb
 - spec/verified_double/stack_frame_spec.rb
 - spec/verified_double_spec.rb
 - verified_double.gemspec
@@ -185,19 +184,19 @@ test_files:
 - features/verified_mocks.feature
 - features/verified_stubs.feature
 - spec/spec_helper.rb
+- spec/verified_double/can_record_interactions_spec.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_signatures_report_spec.rb
 - spec/verified_double/parse_method_signature_spec.rb
+- spec/verified_double/recorded_method_signature_registry_spec.rb
 - spec/verified_double/recorded_method_signature_spec.rb
-- spec/verified_double/recording_double_spec.rb
+- spec/verified_double/simple_double_spec.rb
 - spec/verified_double/stack_frame_spec.rb
 - spec/verified_double_spec.rb
 has_rdoc: 

data/lib/verified_double/method_signature/instance_double_value.rb

@@ -1,9 +0,0 @@
-module VerifiedDouble
-  class MethodSignature
-    class InstanceDoubleValue < InstanceValue
-      def content_as_instance
-        Value.from(content_class).content_as_instance
-      end
-    end
-  end
-end

data/lib/verified_double/method_signature/recording_double_class_value.rb

@@ -1,9 +0,0 @@
-module VerifiedDouble
-  class MethodSignature
-    class RecordingDoubleClassValue < ClassValue
-      def belongs_to?(other)
-        Value.from(content.doubled_class).belongs_to?(other)
-      end
-    end
-  end
-end

data/lib/verified_double/recording_double.rb

@@ -1,92 +0,0 @@
-require 'delegate'
-require 'verified_double/relays_to_internal_double_returning_self'
-
-module VerifiedDouble
-  class RecordingDouble < ::SimpleDelegator
-    extend VerifiedDouble::RelaysToInternalDoubleReturningSelf
-
-    relays_to_internal_double_returning_self :any_number_of_times, :and_raise,
-      :and_throw, :at_least, :at_most, :exactly, :once, :twice
-
-    attr_reader :class_name
-
-    def initialize(double, class_name, method_stubs={})
-      @double = double
-      @class_name = class_name
-
-      super(@double)
-      method_stubs.each do |method, output|
-        self.stub(method).and_return(output)
-      end
-    end
-
-    def and_return(return_value)
-      self.method_signatures.last.return_values = [MethodSignature::Value.from(return_value)]
-      @double_call.and_return(return_value)
-      self
-    end
-
-    def class
-      class_double? ? Class : doubled_class
-    end
-
-    def class_double?
-      ! double.is_a?(RSpec::Mocks::Mock)
-    end
-
-    def double
-      __getobj__
-    end
-
-    def doubled_class
-      class_name.constantize
-    end
-
-    def inspect
-      to_s
-    end
-
-    def method_operator
-      class_double? ? '.' : '#'
-    end
-
-    def method_signatures
-      @method_signatures ||= []
-    end
-
-    def should_receive(method)
-      add_method_signature method
-      @double_call = double.should_receive(method)
-      self
-    end
-
-    def stub(method)
-      add_method_signature method
-      @double_call = double.stub(method)
-      self
-    end
-
-    def to_s
-      "#{VerifiedDouble}.of_#{class_double? ? 'class' : 'instance' }('#{class_name}')"
-    end
-
-    def with(*args)
-      self.method_signatures.last.args =
-        args.map{|arg| MethodSignature::Value.from(arg) }
-      @double_call.with(*args)
-      self
-    end
-
-    private
-
-    def add_method_signature(method)
-      method_signature = RecordedMethodSignature.new(
-        class_name: class_name,
-        method_operator: method_operator,
-        method: method.to_s,
-        stack_frame: StackFrame.new(caller(2)[0]))
-
-      self.method_signatures << method_signature
-    end
-  end
-end

data/lib/verified_double/relays_to_internal_double_returning_self.rb

@@ -1,12 +0,0 @@
-module VerifiedDouble
-  module RelaysToInternalDoubleReturningSelf
-    def relays_to_internal_double_returning_self(*methods)
-      methods.each do |method|
-        define_method method do |*args|
-          @double_call.send(method, *args)
-          self
-        end
-      end
-    end
-  end
-end

data/spec/verified_double/method_signature/instance_double_value_spec.rb

@@ -1,17 +0,0 @@
-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/recording_double_class_value_spec.rb

@@ -1,23 +0,0 @@
-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/recording_double_spec.rb

@@ -1,236 +0,0 @@
-require 'spec_helper'
-require "verified_double/recording_double"
-
-describe VerifiedDouble::RecordingDouble do
-  class Dummy
-  end
-
-  let(:class_name) {  'Dummy' }
-  let(:some_instance_double) { double(class_name) }
-  let(:some_class_double) { stub_const(class_name, Class.new) }
-
-  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(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 }
-
-      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(recording_instance_double.send(stubbed_method)).to eq(assumed_output)
-      end
-    end
-  end
-
-  it "delegates all unknown calls to its internal double" do
-    some_instance_double.should_receive(:do_something)
-    recording_instance_double.do_something
-  end
-
-  describe "#to_s" do
-    context "where the internal double is a class" do
-      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(:some_instance_double) { double(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(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
-        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
-        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
-      expect(recording_instance_double).to_not be_class_double
-    end
-
-    it "should be false if the internal double is not an class double" do
-      expect(recording_class_double).to be_class_double
-    end
-  end
-
-  describe "#method_operator" do
-    context "when the recording_instance_double wraps an instance double" do
-      it "is #" do
-        expect(recording_instance_double.method_operator).to eq("#")
-      end
-    end
-
-    context "when the recording_instance_double wraps a class double" do
-      it "is '.'" do
-        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(recording_instance_double.method_signatures).to be_empty
-
-      recording_instance_double.should_receive(:fake_to_s)
-      recording_instance_double.should_receive(:fake_inspect)
-
-      expect(recording_instance_double.method_signatures.map(&:method)).to eq(['fake_to_s', 'fake_inspect'])
-
-      recording_instance_double.fake_to_s
-      recording_instance_double.fake_inspect
-    end
-
-    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(recording_instance_double.method_signatures).to be_empty
-
-      recording_instance_double.stub(:fake_to_s)
-      recording_instance_double.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(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
-      recording_instance_double.should_receive(:fake_to_s).with(: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])
-
-      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
-      recording_instance_double.should_receive(:fake_to_s).with(:arg_1, :arg_2).and_return(:return_value)
-
-      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::MethodSignature::Value)
-      expect(return_values.first.content).to eq(:return_value)
-
-      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(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(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(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(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(recording_instance_double.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(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(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