puppet 8.4.0-x64-mingw32 → 8.5.1-x64-mingw32

data/spec/unit/pops/serialization/to_stringified_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe 'ToStringifiedConverter' do
-  include PuppetSpec::Compiler
-
-  after(:all) { Puppet::Pops::Loaders.clear }
-
-  let(:env) { Puppet::Node::Environment.create(:testing, []) }
-  let(:loaders) { Puppet::Pops::Loaders.new(env) }
-  let(:node) { Puppet::Node.new(env, environment: env) }
-
-  def transform(v)
-    Puppet::Pops::Serialization::ToStringifiedConverter.convert(v)
-  end
-
-  def eval_transform(source)
-    Puppet.override(:current_environment => env, :loaders => loaders) do
-      transform(evaluate(source: source, node: node))
-    end
-  end
-
-  it 'converts undef to to nil' do
-    expect(transform(nil)).to be_nil
-    expect(eval_transform('undef')).to be_nil
-  end
-
-  it "converts literal default to the string 'default'" do
-    expect(transform(:default)).to eq('default')
-    expect(eval_transform('default')).to eq('default')
-  end
-
-  it "does not convert an integer" do
-    expect(transform(42)).to eq(42)
-  end
-
-  it "does not convert a float" do
-    expect(transform(3.14)).to eq(3.14)
-  end
-
-  it "does not convert a boolean" do
-    expect(transform(true)).to be(true)
-    expect(transform(false)).to be(false)
-  end
-
-  it "does not convert a string (that is free from encoding issues)" do
-    expect(transform("hello")).to eq("hello")
-  end
-
-  it "converts a regexp to a string" do
-    expect(transform(/this|that.*/)).to eq("/this|that.*/")
-    expect(eval_transform('/this|that.*/')).to eq("/this|that.*/")
-  end
-
-  it 'handles a string with an embedded single quote' do
-    expect(transform("ta'phoenix")).to eq("ta'phoenix")
-  end
-
-  it 'handles a string with embedded double quotes' do
-    expect(transform('he said "hi"')).to eq("he said \"hi\"")
-  end
-
-  it 'converts a user defined object to its string representation including attributes' do
-    result = evaluate(code: "type Car = Object[attributes=>{regnbr => String}]", source: "Car(abc123)")
-    expect(transform(result)).to eq("Car({'regnbr' => 'abc123'})")
-  end
-
-  it 'converts a Deferred object to its string representation including attributes' do
-    expect(eval_transform("Deferred(func, [1,2,3])")).to eq("Deferred({'name' => 'func', 'arguments' => [1, 2, 3]})")
-  end
-
-  it 'converts a Sensitive to type + redacted plus id' do
-    sensitive = evaluate(source: "Sensitive('hush')")
-    id = sensitive.object_id
-    expect(transform(sensitive)).to eq("#<Sensitive [value redacted]:#{id}>")
-  end
-
-  it 'converts a Timestamp to String' do
-    expect(eval_transform("Timestamp('2018-09-03T19:45:33.697066000 UTC')")).to eq("2018-09-03T19:45:33.697066000 UTC")
-  end
-
-  it 'does not convert an array' do
-    expect(transform([1,2,3])).to eq([1,2,3])
-  end
-
-  it 'converts the content of an array - for example a Sensitive value' do
-    sensitive = evaluate(source: "Sensitive('hush')")
-    id = sensitive.object_id
-    expect(transform([sensitive])).to eq(["#<Sensitive [value redacted]:#{id}>"])
-  end
-
-  it 'converts the content of a hash - for example a Sensitive value' do
-    sensitive = evaluate(source: "Sensitive('hush')")
-    id = sensitive.object_id
-    expect(transform({'x' => sensitive})).to eq({'x' => "#<Sensitive [value redacted]:#{id}>"})
-  end
-
-  it 'does not convert a hash' do
-    expect(transform({'a' => 10, 'b' => 20})).to eq({'a' => 10, 'b' => 20})
-  end
-
-  it 'converts non Data compliant hash key to string' do
-    expect(transform({['funky', 'key'] => 10})).to eq({'["funky", "key"]' => 10})
-  end
-
-  it 'converts reserved __ptype hash key to different string' do
-    expect(transform({'__ptype' => 10})).to eq({'reserved key: __ptype' => 10})
-  end
-
-  it 'converts reserved __pvalue hash key to different string' do
-    expect(transform({'__pvalue' => 10})).to eq({'reserved key: __pvalue' => 10})
-  end
-
-  it 'converts a Binary to Base64 string' do
-    expect(eval_transform("Binary('hello', '%s')")).to eq("aGVsbG8=")
-  end
-
-  it 'converts an ASCII-8BIT String to Base64 String' do
-    binary_string = "\x02\x03\x04hello".force_encoding('ascii-8bit')
-    expect(transform(binary_string)).to eq("AgMEaGVsbG8=")
-  end
-
-  it 'converts Runtime (alien) object to its to_s' do
-    class Alien
-    end
-    an_alien = Alien.new
-    expect(transform(an_alien)).to eq(an_alien.to_s)
-  end
-
-  it 'converts a runtime Symbol to String' do
-    expect(transform(:symbolic)).to eq("symbolic")
-  end
-
-  it 'converts a datatype (such as Integer[0,10]) to its puppet source string form' do
-    expect(eval_transform("Integer[0,100]")).to eq("Integer[0, 100]")
-  end
-
-  it 'converts a user defined datatype (such as Car) to its puppet source string form' do
-    result = evaluate(code: "type Car = Object[attributes=>{regnbr => String}]", source: "Car")
-    expect(transform(result)).to eq("Car")
-  end
-
-  it 'converts a self referencing user defined datatype by using named references for cyclic entries' do
-    result = evaluate(code: "type Tree = Array[Variant[String, Tree]]", source: "Tree")
-    expect(transform(result)).to eq("Tree = Array[Variant[String, Tree]]")
-  end
-
-  it 'converts illegal char sequence in an encoding to Unicode Illegal' do
-    invalid_sequence = [0xc2, 0xc2].pack("c*").force_encoding(Encoding::UTF_8)
-    expect(transform(invalid_sequence)).to eq("��")
-  end
-
-  it 'does not convert unassigned char - glyph is same for all unassigned' do
-    unassigned = [243, 176, 128, 128].pack("C*").force_encoding(Encoding::UTF_8) 
-    expect(transform(unassigned)).to eq("󰀀")
-  end
-
-  it 'converts ProcessOutput objects to string' do
-    object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
-    expect(transform(object)).to be_instance_of(String)
-  end
-end

