puppet 5.3.4 → 6.29.0

data/spec/unit/pops/types/type_calculator_spec.rb

@@ -42,6 +42,13 @@ describe 'The type calculator' do
     TypeFactory.variant(*types)
   end
 
+  def empty_variant_t()
+    t = TypeFactory.variant()
+    # assert this to ensure we did get an empty variant (or tests may pass when not being empty)
+    raise 'typefactory did not return empty variant' unless t.types.empty?
+    t
+  end
+
   def type_alias_t(name, type_string)
     type_expr = Parser::EvaluatingParser.new.parse_string(type_string)
     TypeFactory.type_alias(name, type_expr)
@@ -60,7 +67,7 @@ describe 'The type calculator' do
   end
 
   def empty_array_t
-  empty_array = array_t(unit_t, range_t(0,0))
+    array_t(unit_t, range_t(0,0))
   end
 
   def hash_t(k,v,s = nil)
@@ -156,12 +163,12 @@ describe 'The type calculator' do
       expect(t.value).to eq('foo')
     end
 
-    it 'boolean true translates to PBooleanType' do
-      expect(calculator.infer(true).class).to eq(PBooleanType)
+    it 'boolean true translates to PBooleanType::TRUE' do
+      expect(calculator.infer(true)).to eq(PBooleanType::TRUE)
     end
 
-    it 'boolean false translates to PBooleanType' do
-      expect(calculator.infer(false).class).to eq(PBooleanType)
+    it 'boolean false translates to PBooleanType::FALSE' do
+      expect(calculator.infer(false)).to eq(PBooleanType::FALSE)
     end
 
     it 'regexp translates to PRegexpType' do
@@ -851,7 +858,6 @@ describe 'The type calculator' do
         t = PTypeReferenceType::DEFAULT
         all_instances = (all_types - [
           PTypeReferenceType, # Avoid comparison with t
-          PVariantType,   # DEFAULT contains no variants, so assignability is never tested and always true
           PTypeAliasType      # DEFAULT resolves to PTypeReferenceType::DEFAULT, i.e. t
         ]).map {|c| c::DEFAULT }
 
@@ -942,6 +948,45 @@ describe 'The type calculator' do
         expect(v).not_to be_assignable_to(range_t(0, 4))
         expect(v).not_to be_assignable_to(string_t)
       end
+
+      it 'an empty Variant is assignable to another empty Variant' do
+        expect(empty_variant_t).to be_assignable_to(empty_variant_t)
+      end
+
+      it 'an empty Variant is assignable to Any' do
+        expect(empty_variant_t).to be_assignable_to(PAnyType::DEFAULT)
+      end
+
+      it 'an empty Variant is assignable to Unit' do
+        expect(empty_variant_t).to be_assignable_to(PUnitType::DEFAULT)
+      end
+
+      it 'an empty Variant is not assignable to any type except empty Variant, Any, NotUndef, and Unit' do
+        assignables = [PUnitType, PAnyType, PNotUndefType]
+        unassignables = all_types - assignables
+        unassignables.each {|t2| expect(empty_variant_t).not_to be_assignable_to(t2::DEFAULT) }
+        assignables.each   {|t2| expect(empty_variant_t).to be_assignable_to(t2::DEFAULT) }
+      end
+
+      it 'an empty Variant is not assignable to Optional[Any] since it is not assignable to Undef' do
+        opt_any = optional_t(any_t)
+        expect(empty_variant_t).not_to be_assignable_to(opt_any)
+      end
+
+      it 'an Optional[Any] is not assignable to empty Variant' do
+        opt_any = optional_t(any_t)
+        expect(opt_any).not_to be_assignable_to(empty_variant_t)
+      end
+
+      it 'an empty Variant is assignable to NotUndef[Variant] since Variant is not Undef' do
+        not_undef_variant = not_undef_t(empty_variant_t)
+        expect(empty_variant_t).to be_assignable_to(not_undef_variant)
+      end
+
+      it 'a NotUndef[Variant] is assignable to empty Variant' do
+        not_undef_variant = not_undef_t(empty_variant_t)
+        expect(not_undef_variant).to be_assignable_to(empty_variant_t)
+      end
     end
 
     context 'for Scalar, such that' do
@@ -1056,6 +1101,32 @@ describe 'The type calculator' do
       end
     end
 
