bogus 0.0.2 → 0.0.3.rc.1

data/lib/bogus/any_args.rb

@@ -0,0 +1,7 @@
+module Bogus
+  module AnyArgs
+    def self.inspect
+      "any_args"
+    end
+  end
+end

data/lib/bogus/anything.rb

@@ -0,0 +1,11 @@
+module Bogus
+  module Anything
+    def self.==(other)
+      true
+    end
+
+    def self.inspect
+      "anything"
+    end
+  end
+end

data/lib/bogus/contract_not_fulfilled.rb

@@ -1,24 +1,31 @@
 module Bogus
   class ContractNotFulfilled < StandardError
-    attr_reader :interactions
+    attr_reader :fake_name, :missed_interactions, :actual_interactions
 
-    def initialize(interactions)
-      @interactions = interactions
+    def initialize(fake_name, opts = {})
+      @fake_name = fake_name
+      @actual_interactions = opts.fetch(:actual)
+      @missed_interactions = opts.fetch(:missed)
       super(message)
     end
 
     def message
-      interactions.map { |fake_name, missed| missed_for_fake(fake_name, missed) }.join("\n")
-    end
+      str = <<-EOF
+      Contract not fullfilled for #{fake_name}!
 
-    private
+      Missed interactions:
+      #{interactions_str(missed_interactions)}
 
-    def missed_for_fake(fake_name, missed)
-      "Contract not fullfilled for #{fake_name}:\n#{missed_interactions(missed)}"
+      Actual interactions:
+      #{interactions_str(actual_interactions)}
+      EOF
+      str.gsub(' ' * 6, '')
     end
 
-    def missed_interactions(missed)
-      missed.map { |i| "  - #{InteractionPresenter.new(i)}" }.join("\n")
+    private
+
+    def interactions_str(interactions)
+      interactions.map { |i| "  - #{InteractionPresenter.new(i)}" }.join("\n")
     end
   end
 end

data/lib/bogus/copies_classes.rb

@@ -2,7 +2,7 @@ module Bogus
   class CopiesClasses
     extend Takes
 
-    takes :method_stringifier
+    takes :makes_substitute_methods
 
     def copy(klass)
       copy_class = Class.new(Bogus::Fake)
@@ -33,11 +33,7 @@ module Bogus
     end
 
     def method_as_string(method)
-      args = @method_stringifier.arguments_as_string(method.parameters)
-      args_no_defaults = args.gsub(' = {}', '')
-
-      @method_stringifier.stringify(method,
-        "__record__(:#{method.name}, #{args_no_defaults})")
+      makes_substitute_methods.stringify(method)
     end
 
   end

data/lib/bogus/creates_fakes_with_stubbed_methods.rb

@@ -0,0 +1,40 @@
+module Bogus
+  class CreatesFakesWithStubbedMethods
+    extend Bogus::Takes
+
+    takes :multi_stubber, :creates_fakes,
+      :responds_to_everything, :fake_configuration
+
+    def create(name = nil, methods = {}, &block)
+      if name.is_a?(Hash)
+        methods = name
+        name = nil
+      end
+
+      fake = responds_to_everything unless name
+
+      fake_opts, methods = split_methods(methods)
+      fake_definition = get_configuration(name, fake_opts, methods, block)
+
+      fake ||= creates_fakes.create(fake_definition.name, fake_definition.opts,
+                                    &fake_definition.class_block)
+
+      multi_stubber.stub_all(fake, fake_definition.stubs)
+    end
+
+    private
+
+    def split_methods(methods)
+      fake_args = proc{ |k,_| [:as].include?(k) }
+      [methods.select(&fake_args), methods.reject(&fake_args)]
+    end
+
+    def get_configuration(name, fake_opts, methods, block)
+      fake = FakeDefinition.new(name: name, opts: fake_opts, stubs: methods, class_block: block)
+      return fake unless fake_configuration.include?(name)
+
+      configured_fake = fake_configuration.get(name)
+      configured_fake.merge(fake)
+    end
+  end
+end

data/lib/bogus/double.rb

@@ -1,10 +1,30 @@
-class Bogus::Double < BasicObject
-  extend ::Bogus::Takes
-  takes :object, :double, :verifies_stub_definition, :records_double_interactions
-
-  def method_missing(name, *args, &block)
-    @verifies_stub_definition.verify!(@object, name, args)
-    @records_double_interactions.record(@object, name, args, &block)
-    @double.__send__(name, *args, &block)
+module Bogus
+  class Double
+    extend Takes
+    include ProxiesMethodCalls
+
+    takes :object, :double_tracker, :verifies_stub_definition,
+      :overwrites_methods, :records_double_interactions
+
+    def stub
+      proxy(:stubs)
+    end
+
+    def stubs(name, *args, &return_value)
+      double_tracker.track(object)
+      verifies_stub_definition.verify!(object, name, args)
+      records_double_interactions.record(object, name, args, &return_value)
+      overwrites_methods.overwrite(object, name)
+      object.__shadow__.stubs(name, *args, &return_value)
+    end
+
+    def mock
+      proxy(:mocks)
+    end
+
+    def mocks(name, *args, &return_value)
+      stubs(name, *args, &return_value)
+      object.__shadow__.mocks(name, *args, &return_value)
+    end
   end
 end

