puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/pops/binder/bindings_checker_spec.rb

@@ -79,77 +79,77 @@ describe 'The bindings checker' do
 
   it 'should complain about missing producer and type' do
     validate(binding())
-    acceptor.should have_issue(Issues::MISSING_PRODUCER)
-    acceptor.should have_issue(Issues::MISSING_TYPE)
+    expect(acceptor).to have_issue(Issues::MISSING_PRODUCER)
+    expect(acceptor).to have_issue(Issues::MISSING_TYPE)
   end
 
   context 'when checking array multibinding' do
     it 'should complain about non array producers' do
       validate(bad_array_multibinding())
-      acceptor.should have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
+      expect(acceptor).to have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
     end
   end
 
   context 'when checking hash multibinding' do
     it 'should complain about non hash producers' do
       validate(bad_hash_multibinding())
-      acceptor.should have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
+      expect(acceptor).to have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
     end
   end
 
   context 'when checking bindings' do
     it 'should not accept zero bindings' do
       validate(bindings())
-      acceptor.should have_issue(Issues::MISSING_BINDINGS)
+      expect(acceptor).to have_issue(Issues::MISSING_BINDINGS)
     end
 
     it 'should accept non-zero bindings' do
       validate(bindings(ok_binding))
-      acceptor.errors_or_warnings?.should() == false
+      expect(acceptor.errors_or_warnings?).to eq(false)
     end
 
     it 'should check contained bindings' do
       validate(bindings(bad_array_multibinding()))
-      acceptor.should have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
+      expect(acceptor).to have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
     end
   end
 
   context 'when checking named bindings' do
     it 'should accept named bindings' do
       validate(named_bindings('garfield', ok_binding))
-      acceptor.errors_or_warnings?.should() == false
+      expect(acceptor.errors_or_warnings?).to eq(false)
     end
 
     it 'should not accept unnamed bindings' do
       validate(named_bindings(nil, ok_binding))
-      acceptor.should have_issue(Issues::MISSING_BINDINGS_NAME)
+      expect(acceptor).to have_issue(Issues::MISSING_BINDINGS_NAME)
     end
 
     it 'should do generic bindings check' do
       validate(named_bindings('garfield'))
-      acceptor.should have_issue(Issues::MISSING_BINDINGS)
+      expect(acceptor).to have_issue(Issues::MISSING_BINDINGS)
     end
   end
 
   context 'when checking layered bindings' do
     it 'should not accept zero layers' do
       validate(layered_bindings())
-      acceptor.should have_issue(Issues::MISSING_LAYERS)
+      expect(acceptor).to have_issue(Issues::MISSING_LAYERS)
     end
 
     it 'should accept non-zero layers' do
       validate(layered_bindings(layer('foo', named_bindings('bar', ok_binding))))
-      acceptor.errors_or_warnings?.should() == false
+      expect(acceptor.errors_or_warnings?).to eq(false)
     end
 
     it 'should not accept unnamed layers' do
       validate(layered_bindings(layer(nil, named_bindings('bar', ok_binding))))
-      acceptor.should have_issue(Issues::MISSING_LAYER_NAME)
+      expect(acceptor).to have_issue(Issues::MISSING_LAYER_NAME)
     end
 
     it 'should accept layers without bindings' do
       validate(layered_bindings(layer('foo')))
-      acceptor.should_not have_issue(Issues::MISSING_BINDINGS_IN_LAYER)
+      expect(acceptor).not_to have_issue(Issues::MISSING_BINDINGS_IN_LAYER)
     end
   end
 end

data/spec/unit/pops/binder/bindings_composer_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet_spec/pops'
+require 'puppet/plugins'
 
 describe 'BinderComposer' do
   include PuppetSpec::Pops
@@ -18,10 +19,6 @@ describe 'BinderComposer' do
   let(:parser)      { Puppet::Pops::Parser::Parser.new() }
   let(:factory)     { Puppet::Pops::Binder::BindingsFactory }
 
-  before(:each) do
-    Puppet[:binder] = true
-  end
-
   it 'should load default config if no config file exists' do
     diagnostics = diag
     composer = Puppet::Pops::Binder::BindingsComposer.new()
