puppet 6.0.0 → 6.0.1

data/man/man5/puppet.conf.5

@@ -891,7 +891,7 @@ The time to wait for data to be read from an HTTP connection\. If nothing is rea
 The HTTP User\-Agent string to send when making network requests\.
 .
 .IP "\(bu" 4
-\fIDefault\fR: Puppet/6\.0\.0 Ruby/2\.4\.1\-p111 (x86_64\-linux)
+\fIDefault\fR: Puppet/6\.0\.1 Ruby/2\.4\.1\-p111 (x86_64\-linux)
 .
 .IP "" 0
 .
@@ -1683,6 +1683,17 @@ Where puppet agent and puppet master store state associated with the running con
 .
 .IP "" 0
 .
+.SS "statettl"
+How long the Puppet agent should cache when a resource was last checked or synced\. This setting can be a time interval in seconds (30 or 30s), minutes (30m), hours (6h), days (2d), or years (5y)\. A value of \fB0\fR or \fBunlimited\fR will disable cache pruning\.
+.
+.P
+This setting affects the usage of \fBschedule\fR resources, as the information about when a resource was last checked (and therefore when it needs to be checked again) is stored in the \fBstatefile\fR\. The \fBstatettl\fR needs to be large enough to ensure that a resource will not trigger multiple times during a schedule due to its entry expiring from the cache\.
+.
+.IP "\(bu" 4
+\fIDefault\fR: 32d
+.
+.IP "" 0
+.
 .SS "static_catalogs"
 Whether to compile a static catalog \fIhttps://puppet\.com/docs/puppet/latest/static_catalogs\.html#enabling\-or\-disabling\-static\-catalogs\fR, which occurs only on a Puppet Server master when the \fBcode\-id\-command\fR and \fBcode\-content\-command\fR settings are configured in its \fBpuppetserver\.conf\fR file\.
 .

data/man/man8/puppet.8

@@ -25,4 +25,4 @@ Specialized:
 catalog Compile, save, view, and convert catalogs\. describe Display help about resource types device Manage remote network devices doc Generate Puppet references epp Interact directly with the EPP template parser/renderer\. facts Retrieve and store facts\. filebucket Store and retrieve files in a filebucket generate Generates Puppet code from Ruby definitions\. node View and manage node definitions\. parser Interact directly with the parser\. script Run a puppet manifests as a script without compiling a catalog ssl Manage SSL keys and certificates for puppet SSL clients
 .
 .P
-See \'puppet help \fIsubcommand\fR \fIaction\fR\' for help on a specific subcommand action\. See \'puppet help \fIsubcommand\fR\' for help on a specific subcommand\. Puppet v6\.0\.0
+See \'puppet help \fIsubcommand\fR \fIaction\fR\' for help on a specific subcommand action\. See \'puppet help \fIsubcommand\fR\' for help on a specific subcommand\. Puppet v6\.0\.1

data/spec/integration/application/apply_spec.rb

@@ -518,7 +518,10 @@ class amod::bad_type {
         apply.options[:catalog] = file_containing('manifest', serialized_catalog)
         apply.expects(:apply_catalog).with do |cat|
           expect(cat.resource(:notify, 'rx')['message']).to be_a(Regexp)
-          expect(cat.resource(:notify, 'bin')['message']).to be_a(Puppet::Pops::Types::PBinaryType::Binary)
+          # The resource return in this expect is a String, but since it was a Binary type that
+          # was converted with `resolve_and_replace`, we want to make sure that the encoding
+          # of that string is the expected ASCII-8BIT.
+          expect(cat.resource(:notify, 'bin')['message'].encoding.inspect).to include('ASCII-8BIT')
           expect(cat.resource(:notify, 'ver')['message']).to be_a(SemanticPuppet::Version)
           expect(cat.resource(:notify, 'vrange')['message']).to be_a(SemanticPuppet::VersionRange)
           expect(cat.resource(:notify, 'tspan')['message']).to be_a(Puppet::Pops::Time::Timespan)

data/spec/integration/util/windows/adsi_spec.rb

@@ -118,7 +118,8 @@ describe Puppet::Util::Windows::ADSI::Group,
         # create a test group and add above 5 members by SID
         group = described_class.create(temp_groupname)
         group.commit()
-        group.set_members(users.map { |u| u[:sid]} )
+        members = users.map { |u| u[:sid] }
+        group.set_members(members.join(','))
 
         # most importantly make sure that all name are convertible to SIDs
         expect { described_class.name_sid_hash(group.members) }.to_not raise_error

data/spec/unit/application/apply_spec.rb

@@ -279,6 +279,11 @@ describe Puppet::Application::Apply do
         expect { @apply.main }.to exit_with 0
       end
 
+      it 'should called the DeferredResolver to resolve any Deferred values' do
+        Puppet::Pops::Evaluator::DeferredResolver.expects(:resolve_and_replace).with(any_parameters)
+        expect { @apply.main }.to exit_with 0
+      end
+
       it 'should make the Puppet::Pops::Loaders available when applying the compiled catalog' do
         Puppet::Resource::Catalog.indirection.expects(:find).returns(@catalog)
         @apply.expects(:apply_catalog).with(@catalog) do
@@ -475,6 +480,15 @@ describe Puppet::Application::Apply do
         end
         expect { @apply.apply }.not_to raise_error
       end
+
+      it "should call the DeferredResolver to resolve Deferred values" do
+        @apply.options[:catalog] = temporary_catalog
+        Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
+        catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
+        Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'"something"').returns(catalog)
+        Puppet::Pops::Evaluator::DeferredResolver.expects(:resolve_and_replace).with(any_parameters)
+        @apply.apply
+      end
     end
   end
 

