puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+  module Types
+    describe 'Deferred type' do
+      context 'when used in Puppet expressions' do
+        include PuppetSpec::Compiler
+        it 'is equal to itself only' do
+          expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true false false))
+            $t = Deferred
+            notice(Deferred =~ Type[Deferred])
+            notice(Deferred == Deferred)
+            notice(Deferred < Deferred)
+            notice(Deferred > Deferred)
+            CODE
+        end
+
+        context 'a Deferred instance' do
+          it 'can be created using positional arguments' do
+            code = <<-CODE
+              $o = Deferred('michelangelo', [1,2,3])
+              notice($o)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Deferred({'name' => 'michelangelo', 'arguments' => [1, 2, 3]})"
+            ])
+          end
+
+          it 'can be created using named arguments' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Deferred({'name' => 'michelangelo', 'arguments' => [1, 2, 3]})"
+            ])
+          end
+
+          it 'is inferred to have the type Deferred' do
+            pending 'bug in type() function outputs the entire pcore definition'
+            code = <<-CODE
+              $o = Deferred('michelangelo', [1,2,3])
+              notice(type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Deferred"
+            ])
+          end
+
+          it 'exposes name' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o.name)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["michelangelo"])
+          end
+
+          it 'exposes arguments' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o.arguments)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["[1, 2, 3]"])
+          end
+
+          it 'is an instance of its inferred type' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o =~ type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is an instance of Deferred' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o =~ Deferred)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -74,6 +74,26 @@ describe 'The Object Type' do
         /expects a match for Enum\['constant', 'derived', 'given_or_derived', 'reference'\], got 'derivd'/)
     end
 
+    it 'raises an error if the name is __ptype' do
+      obj = <<-OBJECT
+        attributes => {
+          __ptype => String
+        }
+      OBJECT
+      expect { parse_object('MyObject', obj) }.to raise_error(Puppet::ParseError,
+        /The attribute '__ptype' is reserved and cannot be used/)
+    end
+
+    it 'raises an error if the name is __pvalue' do
+      obj = <<-OBJECT
+        attributes => {
+          __pvalue => String
+        }
+      OBJECT
+      expect { parse_object('MyObject', obj) }.to raise_error(Puppet::ParseError,
+        /The attribute '__pvalue' is reserved and cannot be used/)
+    end
+
     it 'stores value in attribute' do
       tp = parse_object('MyObject', <<-OBJECT)
         attributes => {

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

@@ -68,28 +68,6 @@ describe 'Timespan type' do
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true false))
       end
-
-      it 'accepts integer values when specifying the range' do
-        code = <<-CODE
-            notice(Timespan(1) =~ Timespan[1, 2])
-            notice(Timespan(3) =~ Timespan[1])
-            notice(Timespan(0) =~ Timespan[default, 2])
-            notice(Timespan(0) =~ Timespan[1, 2])
-            notice(Timespan(3) =~ Timespan[1, 2])
-        CODE
-        expect(eval_and_collect_notices(code)).to eq(%w(true true true false false))
-      end
-
-      it 'accepts float values when specifying the range' do
-        code = <<-CODE
-            notice(Timespan(1.0) =~ Timespan[1.0, 2.0])
-            notice(Timespan(3.0) =~ Timespan[1.0])
-            notice(Timespan(0.0) =~ Timespan[default, 2.0])
-            notice(Timespan(0.0) =~ Timespan[1.0, 2.0])
-            notice(Timespan(3.0) =~ Timespan[1.0, 2.0])
-        CODE
-        expect(eval_and_collect_notices(code)).to eq(%w(true true true false false))
-      end
     end
 
     context 'a Timespan instance' do

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

@@ -74,25 +74,6 @@ describe 'Timestamp type' do
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true false))
       end
