puppet 5.1.0-x64-mingw32 → 5.2.0-x64-mingw32

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

@@ -862,22 +862,53 @@ describe 'The type calculator' do
     context 'for Data, such that' do
       let(:data) { TypeFactory.data }
       data_compatible_types.map { |t2| type_from_class(t2) }.each do |tc|
-        it "#{tc.name} is assignable to Data" do
+        it "it is assignable from #{tc.name}" do
           expect(tc).to be_assignable_to(data)
         end
       end
 
-      it 'Data is not assignable to any of its subtypes' do
+      data_compatible_types.map { |t2| type_from_class(t2) }.each do |tc|
+        it "it is assignable from Optional[#{tc.name}]" do
+          expect(optional_t(tc)).to be_assignable_to(data)
+        end
+      end
+
+      it 'it is not assignable to any of its subtypes' do
         types_to_test = data_compatible_types
         types_to_test.each {|t2| expect(data).not_to be_assignable_to(type_from_class(t2)) }
       end
 
-      it 'Data is not assignable to any disjunct type' do
-        tested_types = all_types - [PAnyType, POptionalType, PInitType] - scalar_types
+      it 'it is not assignable to any disjunct type' do
+        tested_types = all_types - [PAnyType, POptionalType, PInitType] - scalar_data_types
         tested_types.each {|t2| expect(data).not_to be_assignable_to(t2::DEFAULT) }
       end
     end
 
+    context 'for Rich Data, such that' do
+      let(:rich_data) { TypeFactory.rich_data }
+      rich_data_compatible_types.map { |t2| type_from_class(t2) }.each do |tc|
+        it "it is assignable from #{tc.name}" do
+          expect(tc).to be_assignable_to(rich_data)
+        end
+      end
+
+      rich_data_compatible_types.map { |t2| type_from_class(t2) }.each do |tc|
+        it "it is assignable from Optional[#{tc.name}]" do
+          expect(optional_t(tc)).to be_assignable_to(rich_data)
+        end
+      end
+
+      it 'it is not assignable to any of its subtypes' do
+        types_to_test = rich_data_compatible_types
+        types_to_test.each {|t2| expect(rich_data).not_to be_assignable_to(type_from_class(t2)) }
+      end
+
+      it 'it is not assignable to any disjunct type' do
+        tested_types = all_types - [PAnyType, POptionalType, PInitType] - scalar_types
+        tested_types.each {|t2| expect(rich_data).not_to be_assignable_to(t2::DEFAULT) }
+      end
+    end
+
     context 'for Variant, such that' do
       it 'it is assignable to a type if all contained types are assignable to that type' do
         v = variant_t(range_t(10, 12),range_t(14, 20))
@@ -1744,11 +1775,12 @@ describe 'The type calculator' do
       expect(calculator.instance?(PAnyType::DEFAULT, :default)).to eq(true)
     end
 
-    it 'should not consider "default" to be an instance of anything but Default, NotUndef, and Any' do
+    it 'should not consider "default" to be an instance of anything but Default, Init, NotUndef, and Any' do
       types_to_test = all_types - [
         PAnyType,
         PNotUndefType,
         PDefaultType,
+        PInitType,
         ]
 
       types_to_test.each {|t| expect(calculator.instance?(t::DEFAULT, :default)).to eq(false) }

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

@@ -223,6 +223,18 @@ describe 'the type mismatch describer' do
       expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' block return expects a String value, got Integer")
     end
   end
+
+  it "reports struct mismatch correctly when hash doesn't contain required keys" do
+    code = <<-PUPPET
+      type Test::Options = Struct[{
+        var => String
+      }]
+      class test(String $var, Test::Options $opts) {}
+      class { 'test': var => 'hello', opts => {} }
+    PUPPET
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /Class\[Test\]: parameter 'opts' expects size to be 1, got 0/))
+  end
 end
 end
 end

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

@@ -30,6 +30,11 @@ describe TypeParser do
       /The expression <Array\[notAType\]> is not a valid type specification/)
   end
 