data/spec/unit/configurer_spec.rb

@@ -1019,6 +1019,17 @@ describe Puppet::Configurer do
       expect(options[:report].master_used).to eq('myserver:123')
     end
 
+    it "queries the simple status for the 'master' service" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      response = Net::HTTPOK.new(nil, 200, 'OK')
+      http = mock('request')
+      http.expects(:get).with('/status/v1/simple/master').returns(response)
+      Puppet::Network::HttpPool.stubs(:http_ssl_instance).with('myserver', '123').returns(http)
+      @agent.stubs(:run_internal)
+
+      @agent.run
+    end
+
     it "should report when a server is unavailable" do
       Puppet.settings[:server_list] = ["myserver:123"]
       response = Net::HTTPInternalServerError.new(nil, 500, 'Internal Server Error')

data/spec/unit/etc_spec.rb

@@ -412,6 +412,31 @@ describe Puppet::Etc, :if => !Puppet::Util::Platform.windows? do
     end
   end
 
+  describe :group do
+    it 'should return the next group struct if a block is not provided' do
+      Puppet::Etc.expects(:getgrent).returns(ascii_group_struct)
+
+      expect(Puppet::Etc.group).to eql(ascii_group_struct)
+    end
+
+    it 'should iterate over the available groups if a block is provided' do
+      expected_groups = [
+        utf_8_group_struct,
+        euc_kr_group_struct,
+        ascii_group_struct
+      ]
+      Puppet::Etc.stubs(:getgrent).returns(*(expected_groups + [nil]))
+
+      Puppet::Etc.expects(:setgrent)
+      Puppet::Etc.expects(:endgrent)
+
+      actual_groups = []
+      Puppet::Etc.group { |group| actual_groups << group }
+
+      expect(actual_groups).to eql(expected_groups)
+    end
+  end
+
   describe "endgrent" do
     it "should call Etc.getgrent" do
       Etc.expects(:getgrent)

data/spec/unit/indirector/catalog/json_spec.rb

@@ -17,8 +17,9 @@ describe Puppet::Resource::Catalog::Json do
     let(:binary) { "\xC0\xFF".force_encoding(Encoding::BINARY) }
     let(:key)    { 'foo' }
     let(:file)   { subject.path(key) }
+    let(:env)    { Puppet::Node::Environment.create(:testing, []) }
     let(:catalog) do
-      catalog = Puppet::Resource::Catalog.new(key, Puppet::Node::Environment.create(:testing, []))
+      catalog = Puppet::Resource::Catalog.new(key, env)
       catalog.add_resource(Puppet::Resource.new(:file, '/tmp/a_file', :parameters => { :content => binary }))
       catalog
     end
