bogus 0.1.4 → 0.1.5

data/spec/bogus/stubbing/anything_spec.rb

@@ -4,10 +4,10 @@ describe Bogus::Anything do
   it "is equal to everything" do
     anything = Bogus::Anything
 
-    anything.should == "foo"
-    anything.should == "bar"
-    anything.should == 1
-    anything.should == Object.new
-    anything.should == anything
+    expect(anything).to eq("foo")
+    expect(anything).to eq("bar")
+    expect(anything).to eq(1)
+    expect(anything).to eq(Object.new)
+    expect(anything).to eq(anything)
   end
 end

data/spec/bogus/stubbing/double_spec.rb

@@ -16,7 +16,7 @@ module Bogus
           double.stub.foo("a", "b") { "the result" }
         }.to raise_error
 
-        double_tracker.should_not have_received.track(object)
+        expect(double_tracker).not_to have_received.track(object)
       end
 
       it "verifies stub definition" do
@@ -42,7 +42,7 @@ module Bogus
       it "adds method overwriting" do
         double.stub.foo("a", "b") { "the result" }
 
-        overwrites_methods.overwrites.should == [[object, :foo]]
+        expect(overwrites_methods.overwrites).to eq([[object, :foo]])
       end
 
       it "records double interactions" do

data/spec/bogus/stubbing/have_received_matcher_spec.rb

@@ -13,11 +13,11 @@ describe Bogus::HaveReceivedMatcher do
 
   shared_examples_for "have_received_matcher" do
     it "matches when the spy has received the message" do
-      fake.should have_received(:foo, "a", "b")
+      expect(fake).to have_received(:foo, "a", "b")
     end
 
     it "does not match if the spy hasn't received the message" do
-      fake.should_not have_received(:foo, "a", "c")
+      expect(fake).not_to have_received(:foo, "a", "c")
     end
 
     it "verifies that the method call has the right signature" do
@@ -39,9 +39,11 @@ describe Bogus::HaveReceivedMatcher do
     it "returns a readable error message for object with no shadow" do
       have_received(:upcase)
 
-      have_received_matcher.matches?("foo").should be_false
-      have_received_matcher.failure_message_for_should.should == Bogus::HaveReceivedMatcher::NO_SHADOW
-      have_received_matcher.failure_message_for_should_not.should == Bogus::HaveReceivedMatcher::NO_SHADOW
+      expect(have_received_matcher.matches?("foo")).to be_false
+      expect(have_received_matcher.failure_message_for_should).to eq(Bogus::HaveReceivedMatcher::NO_SHADOW)
+      expect(have_received_matcher.failure_message).to eq(Bogus::HaveReceivedMatcher::NO_SHADOW)
+      expect(have_received_matcher.failure_message_for_should_not).to eq(Bogus::HaveReceivedMatcher::NO_SHADOW)
+      expect(have_received_matcher.failure_message_when_negated).to eq(Bogus::HaveReceivedMatcher::NO_SHADOW)
     end
 
     it "returns a readable error message for fakes" do
@@ -49,10 +51,13 @@ describe Bogus::HaveReceivedMatcher do
 
       have_received_matcher.matches?(fake)
 
