puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

data/spec/unit/task_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/modules'
@@ -8,8 +9,11 @@ describe Puppet::Module::Task do
 
   let(:modpath) { tmpdir('task_modpath') }
   let(:mymodpath) { File.join(modpath, 'mymod') }
+  let(:othermodpath) { File.join(modpath, 'othermod') }
   let(:mymod) { Puppet::Module.new('mymod', mymodpath, nil) }
+  let(:othermod) { Puppet::Module.new('othermod', othermodpath, nil) }
   let(:tasks_path) { File.join(mymodpath, 'tasks') }
+  let(:other_tasks_path) { File.join(othermodpath, 'tasks') }
   let(:tasks_glob) { File.join(mymodpath, 'tasks', '*') }
 
   it "cannot construct tasks with illegal names" do
@@ -18,61 +22,90 @@ describe Puppet::Module::Task do
                       "Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
   end
 
-  it "cannot construct tasks whose files are outside of their module's tasks directory" do
-    outside_file = "/var/root/secret_tasks/classified"
-    expect { Puppet::Module::Task.new(mymod, "fail", [outside_file]) }
-      .to raise_error(Puppet::Module::Task::InvalidFile,
-                     "The file '#{outside_file}' is not located in the mymod module's tasks directory")
-  end
-
   it "constructs tasks as expected when every task has a metadata file with the same name (besides extension)" do
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.json task1 task2.json task2.exe task3.json task3.sh})
+    task_files = %w{task1.json task1 task2.json task2.exe task3.json task3.sh}.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({})
 
     expect(tasks.count).to eq(3)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1 mymod::task2 mymod::task3})
     expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json",
                                                   "#{tasks_path}/task2.json",
                                                   "#{tasks_path}/task3.json"])
-    expect(tasks.map{|t| t.files}).to eq([["#{tasks_path}/task1"],
-                                          ["#{tasks_path}/task2.exe"],
-                                          ["#{tasks_path}/task3.sh"]])
+    expect(tasks.map{|t| t.files.map { |f| f["path"] } }).to eq([["#{tasks_path}/task1"],
+                                                                 ["#{tasks_path}/task2.exe"],
+                                                                 ["#{tasks_path}/task3.sh"]])
+    expect(tasks.map{|t| t.files.map { |f| f["name"] } }).to eq([["task1"],
+                                                                 ["task2.exe"],
+                                                                 ["task3.sh"]])
 
     tasks.map{|t| t.metadata_file}.each do |metadata_file|
       expect(metadata_file).to eq(File.absolute_path(metadata_file))
     end
 
-    tasks.map{|t| t.files}.each do |task_files|
-      task_file = task_files[0]
-      expect(task_file).to eq(File.absolute_path(task_file))
+    tasks.map{|t| t.files}.each do |file_data|
+      path = file_data[0]['path']
+      expect(path).to eq(File.absolute_path(path))
     end
   end
 
   it "constructs tasks as expected when some tasks don't have a metadata file" do
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1 task2.exe task3.json task3.sh})
+    task_files = %w{task1 task2.exe task3.json task3.sh}.map { |bn| "#{tasks_path}/#{bn}" }
+    Dir.expects(:glob).with(tasks_glob).returns(task_files)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({})
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
     expect(tasks.count).to eq(3)
     expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1 mymod::task2 mymod::task3})
     expect(tasks.map{|t| t.metadata_file}).to eq([nil, nil, "#{tasks_path}/task3.json"])
