puppet 4.5.2-x64-mingw32 → 4.5.3-x64-mingw32

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

@@ -115,18 +115,44 @@ describe 'The string converter' do
       expect(converter.convert('3.1415', string_formats)).to eq('3.1415')
     end
 
-    it 'The %p format for string produces quoted string' do
-      string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => '%p'}
-      expect(converter.convert("hello\tworld", string_formats)).to eq('"hello\\tworld"')
+    context 'The %p format for string produces' do
+      let!(:string_formats) { { Puppet::Pops::Types::PStringType::DEFAULT => '%p'} }
+      it 'double quoted result for string that contains control characters' do
+         expect(converter.convert("hello\tworld.\r\nSun is brigth today.", string_formats)).to eq('"hello\\tworld.\\r\\nSun is brigth today."')
+      end
+
+      it 'singe quoted result for string that is plain ascii without \\, $ or control characters' do
+        expect(converter.convert('hello world', string_formats)).to eq("'hello world'")
+      end
+
+      it 'quoted 5-byte unicode chars' do
+        expect(converter.convert("smile \u{1f603}.", string_formats)).to eq('"smile \\u{1F603}."')
+      end
+
+      it 'quoted 2-byte unicode chars' do
+        expect(converter.convert("esc \u{1b}.", string_formats)).to eq('"esc \\u{1B}."')
+      end
+
+      it 'escape for $' do
+        expect(converter.convert('escape the $ sign', string_formats)).to eq('"escape the \$ sign"')
+      end
+
+      it 'escape for double qoute but not for single quote' do
+        expect(converter.convert('the \' single and " double quote', string_formats)).to eq('"the \' single and \\" double quote"')
+      end
+
+      it 'no escape for #' do
+        expect(converter.convert('do not escape #{x}', string_formats)).to eq('\'do not escape #{x}\'')
+      end
     end
 
     {
       '%s'   => 'hello::world',
-      '%p'   => '"hello::world"',
+      '%p'   => "'hello::world'",
       '%c'   => 'Hello::world',
-      '%#c'   => '"Hello::world"',
+      '%#c'   => "'Hello::world'",
       '%u'   => 'HELLO::WORLD',
-      '%#u'   => '"HELLO::WORLD"',
+      '%#u'   => "'HELLO::WORLD'",
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
         string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => fmt}
@@ -136,9 +162,9 @@ describe 'The string converter' do
 
     {
       '%c'   => 'Hello::world',
-      '%#c'  => '"Hello::world"',
+      '%#c'  => "'Hello::world'",
       '%d'   => 'hello::world',
-      '%#d'  => '"hello::world"',
+      '%#d'  => "'hello::world'",
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
         string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => fmt}
@@ -146,6 +172,18 @@ describe 'The string converter' do
       end
     end
 
+    {
+      [nil, '%.1p']  => 'u',
+      [nil, '%#.2p'] => '"u',
+      [:default, '%.1p'] => 'd',
+      [true, '%.2s'] => 'tr',
+      [true, '%.2y'] => 'ye',
+    }.each do |args, result |
+      it "the format #{args[1]} produces #{result} for value #{args[0]}" do
+        expect(converter.convert(*args)).to eq(result)
+      end
+    end
+
     {
       '   a b  ' => 'a b',
       'a b  '    => 'a b',
@@ -158,9 +196,9 @@ describe 'The string converter' do
     end
 
     {
-      '   a b  ' => '"a b"',
-      'a b  '    => '"a b"',
-      '   a b'   => '"a b"',
+      '   a b  ' => "'a b'",
+      'a b  '    => "'a b'",
+      '   a b'   => "'a b'",
     }.each do |input, result |
       it "the input #{input} is trimmed to #{result} by using format '%#t'" do
         string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => '%#t'}
@@ -192,15 +230,13 @@ describe 'The string converter' do
 
     {
       '%4.2s'   => '  he',
-      '%4.2p'   => '  "h',
+      '%4.2p'   => "  'h",
       '%4.2c'   => '  He',
-      '%#4.2c'  => '  "H',
+      '%#4.2c'  => "  'H",
       '%4.2u'   => '  HE',
-      '%#4.2u'  => '  "H',
-      '%4.2c'   => '  He',
-      '%#4.2c'  => '  "H',
+      '%#4.2u'  => "  'H",
       '%4.2d'   => '  he',
-      '%#4.2d'  => '  "h',
+      '%#4.2d'  => "  'h"
     }.each do |fmt, result |
       it "width and precision can be combined with #{fmt}" do
         string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => fmt}
