bogus 0.1.4 → 0.1.5

data/spec/bogus/configuration_spec.rb

@@ -8,10 +8,10 @@ describe Bogus::Configuration do
       c.search_modules << String
     end
 
-    Bogus.config.search_modules.should == [Object, String]
+    expect(Bogus.config.search_modules).to eq [Object, String]
   end
 
   it "defaults search_modules to [Object]" do
-    Bogus.config.search_modules.should == [Object]
+    expect(Bogus.config.search_modules).to eq [Object]
   end
 end

data/spec/bogus/contracts/adds_contract_verification_spec.rb

@@ -37,7 +37,7 @@ describe Bogus::AddsContractVerification do
     it "verifies the contract in after_suite" do
       syntax.run_after_suite
 
-      verifies_contracts.should have_received.verify(:some_fake)
+      expect(verifies_contracts).to have_received.verify(:some_fake)
     end
   end
 
@@ -72,14 +72,14 @@ describe Bogus::AddsContractVerification do
     it "overwrites described_class in before" do
       syntax.run_before
 
-      syntax.described_class.should == overwritten_class
+      expect(syntax.described_class).to eq overwritten_class
     end
 
     it "resets described_class in after" do
       syntax.run_before
       syntax.run_after
 
-      syntax.described_class.should == SomeClass
+      expect(syntax.described_class).to eq SomeClass
     end
 
     it_verifies_contract_after_suite
@@ -87,7 +87,7 @@ describe Bogus::AddsContractVerification do
     it "adds recording to described_class" do
       syntax.run_before
 
-      adds_recording.should have_received.add(:some_fake, SomeClass)
+      expect(adds_recording).to have_received.add(:some_fake, SomeClass)
     end
   end
 
@@ -104,14 +104,14 @@ describe Bogus::AddsContractVerification do
     it "does not overwrite described_class in before" do
       syntax.run_before
 
-      syntax.described_class.should == SomeClass
+      expect(syntax.described_class).to eq SomeClass
     end
 
     it "does not change described_class in after" do
       syntax.run_before
       syntax.run_after
 
-      syntax.described_class.should == SomeClass
+      expect(syntax.described_class).to eq SomeClass
     end
 
     it_verifies_contract_after_suite
@@ -119,7 +119,7 @@ describe Bogus::AddsContractVerification do
     it "adds recording to custom class" do
       syntax.run_before
 
-      adds_recording.should have_received.add(:some_fake, ClassToOverwrite)
+      expect(adds_recording).to have_received.add(:some_fake, ClassToOverwrite)
     end
   end
 
@@ -133,14 +133,14 @@ describe Bogus::AddsContractVerification do
     it "does not overwrite described_class in before" do
       syntax.run_before
 
-      syntax.described_class.should be_nil
+      expect(syntax.described_class).to be_nil
     end
 
     it "does not change described_class in after" do
       syntax.run_before
       syntax.run_after
 
-      syntax.described_class.should be_nil
+      expect(syntax.described_class).to be_nil
     end
 
     it_verifies_contract_after_suite
@@ -148,7 +148,7 @@ describe Bogus::AddsContractVerification do
     it "adds recording to class based on fake name" do
       syntax.run_before
 
-      adds_recording.should have_received.add(:some_fake, ClassGuessedFromFakeName)
+      expect(adds_recording).to have_received.add(:some_fake, ClassGuessedFromFakeName)
     end
   end
 end

data/spec/bogus/contracts/adds_recording_spec.rb

@@ -26,18 +26,18 @@ describe Bogus::AddsRecording do
   end
 
   it "creates the proxy" do
-    create_proxy_class.should have_received.call(:library, SampleModule::Library)
+    expect(create_proxy_class).to have_received.call(:library, SampleModule::Library)
   end
 
   it "swaps the classes" do
-    overwrites_classes.should have_received.overwrite('SampleModule::Library', Object)
+    expect(overwrites_classes).to have_received.overwrite('SampleModule::Library', Object)
   end
 
   it "records the overwritten class, so that it can be later restored" do
-    overwritten_classes.should have_received.add("SampleModule::Library", SampleModule::Library)
+    expect(overwritten_classes).to have_received.add("SampleModule::Library", SampleModule::Library)
   end
 
   it "returns the proxy class" do