@@ -35,10 +32,11 @@ describe 'BinderComposer' do
       Puppet.settings[:confdir] = config_directory
       Puppet.settings[:libdir] = File.join(config_directory, 'lib')
 
-      Puppet.override(:environments => Puppet::Environments::Static.new(Puppet::Node::Environment.create(:production, [File.join(config_directory, 'modules')]))) do
+      environments = Puppet::Environments::Static.new(Puppet::Node::Environment.create(:production, [File.join(config_directory, 'modules')]))
+      Puppet.override(:environments => environments, :current_environment => environments.get('production')) do
         # this ensure the binder is active at the right time
         # (issues with getting a /dev/null path for "confdir" / "libdir")
-        raise "Binder not active" unless scope.compiler.is_binder_active?
+        raise "Binder not active" unless scope.compiler.activate_binder
 
         diagnostics = diag
         composer = Puppet::Pops::Binder::BindingsComposer.new()

data/spec/unit/pops/binder/bindings_validator_factory_spec.rb

@@ -5,14 +5,14 @@ describe 'The bindings validator factory' do
   let(:factory) {  Puppet::Pops::Binder::BindingsValidatorFactory.new() }
 
   it 'should instantiate a BindingsValidatorFactory' do
-    factory.class.should == Puppet::Pops::Binder::BindingsValidatorFactory
+    expect(factory.class).to eq(Puppet::Pops::Binder::BindingsValidatorFactory)
   end
 
   it 'should produce label_provider of class BindingsLabelProvider' do
-    factory.label_provider.class.should == Puppet::Pops::Binder::BindingsLabelProvider
+    expect(factory.label_provider.class).to eq(Puppet::Pops::Binder::BindingsLabelProvider)
   end
 
   it 'should produce validator of class BindingsChecker' do
-    factory.validator(Puppet::Pops::Validation::Acceptor.new()).class.should == Puppet::Pops::Binder::BindingsChecker
+    expect(factory.validator(Puppet::Pops::Validation::Acceptor.new()).class).to eq(Puppet::Pops::Binder::BindingsChecker)
   end
 end

data/spec/unit/pops/binder/config/binder_config_spec.rb

@@ -30,6 +30,13 @@ describe 'BinderConfig' do
     expect(config.layering_config[1]['exclude']).to be == 'module:/bad::test/'
   end
 
+  it 'should correctly set values to default if not defined in bunder_config.yml)' do
+    Puppet::Pops::Binder::Config::BinderConfig.any_instance.stubs(:confdir).returns(my_fixture("/nolayer/"))
+    config = Puppet::Pops::Binder::Config::BinderConfig.new(diag)
+    expect(acceptor.errors?()).to be == false
+    expect(config.layering_config[0]['name']).to    be == 'site'
+  end
+
   # TODO: test error conditions (see BinderConfigChecker for what to test)
 
-end
+end

data/spec/unit/pops/binder/injector_spec.rb

@@ -124,29 +124,29 @@ describe 'Injector' do
     end
 
     it "should be possible to reference the TypeCalculator" do
-      injector(lbinder).type_calculator.is_a?(Puppet::Pops::Types::TypeCalculator).should == true
+      expect(injector(lbinder).type_calculator.is_a?(Puppet::Pops::Types::TypeCalculator)).to eq(true)
     end
 
     it "should be possible to reference the KeyFactory" do
-      injector(lbinder).key_factory.is_a?(Puppet::Pops::Binder::KeyFactory).should == true
+      expect(injector(lbinder).key_factory.is_a?(Puppet::Pops::Binder::KeyFactory)).to eq(true)
     end
 
     it "can be created using a model" do
       bindings.bind.name('a_string').to('42')
       injector = Puppet::Pops::Binder::Injector.create_from_model(layered_bindings)
-      injector.lookup(scope, 'a_string').should == '42'
+      expect(injector.lookup(scope, 'a_string')).to eq('42')
     end
 
     it 'can be created using a block' do
       injector = Puppet::Pops::Binder::Injector.create('test') do
         bind.name('a_string').to('42')
       end