data/spec/unit/pops/time/timespan_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet_spec/compiler'
-
-module Puppet::Pops
-module Time
-describe 'Timespan' do
-  include PuppetSpec::Compiler
-
-  let! (:simple) { Timespan.from_fields(false, 1, 3, 10, 11) }
-  let! (:all_fields_hash) { {'days' => 1, 'hours' => 7, 'minutes' => 10, 'seconds' => 11, 'milliseconds' => 123, 'microseconds' => 456, 'nanoseconds' => 789} }
-  let! (:complex) { Timespan.from_fields_hash(all_fields_hash) }
-
-  context 'can be created from a String' do
-    it 'using default format' do
-      expect(Timespan.parse('1-03:10:11')).to eql(simple)
-    end
-
-    it 'using explicit format' do
-      expect(Timespan.parse('1-7:10:11.123456789', '%D-%H:%M:%S.%N')).to eql(complex)
-    end
-
-    it 'using leading minus and explicit format' do
-      expect(Timespan.parse('-1-7:10:11.123456789', '%D-%H:%M:%S.%N')).to eql(-complex)
-    end
-
-    it 'using %H as the biggest quantity' do
-      expect(Timespan.parse('27:10:11', '%H:%M:%S')).to eql(simple)
-    end
-
-    it 'using %M as the biggest quantity' do
-      expect(Timespan.parse('1630:11', '%M:%S')).to eql(simple)
-    end
-
-    it 'using %S as the biggest quantity' do
-      expect(Timespan.parse('97811', '%S')).to eql(simple)
-    end
-
-    it 'where biggest quantity is not frist' do
-      expect(Timespan.parse('11:1630', '%S:%M')).to eql(simple)
-    end
-
-    it 'raises an error when using %L as the biggest quantity' do
-      expect { Timespan.parse('123', '%L') }.to raise_error(ArgumentError, /denotes fractions and must be used together with a specifier of higher magnitude/)
-    end
-
-    it 'raises an error when using %N as the biggest quantity' do
-      expect { Timespan.parse('123', '%N') }.to raise_error(ArgumentError, /denotes fractions and must be used together with a specifier of higher magnitude/)
-    end
-
-    it 'where %L is treated as fractions of a second' do
-      expect(Timespan.parse('0.4', '%S.%L')).to eql(Timespan.from_fields(false, 0, 0, 0, 0, 400))
-    end
-
-    it 'where %N is treated as fractions of a second' do
-      expect(Timespan.parse('0.4', '%S.%N')).to eql(Timespan.from_fields(false, 0, 0, 0, 0, 400))
-    end
-  end
-
-  context 'when presented as a String' do
-    it 'uses default format for #to_s' do
-      expect(simple.to_s).to eql('1-03:10:11.0')
-    end
-
-    context 'using a format' do
-      it 'produces a string containing all components' do
-        expect(complex.format('%D-%H:%M:%S.%N')).to eql('1-07:10:11.123456789')
-      end
-
-      it 'produces a literal % for %%' do
-        expect(complex.format('%D%%%H:%M:%S')).to eql('1%07:10:11')
-      end
-
-      it 'produces a leading dash for negative instance' do
-        expect((-complex).format('%D-%H:%M:%S')).to eql('-1-07:10:11')
-      end
-
-      it 'produces a string without trailing zeros for %-N' do
-        expect(Timespan.parse('2.345', '%S.%N').format('%-S.%-N')).to eql('2.345')
-      end
-
-      it 'produces a string with trailing zeros for %N' do
-        expect(Timespan.parse('2.345', '%S.%N').format('%-S.%N')).to eql('2.345000000')
-      end
-
-      it 'produces a string with trailing zeros for %0N' do
-        expect(Timespan.parse('2.345', '%S.%N').format('%-S.%0N')).to eql('2.345000000')
-      end
-
-      it 'produces a string with trailing spaces for %_N' do
-        expect(Timespan.parse('2.345', '%S.%N').format('%-S.%_N')).to eql('2.345      ')
-      end
-    end
-  end
-
-  context 'when converted to a hash' do
-    it 'produces a hash with all numeric keys' do
-      hash = complex.to_hash
-      expect(hash).to eql(all_fields_hash)
-    end
-
-    it 'produces a compact hash with seconds and nanoseconds for #to_hash(true)' do
-      hash = complex.to_hash(true)
-      expect(hash).to eql({'seconds' => 112211, 'nanoseconds' => 123456789})
-    end
-
-    context 'from a negative value' do
-      it 'produces a hash with all numeric keys and negative = true' do
-        hash = (-complex).to_hash
-        expect(hash).to eql(all_fields_hash.merge('negative' => true))
-      end
-
-      it 'produces a compact hash with negative seconds and negative nanoseconds for #to_hash(true)' do
-        hash = (-complex).to_hash(true)
-        expect(hash).to eql({'seconds' => -112211, 'nanoseconds' => -123456789})
-      end
-    end
-  end
-end
-end
-end

