bogus 0.0.1

data/lib/bogus/takes.rb

@@ -0,0 +1,8 @@
+module Bogus
+  module Takes
+    def takes(*args)
+      include Dependor::Constructor(*args)
+      attr_reader *args
+    end
+  end
+end

data/lib/bogus/verifies_contracts.rb

@@ -0,0 +1,12 @@
+class Bogus::VerifiesContracts
+  extend Bogus::Takes
+
+  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
+    raise Bogus::ContractNotFulfilled.new(fake_name => missed) unless missed.empty?
+  end
+end

data/lib/bogus/verifies_stub_definition.rb

@@ -0,0 +1,37 @@
+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)
+    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| [:opt, :req].include?(type) }
+
+    args_count > number_of_arguments
+  end
+end

data/lib/bogus/version.rb

@@ -0,0 +1,3 @@
+module Bogus
+  VERSION = "0.0.1"
+end

data/pelusa.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+rvm rbx exec pelusa

data/rbs.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+rvm 1.9.2@bogus,1.9.3@bogus,rbx19@bogus,jruby@bogus exec $@

data/spec/bogus/adds_recording_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Bogus::AddsRecording do
+  module SampleModule
+    class Library
+    end
+  end
+
+  let(:converts_name_to_class) { stub }
+  let(:create_proxy_class) { stub }
+  let(:overwrites_classes) { stub }
+  let(:adds_recording) { Bogus::AddsRecording.new(converts_name_to_class, create_proxy_class, overwrites_classes) }
+
+  before do
+    stub(converts_name_to_class).convert { SampleModule::Library }
+    stub(create_proxy_class).call { Object }
+    stub(overwrites_classes).overwrite
+
+    adds_recording.add(:library)
+  end
+
+  it "converts the fake name to class" do
+    converts_name_to_class.should have_received.convert(:library)
+  end
+
+  it "creates the proxy" do
+    create_proxy_class.should have_received.call(:library, SampleModule::Library)
+  end
+
+  it "swaps the classes" do
+    overwrites_classes.should have_received.overwrite(SampleModule::Library, Object)
+  end
+end

data/spec/bogus/configuration_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../spec_helper'
+
+describe Bogus::Configuration do
+  after { Bogus.reset! }
+
+  it "stores the modules to be searched" do
+    Bogus.configure do |c|
+      c.search_modules << String
+    end
+
+    Bogus.config.search_modules.should == [Object, String]
+  end
+
+  it "defaults search_modules to [Object]" do
+    Bogus.config.search_modules.should == [Object]
+  end
+end

data/spec/bogus/converts_name_to_class_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../spec_helper'
+
+describe Bogus::ConvertsNameToClass do
+  FooBarBaz = Class.new
+
+  module Foo
+    FooBarBaz = Class.new
+  end
+
+  module Bar
+    FooBarBaz = Class.new
+    Bam = Class.new
+  end
+
+  it "finds classes in golbal namespace by default" do
+    converts_name_to_class = Bogus::ConvertsNameToClass.new(Bogus.config.search_modules)
+
+    converts_name_to_class.convert(:foo_bar_baz).should == FooBarBaz
+  end
+
+  it "looks in the modules in the specified order" do
+    converts_name_to_class = Bogus::ConvertsNameToClass.new([Foo, Bar])
+
+    converts_name_to_class.convert(:foo_bar_baz).should == Foo::FooBarBaz
+  end
+
+  it "looks in the next module on the list if the first does not contain the class" do
+    converts_name_to_class = Bogus::ConvertsNameToClass.new([Foo, Bar])
+
+    converts_name_to_class.convert(:bam).should == Bar::Bam
+  end
+
+  it "raises an error if it can't find the class" do
+    converts_name_to_class = Bogus::ConvertsNameToClass.new([Foo])
+
+    expect do
+      converts_name_to_class.convert(:bam)
+    end.to raise_error(Bogus::ConvertsNameToClass::CanNotFindClass)
+  end
+end

