bogus 0.1.4 → 0.1.5

data/spec/bogus/fakes/creates_fakes_spec.rb

@@ -23,15 +23,15 @@ describe Bogus::CreatesFakes do
     end
 
     it "creates a new instance of copied class by default" do
-      creates_fakes.create(:foo).should == fake_instance
+      expect(creates_fakes.create(:foo)).to eq 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
+      expect(creates_fakes.create(:foo, as: :instance)).to eq 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
+      expect(creates_fakes.create(:foo, as: :class)).to eq fake_class
     end
 
     it "raises an error if the as mode is not known" do
@@ -48,13 +48,13 @@ describe Bogus::CreatesFakes do
     end
 
     it "uses the class provided" do
-      creates_fakes.create(:foo){Bar}.should == fake_instance
+      expect(creates_fakes.create(:foo){Bar}).to eq fake_instance
     end
 
     it "does not convert the class name" do
       creates_fakes.create(:foo) { Bar}
 
-      copies_classes.should_not have_received.convert
+      expect(copies_classes).to_not have_received.convert
     end
   end
 
@@ -68,7 +68,7 @@ describe Bogus::CreatesFakes do
 
       fake = creates_fakes.create(:role, as: :class) { [Foo, Bar] }
 
-      fake.should == :the_fake
+      expect(fake).to eq :the_fake
     end
   end
 end

data/spec/bogus/fakes/creates_fakes_with_stubbed_methods_spec.rb

@@ -5,12 +5,13 @@ module Bogus
     let(:creates_fakes) { FakeCreatorOfFakes.new }
     let(:fake_configuration) { stub }
     let(:responds_to_everything) { stub }
-    let(:multi_stubber) { stub(stub_all: :stubbed_object) }
+    let(:multi_stubber) { stub }
 
     let(:creates_anonymous_stubs) { isolate(CreatesFakesWithStubbedMethods) }
 
     before do
       stub(fake_configuration).include? { false }
+      stub(multi_stubber).stub_all { :stubbed_object }
     end
 
     context "given symbol as first parameter" do
@@ -21,11 +22,11 @@ module Bogus
       end
 
       it "creates fakes" do
-        creates_fakes.should have_created(:foo, {as: :class}, "something")
+        expect(creates_fakes).to have_created(:foo, {as: :class}, "something")
       end
 
       it "stubs all the given methods" do
-        multi_stubber.should have_received.stub_all(fake, bar: 1)
+        expect(multi_stubber).to have_received.stub_all(fake, bar: 1)
       end
     end
 
@@ -35,11 +36,11 @@ module Bogus
       end
 
       it "does not create fakes" do
-        creates_fakes.fakes.should == []
+        expect(creates_fakes.fakes).to eq []
       end
 
       it "stubs all the given methods" do
-        multi_stubber.should have_received.stub_all(responds_to_everything, bar: 1)
+        expect(multi_stubber).to have_received.stub_all(responds_to_everything, bar: 1)
       end
     end
 
@@ -51,11 +52,11 @@ module Bogus
       end
 
       it "creates fakes" do
-        creates_fakes.should have_created(:foo, {}, "something")
+        expect(creates_fakes).to have_created(:foo, {}, "something")
       end
 
       it "stubs all the given methods" do
-        multi_stubber.should have_received.stub_all(fake)
+        expect(multi_stubber).to have_received.stub_all(fake, {})
       end
     end
 
@@ -65,11 +66,11 @@ module Bogus
       end
 
       it "does not create fakes" do
-        creates_fakes.fakes.should == []
+        expect(creates_fakes.fakes).to eq []
       end
 
       it "stubs all the given methods" do
-        multi_stubber.should have_received.stub_all(responds_to_everything)
+        expect(multi_stubber).to have_received.stub_all(responds_to_everything, {})
       end
     end
 
@@ -86,14 +87,14 @@ module Bogus
       end
 
       it "uses the configuration to create fake" do
-        creates_fakes.fakes.should == [fake]
+        expect(creates_fakes.fakes).to eq [fake]
 
-        fake_configuration.should have_received.include?(:foo)
-        fake_configuration.should have_received.get(:foo)
+        expect(fake_configuration).to have_received.include?(:foo)
+        expect(fake_configuration).to have_received.get(:foo)
       end
 
       it "stubs the methods defined in configuration" do
