puppet 5.4.0-x64-mingw32 → 5.5.0-x64-mingw32

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

@@ -230,7 +230,7 @@ describe 'The iterable support' do
     include Enumerable
     include Iterable
 
-     def step(step_size)
+    def step(step_size)
       if block_given?
         begin
           current = 0

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

@@ -761,7 +761,7 @@ describe 'The Object Type' do
 
   context 'when using the initialization hash' do
     it 'produced hash that contains features using short form (type instead of detailed hash when only type is declared)' do
-      obj = t = parse_object('MyObject', <<-OBJECT)
+      obj = parse_object('MyObject', <<-OBJECT)
         attributes => {
           a => { type => Integer }
         }
@@ -770,7 +770,7 @@ describe 'The Object Type' do
     end
 
     it 'produced hash that does not include default for equality_include_type' do
-      obj = t = parse_object('MyObject', <<-OBJECT)
+      obj = parse_object('MyObject', <<-OBJECT)
         attributes => { a => Integer },
         equality_include_type => true
       OBJECT
@@ -778,7 +778,7 @@ describe 'The Object Type' do
     end
 
     it 'constants are presented in a separate hash if they use a generic type' do
-      obj = t = parse_object('MyObject', <<-OBJECT)
+      obj = parse_object('MyObject', <<-OBJECT)
         attributes => {
           a => { type => Integer, value => 23, kind => constant },
         },
@@ -787,7 +787,7 @@ describe 'The Object Type' do
     end
 
     it 'constants are not presented in a separate hash unless they use a generic type' do
-      obj = t = parse_object('MyObject', <<-OBJECT)
+      obj = parse_object('MyObject', <<-OBJECT)
         attributes => {
           a => { type => Integer[0, 30], value => 23, kind => constant },
         },
@@ -796,7 +796,7 @@ describe 'The Object Type' do
     end
 
     it 'can create an equal copy from produced hash' do
-      obj = t = parse_object('MyObject', <<-OBJECT)
+      obj = parse_object('MyObject', <<-OBJECT)
         attributes => {
           a => { type => Struct[{x => Integer, y => Integer}], value => {x => 4, y => 9}, kind => constant },
           b => Integer

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

@@ -47,9 +47,16 @@ describe 'Timespan type' do
         expect(eval_and_collect_notices(code)).to eq(%w(true true))
       end
 
-      it 'using just one parameter is the same as using that parameter twice' do
+      it 'using just one parameter is the same as using default for the second parameter' do
         code = <<-CODE
-            notice(Timespan['01:00:00'] == Timespan['01:00:00', '01:00:00'])
+            notice(Timespan['01:00:00'] == Timespan['01:00:00', default])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true))
+      end
+
+      it 'if the second parameter is default, it is unlimited' do
+        code = <<-CODE
+            notice(Timespan('12345-23:59:59') =~ Timespan['01:00:00', default])
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true))
       end
@@ -114,7 +121,7 @@ describe 'Timespan type' do
         expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /parameter 'format' variant 1 expects size to be at least 1, got 0/)
       end
 
-      it 'can be created from a integer that represents seconds since epoch' do
+      it 'can be created from a integer that represents seconds' do
         code = <<-CODE
             $o = Timespan(6800)
             notice(Integer($o) == 6800)
@@ -123,7 +130,7 @@ describe 'Timespan type' do
         expect(eval_and_collect_notices(code)).to eq(%w(true true))
       end
 
-      it 'can be created from a float that represents seconds with fraction since epoch' do
+      it 'can be created from a float that represents seconds with fraction' do
         code = <<-CODE
             $o = Timespan(6800.123456789)
             notice(Float($o) == 6800.123456789)

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

@@ -53,9 +53,16 @@ describe 'Timestamp type' do
         expect(eval_and_collect_notices(code)).to eq(%w(true true))
       end
 
-      it 'using just one parameter is the same as using that parameter twice' do
+      it 'using just one parameter is the same as using default for the second parameter' do
         code = <<-CODE
