puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/functions/defined_spec.rb

@@ -1,288 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/loaders'
-
-describe "the 'defined' function" do
-  after(:all) { Puppet::Pops::Loaders.clear }
-
-  # This loads the function once and makes it easy to call it
-  # It does not matter that it is not bound to the env used later since the function
-  # looks up everything via the scope that is given to it.
-  # The individual tests needs to have a fresh env/catalog set up
-  #
-  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
-  let(:func) { loaders.puppet_system_loader.load(:function, 'defined') }
-
-  before :each do
-    # A fresh environment is needed for each test since tests creates types and resources
-    environment = Puppet::Node::Environment.create(:testing, [])
-    @node = Puppet::Node.new('yaynode', :environment => environment)
-    @known_resource_types = environment.known_resource_types
-    @compiler = Puppet::Parser::Compiler.new(@node)
-    @scope = Puppet::Parser::Scope.new(@compiler)
-  end
-
-  def newclass(name)
-    @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
-  end
-
-  def newdefine(name)
-    @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
-  end
-
-  def newresource(type, title)
-    resource = Puppet::Resource.new(type, title)
-    @compiler.add_resource(@scope, resource)
-    resource
-  end
-
-  #--- CLASS
-  #
-  context 'can determine if a class' do
-    context 'is defined' do
-
-      it 'by using the class name in string form' do
-        newclass 'yayness'
-        expect(func.call(@scope, 'yayness')).to be_truthy
-      end
-
-      it 'by using a Type[Class[name]] type reference' do
-        name = 'yayness'
-        newclass name
-        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
-        type_type = Puppet::Pops::Types::TypeFactory.type_type(class_type)
-        expect(func.call(@scope, type_type)).to be_truthy
-      end
-    end
-
-    context 'is not defined' do
-      it 'by using the class name in string form' do
-        expect(func.call(@scope, 'yayness')).to be_falsey
-      end
-
-      it 'even if there is a define, by using a Type[Class[name]] type reference' do
-        name = 'yayness'
-        newdefine name
-        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
-        type_type = Puppet::Pops::Types::TypeFactory.type_type(class_type)
-        expect(func.call(@scope, type_type)).to be_falsey
-      end
-    end
-
-    context 'is defined and realized' do
-      it 'by using a Class[name] reference' do
-        name = 'cowabunga'
-        newclass name
-        newresource(:class, name)
-        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
-        expect(func.call(@scope, class_type)).to be_truthy
-      end
-    end
-
-    context 'is not realized' do
-      it '(although defined) by using a Class[name] reference' do
-        name = 'cowabunga'
-        newclass name
-        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
-        expect(func.call(@scope, class_type)).to be_falsey
-      end
-
-      it '(and not defined) by using a Class[name] reference' do
-        name = 'cowabunga'
-        class_type = Puppet::Pops::Types::TypeFactory.host_class(name)
-        expect(func.call(@scope, class_type)).to be_falsey
-      end
-    end
-  end
-
-  #---RESOURCE TYPE
-  #
-  context 'can determine if a resource type' do
-    context 'is defined' do
-
-      it 'by using the type name (of a built in type) in string form' do
-        expect(func.call(@scope, 'file')).to be_truthy
-      end
-
-      it 'by using the type name (of a resource type) in string form' do
-        newdefine 'yayness'
-        expect(func.call(@scope, 'yayness')).to be_truthy
-      end
-
-      it 'by using a File type reference (built in type)' do
-        resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
-        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
-        expect(func.call(@scope, type_type)).to be_truthy
-      end
-
-      it 'by using a Type[File] type reference' do
-        resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
-        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
-        expect(func.call(@scope, type_type)).to be_truthy
-      end
-
-      it 'by using a Resource[T] type reference (defined type)' do
-        name = 'yayness'
-        newdefine name
-        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
-        expect(func.call(@scope, resource_type)).to be_truthy
-      end
-
-      it 'by using a Type[Resource[T]] type reference (defined type)' do
-        name = 'yayness'
-        newdefine name
-        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
-        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
-        expect(func.call(@scope, type_type)).to be_truthy
-      end
-    end
-
-    context 'is not defined' do
-      it 'by using the resource name in string form' do
-        expect(func.call(@scope, 'notatype')).to be_falsey
-      end
-
-      it 'even if there is a class with the same name, by using a Type[Resource[T]] type reference' do
-        name = 'yayness'
-        newclass name
-        resource_type = Puppet::Pops::Types::TypeFactory.resource(name)
-        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
-        expect(func.call(@scope, type_type)).to be_falsey
-      end
-    end
-
-    context 'is defined and instance realized' do
-      it 'by using a Resource[T, title] reference for a built in type' do
-        type_name = 'file'
-        title = '/tmp/myfile'
-        newdefine type_name
-        newresource(type_name, title)
-        class_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
-        expect(func.call(@scope, class_type)).to be_truthy
-      end
-
-      it 'by using a Resource[T, title] reference for a defined type' do
-        type_name = 'meme'
-        title = 'cowabunga'
-        newdefine type_name
-        newresource(type_name, title)
-        class_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
-        expect(func.call(@scope, class_type)).to be_truthy
-      end
-    end
-
-    context 'is not realized' do
-      it '(although defined) by using a Resource[T, title] reference or Type[Resource[T, title]] reference' do
-        type_name = 'meme'
-        title = 'cowabunga'
-        newdefine type_name
-        resource_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
-        expect(func.call(@scope, resource_type)).to be_falsey
-
-        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
-        expect(func.call(@scope, type_type)).to be_falsey
-      end
-
-      it '(and not defined) by using a Resource[T, title] reference or Type[Resource[T, title]] reference' do
-        type_name = 'meme'
-        title = 'cowabunga'
-        resource_type = Puppet::Pops::Types::TypeFactory.resource(type_name, title)
-        expect(func.call(@scope, resource_type)).to be_falsey
-
-        type_type = Puppet::Pops::Types::TypeFactory.type_type(resource_type)
-        expect(func.call(@scope, type_type)).to be_falsey
-      end
-    end
-  end
-
-  #---VARIABLES
-  #
-  context 'can determine if a variable' do
-    context 'is defined' do
-      it 'by giving the variable in string form' do
-        @scope['x'] = 'something'
-        expect(func.call(@scope, '$x')).to be_truthy
-      end
-
-      it 'by giving a :: prefixed variable in string form' do
-        @compiler.topscope['x'] = 'something'
-        expect(func.call(@scope, '$::x')).to be_truthy
-      end
-
-      it 'by giving a numeric variable in string form (when there is a match scope)' do
-        # with no match scope, there are no numeric variables defined
-        expect(func.call(@scope, '$0')).to be_falsey
-        expect(func.call(@scope, '$42')).to be_falsey
-        pattern = Regexp.new('.*')
-        @scope.new_match_scope(pattern.match('anything'))
-
-        # with a match scope, all numeric variables are set (the match defines if they have a value or not, but they are defined)
-        # even if their value is undef.
-        expect(func.call(@scope, '$0')).to be_truthy
-        expect(func.call(@scope, '$42')).to be_truthy
-      end
-    end
-
-    context 'is undefined' do
-      it 'by giving a :: prefixed or regular variable in string form' do
-        expect(func.call(@scope, '$x')).to be_falsey
-        expect(func.call(@scope, '$::x')).to be_falsey
-      end
-    end
-  end
-
-  context 'has any? semantics when given multiple arguments' do
-    it 'and one of the names is a defined user defined type' do
-      newdefine 'yayness'
-      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_truthy
-    end
-
-    it 'and one of the names is a built type' do
-      expect(func.call(@scope, 'meh', 'file', 'booness')).to be_truthy
-    end
-
-    it 'and one of the names is a defined class' do
-      newclass 'yayness'
-      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_truthy
-    end
-
-    it 'is true when at least one variable exists in scope' do
-      @scope['x'] = 'something'
-      expect(func.call(@scope, '$y', '$x', '$z')).to be_truthy
-    end
-
-    it 'is false when none of the names are defined' do
-      expect(func.call(@scope, 'meh', 'yayness', 'booness')).to be_falsey
-    end
-  end
-
-  it 'raises an argument error when asking if Resource type is defined' do
-    resource_type = Puppet::Pops::Types::TypeFactory.resource
-    expect { func.call(@scope, resource_type)}.to raise_error(ArgumentError, /reference to all.*type/)
-  end
-
-  it 'raises an argument error if you ask if Class is defined' do
-    class_type = Puppet::Pops::Types::TypeFactory.host_class
-    expect { func.call(@scope, class_type) }.to raise_error(ArgumentError, /reference to all.*class/)
-  end
-
-  it 'raises error if referencing undef' do
-    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\], got Undef/)
-  end
-
-  it 'raises error if referencing a number' do
-    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\], got Integer/)
-  end
-
-  it 'is false if referencing empty string' do
-    expect(func.call(@scope, '')).to be_falsey
-  end
-
-  it "is true if referencing 'main'" do
-    # mimic what compiler does with "main" in intial import
-    newclass ''
-    newresource :class, ''
-    expect(func.call(@scope, 'main')).to be_truthy
-  end
-
-end

