bogus 0.1.4 → 0.1.5

data/spec/bogus/fakes/overwrites_classes_spec.rb

@@ -14,13 +14,13 @@ describe Bogus::OverwritesClasses do
   it "overwrites nested classes" do
     overwrites_classes.overwrite('SampleOuterModule::SampleModule::SampleClass', new_class)
 
-    SampleOuterModule::SampleModule::SampleClass.should equal(new_class)
+    expect(SampleOuterModule::SampleModule::SampleClass).to equal(new_class)
   end
 
   it "overwrites top level classes" do
     overwrites_classes.overwrite('SampleOuterModule', new_class)
 
-    SampleOuterModule.should equal(new_class)
+    expect(SampleOuterModule).to equal(new_class)
   end
 end
 

data/spec/bogus/fakes/registers_created_fakes_spec.rb

@@ -16,18 +16,18 @@ describe Bogus::RegistersCreatedFakes do
   it "registers the fakes created by creates_fakes" do
     registers_created_fakes.create(:foo, as: :instance) { Object }
 
-    fake_registry.should have_received.store(:foo, :the_fake)
+    expect(fake_registry).to have_received.store(:foo, :the_fake)
   end
 
   it "tracks the created fakes for purposes of mock expectations" do
     registers_created_fakes.create(:foo, as: :instance) { Object }
 
-    double_tracker.should have_received.track(:the_fake)
+    expect(double_tracker).to have_received.track(:the_fake)
   end
 
   it "returns the created fake" do
     fake = registers_created_fakes.create(:foo, as: :instance) { Object }
 
-    fake.should == :the_fake
+    expect(fake).to eq :the_fake
   end
 end

data/spec/bogus/fakes/resets_overwritten_classes_spec.rb

@@ -16,11 +16,11 @@ describe Bogus::ResetsOverwrittenClasses do
   end
 
   it "overwrites back all of the overwritten classes" do
-    overwrites_classes.should have_received.overwrite('Foo', :foo)
-    overwrites_classes.should have_received.overwrite('Bar', :bar)
+    expect(overwrites_classes).to have_received.overwrite('Foo', :foo)
+    expect(overwrites_classes).to have_received.overwrite('Bar', :bar)
   end
 
   it "clears the overwritten classes" do
-    overwritten_classes.should have_received.clear
+    expect(overwritten_classes).to have_received.clear
   end
 end

data/spec/bogus/fakes/stubbing_new_method_on_fake_class_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "Stubbing .new on fake class" do
+  class ExampleForStubbingNew
+  end
+
+  include Bogus::MockingDSL
+
+  it "allows stubbing new on a class" do
+    fake_class = fake(ExampleForStubbingNew, as: :class)
+    stub(fake_class).new { :stubbed_value }
+
+    instance = fake_class.new
+
+    expect(instance).to eq(:stubbed_value)
+  end
+
+  it "returns fake instances when nothing is stubbed" do
+    fake_class = fake(ExampleForStubbingNew, as: :class)
+
+    instance = fake_class.new
+
+    expect(instance).to be_an_instance_of(fake_class)
+  end
+end

data/spec/bogus/mocking_dsl_spec.rb

@@ -30,25 +30,25 @@ describe Bogus::MockingDSL do
     it "allows stubbing the existing methods" do
       Stubber.stub(baz).foo("bar") { :return_value }
 
-      baz.foo("bar").should == :return_value
+      expect(baz.foo("bar")).to eq :return_value
     end
 
     it "can stub method with any parameters" do
       Stubber.stub(baz).foo(Stubber.any_args) { :default_value }
       Stubber.stub(baz).foo("bar") { :foo_value }
 
-      baz.foo("a").should == :default_value
-      baz.foo("b").should == :default_value
-      baz.foo("bar").should == :foo_value
+      expect(baz.foo("a")).to eq :default_value
+      expect(baz.foo("b")).to eq :default_value
+      expect(baz.foo("bar")).to eq :foo_value
     end
 
     it "can stub method with some wildcard parameters" do
       Stubber.stub(baz).hello(Stubber.any_args) { :default_value }
       Stubber.stub(baz).hello("welcome", Stubber.anything) { :greeting_value }
 
