bogus 0.0.1

data/features/safe_mocking.feature

@@ -0,0 +1,59 @@
+Feature: Safe mocking
+
+  Background:
+    Given a file named "foo.rb" with:
+    """ruby
+    class Library
+      def checkout(book)
+      end
+    end
+    """
+
+  Scenario: Mocking methods that exist on real object
+    Then spec file with following content should pass:
+    """ruby
+    describe Library do
+
+      it "does something" do
+        library = Library.new
+        mock(library).checkout("some book") { :checked_out }
+
+        library.checkout("some book").should == :checked_out
+      end
+    end
+    """
+
+  Scenario: Mocking methods that do not exist on real object
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      it "does something" do
+        library = Library.new
+        mock(library).buy("some book") { :bought }
+        library.buy("some book")
+      end
+    end
+    """
+
+  Scenario: Mocking methods with wrong number of arguments
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      it "does something" do
+        library = Library.new
+        mock(library).checkout("some book", "another book") { :bought }
+        library.checkout("some book", "another book")
+      end
+    end
+    """
+
+  Scenario: Mocks require the methods to be called
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      it "does something" do
+        library = Library.new
+        mock(library).checkout("some book") { :bought }
+      end
+    end
+    """

data/features/safe_stubbing.feature

@@ -0,0 +1,62 @@
+Feature: Safe stubbing
+
+  Most Ruby test double libraries let you stub methods that don't exist.
+  Bogus is different in this respect: not only does it not allow stubbing 
+  methods that don't exist, it also ensures that the number of arguments
+  you pass to those methods matches the method definition.
+
+  Background:
+    Given a file named "foo.rb" with:
+    """ruby
+    class Library
+      def checkout(book)
+      end
+    end
+    """
+
+  Scenario: Stubbing methods that exist on real object
+    Then spec file with following content should pass:
+    """ruby
+    describe Library do
+
+      it "does something" do
+        library = Library.new
+        stub(library).checkout("some book") { :checked_out }
+
+        library.checkout("some book").should == :checked_out
+      end
+    end
+    """
+
+  Scenario: Stubbing methods that do not exist on real object
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      it "does something" do
+        library = Library.new
+        stub(library).buy("some book") { :bought }
+      end
+    end
+    """
+
+  Scenario: Stubbing methods with wrong number of arguments
+    Then spec file with following content should fail:
+    """ruby
+    describe Library do
+      it "does something" do
+        library = Library.new
+        stub(library).checkout("some book", "another book") { :bought }
+      end
+    end
+    """
+
+  Scenario: Stubs allow the methods to be called
+    Then spec file with following content should pass:
+    """ruby
+    describe Library do
+      it "does something" do
+        library = Library.new
+        stub(library).checkout("some book") { :bought }
+      end
+    end
+    """

data/features/spies.feature

@@ -0,0 +1,78 @@
+Feature: Spies
+
+  Object Oriented Programming is all about messages sent between the objects.
+  If you follow principles like "Tell, Don't Ask", you will enable yourself
+  to combine Bogus's powerful feature of faking objects with it's ability 
+  to verify object interactions.
+
+  Background:
+    Given a file named "foo.rb" with:
+    """ruby
+    class Library
+      def checkout(book)
+        # marks book as checked out
+      end
+    end
+
+    class Student
+      def initialize(library)
+        @library = library
+      end
+
+      def study(*book_titles)
+        book_titles.each do |book_title|
+          @library.checkout(book_title)
+        end
+      end
+    end
+    """
+
+  Scenario: Ensuring methods were called
+    Then spec file with following content should pass:
+    """ruby
+    describe Student do
+      fake(:library)
+
+      it "studies using books from library" do
+        student = Student.new(library)
+
+        student.study("Moby Dick", "Sherlock Holmes")
+
+        library.should have_received.checkout("Moby Dick")
+        library.should have_received.checkout("Sherlock Holmes")
+      end
+    end
+    """
+
+  Scenario: Spying on methods that do not exist
+    Then spec file with following content should fail:
+    """ruby
+    describe Student do
+      fake(:library)
+
+      it "studies using books from library" do
+        student = Student.new(library)
+
+        student.study("Moby Dick")
+
+        library.should_not have_received.return_book("Moby Dick")
+      end
+    end
+    """
+
+  Scenario: Spying on methods with wrong number of arguments
+    Then spec file with following content should fail:
+    """ruby
+    describe Student do
+      fake(:library)
+
+      it "studies using books from library" do
+        student = Student.new(library)
+
+        student.study("Moby Dick", "Sherlock Holmes")
+
+        library.should_not have_received.checkout("Moby Dick", 
+          "Sherlock Holmes")
+      end
+    end
+    """