-      injector.lookup(scope, 'a_string').should == '42'
+      expect(injector.lookup(scope, 'a_string')).to eq('42')
     end
 
     it 'can be created using a hash' do
       injector = Puppet::Pops::Binder::Injector.create_from_hash('test', 'a_string' => '42')
-      injector.lookup(scope, 'a_string').should == '42'
+      expect(injector.lookup(scope, 'a_string')).to eq('42')
     end
 
     it 'can be created using an overriding injector with block' do
@@ -156,46 +156,46 @@ describe 'Injector' do
       injector2 = injector.override('override') do
         bind.name('a_string').to('43')
       end
-      injector.lookup(scope, 'a_string').should == '42'
-      injector2.lookup(scope, 'a_string').should == '43'
+      expect(injector.lookup(scope, 'a_string')).to eq('42')
+      expect(injector2.lookup(scope, 'a_string')).to eq('43')
     end
 
     it 'can be created using an overriding injector with hash' do
       injector = Puppet::Pops::Binder::Injector.create_from_hash('test', 'a_string' => '42')
       injector2 = injector.override_with_hash('override', 'a_string' => '43')
-      injector.lookup(scope, 'a_string').should == '42'
-      injector2.lookup(scope, 'a_string').should == '43'
+      expect(injector.lookup(scope, 'a_string')).to eq('42')
+      expect(injector2.lookup(scope, 'a_string')).to eq('43')
     end
 
     it "can be created using an overriding injector with a model" do
       injector = Puppet::Pops::Binder::Injector.create_from_hash('test', 'a_string' => '42')
       bindings.bind.name('a_string').to('43')
       injector2 = injector.override_with_model(layered_bindings)
-      injector.lookup(scope, 'a_string').should == '42'
-      injector2.lookup(scope, 'a_string').should == '43'
+      expect(injector.lookup(scope, 'a_string')).to eq('42')
+      expect(injector2.lookup(scope, 'a_string')).to eq('43')
     end
   end
 
   context "When looking up objects" do
     it 'lookup(scope, name) finds bound object of type Data with given name' do
       bindings.bind().name('a_string').to('42')
-      injector(lbinder).lookup(scope, 'a_string').should == '42'
+      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('42')
     end
 
     context 'a block transforming the result can be given' do
       it 'that transform a found value given scope and value' do
         bindings.bind().name('a_string').to('42')
-        injector(lbinder).lookup(scope, 'a_string') {|zcope, val| val + '42' }.should == '4242'
+        expect(injector(lbinder).lookup(scope, 'a_string') {|zcope, val| val + '42' }).to eq('4242')
       end
 
       it 'that transform a found value given only value' do
         bindings.bind().name('a_string').to('42')
-        injector(lbinder).lookup(scope, 'a_string') {|val| val + '42' }.should == '4242'
+        expect(injector(lbinder).lookup(scope, 'a_string') {|val| val + '42' }).to eq('4242')
       end
 
       it 'that produces a default value when entry is missing' do
         bindings.bind().name('a_string').to('42')
-        injector(lbinder).lookup(scope, 'a_non_existing_string') {|val| val ? (raise Error, "Should not happen") : '4242' }.should == '4242'
+        expect(injector(lbinder).lookup(scope, 'a_non_existing_string') {|val| val ? (raise Error, "Should not happen") : '4242' }).to eq('4242')
       end
     end
 
@@ -203,8 +203,8 @@ describe 'Injector' do
       it "assisted inject kicks in for classes with zero args constructor" do
         duck_type = type_factory.ruby(InjectorSpecModule::Daffy)
         injector = injector(lbinder)
-        injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::Daffy).should == true
-        injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::Daffy).should == true
+        expect(injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::Daffy)).to eq(true)
+        expect(injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::Daffy)).to eq(true)
       end
 
       it "assisted inject produces same instance on lookup but not on lookup producer" do
@@ -212,11 +212,11 @@ describe 'Injector' do
         injector = injector(lbinder)
         d1 = injector.lookup(scope, duck_type)
         d2 = injector.lookup(scope, duck_type)