-      baz.hello("hello", "adam").should == :default_value
-      baz.hello("welcome", "adam").should == :greeting_value
-      baz.hello("welcome", "rudy").should == :greeting_value
+      expect(baz.hello("hello", "adam")).to eq :default_value
+      expect(baz.hello("welcome", "adam")).to eq :greeting_value
+      expect(baz.hello("welcome", "rudy")).to eq :greeting_value
     end
 
     it "does not allow stubbing non-existent methods" do
@@ -63,7 +63,7 @@ describe Bogus::MockingDSL do
 
       Bogus.after_each_test
 
-      ExampleFoo.bar("John").should == "Hello John"
+      expect(ExampleFoo.bar("John")).to eq "Hello John"
     end
   end
 
@@ -74,25 +74,25 @@ describe Bogus::MockingDSL do
       it "allows verifying that fakes have correct interfaces" do
         the_fake.foo("test")
 
-        the_fake.should Stubber.have_received.foo("test")
+        expect(the_fake).to Stubber.have_received.foo("test")
       end
 
       it "does not allow verifying on non-existent methods" do
         expect {
-          the_fake.should Stubber.have_received.bar("test")
+          expect(the_fake).to Stubber.have_received.bar("test")
         }.to raise_error(NameError)
       end
 
       it "does not allow verifying on methods with a wrong argument count" do
         expect {
-          the_fake.should Stubber.have_received.foo("test", "test 2")
+          expect(the_fake).to Stubber.have_received.foo("test", "test 2")
         }.to raise_error(ArgumentError)
       end
 
       it "allows spying on methods with optional parameters" do
         the_fake.with_optional_args(123)
 
-        the_fake.should Stubber.have_received.with_optional_args(123)
+        expect(the_fake).to Stubber.have_received.with_optional_args(123)
       end
     end
 
@@ -102,16 +102,16 @@ describe Bogus::MockingDSL do
 
       object.foo('test')
 
-      object.should Stubber.have_received.foo("test")
+      expect(object).to Stubber.have_received.foo("test")
     end
 
     it "allows spying on methods with optional parameters" do
       object = ExampleFoo.new
       Stubber.stub(object).with_optional_args(123) { 999 }
 
-      object.with_optional_args(123).should == 999
+      expect(object.with_optional_args(123)).to eq 999
 
-      object.should Stubber.have_received.with_optional_args(123)
+      expect(object).to Stubber.have_received.with_optional_args(123)
     end
 
     class ClassWithMatches
@@ -124,7 +124,7 @@ describe Bogus::MockingDSL do
 
       fake.matches?("foo")
 
-      fake.should Bogus.have_received.matches?("foo")
+      expect(fake).to Bogus.have_received.matches?("foo")
     end
 
     class PassesSelfToCollaborator
@@ -141,7 +141,7 @@ describe Bogus::MockingDSL do
 
       object.hello(fake)
 
-      fake.should Bogus.have_received.foo(object)
+      expect(fake).to Bogus.have_received.foo(object)
     end
   end
 
@@ -157,7 +157,7 @@ describe Bogus::MockingDSL do
       it "allows mocking on methods with optional parameters" do
         Mocker.mock(baz).with_optional_args(1) { :return }
 
-        baz.with_optional_args(1).should == :return
+        expect(baz.with_optional_args(1)).to eq :return
 
         expect { Bogus.after_each_test }.not_to raise_error
       end
@@ -165,7 +165,7 @@ describe Bogus::MockingDSL do
       it "allows mocking with anything" do
         Mocker.mock(baz).hello(1, Bogus::Anything) { :return }
 
-        baz.hello(1, 2).should == :return
+        expect(baz.hello(1, 2)).to eq :return
 
         expect { Bogus.after_each_test }.not_to raise_error
       end
@@ -173,7 +173,7 @@ describe Bogus::MockingDSL do
       it "allows mocking the existing methods" do
         Mocker.mock(baz).foo("bar") { :return_value }
 
-        baz.foo("bar").should == :return_value
+        expect(baz.foo("bar")).to eq :return_value
 
         expect { Bogus.after_each_test }.not_to raise_error
       end
@@ -246,7 +246,7 @@ describe Bogus::MockingDSL do
 
       stub(greeter).greet("Jake") { "Hello Jake" }
 
