puppet 6.0.0 → 6.1.0

data/spec/unit/provider/user/hpux_spec.rb

@@ -1,10 +1,8 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 require 'etc'
 
-provider_class = Puppet::Type.type(:user).provider(:hpuxuseradd)
-
-describe provider_class, :unless => Puppet::Util::Platform.windows? do
+describe Puppet::Type.type(:user).provider(:hpuxuseradd),
+         unless: Puppet::Util::Platform.windows? do
   let :resource do
     Puppet::Type.type(:user).new(
       :title => 'testuser',
@@ -39,7 +37,7 @@ describe provider_class, :unless => Puppet::Util::Platform.windows? do
     end
 
     it "should have feature manages_passwords" do
-      expect(provider_class).to be_manages_passwords
+      expect(described_class).to be_manages_passwords
     end
 
     it "should return nil if user does not exist" do

data/spec/unit/provider/user/ldap_spec.rb

@@ -1,27 +1,24 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:user).provider(:ldap)
-
-describe provider_class do
+describe Puppet::Type.type(:user).provider(:ldap) do
   it "should have the Ldap provider class as its baseclass" do
-    expect(provider_class.superclass).to equal(Puppet::Provider::Ldap)
+    expect(described_class.superclass).to equal(Puppet::Provider::Ldap)
   end
 
   it "should manage :posixAccount and :person objectclasses" do
-    expect(provider_class.manager.objectclasses).to eq([:posixAccount, :person])
+    expect(described_class.manager.objectclasses).to eq([:posixAccount, :person])
   end
 
   it "should use 'ou=People' as its relative base" do
-    expect(provider_class.manager.location).to eq("ou=People")
+    expect(described_class.manager.location).to eq("ou=People")
   end
 
   it "should use :uid as its rdn" do
-    expect(provider_class.manager.rdn).to eq(:uid)
+    expect(described_class.manager.rdn).to eq(:uid)
   end
 
   it "should be able to manage passwords" do
-    expect(provider_class).to be_manages_passwords
+    expect(described_class).to be_manages_passwords
   end
 
   {:name => "uid",
@@ -33,15 +30,15 @@ describe provider_class do
     :shell => "loginShell"
   }.each do |puppet, ldap|
     it "should map :#{puppet.to_s} to '#{ldap}'" do
-      expect(provider_class.manager.ldap_name(puppet)).to eq(ldap)
+      expect(described_class.manager.ldap_name(puppet)).to eq(ldap)
     end
   end
 
-  describe "when being created" do
+  context "when being created" do
     before do
       # So we don't try to actually talk to ldap
       @connection = mock 'connection'
-      provider_class.manager.stubs(:connect).yields @connection
+      described_class.manager.stubs(:connect).yields @connection
     end
 
     it "should generate the sn as the last field of the cn" do
@@ -50,7 +47,7 @@ describe provider_class do
       resource = stub 'resource', :should => %w{whatever}
       resource.stubs(:should).with(:comment).returns ["Luke Kanies"]
       resource.stubs(:should).with(:ensure).returns :present
-      instance = provider_class.new(:name => "luke", :ensure => :absent)
+      instance = described_class.new(:name => "luke", :ensure => :absent)
 
       instance.stubs(:resource).returns resource
 
@@ -66,7 +63,7 @@ describe provider_class do
       resource = stub 'resource', :should => %w{whatever}
       resource.stubs(:should).with(:gid).returns 'bar'
       resource.stubs(:should).with(:ensure).returns :present
-      instance = provider_class.new(:name => "luke", :ensure => :absent)
+      instance = described_class.new(:name => "luke", :ensure => :absent)
       instance.stubs(:resource).returns resource
 
       @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["101"] }
@@ -75,18 +72,18 @@ describe provider_class do
       instance.flush
     end
 