-        d1.equal?(d2).should == true
+        expect(d1.equal?(d2)).to eq(true)
 
         d1 = injector.lookup_producer(scope, duck_type).produce(scope)
         d2 = injector.lookup_producer(scope, duck_type).produce(scope)
-        d1.equal?(d2).should == false
+        expect(d1.equal?(d2)).to eq(false)
       end
 
       it "assisted inject kicks in for classes with a class inject method" do
@@ -224,22 +224,22 @@ describe 'Injector' do
         injector = injector(lbinder)
         # Do not pass any arguments, the ScroogeMcDuck :inject method should pick 1 by default
         # This tests zero args passed
-        injector.lookup(scope, duck_type).fortune.should == 1
-        injector.lookup_producer(scope, duck_type).produce(scope).fortune.should == 1
+        expect(injector.lookup(scope, duck_type).fortune).to eq(1)
+        expect(injector.lookup_producer(scope, duck_type).produce(scope).fortune).to eq(1)
       end
 
       it "assisted inject selects the inject method if it exists over a zero args constructor" do
         injector = injector(lbinder)
         duck_type = type_factory.ruby(InjectorSpecModule::AngryDuck)
-        injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::Donald).should == true
-        injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::Donald).should == true
+        expect(injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::Donald)).to eq(true)
+        expect(injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::Donald)).to eq(true)
       end
 
       it "assisted inject selects the zero args constructor if injector is from a superclass" do
         injector = injector(lbinder)
         duck_type = type_factory.ruby(InjectorSpecModule::ArneAnka)
-        injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::ArneAnka).should == true
-        injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::ArneAnka).should == true
+        expect(injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::ArneAnka)).to eq(true)
+        expect(injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::ArneAnka)).to eq(true)
       end
     end
 
@@ -254,7 +254,7 @@ describe 'Injector' do
         higher_layer =  factory.named_layer('higher-layer', bindings2.model)
 
         injector = injector(binder.new(factory.layered_bindings(higher_layer, lower_layer)))
-        injector.lookup(scope,'a_string').should == 'good stuff'
+        expect(injector.lookup(scope,'a_string')).to eq('good stuff')
       end
 
       it "a higher layer may not shadow a lower layer binding that is final" do
@@ -283,12 +283,12 @@ describe 'Injector' do
         bindings.bind().name('a_hash').to({'a'=>1,'b'=>2,'c'=>3})
 
         injector = injector(lbinder)
-        injector.lookup(scope,'a_string').should  == '42'
-        injector.lookup(scope,'an_int').should    == 43
-        injector.lookup(scope,'a_float').should   == 3.14
-        injector.lookup(scope,'a_boolean').should == true
-        injector.lookup(scope,'an_array').should  == [1,2,3]
-        injector.lookup(scope,'a_hash').should    == {'a'=>1,'b'=>2,'c'=>3}
+        expect(injector.lookup(scope,'a_string')).to  eq('42')
+        expect(injector.lookup(scope,'an_int')).to    eq(43)
+        expect(injector.lookup(scope,'a_float')).to   eq(3.14)
+        expect(injector.lookup(scope,'a_boolean')).to eq(true)
+        expect(injector.lookup(scope,'an_array')).to  eq([1,2,3])
+        expect(injector.lookup(scope,'a_hash')).to    eq({'a'=>1,'b'=>2,'c'=>3})
       end
 
       it "should provide type-safe lookup of given type/name" do
@@ -302,20 +302,20 @@ describe 'Injector' do
         injector = injector(lbinder)
 
         # Check lookup using implied Data type