-            notice(Timestamp['2015-03-01'] == Timestamp['2015-03-01', '2015-03-01'])
+            notice(Timestamp['2015-03-01'] == Timestamp['2015-03-01', default])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true))
+      end
+
+      it 'if the second parameter is default, it is unlimited' do
+        code = <<-CODE
+            notice(Timestamp('5553-12-31') =~ Timestamp['2015-03-01', default])
         CODE
         expect(eval_and_collect_notices(code)).to eq(%w(true))
       end

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

@@ -314,7 +314,7 @@ module Puppet::Pops
           OBJECT
         end
 
-        it 'can declare a type and Object type' do
+        it 'can declare an Object type using Object[{}]' do
           expect { parse_type_set('TheSet', <<-OBJECT) }.not_to raise_error
             version => '1.0.0',
             pcore_version => '1.0.0',
@@ -410,6 +410,110 @@ module Puppet::Pops
               }
           OBJECT
         end
+
+        context 'allows bracket-less form' do
+          let(:logs) { [] }
+          let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
+          let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+          let(:node) { Puppet::Node.new('example.com') }
+          let(:compiler) { Puppet::Parser::Compiler.new(node) }
+
+          def compile(code)
+            Puppet[:code] = code
+            Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) { compiler.compile }
+          end
+
+          it 'on the TypeSet declaration itself' do
+            compile(<<-PUPPET)
+              type TS = TypeSet { pcore_version => '1.0.0' }
+              notice(TS =~ Type[TypeSet])
+            PUPPET
+            expect(warnings).to be_empty
+            expect(notices).to eql(['true'])
+          end
+
+          it 'without prefix on declared types (implies Object)' do
+            compile(<<-PUPPET)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => { attributes => { a => Integer} }
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+              notice(TS::MyObject =~ Type)
+              notice(TS::MyObject(3))
+            PUPPET
+            expect(warnings).to be_empty
+            expect(notices).to eql(['true', 'true', "TS::MyObject({'a' => 3})"])
+          end
+
+          it "prefixed with QREF 'Object' on declared types" do
+            compile(<<-PUPPET)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => Object { attributes => { a => Integer} }
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+              notice(TS::MyObject =~ Type)
+              notice(TS::MyObject(3))
+            PUPPET
+            expect(warnings).to be_empty
+            expect(notices).to eql(['true', 'true', "TS::MyObject({'a' => 3})"])
+          end
+
+          it 'prefixed with QREF to declare parent on declared types' do
+            compile(<<-PUPPET)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => { attributes => { a => String }},
+                  MySecondObject => MyObject { attributes => { b => String }}
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+              notice(TS::MySecondObject =~ Type)
+              notice(TS::MySecondObject < TS::MyObject)
+              notice(TS::MyObject('hi'))
+              notice(TS::MySecondObject('hello', 'world'))
+            PUPPET
+            expect(warnings).to be_empty
+            expect(notices).to eql(
+              ['true', 'true', 'true', "TS::MyObject({'a' => 'hi'})", "TS::MySecondObject({'a' => 'hello', 'b' => 'world'})"])
+          end
+
+          it 'and warns when parent is specified both before and inside the hash if strict == warning' do
+            Puppet[:strict] = 'warning'
+            compile(<<-PUPPET)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => { attributes => { a => String }},
+                  MySecondObject => MyObject { parent => MyObject, attributes => { b => String }}
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+            PUPPET
+            expect(warnings).to eql(["The key 'parent' is declared more than once"])
+            expect(notices).to eql(['true'])
+          end
+
+          it 'and errors when parent is specified both before and inside the hash if strict == error' do
+            Puppet[:strict] = 'error'
+            expect{ compile(<<-PUPPET) }.to raise_error(/The key 'parent' is declared more than once/)
+              type TS = TypeSet {
+                pcore_version => '1.0.0',
+                types => {
+                  MyObject => { attributes => { a => String }},
+                  MySecondObject => MyObject { parent => MyObject, attributes => { b => String }}
+                }
+              }
+              notice(TS =~ Type[TypeSet])
+            PUPPET
+          end
+        end
       end
 
       it '#name_for method reports the name of deeply nested type correctly' do