-    expect(tasks.map{|t| t.files}).to eq([["#{tasks_path}/task1"],
+    expect(tasks.map{|t| t.files.map { |f| f["path"] } }).to eq([["#{tasks_path}/task1"],
                                           ["#{tasks_path}/task2.exe"],
                                           ["#{tasks_path}/task3.sh"]])
   end
 
-  it "constructs tasks as expected when a task has multiple executable files" do
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task1.elf task1.exe task1.json task2.ps1 task2.sh})
+  it "constructs a task as expected when a task has implementations" 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"}]})
+
+    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"]])
+  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)
+    File.expects(:exist?).with(any_parameters).returns(true).at_least(1)
+
+    Puppet::Module.expects(:find).with(othermod.name, "production").returns(othermod).at_least(1)
+    short_files = %w{other_task.sh other_task.json task_2.sh}.map { |bn| "#{othermod.name}/tasks/#{bn}" }
+    long_files = %w{other_task.sh other_task.json task_2.sh}.map { |bn| "#{other_tasks_path}/#{bn}" }
+    tasks = Puppet::Module::Task.tasks_in_module(mymod)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'files' => short_files})
+
+    expect(tasks.count).to eq(1)
+    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh"] + long_files])
+  end
+
+  it "fails to load a task if its metadata specifies a non-existent file" do
+    og_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
+    Dir.stubs(:glob).with(tasks_glob).returns(og_files)
+    File.stubs(:exist?).with(any_parameters).returns(true)
+
+    Puppet::Module.expects(:find).with(othermod.name, "production").returns(nil).at_least(1)
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
+    Puppet::Module::Task.any_instance.stubs(:metadata).returns({'files' => ["#{othermod.name}/files/test"]})
 
-    expect(tasks.count).to eq(2)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1 mymod::task2})
-    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json", nil])
-    expect(tasks.map{|t| t.files}).to eq([["#{tasks_path}/task1.elf", "#{tasks_path}/task1.exe"],
-                                          ["#{tasks_path}/task2.ps1", "#{tasks_path}/task2.sh"]])
+    expect { tasks.first.files }.to raise_error(Puppet::Module::Task::InvalidMetadata, /Could not find module #{othermod.name} containing task file test/)
   end
 
   it "finds files whose names (besides extensions) are valid task names" do
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{task task_1 xx_t_a_s_k_2_xx})
+    Dir.expects(:glob).with(tasks_glob).returns(%w{task task_1 xx_t_a_s_k_2_xx})
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
     expect(tasks.count).to eq(3)
@@ -80,7 +113,7 @@ describe Puppet::Module::Task do
   end
 
   it "ignores files that have names (besides extensions) that are not valid task names" do
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{.nottask.exe .wat !runme _task 2task2furious def_a_task_PSYCH Fake_task not-a-task realtask})
+    Dir.expects(:glob).with(tasks_glob).returns(%w{.nottask.exe .wat !runme _task 2task2furious def_a_task_PSYCH Fake_task not-a-task realtask})
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
     expect(tasks.count).to eq(1)
@@ -88,7 +121,7 @@ describe Puppet::Module::Task do
   end
 
   it "ignores files that have names ending in .conf and .md" do
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(%w{ginuwine_task task.conf readme.md other_task.md})
+    Dir.expects(:glob).with(tasks_glob).returns(%w{ginuwine_task task.conf readme.md other_task.md})
     tasks = Puppet::Module::Task.tasks_in_module(mymod)
 
     expect(tasks.count).to eq(1)
@@ -98,4 +131,117 @@ describe Puppet::Module::Task do
   it "gives the 'init' task a name that is just the module's name" do
     expect(Puppet::Module::Task.new(mymod, 'init', ["#{tasks_path}/init.sh"]).name).to eq('mymod')
   end
