bogus 0.0.4 → 0.1.0

data/lib/bogus/constructor_methods.rb

@@ -0,0 +1,18 @@
+module Bogus
+  class CopiesConstructor
+    extend Takes
+    takes :method_stringifier, :instance_methods, :class_methods
+
+    def copy(from, into)
+      return unless from.is_a?(Class)
+      initializer = instance_methods.call(from).get(:initialize)
+      body = body(initializer)
+      class_methods.call(into).define(body)
+    end
+
+    def body(initializer)
+      body = method_stringifier.stringify(initializer, "super")
+      body.gsub("initialize", "new")
+    end
+  end
+end

data/lib/bogus/copies_methods.rb

@@ -1,14 +1,16 @@
 module Bogus
   class CopiesMethods
-    extend Bogus::Takes
+    extend Takes
 
     takes :makes_substitute_methods,
-      :instance_methods,
-      :class_methods
+      :method_copiers,
+      :copies_constructor
 
     def copy(from, into)
-      copy_methods(from, into, instance_methods)
-      copy_methods(from, into, class_methods)
+      method_copiers.each do |copier|
+        copy_methods(from, into, copier)
+      end
+      copies_constructor.copy(from, into)
     end
 
     private

data/lib/bogus/creates_fakes.rb

@@ -15,7 +15,7 @@ module Bogus
 
       case mode
       when :instance
-        return klass_copy.new
+        return klass_copy.__create__
       when :class
         return klass_copy
       else

data/lib/bogus/creates_fakes_with_stubbed_methods.rb

@@ -1,6 +1,6 @@
 module Bogus
   class CreatesFakesWithStubbedMethods
-    extend Bogus::Takes
+    extend Takes
 
     takes :multi_stubber, :creates_fakes,
       :responds_to_everything, :fake_configuration

data/lib/bogus/ensures_all_interactions_satisfied.rb

@@ -1,7 +1,5 @@
 module Bogus
   class EnsuresAllInteractionsSatisfied
-    extend Bogus::Takes
-
     def ensure_satisfied!(objects)
       unsatisfied = unsatisfied_interactions(objects)
       return if unsatisfied.empty?

data/lib/bogus/fake.rb

@@ -10,6 +10,7 @@ module Bogus
     extend FakeObject
 
     def initialize(*args)
+      __shadow__
     end
 
     def to_s
@@ -27,6 +28,13 @@ module Bogus
     class << self
       attr_accessor :__copied_class__
 
+      alias :__create__ :new
+
+      def new(*args, &block)
+        __record__(:new, *args, &block)
+        __create__
+      end
+
       def name
         __copied_class__.name
       end

data/lib/bogus/injector.rb

@@ -44,6 +44,16 @@ module Bogus
       inject(ClassMethods, klass: klass)
     end
 
+    def active_record_accessors(klass)
+      inject(ActiveRecordAccessors, klass: klass)
+    end
+
+    def method_copiers
+      copiers = [method(:class_methods), method(:instance_methods)]
+      copiers << method(:active_record_accessors) if configuration.fake_ar_attributes
+      copiers
+    end
+
     def have_received_matcher
       inject(HaveReceivedMatcher)
     end

data/lib/bogus/instance_methods.rb

@@ -1,6 +1,6 @@
 module Bogus
   class InstanceMethods
-    extend Bogus::Takes
+    extend Takes
     takes :klass
 
     def all

data/lib/bogus/interaction.rb

@@ -19,15 +19,26 @@ module Bogus
     end
 
     def args
-      super.reject { |arg| arg.eql?(Bogus::DefaultValue) }
+      args = super.map { |arg| remove_default_values_from_hash(arg) }
+      args.reject { |arg| arg.eql?(DefaultValue) }
     end
 
     private
 
     def same_args?(other)
       return true if any_args? || other.any_args?
-      return false unless args.size == other.args.size
-      args.zip(other.args).all?{|a1, a2| a1 == a2 || a2 == a1}
+
+      other_args = normalize_other_args(args, other.args)
+      return false unless args.size == other_args.size
+      args.zip(other_args).all?{|a1, a2| a1 == a2 || a2 == a1}
+    end
+
+    def normalize_other_args(args, other_args)
+      if args.last.is_a?(Hash) && !other_args.last.is_a?(Hash)
+        other_args + [{}]
+      else
+        other_args
+      end
     end
 
     def same_result?(other)
@@ -40,5 +51,13 @@ module Bogus
     rescue => e
       self.error = e.class
     end
+
+    def remove_default_values_from_hash(arg)
+      if arg.is_a?(Hash)
+        arg.reject { |_, val| val.eql?(DefaultValue) }
+      else
+        arg
+      end
+    end
   end
 end

data/lib/bogus/interaction_presenter.rb

@@ -1,6 +1,6 @@
 module Bogus
   class InteractionPresenter