-      greeter.greet("Jake").should == "Hello Jake"
+      expect(greeter.greet("Jake")).to eq "Hello Jake"
     end
 
     it "creates objects that can be mocked" do
@@ -254,13 +254,13 @@ describe Bogus::MockingDSL do
 
       mock(greeter).greet("Jake") { "Hello Jake" }
 
-      greeter.greet("Jake").should == "Hello Jake"
+      expect(greeter.greet("Jake")).to eq "Hello Jake"
     end
 
     it "creates objects with some methods stubbed by default" do
       greeter = fake(greet: "Hello Jake")
 
-      greeter.greet("Jake").should == "Hello Jake"
+      expect(greeter.greet("Jake")).to eq "Hello Jake"
     end
 
     it "creates objects that can be spied upon" do
@@ -268,8 +268,8 @@ describe Bogus::MockingDSL do
 
       greeter.greet("Jake")
 
-      greeter.should have_received.greet("Jake")
-      greeter.should_not have_received.greet("Bob")
+      expect(greeter).to have_received.greet("Jake")
+      expect(greeter).to_not have_received.greet("Bob")
     end
 
     it "verifies mock expectations set on anonymous fakes" do
@@ -307,15 +307,15 @@ describe Bogus::MockingDSL do
     it "returns configured fakes" do
       the_fake = Stubber.fake(:globally_configured_fake)
 
-      the_fake.foo('a').should == "foo"
-      the_fake.bar('a', 'b').should == "bar"
+      expect(the_fake.foo('a')).to eq "foo"
+      expect(the_fake.bar('a', 'b')).to eq "bar"
     end
 
     it "allows overwriting stubbed methods" do
       the_fake = Stubber.fake(:globally_configured_fake, bar: "baz")
 
-      the_fake.foo('a').should == "foo"
-      the_fake.bar('a', 'b').should == "baz"
+      expect(the_fake.foo('a')).to eq "foo"
+      expect(the_fake.bar('a', 'b')).to eq "baz"
     end
 
     it "evaluates the block passed to method in configuration when method is called" do
@@ -340,8 +340,8 @@ describe Bogus::MockingDSL do
     it "replaces the class for the duration of the test" do
       Stubber.fake_class(ThisClassWillBeReplaced, hello: "replaced!")
 
-      ThisClassWillBeReplaced.hello("foo").should == "replaced!"
-      ThisClassWillBeReplaced.should_not equal(TheOriginalClass)
+      expect(ThisClassWillBeReplaced.hello("foo")).to eq "replaced!"
+      expect(ThisClassWillBeReplaced).to_not equal(TheOriginalClass)
     end
 
     it "makes it possible to spy on classes" do
@@ -349,15 +349,15 @@ describe Bogus::MockingDSL do
 
       ThisClassWillBeReplaced.hello("foo")
 
-      ThisClassWillBeReplaced.should Bogus.have_received.hello("foo")
-      ThisClassWillBeReplaced.should_not Bogus.have_received.hello("bar")
+      expect(ThisClassWillBeReplaced).to Bogus.have_received.hello("foo")
+      expect(ThisClassWillBeReplaced).to_not Bogus.have_received.hello("bar")
     end
 
     it "restores the class after the test has finished" do
       Stubber.fake_class(ThisClassWillBeReplaced)
       Bogus.reset_overwritten_classes
 
-      ThisClassWillBeReplaced.should equal(TheOriginalClass)
+      expect(ThisClassWillBeReplaced).to equal(TheOriginalClass)
     end
   end
 
@@ -385,7 +385,7 @@ describe Bogus::MockingDSL do
     end
 
     it "passes when all the mocked interactions were executed" do
-      sample.greet("Welcome").should == "Welcome, John!"
+      expect(sample.greet("Welcome")).to eq "Welcome, John!"
 
       Bogus.after_each_test
 
@@ -395,7 +395,7 @@ describe Bogus::MockingDSL do
     end
 
     it "fails when contracts are fullfilled" do
-      sample.greet("Hello").should == "Hello, John!"
+      expect(sample.greet("Hello")).to eq "Hello, John!"
 
       Bogus.after_each_test
 

