puppet 4.0.0 → 4.9.1

data/spec/unit/resource/catalog_spec.rb

@@ -67,7 +67,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
     Puppet[:classfile] = File.expand_path("/class/file")
 
     fh = mock 'filehandle'
-    File.expects(:open).with(Puppet[:classfile], "w").yields fh
+    classfile = Puppet.settings.setting(:classfile)
+    Puppet::FileSystem.expects(:open).with(classfile.value, classfile.mode.to_i(8), "w:UTF-8").yields fh
 
     fh.expects(:puts).with "foo\nbar"
 
@@ -86,6 +87,22 @@ describe Puppet::Resource::Catalog, "when compiling" do
     expect(@catalog.server_version).to eq(5)
   end
 
+  it "defaults code_id to nil" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.code_id).to be_nil
+  end
+
+  it "should include a catalog_uuid" do
+    SecureRandom.stubs(:uuid).returns ("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.catalog_uuid).to eq("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+  end
+
+  it "should include the current catalog_format" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.catalog_format).to eq(1)
+  end
+
   describe "when compiling" do
     it "should accept tags" do
       config = Puppet::Resource::Catalog.new("mynode")
@@ -127,6 +144,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
       config.add_class("one")
       expect(config).to be_tagged("one")
     end
+
+    it "handles resource titles with brackets" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      expect(config.title_key_for_ref("Notify[[foo]bar]")).to eql(["Notify", "[foo]bar"])
+    end
   end
 
   describe "when converting to a RAL catalog" do
@@ -248,6 +270,26 @@ describe Puppet::Resource::Catalog, "when compiling" do
         r == @r1
       end.edge?(@r1,@r2)).not_to be
     end
+
+    it "copies the version" do
+      @original.version = '123'
+      expect(@original.filter.version).to eq(@original.version)
+    end
+
+    it 'copies the code_id' do
+      @original.code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      expect(@original.filter.code_id).to eq(@original.code_id)
+    end
+
+    it 'copies the catalog_uuid' do
+      @original.catalog_uuid = '827a74c8-cf98-44da-9ff7-18c5e4bee41e'
+      expect(@original.filter.catalog_uuid).to eq(@original.catalog_uuid)
+    end
+
+    it 'copies the catalog_format' do
+      @original.catalog_format = 42
+      expect(@original.filter.catalog_format).to eq(@original.catalog_format)
+    end
   end
 
   describe "when functioning as a resource container" do
@@ -255,6 +297,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog = Puppet::Resource::Catalog.new("host")
       @one = Puppet::Type.type(:notify).new :name => "one"
       @two = Puppet::Type.type(:notify).new :name => "two"
+      @three = Puppet::Type.type(:notify).new :name => "three"
       @dupe = Puppet::Type.type(:notify).new :name => "one"
     end
 
@@ -308,6 +351,32 @@ describe Puppet::Resource::Catalog, "when compiling" do
       expect(@catalog.resource("notify[one]", nil)).to equal(@one)
     end
 
+    it "adds resources before an existing resource" do
+      @catalog.add_resource(@one)
+      @catalog.add_resource_before(@one, @two, @three)
+
+      expect(@catalog.resources).to eq([@two, @three, @one])
+    end
+
+    it "raises if adding a resource before a resource not in the catalog" do
+      expect {
+        @catalog.add_resource_before(@one, @two)
+      }.to raise_error(ArgumentError, "Cannot add resource Notify[two] before Notify[one] because Notify[one] is not yet in the catalog")
+    end
+
+    it "adds resources after an existing resource in reverse order" do
+      @catalog.add_resource(@one)
+      @catalog.add_resource_after(@one, @two, @three)
+
+      expect(@catalog.resources).to eq([@one, @three, @two])
+    end
+
+    it "raises if adding a resource after a resource not in the catalog" do
+      expect {
+        @catalog.add_resource_after(@one, @two)
+      }.to raise_error(ArgumentError, "Cannot add resource Notify[two] after Notify[one] because Notify[one] is not yet in the catalog")
+    end
+
     describe 'with a duplicate resource' do
       def resource_at(type, name, file, line)
         resource = Puppet::Resource.new(type, name)