-    extend Bogus::Takes
+    extend Takes
 
     takes :interaction
 

data/lib/bogus/makes_ducks.rb

@@ -1,16 +1,15 @@
 module Bogus
   class MakesDucks
-    extend Bogus::Takes
+    extend Takes
 
-    takes :class_methods, :instance_methods, :makes_subtypes
+    takes :method_copiers, :makes_subtypes
 
     def make(first_class, *classes)
       duck = makes_subtypes.make(first_class)
       classes.each do |klass|
-        remove_methods(class_methods.call(duck),
-                       class_methods.call(klass))
-        remove_methods(instance_methods.call(duck),
-                       instance_methods.call(klass))
+        method_copiers.each do |copier|
+          remove_methods(copier.call(duck), copier.call(klass))
+        end
       end
       duck
     end

data/lib/bogus/makes_subtypes.rb

@@ -1,6 +1,6 @@
 module Bogus
   class MakesSubtypes
-    extend Bogus::Takes
+    extend Takes
 
     takes :copies_methods
 

data/lib/bogus/method_stringifier.rb

@@ -10,21 +10,29 @@ module Bogus
     end
 
     def arguments_as_string(arguments)
-      arguments = fill_in_missing_names(arguments)
-      arguments.map{|type, name| argument_to_string(name, type) }.compact.join(', ')
+      stringify_arguments(arguments, DefaultValue)
     end
 
     def argument_values(arguments)
-      arguments_as_string(arguments).gsub(" = Bogus::DefaultValue", '')
+      stringify_arguments(arguments)
     end
 
-    def argument_to_string(name, type)
+    private
+
+    def stringify_arguments(arguments, default = nil)
+      fill_in_missing_names(arguments).map do |type, name|
+        argument_to_string(name, type, default)
+      end.join(', ')
+    end
+
+    def argument_to_string(name, type, default)
       case type
       when :block then "&#{name}"
-      when :key   then "#{name}: #{name}"
-      when :opt   then "#{name} = Bogus::DefaultValue"
-      when :req   then name
-      when :rest  then "*#{name}"
+      when :key then default ? "#{name}: #{default}" : "#{name}: #{name}"
+      when :opt then default ? "#{name} = #{default}" : name
+      when :req then name
+      when :rest then "*#{name}"
+      when :keyrest then "**#{name}"
       else raise "unknown argument type: #{type}"
       end
     end

data/lib/bogus/record_interactions.rb

@@ -1,7 +1,7 @@
 module Bogus
   module RecordInteractions
     def __shadow__
-      @__shadow__ ||= Shadow.new{ self }
+      @__shadow__ ||= Shadow.new
     end
 
     def __record__(method, *args, &block)

data/lib/bogus/records_double_interactions.rb

@@ -1,11 +1,12 @@
-class Bogus::RecordsDoubleInteractions
-  extend Bogus::Takes
+module Bogus
+  class RecordsDoubleInteractions
+    extend Takes
 
-  takes :doubled_interactions, :fake_registry
+    takes :doubled_interactions, :fake_registry
 
-  def record(object, method_name, args, &block)
-    fake_name = fake_registry.name(object)
-    doubled_interactions.record(fake_name, method_name, *args, &block) if fake_name
+    def record(object, method_name, args, &block)
+      fake_name = fake_registry.name(object)
+      doubled_interactions.record(fake_name, method_name, *args, &block) if fake_name
+    end
   end
-
 end

data/lib/bogus/registers_created_fakes.rb

@@ -1,12 +1,14 @@
-class Bogus::RegistersCreatedFakes
-  extend Bogus::Takes
+module Bogus
+  class RegistersCreatedFakes
+    extend Takes
 
-  takes :creates_fakes, :fake_registry, :double_tracker
+    takes :creates_fakes, :fake_registry, :double_tracker
 
-  def create(name, opts = {}, &block)
-    fake = creates_fakes.create(name, opts, &block)
-    fake_registry.store(name, fake)
-    double_tracker.track(fake)
-    fake
+    def create(name, opts = {}, &block)
+      fake = creates_fakes.create(name, opts, &block)
+      fake_registry.store(name, fake)
+      double_tracker.track(fake)
+      fake
+    end
   end
 end

data/lib/bogus/responds_to_everything.rb

@@ -1,11 +1,18 @@
 module Bogus
   class RespondsToEverything
+    include FakeObject
+    include RecordInteractions
+
+    def initialize
+      __shadow__
+    end
+
     def respond_to?(method)
       true
     end
 
     def method_missing(name, *args, &block)
-      self
+      __record__(name, *args, &block)
     end
   end
 end

data/lib/bogus/shadow.rb

@@ -2,10 +2,10 @@ module Bogus
   class Shadow
     attr_reader :calls
 
-    def initialize(&default_return_value)
+    def initialize
       @calls = []
       @stubs = []