@@ -27,6 +28,11 @@ describe Puppet::Resource::Catalog::Json do
       Puppet.run_mode.stubs(:master?).returns(true)
       Puppet[:server_datadir] = tmpdir('jsondir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
+      Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
+    end
+
+    after :each do
+      Puppet.pop_context()
     end
 
     it 'saves a catalog containing binary content' do
@@ -43,7 +49,7 @@ describe Puppet::Resource::Catalog::Json do
       parsed_catalog = subject.find(request)
 
       content = parsed_catalog.resource(:file, '/tmp/a_file')[:content]
-      expect(content.bytes.to_a).to eq(binary.bytes.to_a)
+      expect(content.binary_buffer.bytes.to_a).to eq(binary.bytes.to_a)
     end
 
     it 'searches for catalogs contains binary content' do
@@ -55,7 +61,7 @@ describe Puppet::Resource::Catalog::Json do
 
       expect(parsed_catalogs.size).to eq(1)
       content = parsed_catalogs.first.resource(:file, '/tmp/a_file')[:content]
-      expect(content.bytes.to_a).to eq(binary.bytes.to_a)
+      expect(content.binary_buffer.bytes.to_a).to eq(binary.bytes.to_a)
     end
   end
 end

data/spec/unit/pops/evaluator/runtime3_converter_spec.rb

@@ -30,22 +30,40 @@ describe 'when converting to 3.x' do
     expect(converter.convert(v, {}, nil)).to equal(v)
   end
 
-  it 'converts the symbol :undef to the undef value' do
+  it 'converts top level symbol :undef to the given undef value' do
     expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
   end
 
-  it 'converts the nil to the undef value' do
+  it 'converts top level nil value to the given undef value' do
     expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
   end
 
-  it 'convert a symbol nested in an array' do
-    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => 'undef value'})
+  it 'converts nested :undef in a hash to nil' do
+    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => nil})
+  end
+
+  it 'converts nested :undef in an array to nil' do
+    expect(converter.convert(['boo', :undef], {}, 'undef value')).to eql(['boo', nil])
+  end
+
+  it 'converts deeply nested :undef in to nil' do
+    expect(converter.convert({'foo' => [[:undef]], 'bar' => { 'x' => :undef }}, {}, 'undef value')).to eql({'foo' => [[nil]], 'bar' => { 'x' => nil}})
   end
 
   it 'does not converts nil to given undef value when nested in an array' do
     expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => nil})
   end
 
+  it 'does not convert top level symbols' do
+    expect(converter.convert(:default, {}, 'undef value')).to eql(:default)
+    expect(converter.convert(:whatever, {}, 'undef value')).to eql(:whatever)
+  end
+
+  it 'does not convert nested symbols' do
+    expect(converter.convert([:default], {}, 'undef value')).to eql([:default])
+    expect(converter.convert([:whatever], {}, 'undef value')).to eql([:whatever])
+  end
+
   it 'does not convert a Regex instance to string' do
     v = /^[A-Z]$/
     expect(converter.convert(v, {}, nil)).to equal(v)

data/spec/unit/pops/loaders/loader_spec.rb

@@ -329,13 +329,6 @@ describe 'The Loader' do
               'bad_syntax.json' => <<-TXT.unindent,
                 text => This is not a task because JSON is unparsable
                 TXT
-              'bad_content.sh' => '',
-              'bad_content.json' => <<-JSON.unindent,
-                {
-                  "description": "This is not a task because parameters is misspelled",
-                  "paramters": { "string_param": { "type": "String[1]" } }
-                }
-                JSON
               'missing_adjacent.json' => <<-JSON.unindent,
                 {
                   "description": "This is not a task because there is no adjacent file with the same base name",
@@ -415,7 +408,7 @@ describe 'The Loader' do
                   contain_exactly(tn(:task, 'c::foo')))
               end
               expect(logs.select { |log| log.level == :warning }.map { |log| log.message }).to(
-                contain_exactly(/unexpected token/, /unrecognized key/, /No source besides task metadata was found/)
+                contain_exactly(/unexpected token/, /No source besides task metadata was found/)
               )
             end
 
@@ -427,11 +420,11 @@ describe 'The Loader' do
                   contain_exactly(tn(:task, 'c::foo')))
               end
               expect(logs.select { |log| log.level == :warning }.map { |log| log.message }).to be_empty
-              expect(error_collector.size).to eql(3)
+              expect(error_collector.size).to eql(2)
               expect(error_collector.all? { |e| e.is_a?(Puppet::DataTypes::Error) })
               expect(error_collector.all? { |e| e.issue_code == Puppet::Pops::Issues::LOADER_FAILURE.issue_code })
               expect(error_collector.map { |e| e.details['original_error'] }).to(
-                contain_exactly(/unexpected token/, /unrecognized key/, /No source besides task metadata was found/)
+                contain_exactly(/unexpected token/, /No source besides task metadata was found/)
               )
             end
 

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -420,6 +420,36 @@ describe 'loaders' do
       function = loader.load_typed(typed_name(:function, 'user::caller_ws')).value
       expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'passed in scope'")
     end