data/spec/unit/functions/dig_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the dig function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'returns a value from an array index via integer index' do
-    expect(compile_to_catalog("notify { [testing].dig(0): }")).to have_resource('Notify[testing]')
-  end
-
-  it 'returns undef if given an undef key' do
-  expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test-Undef-ing]')
-    notify { "test-${type([testing].dig(undef))}-ing": }
-    SOURCE
-  end
-
-  it 'returns undef if starting with undef' do
-  expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test-Undef-ing]')
-    notify { "test-${type(undef.dig(undef))}-ing": }
-    SOURCE
-  end
-
-  it 'returns a value from an hash key via given key' do
-    expect(compile_to_catalog("notify { {key => testing}.dig(key): }")).to have_resource('Notify[testing]')
-  end
-
-  it 'continues digging if result is an array' do
-    expect(compile_to_catalog("notify { [nope, [testing]].dig(1, 0): }")).to have_resource('Notify[testing]')
-  end
-
-  it 'continues digging if result is a hash' do
-    expect(compile_to_catalog("notify { [nope, {yes => testing}].dig(1, yes): }")).to have_resource('Notify[testing]')
-  end
-
-  it 'stops digging when step is undef' do
-    expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[testing]')
-    $result = [nope, {yes => testing}].dig(1, no, 2)
-    notify { "test${result}ing": }
-    SOURCE
-  end
-
-  it 'errors if step is neither Array nor Hash' do
-    expect { compile_to_catalog(<<-SOURCE)}.to raise_error(/The given data does not contain a Collection at \[1, "yes"\], got 'String'/)
-    $result = [nope, {yes => testing}].dig(1, yes, 2)
-    notify { "test${result}ing": }
-    SOURCE
-  end
-
-  it 'errors if not given a non Collection as the starting point' do
-    expect { compile_to_catalog(<<-SOURCE)}.to raise_error(/'dig' parameter 'data' expects a value of type Undef or Collection, got String/)
-    "hello".dig(1, yes, 2)
-    SOURCE
-  end
-
-end