+
+  describe :metadata 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)
+
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+
+      expect(tasks.count).to eq(1)
+      expect(tasks[0].metadata).to eq(metadata)
+    end
+
+    it 'returns nil for metadata if no file is present' do
+      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe})
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+
+      expect(tasks.count).to eq(1)
+      expect(tasks[0].metadata).to be_nil
+    end
+
+    it 'raises InvalidMetadata if the json metadata is invalid' do
+      FileUtils.mkdir_p(tasks_path)
+      File.open(File.join(tasks_path, 'task.json'), 'w') { |f| f.write '{ "whoops"' }
+      FileUtils.touch(File.join(tasks_path, 'task'))
+
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+      expect(tasks.count).to eq(1)
+
+      expect {
+        tasks[0].metadata
+      }.to raise_error(Puppet::Module::Task::InvalidMetadata, /whoops/)
+    end
+  end
+
+  describe :validate do
+    it "validates when there is no metadata" do
+      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.exe})
+
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+
+      expect(tasks.count).to eq(1)
+      expect(tasks[0].validate).to eq(true)
+    end
+
+    it "validates when an implementation isn't used" 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)
+
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+
+      expect(tasks.count).to eq(1)
+      expect(tasks[0].validate).to be(true)
+    end
+
+    it "validates when an implementation is another 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)
+
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+
+      expect(tasks.count).to eq(2)
+      expect(tasks.map(&:validate)).to eq([true, true])
+    end
+
+    it "fails validation when there is no metadata and multiple task files" do
+      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.elf task1.exe task1.json task2.ps1 task2.sh})
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+      Puppet::Module::Task.any_instance.stubs(:metadata).returns({})
+
+      tasks.each do |task|
+        expect {task.validate}.to raise_error(Puppet::Module::Task::InvalidTask)
+      end
+    end
+
+    it "fails validation when an implementation references a non-existant file" do
+      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.elf task1.exe task1.json})
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+      Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [ { 'name' => 'task1.sh' } ] })
+
+      tasks.each do |task|
+        expect {task.validate}.to raise_error(Puppet::Module::Task::InvalidTask)
+      end
+    end
+
+    it 'fails validation when there is metadata but no executable' do
+      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.json task2.sh})
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+      Puppet::Module::Task.any_instance.stubs(:metadata).returns({})
+
+      expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
+    end
+
+    it 'fails validation when the implementations are not an array' do
+      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.json task2.sh})
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+      Puppet::Module::Task.any_instance.stubs(:metadata).returns({"implemenations" => {}})
+
+      expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
+    end
+
+    it 'fails validation when the implementation is json' do
+      Dir.expects(:glob).with(tasks_glob).returns(%w{task1.json task1.sh})
+      tasks = Puppet::Module::Task.tasks_in_module(mymod)
+      Puppet::Module::Task.any_instance.stubs(:metadata).returns({'implementations' => [ { 'name' => 'task1.json' } ] })
+
+      expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
+    end
+  end
 end

data/spec/unit/transaction/additional_resource_generator_spec.rb

@@ -17,95 +17,94 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
   let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
   before(:each) do
-    allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
-  end
-
-  around :each do |example|
-    Puppet.override(:loaders => loaders, :current_environment => env) do
-      Puppet::Type.newtype(:generator) do
-        include PuppetSpec::Compiler
+    Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+    Puppet.push_context({:loaders => loaders, :current_environment => env})
+    Puppet::Type.newtype(:generator) do
+      include PuppetSpec::Compiler
 
-        newparam(:name) do
-          isnamevar
-        end
+      newparam(:name) do
+        isnamevar
+      end
 
-        newparam(:kind) do
-          defaultto :eval_generate
-          newvalues(:eval_generate, :generate)
-        end
+      newparam(:kind) do
+        defaultto :eval_generate
+        newvalues(:eval_generate, :generate)
+      end
 
-        newparam(:code)
+      newparam(:code)
 
-        def respond_to?(method_name)
-          method_name == self[:kind] || super
-        end
+      def respond_to?(method_name)
+        method_name == self[:kind] || super
+      end
 
-        def eval_generate
-          eval_code
-        end
+      def eval_generate
+        eval_code
+      end
 
-        def generate
-          eval_code
-        end
+      def generate
+        eval_code
+      end
 
-        def eval_code
-          if self[:code]
-            compile_to_ral(self[:code]).resources.select { |r| r.ref =~ /Notify/ }
-          else
-            []
-          end
+      def eval_code
+        if self[:code]
+          compile_to_ral(self[:code]).resources.select { |r| r.ref =~ /Notify/ }
+        else
+          []
         end
       end