-    describe "with no uid specified" do
+    context "with no uid specified" do
       it "should pick the first available UID after the largest existing UID" do
         Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with(["whatever"]).returns [123]
 
         low = {:name=>["luke"], :shell=>:absent, :uid=>["600"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["l k"]}
         high = {:name=>["testing"], :shell=>:absent, :uid=>["640"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["t u"]}
-        provider_class.manager.expects(:search).returns([low, high])
+        described_class.manager.expects(:search).returns([low, high])
 
         resource = stub 'resource', :should => %w{whatever}
         resource.stubs(:should).with(:uid).returns nil
         resource.stubs(:should).with(:ensure).returns :present
-        instance = provider_class.new(:name => "luke", :ensure => :absent)
+        instance = described_class.new(:name => "luke", :ensure => :absent)
         instance.stubs(:resource).returns resource
 
         @connection.expects(:add).with { |dn, attrs| attrs["uidNumber"] == ["641"] }
@@ -98,12 +95,12 @@ describe provider_class do
       it "should pick 501 of no users exist" do
         Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with(["whatever"]).returns [123]
 
-        provider_class.manager.expects(:search).returns nil
+        described_class.manager.expects(:search).returns nil
 
         resource = stub 'resource', :should => %w{whatever}
         resource.stubs(:should).with(:uid).returns nil
         resource.stubs(:should).with(:ensure).returns :present
-        instance = provider_class.new(:name => "luke", :ensure => :absent)
+        instance = described_class.new(:name => "luke", :ensure => :absent)
         instance.stubs(:resource).returns resource
 
         @connection.expects(:add).with { |dn, attrs| attrs["uidNumber"] == ["501"] }
@@ -114,11 +111,11 @@ describe provider_class do
     end
   end
 
-  describe "when flushing" do
+  context "when flushing" do
     before do
-      provider_class.stubs(:suitable?).returns true
+      described_class.stubs(:suitable?).returns true
 
-      @instance = provider_class.new(:name => "myname", :groups => %w{whatever}, :uid => "400")
+      @instance = described_class.new(:name => "myname", :groups => %w{whatever}, :uid => "400")
     end
 
     it "should remove the :groups value before updating" do
@@ -144,13 +141,13 @@ describe provider_class do
     end
   end
 
-  describe "when checking group membership" do
+  context "when checking group membership" do
     before do
       @groups = Puppet::Type.type(:group).provider(:ldap)
       @group_manager = @groups.manager
-      provider_class.stubs(:suitable?).returns true
+      described_class.stubs(:suitable?).returns true
 
-      @instance = provider_class.new(:name => "myname")
+      @instance = described_class.new(:name => "myname")
     end
 
     it "should show its group membership as the sorted list of all groups returned by an ldap query of group memberships" do
@@ -175,11 +172,11 @@ describe provider_class do
     end
   end
 
-  describe "when modifying group membership" do
+  context "when modifying group membership" do
     before do
       @groups = Puppet::Type.type(:group).provider(:ldap)
       @group_manager = @groups.manager
-      provider_class.stubs(:suitable?).returns true
+      described_class.stubs(:suitable?).returns true
 
       @one = {:name => "one", :gid => "500"}
       @group_manager.stubs(:find).with("one").returns(@one)
@@ -187,7 +184,7 @@ describe provider_class do
       @two = {:name => "one", :gid => "600"}
       @group_manager.stubs(:find).with("two").returns(@two)
 
-      @instance = provider_class.new(:name => "myname")
+      @instance = described_class.new(:name => "myname")
 
       @instance.stubs(:groups).returns :absent
     end
@@ -231,7 +228,7 @@ describe provider_class do
       @instance.groups = "one"
     end
 
-    describe "for groups that have no members" do
+    context "for groups that have no members" do
       it "should create a new members attribute with its value being the user's name" do
         @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{myname} }
 
@@ -239,7 +236,7 @@ describe provider_class do
       end
     end
 
-    describe "for groups it is being removed from" do
+    context "for groups it is being removed from" do
       it "should replace the group's member list with one missing the user's name" do
         @one[:members] = %w{myname a}
         @two[:members] = %w{myname b}
@@ -261,7 +258,7 @@ describe provider_class do
       end
     end
 
-    describe "for groups that already have members" do
+    context "for groups that already have members" do
       it "should replace each group's member list with a new list including the user's name" do
         @one[:members] = %w{a b}
         @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{a b myname} }
@@ -272,7 +269,7 @@ describe provider_class do
       end
     end
 
-    describe "for groups of which it is a member" do
+    context "for groups of which it is a member" do
       it "should do nothing" do
         @one[:members] = %w{a b}
         @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{a b myname} }

data/spec/unit/provider/user/pw_spec.rb