data/lib/bogus/ensures_all_interactions_satisfied.rb

@@ -0,0 +1,36 @@
+module Bogus
+  class EnsuresAllInteractionsSatisfied
+    extend Bogus::Takes
+
+    def ensure_satisfied!(objects)
+      unsatisfied = unsatisfied_interactions(objects)
+      return if unsatisfied.empty?
+
+      calls = all_calls(objects)
+      raise NotAllExpectationsSatisfied.create(unsatisfied, calls)
+    end
+
+    private
+
+    def unsatisfied_interactions(objects)
+      mapcat_shadows(objects) do |object, shadow|
+        shadow.unsatisfied_interactions.map{|c| [object, c]}
+      end
+    end
+
+    def all_calls(objects)
+      mapcat_shadows(objects) do |object, shadow|
+        shadow.calls.map{|c| [object, c]}
+      end
+    end
+
+    def mapcat_shadows(objects, &block)
+      mapped = objects.map do |object|
+        shadow = object.__shadow__
+        block.call(object, shadow)
+      end
+
+      mapped.reduce([], :concat)
+    end
+  end
+end

data/lib/bogus/fake.rb

@@ -1,7 +1,13 @@
 module Bogus
+  module FakeObject
+    # marker for fake objects
+  end
+
   class Fake
     include RecordInteractions
     extend RecordInteractions
+    include FakeObject
+    extend FakeObject
 
     def initialize(*args)
     end

data/lib/bogus/fake_configuration.rb

@@ -0,0 +1,69 @@
+module Bogus
+  class FakeConfiguration
+    def include?(name)
+      fakes.key?(name)
+    end
+
+    def fake(name, opts = {}, &block)
+      opts = opts.dup
+      class_block = opts.delete(:class)
+      fakes[name] = FakeDefinition.new(name: name,
+                                       opts: opts,
+                                       stubs: stubs_hash(&block),
+                                       class_block: class_block)
+    end
+
+    def evaluate(&block)
+      instance_eval(&block)
+    end
+
+    def get(name)
+      fakes[name]
+    end
+
+    private
+
+    def stubs_hash(&block)
+      stubs = StubsConfiguration.new(&block)
+      stubs.stubs
+    end
+
+    def fakes
+      @fakes ||= {}
+    end
+  end
+
+  class FakeDefinition
+    attr_reader :name, :class_block, :opts, :stubs
+
+    def initialize(attrs = {})
+      @name = attrs[:name]
+      @class_block = attrs[:class_block]
+      @opts = attrs[:opts] || {}
+      @stubs = attrs[:stubs] || {}
+    end
+
+    def merge(other)
+      FakeDefinition.new(name: other.name,
+                        opts: opts.merge(other.opts),
+                        stubs: stubs.merge(other.stubs),
+                        class_block: other.class_block || class_block)
+    end
+  end
+
+  class StubsConfiguration
+    include ProxiesMethodCalls
+
+    def initialize(&block)
+      proxy(:add_stub).instance_eval(&block) if block
+    end
+
+    def add_stub(name, value = nil, &block)
+      stubs[name] = block || value
+    end
+
+    def stubs
+      @stubs ||= {}
+    end
+  end
+end

data/lib/bogus/fakes_classes.rb

@@ -0,0 +1,21 @@
+module Bogus
+  class FakesClasses
+    extend Takes
+
+    takes :creates_fakes_with_stubbed_methods, :overwrites_classes, :overwritten_classes
+
+    def fake(klass, opts = {})
+      opts = opts.merge(as: :class)
+      name = opts.delete(:fake_name) || underscore(klass.name.split('::').last).to_sym
+      fake = creates_fakes_with_stubbed_methods.create(name, opts) { klass }
+      overwrites_classes.overwrite(klass.name, fake)
+      overwritten_classes.add(klass.name, klass)
+    end
+
+    private
+
+    def underscore(str)
+      str.gsub(/[A-Z]/) { |s| "_" + s.downcase }.gsub(/^_/, '')
+    end
+  end
+end

data/lib/bogus/has_overwritten_methods.rb

@@ -0,0 +1,24 @@
+module Bogus
+  module HasOverwritenMethods
+    def __overwritten_methods__
+      @__overwritten_methods__ ||= {}
+    end
+
+    def __overwrite__(name, method, body)
+      return if __overwritten_methods__[name]
+      method = method.to_proc if method
+      __overwritten_methods__[name] = method || :no_such_method
+      instance_eval(body)
+    end
+
+    def __reset__
+      __overwritten_methods__.each do |name, method|
+        method = __overwritten_methods__.delete(name)
+        instance_eval "undef #{name}"
+        next if method == :no_such_method
+        define_singleton_method(name, method)
+      end
+      @__overwritten_methods__ = {}
+    end
+  end
+end

