puppet 8.4.0-universal-darwin → 8.5.1-universal-darwin

data/spec/unit/datatypes_spec.rb

@@ -1,352 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-require 'puppet_spec/files'
-require 'puppet/pops'
-
-module PuppetSpec::DataTypes
-describe "Puppet::DataTypes" do
-  include PuppetSpec::Compiler
-  include PuppetSpec::Files
-
-  let(:modules) { { 'mytest' => mytest } }
-  let(:datatypes) { {} }
-  let(:environments_dir) { Puppet[:environmentpath] }
-
-  let(:mytest) {{
-    'lib' => {
-      'puppet' => {
-        'datatypes' => mytest_datatypes,
-        'functions' => mytest_functions },
-      'puppetx' => { 'mytest' => mytest_classes },
-    }
-  }}
-
-  let(:mytest_datatypes) { {} }
-  let(:mytest_classes) { {} }
-  let(:mytest_functions) { {
-    'mytest' => {
-      'to_data.rb' => <<-RUBY.unindent,
-        Puppet::Functions.create_function('mytest::to_data') do
-          def to_data(data)
-            Puppet::Pops::Serialization::ToDataConverter.convert(data, {
-              :rich_data => true,
-              :symbol_as_string => true,
-              :type_by_reference => true,
-              :message_prefix => 'test'
-            })
-          end
-        end
-        RUBY
-
-      'from_data.rb' => <<-RUBY.unindent,
-        Puppet::Functions.create_function('mytest::from_data') do
-          def from_data(data)
-            Puppet::Pops::Serialization::FromDataConverter.convert(data)
-          end
-        end
-        RUBY
-
-      'serialize.rb' => <<-RUBY.unindent,
-        Puppet::Functions.create_function('mytest::serialize') do
-          def serialize(data)
-            buffer = ''
-            serializer = Puppet::Pops::Serialization::Serializer.new(
-              Puppet::Pops::Serialization::JSON::Writer.new(buffer))
-            serializer.write(data)
-            serializer.finish
-            buffer
-          end
-        end
-        RUBY
-
-      'deserialize.rb' => <<-RUBY.unindent,
-        Puppet::Functions.create_function('mytest::deserialize') do
-          def deserialize(data)
-            deserializer = Puppet::Pops::Serialization::Deserializer.new(
-              Puppet::Pops::Serialization::JSON::Reader.new(data), Puppet::Pops::Loaders.find_loader(nil))
-            deserializer.read
-          end
-        end
-        RUBY
-      }
-  } }
-
-  let(:testing_env_dir) do
-    dir_contained_in(environments_dir, testing_env)
-    env_dir = File.join(environments_dir, 'testing')
-    PuppetSpec::Files.record_tmp(env_dir)
-    env_dir
-  end
-
-  let(:modules_dir) { File.join(testing_env_dir, 'modules') }
-  let(:env) { Puppet::Node::Environment.create(:testing, [modules_dir]) }
-  let(:node) { Puppet::Node.new('test', :environment => env) }
-
-  let(:testing_env) do
-    {
-      'testing' => {
-        'lib' => { 'puppet' => { 'datatypes' => datatypes } },
-        'modules' => modules,
-      }
-    }
-  end
-
-  before(:each) do
-    Puppet[:environment] = 'testing'
-  end
-
-  context 'when creating type with derived attributes using implementation' do
-    let(:datatypes) {
-      {
-        'mytype.rb' => <<-RUBY.unindent,
-          Puppet::DataTypes.create_type('Mytype') do
-            interface <<-PUPPET
-              attributes => {
-                name => { type => String },
-                year_of_birth => { type => Integer },
-                age => { type => Integer, kind => derived },
-              }
-              PUPPET
-
-            implementation do
-              def age
-                DateTime.now.year - @year_of_birth
-              end
-            end
-          end
-          RUBY
-      }
-    }
-
-    it 'loads and returns value of attribute' do
-      expect(eval_and_collect_notices('notice(Mytype("Bob", 1984).age)', node)).to eql(["#{DateTime.now.year - 1984}"])
-    end
-
-    it 'can convert value to and from data' do
-      expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eql(['false', 'true', 'true', "#{DateTime.now.year - 1984}"])
-        $m = Mytype("Bob", 1984)
-        $d = $m.mytest::to_data
-        notice($m == $d)
-        notice($d =~ Data)
-        $m2 = $d.mytest::from_data
-        notice($m == $m2)
-        notice($m2.age)
-      PUPPET
-    end
-  end
-
-  context 'when creating type for an already implemented class' do
-    let(:datatypes) {
-      {
-        'mytest.rb' => <<-RUBY.unindent,
-          Puppet::DataTypes.create_type('Mytest') do
-            interface <<-PUPPET
-              attributes => {
-                name => { type => String },
-                year_of_birth => { type => Integer },
-                age => { type => Integer, kind => derived },
-              },
-              functions => {
-                '[]' => Callable[[String[1]], Variant[String, Integer]]
-              }
-              PUPPET
-
-            implementation_class PuppetSpec::DataTypes::MyTest
-          end
-      RUBY
-      }
-    }
-
-    before(:each) do
-      class ::PuppetSpec::DataTypes::MyTest
-        attr_reader :name, :year_of_birth
-
-        def initialize(name, year_of_birth)
-          @name = name
-          @year_of_birth = year_of_birth
-        end
-
-        def age
-          DateTime.now.year - @year_of_birth
-        end
-
-        def [](key)
-          case key
-          when 'name'
-            @name
-          when 'year_of_birth'
-            @year_of_birth
-          when 'age'
-            age
-          else
-            nil
-          end
-        end
-
-        def ==(o)
-          self.class == o.class && @name == o.name && @year_of_birth == o.year_of_birth
-        end
-      end
-    end
-
-    after(:each) do
-      ::PuppetSpec::DataTypes.send(:remove_const, :MyTest)
-    end
-
-    it 'loads and returns value of attribute' do
-      expect(eval_and_collect_notices('notice(Mytest("Bob", 1984).age)', node)).to eql(["#{DateTime.now.year - 1984}"])
-    end
-
-    it 'can convert value to and from data' do
-      expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eql(['true', 'true', "#{DateTime.now.year - 1984}"])
-        $m = Mytest("Bob", 1984)
-        $d = $m.mytest::to_data
-        notice($d =~ Data)
-        $m2 = $d.mytest::from_data
-        notice($m == $m2)
-        notice($m2.age)
-        PUPPET
-    end
-
-    it 'can access using implemented [] method' do
-      expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eql(['Bob', "#{DateTime.now.year - 1984}"])
-        $m = Mytest("Bob", 1984)
-        notice($m['name'])
-        notice($m['age'])
-      PUPPET
-    end
-
-    it 'can serialize and deserialize data' do
-      expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eql(['true', 'true', "#{DateTime.now.year - 1984}"])
-        $m = Mytest("Bob", 1984)
-        $d = $m.mytest::serialize
-        notice($d =~ String)
-        $m2 = $d.mytest::deserialize
-        notice($m == $m2)
-        notice($m2.age)
-        PUPPET
-    end
-  end
-
-  context 'when creating type with custom new_function' do
-    let(:datatypes) {
-      {
-        'mytest.rb' => <<-RUBY.unindent,
-          Puppet::DataTypes.create_type('Mytest') do
-            interface <<-PUPPET
-              attributes => {
-                strings => { type => Array[String] },
-                ints => { type => Array[Integer] },
-              }
-              PUPPET
-
-          implementation_class PuppetSpec::DataTypes::MyTest
-        end
-      RUBY
-      }
-    }
-
-    before(:each) do
-      class ::PuppetSpec::DataTypes::MyTest
-        def self.create_new_function(t)
-          Puppet::Functions.create_function('new_%s' % t.name) do
-            dispatch :create do
-              repeated_param 'Variant[String,Integer]', :args
-            end
-
-            def create(*args)
-              ::PuppetSpec::DataTypes::MyTest.new(*args.partition { |arg| arg.is_a?(String) })
-            end
-          end
-        end
-        attr_reader :strings, :ints
-
-        def initialize(strings, ints)
-          @strings = strings
-          @ints = ints
-        end
-      end
-    end
-
-    after(:each) do
-      ::PuppetSpec::DataTypes.send(:remove_const, :MyTest)
-    end
-
-    it 'loads and calls custom new function' do
-      expect(eval_and_collect_notices('notice(Mytest("A", 32, "B", 20).ints)', node)).to eql(['[32, 20]'])
-    end
-  end
-
-  context 'with data type and class defined in a module' do
-    let(:mytest_classes) {
-      {
-        'position.rb' => <<-RUBY
-            module PuppetX; module Mytest; class Position
-              attr_reader :x, :y
-
-              def initialize(x, y)
-                @x = x
-                @y = y
-              end
-            end; end; end
-      RUBY
-      }
-    }
-
-    after(:each) do
-      ::PuppetX.send(:remove_const, :Mytest)
-    end
-
-    context 'in module namespace' do
-      let(:mytest_datatypes) {
-        {
-          'mytest' => { 'position.rb' => <<-RUBY
-            Puppet::DataTypes.create_type('Mytest::Position') do
-              interface <<-PUPPET
-                attributes => {
-                  x => Integer,
-                  y => Integer
-                }
-                PUPPET
-
-              load_file('puppetx/mytest/position')
-
-              implementation_class PuppetX::Mytest::Position
-            end
-            RUBY
-          }
-        }
-      }
-
-      it 'loads and returns value of attribute' do
-        expect(eval_and_collect_notices('notice(Mytest::Position(23, 12).x)', node)).to eql(['23'])
-      end
-    end
-
-    context 'in top namespace' do
-      let(:mytest_datatypes) {
-        {
-          'position.rb' => <<-RUBY
-            Puppet::DataTypes.create_type('Position') do
-              interface <<-PUPPET
-                attributes => {
-                  x => Integer,
-                  y => Integer
-                }
-                PUPPET
-
-              load_file('puppetx/mytest/position')
-
-              implementation_class PuppetX::Mytest::Position
-            end
-        RUBY
-        }
-      }
-
-      it 'loads and returns value of attribute' do
-        expect(eval_and_collect_notices('notice(Position(23, 12).x)', node)).to eql(['23'])
-      end
-    end
-  end
-end
-end