+    context 'for Enum, such that' do
+      it 'Enum is assignable to an Enum with all contained options' do
+        expect(enum_t('a', 'b')).to be_assignable_to(enum_t('a', 'b', 'c'))
+      end
+
+      it 'Enum is not assignable to an Enum with fewer contained options' do
+        expect(enum_t('a', 'b')).not_to be_assignable_to(enum_t('a'))
+      end
+
+      it 'case insensitive Enum is not assignable to case sensitive Enum' do
+        expect(enum_t('a', 'b', true)).not_to be_assignable_to(enum_t('a', 'b'))
+      end
+
+      it 'case sensitive Enum is assignable to case insensitive Enum' do
+        expect(enum_t('a', 'b')).to be_assignable_to(enum_t('a', 'b', true))
+      end
+
+      it 'case sensitive Enum is not assignable to case sensitive Enum using different case' do
+        expect(enum_t('a', 'b')).not_to be_assignable_to(enum_t('A', 'B'))
+      end
+
+      it 'case sensitive Enum is assignable to case insensitive Enum using different case' do
+        expect(enum_t('a', 'b')).to be_assignable_to(enum_t('A', 'B', true))
+      end
+    end
+
     context 'for Hash, such that' do
       it 'Hash is not assignable to any other Collection type' do
         t = PHashType::DEFAULT
@@ -1263,8 +1334,6 @@ describe 'The type calculator' do
 
     it 'should recognize mapped ruby types' do
       { Integer    => PIntegerType::DEFAULT,
-        Fixnum     => PIntegerType::DEFAULT,
-        Bignum     => PIntegerType::DEFAULT,
         Float      => PFloatType::DEFAULT,
         Numeric    => PNumericType::DEFAULT,
         NilClass   => PUndefType::DEFAULT,
@@ -1652,13 +1721,13 @@ describe 'The type calculator' do
       end
 
       it 'a recursive alias can be assignable from a conformant type with any depth' do
-        scope = Object.new
+        scope = {}
 
         t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree').returns t
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree').and_return(t)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t.resolve(scope)
         expect(calculator.assignable?(t, parser.parse('Hash[String,Variant[String,Hash[String,Variant[String,String]]]]'))).to be_truthy
@@ -1666,15 +1735,15 @@ describe 'The type calculator' do
 
 
       it 'similar recursive aliases are assignable' do
-        scope = Object.new
+        scope = {}
 
         t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree1]]')
         t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree2]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree1').returns t1
-        loader.expects(:load).with(:type, 'tree2').returns t2
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree1').and_return(t1)
+        expect(loader).to receive(:load).with(:type, 'tree2').and_return(t2)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1.resolve(scope)
         t2.resolve(scope)
@@ -1684,11 +1753,11 @@ describe 'The type calculator' do
       it 'crossing recursive aliases are assignable' do
         t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree2]]')
         t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree1]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree1').returns t1
-        loader.expects(:load).with(:type, 'tree2').returns t2
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree1').and_return(t1)
+        expect(loader).to receive(:load).with(:type, 'tree2').and_return(t2)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1.resolve(loader)
         t2.resolve(loader)
@@ -1696,12 +1765,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[T] is assignable to Type[AT] when AT is an alias for T' do
-        scope = Object.new
+        scope = {}
 
         ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'positiveinteger').returns ta
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'positiveinteger').and_return(ta)
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1 = type_t(range_t(0, :default))
         t2 = parser.parse('Type[PositiveInteger]', scope)
@@ -1709,12 +1778,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[T] is assignable to AT when AT is an alias for Type[T]' do
-        scope = Object.new
+        scope = {}
 
         ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'positiveintegertype').returns ta
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'positiveintegertype').and_return(ta)
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1 = type_t(range_t(0, :default))
         t2 = parser.parse('PositiveIntegerType', scope)
@@ -1722,12 +1791,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[Type[T]] is assignable to Type[Type[AT]] when AT is an alias for T' do
-        scope = Object.new
+        scope = {}
 
         ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'positiveinteger').returns ta
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'positiveinteger').and_return(ta)
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1 = type_t(type_t(range_t(0, :default)))
         t2 = parser.parse('Type[Type[PositiveInteger]]', scope)
@@ -1735,12 +1804,12 @@ describe 'The type calculator' do
       end
 
       it 'Type[Type[T]] is assignable to Type[AT] when AT is an alias for Type[T]' do
-        scope = Object.new
+        scope = {}
 
         ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'positiveintegertype').returns ta
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'positiveintegertype').and_return(ta)
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1 = type_t(type_t(range_t(0, :default)))
         t2 = parser.parse('Type[PositiveIntegerType]', scope)
@@ -1911,6 +1980,12 @@ describe 'The type calculator' do
       expect(calculator.instance?(tuple, [1, 'a', 1])).to          eq(false)
     end
 