-        multi_stubber.should have_received.stub_all(fake, xyz: "abc")
+        expect(multi_stubber).to have_received.stub_all(fake, xyz: "abc")
       end
     end
 
@@ -110,11 +111,11 @@ module Bogus
       end
 
       it "overrides the class block and fake options" do
-        creates_fakes.should have_created(:foo, {as: :instance}, "SomeOtherClass")
+        expect(creates_fakes).to have_created(:foo, {as: :instance}, "SomeOtherClass")
       end
 
       it "overrides the stubbed methods" do
-        multi_stubber.should have_received.stub_all(fake, a: "b", b: "d", c: "e")
+        expect(multi_stubber).to have_received.stub_all(fake, a: "b", b: "d", c: "e")
       end
     end
   end

data/spec/bogus/fakes/fake_ar_attributes_spec.rb

@@ -30,7 +30,7 @@ describe "Stubbing ActiveRecord::Base subclasses" do
   it "makes it possible to stub active record fields" do
     post = fake(:blog_post, name: "hello")
 
-    post.name.should == "hello"
+    expect(post.name).to eq "hello"
   end
 
   it "works only when enabled in configuration" do
@@ -48,7 +48,7 @@ describe "Stubbing ActiveRecord::Base subclasses" do
 
     post.author("hello")
 
-    post.should have_received.author("hello")
+    expect(post).to have_received.author("hello")
   end
 
   class ExampleForActiveRecordAttributes
@@ -61,7 +61,7 @@ describe "Stubbing ActiveRecord::Base subclasses" do
 
     fake.foo(1)
 
-    fake.should have_received.foo(1)
+    expect(fake).to have_received.foo(1)
   end
 
   after do

data/spec/bogus/fakes/fake_configuration_spec.rb

@@ -4,7 +4,7 @@ describe Bogus::FakeConfiguration do
   let(:config) { Bogus::FakeConfiguration.new }
 
   it "does not contain not configured fakes" do
-    config.include?(:foo).should be_false
+    expect(config.include?(:foo)).to be_false
   end
 
   def class_block(name)
@@ -26,8 +26,8 @@ describe Bogus::FakeConfiguration do
       end
     end
 
-    config.include?(:foo).should be_true
-    config.include?(:bar).should be_false
+    expect(config.include?(:foo)).to be_true
+    expect(config.include?(:bar)).to be_false
   end
 
   it "returns the configuration for a fake" do
@@ -37,9 +37,9 @@ describe Bogus::FakeConfiguration do
       end
     end
 
-    opts(:foo).should == {as: :class}
-    stubs(:foo).should == {bar: "the bar"}
-    class_block(:foo).call.should == Samples::Foo
+    expect(opts(:foo)).to eq ({ as: :class} )
+    expect(stubs(:foo)).to eq ({ bar: "the bar"} )
+    expect(class_block(:foo).call).to eq Samples::Foo
   end
 
   context "with no class" do
@@ -48,9 +48,9 @@ describe Bogus::FakeConfiguration do
         fake(:foo, as: :class) { bar "bar" }
       end
 
-      opts(:foo).should == {as: :class}
-      stubs(:foo).should == {bar: "bar"}
-      class_block(:foo).should be_nil
+      expect(opts(:foo)).to eq ({ as: :class} )
+      expect(stubs(:foo)).to eq ({ bar: "bar"} )
+      expect(class_block(:foo)).to be_nil
     end
   end
 
@@ -60,9 +60,9 @@ describe Bogus::FakeConfiguration do
         fake(:foo) { bar "bar" }
       end
 
-      opts(:foo).should == {}
-      stubs(:foo).should == {bar: "bar"}
-      class_block(:foo).should be_nil
+      expect(opts(:foo)).to eq ({ } )
+      expect(stubs(:foo)).to eq ({ bar: "bar"} )
+      expect(class_block(:foo)).to be_nil
     end
   end
 
@@ -72,7 +72,7 @@ describe Bogus::FakeConfiguration do
         fake(:foo) { bar {"bar"} }
       end
 