-        injector.lookup(scope,'a_string').should  == '42'
-        injector.lookup(scope,'an_int').should    == 43
-        injector.lookup(scope,'a_float').should   == 3.14
-        injector.lookup(scope,'a_boolean').should == true
-        injector.lookup(scope,'an_array').should  == [1,2,3]
-        injector.lookup(scope,'a_hash').should    == {'a'=>1,'b'=>2,'c'=>3}
+        expect(injector.lookup(scope,'a_string')).to  eq('42')
+        expect(injector.lookup(scope,'an_int')).to    eq(43)
+        expect(injector.lookup(scope,'a_float')).to   eq(3.14)
+        expect(injector.lookup(scope,'a_boolean')).to eq(true)
+        expect(injector.lookup(scope,'an_array')).to  eq([1,2,3])
+        expect(injector.lookup(scope,'a_hash')).to    eq({'a'=>1,'b'=>2,'c'=>3})
 
         # Check lookup using expected type
-        injector.lookup(scope,type_factory.string(), 'a_string').should        == '42'
-        injector.lookup(scope,type_factory.integer(), 'an_int').should         == 43
-        injector.lookup(scope,type_factory.float(),'a_float').should           == 3.14
-        injector.lookup(scope,type_factory.boolean(),'a_boolean').should       == true
-        injector.lookup(scope,type_factory.array_of_data(),'an_array').should  == [1,2,3]
-        injector.lookup(scope,type_factory.hash_of_data(),'a_hash').should     == {'a'=>1,'b'=>2,'c'=>3}
+        expect(injector.lookup(scope,type_factory.string(), 'a_string')).to        eq('42')
+        expect(injector.lookup(scope,type_factory.integer(), 'an_int')).to         eq(43)
+        expect(injector.lookup(scope,type_factory.float(),'a_float')).to           eq(3.14)
+        expect(injector.lookup(scope,type_factory.boolean(),'a_boolean')).to       eq(true)
+        expect(injector.lookup(scope,type_factory.array_of_data(),'an_array')).to  eq([1,2,3])
+        expect(injector.lookup(scope,type_factory.hash_of_data(),'a_hash')).to     eq({'a'=>1,'b'=>2,'c'=>3})
 
         # Check lookup using wrong type
         expect { injector.lookup(scope,type_factory.integer(), 'a_string')}.to raise_error(/Type error/)
@@ -331,23 +331,23 @@ describe 'Injector' do
   context "When looking up producer" do
     it 'the value is produced by calling produce(scope)' do
       bindings.bind().name('a_string').to('42')
-      injector(lbinder).lookup_producer(scope, 'a_string').produce(scope).should == '42'
+      expect(injector(lbinder).lookup_producer(scope, 'a_string').produce(scope)).to eq('42')
     end
 
     context 'a block transforming the result can be given' do
       it 'that transform a found value given scope and producer' do
         bindings.bind().name('a_string').to('42')
-        injector(lbinder).lookup_producer(scope, 'a_string') {|zcope, p| p.produce(zcope) + '42' }.should == '4242'
+        expect(injector(lbinder).lookup_producer(scope, 'a_string') {|zcope, p| p.produce(zcope) + '42' }).to eq('4242')
       end
 
       it 'that transform a found value given only producer' do
         bindings.bind().name('a_string').to('42')
-        injector(lbinder).lookup_producer(scope, 'a_string') {|p| p.produce(scope) + '42' }.should == '4242'
+        expect(injector(lbinder).lookup_producer(scope, 'a_string') {|p| p.produce(scope) + '42' }).to eq('4242')
       end
 
       it 'that can produce a default value when entry is not found' do
         bindings.bind().name('a_string').to('42')
-        injector(lbinder).lookup_producer(scope, 'a_non_existing_string') {|p| p ? (raise Error,"Should not happen") : '4242' }.should == '4242'
+        expect(injector(lbinder).lookup_producer(scope, 'a_non_existing_string') {|p| p ? (raise Error,"Should not happen") : '4242' }).to eq('4242')
       end
     end
   end
@@ -358,7 +358,7 @@ describe 'Injector' do
       injector = injector(lbinder)
       a = injector.lookup(scope, 'a_string')
       b = injector.lookup(scope, 'a_string')
-      a.equal?(b).should == true
+      expect(a.equal?(b)).to eq(true)
     end
 
     it "should produce different instances when producer is a non singleton producer" do
@@ -366,9 +366,9 @@ describe 'Injector' do
       injector = injector(lbinder)
       a = injector.lookup(scope, 'a_string')
       b = injector.lookup(scope, 'a_string')