@@ -418,7 +522,7 @@ module Puppet::Pops
             pcore_version => '1.0.0',
             types => { Car => Object[{}] }
         OBJECT
-        tt = parse_type_set('Transports', <<-OBJECT)
+        parse_type_set('Transports', <<-OBJECT)
             version => '1.0.0',
             pcore_version => '1.0.0',
             references => {

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

@@ -291,8 +291,6 @@ describe 'Puppet Ruby Generator' do
         end)
       end
 
-      after(:each) { typeset = nil }
-
       context 'the generated class' do
         it 'inherits the PuppetObject module' do
           expect(first < PuppetObject).to be_truthy
@@ -432,10 +430,9 @@ describe 'Puppet Ruby Generator' do
             first_type = parser.parse('MyModule::FirstGenerated')
             second_type = parser.parse('MyModule::SecondGenerated')
 
-            loader = Loaders.find_loader(nil)
             Loaders.implementation_registry.register_type_mapping(
               PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::(\w+)$/, 'MyModule::\1']),
-              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::\1'], loader)
+              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::\1'])
 
             module_def = generator.module_definition([first_type, second_type], 'Generated stuff')
           end
@@ -740,19 +737,17 @@ describe 'Puppet Ruby Generator' do
         # Ideally, this would be in a before(:all) but that is impossible since lots of Puppet
         # environment specific settings are configured by the spec_helper in before(:each)
         if module_def.nil?
-          typeset = nil
           eval_and_collect_notices(source) do
             typeset1 = parser.parse('MyModule')
             typeset2 = parser.parse('OtherModule')
 
-            loader = Loaders.find_loader(nil)
             Loaders.implementation_registry.register_type_mapping(
               PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::My::(\w+)$/, 'MyModule::\1']),
-              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::My::\1'], loader)
+              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::My::\1'])
 
             Loaders.implementation_registry.register_type_mapping(
               PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::Other::(\w+)$/, 'OtherModule::\1']),
-              [/^OtherModule::(\w+)$/, 'PuppetSpec::RubyGenerator::Other::\1'], loader)
+              [/^OtherModule::(\w+)$/, 'PuppetSpec::RubyGenerator::Other::\1'])
 
             module_def = generator.module_definition_from_typeset(typeset1)
             module_def2 = generator.module_definition_from_typeset(typeset2)

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

@@ -83,19 +83,19 @@ describe 'The string converter' do
 
     it "Is an error to specify different delimiters at the same time" do
       expect do
-        fmt = format.new("%[{d")
+        format.new("%[{d")
       end.to raise_error(/Only one of the delimiters/)
     end
 
     it "Is an error to have trailing characters after the format" do
       expect do
-        fmt = format.new("%dv")
+        format.new("%dv")
       end.to raise_error(/The format '%dv' is not a valid format/)
     end
 
     it "Is an error to specify the same flag more than once" do
       expect do
-        fmt = format.new("%[[d")
+        format.new("%[[d")
       end.to raise_error(/The same flag can only be used once/)
     end
   end

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

@@ -67,7 +67,7 @@ describe 'The type calculator' do
   end
 
   def empty_array_t
-  empty_array = array_t(unit_t, range_t(0,0))
+    array_t(unit_t, range_t(0,0))
   end
 
   def hash_t(k,v,s = nil)

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

@@ -283,7 +283,9 @@ describe "validating 4x" do
       'Foo[a] -> Foo[b]',
       '($a=1)',
       'foo()',
-      '$a.foo()'
+      '$a.foo()',
+      '"foo" =~ /foo/', # may produce or modify $n vars
+      '"foo" !~ /foo/', # may produce or modify $n vars
       ].each do |expr|
 
       it "does not produce error when for productive: #{expr}" do

data/spec/unit/property_spec.rb

@@ -294,7 +294,7 @@ describe Puppet::Property do
     end
 
     it "should validate that all required features are present for regexes" do
-      value = subclass.newvalue(/./, :required_features => [:a, :b])
+      subclass.newvalue(/./, :required_features => [:a, :b])
 
       resource.provider.expects(:satisfies?).with([:a, :b]).returns true
 