data/spec/unit/pops/time/timestamp_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-module Puppet::Pops
-  module Time
-    describe 'Timestamp' do
-      it 'Does not loose microsecond precision when converted to/from String' do
-        ts = Timestamp.new(1495789430910161286)
-        expect(Timestamp.parse(ts.to_s)).to eql(ts)
-      end
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-describe 'the Puppet::Pops::Types::ClassLoader' do
-  it 'should produce path alternatives for CamelCase classes' do
-    expected_paths = ['puppet_x/some_thing', 'puppetx/something']
-    # path_for_name method is private
-    expect(Puppet::Pops::Types::ClassLoader.send(:paths_for_name, ['PuppetX', 'SomeThing'])).to include(*expected_paths)
-  end
-end

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

@@ -1,87 +0,0 @@
-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/error_spec.rb

@@ -1,207 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet_spec/compiler'
-
-module Puppet::Pops
-  module Types
-    describe 'Error 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 = Error
-            notice(Error =~ Type[Error])
-            notice(Error == Error)
-            notice(Error < Error)
-            notice(Error > Error)
-            CODE
-        end
-
-        context "when parameterized" do
-          it 'is equal other types with the same parameterization' do
-            code = <<-CODE
-              notice(Error['puppet/error'] == Error['puppet/error', default])
-              notice(Error['puppet/error', 'ouch'] == Error['puppet/error', 'ouch'])
-              notice(Error['puppet/error', 'ouch'] != Error['puppet/error', 'ouch!'])
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(%w(true true true))
-          end
-
-          it 'is assignable from more qualified types' do
-            expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true true))
-              notice(Error > Error['puppet/error'])
-              notice(Error['puppet/error'] > Error['puppet/error', 'ouch'])
-              notice(Error['puppet/error', default] > Error['puppet/error', 'ouch'])
-              CODE
-          end
-
-          it 'is not assignable unless kind is assignable' do
-            expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true false true false true false true))
-              notice(Error[/a/] > Error['hah'])
-              notice(Error[/a/] > Error['hbh'])
-              notice(Error[Enum[a,b,c]] > Error[a])
-              notice(Error[Enum[a,b,c]] > Error[d])
-              notice(Error[Pattern[/a/, /b/]] > Error[a])
-              notice(Error[Pattern[/a/, /b/]] > Error[c])
-              notice(Error[Pattern[/a/, /b/]] > Error[Enum[a, b]])
-              CODE
-          end
-
-          it 'presents parsable string form' do
-            code = <<-CODE
-              notice(Error['a'])
-              notice(Error[/a/])
-              notice(Error[Enum['a', 'b']])
-              notice(Error[Pattern[/a/, /b/]])
-              notice(Error['a', default])
-              notice(Error[/a/, default])
-              notice(Error[Enum['a', 'b'], default])
-              notice(Error[Pattern[/a/, /b/], default])
-              notice(Error[default,'a'])
-              notice(Error[default,/a/])
-              notice(Error[default,Enum['a', 'b']])
-              notice(Error[default,Pattern[/a/, /b/]])
-              notice(Error['a','a'])
-              notice(Error[/a/,/a/])
-              notice(Error[Enum['a', 'b'],Enum['a', 'b']])
-              notice(Error[Pattern[/a/, /b/],Pattern[/a/, /b/]])
-              CODE
-            expect(eval_and_collect_notices(code)).to eq([
-              "Error['a']",
-              'Error[/a/]',
-              "Error[Enum['a', 'b']]",
-              "Error[Pattern[/a/, /b/]]",
-              "Error['a']",
-              'Error[/a/]',
-              "Error[Enum['a', 'b']]",
-              "Error[Pattern[/a/, /b/]]",
-              "Error[default, 'a']",
-              'Error[default, /a/]',
-              "Error[default, Enum['a', 'b']]",
-              "Error[default, Pattern[/a/, /b/]]",
-              "Error['a', 'a']",
-              'Error[/a/, /a/]',
-              "Error[Enum['a', 'b'], Enum['a', 'b']]",
-              "Error[Pattern[/a/, /b/], Pattern[/a/, /b/]]",
-            ])
-          end
-        end
-
-        context 'an Error instance' do
-          it 'can be created using positional arguments' do
-            code = <<-CODE
-              $o = Error('bad things happened', 'puppet/error', {'detail' => 'val'}, 'OOPS')
-              notice($o)
-              notice(type($o))
-              CODE
-            expect(eval_and_collect_notices(code)).to eq([
-              "Error({'msg' => 'bad things happened', 'kind' => 'puppet/error', 'details' => {'detail' => 'val'}, 'issue_code' => 'OOPS'})",
-              "Error['puppet/error', 'OOPS']"
-            ])
-          end
-
-          it 'can be created using named arguments' do
-            code = <<-CODE
-              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
-              notice($o)
-              notice(type($o))
-              CODE
-            expect(eval_and_collect_notices(code)).to eq([
-              "Error({'msg' => 'Sorry, not implemented', 'kind' => 'puppet/error', 'issue_code' => 'NOT_IMPLEMENTED'})",
-              "Error['puppet/error', 'NOT_IMPLEMENTED']"
-            ])
-          end
-
-          it 'exposes message' do
-            code = <<-CODE
-              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
-              notice($o.message)
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(["Sorry, not implemented"])
-          end
-
-          it 'exposes kind' do
-            code = <<-CODE
-              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
-              notice($o.kind)
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(["puppet/error"])
-          end
-
-          it 'exposes issue_code' do
-            code = <<-CODE
-              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
-              notice($o.issue_code)
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(["NOT_IMPLEMENTED"])
-          end
-
-          it 'exposes details' do
-            code = <<-CODE
-              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', details => { 'detailk' => 'detailv' })
-              notice($o.details)
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(["{detailk => detailv}"])
-          end
-
-          it 'is an instance of its inferred type' do
-            code = <<-CODE
-              $o = Error('bad things happened', 'puppet/error')
-              notice($o =~ type($o))
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(['true'])
-          end
-
-          it 'is an instance of Error with matching kind' do
-            code = <<-CODE
-              $o = Error('bad things happened', 'puppet/error')
-              notice($o =~ Error[/puppet\\/error/])
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(['true'])
-          end
-
-          it 'is an instance of Error with matching issue_code' do
-            code = <<-CODE
-              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
-              notice($o =~ Error[default, 'FEE'])
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(['true'])
-          end
-
-          it 'is an instance of Error with matching kind and issue_code' do
-            code = <<-CODE
-              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
-              notice($o =~ Error['puppet/error', 'FEE'])
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(['true'])
-          end
-
-          it 'is not an instance of Error unless kind matches' do
-            code = <<-CODE
-              $o = Error('bad things happened', 'puppetlabs/error')
-              notice($o =~ Error[/puppet\\/error/])
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(['false'])
-          end
-
-          it 'is not an instance of Error unless issue_code matches' do
-            code = <<-CODE
-              $o = Error('bad things happened', 'puppetlabs/error', {}, 'BAR')
-              notice($o =~ Error[default, 'FOO'])
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(['false'])
-          end
-
-          it 'is not an instance of Error unless both kind and issue is a match' do
-            code = <<-CODE
-              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
-              notice($o =~ Error['puppetlabs/error', 'FEE'])
-              notice($o =~ Error['puppet/error', 'FUM'])
-              CODE
-            expect(eval_and_collect_notices(code)).to eq(['false', 'false'])
-          end
-        end
-      end
-    end
-  end
-end