+
+  end
+
+  context 'when causing a 3x load followed by a 4x load' do
+    let(:env) { environment_for(mix_4x_and_3x_functions) }
+    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
+    let(:scope) { compiler.topscope }
+    let(:loader) { compiler.loaders.private_loader_for_module('user') }
+
+
+    before(:each) do
+      Puppet.push_context(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders)
+    end
+    after(:each) do
+      Puppet.pop_context
+    end
+
+    it 'a 3x function is loaded once' do
+      # create a 3x function that when called will do a load of "callee_ws"
+      Puppet::Parser::Functions::newfunction(:callee, :type => :rvalue, :arity => 1) do |args|
+        function_callee_ws(['passed in scope'])
+      end
+      Puppet.expects(:warning).with(any_parameters).never
+      scope['passed_in_scope'] = 'value'
+      function = loader.load_typed(typed_name(:function, 'callee')).value
+      expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")
+
+      function = loader.load_typed(typed_name(:function, 'callee_ws')).value
+      expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")
+    end
   end
 
   context 'loading' do

data/spec/unit/pops/loaders/module_loaders_spec.rb

@@ -104,8 +104,8 @@ describe 'FileBased module loader' do
 
       task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
       expect(task.name).to eq('testmodule::foo')
-      expect(task.implementations.length).to eq(1)
-      expect(task.implementations[0]['name']).to eq('foo.py')
+      expect(task.files.length).to eq(1)
+      expect(task.files[0]['name']).to eq('foo.py')
     end
 
     it 'can load tasks with multiple implementations' do
@@ -116,7 +116,7 @@ describe 'FileBased module loader' do
 
       task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
       expect(task.name).to eq('testmodule::foo')
-      expect(task.implementations.map {|impl| impl['name']}).to eq(['foo.py', 'foo.ps1'])
+      expect(task.files.map {|impl| impl['name']}).to eq(['foo.py', 'foo.ps1'])
     end
 
     it 'can load multiple tasks with multiple files' do
@@ -128,11 +128,11 @@ describe 'FileBased module loader' do
       foobar_task = module_loader.load_typed(typed_name(:task, 'testmodule::foobar')).value
 
       expect(foo_task.name).to eq('testmodule::foo')
-      expect(foo_task.implementations.length).to eq(1)
-      expect(foo_task.implementations[0]['name']).to eq('foo.py')
+      expect(foo_task.files.length).to eq(1)
+      expect(foo_task.files[0]['name']).to eq('foo.py')
       expect(foobar_task.name).to eq('testmodule::foobar')
-      expect(foobar_task.implementations.length).to eq(1)
-      expect(foobar_task.implementations[0]['name']).to eq('foobar.py')
+      expect(foobar_task.files.length).to eq(1)
+      expect(foobar_task.files[0]['name']).to eq('foobar.py')
     end
 
     it "won't load tasks with invalid names" do

data/spec/unit/pops/parser/parse_heredoc_spec.rb

@@ -140,6 +140,22 @@ describe "egrammar parsing heredoc" do
     ].join("\n"))
   end
 
+  it "parses interpolated [] expression by looking at the correct preceding char for space" do
+    # NOTE: Important not to use the left margin feature here
+    src = <<-CODE
+$xxxxxxx = @("END")
+${facts['os']['family']}
+XXXXXXX XXX
+END
+CODE
+    expect(dump(parse(src))).to eq([
+      "(= $xxxxxxx (@()",
+      "  (sublocated (cat (str (slice (slice $facts 'os') 'family')) '",
+      "XXXXXXX XXX",
+      "'))",
+      "))"].join("\n"))
+  end
+
   it 'parses multiple heredocs on the same line' do
     src = <<-CODE
     notice({ @(foo) => @(bar) })

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -153,6 +153,15 @@ module Serialization
       expect(val2).to eql(val)
     end
 
+    it 'ACII_8BIT String as Binary' do
+      val = Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+      strval = val.binary_buffer
+      write(strval)
+      val2 = read
+      expect(val2).to be_a(Types::PBinaryType::Binary)
+      expect(val2).to eql(val)
+    end
+
     it 'URI' do
       val = URI('http://bob:ewing@dallas.example.com:8080/oil/baron?crude=cash#leftovers')
       write(val)

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

@@ -143,13 +143,12 @@ describe 'The Task Type' do
             expect(task_t.instance?(task)).to be_truthy
             expect(task.name).to eq('testmodule::hello')
             expect(task._pcore_type).to eq(task_t)