-
-      it 'accepts integer values when specifying the range' do
-        code = <<-CODE
-            notice(Timestamp(1) =~ Timestamp[1, 2])
-            notice(Timestamp(3) =~ Timestamp[1])
-            notice(Timestamp(0) =~ Timestamp[default, 2])
-        CODE
-        expect(eval_and_collect_notices(code)).to eq(%w(true true true))
-      end
-
-      it 'accepts float values when specifying the range' do
-        code = <<-CODE
-            notice(Timestamp(1.0) =~ Timestamp[1.0, 2.0])
-            notice(Timestamp(3.0) =~ Timestamp[1.0])
-            notice(Timestamp(0.0) =~ Timestamp[default, 2.0])
-        CODE
-        expect(eval_and_collect_notices(code)).to eq(%w(true true true))
-      end
-
     end
 
     context 'a Timestamp instance' do

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

@@ -61,32 +61,32 @@ describe 'the RecursionGuard' do
   end
 
   it "should not call 'hash' on an added instance" do
-    x = double()
-    expect(x).not_to receive(:hash)
+    x = mock
+    x.expects(:hash).never
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call '==' on an added instance" do
-    x = double()
-    expect(x).not_to receive(:==)
+    x = mock
+    x.expects(:==).never
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'eq?' on an added instance" do
-    x = double()
-    expect(x).not_to receive(:eq?)
+    x = mock
+    x.expects(:eq?).never
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'eql?' on an added instance" do
-    x = double()
-    expect(x).not_to receive(:eql?)
+    x = mock
+    x.expects(:eql?).never
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'equal?' on an added instance" do
-    x = double()
-    expect(x).not_to receive(:equal?)
+    x = mock
+    x.expects(:equal?).never
     expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 end

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

@@ -448,7 +448,7 @@ describe 'Puppet Ruby Generator' do
 
       after(:all) do
         # Don't want generated module to leak outside this test
-        PuppetSpec.send(:remove_const, :RubyGenerator) if PuppetSpec.const_defined?(:RubyGenerator)
+        PuppetSpec.send(:remove_const, :RubyGenerator)
       end
 
       it 'the #_pcore_type class method returns a resolved Type' do
@@ -765,7 +765,7 @@ describe 'Puppet Ruby Generator' do
 
       after(:all) do
         # Don't want generated module to leak outside this test
-        PuppetSpec.send(:remove_const, :RubyGenerator) if PuppetSpec.const_defined?(:RubyGenerator)
+        PuppetSpec.send(:remove_const, :RubyGenerator)
       end
 
       it 'the #_pcore_type class method returns a resolved Type' do

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

@@ -296,7 +296,6 @@ describe 'The string converter' do
       '%o'      => '22',
       '%4.2o'   => '  22',
       '%#o'     => '022',
-      '%#6.4o'  => '  0022',
       '%b'      => '10010',
       '%7.6b'   => ' 010010',
       '%#b'     => '0b10010',
@@ -313,11 +312,18 @@ describe 'The string converter' do
       '%.1f'    => '18.0',
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
+        pending("PUP-8612 %a and %A not support on JRuby") if RUBY_PLATFORM == 'java' && fmt =~ /^%[aA]$/
         string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => fmt}
         expect(converter.convert(18, string_formats)).to eq(result)
       end
     end
 
+    it 'the format %#6.4o produces 0022' do
+      string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => '%#6.4o' }
+      result = RUBY_PLATFORM == 'java' ? ' 00022' : '  0022'
+      expect(converter.convert(18, string_formats)).to eq(result)
+    end
+
     it 'produces a unicode char string by using format %c' do
       string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => '%c'}
       expect(converter.convert(0x1F603, string_formats)).to eq("\u{1F603}")
@@ -400,6 +406,7 @@ describe 'The string converter' do
       '%#B'     => '0B10010',
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
+        pending("PUP-8612 %a and %A not support on JRuby") if RUBY_PLATFORM == 'java' && fmt =~ /^%[-.014]*[aA]$/
         string_formats = { Puppet::Pops::Types::PFloatType::DEFAULT => fmt}
         expect(converter.convert(18.0, string_formats)).to eq(result)
       end
@@ -576,6 +583,7 @@ describe 'The string converter' do
       "%#Y"  => 'Y',
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
+        pending("PUP-8612 %a and %A not support on JRuby") if RUBY_PLATFORM == 'java' && fmt =~ /^%[aA]$/
         string_formats = { Puppet::Pops::Types::PBooleanType::DEFAULT => fmt}
         expect(converter.convert(true, string_formats)).to eq(result)
       end
