rr 0.3.11 → 0.4.0

data/examples/rr/scenario_method_proxy_example.rb

@@ -1,71 +0,0 @@
-require "examples/example_helper"
-
-module RR
-describe ScenarioMethodProxy, :shared => true do
-  before(:each) do
-    @space = Space.new
-    @subject = Object.new
-    @creator = @space.scenario_creator
-    @creator.mock
-  end
-
-  it "initializes proxy with passed in creator" do
-    class << @proxy
-      attr_reader :creator
-    end
-    @proxy.creator.should === @creator
-  end
-end
-
-describe ScenarioMethodProxy, ".new without block" do
-  it_should_behave_like "RR::ScenarioMethodProxy"
-
-  before do
-    @proxy = ScenarioMethodProxy.new(@space, @creator, @subject)
-  end
-
-  it "clears out all methods from proxy" do
-    proxy_subclass = Class.new(ScenarioMethodProxy) do
-      def i_should_be_a_scenario
-      end
-    end
-    proxy_subclass.instance_methods.should include('i_should_be_a_scenario')
-
-    proxy = proxy_subclass.new(@space, @creator, @subject)
-    proxy.i_should_be_a_scenario.should be_instance_of(ScenarioDefinition)
-  end
-end
-
-describe ScenarioMethodProxy, ".new with block" do
-  it_should_behave_like "RR::ScenarioMethodProxy"
-
-  before do
-    @proxy = ScenarioMethodProxy.new(@space, @creator, @subject) do |b|
-      b.foobar(1, 2) {:one_two}
-      b.foobar(1) {:one}
-      b.foobar.with_any_args {:default}
-      b.baz() {:baz_result}
-    end
-  end
-
-  it "creates doubles" do
-    @subject.foobar(1, 2).should == :one_two
-    @subject.foobar(1).should == :one
-    @subject.foobar(:something).should == :default
-    @subject.baz.should == :baz_result
-  end
-
-  it "clears out all methods from proxy" do
-    proxy_subclass = Class.new(ScenarioMethodProxy) do
-      def i_should_be_a_scenario
-      end
-    end
-    proxy_subclass.instance_methods.should include('i_should_be_a_scenario')
-
-    proxy_subclass.new(@space, @creator, @subject) do |m|
-      m.i_should_be_a_scenario.should be_instance_of(ScenarioDefinition)
-    end
-  end
-end
-
-end

data/examples/rr/space/hash_with_object_id_key_example.rb

@@ -1,86 +0,0 @@
-require "examples/example_helper"
-
-module RR
-describe HashWithObjectIdKey, "#[] and #[]=" do
-  it "stores object via object id" do
-    hash = HashWithObjectIdKey.new
-    array_1 = []
-    hash[array_1] = 1
-    array_2 = []
-    hash[array_2] = 2
-
-    hash[array_1].should_not == hash[array_2]
-  end
-
-  it "stores the passed in object" do
-    hash = HashWithObjectIdKey.new
-    obj = Object.new
-    hash[obj] = 1
-    hash.instance_eval {@keys}.should == {obj.__id__ => obj}
-  end
-end
-
-describe HashWithObjectIdKey, "#each" do
-  it "iterates through the items in the hash" do
-    hash = HashWithObjectIdKey.new
-    hash['one'] = 1
-    hash['two'] = 2
-
-    keys = []
-    values = []
-    hash.each do |key, value|
-      keys << key
-      values << value
-    end
-
-    keys.sort.should == ['one', 'two']
-    values.sort.should == [1, 2]
-  end
-end
-
-describe HashWithObjectIdKey, "#delete" do
-  before do
-    @hash = HashWithObjectIdKey.new
-    @key = Object.new
-    @hash[@key] = 1
-  end
-
-  it "removes the object from the hash" do
-    @hash.delete(@key)
-    @hash[@key].should == {}
-  end
-
-  it "removes the object from the keys hash" do
-    @hash.delete(@key)
-    @hash.instance_eval {@keys}.should == {}
-  end
-end
-
-describe HashWithObjectIdKey, "#keys" do
-  before do
-    @hash = HashWithObjectIdKey.new
-    @key = Object.new
-    @hash[@key] = 1
-  end
-
-  it "returns an array of the keys" do
-    @hash.keys.should == [@key]
-  end
-end
-
-describe HashWithObjectIdKey, "#include?" do
-  before do
-    @hash = HashWithObjectIdKey.new
-    @key = Object.new
-    @hash[@key] = 1
-  end
-
-  it "returns true when the key is in the Hash" do
-    @hash.should include(@key)
-  end
-
-  it "returns false when the key is not in the Hash" do
-    @hash.should_not include(Object.new)
-  end
-end
-end