@@ -651,7 +720,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should only write when it is a host catalog" do
-      File.expects(:open).with(@file).never
+      Puppet::FileSystem.expects(:open).with(@file, 0640, "w:UTF-8").never
       @catalog.host_config = false
       Puppet[:graph] = true
       @catalog.write_graph(@name)
@@ -750,6 +819,11 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
     expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
 
+  it "should validate a single sensitive parameter resource catalog against the schema" do
+    catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present','content'=>Sensitive('hunter2')}})")
+    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
+  end
+
   it "should validate a two resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
     expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
@@ -770,6 +844,138 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
     MANIFEST
     expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
+
+  context 'when dealing with parameters that have non-Data values' do
+    context 'and rich_data is enabled' do
+      before(:each) do
+        Puppet[:rich_data] = true
+      end
+
+      after(:each) do
+        Puppet[:rich_data] = false
+      end
+
+
+      let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
+
+      it 'should generate ext_parameters for parameter values that are not Data' do
+        expect(catalog_w_regexp.to_json).to include('"ext_parameters":{"message":[[48,"[a-z]+"]]}')
+      end
+
+      it 'should validate ext_parameters against the schema' do
+        expect(catalog_w_regexp.to_json).to validate_against('api/schemas/catalog.json')
+      end
+
+      it 'should read and convert ext_parameters containing Regexp from json' do
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog_w_regexp.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Regexp)
+        expect(message).to eql(/[a-z]+/)
+      end
+
+      it 'should read and convert ext_parameters containing Version from json' do
+        catalog = compile_to_catalog("notify {'foo': message => SemVer('1.0.0') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(SemanticPuppet::Version)
+        expect(message).to eql(SemanticPuppet::Version.parse('1.0.0'))
+      end
+
+      it 'should read and convert ext_parameters containing VersionRange from json' do
+        catalog = compile_to_catalog("notify {'foo': message => SemVerRange('>=1.0.0') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(SemanticPuppet::VersionRange)
+        expect(message).to eql(SemanticPuppet::VersionRange.parse('>=1.0.0'))
+      end
+
+      it 'should read and convert ext_parameters containing Timespan from json' do
+        catalog = compile_to_catalog("notify {'foo': message => Timespan(1234) }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Puppet::Pops::Time::Timespan)
+        expect(message).to eql(Puppet::Pops::Time::Timespan.parse('1234', '%S'))
+      end
+
+      it 'should read and convert ext_parameters containing Timestamp from json' do
+        catalog = compile_to_catalog("notify {'foo': message => Timestamp('2016-09-15T08:32:16.123 UTC') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Puppet::Pops::Time::Timestamp)
+        expect(message).to eql(Puppet::Pops::Time::Timestamp.parse('2016-09-15T08:32:16.123 UTC'))
+      end
+
+      it 'should read and convert ext_parameters containing hash with rich data from json' do
+        catalog = compile_to_catalog("notify {'foo': message => { 'version' => SemVer('1.0.0'), 'time' => Timestamp('2016-09-15T08:32:16.123 UTC') }}")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Hash)
+        expect(message['version']).to eql(SemanticPuppet::Version.parse('1.0.0'))
+        expect(message['time']).to eql(Puppet::Pops::Time::Timestamp.parse('2016-09-15T08:32:16.123 UTC'))
+      end
+
+      it 'should read and convert ext_parameters containing an array with rich data from json' do
+        catalog = compile_to_catalog("notify {'foo': message => [ SemVer('1.0.0'), Timestamp('2016-09-15T08:32:16.123 UTC') ] }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Array)
+        expect(message[0]).to eql(SemanticPuppet::Version.parse('1.0.0'))
+        expect(message[1]).to eql(Puppet::Pops::Time::Timestamp.parse('2016-09-15T08:32:16.123 UTC'))
+      end
+    end
+
+    context 'and rich_data is disabled' do
+      before(:each) do
+        Puppet[:rich_data] = false
+      end
+
+      let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
+
+      it 'should not generate ext_parameters for parameter values that are not Data' do
+        expect(catalog_w_regexp.to_json).not_to include('"ext_parameters":{"message":[48,"[a-z]+"]}')
+      end
+
+      it 'should convert parameter containing Regexp into strings' do
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog_w_regexp.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('/[a-z]+/')
+      end
+
+      it 'should convert parameter containing Version into string' do
+        catalog = compile_to_catalog("notify {'foo': message => SemVer('1.0.0') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('1.0.0')
+      end
+
+      it 'should convert parameter containing VersionRange into string' do
+        catalog = compile_to_catalog("notify {'foo': message => SemVerRange('>=1.0.0') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('>=1.0.0')
+      end
+
+      it 'should convert parameter containing Timespan into string' do
+        catalog = compile_to_catalog("notify {'foo': message => Timespan(1234) }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('0-00:20:34.0')
+      end
+
+      it 'should convert parameter containing Timestamp into string' do
+        catalog = compile_to_catalog("notify {'foo': message => Timestamp('2016-09-15T08:32:16.123 UTC') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('2016-09-15T08:32:16.123 UTC')
+      end
+    end
+
+  end
 end
 
 describe Puppet::Resource::Catalog, "when converting to pson" do
@@ -777,17 +983,25 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
     @catalog = Puppet::Resource::Catalog.new("myhost")
   end
 
-  def pson_output_should
-    @catalog.class.expects(:from_data_hash).with { |hash| yield hash }.returns(:something)
+  { :name => 'myhost',
+    :version => 42,
+    :code_id => 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe',
+    :catalog_uuid => '827a74c8-cf98-44da-9ff7-18c5e4bee41e',
+    :catalog_format => 42
+  }.each do |param, value|
+    it "emits a #{param} equal to #{value.inspect}" do
+      @catalog.send(param.to_s + "=", value)
+      pson = PSON.parse(@catalog.to_pson)
+
+      expect(pson[param.to_s]).to eq(@catalog.send(param))
+    end
   end
 
-  [:name, :version, :classes].each do |param|
-    it "should set its #{param} to the #{param} of the resource" do
-      @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
+  it "emits an array of classes" do
+    @catalog.add_class('foo')
+    pson = PSON.parse(@catalog.to_pson)
 
-      pson_output_should { |hash| expect(hash[param.to_s]).to eq(@catalog.send(param)) }
-      Puppet::Resource::Catalog.from_data_hash PSON.parse @catalog.to_pson
-    end
+    expect(pson['classes']).to eq(['foo'])
   end
 
   it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
@@ -826,6 +1040,9 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
 
   it "should create it with the provided name" do
     @data['version'] = 50
+    @data['code_id'] = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+    @data['catalog_uuid'] = '827a74c8-cf98-44da-9ff7-18c5e4bee41e'
+    @data['catalog_format'] = 42
     @data['tags'] = %w{one two}
     @data['classes'] = %w{one two}
     @data['edges'] = [Puppet::Relationship.new("File[/foo]", "File[/bar]",
@@ -839,6 +1056,9 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
 
     expect(catalog.name).to eq('myhost')
     expect(catalog.version).to eq(@data['version'])
+    expect(catalog.code_id).to eq(@data['code_id'])
+    expect(catalog.catalog_uuid).to eq(@data['catalog_uuid'])
+    expect(catalog.catalog_format).to eq(@data['catalog_format'])
     expect(catalog).to be_tagged("one")
     expect(catalog).to be_tagged("two")
 
@@ -850,6 +1070,11 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
     expect(catalog.edges[0].target).to eq(catalog.resource(:file, "/bar"))
   end
 
+  it "defaults the catalog_format to 0" do
+    catalog = Puppet::Resource::Catalog.from_data_hash PSON.parse @data.to_pson
+    expect(catalog.catalog_format).to eq(0)
+  end
+
   it "should fail if the source resource cannot be found" do
     @data['edges'] = [Puppet::Relationship.new("File[/missing]", "File[/bar]").to_data_hash]
     @data['resources'] = [Puppet::Resource.new(:file, "/bar").to_data_hash]

data/spec/unit/resource/type_collection_spec.rb

@@ -76,16 +76,18 @@ describe Puppet::Resource::TypeCollection do
     end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
-  it "should remove all nodes, classes, and definitions when cleared" do
+  it "should remove all nodes, classes, definitions, and applications when cleared" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
+    loader.add Puppet::Resource::Type.new(:application, "application")
 
     loader.clear
     expect(loader.hostclass("class")).to be_nil
     expect(loader.definition("define")).to be_nil
     expect(loader.node("node")).to be_nil
+    expect(loader.node("application")).to be_nil
   end
 
   describe "when looking up names" do
@@ -153,7 +155,8 @@ describe Puppet::Resource::TypeCollection do
     end
   end
 
-  %w{hostclass node definition}.each do |data|
+  KINDS = %w{hostclass node definition application}
+  KINDS.each do |data|
     describe "behavior of add for #{data}" do
 
       it "should return the added #{data}" do
@@ -175,6 +178,24 @@ describe Puppet::Resource::TypeCollection do
       it "should return nil when asked for a #{data} that has not been added" do
         expect(Puppet::Resource::TypeCollection.new(environment).send(data, "foo")).to be_nil
       end
+
+      if data != "node"
+        it "should fail if an application with the same name is added" do
+          loader = Puppet::Resource::TypeCollection.new(environment)
+          instance = Puppet::Resource::Type.new(data, "foo")
+          application = Puppet::Resource::Type.new(:application, "foo")
+          loader.add(instance)
+          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
+        end
+
+        it "should fail if there is an application with the same name" do
+          loader = Puppet::Resource::TypeCollection.new(environment)
+          application = Puppet::Resource::Type.new(:application, "foo")
+          instance = Puppet::Resource::Type.new(data, "foo")
+          loader.add(instance)
+          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
+        end
+      end
     end
   end
 

data/spec/unit/resource/type_spec.rb

@@ -240,9 +240,26 @@ describe Puppet::Resource::Type do
   end
 
   describe "when setting its parameters in the scope" do
+    let(:parser) { Puppet::Pops::Parser::Parser.new() }
+
+    def wrap3x(expression)
+      Puppet::Parser::AST::PopsBridge::Expression.new(:value => expression.current)
+    end
+
+    def parse_expression(expr_string)
+      wrap3x(parser.parse_string(expr_string))
+    end
+
+    def number_expression(number)
+      wrap3x(Puppet::Pops::Model::Factory.NUMBER(number))
+    end
+
     def variable_expression(name)
-      varexpr = Puppet::Pops::Model::Factory.QNAME(name).var().current
-      Puppet::Parser::AST::PopsBridge::Expression.new(:value => varexpr)
+      wrap3x(Puppet::Pops::Model::Factory.QNAME(name).var())
+    end
+
+    def matchref_expression(number)
+      wrap3x(Puppet::Pops::Model::Factory.NUMBER(number).var())
     end
 
     before do
@@ -272,6 +289,143 @@ describe Puppet::Resource::Type do
       expect(@scope['foo']).to eq('foobar')
     end
 
+    context 'referencing a variable to the left of the default expression' do
+      it 'is possible when the referenced variable uses a default' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(10)
+        expect(@scope['second']).to eq(10)
+      end
+
+      it 'is possible when the referenced variable is given a value' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @resource[:first] = 2
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(2)
+        expect(@scope['second']).to eq(2)
+      end
+
+      it 'is possible when the referenced variable is an array produced by match function' do
+        @type.set_arguments({
+          :first => parse_expression("'hello'.match(/(h)(.*)/)"),
+          :second => parse_expression('$first[0]'),
+          :third => parse_expression('$first[1]')
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(['hello', 'h', 'ello'])
+        expect(@scope['second']).to eq('hello')
+        expect(@scope['third']).to eq('h')
+      end
+
+      it 'fails when the referenced variable is unassigned' do
+        @type.set_arguments({
+          :first => nil,
+          :second => variable_expression('first'),
+        })
+        expect { @type.set_resource_parameters(@resource, @scope) }.to raise_error(
+          Puppet::Error, 'Foo[bar]: expects a value for parameter $first')
+      end
+
+      it 'does not clobber a given value' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @resource[:first] = 2
+        @resource[:second] = 5
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(2)
+        expect(@scope['second']).to eq(5)
+      end
+    end
+
+    context 'referencing a variable to the right of the default expression' do
+      before :each do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('third'),
+          :third => number_expression(20)
+        })
+      end
+
+      it 'no error is raised when no defaults are evaluated' do
+        @resource[:first] = 1
+        @resource[:second] = 2
+        @resource[:third] = 3
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(1)
+        expect(@scope['second']).to eq(2)
+        expect(@scope['third']).to eq(3)
+      end
+
+      it 'no error is raised unless the referencing default expression is evaluated' do
+        @resource[:second] = 2
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(10)
+        expect(@scope['second']).to eq(2)
+        expect(@scope['third']).to eq(20)
+      end
+
+      it 'fails when the default expression is evaluated' do
+        @resource[:first] = 1
+        expect { @type.set_resource_parameters(@resource, @scope) }.to raise_error(Puppet::Error, 'Foo[bar]: default expression for $second tries to illegally access not yet evaluated $third')
+      end
+    end
+
+    it 'does not allow a variable to be referenced from its own default expression' do
+      @type.set_arguments({
+        :first => variable_expression('first')
+      })
+      expect { @type.set_resource_parameters(@resource, @scope) }.to raise_error(Puppet::Error, 'Foo[bar]: default expression for $first tries to illegally access not yet evaluated $first')
+    end
+
+    context 'when using match scope' do
+      it '$n evaluates to undef at the top level' do
+        @type.set_arguments({
+          :first => matchref_expression('0'),
+          :second => matchref_expression('1'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope).not_to include('first')
+        expect(@scope).not_to include('second')
+      end
+
+      it 'a match scope to the left of a parameter is not visible to it' do
+        @type.set_arguments({
+          :first => parse_expression("['hello' =~ /(h)(.*)/, $1, $2]"),
+          :second => matchref_expression('1'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq([true, 'h', 'ello'])
+        expect(@scope['second']).to be_nil
+      end
+
+      it 'match scopes nests per parameter' do
+        @type.set_arguments({
+          :first => parse_expression("['hi' =~ /(h)(.*)/, $1, if 'foo' =~ /f(oo)/ { $1 }, $1, $2]"),
+          :second => matchref_expression('0'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq([true, 'h', 'oo', 'h', 'i'])
+        expect(@scope['second']).to be_nil
+      end
+    end
+
     it "should set each of the resource's parameters as variables in the scope" do
       @type.set_arguments :foo => nil, :boo => nil
       @resource[:foo] = "bar"
@@ -432,10 +586,9 @@ describe Puppet::Resource::Type do
       @scope.expects(:newscope).with(:source => @type, :namespace => '', :resource => @resource).returns subscope
 
       elevel = 876
-      subscope.expects(:ephemeral_level).returns elevel
+      subscope.expects(:with_guarded_scope).yields
       subscope.expects(:ephemeral_from).with(match, nil, nil).returns subscope
       code.expects(:safeevaluate).with(subscope)
-      subscope.expects(:unset_ephemeral_var).with(elevel)
 
       # Just to keep the stub quiet about intermediate calls
       @type.expects(:set_resource_parameters).with(@resource, subscope)
@@ -484,9 +637,7 @@ describe Puppet::Resource::Type do
     it "should evaluate the AST code if any is provided" do
       code = stub 'code'
       @type.stubs(:code).returns code
-      subscope = stub_everything("subscope", :compiler => @compiler)
-      @scope.stubs(:newscope).returns subscope
-      code.expects(:safeevaluate).with subscope
+      code.expects(:safeevaluate).with kind_of(Puppet::Parser::Scope)
 
       @type.evaluate_code(@resource)
     end
@@ -505,7 +656,7 @@ describe Puppet::Resource::Type do
 
         @compiler.add_resource @scope, @parent_resource
 
-        @type.resource_type_collection = @scope.known_resource_types
+        @type.resource_type_collection = @scope.environment.known_resource_types
         @type.resource_type_collection.add @parent_type
       end
 
@@ -545,7 +696,7 @@ describe Puppet::Resource::Type do
 
         @compiler.add_resource @scope, @parent_resource
 
-        @type.resource_type_collection = @scope.known_resource_types
+        @type.resource_type_collection = @scope.environment.known_resource_types
         @type.resource_type_collection.add(@parent_type)
       end
 
@@ -766,7 +917,7 @@ describe Puppet::Resource::Type do
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
 
       dest.merge(source)
-      expect(dest.code.children.collect { |l| l.children[0].value }).to eq(%w{dest source})
+      expect(dest.code.children.map { |c| c.value }).to eq(%w{dest source})
     end
   end
 end