+  it "rejects an unknown type parameter in a variant" do
+    expect { parser.parse("Variant[Integer,'not a type']") }.to raise_error(Puppet::ParseError,
+      /The expression <Variant\[Integer,'not a type'\]> is not a valid type specification/)
+  end
+
   [
     'Any', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric', 'Default'
   ].each do |name|
@@ -371,6 +376,26 @@ describe TypeParser do
     expect(t.type_string).to eql('Nonesuch[{a=>undef,b=>true,c=>false,d=>default,e=>"string",f=>0,g=>1.0,h=>[1,2,3]}]')
   end
 
+  it 'parses a parameterized Enum using identifiers' do
+    t = parser.parse('Enum[a, b]')
+    expect(t).to be_a(PEnumType)
+    expect(t.to_s).to eql("Enum['a', 'b']")
+  end
+
+  it 'parses a parameterized Enum using strings' do
+    t = parser.parse("Enum['a', 'b']")
+    expect(t).to be_a(PEnumType)
+    expect(t.to_s).to eql("Enum['a', 'b']")
+  end
+
+  it 'rejects a parameterized Enum using type refs' do
+    expect { parser.parse('Enum[A, B]') }.to raise_error(/Enum parameters must be identifiers or strings/)
+  end
+
+  it 'rejects a parameterized Enum using integers' do
+    expect { parser.parse('Enum[1, 2]') }.to raise_error(/Enum parameters must be identifiers or strings/)
+  end
+
   matcher :be_the_type do |type|
     calc = TypeCalculator.new
 

data/spec/unit/pops/validator/validator_spec.rb

@@ -472,12 +472,12 @@ describe "validating 4x" do
     context 'that are type aliases' do
       it 'raises errors when RHS is a name that is an invalid reference' do
         source = 'type MyInt = integer'
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
+        expect { parse(source) }.to raise_error(/Syntax error at 'integer'/)
       end
 
       it 'raises errors when RHS is an AccessExpression with a name that is an invalid reference on LHS' do
         source = 'type IntegerArray = array[Integer]'
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
+        expect { parse(source) }.to raise_error(/Syntax error at 'array'/)
       end
     end
 

data/spec/unit/provider/package/aix_spec.rb

@@ -25,7 +25,6 @@ describe provider_class do
 
   describe "when installing" do
     it "should install a package" do
-      @resource.stubs(:should).with(:ensure).returns(:installed)
       @provider.expects(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
       @provider.install
     end
@@ -98,10 +97,36 @@ mypackage                 1.2.3.3         Already superseded by 1.2.3.4
       @provider.stubs(:latest_info).returns( { :version => "1.2.3.5" } )
       expect(@provider.latest).to eq("1.2.3.5")
     end
+
+    it "should prefetch the right values" do
+      Process.stubs(:euid).returns(0)
+      resource = Puppet::Type.type(:package).
+          new(:name => 'sudo.rte', :ensure => :latest,
+              :source => 'mysource', :provider => :aix)
+
+      resource.stubs(:should).with(:ensure).returns(:latest)
+      resource.should(:ensure)
+
+      resource.provider.class.stubs(:execute).returns(<<-END.chomp)
+sudo:sudo.rte:1.7.10.4::I:C:::::N:Configurable super-user privileges runtime::::0::
+sudo:sudo.rte:1.8.6.4::I:T:::::N:Configurable super-user privileges runtime::::0::
+END
+
+      resource.provider.class.prefetch('sudo.rte' => resource)
+      expect(resource.provider.latest).to eq('1.8.6.4')
+    end
   end
 
   it "update should install a package" do
     @provider.expects(:install).with(false)
     @provider.update
   end
+
+  it "should prefetch when some packages lack sources" do
+    latest = Puppet::Type.type(:package).new(:name => 'mypackage', :ensure => :latest, :source => 'mysource', :provider => :aix)
+    absent = Puppet::Type.type(:package).new(:name => 'otherpackage', :ensure => :absent, :provider => :aix)
+    Process.stubs(:euid).returns(0)
+    provider_class.expects(:execute).returns 'mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n'
+    provider_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
+  end
 end

data/spec/unit/provider/package/yum_spec.rb

@@ -69,5 +69,15 @@ describe provider_class do
         }.to raise_exception(Exception, /Failed to parse/)
       end
     end