@@ -302,7 +302,7 @@ describe Puppet::Property do
     end
 
     it "should support specifying an individual required feature" do
-      value = subclass.newvalue(/./, :required_features => :a)
+      subclass.newvalue(/./, :required_features => :a)
 
       resource.provider.expects(:satisfies?).returns true
 

data/spec/unit/provider/aixobject_spec.rb

@@ -10,7 +10,7 @@ describe Puppet::Provider::AixObject do
   end
 
   let(:provider) do
-    provider = Puppet::Provider::AixObject.new resource
+    Puppet::Provider::AixObject.new resource
   end
 
   describe "base provider methods" do

data/spec/unit/provider/cron/crontab_spec.rb

@@ -59,7 +59,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
     it "should parse all sample records at once" do
       subject.parse(text).zip(records).each do |round|
-        compare_crontab_record *round
+        compare_crontab_record(*round)
       end
     end
 
@@ -95,7 +95,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
           it "should parse the records from the text" do
             subject.parse(text).zip(records).each do |round|
-              compare_crontab_record *round
+              compare_crontab_record(*round)
             end
           end
         end
@@ -103,7 +103,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
 
       it "should parse the whole set of records from the text" do
         subject.parse(all_text).zip(all_records).each do |round|
-          compare_crontab_record *round
+          compare_crontab_record(*round)
         end
       end
 

data/spec/unit/provider/exec/posix_spec.rb

@@ -140,14 +140,14 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
         Puppet::Util::POSIX::LOCALE_ENV_VARS.each { |var| orig_env[var] = ENV[var] if ENV[var] }
 
         orig_env.keys.each do |var|
-          output, status = provider.run(command % var)
+          output, _ = provider.run(command % var)
           expect(output.strip).to eq(orig_env[var])
         end
 
         # now, once more... but with our sentinel values
         Puppet::Util.withenv(locale_sentinel_env) do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-            output, status = provider.run(command % var)
+            output, _ = provider.run(command % var)
             expect(output.strip).to eq(locale_sentinel_env[var])
           end
         end
@@ -155,9 +155,9 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
 
       it "should respect locale overrides in user's 'environment' configuration" do
         provider.resource[:environment] = ['LANG=C', 'LC_ALL=C']
-        output, status = provider.run(command % 'LANG')
+        output, _ = provider.run(command % 'LANG')
         expect(output.strip).to eq('C')
-        output, status = provider.run(command % 'LC_ALL')
+        output, _ = provider.run(command % 'LC_ALL')
         expect(output.strip).to eq('C')
       end
     end
@@ -180,7 +180,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
             expect(ENV[var]).to eq(user_sentinel_env[var])
 
             # run an "exec" via the provider and ensure that it unsets the vars
-            output, status = provider.run(command % var)
+            output, _ = provider.run(command % var)
             expect(output.strip).to eq("")
 
             # ensure that after the exec, our temporary env is still intact
@@ -199,7 +199,7 @@ describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix
         # loop over the posix user-related environment variables
         Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
           # run an 'exec' to get the value of each variable
-          output, status = provider.run(command % var)
+          output, _ = provider.run(command % var)
           # ensure that it matches our expected sentinel value
           expect(output.strip).to eq(sentinel_value)
         end

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

@@ -78,13 +78,13 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use groupmod" do
-        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, 'mygroup'], has_entry(:custom_environment, {}))
+        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.gid = 150
       end
 
       it "should pass -o to groupmod" do
         resource[:allowdupe] = :true
-        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entry(:custom_environment, {}))
+        provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.gid = 150
       end
     end
@@ -116,7 +116,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
   describe "#gid=" do
     it "should add -o when allowdupe is enabled and the gid is being modified" do
       resource[:allowdupe] = :true
-      provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entry(:custom_environment, {}))
+      provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
       provider.gid = 150
     end
   end
@@ -132,7 +132,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
       end
 
       it "should use groupdel" do
-        provider.expects(:execute).with(['/usr/sbin/groupdel', 'mygroup'], has_entry(:custom_environment, {}))
+        provider.expects(:execute).with(['/usr/sbin/groupdel', 'mygroup'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.delete
       end
     end