-      stubs(:foo)[:bar].call.should == "bar"
+      expect(stubs(:foo)[:bar].call).to eq "bar"
     end
 
     it "does not evaluate the blocks when getting, nor when setting" do
@@ -91,9 +91,9 @@ describe Bogus::FakeConfiguration do
         fake(:foo, as: :class)
       end
 
-      opts(:foo).should == {as: :class}
-      stubs(:foo).should == {}
-      class_block(:foo).should be_nil
+      expect(opts(:foo)).to eq ({ as: :class} )
+      expect(stubs(:foo)).to eq ({ } )
+      expect(class_block(:foo)).to be_nil
     end
   end
 end

data/spec/bogus/fakes/fake_registry_spec.rb

@@ -8,7 +8,7 @@ describe Bogus::FakeRegistry do
 
     fake_registry.store(:name, object)
 
-    fake_registry.name(object).should == :name
+    expect(fake_registry.name(object)).to eq :name
   end
 
   it "returns name based on object identity" do
@@ -19,6 +19,6 @@ describe Bogus::FakeRegistry do
 
     fake_registry.store(:object, object)
 
-    fake_registry.name(duplicate).should be_nil
+    expect(fake_registry.name(duplicate)).to be_nil
   end
 end

data/spec/bogus/fakes/fake_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Bogus::Fake do
   it 'has a class name' do
-    Bogus::Fake.name.should == "Bogus::Fake"
+    expect(Bogus::Fake.name).to eq "Bogus::Fake"
   end
 end
 

data/spec/bogus/fakes/fakes_classes_spec.rb

@@ -20,7 +20,7 @@ describe Bogus::FakesClasses do
   it "creates a fake named after the class" do
     fakes_classes.fake(Samples::WillBeOverwritten, foo: "bar")
 