+    it 'should not consider ProcessOutput objects as instanceof PScalarDataType' do
+      object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
+      
+      expect(calculator.instance?(PScalarDataType::DEFAULT, object)).to eq(false)
+    end
+
     context 'and t is Struct' do
       it 'should consider hash[cont] as instance of Struct[cont-t]' do
         struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>Float})
@@ -2051,10 +2126,10 @@ describe 'The type calculator' do
 
       it 'should consider x an instance of the aliased type that uses self recursion' do
         t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree').returns t
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree').and_return(t)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t.resolve(loader)
         expect(calculator.instance?(t, {'a'=>{'aa'=>{'aaa'=>'aaaa'}}, 'b'=>'bb'})).to be_truthy
@@ -2063,11 +2138,11 @@ describe 'The type calculator' do
       it 'should consider x an instance of the aliased type that uses contains an alias that causes self recursion' do
         t1 = type_alias_t('Tree', 'Hash[String,Variant[String,OtherTree]]')
         t2 = type_alias_t('OtherTree', 'Hash[String,Tree]')
-        loader = Object.new
-        loader.expects(:load).with(:type, 'tree').returns t1
-        loader.expects(:load).with(:type, 'othertree').returns t2
+        loader = double
+        expect(loader).to receive(:load).with(:type, 'tree').and_return(t1)
+        expect(loader).to receive(:load).with(:type, 'othertree').and_return(t2)
 
-        Adapters::LoaderAdapter.expects(:loader_for_model_object).at_least_once.returns loader
+        expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).at_least(:once).and_return(loader)
 
         t1.resolve(loader)
         expect(calculator.instance?(t1, {'a'=>{'aa'=>{'aaa'=>'aaaa'}}, 'b'=>'bb'})).to be_truthy
@@ -2076,14 +2151,6 @@ describe 'The type calculator' do
   end
 
   context 'when converting a ruby class' do
-    it 'should yield \'PIntegerType\' for Fixnum' do
-      expect(calculator.type(Fixnum).class).to eq(PIntegerType)
-    end
-
-    it 'should yield \'PIntegerType\' for Bignum' do
-      expect(calculator.type(Bignum).class).to eq(PIntegerType)
-    end
-
     it 'should yield \'PIntegerType\' for Integer' do
       expect(calculator.type(Integer).class).to eq(PIntegerType)
     end
@@ -2204,7 +2271,7 @@ describe 'The type calculator' do
     it 'should infer PTypeType as the type of ruby classes' do
       class Foo
       end
-      [Object, Numeric, Integer, Fixnum, Bignum, Float, String, Regexp, Array, Hash, Foo].each do |c|
+      [Object, Numeric, Integer, Float, String, Regexp, Array, Hash, Foo].each do |c|
         expect(calculator.infer(c).is_a?(PTypeType)).to eq(true)
       end
     end

data/spec/unit/pops/types/type_formatter_spec.rb