data/features/step_definitions/rspec_steps.rb

@@ -0,0 +1,68 @@
+Given /^a spec file named "([^"]*)" with:$/ do |file_name, string|
+  @spec_file_names ||= []
+  @spec_file_names << file_name
+
+  steps %Q{
+    Given a file named "#{file_name}" with:
+    """ruby
+    require 'bogus'
+    require 'bogus/rspec'
+    require 'rr'
+
+    require_relative 'foo'
+
+    RSpec.configure do |config|
+      config.mock_with :rr
+    end
+
+    #{string}
+    """
+  }
+end
+
+Then /^the specs should fail$/ do
+  steps %Q{
+    Then the exit status should be 1
+  }
+end
+
+Then /^all the specs should pass$/ do
+  steps %Q{
+    Then the exit status should be 0
+  }
+end
+
+When /^I run spec with the following content:$/ do |string|
+  file_name = 'foo_spec.rb'
+
+  steps %Q{
+    Given a spec file named "#{file_name}" with:
+    """ruby
+    #{string}
+    """
+  }
+
+  steps %Q{
+    When I run `rspec #{@spec_file_names.join(' ')}`
+  }
+end
+
+Then /^spec file with following content should pass:$/ do |string|
+  steps %Q{
+    When I run spec with the following content:
+    """ruby
+    #{string}
+    """
+    Then all the specs should pass
+  }
+end
+
+Then /^spec file with following content should fail:$/ do |string|
+  steps %Q{
+    When I run spec with the following content:
+    """ruby
+    #{string}
+    """
+    Then the specs should fail
+  }
+end

data/features/support/env.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/lib/bogus.rb

@@ -0,0 +1,35 @@
+require 'dependor'
+
+module Bogus
+  autoload :AddsRecording,             'bogus/adds_recording'
+  autoload :Configuration,             'bogus/configuration'
+  autoload :ContractNotFulfilled,      'bogus/contract_not_fulfilled'
+  autoload :ConvertsNameToClass,       'bogus/converts_name_to_class'
+  autoload :CopiesClasses,             'bogus/copies_classes'
+  autoload :CreatesFakes,              'bogus/creates_fakes'
+  autoload :Double,                    'bogus/double'
+  autoload :Fake,                      'bogus/fake'
+  autoload :FakeRegistry,              'bogus/fake_registry'
+  autoload :Injector,                  'bogus/injector'
+  autoload :Interaction,               'bogus/interaction'
+  autoload :InteractionPresenter,      'bogus/interaction_presenter'
+  autoload :InteractionsRepository,    'bogus/interactions_repository'
+  autoload :InvocationMatcher,         'bogus/invocation_matcher'
+  autoload :MethodStringifier,         'bogus/method_stringifier'
+  autoload :MockingDSL,                'bogus/rspec_extensions'
+  autoload :OverwritesClasses,         'bogus/overwrites_classes'
+  autoload :ProxyClass,                'bogus/proxy_class'
+  autoload :PublicMethods,             'bogus/public_methods'
+  autoload :RRProxy,                   'bogus/rr_proxy'
+  autoload :RSpecExtensions,           'bogus/rspec_extensions'
+  autoload :RecordInteractions,        'bogus/record_interactions'
+  autoload :RecordingProxy,            'bogus/recording_proxy'
+  autoload :RecordsDoubleInteractions, 'bogus/records_double_interactions'
+  autoload :RegistersCreatedFakes,     'bogus/registers_created_fakes'
+  autoload :Takes,                     'bogus/takes'
+  autoload :VERSION,                   'bogus/version'
+  autoload :VerifiesContracts,         'bogus/verifies_contracts'
+  autoload :VerifiesStubDefinition,    'bogus/verifies_stub_definition'
+
+  extend PublicMethods
+end