data/spec/bogus/copies_classes_spec.rb

@@ -0,0 +1,175 @@
+require_relative '../spec_helper'
+
+describe Bogus::CopiesClasses do
+  module SampleMethods
+    def foo
+    end
+
+    def bar(x)
+    end
+
+    def baz(x, *y)
+    end
+
+    def bam(opts = {})
+    end
+
+    def baa(x, &block)
+    end
+  end
+
+  shared_examples_for 'the copied class' do
+    it "copies methods with no arguments" do
+      subject.should respond_to(:foo)
+      subject.foo
+    end
+
+    it "copies methods with explicit arguments" do
+      subject.should respond_to(:bar)
+
+      subject.method(:bar).arity.should == 1
+
+      subject.bar('hello')
+    end
+
+    it "copies methods with variable arguments" do
+      subject.should respond_to(:baz)
+
+      subject.baz('hello', 'foo', 'bar', 'baz')
+    end
+
+    it "copies methods with default arguments" do
+      subject.should respond_to(:bam)
+
+      subject.bam
+      subject.bam(hello: 'world')
+    end
+
+    it "copies methods with block arguments" do
+      subject.should respond_to(:baa)
+
+      subject.baa('hello')
+      subject.baa('hello') {}
+    end
+
+    it "makes the methods chainable" do
+      subject.foo.bar('hello').baz('hello', 'world', 'foo').bam.baa('foo')
+    end
+  end
+
+  let(:method_stringifier) { Bogus::MethodStringifier.new }
+  let(:copies_classes) { Bogus::CopiesClasses.new(method_stringifier) }
+  let(:fake_class) { copies_classes.copy(klass) }
+  let(:fake) { fake_class.new }
+
+  class FooWithInstanceMethods
+    include SampleMethods
+  end
+
+  context "instance methods" do
+    let(:klass) { FooWithInstanceMethods }
+    subject{ fake }
+
+    it_behaves_like 'the copied class'
+  end
+
+  context "constructors" do
+    let(:klass) {
+      Class.new do
+        def initialize(hello)
+        end
+      end
+    }
+
+    it "adds a constructor that allows passing any number of arguments" do
+      fake_class.new('hello', 'w', 'o', 'r', 'l', 'd') { test }
+    end
+  end
+
+  class ClassWithClassMethods
+    extend SampleMethods
+  end
+
+  context "class methods" do
+    let(:klass) { ClassWithClassMethods }
+    subject{ fake_class }
+
+    it_behaves_like 'the copied class'
+  end
+
+  context "identification" do
+    module SomeModule
+      class SomeClass
+      end
+    end
+
+    let(:klass) { SomeModule::SomeClass }
+
+    it "should copy the class name" do
+      fake.class.name.should == 'SomeModule::SomeClass'
+    end
+
+    it "should override kind_of?" do
+      fake.should be_kind_of(SomeModule::SomeClass)
+    end
+
+    it "should override instance_of?" do
+      fake.should be_instance_of(SomeModule::SomeClass)
+    end
+
+    it "should override is_a?" do
+      fake.should be_a(SomeModule::SomeClass)
+    end
+
+    it "should include class name in the output of fake's class #to_s" do
+      fake.class.to_s.should include(klass.name)
+    end
+
+    it "should include class name in the output of fake's #to_s" do
+      fake.to_s.should include(klass.name)
+    end
+
+    # TODO
+    it "should override kind_of?/instance_of? for base classes of copied class"
+    it "should override kind_of? for modules included into copied class"
+  end
+
+  shared_examples_for 'spying' do
+    def should_record(method, *args)
+      mock(subject).__record__(method, *args)
+
+      subject.send(method, *args)
+    end
+
+    it "records method calls with no arguments" do
+      should_record(:foo)
+    end
+
+    it "records method calls with explicit arguments" do
+      should_record(:bar, 'hello')
+    end
+
+    it "records method calls with variable arguments" do
+      should_record(:baz, 'hello', 'foo', 'bar', 'baz')
+    end
+
+    it "records method calls with default arguments" do
+      should_record(:bam, hello: 'world')
+    end
+  end
+
+  context "spying on an instance" do
+    let(:klass) { FooWithInstanceMethods }
+    subject{ fake }
+
+    include_examples 'spying'
+  end
+
+  context "spying on copied class" do
+    let(:klass) { ClassWithClassMethods }
+    subject { fake_class }
+
+    include_examples 'spying'
+  end
+end
+