-    adds_recording.add(:library, SampleModule::Library).should == Object
+    expect(adds_recording.add(:library, SampleModule::Library)).to eq Object
   end
 end

data/spec/bogus/contracts/interactions_repository_spec.rb

@@ -10,80 +10,80 @@ describe Bogus::InteractionsRepository do
   it "considers the interaction recorded if it was recorded previously" do
     interactions_repository.record(:foo, :bar, 1, 2, 3)
 
-    recorded?(:foo, :bar, 1, 2, 3).should be_true
+    expect(recorded?(:foo, :bar, 1, 2, 3)).to be_true
   end
 
   it "considers the interaction recorded if it returned the same value as passed block" do
     interactions_repository.record(:foo, :bar) { "a result" }
     interaction = Bogus::Interaction.new(:bar, []) { "a result" }
 
-    interactions_repository.recorded?(:foo, interaction).should be_true
+    expect(interactions_repository.recorded?(:foo, interaction)).to be_true
   end
 
   it "does not consider any interactions recorded prior to any recordings" do
-    recorded?(:foo, :bar, 1).should be_false
+    expect(recorded?(:foo, :bar, 1)).to be_false
   end
 
   it "does not consider the interaction recorded with a different fake name"  do
     interactions_repository.record(:baz, :bar, 1)
 
-    recorded?(:foo, :bar, 1).should be_false
+    expect(recorded?(:foo, :bar, 1)).to be_false
   end
 
   it "does not consider the interaction recorded with a different method name" do
     interactions_repository.record(:foo, :baz, 1)
 
-    recorded?(:foo, :bar, 1).should be_false
+    expect(recorded?(:foo, :bar, 1)).to be_false
   end
 
   it "does not consider the interaction recorded with different method arguments" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
-    recorded?(:foo, :bar, 1).should be_false
+    expect(recorded?(:foo, :bar, 1)).to be_false
   end
 
   it "returns a list of interactions for given fake" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
     interactions = interactions_repository.for_fake(:foo)
-    interactions.should have(1).item
-    interactions.first.method.should == :bar
-    interactions.first.args.should == [1, 2]
+    expect(interactions).to have(1).item
+    expect(interactions.first.method).to eq :bar
+    expect(interactions.first.args).to eq [1, 2]
   end
 
   it "ignores arguments if the checked interaction has any_args" do
     interactions_repository.record(:foo, :bar, 1)
 
-    recorded?(:foo, :bar, Bogus::AnyArgs).should be_true
+    expect(recorded?(:foo, :bar, Bogus::AnyArgs)).to be_true
   end
 
   it "takes method name into account when matching interaction with wildcard arguments" do
     interactions_repository.record(:foo, :baz, 1)
 
-    recorded?(:foo, :bar, Bogus::AnyArgs).should be_false
+    expect(recorded?(:foo, :bar, Bogus::AnyArgs)).to be_false
   end
 
   it "ignores arguments if the recorded interaction was recorded with wildcard argument" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
-    recorded?(:foo, :bar, 1, Bogus::Anything).should be_true
+    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be_true
   end
 
   it "takes other arguments into account when matching interactions with wildcards" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
-    recorded?(:foo, :bar, 2, Bogus::Anything).should be_false
+    expect(recorded?(:foo, :bar, 2, Bogus::Anything)).to be_false
   end
 
   it "ignores arguments if the checked interaction has any_args" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
-    recorded?(:foo, :bar, 1, Bogus::Anything).should be_true
+    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be_true
   end
 
   it "takes method name into account when matching interaction with wildcard arguments" do
     interactions_repository.record(:foo, :baz, 1, 2)
 
-    recorded?(:foo, :bar, 1, Bogus::Anything).should be_false
+    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be_false
   end
 end

data/spec/bogus/contracts/proxy_class_spec.rb

@@ -28,33 +28,33 @@ describe Bogus::ProxyClass do
   let(:interactions_repository) { FakeRepository.new }
 
   it "returns the proxy" do