data/lib/bogus/adds_recording.rb

@@ -0,0 +1,11 @@
+class Bogus::AddsRecording
+  extend Bogus::Takes
+
+  takes :converts_name_to_class, :create_proxy_class, :overwrites_classes
+
+  def add(name)
+    klass = converts_name_to_class.convert(name)
+    new_klass = create_proxy_class.call(name, klass)
+    overwrites_classes.overwrite(klass, new_klass)
+  end
+end

data/lib/bogus/configuration.rb

@@ -0,0 +1,9 @@
+module Bogus
+  class Configuration
+    attr_writer :search_modules
+
+    def search_modules
+      @search_modules ||= [Object]
+    end
+  end
+end

data/lib/bogus/contract_not_fulfilled.rb

@@ -0,0 +1,24 @@
+module Bogus
+  class ContractNotFulfilled < StandardError
+    attr_reader :interactions
+
+    def initialize(interactions)
+      @interactions = interactions
+      super(message)
+    end
+
+    def message
+      interactions.map { |fake_name, missed| missed_for_fake(fake_name, missed) }.join("\n")
+    end
+
+    private
+
+    def missed_for_fake(fake_name, missed)
+      "Contract not fullfilled for #{fake_name}:\n#{missed_interactions(missed)}"
+    end
+
+    def missed_interactions(missed)
+      missed.map { |i| "  - #{InteractionPresenter.new(i)}" }.join("\n")
+    end
+  end
+end

data/lib/bogus/converts_name_to_class.rb

@@ -0,0 +1,31 @@
+module Bogus
+  class ConvertsNameToClass
+    extend Takes
+
+    class CanNotFindClass < RuntimeError; end
+
+    takes :search_modules
+
+    def convert(name)
+      class_name = camelize(name)
+      klass = nil
+
+      @search_modules.each do |mod|
+        klass = mod.const_get(class_name) rescue nil
+        break if klass
+      end
+
+      raise CanNotFindClass.new("Can not locate class for name: #{name}") unless klass
+
+      klass
+    end
+
+    private
+
+    def camelize(symbol)
+      string = symbol.to_s
+      string = string.gsub(/_\w/) { |match| match[1].upcase }
+      return string.gsub(/^\w/) { |match| match.upcase }
+    end
+  end
+end

data/lib/bogus/copies_classes.rb

@@ -0,0 +1,44 @@
+module Bogus
+  class CopiesClasses
+    extend Takes
+
+    takes :method_stringifier
+
+    def copy(klass)
+      copy_class = Class.new(Bogus::Fake)
+
+      copy_class.__copied_class__ = klass
+      copy_instance_methods(klass, copy_class)
+      copy_class_methods(klass, copy_class)
+
+      return copy_class
+    end
+
+    private
+
+    def copy_instance_methods(klass, copy_class)
+      instance_methods = klass.instance_methods - Object.instance_methods
+
+      instance_methods.each do |name|
+        copy_class.class_eval(method_as_string(klass.instance_method(name)))
+      end
+    end
+
+    def copy_class_methods(klass, copy_class)
+      klass_methods = klass.methods - Class.methods
+
+      klass_methods.each do |name|
+        copy_class.instance_eval(method_as_string(klass.method(name)))
+      end
+    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})")
+    end
+
+  end
+end

data/lib/bogus/creates_fakes.rb

@@ -0,0 +1,32 @@
+module Bogus
+  class CreatesFakes
+    class UnknownMode < RuntimeError; end
+
+    extend Takes
+
+    takes :copies_classes, :converts_name_to_class
+
+    def create(name, opts = {}, &block)
+      klass = self.klass(name, &block)
+      klass_copy = copies_classes.copy(klass)
+
+      mode = opts.fetch(:as, :instance)
+
+      case mode
+      when :instance
+        return klass_copy.new
+      when :class
+        return klass_copy
+      else
+        raise UnknownMode.new("Unknown fake creation mode: #{mode}. Allowed values are :instance, :class")
+      end
+    end
+
+    protected
+
+    def klass(name, &block)
+      return block.call if block_given?
+      converts_name_to_class.convert(name)
+    end
+  end
+end