-      have_received_matcher.failure_message_for_should.should ==
+      message =
         %Q{Expected #{fake.inspect} to have received foo("a", "c"), but it didn't.\n\n}+
         %Q{The recorded interactions were:\n} +
         %Q{  - foo("a", "b")\n}
+
+      expect(have_received_matcher.failure_message_for_should).to eq(message)
+      expect(have_received_matcher.failure_message).to eq(message)
     end
   end
 

data/spec/bogus/stubbing/interaction_spec.rb

@@ -52,7 +52,7 @@ module Bogus
         first = create_interaction(first_interaction)
         second = create_interaction(second_interaction)
 
-        Interaction.same?(recorded: first, stubbed: second).should be_true
+        expect(Interaction.same?(recorded: first, stubbed: second)).to be_true
       end
     end
 
@@ -61,7 +61,7 @@ module Bogus
         first = create_interaction(first_interaction)
         second = create_interaction(second_interaction)
 
-        Interaction.same?(recorded: first, stubbed: second).should be_false
+        expect(Interaction.same?(recorded: first, stubbed: second)).to be_false
       end
     end
 
@@ -69,21 +69,21 @@ module Bogus
       first = Interaction.new(:foo, [:bar]) { raise SomeError }
       second = Interaction.new(:foo, [:bar]) { nil }
 
-      Interaction.same?(recorded: first, stubbed: second).should be_false
+      expect(Interaction.same?(recorded: first, stubbed: second)).to be_false
     end
 
     it "differs raised exceptions from ones just returned from the block" do
       first = Interaction.new(:foo, [:bar]) { raise SomeError }
       second = Interaction.new(:foo, [:bar]) { SomeError }
 
-      Interaction.same?(recorded: first, stubbed: second).should be_false
+      expect(Interaction.same?(recorded: first, stubbed: second)).to be_false
     end
 
     it "considers exceptions of the same type as equal" do
       first = Interaction.new(:foo, [:bar]) { raise SomeError }
       second = Interaction.new(:foo, [:bar]) { raise SomeError }
 
-      Interaction.same?(recorded: first, stubbed: second).should be_true
+      expect(Interaction.same?(recorded: first, stubbed: second)).to be_true
     end
 
     context 'when comparing arguments with custom #== implementations' do
@@ -97,14 +97,14 @@ module Bogus
         first = Interaction.new(:with, [Dev.new(:psyho)])
         second = Interaction.new(:with, [Dev.new(:psyho)])
 
-        Interaction.same?(recorded: first, stubbed: second).should be_true
+        expect(Interaction.same?(recorded: first, stubbed: second)).to be_true
       end
 
       it "considers two interactions != when the arguments are !=" do
         first = Interaction.new(:with, [Dev.new(:wrozka)])
         second = Interaction.new(:with, [Dev.new(:yundt)])
 
-        Interaction.same?(recorded: first, stubbed: second).should be_false
+        expect(Interaction.same?(recorded: first, stubbed: second)).to be_false
       end
     end
   end

data/spec/bogus/stubbing/multi_stubber_spec.rb

@@ -10,13 +10,13 @@ describe Bogus::MultiStubber do
   it "stubs all the given methods with any args returning the given value" do
     multi_stubber.stub_all(Object.new, foo: 1, bar: 2)
 
-    double.stubbed.should == [[:foo, [any_args], 1], [:bar, [any_args], 2]]
+    expect(double.stubbed).to eq([[:foo, [any_args], 1], [:bar, [any_args], 2]])
   end
 
   it "uses passed procs as the return value block" do
     multi_stubber.stub_all(Object.new, foo: proc{ 1 })
 
-    double.stubbed.should == [[:foo, [any_args], 1]]
+    expect(double.stubbed).to eq([[:foo, [any_args], 1]])
   end
 
   class FakeDouble

data/spec/bogus/stubbing/overwrites_methods_spec.rb

@@ -24,7 +24,7 @@ module Bogus
       end
 
       it "does not change the method signature" do
-        object.method(:greet).arity.should == 1
+        expect(object.method(:greet).arity).to eq(1)
       end
 
       it "does not change the method signature" do
@@ -36,14 +36,14 @@ module Bogus
       it "adds interaction recording to the overwritten object" do
         object.greet("John")
 
-        object.should Bogus.have_received.greet("John")
-        object.should_not Bogus.have_received.greet("Paul")
+        expect(object).to Bogus.have_received.greet("John")
+        expect(object).not_to Bogus.have_received.greet("Paul")
       end
 
       it "can reset the overwritten methods" do
         overwriter.reset(object)
 
-        object.greet("John").should == "Hello John"
+        expect(object.greet("John")).to eq("Hello John")
       end
 
       it "is imdepotent when overwriting" do
@@ -53,7 +53,7 @@ module Bogus
 
         overwriter.reset(object)
 
-        object.greet("John").should == "Hello John"
+        expect(object.greet("John")).to eq("Hello John")
       end
     end
 
@@ -75,7 +75,7 @@ module Bogus
       end
 
       it "can overwrite the non-existent methods" do
-        object.methods.should include(:greet)
+        expect(object.methods).to include(:greet)
       end
 
       it "can be reset back to the original state" do
@@ -84,7 +84,7 @@ module Bogus
 
         overwriter.reset(object)
 
-        object.greet.should == "the original return value"
+        expect(object.greet).to eq("the original return value")
       end
     end
 
@@ -94,7 +94,7 @@ module Bogus
       it "does nothing because fakes methods already work as we need" do
         overwriter.overwrite(fake, :foo_bar)
 
-        fake.should_not respond_to(:foo_bar)
+        expect(fake).not_to respond_to(:foo_bar)
       end
 
       it "does not reset fakes, because there is nothing to reset" do

data/spec/bogus/stubbing/record_interactions_spec.rb

@@ -11,16 +11,16 @@ describe Bogus::RecordInteractions do
   it "allows verifying that interactions happened" do
     sample.__record__(:foo, 1, 2, 3)
 
-    sample.__shadow__.has_received(:foo, [1,2,3]).should be_true
+    expect(sample.__shadow__.has_received(:foo, [1,2,3])).to be_true
   end
 
   it "allows verifying that interactions didn't happen" do
     sample.__record__(:bar)
 
-    sample.__shadow__.has_received(:foo, [1,2,3]).should be_false
+    expect(sample.__shadow__.has_received(:foo, [1,2,3])).to be_false
   end
 
   it "returns self from record by default" do
-    sample.__record__(:foo).should be_a_default_return_value
+    expect(sample.__record__(:foo)).to be_a_default_return_value
   end
 end

data/spec/bogus/stubbing/shadow_spec.rb

@@ -11,12 +11,12 @@ describe Bogus::Shadow do
       end
 
       it "returns the called methods" do
-        shadow.has_received(:foo, ["a", "b"]).should be_true
+        expect(shadow.has_received(:foo, ["a", "b"])).to be_true
       end
 
       it "does not return true for interactions that did not happen" do
-        shadow.has_received(:foo, ["a", "c"]).should be_false
-        shadow.has_received(:bar, ["a", "c"]).should be_false
+        expect(shadow.has_received(:foo, ["a", "c"])).to be_false
+        expect(shadow.has_received(:bar, ["a", "c"])).to be_false
       end
     end
   end
@@ -25,7 +25,7 @@ describe Bogus::Shadow do
     it "returns an unstubbed value" do
       return_value = shadow.run(:foo, "a", "b")
 
-      return_value.should be_a_default_return_value
+      expect(return_value).to be_a_default_return_value
     end
 
     include_examples "spying on shadows"
@@ -53,7 +53,7 @@ describe Bogus::Shadow do
     end
 
     it "returns the default value" do
-      shadow.run(:foo, ["a", "b"]).should be_a_default_return_value
+      expect(shadow.run(:foo, ["a", "b"])).to be_a_default_return_value
     end
 
     include_examples "spying on shadows"
@@ -67,21 +67,21 @@ describe Bogus::Shadow do
     end
 
     it "changes the default value returned from method" do
-      shadow.run(:foo, "b", "c").should == "default value"
+      expect(shadow.run(:foo, "b", "c")).to eq("default value")
     end
 
     it "overwrites the old specific stubbed values" do
-      shadow.run(:foo, "a", "b").should == "default value"
+      expect(shadow.run(:foo, "a", "b")).to eq("default value")
     end
 
     it "does not affect the new specific stubbed values" do
-      shadow.run(:foo, "a", "d").should == "new specific value"
+      expect(shadow.run(:foo, "a", "d")).to eq("new specific value")
     end
 
     it "allows spying on calls using any args" do
       shadow.run(:foo, "a", "c")
 
-      shadow.has_received(:foo, [Bogus::AnyArgs]).should be_true
+      expect(shadow.has_received(:foo, [Bogus::AnyArgs])).to be_true
     end
   end
 
@@ -91,19 +91,19 @@ describe Bogus::Shadow do
     end
 
     it "changes the return value for calls that match" do
-      shadow.run(:foo, "a", "c").should == "return value"
+      expect(shadow.run(:foo, "a", "c")).to eq("return value")
     end
 
     it "does not affect the return value for other calls" do
       shadow.stubs(:foo, "a", "b") { "specific value" }
 
-      shadow.run(:foo, "a", "b").should == "specific value"
+      expect(shadow.run(:foo, "a", "b")).to eq("specific value")
     end
 
     it "allows spying on calls using anything in args" do
       shadow.run(:foo, "a", "b")
 
-      shadow.has_received(:foo, [Bogus::Anything, "b"]).should be_true
+      expect(shadow.has_received(:foo, [Bogus::Anything, "b"])).to be_true
     end
   end
 
@@ -113,30 +113,30 @@ describe Bogus::Shadow do
     end
 
     it "returns the stubbed value" do
-      shadow.run(:foo, "a", "b").should == "stubbed value"
+      expect(shadow.run(:foo, "a", "b")).to eq("stubbed value")
     end
 
     it "returns the latest stubbed value" do
       shadow.stubs(:foo, "a", "b") { "stubbed twice" }
       shadow.stubs(:foo, "b", "c") { "different params" }
 
-      shadow.run(:foo, "a", "b").should == "stubbed twice"
-      shadow.run(:foo, "b", "c").should == "different params"
+      expect(shadow.run(:foo, "a", "b")).to eq("stubbed twice")
+      expect(shadow.run(:foo, "b", "c")).to eq("different params")
     end
 
     it "returns the default value for non-stubbed calls" do
-      shadow.run(:foo, "c", "d").should be_a_default_return_value
-      shadow.run(:bar).should be_a_default_return_value
+      expect(shadow.run(:foo, "c", "d")).to be_a_default_return_value
+      expect(shadow.run(:bar)).to be_a_default_return_value
     end
 
     it "does not contribute towards unsatisfied interactions" do
-      shadow.unsatisfied_interactions.should be_empty
+      expect(shadow.unsatisfied_interactions).to be_empty
     end
 
     it "adds required interaction when mocking over stubbing" do
       shadow.mocks(:foo, "a", "b") { "stubbed value" }
 
-      shadow.unsatisfied_interactions.should_not be_empty
+      expect(shadow.unsatisfied_interactions).not_to be_empty
     end
 
     include_examples "spying on shadows"
@@ -148,38 +148,38 @@ describe Bogus::Shadow do
     end
 
     it "returns the mocked value" do
-      shadow.run(:foo, "a", "b").should == "mocked value"
+      expect(shadow.run(:foo, "a", "b")).to eq("mocked value")
     end
 
     it "overwrites the stubbed value" do
       shadow.stubs(:foo, "a", "c") { "stubbed value" }
       shadow.mocks(:foo, "a", "c") { "mocked value" }
 
-      shadow.run(:foo, "a", "c").should == "mocked value"
+      expect(shadow.run(:foo, "a", "c")).to eq("mocked value")
     end
 
     it "is overwritten by stubbing" do
       shadow.mocks(:foo, "a", "c") { "mocked value" }
       shadow.stubs(:foo, "a", "c") { "stubbed value" }
 
-      shadow.run(:foo, "a", "c").should == "stubbed value"
+      expect(shadow.run(:foo, "a", "c")).to eq("stubbed value")
     end
 
     it "removes the required interaction when stubbing over mocking" do
       shadow.stubs(:foo, "a", "b") { "stubbed value" }
 
-      shadow.unsatisfied_interactions.should be_empty
+      expect(shadow.unsatisfied_interactions).to be_empty
     end
 
     it "returns the default value for non-stubbed calls" do
-      shadow.run(:foo, "a", "c").should be_a_default_return_value
+      expect(shadow.run(:foo, "a", "c")).to be_a_default_return_value
     end
 
     it "contributes towards unsatisfied interactions" do
       interactions = shadow.unsatisfied_interactions
-      interactions.should have(1).item
-      interactions.first.method.should == :foo
-      interactions.first.args.should == ["a", "b"]
+      expect(interactions).to have(1).item
+      expect(interactions.first.method).to eq(:foo)
+      expect(interactions.first.args).to eq(["a", "b"])
     end
 
     it "removes the staisfied expectations from unsatisfied interactions" do
@@ -187,7 +187,7 @@ describe Bogus::Shadow do
       shadow.run(:with_optional_args, 'a', Bogus::DefaultValue)
       shadow.run(:foo, "a", "b")
 
-      shadow.unsatisfied_interactions.should be_empty
+      expect(shadow.unsatisfied_interactions).to be_empty
     end
 
     include_examples "spying on shadows"

data/spec/bogus/stubbing/stubbing_existing_methods_on_fakes_spec.rb

@@ -0,0 +1,50 @@
+ require 'spec_helper'
+
+ describe "Stubbing existing methods on fakes" do
+   include Bogus::MockingDSL
+
+   before do
+     Bogus.clear
+   end
+
+   it "should be possible to stub to_s" do
+     foo = fake(:foo) { Samples::Foo }
+
+     stub(foo).to_s { "I'm a foo" }
+
+     expect(foo.to_s).to eq("I'm a foo")
+   end
+
+   it "should be possible to mock to_s" do
+     foo = fake(:foo) { Samples::Foo }
+
+     mock(foo).to_s { "I'm a foo" }
+
+     expect {
+       Bogus.after_each_test
+     }.to raise_exception(Bogus::NotAllExpectationsSatisfied)
+   end
+
+
+   it "should be possible to stub to_s on anonymous fake" do
+     foo = fake(to_s: "I'm a foo")
+
+     expect(foo.to_s).to eq("I'm a foo")
+   end
+
+   class Object
+     def sample_method_for_stubbing_existing_methods
+     end
+   end
+
+   class SampleForStubbingExistingMethods
+   end
+
+   it "should be possible to stub arbitrary methods that were defined on Object" do
+     foo = fake(:foo) { SampleForStubbingExistingMethods }
+
+     stub(foo).sample_method_for_stubbing_existing_methods { :bar }
+
+     expect(foo.sample_method_for_stubbing_existing_methods).to eq(:bar)
+   end
+ end