data/lib/bogus/have_received_matcher.rb

@@ -0,0 +1,63 @@
+module Bogus
+  class HaveReceivedMatcher
+    include ProxiesMethodCalls
+
+    extend Takes
+    NO_SHADOW = "Given object is not a fake and nothing was ever stubbed or mocked on it!"
+
+    takes :verifies_stub_definition, :records_double_interactions
+
+    def matches?(subject)
+      @subject = subject
+      return false unless Shadow.has_shadow?(subject)
+
+      verifies_stub_definition.verify!(subject, @name, @args)
+      records_double_interactions.record(subject, @name, @args)
+
+      subject.__shadow__.has_received(@name, @args)
+    end
+
+    def description
+      "have received #{call_str(@name, @args)}"
+    end
+
+    def failure_message_for_should
+      return NO_SHADOW unless Shadow.has_shadow?(@subject)
+      %Q{Expected #{@subject.inspect} to #{description}, but it didn't.\n\n} + all_calls_str
+    end
+
+    def failure_message_for_should_not
+      return NO_SHADOW unless Shadow.has_shadow?(@subject)
+      %Q{Expected #{@subject.inspect} not to #{description}, but it did.}
+    end
+
+    def method_call
+      proxy(:set_method)
+    end
+
+    def set_method(name, *args, &block)
+      @name = name
+      @args = args
+      self
+    end
+
+    private
+
+    def call_str(method, args)
+      "#{method}(#{args.map(&:inspect).join(', ')})"
+    end
+
+    def all_calls_str
+      shadow = @subject.__shadow__
+      calls = shadow.calls.map{|i| call_str(i.method, i.args)}
+
+      if calls.any?
+        message = "The recorded interactions were:\n"
+        calls.each{|s| message << "  - #{s}\n"}
+        message
+      else
+        "There were no interactions with this object.\n"
+      end
+    end
+  end
+end

data/lib/bogus/injector.rb

@@ -4,7 +4,11 @@ module Bogus
     look_in_modules Bogus
 
     def configuration
-      @configuration ||= Bogus::Configuration.new
+      @configuration ||= inject(Configuration)
+    end
+
+    def fake_configuration
+      @fake_configuration ||= inject(FakeConfiguration)
     end
 
     def search_modules
@@ -15,47 +19,65 @@ module Bogus
       Bogus::RRProxy
     end
 
+    def rr_shadow(object)
+      inject(Bogus::RRShadow, object: object)
+    end
+
     def fake_registry
-      @fake_registry ||= inject(Bogus::FakeRegistry)
+      @fake_registry ||= inject(FakeRegistry)
     end
 
     def creates_fakes
-      creates_fakes = inject(Bogus::CreatesFakes)
-      inject(Bogus::RegistersCreatedFakes, creates_fakes: creates_fakes)
+      creates_fakes = inject(CreatesFakes)
+      inject(RegistersCreatedFakes, creates_fakes: creates_fakes)
+    end
+
+    def create_double(object)
+      inject(Double, object: object)
     end
 
     def create_stub(object)
-      stub = rr_proxy.stub(object)
-      inject(Bogus::Double, object: object, double: stub)
+      create_double(object).stub
     end
 
     def create_mock(object)
-      mock = rr_proxy.mock(object)
-      inject(Bogus::Double, object: object, double: mock)
+      create_double(object).mock
     end
 
-    def invocation_matcher(method = nil)
-      inject(Bogus::InvocationMatcher, method: method)
+    def have_received_matcher
+      inject(HaveReceivedMatcher)
     end
 
     def interactions_repository
       raise "Specify either real_interactions or stubbed_interactions"
     end
 
+    def double_tracker
+      @double_tracker ||= inject(TracksExistenceOfTestDoubles)
+    end
+
+    def clear_tracked_doubles
+      @double_tracker = nil
+    end
+
     def real_interactions
-      @real_interactions ||= inject(Bogus::InteractionsRepository)
+      @real_interactions ||= inject(InteractionsRepository)
     end
 
     def doubled_interactions
-      @doubled_interactions ||= inject(Bogus::InteractionsRepository)
+      @doubled_interactions ||= inject(InteractionsRepository)
+    end
+
+    def overwritten_classes
+      @overwritten_classes ||= inject(OverwrittenClasses)
     end
 
     def create_proxy_class(fake_name, klass)
-      inject(Bogus::ProxyClass, fake_name: fake_name, klass: klass)
+      inject(ProxyClass, fake_name: fake_name, klass: klass)
     end
 
     def create_recording_proxy(instance, fake_name)
-      inject(Bogus::RecordingProxy,
+      inject(RecordingProxy,
         instance: instance,
         fake_name: fake_name,
         interactions_repository: real_interactions)