-            expect(task.supports_noop).to eql(true)
-            expect(task.puppet_task_version).to eql(1)
-            expect(task.implementations).to eql([{"name" => "hello.rb", "path" => "#{modules_dir}/testmodule/tasks/hello.rb", "requirements" => []}])
+            expect(task.metadata['supports_noop']).to eql(true)
+            expect(task.metadata['puppet_task_version']).to eql(1)
+            expect(task.files).to eql([{"name" => "hello.rb", "path" => "#{modules_dir}/testmodule/tasks/hello.rb"}])
 
-            tp = task.parameters
-            expect(tp['message']['description']).to eql('the message')
-            expect(tp['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+            expect(task.metadata['parameters']['message']['description']).to eql('the message')
+            expect(task.parameters['message']).to be_a(Puppet::Pops::Types::PStringType)
           end
         end
 
@@ -157,8 +156,7 @@ describe 'The Task Type' do
           compile do
             task = module_loader.load(:task, 'testmodule::non_data')
             expect(task_t.instance?(task)).to be_truthy
-            tp = task.parameters
-            expect(tp['arg']['type']).to be_a(Puppet::Pops::Types::PHashType)
+            expect(task.parameters['arg']).to be_a(Puppet::Pops::Types::PHashType)
           end
         end
 
@@ -173,7 +171,9 @@ describe 'The Task Type' do
 
           it 'fails to load the task' do
             compile do
-              expect { module_loader.load(:task, 'testmodule') }.to raise_error(ArgumentError, /No source besides task metadata was found/)
+              expect {
+                module_loader.load(:task, 'testmodule')
+              }.to raise_error(Puppet::Module::Task::InvalidTask, /No source besides task metadata was found/)
             end
           end
         end
@@ -192,7 +192,9 @@ describe 'The Task Type' do
 
           it "fails if metadata doesn't specify implementations" do
             compile do
-              expect { module_loader.load(:task, 'testmodule') }.to raise_error(ArgumentError, /Multiple executables were found .*/)
+              expect {
+                module_loader.load(:task, 'testmodule')
+              }.to raise_error(Puppet::Module::Task::InvalidTask, /Multiple executables were found .*/)
             end
           end
 
@@ -204,9 +206,13 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([
-                {"name" => "init.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh", "requirements" => ['shell']},
-                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1", "requirements" => ['powershell']}
+              expect(task.files).to eql([
+                {"name" => "init.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh"},
+                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1"}
+              ])
+              expect(task.metadata['implementations']).to eql([
+                {"name" => "init.sh", "requirements" => ['shell']},
+                {"name" => "init.ps1", "requirements" => ['powershell']}
               ])
             end
           end
@@ -218,21 +224,11 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([
-                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1", "requirements" => ['powershell']}
+              expect(task.files).to eql([
+                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1"}
               ])
-            end
-          end
-
-          it "adds an empty requirements list if one is not specified" do
-            impls = [{'name' => 'init.ps1'}]
-            metadata.replace({'implementations' => impls}.to_json)
-
-            compile do
-              task = module_loader.load(:task, 'testmodule')
-              expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([
-                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1", "requirements" => []}
+              expect(task.metadata['implementations']).to eql([
+                {"name" => "init.ps1", "requirements" => ['powershell']}
               ])
             end
           end
@@ -244,7 +240,9 @@ describe 'The Task Type' do
             metadata.replace({'implementations' => impls}.to_json)
 
             compile do
-              expect { module_loader.load(:task, 'testmodule') }.to raise_error(ArgumentError, /Task metadata for task testmodule specifies missing implementation init\.rb/)
+              expect {
+                module_loader.load(:task, 'testmodule')
+              }.to raise_error(Puppet::Module::Task::InvalidTask, /Task metadata for task testmodule specifies missing implementation init\.rb/)
             end
           end
 
@@ -252,7 +250,9 @@ describe 'The Task Type' do
             metadata.replace({'implementations' => {'init.rb' => []}}.to_json)
 
             compile do
-              expect { module_loader.load(:task, 'testmodule') }.to raise_error(Puppet::ParseError, /Task initializer has wrong type/)
+              expect {
+                module_loader.load(:task, 'testmodule')
+              }.to raise_error(Puppet::Module::Task::InvalidMetadata, /Task metadata for task testmodule does not specify implementations as an array/)
             end
           end
         end
@@ -283,16 +283,18 @@ describe 'The Task Type' do
 
             compile do
               task = module_loader.load(:task, 'testmodule::bar')
-              expect(task.implementations).to eql([
-                {'name' => 'foo.sh', 'path' => "#{modules_dir}/testmodule/tasks/foo.sh", 'requirements' => ['shell']},
-                {'name' => 'foo.ps1', 'path' => "#{modules_dir}/testmodule/tasks/foo.ps1", 'requirements' => ['powershell']},
+              expect(task.files).to eql([
+                {'name' => 'foo.sh', 'path' => "#{modules_dir}/testmodule/tasks/foo.sh"},
+                {'name' => 'foo.ps1', 'path' => "#{modules_dir}/testmodule/tasks/foo.ps1"},
               ])
             end
           end
 
           it 'fails to load the task if it has no implementations section and no associated executables' do
             compile do
-              expect { module_loader.load(:task, 'testmodule::bar') }.to raise_error(ArgumentError, /No source besides task metadata was found/)
+              expect {
+                module_loader.load(:task, 'testmodule::bar')
+              }.to raise_error(Puppet::Module::Task::InvalidTask, /No source besides task metadata was found/)
             end
           end
 
@@ -327,9 +329,9 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([{"name" => "init.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh", "requirements" => []}])
-              expect(task.parameters).to be_a(Hash)
-              expect(task.parameters['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+              expect(task.files).to eql([{"name" => "init.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh"}])
+              expect(task.metadata['parameters']).to be_a(Hash)
+              expect(task.parameters['message']).to be_a(Puppet::Pops::Types::PStringType)
             end
           end
         end
@@ -358,9 +360,9 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule::hello')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.implementations).to eql([{"name" => "hello.sh", "path" => "#{modules_dir}/testmodule/tasks/hello.sh", "requirements" => []}])
-              expect(task.parameters).to be_a(Hash)
-              expect(task.parameters['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+              expect(task.files).to eql([{"name" => "hello.sh", "path" => "#{modules_dir}/testmodule/tasks/hello.sh"}])
+              expect(task.metadata['parameters']).to be_a(Hash)
+              expect(task.parameters['message']).to be_a(Puppet::Pops::Types::PStringType)
             end
           end
         end
@@ -383,31 +385,6 @@ describe 'The Task Type' do
           end
         end
 
-        context 'that has a malformed top-level entry' do
-          let(:testmodule) {
-            {
-              'tasks' => {
-                'hello' => 'echo hello',
-                'hello.json' => <<-JSON
-                {
-                  "supports_nop": true,
-                  "parameters": {
-                     "message": { "type": "String" }
-                  }
-                }
-              JSON
-              }
-            }
-          }
-
-          it 'fails with unrecognized key error' do
-            compile do
-              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
-                /Failed to load metadata for task testmodule::hello:.*unrecognized key 'supports_nop'/)
-            end
-          end
-        end
-
         context 'that has no parameters' do
           let(:testmodule) {
             {
@@ -421,58 +398,7 @@ describe 'The Task Type' do
             compile do
               task = module_loader.load(:task, 'testmodule::hello')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.parameters).to be_nil
-            end
-          end
-        end
-
-        context 'that has a malformed parameter name' do
-          let(:testmodule) {
-            {
-              'tasks' => {
-                'hello' => 'echo hello',
-                'hello.json' => <<-JSON
-                {
-                  "supports_noop": true,
-                  "parameters": {
-                     "Message": { "type": "String" }
-                  }
-                }
-              JSON
-              }
-            }
-          }
-
-          it 'fails with pattern mismatch error' do
-            compile do
-              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
-                /entry 'parameters' key of entry 'Message' expects a match for Pattern\[\/\\A\[a-z\]\[a-z0-9_\]\*\\z\/\], got 'Message'/)
-            end
-          end
-        end
-
-        context 'that has a puppet_task_version that is a string' do
-          let(:testmodule) {
-            {
-              'tasks' => {
-                'hello' => 'echo hello',
-                'hello.json' => <<-JSON
-                {
-                  "puppet_task_version": "1",
-                  "supports_noop": true,
-                  "parameters": {
-                     "message": { "type": "String" }
-                  }
-                }
-              JSON
-              }
-            }
-          }
-
-          it 'fails with type mismatch error' do
-            compile do
-              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
-                /entry 'puppet_task_version' expects an Integer value, got String/)
+              expect(task.metadata['parameters']).to be_nil
             end
           end
         end