@@ -622,6 +630,7 @@ describe 'The string converter' do
       "%#Y"  => 'N',
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
+        pending("PUP-8612 %a and %A not support on JRuby") if RUBY_PLATFORM == 'java' && fmt =~ /^%[aA]$/
         string_formats = { Puppet::Pops::Types::PBooleanType::DEFAULT => fmt}
         expect(converter.convert(false, string_formats)).to eq(result)
       end
@@ -679,7 +688,7 @@ describe 'The string converter' do
         short_array_t => "%(a",
         long_array_t  => "%[a",
       }
-      expect(converter.convert([1, 2], string_formats)).to eq('(1, 2)')
+      expect(converter.convert([1, 2], string_formats)).to eq('(1, 2)') unless RUBY_PLATFORM == 'java' # PUP-8615
       expect(converter.convert([1, 2, 3], string_formats)).to eq('[1, 2, 3]')
     end
 
@@ -698,15 +707,6 @@ describe 'The string converter' do
      expect(formatted).to eq(result)
     end
 
-    it 'applies a short form format' do
-      result = [
-        "[1,",
-        "  [2, 3],",
-        "  4]"
-        ].join("\n")
-      expect(converter.convert([1, [2,3], 4], '%#a')).to eq(result)
-    end
-
     it 'treats hashes as nested arrays wrt indentation' do
       string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
@@ -855,17 +855,6 @@ describe 'The string converter' do
       expect(converter.convert({1 => "hello", 2 => {3=> "world"}}, string_formats)).to eq(result)
     end
 
-    it 'applies a short form format' do
-      result = [
-        "{",
-        "  1 => {",
-        "    2 => 3",
-        "  },",
-        "  4 => 5",
-        "}"].join("\n")
-      expect(converter.convert({1 => {2 => 3}, 4 => 5}, '%#h')).to eq(result)
-    end
-
     context "containing an array" do
       it 'the hash and array renders without breaks and indentation by default' do
         result = "{1 => [1, 2, 3]}"

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

@@ -45,6 +45,8 @@ describe 'The Task Type' do
         { 'testmodule' => testmodule }
       end
 
+      let(:module_loader) { Puppet.lookup(:loaders).find_loader('testmodule') }
+
       def compile(code = nil)
         Puppet[:code] = code
         Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
@@ -71,7 +73,6 @@ describe 'The Task Type' do
 
         it 'loads task without metadata as a generic Task' do
           compile do
-            module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
             task = module_loader.load(:task, 'testmodule::hello')
             expect(task_t.instance?(task)).to be_truthy
             expect(task.name).to eq('testmodule::hello')
@@ -84,7 +85,6 @@ describe 'The Task Type' do
 
           it 'evaluator does not recognize generic tasks' do
             compile do
-              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
               expect(module_loader.load(:task, 'testmodule::hello')).to be_nil
             end
           end
@@ -139,14 +139,13 @@ describe 'The Task Type' do
 
         it 'loads a task with parameters' do
           compile do
-            module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
             task = module_loader.load(:task, 'testmodule::hello')
             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.executable).to eql("#{modules_dir}/testmodule/tasks/hello.rb")
+            expect(task.implementations).to eql([{"name" => "hello.rb", "path" => "#{modules_dir}/testmodule/tasks/hello.rb", "requirements" => []}])
 
             tp = task.parameters
             expect(tp['message']['description']).to eql('the message')
@@ -156,7 +155,6 @@ describe 'The Task Type' do
 
         it 'loads a task with non-Data parameter' do
           compile do
-            module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
             task = module_loader.load(:task, 'testmodule::non_data')
             expect(task_t.instance?(task)).to be_truthy
             tp = task.parameters
@@ -164,6 +162,147 @@ describe 'The Task Type' do
           end
         end
 