-      a.should == '42'
-      b.should == '42'
-      a.equal?(b).should == false
+      expect(a).to eq('42')
+      expect(b).to eq('42')
+      expect(a.equal?(b)).to eq(false)
     end
   end
 
@@ -376,12 +376,12 @@ describe 'Injector' do
     it "should lookup again to produce a value" do
       bindings.bind().name('a_string').to_lookup_of('another_string')
       bindings.bind().name('another_string').to('hello')
-      injector(lbinder).lookup(scope, 'a_string').should == 'hello'
+      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('hello')
     end
 
     it "should produce nil if looked up key does not exist" do
       bindings.bind().name('a_string').to_lookup_of('non_existing')
-      injector(lbinder).lookup(scope, 'a_string').should == nil
+      expect(injector(lbinder).lookup(scope, 'a_string')).to eq(nil)
     end
 
     it "should report an error if lookup loop is detected" do
@@ -395,14 +395,14 @@ describe 'Injector' do
       data_hash = type_factory.hash_of_data()
       bindings.bind().name('a_string').to_hash_lookup_of(data_hash, 'a_hash', 'huey')
       bindings.bind().name('a_hash').to({'huey' => 'red', 'dewey' => 'blue', 'louie' => 'green'})
-      injector(lbinder).lookup(scope, 'a_string').should == 'red'
+      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('red')
     end
 
     it "should produce nil if looked up entry does not exist" do
       data_hash = type_factory.hash_of_data()
       bindings.bind().name('a_string').to_hash_lookup_of(data_hash, 'non_existing_entry', 'huey')
       bindings.bind().name('a_hash').to({'huey' => 'red', 'dewey' => 'blue', 'louie' => 'green'})
-      injector(lbinder).lookup(scope, 'a_string').should == nil
+      expect(injector(lbinder).lookup(scope, 'a_string')).to eq(nil)
     end
   end
 
@@ -411,21 +411,21 @@ describe 'Injector' do
       bindings.bind().name('a_string').to_first_found('b_string', 'c_string', 'g_string')
       bindings.bind().name('c_string').to('hello')
       bindings.bind().name('g_string').to('Oh, mrs. Smith...')
-      injector(lbinder).lookup(scope, 'a_string').should == 'hello'
+      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('hello')
     end
 
     it "should lookup until it finds a value using mix of type and name, but not further" do
       bindings.bind().name('a_string').to_first_found('b_string', [type_factory.string, 'c_string'], 'g_string')
       bindings.bind().name('c_string').to('hello')
       bindings.bind().name('g_string').to('Oh, mrs. Smith...')
-      injector(lbinder).lookup(scope, 'a_string').should == 'hello'
+      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('hello')
     end
   end
 
   context "When producing instances" do
     it "should lookup an instance of a class without arguments" do
       bindings.bind().type(duck_type).name('the_duck').to(InjectorSpecModule::Daffy)
-      injector(lbinder).lookup(scope, duck_type, 'the_duck').is_a?(InjectorSpecModule::Daffy).should == true
+      expect(injector(lbinder).lookup(scope, duck_type, 'the_duck').is_a?(InjectorSpecModule::Daffy)).to eq(true)
     end
 
     it "should lookup an instance of a class with arguments" do
@@ -433,8 +433,8 @@ describe 'Injector' do
       injector = injector(lbinder)
 
       the_duck = injector.lookup(scope, duck_type, 'the_duck')
-      the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck).should == true
-      the_duck.fortune.should == 1234
+      expect(the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck)).to eq(true)
+      expect(the_duck.fortune).to eq(1234)
     end
 
     it "singleton producer should not be recreated between lookups" do
@@ -442,17 +442,17 @@ describe 'Injector' do
       injector = injector(lbinder)
 
       the_duck = injector.lookup(scope, duck_type, 'the_duck')
-      the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck).should == true
-      the_duck.fortune.should == 200
+      expect(the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck)).to eq(true)
+      expect(the_duck.fortune).to eq(200)
 
       # singleton, do it again to get next value in series - it is the producer that is a singleton
       # not the produced value
       the_duck = injector.lookup(scope, duck_type, 'the_duck')