data/spec/unit/defaults_spec.rb

@@ -1,182 +0,0 @@
-require 'spec_helper'
-require 'puppet/settings'
-
-describe "Defaults" do
-  describe ".default_diffargs" do
-    it "should be '-u'" do
-      expect(Puppet.default_diffargs).to eq("-u")
-    end
-  end
-
-  describe 'strict' do
-    it 'should accept the valid value :off' do
-      expect {Puppet.settings[:strict] = 'off'}.to_not raise_exception
-    end
-
-    it 'should accept the valid value :warning' do
-      expect {Puppet.settings[:strict] = 'warning'}.to_not raise_exception
-    end
-
-    it 'should accept the valid value :error' do
-      expect {Puppet.settings[:strict] = 'error'}.to_not raise_exception
-    end
-
-    it 'should fail if given an invalid value' do
-      expect {Puppet.settings[:strict] = 'ignore'}.to raise_exception(/Invalid value 'ignore' for parameter strict\./)
-    end
-  end
-
-  describe '.default_digest_algorithm' do
-    it 'defaults to sha256 when FIPS is not enabled' do
-      allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(false)
-      expect(Puppet.default_digest_algorithm).to eq('sha256')
-    end
-
-    it 'defaults to sha256 when FIPS is enabled' do
-      allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(true)
-      expect(Puppet.default_digest_algorithm).to eq('sha256')
-    end
-  end
-
-  describe '.supported_checksum_types' do
-    it 'defaults to sha256, sha384, sha512, sha224, md5 when FIPS is not enabled' do
-      allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(false)
-      expect(Puppet.default_file_checksum_types).to eq(%w[sha256 sha384 sha512 sha224 md5])
-    end
-
-    it 'defaults to sha256, sha384, sha512, sha224 when FIPS is enabled' do
-      allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(true)
-      expect(Puppet.default_file_checksum_types).to eq(%w[sha256 sha384 sha512 sha224])
-    end
-  end
-
-  describe 'Puppet[:supported_checksum_types]' do
-    it 'defaults to sha256, sha512, sha384, sha224, md5' do
-      expect(Puppet.settings[:supported_checksum_types]).to eq(%w[sha256 sha384 sha512 sha224 md5])
-    end
-
-    it 'should raise an error on an unsupported checksum type' do
-      expect {
-        Puppet.settings[:supported_checksum_types] = %w[md5 foo]
-      }.to raise_exception ArgumentError,
-                           /Invalid value 'foo' for parameter supported_checksum_types. Allowed values are/
-    end
-
-    it 'should not raise an error on setting a valid list of checksum types' do
-      Puppet.settings[:supported_checksum_types] = %w[sha256 md5lite mtime]
-      expect(Puppet.settings[:supported_checksum_types]).to eq(%w[sha256 md5lite mtime])
-    end
-
-    it 'raises when setting md5 in FIPS mode' do
-      allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(true)
-      expect {
-        Puppet.settings[:supported_checksum_types] = %w[md5]
-      }.to raise_error(ArgumentError,
-                       /Invalid value 'md5' for parameter supported_checksum_types. Allowed values are 'sha256'/)
-    end
-  end
-
-  describe 'manage_internal_file_permissions' do
-    describe 'on windows', :if => Puppet::Util::Platform.windows? do
-      it 'should default to false' do
-        expect(Puppet.settings[:manage_internal_file_permissions]).to be false
-      end
-    end
-
-    describe 'on non-windows', :if => ! Puppet::Util::Platform.windows? do
-      it 'should default to true' do
-        expect(Puppet.settings[:manage_internal_file_permissions]).to be true
-      end
-    end
-  end
-
-  describe 'basemodulepath' do
-    it 'includes the user and system modules', :unless => Puppet::Util::Platform.windows? do
-      expect(
-        Puppet[:basemodulepath]
-      ).to match(%r{.*/code/modules:/opt/puppetlabs/puppet/modules$})
-    end
-
-    describe 'on windows', :if => Puppet::Util::Platform.windows? do
-      let(:installdir) { 'C:\Program Files\Puppet Labs\Puppet' }
-
-      it 'includes user and system modules' do
-        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(installdir)
-
-        expect(
-          Puppet.default_basemodulepath
-        ).to eq('$codedir/modules;C:\Program Files\Puppet Labs\Puppet/puppet/modules')
-      end
-
-      it 'includes user modules if installdir fact is missing' do
-        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(nil)
-
-        expect(
-          Puppet.default_basemodulepath
-        ).to eq('$codedir/modules')
-      end
-    end
-  end
-
-  describe 'vendormoduledir' do
-    it 'includes the default vendormoduledir', :unless => Puppet::Util::Platform.windows? do
-      expect(
-        Puppet[:vendormoduledir]
-      ).to eq('/opt/puppetlabs/puppet/vendor_modules')
-    end
-
-    describe 'on windows', :if => Puppet::Util::Platform.windows? do
-      let(:installdir) { 'C:\Program Files\Puppet Labs\Puppet' }
-
-      it 'includes the default vendormoduledir' do
-        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(installdir)
-
-        expect(
-          Puppet.default_vendormoduledir
-        ).to eq('C:\Program Files\Puppet Labs\Puppet\puppet\vendor_modules')
-      end
-
-      it 'is nil if installdir fact is missing' do
-        allow(ENV).to receive(:[]).with("FACTER_env_windows_installdir").and_return(nil)
-
-        expect(Puppet.default_vendormoduledir).to be_nil
-      end
-    end
-  end
-
-  describe "deprecated settings" do
-    it 'does not issue a deprecation warning by default' do
-      expect(Puppet).to receive(:deprecation_warning).never
-
-      Puppet.initialize_settings
-    end
-  end
-
-  describe "the default cadir", :unless => Puppet::Util::Platform.windows?  do
-    it 'defaults to the puppetserver confdir when no cadir is found' do
-      Puppet.initialize_settings
-      expect(Puppet[:cadir]).to eq('/etc/puppetlabs/puppetserver/ca')
-    end
-
-    it 'returns an empty string for Windows platforms', :if => Puppet::Util::Platform.windows? do
-      Puppet.initialize_settings
-      expect(Puppet[:cadir]).to eq("")
-    end
-  end
-
-  describe '#default_cadir', :unless => Puppet::Util::Platform.windows?  do
-    it 'warns when a CA dir exists in the current ssldir' do
-      cadir = File.join(Puppet[:ssldir], 'ca')
-      FileUtils.mkdir_p(cadir)
-      expect(Puppet.default_cadir).to eq(cadir)
-    end
-  end
-
-  describe "#preferred_serialization_format" do
-    it 'raises if PSON is not available', unless: Puppet.features.pson? do
-      expect {
-        Puppet.settings[:preferred_serialization_format] = "pson"
-      }.to raise_error(Puppet::Settings::ValidationError, "The 'puppet-pson' gem must be installed to use the PSON serialization format.")
-    end
-  end
-end