@@ -19,7 +19,7 @@ describe 'The type formatter' do
     {
       'true' => true,
       'false' => false,
-      '?' => nil,
+      'undef' => nil,
       '23.4' => 23.4,
       '145' => 145,
       "'string'" => 'string',
@@ -99,6 +99,14 @@ FORMATTED
       expect(s.string(f.boolean)).to eq('Boolean')
     end
 
+    it "should yield 'Boolean[true]' for PBooleanType parameterized with true" do
+      expect(s.string(f.boolean(true))).to eq('Boolean[true]')
+    end
+
+    it "should yield 'Boolean[false]' for PBooleanType parameterized with false" do
+      expect(s.string(f.boolean(false))).to eq('Boolean[false]')
+    end
+
     it "should yield 'Data' for the Data type" do
       expect(s.string(f.data)).to eq('Data')
     end
@@ -112,7 +120,7 @@ FORMATTED
       expect(s.string(f.range(1,1))).to eq('Integer[1, 1]')
       expect(s.string(f.range(1,2))).to eq('Integer[1, 2]')
       expect(s.string(f.range(:default, 2))).to eq('Integer[default, 2]')
-      expect(s.string(f.range(2, :default))).to eq('Integer[2, default]')
+      expect(s.string(f.range(2, :default))).to eq('Integer[2]')
     end
 
     it "should yield 'Float' for PFloatType" do
@@ -142,8 +150,8 @@ FORMATTED
     it "should yield 'String' and from/to for PStringType" do
       expect(s.string(f.string(f.range(1,1)))).to eq('String[1, 1]')
       expect(s.string(f.string(f.range(1,2)))).to eq('String[1, 2]')
-      expect(s.string(f.string(f.range(:default, 2)))).to eq('String[default, 2]')
-      expect(s.string(f.string(f.range(2, :default)))).to eq('String[2, default]')
+      expect(s.string(f.string(f.range(:default, 2)))).to eq('String[0, 2]')
+      expect(s.string(f.string(f.range(2, :default)))).to eq('String[2]')
     end
 
     it "should yield 'Array[Integer]' for PArrayType[PIntegerType]" do
@@ -167,15 +175,15 @@ FORMATTED
     it "should yield 'Collection' and from/to for PCollectionType" do
       expect(s.string(f.collection(f.range(1,1)))).to eq('Collection[1, 1]')
       expect(s.string(f.collection(f.range(1,2)))).to eq('Collection[1, 2]')
-      expect(s.string(f.collection(f.range(:default, 2)))).to eq('Collection[default, 2]')
-      expect(s.string(f.collection(f.range(2, :default)))).to eq('Collection[2, default]')
+      expect(s.string(f.collection(f.range(:default, 2)))).to eq('Collection[0, 2]')
+      expect(s.string(f.collection(f.range(2, :default)))).to eq('Collection[2]')
     end
 
     it "should yield 'Array' and from/to for PArrayType" do
       expect(s.string(f.array_of(f.string, f.range(1,1)))).to eq('Array[String, 1, 1]')
       expect(s.string(f.array_of(f.string, f.range(1,2)))).to eq('Array[String, 1, 2]')
-      expect(s.string(f.array_of(f.string, f.range(:default, 2)))).to eq('Array[String, default, 2]')
-      expect(s.string(f.array_of(f.string, f.range(2, :default)))).to eq('Array[String, 2, default]')
+      expect(s.string(f.array_of(f.string, f.range(:default, 2)))).to eq('Array[String, 0, 2]')
+      expect(s.string(f.array_of(f.string, f.range(2, :default)))).to eq('Array[String, 2]')
     end
 
     it "should yield 'Iterable' for PIterableType" do
@@ -240,7 +248,7 @@ FORMATTED
       expect(s.string(f.tuple(types, f.range(1,1)))).to eq('Tuple[String, 1, 1]')
       expect(s.string(f.tuple(types, f.range(1,2)))).to eq('Tuple[String, 1, 2]')
       expect(s.string(f.tuple(types, f.range(:default, 2)))).to eq('Tuple[String, 0, 2]')
-      expect(s.string(f.tuple(types, f.range(2, :default)))).to eq('Tuple[String, 2, default]')
+      expect(s.string(f.tuple(types, f.range(2, :default)))).to eq('Tuple[String, 2]')
     end
 
     it "should yield 'Struct' and details for PStructType" do
@@ -257,8 +265,8 @@ FORMATTED
     it "should yield 'Hash' and from/to for PHashType" do
       expect(s.string(f.hash_of(f.string, f.string, f.range(1,1)))).to eq('Hash[String, String, 1, 1]')
       expect(s.string(f.hash_of(f.string, f.string, f.range(1,2)))).to eq('Hash[String, String, 1, 2]')
-      expect(s.string(f.hash_of(f.string, f.string, f.range(:default, 2)))).to eq('Hash[String, String, default, 2]')
-      expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2, default]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(:default, 2)))).to eq('Hash[String, String, 0, 2]')
+      expect(s.string(f.hash_of(f.string, f.string, f.range(2, :default)))).to eq('Hash[String, String, 2]')
     end
 
     it "should yield 'Hash' for PHashType::DEFAULT" do
@@ -290,6 +298,16 @@ FORMATTED
       expect(s.string(t)).to eq("Enum['a', 'b', 'c']")
     end
 
+    it "should yield 'Enum[s,...]' for a PEnumType[s,...,false]" do
+      t = f.enum('a', 'b', 'c', false)
+      expect(s.string(t)).to eq("Enum['a', 'b', 'c']")
+    end
+
+    it "should yield 'Enum[s,...,true]' for a PEnumType[s,...,true]" do
+      t = f.enum('a', 'b', 'c', true)
+      expect(s.string(t)).to eq("Enum['a', 'b', 'c', true]")
+    end
+
     it "should yield 'Pattern[/pat/,...]' for a PPatternType['pat',...]" do
       t = f.pattern('a')
       t2 = f.pattern('a', 'b', 'c')
@@ -331,7 +349,7 @@ FORMATTED
     end
 
     it "should yield 'Callable[t,min,max]' for callable with size constraint (infinite max)" do
-      expect(s.string(f.callable(String, 0))).to eql('Callable[String, 0, default]')
+      expect(s.string(f.callable(String, 0))).to eql('Callable[String, 0]')
     end
 
     it "should yield 'Callable[t,min,max]' for callable with size constraint (capped max)" do