@@ -1,14 +1,11 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:user).provider(:pw)
-
-describe provider_class do
+describe Puppet::Type.type(:user).provider(:pw) do
   let :resource do
     Puppet::Type.type(:user).new(:name => "testuser", :provider => :pw)
   end
 
-  describe "when creating users" do
+  context "when creating users" do
     let :provider do
       prov = resource.provider
       prov.expects(:exists?).returns nil
@@ -16,8 +13,8 @@ describe provider_class do
     end
 
     it "should run pw with no additional flags when no properties are given" do
-      expect(provider.addcmd).to eq([provider_class.command(:pw), "useradd", "testuser"])
-      provider.expects(:execute).with([provider_class.command(:pw), "useradd", "testuser"], kind_of(Hash))
+      expect(provider.addcmd).to eq([described_class.command(:pw), "useradd", "testuser"])
+      provider.expects(:execute).with([described_class.command(:pw), "useradd", "testuser"], kind_of(Hash))
       provider.create
     end
 
@@ -104,12 +101,12 @@ describe provider_class do
     end
   end
 
-  describe "when deleting users" do
+  context "when deleting users" do
     it "should run pw with no additional flags" do
       provider = resource.provider
       provider.expects(:exists?).returns true
-      expect(provider.deletecmd).to eq([provider_class.command(:pw), "userdel", "testuser"])
-      provider.expects(:execute).with([provider_class.command(:pw), "userdel", "testuser"], has_entry(:custom_environment, {}))
+      expect(provider.deletecmd).to eq([described_class.command(:pw), "userdel", "testuser"])
+      provider.expects(:execute).with([described_class.command(:pw), "userdel", "testuser"], has_entry(:custom_environment, {}))
       provider.delete
     end
 
@@ -133,14 +130,14 @@ describe provider_class do
     end
   end
 
-  describe "when modifying users" do
+  context "when modifying users" do
     let :provider do
       resource.provider
     end
 
     it "should run pw with the correct arguments" do
-      expect(provider.modifycmd("uid", 12345)).to eq([provider_class.command(:pw), "usermod", "testuser", "-u", 12345])
-      provider.expects(:execute).with([provider_class.command(:pw), "usermod", "testuser", "-u", 12345], has_entry(:custom_environment, {}))
+      expect(provider.modifycmd("uid", 12345)).to eq([described_class.command(:pw), "usermod", "testuser", "-u", 12345])
+      provider.expects(:execute).with([described_class.command(:pw), "usermod", "testuser", "-u", 12345], has_entry(:custom_environment, {}))
       provider.uid = 12345
     end
 

data/spec/unit/provider/user/useradd_spec.rb

@@ -138,10 +138,10 @@ describe Puppet::Type.type(:user).provider(:useradd) do
         provider.create
       end
 