+        context 'without an implementation file' do
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'init.json' => '{}'
+              }
+            }
+          }
+
+          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/)
+            end
+          end
+        end
+
+        context 'with multiple implementation files' do
+          let(:metadata) { '{}' }
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'init.sh' => '',
+                'init.ps1' => '',
+                'init.json' => metadata,
+              }
+            }
+          }
+
+          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 .*/)
+            end
+          end
+
+          it "returns the implementations if metadata lists them all" do
+            impls = [{'name' => 'init.sh', 'requirements' => ['shell']},
+                     {'name' => 'init.ps1', 'requirements' => ['powershell']}]
+            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.sh", "path" => "#{modules_dir}/testmodule/tasks/init.sh", "requirements" => ['shell']},
+                {"name" => "init.ps1", "path" => "#{modules_dir}/testmodule/tasks/init.ps1", "requirements" => ['powershell']}
+              ])
+            end
+          end
+
+          it "returns a single implementation if metadata only specifies one implementation" do
+            impls = [{'name' => 'init.ps1', 'requirements' => ['powershell']}]
+            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" => ['powershell']}
+              ])
+            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" => []}
+              ])
+            end
+          end
+
+          it "fails if a specified implementation doesn't exist" do
+            impls = [{'name' => 'init.sh', 'requirements' => ['shell']},
+                     {'name' => 'init.ps1', 'requirements' => ['powershell']},
+                     {'name' => 'init.rb', 'requirements' => ['puppet-agent']}]
+            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/)
+            end
+          end
+
+          it "fails if the implementations key isn't an array" 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/)
+            end
+          end
+        end
+
+        context 'with multiple tasks sharing executables' do
+          let(:foo_metadata) { '{}' }
+          let(:bar_metadata) { '{}' }
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'foo.sh' => '',
+                'foo.ps1' => '',
+                'foo.json' => foo_metadata,
+                'bar.json' => bar_metadata,
+                'baz.json' => bar_metadata,
+              }
+            }
+          }
+
+          it 'loads a task that uses executables named after another task' do
+            metadata = {
+              implementations: [
+                {name: 'foo.sh', requirements: ['shell']},
+                {name: 'foo.ps1', requirements: ['powershell']},
+              ]
+            }
+            bar_metadata.replace(metadata.to_json)
+
+            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']},
+              ])
+            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/)
+            end
+          end
+
+          it 'fails to load the task if it has no files at all' do
+            compile do
+              expect(module_loader.load(:task, 'testmodule::qux')).to be_nil
+            end
+          end
+        end
+
         context 'with adjacent directory for init task' do
           let(:testmodule) {
             {
@@ -184,12 +323,11 @@ describe 'The Task Type' do
             }
           }
 
-          it 'loads the init task with parameters and executable' do
+          it 'loads the init task with parameters and implementations' do
             compile do
-              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
               task = module_loader.load(:task, 'testmodule')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.executable).to eql("#{modules_dir}/testmodule/tasks/init.sh")
+              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)
             end
@@ -216,12 +354,11 @@ describe 'The Task Type' do
             }
           }
 
-          it 'loads a named task with parameters and executable' do
+          it 'loads a named task with parameters and implementations' do
             compile do
-              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
               task = module_loader.load(:task, 'testmodule::hello')
               expect(task_t.instance?(task)).to be_truthy
-              expect(task.executable).to eql("#{modules_dir}/testmodule/tasks/hello.sh")
+              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)
             end
@@ -241,7 +378,6 @@ describe 'The Task Type' do
 
           it 'task is not found' do
             compile do
-              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
               expect(module_loader.load(:task, 'testmodule::hello::foo')).to be_nil
             end
           end
@@ -266,7 +402,6 @@ describe 'The Task Type' do
 
           it 'fails with unrecognized key error' do
             compile do
-              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
               expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
                 /Failed to load metadata for task testmodule::hello:.*unrecognized key 'supports_nop'/)
             end
@@ -284,7 +419,6 @@ describe 'The Task Type' do
 
           it 'loads the task with parameters set to undef' do
             compile do
-              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
               task = module_loader.load(:task, 'testmodule::hello')
               expect(task_t.instance?(task)).to be_truthy
               expect(task.parameters).to be_nil
@@ -311,7 +445,6 @@ describe 'The Task Type' do
 
           it 'fails with pattern mismatch error' do
             compile do
-              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
               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
@@ -338,7 +471,6 @@ describe 'The Task Type' do
 
           it 'fails with type mismatch error' do
             compile do
-              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
               expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
                 /entry 'puppet_task_version' expects an Integer value, got String/)
             end