-    proxy_class.new.checkout("Moby Dick", "Bob").should == :checkouted
+    expect(proxy_class.new.checkout("Moby Dick", "Bob")).to eq :checkouted
   end
 
   it "records interactions with created objects" do
     proxy_class.new.checkout("Moby Dick", "Bob")
 
-    interactions_repository.should have_recorded(:fake_name, :checkout, "Moby Dick", "Bob")
+    expect(interactions_repository).to have_recorded(:fake_name, :checkout, "Moby Dick", "Bob")
   end
 
   it "responds to every method that the original class responds to" do
-    proxy_class.should respond_to(:find_by_address)
+    expect(proxy_class).to respond_to(:find_by_address)
   end
 
   it "delegates interactions with the proxy class to wrapped class" do
-    proxy_class.find_by_address("some address").should == :the_library
+    expect(proxy_class.find_by_address("some address")).to eq :the_library
   end
 
   it "records interactions with the proxy class" do
     proxy_class.find_by_address("some address")
 
-    interactions_repository.should have_recorded(:fake_name, :find_by_address, "some address")
+    expect(interactions_repository).to have_recorded(:fake_name, :find_by_address, "some address")
   end
 
   it "records return values" do
     proxy_class.find_by_address("some address")
 
-    interactions_repository.return_value(:fake_name, :find_by_address, "some address").should == :the_library
+    expect(interactions_repository.return_value(:fake_name, :find_by_address, "some address")).to eq :the_library
   end
 
   it "re-raises exceptions" do
@@ -72,7 +72,7 @@ describe Bogus::ProxyClass do
   end
 
   it "allows accessing the constants defined on proxied class" do
-    proxy_class::SAMPLE_CONSTANT.should == "foo"
+    expect(proxy_class::SAMPLE_CONSTANT).to eq "foo"
   end
 
   class FakeRepository

data/spec/bogus/contracts/records_double_interactions_spec.rb

@@ -13,7 +13,7 @@ describe Bogus::RecordsDoubleInteractions do
 
     records_double_interactions.record(object, :method_name, [:foo, 1])
 
-    doubled_interactions.should have_received.record(:object_name, :method_name, :foo, 1)
+    expect(doubled_interactions).to have_received.record(:object_name, :method_name, :foo, 1)
   end
 
   it "does not record the interaction if object is not a fake" do

data/spec/bogus/contracts/verifies_contracts_spec.rb

@@ -37,9 +37,9 @@ describe Bogus::VerifiesContracts do
     verifies_contracts.verify(name)
     fail
   rescue Bogus::ContractNotFulfilled => contract_error
-    contract_error.fake_name.should == name
-    contract_error.missed_interactions.should == missed
-    contract_error.actual_interactions.should == real
+    expect(contract_error.fake_name).to eq name
+    expect(contract_error.missed_interactions).to eq missed
+    expect(contract_error.actual_interactions).to eq real
   end
 
   def interaction(method)

data/spec/bogus/fakes/base_class_identifier_spec.rb

@@ -45,7 +45,7 @@ module SampleForBaseIdentifier
         it "returns the same for is_a?(#{klass})" do
           expected = instance.is_a?(klass)
           actual = Bogus::BaseClassIdentifier.base_class?(copied_class, klass)
-          actual.should == expected
+          expect(actual).to eq expected
         end
       end
     end

data/spec/bogus/fakes/class_methods_spec.rb

@@ -22,18 +22,17 @@ module Bogus
     let(:class_methods) { ClassMethods.new(SampleClass) }
 
     it "lists the class methods excluding the ones added by Bogus" do
-      class_methods.all.should =~ [:bar, :hello]
+      expect(class_methods.all).to match_array([:bar, :hello])
     end
 
     it "returns the instance methods by name" do
-      class_methods.get(:bar).should ==
-        SampleClass.method(:bar)
+      expect(class_methods.get(:bar)).to eq SampleClass.method(:bar)
     end
 
     it "removes methods by name" do
       class_methods.remove(:hello)
 
-      SampleClass.should_not respond_to(:hello)
+      expect(SampleClass).to_not respond_to(:hello)
     end
 
     it "defines instance methods" do
@@ -43,7 +42,7 @@ module Bogus
       end
       EOF
 