data/spec/unit/functions/downcase_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the downcase function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'returns lower case version of a string' do
-    expect(compile_to_catalog("notify { 'ABC'.downcase: }")).to have_resource('Notify[abc]')
-  end
-
-  it 'returns the value if Numeric' do
-    expect(compile_to_catalog("notify { String(42.downcase == 42): }")).to have_resource('Notify[true]')
-  end
-
-  it 'performs downcase of international UTF-8 characters' do
-    expect(compile_to_catalog("notify { 'ÅÄÖ'.downcase: }")).to have_resource('Notify[åäö]')
-  end
-
-  it 'returns lower case version of each entry in an array (recursively)' do
-    expect(compile_to_catalog("notify { String(['A', ['B', ['C']]].downcase == ['a', ['b', ['c']]]): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns lower case version of keys and values in a hash (recursively)' do
-    expect(compile_to_catalog("notify { String({'A'=>'B','C'=>{'D'=>'E'}}.downcase == {'a'=>'b', 'c'=>{'d'=>'e'}}): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns lower case version of keys and values in nested hash / array structure' do
-    expect(compile_to_catalog("notify { String({'A'=>['B'],'C'=>[{'D'=>'E'}]}.downcase == {'a'=>['b'],'c'=>[{'d'=>'e'}]}): }")).to have_resource('Notify[true]')
-  end
-
-end

data/spec/unit/functions/each_spec.rb

@@ -1,107 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-require 'shared_behaviours/iterative_functions'
-
-describe 'the each method' do
-  include PuppetSpec::Compiler
-
-  context "should be callable as" do
-    it 'each on an array selecting each value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $a.each |$v| {
-          file { "/file_$v": ensure => present }
-        }
-      MANIFEST
-
-      expect(catalog.resource(:file, "/file_1")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_2")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
-    end
-
-    it 'each on an array selecting each value - function call style' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        each ($a) |$index, $v| {
-          file { "/file_$v": ensure => present }
-        }
-      MANIFEST
-
-      expect(catalog.resource(:file, "/file_1")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_2")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
-    end
-
-    it 'each on an array with index' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [present, absent, present]
-        $a.each |$k,$v| {
-          file { "/file_${$k+1}": ensure => $v }
-        }
-      MANIFEST
-
-      expect(catalog.resource(:file, "/file_1")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_2")['ensure']).to eq('absent')
-      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
-    end
-
-    it 'each on a hash selecting entries' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = {'a'=>'present','b'=>'absent','c'=>'present'}
-        $a.each |$e| {
-        file { "/file_${e[0]}": ensure => $e[1] }
-        }
-      MANIFEST
-
-      expect(catalog.resource(:file, "/file_a")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_b")['ensure']).to eq('absent')
-      expect(catalog.resource(:file, "/file_c")['ensure']).to eq('present')
-    end
-
-    it 'each on a hash selecting key and value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = {'a'=>present,'b'=>absent,'c'=>present}
-        $a.each |$k, $v| {
-          file { "/file_$k": ensure => $v }
-        }
-      MANIFEST
-
-      expect(catalog.resource(:file, "/file_a")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_b")['ensure']).to eq('absent')
-      expect(catalog.resource(:file, "/file_c")['ensure']).to eq('present')
-    end
-
-    it 'each on a hash selecting key and value (using captures-last parameter)' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = {'a'=>present,'b'=>absent,'c'=>present}
-        $a.each |*$kv| {
-          file { "/file_${kv[0]}": ensure => $kv[1] }
-        }
-      MANIFEST
-
-      expect(catalog.resource(:file, "/file_a")['ensure']).to eq('present')
-      expect(catalog.resource(:file, "/file_b")['ensure']).to eq('absent')
-      expect(catalog.resource(:file, "/file_c")['ensure']).to eq('present')
-    end
-  end
-
-  context "should produce receiver" do
-    it 'each checking produced value using single expression' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1, 3, 2]
-        $b = $a.each |$x| { "unwanted" }
-        file { "/file_${b[1]}":
-          ensure => present
-        }
-      MANIFEST
-
-      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
-    end
-
-  end
-  it_should_behave_like 'all iterative functions argument checks', 'each'
-  it_should_behave_like 'all iterative functions hash handling', 'each'
-
-end

data/spec/unit/functions/empty_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the empty function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  let(:logs) { [] }
-  let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
-
-  context 'for an array it' do
-    it 'returns true when empty' do
-      expect(compile_to_catalog("notify { String(empty([])): }")).to have_resource('Notify[true]')
-    end
-
-    it 'returns false when not empty' do
-      expect(compile_to_catalog("notify { String(empty([1])): }")).to have_resource('Notify[false]')
-    end
-  end
-
-  context 'for a hash it' do
-    it 'returns true when empty' do
-      expect(compile_to_catalog("notify { String(empty({})): }")).to have_resource('Notify[true]')
-    end
-
-    it 'returns false when not empty' do
-      expect(compile_to_catalog("notify { String(empty({1=>1})): }")).to have_resource('Notify[false]')
-    end
-  end
-
-  context 'for numeric values it' do
-    it 'always returns false for integer values (including 0)' do
-      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-        expect(compile_to_catalog("notify { String(empty(0)): }")).to have_resource('Notify[false]')
-      end
-      expect(warnings).to include(/Calling function empty\(\) with Numeric value is deprecated/)
-    end
-
-    it 'always returns false for float values (including 0.0)' do
-      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-        expect(compile_to_catalog("notify { String(empty(0.0)): }")).to have_resource('Notify[false]')
-      end
-      expect(warnings).to include(/Calling function empty\(\) with Numeric value is deprecated/)
-    end
-  end
-
-  context 'for a string it' do
-    it 'returns true when empty' do
-      expect(compile_to_catalog("notify { String(empty('')): }")).to have_resource('Notify[true]')
-    end
-
-    it 'returns false when not empty' do
-      expect(compile_to_catalog("notify { String(empty(' ')): }")).to have_resource('Notify[false]')
-    end
-  end
-
-  context 'for a sensitive string it' do
-    it 'returns true when empty' do
-      expect(compile_to_catalog("notify { String(empty(Sensitive(''))): }")).to have_resource('Notify[true]')
-    end
-
-    it 'returns false when not empty' do
-      expect(compile_to_catalog("notify { String(empty(Sensitive(' '))): }")).to have_resource('Notify[false]')
-    end
-  end
-
-  context 'for a binary it' do
-    it 'returns true when empty' do
-      expect(compile_to_catalog("notify { String(empty(Binary(''))): }")).to have_resource('Notify[true]')
-    end
-
-    it 'returns false when not empty' do
-      expect(compile_to_catalog("notify { String(empty(Binary('b25l'))): }")).to have_resource('Notify[false]')
-    end
-  end
-
-  context 'for undef it' do
-    it 'returns true without deprecation warning' do
-      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-        expect(compile_to_catalog("notify { String(empty(undef)): }")).to have_resource('Notify[true]')
-      end
-      expect(warnings).to_not include(/Calling function empty\(\) with Undef value is deprecated/)
-    end
-  end
-end