-    creates_fakes_with_stubbed_methods.should have_created(:will_be_overwritten,
+    expect(creates_fakes_with_stubbed_methods).to have_created(:will_be_overwritten,
                                                            {as: :class, foo: "bar"}, Samples::WillBeOverwritten)
   end
 
@@ -29,18 +29,18 @@ describe Bogus::FakesClasses do
 
     fakes_classes.fake(Samples::WillBeOverwritten)
 
-    overwrites_classes.should have_received.overwrite("Samples::WillBeOverwritten", fake)
+    expect(overwrites_classes).to have_received.overwrite("Samples::WillBeOverwritten", fake)
   end
 
   it "stores the overwritten class so that it can be replaced back later" do
     fakes_classes.fake(Samples::WillBeOverwritten)
 
-    overwritten_classes.should have_received.add("Samples::WillBeOverwritten", Samples::WillBeOverwritten)
+    expect(overwritten_classes).to have_received.add("Samples::WillBeOverwritten", Samples::WillBeOverwritten)
   end
 
   it "uses the passed fake name if provided" do
     fakes_classes.fake(Samples::WillBeOverwritten, fake_name: :foo_bar)
 
-    creates_fakes_with_stubbed_methods.should have_created(:foo_bar, {as: :class}, Samples::WillBeOverwritten)
+    expect(creates_fakes_with_stubbed_methods).to have_created(:foo_bar, {as: :class}, Samples::WillBeOverwritten)
   end
 end

data/spec/bogus/fakes/faking_factories_spec.rb

@@ -24,7 +24,7 @@ describe "Faking Factories" do
 
     factory.create(2)
 
-    model_class.should have_received.new(1, 2)
+    expect(model_class).to have_received.new(1, 2)
   end
 
   class ExampleModel2
@@ -49,7 +49,7 @@ describe "Faking Factories" do
 
     model = model_class.new
 
-    model_class.should have_received.new
+    expect(model_class).to have_received.new
   end
 
   class ExampleModel4
@@ -65,7 +65,7 @@ describe "Faking Factories" do
 
     model.foo(1)
 
-    model.should have_received.foo(1)
+    expect(model).to have_received.foo(1)
   end
 
   module ExampleModel5
@@ -78,6 +78,6 @@ describe "Faking Factories" do
 
     model.foo(1)
 
-    model.should have_received.foo(1)
+    expect(model).to have_received.foo(1)
   end
 end

data/spec/bogus/fakes/frozen_fakes_spec.rb

@@ -15,7 +15,7 @@ describe "Frozen Fakes" do
       it "allows stubbing" do
         stub(object).foo(1) { 123 }
 
-        object.foo(1).should == 123
+        expect(object.foo(1)).to eq 123
       end
     end
 
@@ -23,7 +23,7 @@ describe "Frozen Fakes" do
       it "allows mocking" do
         mock(object).foo(1) { 123 }
 
-        object.foo(1).should == 123
+        expect(object.foo(1)).to eq 123
       end
 
       it "allows verifying expectations" do
@@ -39,8 +39,8 @@ describe "Frozen Fakes" do
       it "allows spying" do
         object.foo(1)
 
-        object.should have_received.foo(1)
-        object.should_not have_received.foo(2)
+        expect(object).to have_received.foo(1)
+        expect(object).to_not have_received.foo(2)
       end
     end
   end

data/spec/bogus/fakes/instance_methods_spec.rb

@@ -16,18 +16,18 @@ module Bogus
     let(:instance_methods) { InstanceMethods.new(SampleClass) }
 
     it "lists the instance methods" do
-      instance_methods.all.should =~ [:foo, :hello]
+      expect(instance_methods.all).to match_array([:foo, :hello])
     end
 
     it "returns the instance methods by name" do
-      instance_methods.get(:foo).should ==
-        SampleClass.instance_method(:foo)
+      expect(instance_methods.get(:foo)).to eq(
+        SampleClass.instance_method(:foo))
     end
 
     it "removes methods by name" do
       instance_methods.remove(:hello)
 
-      SampleClass.new.should_not respond_to(:hello)
+      expect(SampleClass.new).to_not respond_to(:hello)
     end
 
     it "defines instance methods" do
@@ -39,7 +39,7 @@ module Bogus
 
       instance = SampleClass.new
 
-      instance.greet("Joe").should == "Hello, Joe!"
+      expect(instance.greet("Joe")).to eq "Hello, Joe!"
     end
   end
 end

data/spec/bogus/fakes/makes_ducks_spec.rb

@@ -40,7 +40,7 @@ module Bogus
       it { should respond_to(:foo) }
 
       it "should have arity -3 for foo" do
-        duck.method(:foo).arity.should == -3
+        expect(duck.method(:foo).arity).to eq -3
       end
 
       it { should_not respond_to(:bar) }
@@ -76,11 +76,11 @@ module Bogus
       end
 
       it "copies class methods" do
-        duck.should respond_to(:enabled?)
+        expect(duck).to respond_to(:enabled?)
       end
 
       it "copies instance methods" do
-        duck_instance.should respond_to(:enabled?)
+        expect(duck_instance).to respond_to(:enabled?)
       end
     end
   end

data/spec/bogus/fakes/makes_substitute_methods_spec.rb

@@ -14,7 +14,7 @@ module Bogus
     it "makes a copy of the method with its params and adds recording" do
       copy = makes_substitute_methods.stringify(SampleForCopyingMethods.method(:foo))
 
-      copy.should == <<-EOF
+      expect(copy).to eq <<-EOF
       def foo(name, value = Bogus::DefaultValue, *rest, &block)
         __record__(:foo, name, value, *rest, &block)
       end

data/spec/bogus/fakes/overwriten_classes_spec.rb

@@ -9,7 +9,7 @@ describe Bogus::OverwrittenClasses do
     overwritten_classes.add("Foo::Bar", klass)
     overwritten_classes.add("Baz::Bam", klass)
 
-    overwritten_classes.classes.should == [["Foo::Bar", klass],
+    expect(overwritten_classes.classes).to eq [["Foo::Bar", klass],
                                            ["Baz::Bam", klass]]
   end
 
@@ -18,10 +18,10 @@ describe Bogus::OverwrittenClasses do
     overwritten_classes.add("Baz::Bam", klass)
     overwritten_classes.clear
 
-    overwritten_classes.classes.should == []
+    expect(overwritten_classes.classes).to eq []
   end
 
   it "returns an empty array with no classes" do
-    overwritten_classes.classes.should == []
+    expect(overwritten_classes.classes).to eq []
   end
 end