+    describe "with trailing plugin output" do
+      let(:check_update) { File.read(my_fixture("yum-check-update-plugin-output.txt")) }
+      let(:output) { described_class.parse_updates(check_update) }
+      it "parses correctly formatted entries" do
+        expect(output['bash']).to eq([{:name => 'bash', :epoch => '0', :version => '4.2.46', :release => '12.el7', :arch => 'x86_64'}])
+      end
+      it "ignores all mentions of plugin output" do
+        expect(output).not_to include("Random plugin")
+      end
+    end
   end
 end

data/spec/unit/task_spec.rb

@@ -0,0 +1,102 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet_spec/modules'
+require 'puppet/module/task'
+
+describe Puppet::Module::Task do
+  include PuppetSpec::Files
+
+  let(:modpath) { tmpdir('task_modpath') }
+  let(:mymodpath) { File.join(modpath, 'mymod') }
+  let(:mymod) { Puppet::Module.new('mymod', mymodpath, nil) }
+  let(:tasks_path) { File.join(mymodpath, 'tasks') }
+  let(:tasks_glob) { File.join(mymodpath, 'tasks', '*') }
+
+  it "cannot construct tasks with illegal names" do
+    expect { Puppet::Module::Task.new(mymod, "iLegal", []) }
+      .to raise_error(Puppet::Module::Task::InvalidName,
+                      "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
+    Dir.expects(:glob).with(tasks_glob).returns(%w{task1.json task1 task2.json task2.exe task3.json task3.sh})
+    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(["#{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"]])
+
+    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))
+    end
+  end
+
+  it "constructs tasks as expected when some tasks don't have a metadata file" do
+    Dir.expects(:glob).with(tasks_glob).returns(%w{task1 task2.exe task3.json task3.sh})
+    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"],
+                                          ["#{tasks_path}/task2.exe"],
+                                          ["#{tasks_path}/task3.sh"]])
+  end
+
+  it "constructs tasks as expected when a task has multiple executable 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)
+
+    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"]])
+  end
+
+  it "finds files whose names (besides extensions) are valid task names" do
+    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)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task mymod::task_1 mymod::xx_t_a_s_k_2_xx})
+  end
+
+  it "ignores files that have names (besides extensions) that are not valid task names" do
+    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)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::realtask})
+  end
+
+  it "ignores files that have names ending in .conf and .md" do
+    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)
+    expect(tasks.map{|t| t.name}).to eq(%w{mymod::ginuwine_task})
+  end
+
+  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
+end

data/spec/unit/util/log_spec.rb

@@ -32,11 +32,11 @@ describe Puppet::Util::Log do
     end
 
     it "includes a backtrace in the log" do
-      expect(logs.last.message).to match(/Backtrace:\n.*in `initialize'/ )
+      expect(logs.last.message).to match(/Backtrace:\n.*in `newmessage'\n.*in `initialize'/ )
     end
 
     it "warns that message included invalid encoding" do
-      expect(logs.last.message).to match(/Received a log message with invalid encoding/)
+      expect(logs.last.message).to match(/Received a Log attribute with invalid encoding/)
     end
 
     it "includes the 'dump' of the invalid message" do
@@ -44,9 +44,18 @@ describe Puppet::Util::Log do
     end
   end
 
+  # need a string that cannot be converted to US-ASCII or other encodings easily
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte ܎ - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ܎
+
   it "converts a given non-UTF-8 message to UTF-8" do
     logs = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(logs))