-      it "should not use -e with luseradd, should call lusermod with -e after luseradd when expiry is set" do
+      it "should not use -e with luseradd, should call usermod with -e after luseradd when expiry is set" do
         resource[:expiry] = '2038-01-24'
         provider.expects(:execute).with(all_of(includes('/usr/sbin/luseradd'), Not(includes('-e'))), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
-        provider.expects(:execute).with(all_of(includes('/usr/sbin/lusermod'), includes('-e')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        provider.expects(:execute).with(all_of(includes('/usr/sbin/usermod'), includes('-e')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 

data/spec/unit/provider/user/windows_adsi_spec.rb

@@ -218,6 +218,9 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
     end
 
     it "should set a user's password" do
+      provider.user.expects(:disabled?).returns(false)
+      provider.user.expects(:locked_out?).returns(false)
+      provider.user.expects(:expired?).returns(false)
       provider.user.expects(:password=).with('plaintextbad')
 
       provider.password = "plaintextbad"
@@ -259,10 +262,7 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::
       connection.expects(:Put).with('UserFlags', true)
       connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
 
-      expect{ provider.create }.to raise_error(
-        Puppet::Error,
-        /not able to create\/delete domain users/
-      )
+      expect{ provider.create }.to raise_error(Puppet::Error)
     end
   end
 

data/spec/unit/puppet_pal_2pec.rb

@@ -767,13 +767,13 @@ describe 'Puppet Pal' do
               [ signature.runnable_with?('string_param' => 'foo', 'int_param' => 10),
                 signature.runnable_with?('anything_goes' => 'foo'),
                 signature.task_hash['name'],
-                signature.task_hash['parameters']['string_param']['description'],
-                signature.task.description,
-                signature.task.parameters['int_param']['type'],
+                signature.task_hash['metadata']['parameters']['string_param']['description'],
+                signature.task_hash['metadata']['description'],
+                signature.task_hash['metadata']['parameters']['int_param']['type'],
               ]
             end
           end
-          expect(result).to eq([true, false, 'b::atask', 'A string parameter', 'test task b::atask', Puppet::Pops::Types::PIntegerType::DEFAULT])
+          expect(result).to eq([true, false, 'b::atask', 'A string parameter', 'test task b::atask', 'Integer'])
         end
 
         it '"TaskSignature#runnable_with?" calls a given lambda if there is an error' do
@@ -802,7 +802,7 @@ describe 'Puppet Pal' do
               signature.task_hash
             end
           end
-          expect(result['input_method']).to be_nil
+          expect(result['metadata']['input_method']).to be_nil
         end
 
         it 'task input_method is parsed from task metadata' do
@@ -812,7 +812,7 @@ describe 'Puppet Pal' do
               signature.task_hash
             end
           end
-          expect(result['input_method']).to eq('stdin')
+          expect(result['metadata']['input_method']).to eq('stdin')
         end
 
         it '"list_tasks" returns an array with all tasks that can be loaded' do

data/spec/unit/puppet_pal_catalog_spec.rb

@@ -463,6 +463,64 @@ describe 'Puppet Pal' do
         end.to raise_error(/does not represent a literal value/)
       end
 
+      it 'the "evaluate" method evaluates but does not evaluate lazy constructs' do
+        result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+          ctx.with_catalog_compiler do |c|
+            c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: }'))
+            c.with_json_encoding() {|encoder| encoder.encode }
+          end
+        end
+        parsed = JSON.parse(result)
+        expect(parsed['resources']).to_not include(include('type' => 'Notify'))
+      end
+
+      it 'an "evaluate" followed by "compile_additions" evaluates lazy constructs' do
+        result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+          ctx.with_catalog_compiler do |c|
+            c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: }'))
+            c.compile_additions
+            c.with_json_encoding() {|encoder| encoder.encode }
+          end
+        end
+        parsed = JSON.parse(result)
+        expect(parsed['resources']).to include(include('type' => 'Notify'))
+      end
+
+      it 'an "evaluate" followed by "compile_additions" validates the result' do
+        expect do
+          Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+            ctx.with_catalog_compiler do |c|
+              c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: before =>"Bar[nope]"}'))
+              c.compile_additions
+            end
+          end
+        end.to raise_error(Puppet::Error, /Could not find resource 'Bar\[nope\]'/)
+      end
+
+      it 'an "evaluate" followed by "evaluate_additions" does not validate the result' do
+        result = Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+          ctx.with_catalog_compiler do |c|
+            c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: before =>"Bar[nope]"}'))
+            c.evaluate_additions
+            c.with_json_encoding() {|encoder| encoder.encode }
+          end
+        end
+        parsed = JSON.parse(result)
+        expect(parsed['resources']).to include(include('type' => 'Notify'))
+      end
+
+      it 'an "evaluate" followed by "evaluate_additions" and "validate" validates the result' do
+        expect do
+          Puppet::Pal.in_tmp_environment('pal_env', modulepath: modulepath, facts: node_facts) do | ctx|
+            ctx.with_catalog_compiler do |c|
+              c.evaluate(c.parse_string('define foo() { notify {nope: }} foo { test: before =>"Bar[nope]"}'))
+              c.compile_additions
+              c.validate
+            end
+          end
+        end.to raise_error(Puppet::Error, /Could not find resource 'Bar\[nope\]'/)
+      end
+
     end
   end
 

data/spec/unit/resource/catalog_spec.rb

@@ -48,8 +48,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
     catalog.add_resource(res, res2, res3, res4, comp_res)
     catalog.write_resource_file
     expect(File.readlines(resourcefile).map(&:chomp)).to match_array([
-      "file[#{File.expand_path('/tmp/sam')}]",
-      "exec[#{File.expand_path('/bin/rm')} -rf /]"
+      "file[#{res.title.downcase}]",
+      "exec[#{res2.title.downcase}]"
     ])
   end
 

data/spec/unit/resource_spec.rb

@@ -1082,6 +1082,18 @@ describe Puppet::Resource do
         newparam(:admits_to_age)
         newparam(:name)
       end
+
+      Puppet::Type.newtype('brown') do
+        newproperty(:ensure)
+        newparam(:admits_to_dying_hair)
+        newparam(:admits_to_age)
+        newparam(:hair_length)
+        newparam(:name)
+
+        def self.parameters_to_include
+          [:admits_to_dying_hair, :admits_to_age]
+        end
+      end
     end
 
     it "should strip all parameters and strip properties that are nil, empty or absent except for ensure" do
@@ -1124,5 +1136,24 @@ describe Puppet::Resource do
       })
       )
     end