@@ -341,7 +359,7 @@ FORMATTED
     it "should yield 'Callable[min,max]' callable with size > 0" do
       expect(s.string(f.callable(0, 0))).to eql('Callable[0, 0]')
       expect(s.string(f.callable(0, 1))).to eql('Callable[0, 1]')
-      expect(s.string(f.callable(0, :default))).to eql('Callable[0, default]')
+      expect(s.string(f.callable(0, :default))).to eql('Callable[0]')
     end
 
     it "should yield 'Callable[Callable]' for callable with block" do

data/spec/unit/pops/types/type_mismatch_describer_spec.rb

@@ -244,6 +244,15 @@ describe 'the type mismatch describer' do
     expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
       /Class\[Test\]: parameter 'opts' expects size to be 1, got 0/))
   end
+
+  it "treats Optional as Optional[Any]" do
+    code = <<-PUPPET
+      class test(Optional $var=undef) {}
+      class { 'test': var => 'hello' }
+    PUPPET
+    expect { eval_and_collect_notices(code) }.not_to raise_error
+  end
+
 end
 end
 end

data/spec/unit/pops/types/type_parser_spec.rb

@@ -36,7 +36,7 @@ describe TypeParser do
   end
 
   [
-    'Any', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric', 'Default'
+    'Any', 'Data', 'CatalogEntry', 'Scalar', 'Undef', 'Numeric', 'Default'
   ].each do |name|
     it "does not support parameterizing unparameterized type <#{name}>" do
       expect { parser.parse("#{name}[Integer]") }.to raise_unparameterized_error_for(name)
@@ -79,6 +79,18 @@ describe TypeParser do
     expect(parser.parse("Hash[Scalar, Integer]")).to be_the_type(types.hash_of(types.integer))
   end
 
+  it 'interprets an Boolean with a true parameter to represent boolean true' do
+    expect(parser.parse('Boolean[true]')).to be_the_type(types.boolean(true))
+  end
+
+  it 'interprets an Boolean with a false parameter to represent boolean false' do
+    expect(parser.parse('Boolean[false]')).to be_the_type(types.boolean(false))
+  end
+
+  it 'does not accept non-boolean parameters' do
+    expect{parser.parse('Boolean["false"]')}.to raise_error(/Boolean parameter must be true or false/)
+  end
+
   it 'interprets an Integer with one parameter to have unbounded upper range' do
     expect(parser.parse('Integer[0]')).to eq(parser.parse('Integer[0,default]'))
   end
@@ -160,39 +172,39 @@ describe TypeParser do
 
   context 'with scope context and loader' do
     let!(:scope) { {} }
-    let(:loader) { Object.new }
+    let(:loader) { double }
 
     before :each do
-      Adapters::LoaderAdapter.expects(:loader_for_model_object).returns loader
+      expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(loader)
     end
 
     it 'interprets anything that is not found by the loader to be a type reference' do
-      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
       expect(parser.parse('Nonesuch', scope)).to be_the_type(types.type_reference('Nonesuch'))
     end
 
     it 'interprets anything that is found by the loader to be what the loader found' do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse('File', scope)).to be_the_type(types.resource('File'))
     end
 
     it "parses a resource type with title" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("File['/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type using 'Resource[type]' form" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("Resource[File]", scope)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title using 'Resource[type, title]'" do
-      loader.expects(:load).with(:type, 'file').returns nil
+      expect(loader).to receive(:load).with(:type, 'file').and_return(nil)
       expect(parser.parse("Resource[File, '/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type with title using 'Resource[Type[title]]'" do
-      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
       expect(parser.parse("Resource[Nonesuch['fife']]", scope)).to be_the_type(types.resource('nonesuch', 'fife'))
     end
   end
@@ -201,27 +213,27 @@ describe TypeParser do
     let(:loader) { Puppet::Pops::Loader::BaseLoader.new(nil, "type_parser_unit_test_loader") }
 
     it 'interprets anything that is not found by the loader to be a type reference' do
-      loader.expects(:load).with(:type, 'nonesuch').returns nil
+      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
       expect(parser.parse('Nonesuch', loader)).to be_the_type(types.type_reference('Nonesuch'))
     end
 
     it 'interprets anything that is found by the loader to be what the loader found' do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse('File', loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("File['/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type using 'Resource[type]' form" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("Resource[File]", loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title using 'Resource[type, title]'" do
-      loader.expects(:load).with(:type, 'file').returns types.resource('File')
+      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
       expect(parser.parse("Resource[File, '/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
   end