+    end
 
-      Puppet::Type.newtype(:autorequire) do
-        newparam(:name) do
-          isnamevar
-        end
+    Puppet::Type.newtype(:autorequire) do
+      newparam(:name) do
+        isnamevar
+      end
 
-        autorequire(:notify) do
-          self[:name]
-        end
+      autorequire(:notify) do
+        self[:name]
       end
+    end
 
-      Puppet::Type.newtype(:gen_auto) do
-        newparam(:name) do
-          isnamevar
-        end
+    Puppet::Type.newtype(:gen_auto) do
+      newparam(:name) do
+        isnamevar
+      end
 
-        newparam(:eval_after) do
-        end
+      newparam(:eval_after) do
+      end
 
-        def generate()
-          [ Puppet::Type.type(:autorequire).new(:name => self[:eval_after]) ]
-        end
+      def generate()
+        [ Puppet::Type.type(:autorequire).new(:name => self[:eval_after]) ]
       end
+    end
 
-      Puppet::Type.newtype(:empty) do
-        newparam(:name) do
-          isnamevar
-        end
+    Puppet::Type.newtype(:empty) do
+      newparam(:name) do
+        isnamevar
       end
+    end
 
-      Puppet::Type.newtype(:gen_empty) do
-        newparam(:name) do
-          isnamevar
-        end
+    Puppet::Type.newtype(:gen_empty) do
+      newparam(:name) do
+        isnamevar
+      end
 
-        newparam(:eval_after) do
-        end
+      newparam(:eval_after) do
+      end
 
-        def generate()
-          [ Puppet::Type.type(:empty).new(:name => self[:eval_after], :require => "Notify[#{self[:eval_after]}]") ]
-        end
+      def generate()
+        [ Puppet::Type.type(:empty).new(:name => self[:eval_after], :require => "Notify[#{self[:eval_after]}]") ]
       end
+    end
+  end
 
-      example.run
 
-      Puppet::Type.rmtype(:gen_empty)
-      Puppet::Type.rmtype(:eval_after)
-      Puppet::Type.rmtype(:autorequire)
-      Puppet::Type.rmtype(:generator)
-    end
+
+  after(:each) do
+    Puppet::Type.rmtype(:gen_empty)
+    Puppet::Type.rmtype(:eval_after)
+    Puppet::Type.rmtype(:autorequire)
+    Puppet::Type.rmtype(:generator)
+    Puppet.pop_context()
   end
 
   def find_vertex(graph, type, title)
@@ -314,11 +313,12 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
     end
 
     it "sets resources_failed_to_generate to true if resource#eval_generate raises an exception" do
+
       catalog = compile_to_ral(<<-MANIFEST)
         notify { 'hello': }
       MANIFEST
 
-      allow(catalog.resource("Notify[hello]")).to receive(:eval_generate).and_raise(RuntimeError)
+      catalog.resource("Notify[hello]").stubs(:eval_generate).raises(RuntimeError)
       relationship_graph = relationship_graph_for(catalog)
       generator = Puppet::Transaction::AdditionalResourceGenerator.new(catalog, relationship_graph, prioritizer)
       generator.eval_generate(catalog.resource("Notify[hello]"))
@@ -487,13 +487,14 @@ describe Puppet::Transaction::AdditionalResourceGenerator do
     end
 
     it "sets resources_failed_to_generate to true if resource#generate raises an exception" do
+
       catalog = compile_to_ral(<<-MANIFEST)
         user { 'foo':
           ensure => present,
         }
       MANIFEST
 
-      allow(catalog.resource("User[foo]")).to receive(:generate).and_raise(RuntimeError)
+      catalog.resource("User[foo]").stubs(:generate).raises(RuntimeError)
       relationship_graph = relationship_graph_for(catalog)
       generator = Puppet::Transaction::AdditionalResourceGenerator.new(catalog, relationship_graph, prioritizer)
       generator.generate_additional_resources(catalog.resource("User[foo]"))