+
+    context "when the resource type has a default set of parameters it wants to include" do
+      it "should leave those parameters alone" do
+        resource = Puppet::Resource.new("brown", "Esmeralda", :parameters => {
+          :admits_to_age        => true,
+          :admits_to_dying_hair => false,
+          :hair_length          => 10
+        })
+
+        pruned_resource = resource.prune_parameters
+        expected_resource = Puppet::Resource.new(
+          "brown",
+          "Esmeralda",
+          :parameters => { :admits_to_age => true, :admits_to_dying_hair => false }
+        )
+  
+        expect(pruned_resource).to eq(expected_resource)
+      end
+    end
   end
 end

data/spec/unit/ssl/host_spec.rb

@@ -155,6 +155,27 @@ describe Puppet::SSL::Host, if: !Puppet::Util::Platform.jruby? do
     expect{ host.validate_certificate_with_key(certificate) }.not_to raise_error
   end
 
+  it "should output agent-specific commands when validation fails" do
+    host = Puppet::SSL::Host.new("foo")
+    key = mock 'key', :content => "private_key"
+    sslcert = mock 'sslcert'
+    certificate = mock 'cert', {:content => sslcert, :fingerprint => 'DEADBEEF'}
+    host.stubs(:key).returns key
+    sslcert.expects(:check_private_key).with("private_key").returns false
+    expect { host.validate_certificate_with_key(certificate) }.to raise_error(Puppet::Error, /puppet ssl clean \n/)
+  end
+
+  it "should output device-specific commands when validation fails" do
+    Puppet[:certname] = "device.example.com"
+    host = Puppet::SSL::Host.new("device.example.com", true)
+    key = mock 'key', :content => "private_key"
+    sslcert = mock 'sslcert'
+    certificate = mock 'cert', {:content => sslcert, :fingerprint => 'DEADBEEF'}
+    host.stubs(:key).returns key
+    sslcert.expects(:check_private_key).with("private_key").returns false
+    expect { host.validate_certificate_with_key(certificate) }.to raise_error(Puppet::Error, /puppet ssl clean --target device.example.com/)
+  end
+
   describe "when initializing" do
     it "should default its name to the :certname setting" do
       Puppet[:certname] = "myname"
@@ -601,7 +622,7 @@ describe Puppet::SSL::Host, if: !Puppet::Util::Platform.jruby? do
       @host.stubs(:generate)
       @host.stubs(:sleep)
 
-      Puppet.expects(:err)
+      Puppet.expects(:log_exception)
 
       @host.wait_for_cert(1)
     end

data/spec/unit/ssl/key_spec.rb

@@ -114,8 +114,8 @@ describe Puppet::SSL::Key do
     end
 
     it "should create the private key with the keylength specified in the settings" do
-      Puppet[:keylength] = "50"
-      OpenSSL::PKey::RSA.expects(:new).with(50).returns(@key)
+      Puppet[:keylength] = 513
+      OpenSSL::PKey::RSA.expects(:new).with(513).returns(@key)
 
       @instance.generate
     end
@@ -157,8 +157,6 @@ describe Puppet::SSL::Key do
       end
 
       it "should export the private key to text using the password" do
-        Puppet[:keylength] = "50"
-
         @instance.password_file = "/path/to/pass"
         @instance.stubs(:password).returns "my password"
 

data/spec/unit/task_spec.rb

@@ -68,8 +68,7 @@ describe Puppet::Module::Task do
     task_files = %w{task1.elf task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
     Dir.expects(:glob).with(tasks_glob).returns(task_files)
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' =>
-    [{"name" => "task1.sh"}]})
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh"}]})
 
     expect(tasks.count).to eq(1)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