+    Puppet::Util::Log.newdestination(:console)
 
     # HIRAGANA LETTER SO
     # In Windows_31J: \x82 \xbb - 130 187
@@ -54,10 +63,30 @@ describe Puppet::Util::Log do
     win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
     utf_8_msg = "\u305d"
 
-    Puppet::Util::Log.new(:level => :notice, :message => win_31j_msg, :source => 'Puppet')
+    $stdout.expects(:puts).with("\e[mNotice: #{mixed_utf8}: #{utf_8_msg}\e[0m")
+
+    # most handlers do special things with a :source => 'Puppet', so use something else
+    Puppet::Util::Log.new(:level => :notice, :message => win_31j_msg, :source => mixed_utf8)
     expect(logs.last.message).to eq(utf_8_msg)
   end
 
+  it "converts a given non-UTF-8 source to UTF-8" do
+    logs = []
+    Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(logs))
+    Puppet::Util::Log.newdestination(:console)
+
+    # HIRAGANA LETTER SO
+    # In Windows_31J: \x82 \xbb - 130 187
+    # In Unicode: \u305d - \xe3 \x81 \x9d - 227 129 157
+    win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
+    utf_8_msg = "\u305d"
+
+    $stdout.expects(:puts).with("\e[mNotice: #{utf_8_msg}: #{mixed_utf8}\e[0m")
+
+    Puppet::Util::Log.new(:level => :notice, :message => mixed_utf8, :source => win_31j_msg)
+    expect(logs.last.source).to eq(utf_8_msg)
+  end
+
   describe ".setup_default" do
     it "should default to :syslog" do
       Puppet.features.stubs(:syslog?).returns(true)

data/spec/unit/util/windows/api_types_spec.rb

@@ -4,6 +4,10 @@
 require 'spec_helper'
 
 describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
+  # use 2 bad bytes at end so we have even number of bytes / characters
+  let (:bad_string) { "hello invalid world".encode(Encoding::UTF_16LE) + "\xDD\xDD".force_encoding(Encoding::UTF_16LE) }
+  let (:bad_string_bytes) { bad_string.bytes.to_a }
+
   context "read_wide_string" do
     let (:string) { "foo_bar" }
 
@@ -24,6 +28,40 @@ describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
 
       expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
+
+    it "should raise an error and emit a debug message when receiving a string containing invalid bytes in the destination encoding" do
+      # enable a debug output sink to local string array
+      Puppet.debug = true
+      arraydest = []
+      Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
+
+      read_string = nil
+
+      expect {
+        FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
+          # uchar here is synonymous with byte
+          ptr.put_array_of_uchar(0, bad_string_bytes)
+
+          read_string = ptr.read_wide_string(bad_string.length)
+        end
+      }.to raise_error(Encoding::InvalidByteSequenceError)
+
+      expect(read_string).to be_nil
+      expect(arraydest.last.message).to eq("Unable to convert value #{bad_string.dump} to encoding UTF-8 due to #<Encoding::InvalidByteSequenceError: \"\\xDD\\xDD\" on UTF-16LE>")
+    end
+
+    it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
+      read_string = nil
+
+      FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
+        # uchar here is synonymous with byte
+        ptr.put_array_of_uchar(0, bad_string_bytes)
+
+        read_string = ptr.read_wide_string(bad_string.length, Encoding::UTF_8, :invalid => :replace)
+      end
+
+      expect(read_string).to eq("hello invalid world\uFFFD")
+    end
   end
 
   context "read_arbitrary_wide_string_up_to" do
@@ -66,5 +104,18 @@ describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
 
       expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
+
+    it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
+      read_string = nil
+
+      FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
+        # uchar here is synonymous with byte
+        ptr.put_array_of_uchar(0, bad_string_bytes)
+
+        read_string = ptr.read_arbitrary_wide_string_up_to(ptr.size / 2, :single_null, :invalid => :replace)
+      end
+
+      expect(read_string).to eq("hello invalid world\uFFFD")
+    end
   end
 end