data/spec/bogus/ruby_2_1_support_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+if RUBY_VERSION >= '2.1'
+  describe "Ruby 2.1 required keyword arguments" do
+    class ExampleForRequiredKeywordArgs
+      eval "def foo(x:); end"
+      eval "def bar(x:, **rest); end"
+    end
+
+    include Bogus::MockingDSL
+
+    context "with regular objects" do
+      subject { ExampleForRequiredKeywordArgs.new }
+
+      it "does not allow calling the method without all required arguments" do
+        stub(subject).foo(any_args) { :hello }
+
+        expect{ subject.foo }.to raise_error(ArgumentError)
+      end
+
+      include_examples "stubbing methods with keyword arguments"
+      include_examples "stubbing methods with double splat"
+    end
+
+    context "with fakes" do
+      subject { fake(:example_for_required_keyword_args) }
+
+      it "allows spying without stubbing" do
+        subject.foo(x: "hello")
+
+        expect(subject).to have_received.foo(x: "hello")
+      end
+
+      include_examples "stubbing methods with keyword arguments"
+      include_examples "stubbing methods with double splat"
+    end
+  end
+end

data/spec/bogus/ruby_2_support_spec.rb

@@ -3,78 +3,22 @@ require 'spec_helper'
 if RUBY_VERSION >= '2.0'
   describe "Ruby 2.0 keyword arguments" do
     class ExampleForKeywordArgs
-      eval "def foo(x: raise, y: 1); end"
+      eval "def foo(x: 1); end"
       eval "def bar(x: 1, **rest); end"
     end
 
     include Bogus::MockingDSL
 
-    shared_examples_for "stubbing methods with keyword arguments" do
-      it "can spy on stubbed methods" do
-        stub(subject).foo(any_args)
-
-        subject.foo(x: "test")
-
-        subject.should have_received.foo(x: "test")
-        subject.should_not have_received.foo(x: "baz")
-      end
-
-      it "can mock methods with keyword arguments" do
-        mock(subject).foo(x: 1) { :return }
-
-        subject.foo(x: 1).should == :return
-
-        expect { Bogus.after_each_test }.not_to raise_error
-      end
-
-      it "can stub methods with keyword arguments" do
-        stub(subject).foo(x: "bar") { :return_value }
-
-        subject.foo(x: "bar").should == :return_value
-      end
-
-      it "raises on error on unknown keyword" do
-        expect {
-          stub(subject).foo(x: "bar", baz: "baz")
-        }.to raise_error(ArgumentError)
-      end
-
-      it "does not overwrite the method signature" do
-        stub(subject).foo(x: 1)
-
-        expect {
-          subject.foo(bar: 1)
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    shared_examples_for "stubbing methods with double splat" do
-      it "can spy on stubbed methods" do
-        stub(subject).bar(any_args)
-
-        subject.bar(x: "test", z: "spec")
-
-        subject.should have_received.bar(x: "test", z: "spec")
-        subject.should_not have_received.bar(y: "baz")
-      end
-
-      it "can mock methods with keyword arguments" do
-        mock(subject).bar(x: 1, z: 2) { :return }
-
-        subject.bar(x: 1, z: 2).should == :return
+    context "with regular objects" do
+      subject { ExampleForKeywordArgs.new }
 
-        expect { Bogus.after_each_test }.not_to raise_error
-      end
+      it "allows calling the method without the optional keyword args" do
+        stub(subject).foo(any_args)
 
-      it "can stub methods with keyword arguments" do
-        stub(subject).bar(x: "bar", z: "bar") { :return_value }
+        subject.foo
 
-        subject.bar(x: "bar", z: "bar").should == :return_value
+        expect(subject).to have_received.foo
       end
-    end
-
-    context "with regular objects" do
-      subject { ExampleForKeywordArgs.new }
 
       include_examples "stubbing methods with keyword arguments"
       include_examples "stubbing methods with double splat"
@@ -86,7 +30,13 @@ if RUBY_VERSION >= '2.0'
       it "allows spying without stubbing" do
         subject.foo(x: "test")
 
-        subject.should have_received.foo(x: "test")
+        expect(subject).to have_received.foo(x: "test")
+      end
+
+      it "allows calling the method without the optional keyword args" do
+        subject.foo
+
+        expect(subject).to have_received.foo
       end
 
       include_examples "stubbing methods with keyword arguments"