@@ -77,6 +76,52 @@ describe Puppet::Module::Task do
     expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh"]])
   end
 
+  it "constructs a task as expected when task metadata declares additional files" do
+    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
+    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    Puppet::Module::Task.expects(:find_extra_files).returns([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
+    tasks = Puppet::Module::Task.tasks_in_module(mymod)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'files' => ["mymod/lib/file0.elf"]})
+
+    expect(tasks.count).to eq(1)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
+    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
+    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh", "/path/to/file0.elf"]])
+  end
+
+  it "constructs a task as expected when a task implementation declares additional files" do
+    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
+    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    Puppet::Module::Task.expects(:find_extra_files).returns([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
+    tasks = Puppet::Module::Task.tasks_in_module(mymod)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
+
+    expect(tasks.count).to eq(1)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
+    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
+    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh", "/path/to/file0.elf"]])
+  end
+
+  it "constructs a task as expected when task metadata and a task implementation both declare additional files" do
+    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
+    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    Puppet::Module::Task.expects(:find_extra_files).returns([
+      {'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"},
+      {'name' => 'yourmod/files/file1.txt', 'path' => "/other/path/to/file1.txt"}
+    ])
+    tasks = Puppet::Module::Task.tasks_in_module(mymod)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
+
+    expect(tasks.count).to eq(1)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
+    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
+    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([[
+      "#{tasks_path}/task1.sh",
+      "/path/to/file0.elf",
+      "/other/path/to/file1.txt"
+    ]])
+  end
+
   it "constructs a task as expected when a task has files" do
     og_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
     Dir.expects(:glob).with(tasks_glob).returns(og_files)
@@ -136,7 +181,7 @@ describe Puppet::Module::Task do
     it "loads metadata for a task" do
       metadata  = {'desciption': 'some info'}
       Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task1.json})
-      Puppet::Module::Task.any_instance.stubs(:read_metadata).returns(metadata)
+      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
@@ -180,7 +225,7 @@ describe Puppet::Module::Task do
       metadata  = {'desciption' => 'some info',
         'implementations' => [ {"name" => "task1.exe"}, ] }
       Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task1.sh task1.json})
-      Puppet::Module::Task.any_instance.stubs(:read_metadata).returns(metadata)
+      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
@@ -192,7 +237,7 @@ describe Puppet::Module::Task do
       metadata  = {'desciption' => 'some info',
                    'implementations' => [ {"name" => "task2.sh"}, ] }
       Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe task2.sh task1.json})
-      Puppet::Module::Task.any_instance.stubs(:read_metadata).returns(metadata)
+      Puppet::Module::Task.stubs(:read_metadata).returns(metadata)
 
       tasks = Puppet::Module::Task.tasks_in_module(mymod)
 

data/spec/unit/transaction/event_manager_spec.rb

@@ -174,11 +174,22 @@ describe Puppet::Transaction::EventManager do
       expect(@transaction.resource_status(@resource)).to be_restarted
     end
 
+    it "should have an event on the resource status" do
+      @manager.expects(:queued_events).with(@resource).yields(:callback1, [@event])
+
+      @resource.stubs(:callback1)
+
+      @manager.process_events(@resource) #x
+
+      expect(@transaction.resource_status(@resource).events.length).to eq(1)
+    end
+
     it "should queue a 'restarted' event generated by the resource" do
       @manager.expects(:queued_events).with(@resource).yields(:callback1, [@event])
 
       @resource.stubs(:callback1)
 
+      @resource.expects(:event).with(:message => "Triggered 'callback1' from 1 event", :status => 'success', :name => 'callback1')
       @resource.expects(:event).with(:name => :restarted, :status => "success").returns "myevent"
       @manager.expects(:queue_events).with(@resource, ["myevent"])
 
@@ -295,7 +306,7 @@ describe Puppet::Transaction::EventManager do
       it "should record a failed event on the resource status" do
         @manager.process_events(@resource)
 
-        expect(@transaction.resource_status(@resource).events.length).to eq(1)
+        expect(@transaction.resource_status(@resource).events.length).to eq(2)
         expect(@transaction.resource_status(@resource).events[0].status).to eq('failure')
       end