-      the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck).should == true
-      the_duck.fortune.should == 400
+      expect(the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck)).to eq(true)
+      expect(the_duck.fortune).to eq(400)
 
       duck_producer = injector.lookup_producer(scope, duck_type, 'the_duck')
-      duck_producer.produce(scope).fortune.should == 800
+      expect(duck_producer.produce(scope).fortune).to eq(800)
     end
 
     it "series of producers should recreate producer on each lookup and lookup_producer" do
@@ -460,16 +460,16 @@ describe 'Injector' do
       injector = injector(lbinder)
 
       duck_producer = injector.lookup_producer(scope, duck_type, 'the_duck')
-      duck_producer.produce(scope).fortune().should == 200
-      duck_producer.produce(scope).fortune().should == 400
+      expect(duck_producer.produce(scope).fortune()).to eq(200)
+      expect(duck_producer.produce(scope).fortune()).to eq(400)
 
       # series, each lookup gets a new producer (initialized to produce 200)
       duck_producer = injector.lookup_producer(scope, duck_type, 'the_duck')
-      duck_producer.produce(scope).fortune().should == 200
-      duck_producer.produce(scope).fortune().should == 400
+      expect(duck_producer.produce(scope).fortune()).to eq(200)
+      expect(duck_producer.produce(scope).fortune()).to eq(400)
 
-      injector.lookup(scope, duck_type, 'the_duck').fortune().should == 200
-      injector.lookup(scope, duck_type, 'the_duck').fortune().should == 200
+      expect(injector.lookup(scope, duck_type, 'the_duck').fortune()).to eq(200)
+      expect(injector.lookup(scope, duck_type, 'the_duck').fortune()).to eq(200)
     end
   end
 
@@ -486,10 +486,10 @@ describe 'Injector' do
 
         injector = injector(lbinder)
         the_ducks = injector.lookup(scope, hash_of_duck, "donalds_nephews")
-        the_ducks.size.should == 3
-        the_ducks['nephew1'].name.should == 'Huey'
-        the_ducks['nephew2'].name.should == 'Dewey'
-        the_ducks['nephew3'].name.should == 'Louie'
+        expect(the_ducks.size).to eq(3)
+        expect(the_ducks['nephew1'].name).to eq('Huey')
+        expect(the_ducks['nephew2'].name).to eq('Dewey')
+        expect(the_ducks['nephew3'].name).to eq('Louie')
       end
 
       it "is an error to not bind contribution with a name" do
@@ -563,8 +563,8 @@ describe 'Injector' do
 
         ducks = injector(lbinder).lookup(scope, 'donalds_family')
 
-        ducks['nephews'].should == ['Huey', 'Dewey', 'Louie']
-        ducks['uncles'].should == ['Scrooge McDuck', 'Ludwig Von Drake']
+        expect(ducks['nephews']).to eq(['Huey', 'Dewey', 'Louie'])
+        expect(ducks['uncles']).to eq(['Scrooge McDuck', 'Ludwig Von Drake'])
       end
 
       it "should be possible to combine hash multibind contributions with append, flat, and uniq, on conflict" do
@@ -587,8 +587,8 @@ describe 'Injector' do
 
         ducks = injector(lbinder).lookup(scope, 'donalds_family')
 
-        ducks['nephews'].should == ['Huey', 'Dewey', 'Louie']
-        ducks['uncles'].should == ['Scrooge McDuck', 'Ludwig Von Drake']
+        expect(ducks['nephews']).to eq(['Huey', 'Dewey', 'Louie'])
+        expect(ducks['uncles']).to eq(['Scrooge McDuck', 'Ludwig Von Drake'])
       end
 
       it "should fail attempts to append, perform  uniq or flatten on type incompatible multibind hash" do
@@ -622,7 +622,7 @@ describe 'Injector' do
 
         binder.define_layers(layered_bindings)
 