data/examples/rr/space/space_create_example.rb

@@ -1,278 +0,0 @@
-require "examples/example_helper"
-
-module RR
-describe Space, "#scenario_method_proxy", :shared => true do
-  it_should_behave_like "RR::Space"
-
-  before do
-    @space = Space.new
-    @object = Object.new
-  end
-
-  it "creates a ScenarioMethodProxy" do
-    proxy = @space.scenario_method_proxy(@creator, @object)
-    proxy.should be_instance_of(ScenarioMethodProxy)
-  end
-
-  it "sets space to self" do
-    proxy = @space.scenario_method_proxy(@creator, @object)
-    class << proxy
-      attr_reader :space
-    end
-    proxy.space.should === @space
-  end
-
-  it "sets creator to passed in creator" do
-    proxy = @space.scenario_method_proxy(@creator, @object)
-    class << proxy
-      attr_reader :creator
-    end
-    proxy.creator.should === @creator
-  end
-
-  it "raises error if passed a method name and a block" do
-    proc do
-      @space.scenario_method_proxy(@creator, @object, :foobar) {}
-    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
-  end
-end
-
-describe Space, "#scenario_method_proxy with a Mock strategy" do
-  it_should_behave_like "RR::Space#scenario_method_proxy"
-
-  before do
-    @creator = @space.scenario_creator
-    @creator.mock
-  end
-
-  it "creates a mock Scenario for method when passed a second argument" do
-    @space.scenario_method_proxy(@creator, @object, :foobar).with(1) {:baz}
-    @object.foobar(1).should == :baz
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
-  end
-
-  it "uses block definition when passed a block" do
-    @space.scenario_method_proxy(@creator, @object) do |c|
-      c.foobar(1) {:baz}
-    end
-    @object.foobar(1).should == :baz
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
-  end
-end
-
-describe Space, "#scenario_method_proxy with a Stub strategy" do
-  it_should_behave_like "RR::Space#scenario_method_proxy"
-
-  before do
-    @creator = @space.scenario_creator
-    @creator.stub
-  end
-
-  it "creates a stub Scenario for method when passed a second argument" do
-    @space.scenario_method_proxy(@creator, @object, :foobar).with(1) {:baz}
-    @object.foobar(1).should == :baz
-    @object.foobar(1).should == :baz
-  end
-
-  it "uses block definition when passed a block" do
-    @space.scenario_method_proxy(@creator, @object) do |c|
-      c.foobar(1) {:return_value}
-      c.foobar.with_any_args {:default}
-      c.baz(1) {:baz_value}
-    end
-    @object.foobar(1).should == :return_value
-    @object.foobar.should == :default
-    proc {@object.baz.should == :return_value}.should raise_error
-  end
-end
-
-describe Space, "#scenario_method_proxy with a Mock Probe strategy" do
-  it_should_behave_like "RR::Space#scenario_method_proxy"
-
-  before do
-    @creator = @space.scenario_creator
-    @creator.mock.probe
-    def @object.foobar(*args)
-      :original_foobar
-    end
-  end
-
-  it "creates a mock probe Scenario for method when passed a second argument" do
-    @space.scenario_method_proxy(@creator, @object, :foobar).with(1)
-    @object.foobar(1).should == :original_foobar
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
-  end
-
-  it "uses block definition when passed a block" do
-    @space.scenario_method_proxy(@creator, @object) do |c|
-      c.foobar(1)
-    end
-    @object.foobar(1).should == :original_foobar
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
-  end
-end
-
-describe Space, "#scenario_method_proxy with a Stub Probe strategy" do
-  it_should_behave_like "RR::Space#scenario_method_proxy"
-
-  before do
-    @creator = @space.scenario_creator
-    @creator.stub.probe
-    def @object.foobar(*args)
-      :original_foobar
-    end
-  end
-
-  it "creates a stub probe Scenario for method when passed a second argument" do
-    @space.scenario_method_proxy(@creator, @object, :foobar)
-    @object.foobar(1).should == :original_foobar
-    @object.foobar(1).should == :original_foobar
-  end
-
-  it "uses block definition when passed a block" do
-    @space.scenario_method_proxy(@creator, @object) do |c|
-      c.foobar(1)
-    end
-    @object.foobar(1).should == :original_foobar
-    @object.foobar(1).should == :original_foobar
-  end
-end
-
-describe Space, "#scenario_method_proxy with a Do Not Allow strategy" do
-  it_should_behave_like "RR::Space#scenario_method_proxy"
-
-  before do
-    @creator = @space.scenario_creator
-    @creator.do_not_call
-  end
-
-  it "creates a do not allow Scenario for method when passed a second argument" do
-    @space.scenario_method_proxy(@creator, @object, :foobar).with(1)
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
-  end
-
-  it "uses block definition when passed a block" do
-    @space.scenario_method_proxy(@creator, @object) do |c|
-      c.foobar(1)
-    end
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
-  end
-end
-
-describe Space, "#scenario_creator" do
-  it_should_behave_like "RR::Space"
-
-  before do
-    @space = Space.new
-    @object = Object.new
-    @creator = @space.scenario_creator
-  end
-
-  it "sets the space" do
-    @creator.space.should === @space
-  end
-
-  it "creates a ScenarioCreator" do
-    @creator.should be_instance_of(ScenarioCreator)
-  end
-end
-
-describe Space, "#scenario" do
-  it_should_behave_like "RR::Space"
-
-  before do
-    @space = Space.new
-    @object = Object.new
-    @method_name = :foobar
-  end
-
-  it "creates a Scenario and registers it to the double" do
-    double = @space.double(@object, @method_name)
-    def double.scenarios
-      @scenarios
-    end
-
-    scenario = @space.scenario(double)
-    double.scenarios.should include(scenario)
-  end
-end
-
-describe Space, "#double" do
-  it_should_behave_like "RR::Space"
-
-  before do
-    @space = Space.new
-  end
-
-  it "creates a new double when existing object == but not === with the same method name" do
-    object1 = []
-    object2 = []
-    (object1 === object2).should be_true
-    object1.__id__.should_not == object2.__id__
-
-    double1 = @space.double(object1, :foobar)
-    double2 = @space.double(object2, :foobar)
-    
-    double1.should_not == double2
-  end
-end
-
-describe Space, "#double when double does not exist" do
-  it_should_behave_like "RR::Space"
-
-  before do
-    @space = Space.new
-    @object = Object.new
-    def @object.foobar(*args)
-      :original_foobar
-    end
-    @method_name = :foobar
-  end
-
-  it "returns double and adds double to double list when method_name is a symbol" do
-    double = @space.double(@object, @method_name)
-    @space.double(@object, @method_name).should === double
-    double.space.should === @space
-    double.object.should === @object
-    double.method_name.should === @method_name
-  end
-
-  it "returns double and adds double to double list when method_name is a string" do
-    double = @space.double(@object, 'foobar')
-    @space.double(@object, @method_name).should === double
-    double.space.should === @space
-    double.object.should === @object
-    double.method_name.should === @method_name
-  end
-
-  it "overrides the method when passing a block" do
-    double = @space.double(@object, @method_name)
-    @object.methods.should include("__rr__#{@method_name}")
-  end
-end
-
-describe Space, "#double when double exists" do
-  it_should_behave_like "RR::Space"
-
-  before do
-    @space = Space.new
-    @object = Object.new
-    def @object.foobar(*args)
-      :original_foobar
-    end
-    @method_name = :foobar
-  end
-
-  it "returns the existing double" do
-    original_foobar_method = @object.method(:foobar)
-    double = @space.double(@object, 'foobar')
-
-    double.object_has_original_method?.should be_true
-
-    @space.double(@object, 'foobar').should === double
-
-    double.reset
-    @object.foobar.should == :original_foobar
-  end
-end
-end

data/examples/rr/space/space_example.rb

@@ -1,29 +0,0 @@
-require "examples/example_helper"
-
-module RR
-describe Space, " class" do
-  it_should_behave_like "RR::Space"
-
-  before(:each) do
-    @original_space = Space.instance
-    @space = Space.new
-    Space.instance = @space
-  end
-
-  after(:each) do
-    Space.instance = @original_space
-  end
-
-  it "proxies to a singleton instance of Space" do
-    create_double_args = nil
-    (class << @space; self; end).class_eval do
-      define_method :double do |*args|
-        create_double_args = args
-      end
-    end
-
-    Space.double(:foo, :bar)
-    create_double_args.should == [:foo, :bar]
-  end
-end
-end