-      SampleClass.greet("Joe").should == "Hello, Joe!"
+      expect(SampleClass.greet("Joe")).to eq "Hello, Joe!"
     end
   end
 end

data/spec/bogus/fakes/converts_name_to_class_spec.rb

@@ -15,19 +15,19 @@ describe Bogus::ConvertsNameToClass do
   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
+    expect(converts_name_to_class.convert(:foo_bar_baz)).to eq 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
+    expect(converts_name_to_class.convert(:foo_bar_baz)).to eq 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
+    expect(converts_name_to_class.convert(:bam)).to eq Bar::Bam
   end
 
   it "raises an error if it can't find the class" do

data/spec/bogus/fakes/copies_classes_spec.rb

@@ -20,33 +20,33 @@ describe Bogus::CopiesClasses do
 
   shared_examples_for 'the copied class' do
     it "copies methods with no arguments" do
-      subject.should respond_to(:foo)
+      expect(subject).to respond_to(:foo)
       subject.foo
     end
 
     it "copies methods with explicit arguments" do
-      subject.should respond_to(:bar)
+      expect(subject).to respond_to(:bar)
 
-      subject.method(:bar).arity.should == 1
+      expect(subject.method(:bar).arity).to eq 1
 
       subject.bar('hello')
     end
 
     it "copies methods with variable arguments" do
-      subject.should respond_to(:baz)
+      expect(subject).to respond_to(:baz)
 
       subject.baz('hello', 'foo', 'bar', 'baz')
     end
 
     it "copies methods with default arguments" do
-      subject.should respond_to(:bam)
+      expect(subject).to respond_to(:bam)
 
       subject.bam
       subject.bam(hello: 'world')
     end
 
     it "copies methods with block arguments" do
-      subject.should respond_to(:baa)
+      expect(subject).to respond_to(:baa)
 
       subject.baa('hello')
       subject.baa('hello') {}
@@ -66,7 +66,7 @@ describe Bogus::CopiesClasses do
     let(:klass) { FooWithInstanceMethods }
 
     it "does not overwrite nested constants" do
-      fake_class::CONST.should == "the const"
+      expect(fake_class::CONST).to eq "the const"
     end
   end
 
@@ -91,13 +91,13 @@ describe Bogus::CopiesClasses do
     it "adds a no-arg constructor" do
       instance = fake_class.__create__
 
-      instance.should respond_to(:foo)
+      expect(instance).to respond_to(:foo)
     end
 
     it "adds a constructor that allows passing the correct number of arguments" do
       instance = fake_class.new('hello')
 
-      instance.should respond_to(:foo)
+      expect(instance).to respond_to(:foo)
     end
   end
 
@@ -121,27 +121,31 @@ describe Bogus::CopiesClasses do
     let(:klass) { SomeModule::SomeClass }
 
     it "should copy the class name" do
-      fake.class.name.should == 'SomeModule::SomeClass'
+      expect(fake.class.name).to eq 'SomeModule::SomeClass'
     end
 
     it "should override kind_of?" do
-      fake.kind_of?(SomeModule::SomeClass).should be_true
+      expect(fake.kind_of?(SomeModule::SomeClass)).to be_true
     end
 
     it "should override instance_of?" do
-      fake.instance_of?(SomeModule::SomeClass).should be_true
+      expect(fake.instance_of?(SomeModule::SomeClass)).to be_true
     end
 
     it "should override is_a?" do
-      fake.is_a?(SomeModule::SomeClass).should be_true
+      expect(fake.is_a?(SomeModule::SomeClass)).to be_true
     end
 
     it "should include class name in the output of fake's class #to_s" do
-      fake.class.to_s.should include(klass.name)
+      expect(fake.class.to_s).to 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)
+      expect(fake.to_s).to include(klass.name)
+    end
+
+    it 'should override ===' do
+      expect(SomeModule::SomeClass === fake).to be_true
     end
   end
 
@@ -193,7 +197,7 @@ describe Bogus::CopiesClasses do
     let(:klass) { SomeModel }
 
     it "copies those methods" do
-      fake.should respond_to(:save)
+      expect(fake).to respond_to(:save)
     end
   end
 end