@@ -580,30 +616,30 @@ describe 'The string converter' do
 
   context 'when converting array' do
     it 'the default string representation is using [] delimiters, joins with ',' and uses %p for values' do
-      expect(converter.convert(["hello", "world"], :default)).to eq('["hello", "world"]')
+      expect(converter.convert(["hello", "world"], :default)).to eq("['hello', 'world']")
     end
 
-    { "%s"  => '[1, "hello"]',
-      "%p"  => '[1, "hello"]',
-      "%a"  => '[1, "hello"]',
-      "%<a"  => '<1, "hello">',
-      "%[a"  => '[1, "hello"]',
-      "%(a"  => '(1, "hello")',
-      "%{a"  => '{1, "hello"}',
-      "% a"  => '1, "hello"',
+    { "%s"  => "[1, 'hello']",
+      "%p"  => "[1, 'hello']",
+      "%a"  => "[1, 'hello']",
+      "%<a"  => "<1, 'hello'>",
+      "%[a"  => "[1, 'hello']",
+      "%(a"  => "(1, 'hello')",
+      "%{a"  => "{1, 'hello'}",
+      "% a"  => "1, 'hello'",
 
       {'format' => '%(a',
         'separator' => ''
-      } => '(1 "hello")',
+      } => "(1 'hello')",
 
       {'format' => '%|a',
         'separator' => ''
-      } => '|1 "hello"|',
+      } => "|1 'hello'|",
 
-      {'format' => '%(a', 
-        'separator' => '', 
+      {'format' => '%(a',
+        'separator' => '',
         'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
-      } => '(0x1 "hello")',
+      } => "(0x1 'hello')",
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
         string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => fmt}
@@ -614,7 +650,7 @@ describe 'The string converter' do
     it "multiple rules selects most specific" do
       short_array_t = factory.array_of(factory.integer, factory.range(1,2))
       long_array_t = factory.array_of(factory.integer, factory.range(3,100))
-      string_formats = { 
+      string_formats = {
         short_array_t => "%(a",
         long_array_t  => "%[a",
       }
@@ -715,27 +751,27 @@ describe 'The string converter' do
 
   context 'when converting hash' do
     it 'the default string representation is using {} delimiters, joins with '=>' and uses %p for values' do
-      expect(converter.convert({"hello" => "world"}, :default)).to eq('{"hello" => "world"}')
+      expect(converter.convert({"hello" => "world"}, :default)).to eq("{'hello' => 'world'}")
     end
 
-    { "%s"  => '{1 => "world"}',
-      "%p"  => '{1 => "world"}',
-      "%h"  => '{1 => "world"}',
-      "%a"  => '[[1, "world"]]',
-      "%<h"  => '<1 => "world">',
-      "%[h"  => '[1 => "world"]',
-      "%(h"  => '(1 => "world")',
-      "%{h"  => '{1 => "world"}',
-      "% h"  => '1 => "world"',
+    { "%s"  => "{1 => 'world'}",
+      "%p"  => "{1 => 'world'}",
+      "%h"  => "{1 => 'world'}",
+      "%a"  => "[[1, 'world']]",
+      "%<h"  => "<1 => 'world'>",
+      "%[h"  => "[1 => 'world']",
+      "%(h"  => "(1 => 'world')",
+      "%{h"  => "{1 => 'world'}",
+      "% h"  => "1 => 'world'",
 
       {'format' => '%(h',
         'separator2' => ' '
-      } => '(1 "world")',
+      } => "(1 'world')",
 
-      {'format' => '%(h', 
-        'separator2' => ' ', 
+      {'format' => '%(h',
+        'separator2' => ' ',
         'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
-      } => '(0x1 "world")',
+      } => "(0x1 'world')",
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
         string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => fmt}
@@ -743,17 +779,17 @@ describe 'The string converter' do
       end
     end
 
-    {  "%s"  => '{1 => "hello", 2 => "world"}',
+    {  "%s"  => "{1 => 'hello', 2 => 'world'}",
 
        {'format' => '%(h',
          'separator2' => ' '
-       } => '(1 "hello", 2 "world")',
+       } => "(1 'hello', 2 'world')",
 
-       {'format' => '%(h', 
-         'separator' => ' >>', 
-         'separator2' => ' <=> ', 
+       {'format' => '%(h',
+         'separator' => ' >>',
+         'separator2' => ' <=> ',
          'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
-       } => '(0x1 <=> "hello" >> 0x2 <=> "world")',
+       } => "(0x1 <=> 'hello' >> 0x2 <=> 'world')",
      }.each do |fmt, result |
        it "the format #{fmt} produces #{result}" do
          string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => fmt}