data/spec/bogus/creates_fakes_spec.rb

@@ -0,0 +1,59 @@
+require_relative '../spec_helper'
+
+describe Bogus::CreatesFakes do
+  let(:fake_class) { stub() }
+  let(:fake_instance) { stub() }
+  let(:converts_name_to_class) { stub() }
+  let(:copies_classes) { stub() }
+  let(:creates_fakes) { Bogus::CreatesFakes.new(copies_classes, converts_name_to_class) }
+
+  module Foo
+  end
+
+  module Bar
+  end
+
+  before { stub(fake_class).new{fake_instance} }
+
+  context "without block" do
+    before do
+      mock(converts_name_to_class).convert(:foo) { Foo }
+      mock(copies_classes).copy(Foo) { fake_class }
+    end
+
+    it "creates a new instance of copied class by default" do
+      creates_fakes.create(:foo).should == fake_instance
+    end
+
+    it "creates a new instance of copied class if called with as: :instance" do
+      creates_fakes.create(:foo, as: :instance).should == fake_instance
+    end
+
+    it "copies class but does not create an instance if called with as: :class" do
+      creates_fakes.create(:foo, as: :class).should == fake_class
+    end
+
+    it "raises an error if the as mode is not known" do
+      expect do
+        creates_fakes.create(:foo, as: :something)
+      end.to raise_error(Bogus::CreatesFakes::UnknownMode)
+    end
+  end
+
+  context "with block" do
+    before do
+      stub(converts_name_to_class).convert
+      mock(copies_classes).copy(Bar) { fake_class }
+    end
+
+    it "uses the class provided" do
+      creates_fakes.create(:foo){Bar}.should == fake_instance
+    end
+
+    it "does not convert the class name" do
+      creates_fakes.create(:foo) { Bar}
+
+      copies_classes.should_not have_received.convert
+    end
+  end
+end

data/spec/bogus/double_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Bogus::Double do
+  let(:rr_double) { stub }
+  let(:verifies_stub_definition) { stub }
+  let(:records_double_interactions) { stub }
+
+  let(:object) { "strings have plenty of methods to call" }
+
+  let(:bogus_double) { isolate(Bogus::Double, double: rr_double) }
+
+  before do
+    stub(verifies_stub_definition).verify!
+    stub(records_double_interactions).record
+    stub(rr_double).method_name
+
+    bogus_double.method_name(:foo, :bar)
+  end
+
+  it "verifies that stub definition matches the real definition" do
+    verifies_stub_definition.should have_received.verify!(object, :method_name, [:foo, :bar])
+  end
+
+  it "records the stub interaction so that it can be verified later" do
+    records_double_interactions.should have_received.record(object, :method_name, [:foo, :bar])
+  end
+
+  it "proxies the method call" do
+    rr_double.should have_received.method_name(:foo, :bar)
+  end
+end

data/spec/bogus/fake_registry_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Bogus::FakeRegistry do
+  let(:fake_registry) { Bogus::FakeRegistry.new }
+
+  it "knows the fake's names" do
+    object = Object.new
+
+    fake_registry.store(:name, object)
+
+    fake_registry.name(object).should == :name
+  end
+
+  it "returns name based on object identity" do
+    example = Struct.new(:id)
+
+    object = example.new(1)
+    duplicate = example.new(1)
+
+    fake_registry.store(:object, object)
+
+    fake_registry.name(duplicate).should be_nil
+  end
+end