-      @defaults = Hash.new(default_return_value)
+      @defaults = {}
       @required = Set.new
     end
 
@@ -54,6 +54,7 @@ module Bogus
     def return_value(interaction)
       _, return_value = @stubs.reverse.find{|i, v| i == interaction}
       return_value ||= @defaults[interaction.method]
+      return_value ||= proc{ UndefinedReturnValue.new(interaction) }
       return_value.call
     end
   end

data/lib/bogus/undefined_return_value.rb

@@ -0,0 +1,11 @@
+module Bogus
+  class UndefinedReturnValue
+    def initialize(interaction)
+      @interaction = InteractionPresenter.new(interaction)
+    end
+
+    def to_s
+      "#<UndefinedReturnValue for #{@interaction}>"
+    end
+  end
+end

data/lib/bogus/verifies_contracts.rb

@@ -1,16 +1,18 @@
-class Bogus::VerifiesContracts
-  extend Bogus::Takes
+module Bogus
+  class VerifiesContracts
+    extend Takes
 
-  takes :doubled_interactions, :real_interactions
+    takes :doubled_interactions, :real_interactions
 
-  def verify(fake_name)
-    missed = doubled_interactions.for_fake(fake_name).reject do |interaction|
-      real_interactions.recorded?(fake_name, interaction)
-    end
+    def verify(fake_name)
+      missed = doubled_interactions.for_fake(fake_name).reject do |interaction|
+        real_interactions.recorded?(fake_name, interaction)
+      end
 
-    unless missed.empty?
-      actual = real_interactions.for_fake(fake_name)
-      raise Bogus::ContractNotFulfilled.new(fake_name, missed: missed, actual: actual)
+      unless missed.empty?
+        actual = real_interactions.for_fake(fake_name)
+        raise Bogus::ContractNotFulfilled.new(fake_name, missed: missed, actual: actual)
+      end
     end
   end
 end

data/lib/bogus/verifies_stub_definition.rb

@@ -1,43 +1,39 @@
-class Bogus::VerifiesStubDefinition
-  extend Bogus::Takes
-
-  takes :method_stringifier
-
-  def verify!(object, method_name, args)
-    stubbing_non_existent_method!(object, method_name) unless object.respond_to?(method_name)
-    return unless object.methods.include?(method_name)
-    return if any_args?(args)
-    method = object.method(method_name)
-    wrong_number_of_arguments!(method, args) if under_number_of_required_arguments?(method, args.size)
-    wrong_number_of_arguments!(method, args) if over_number_of_allowed_arguments?(method, args.size)
-  end
-
-  private
-
-  def wrong_number_of_arguments!(method, args)
-    args_string = method_stringifier.arguments_as_string(method.parameters)
-    raise ArgumentError, "tried to stub #{method.name}(#{args_string}) with #{args.size} arguments"
-  end
-
-  def stubbing_non_existent_method!(object, method_name)
-    raise NameError, "#{object.inspect} does not respond to #{method_name}"
-  end
-
-  def under_number_of_required_arguments?(method, args_count)
-    number_of_arguments = method.arity
-    number_of_arguments = -number_of_arguments - 1 if number_of_arguments < 0
-
-    args_count < number_of_arguments
-  end
-
-  def over_number_of_allowed_arguments?(method, args_count)
-    return false if method.parameters.find{|type, name| type == :rest}
-    number_of_arguments = method.parameters.count{|type, name| [:key, :opt, :req].include?(type) }
-
-    args_count > number_of_arguments
-  end
-
-  def any_args?(args)
-    [Bogus::AnyArgs] == args
+module Bogus
+  class VerifiesStubDefinition
+    extend Takes
+
+    takes :method_stringifier
+
+    def verify!(object, method_name, args)
+      stubbing_non_existent_method!(object, method_name) unless object.respond_to?(method_name)
+      return unless object.methods.include?(method_name)
+      return if any_args?(args)
+      method = object.method(method_name)
+      verify_call!(method, args)
+    end
+
+    private
+
+    def verify_call!(method, args)
+      object = Object.new
+      fake_method = method_stringifier.stringify(method, "")
+      object.instance_eval(fake_method)
+      object.send(method.name, *args)
+    rescue ArgumentError
+      wrong_arguments!(method, args)
+    end
+
+    def wrong_arguments!(method, args)
+      args_string = method_stringifier.arguments_as_string(method.parameters)
+      raise ArgumentError, "tried to stub #{method.name}(#{args_string}) with arguments: #{args.map(&:inspect).join(",")}"
+    end
+
+    def stubbing_non_existent_method!(object, method_name)
+      raise NameError, "#{object.inspect} does not respond to #{method_name}"
+    end
+
+    def any_args?(args)
+      [Bogus::AnyArgs] == args
+    end
   end
 end