-        injector(binder).lookup(scope, hash_of_duck, "donalds_nephews")['nephew'].name.should == 'Huey'
+        expect(injector(binder).lookup(scope, hash_of_duck, "donalds_nephews")['nephew'].name).to eq('Huey')
       end
 
       it "a higher priority contribution wins when resolution is :merge" do
@@ -639,9 +639,9 @@ describe 'Injector' do
         mb2.name('nephew').to({'name' => 'Dewey', 'is' => 'looser', 'has' => 'cap'})
 
         the_ducks = injector(binder.new(layered_bindings)).lookup(scope, "donalds_nephews");
-        the_ducks['nephew']['name'].should == 'Huey'
-        the_ducks['nephew']['is'].should == 'winner'
-        the_ducks['nephew']['has'].should == 'cap'
+        expect(the_ducks['nephew']['name']).to eq('Huey')
+        expect(the_ducks['nephew']['is']).to eq('winner')
+        expect(the_ducks['nephew']['has']).to eq('cap')
       end
     end
 
@@ -658,8 +658,8 @@ describe 'Injector' do
         bindings.bind.in_multibind(multibind_id).type(duck_type).to(InjectorSpecModule::NamedDuck, 'Louie')
 
         the_ducks = injector(lbinder).lookup(scope, array_of_duck, "donalds_nephews")
-        the_ducks.size.should == 3
-        the_ducks.collect {|d| d.name }.sort.should == ['Dewey', 'Huey', 'Louie']
+        expect(the_ducks.size).to eq(3)
+        expect(the_ducks.collect {|d| d.name }.sort).to eq(['Dewey', 'Huey', 'Louie'])
       end
 
       it "should be able to make result contain only unique entries" do
@@ -681,7 +681,7 @@ describe 'Injector' do
         bindings.bind.in_multibind(multibind_id).name('nephews').to('Louie') # duplicate
 
         ducks = injector(lbinder).lookup(scope, 'donalds_family')
-        ducks.should == ['Huey', 'Dewey', 'Louie']
+        expect(ducks).to eq(['Huey', 'Dewey', 'Louie'])
       end
 
       it "should be able to contribute elements and arrays of elements and flatten 1 level" do
@@ -701,7 +701,7 @@ describe 'Injector' do
         bindings.bind.in_multibind(multibind_id).to(['Huey', 'Dewey', 'Louie'])
 
         ducks = injector(lbinder).lookup(scope, 'donalds_family')
-        ducks.should == ['Huey', 'Dewey', 'Louie', 'Huey', 'Dewey', 'Louie']
+        expect(ducks).to eq(['Huey', 'Dewey', 'Louie', 'Huey', 'Dewey', 'Louie'])
       end
 
       it "should produce detailed type error message" do
@@ -742,19 +742,19 @@ describe 'Injector' do
         scope['duck'] = 'Donald Fauntleroy Duck'
         expr = parser.parse_string('"Hello $duck"').current()
         bindings.bind.name('the_duck').to(expr)
-        injector(lbinder).lookup(scope, 'the_duck').should == 'Hello Donald Fauntleroy Duck'
+        expect(injector(lbinder).lookup(scope, 'the_duck')).to eq('Hello Donald Fauntleroy Duck')
       end
 
       it "should be possible to post process lookup with a puppet lambda" do
         model = parser.parse_string('fake() |$value| {$value + 1 }').current
         bindings.bind.name('an_int').to(42).producer_options( :transformer => model.body.lambda)
-        injector(lbinder).lookup(scope, 'an_int').should == 43
+        expect(injector(lbinder).lookup(scope, 'an_int')).to eq(43)
       end
 
       it "should be possible to post process lookup with a ruby proc" do
         transformer = lambda {|value| value + 1 }
         bindings.bind.name('an_int').to(42).producer_options( :transformer => transformer)
-        injector(lbinder).lookup(scope, 'an_int').should == 43
+        expect(injector(lbinder).lookup(scope, 'an_int')).to eq(43)
       end
     end
   end
@@ -783,4 +783,4 @@ describe 'Injector' do
       expect{injector(lbinder).lookup(scope, 'an_int') }.to raise_error(/Binding without producer/)
     end
   end
-end
+end