@@ -770,9 +806,9 @@ describe 'The string converter' do
       # formatting matters here
       result = [
        "{",
-       "  1 => \"hello\",",
+       "  1 => 'hello',",
        "  2 => {",
-       "    3 => \"world\"",
+       "    3 => 'world'",
        "  }",
        "}"
        ].join("\n")
@@ -782,7 +818,7 @@ describe 'The string converter' do
 
     context "containing an array" do
       it 'the hash and array renders without breaks and indentation by default' do
-        result = '{1 => [1, 2, 3]}'
+        result = "{1 => [1, 2, 3]}"
         formatted = converter.convert({ 1 => [1, 2, 3] }, :default)
         expect(formatted).to eq(result)
       end

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

@@ -353,7 +353,7 @@ describe 'Puppet Type System' do
     end
 
     it 'can be created with a runtime and, puppet name pattern, and runtime replacement' do
-      expect(tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1']).to_s).to eq("Runtime[ruby, [/^MyPackage::(.*)$/, 'MyModule::\\1']]")
+      expect(tf.runtime('ruby', [/^MyPackage::(.*)$/, 'MyModule::\1']).to_s).to eq("Runtime[ruby, [/^MyPackage::(.*)$/, \"MyModule::\\\\1\"]]")
     end
 
     it 'will map a Puppet name to a runtime type' do

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

@@ -74,6 +74,10 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
           resource[:auth_membership] = true
         end
 
+        it "should return true when current and should contain the same users in a different order" do
+          expect(provider.members_insync?(['user1', 'user2', 'user3'], ['user3', 'user1', 'user2'])).to be_truthy
+        end
+
         it "should return false when current is nil" do
           expect(provider.members_insync?(nil, ['user2'])).to be_falsey
         end

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

@@ -5,6 +5,26 @@ require 'spec_helper'
 
 provider_class = Puppet::Type.type(:package).provider(:dnf)
 
+context 'default' do
+  [ 19, 20, 21 ].each do |ver|
+    it "should not be the default provider on fedora#{ver}" do
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+      expect(provider_class).to_not be_default
+    end
+  end
+
+  [ 22, 23, 24 ].each do |ver|
+    it "should be the default provider on fedora#{ver}" do
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+      expect(provider_class).to be_default
+    end
+  end
+end
+
 describe provider_class do
   let(:name) { 'mypackage' }
   let(:resource) do

data/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb

@@ -600,16 +600,6 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
       expect(resource.provider.exists?).to eq(true)
     end
-
-    it "uses SystemRoot in the path of Task folder" do
-      Win32::TaskScheduler.unstub(:new)
-      exists_test_task = Win32::TaskScheduler.new
-      Dir.stubs(:foreach).with('D:/WinNT/Tasks').returns([])
-
-      Puppet::Util.withenv('SystemRoot' => 'D:/WinNT') do
-        exists_test_task.exists?('Test Task')
-      end
-    end
   end
 
   describe '#clear_task' do
@@ -1583,6 +1573,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       end
 
       it 'should save the task' do
+        @mock_task.expects(:set_account_information).with(nil, nil)
         @mock_task.expects(:save)
 
         resource.provider.flush
@@ -1856,4 +1847,200 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       resource.provider.create
     end
   end
+
+  describe "Win32::TaskScheduler", :if => Puppet.features.microsoft_windows? do
+
+    let(:name) { SecureRandom.uuid }
+
+    describe 'sets appropriate generic trigger defaults' do
+      before(:each) do
+        @now = Time.now
+        Time.stubs(:now).returns(@now)
+      end
+
+      it 'for a ONCE schedule' do
+        task = Win32::TaskScheduler.new(name, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+
+      it 'for a DAILY schedule' do
+        trigger = {
+          'trigger_type' => Win32::TaskScheduler::DAILY,
+          'type' => { 'days_interval' => 1 }
+        }
+        task = Win32::TaskScheduler.new(name, trigger)
+
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+
+      it 'for a WEEKLY schedule' do
+        trigger = {
+          'trigger_type' => Win32::TaskScheduler::WEEKLY,
+          'type' => { 'weeks_interval' => 1, 'days_of_week' => 1 }
+        }
+        task = Win32::TaskScheduler.new(name, trigger)
+
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+
+      it 'for a MONTHLYDATE schedule' do
+        trigger = {
+          'trigger_type' => Win32::TaskScheduler::MONTHLYDATE,
+          'type' => { 'days' => 1, 'months' => 1 }
+        }
+        task = Win32::TaskScheduler.new(name, trigger)
+
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+
+      it 'for a MONTHLYDOW schedule' do
+        trigger = {
+          'trigger_type' => Win32::TaskScheduler::MONTHLYDOW,
+          'type' => { 'weeks' => 1, 'days_of_week' => 1, 'months' => 1 }
+        }
+        task = Win32::TaskScheduler.new(name, trigger)
+
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+    end
+
+    describe 'enforces maximum lengths' do
+      let(:task) { Win32::TaskScheduler.new(name, { 'trigger_type' => Win32::TaskScheduler::ONCE }) }
+
+      it 'on account user name' do
+        expect {
+          task.set_account_information('a' * (Win32::TaskScheduler::MAX_ACCOUNT_LENGTH + 1), 'pass')
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on application name' do
+        expect {
+          task.application_name = 'a' * (Win32::TaskScheduler::MAX_PATH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on parameters' do
+        expect {
+          task.parameters = 'a' * (Win32::TaskScheduler::MAX_PARAMETERS_LENGTH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on working directory' do
+        expect {
+          task.working_directory = 'a' * (Win32::TaskScheduler::MAX_PATH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on comment' do
+        expect {
+          task.comment = 'a' * (Win32::TaskScheduler::MAX_COMMENT_LENGTH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on creator' do
+        expect {
+          task.creator = 'a' * (Win32::TaskScheduler::MAX_ACCOUNT_LENGTH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+    end
+
+    describe '#exists?' do
+      it 'works with Unicode task names' do
+        task_name = name + "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+
+        begin
+          task = Win32::TaskScheduler.new(task_name, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+          task.save()
+
+          expect(Puppet::FileSystem.exist?("C:\\Windows\\Tasks\\#{task_name}.job")).to be_truthy
+          expect(task.exists?(task_name)).to be_truthy
+        ensure
+          task.delete(task_name) if Win32::TaskScheduler.new.exists?(task_name)
+        end
+      end
+
+      it 'is case insensitive' do
+        task_name = name + 'abc' # name is a guid, but might not have alpha chars
+
+        begin
+          task = Win32::TaskScheduler.new(task_name.upcase, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+          task.save()
+
+          expect(task.exists?(task_name.downcase)).to be_truthy
+        ensure
+          task.delete(task_name) if Win32::TaskScheduler.new.exists?(task_name)
+        end
+      end
+    end
+
+    describe 'does not corrupt tasks' do
+      it 'when setting maximum length values for all settings' do
+        begin
+          task = Win32::TaskScheduler.new(name, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+
+          application_name = 'a' * Win32::TaskScheduler::MAX_PATH
+          parameters = 'b' * Win32::TaskScheduler::MAX_PARAMETERS_LENGTH
+          working_directory = 'c' * Win32::TaskScheduler::MAX_PATH
+          comment = 'd' * Win32::TaskScheduler::MAX_COMMENT_LENGTH
+          creator = 'e' * Win32::TaskScheduler::MAX_ACCOUNT_LENGTH
+
+          task.application_name = application_name
+          task.parameters = parameters
+          task.working_directory = working_directory
+          task.comment = comment
+          task.creator = creator
+
+          # saving and reloading (activating) can induce COM load errors when
+          # file is corrupted, which can happen when the upper bounds of these lengths are set too high
+          task.save()
+          task.activate(name)
+
+          # furthermore, corrupted values may not necessarily be read back properly
+          # note that SYSTEM is always returned as an empty string in account_information
+          expect(task.account_information).to eq('')
+          expect(task.application_name).to eq(application_name)
+          expect(task.parameters).to eq(parameters)
+          expect(task.working_directory).to eq(working_directory)
+          expect(task.comment).to eq(comment)
+          expect(task.creator).to eq(creator)
+        ensure
+          task.delete(name) if Win32::TaskScheduler.new.exists?(name)
+        end
+      end
+
+      it 'by preventing a save() not preceded by a set_account_information()' do
+        begin
+          # creates a default new task with SYSTEM user
+          task = Win32::TaskScheduler.new(name, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+          # save automatically resets the current task
+          task.save()
+
+          # re-activate named task, try to modify, and save
+          task.activate(name)
+          task.application_name = 'c:/windows/system32/notepad.exe'
+
+          expect { task.save() }.to raise_error(Puppet::Error, /Account information must be set on the current task to save it properly/)
+
+          # on a failed save, the current task is still active - add SYSTEM
+          task.set_account_information('', nil)
+          expect(task.save()).to be_instance_of(Win32::TaskScheduler::COM::Task)
+
+          # the most appropriate additional validation here would be to confirm settings with schtasks.exe
+          # but that test can live inside a system-level acceptance test
+        ensure
+          task.delete(name) if Win32::TaskScheduler.new.exists?(name)
+        end
+      end
+    end
+  end
 end