puppet 7.28.0-x86-mingw32 → 7.29.0-x86-mingw32

data/spec/shared_behaviours/hiera_indirections.rb

@@ -1,98 +0,0 @@
-shared_examples_for "Hiera indirection" do |test_klass, fixture_dir|
-  include PuppetSpec::Files
-
-  def write_hiera_config(config_file, datadir)
-    File.open(config_file, 'w') do |f|
-      f.write("---
-        :yaml:
-          :datadir: #{datadir}
-        :hierarchy: ['global', 'invalid']
-        :logger: 'noop'
-        :backends: ['yaml']
-      ")
-    end
-  end
-
-  def request(key)
-    Puppet::Indirector::Request.new(:hiera, :find, key, nil)
-  end
-
-  before do
-    hiera_config_file = tmpfile("hiera.yaml")
-    Puppet.settings[:hiera_config] = hiera_config_file
-    write_hiera_config(hiera_config_file, fixture_dir)
-  end
-
-  after do
-    test_klass.instance_variable_set(:@hiera, nil)
-  end
-
-  it "should be the default data_binding terminus" do
-    expect(Puppet.settings[:data_binding_terminus]).to eq(:hiera)
-  end
-
-  it "should raise an error if we don't have the hiera feature" do
-    expect(Puppet.features).to receive(:hiera?).and_return(false)
-    expect { test_klass.new }.to raise_error RuntimeError,
-      "Hiera terminus not supported without hiera library"
-  end
-
-  describe "the behavior of the hiera_config method", :if => Puppet.features.hiera? do
-    it "should override the logger and set it to puppet" do
-      expect(test_klass.hiera_config[:logger]).to eq("puppet")
-    end
-
-    context "when the Hiera configuration file does not exist" do
-      let(:path) { File.expand_path('/doesnotexist') }
-
-      before do
-        Puppet.settings[:hiera_config] = path
-      end
-
-      it "should log a warning" do
-        expect(Puppet).to receive(:warning).with(
-         "Config file #{path} not found, using Hiera defaults")
-        test_klass.hiera_config
-      end
-
-      it "should only configure the logger and set it to puppet" do
-        expect(Puppet).to receive(:warning).with(
-         "Config file #{path} not found, using Hiera defaults")
-        expect(test_klass.hiera_config).to eq({ :logger => 'puppet' })
-      end
-    end
-  end
-
-  describe "the behavior of the find method", :if => Puppet.features.hiera? do
-    let(:data_binder) { test_klass.new }
-
-    it "should support looking up an integer" do
-      expect(data_binder.find(request("integer"))).to eq(3000)
-    end
-
-    it "should support looking up a string" do
-      expect(data_binder.find(request("string"))).to eq('apache')
-    end
-
-    it "should support looking up an array" do
-      expect(data_binder.find(request("array"))).to eq([
-        '0.ntp.puppetlabs.com',
-        '1.ntp.puppetlabs.com',
-      ])
-    end
-
-    it "should support looking up a hash" do
-      expect(data_binder.find(request("hash"))).to eq({
-        'user'  => 'Hightower',
-        'group' => 'admin',
-        'mode'  => '0644'
-      })
-    end
-
-    it "raises a data binding error if hiera cannot parse the yaml data" do
-      expect do
-        data_binder.find(request('invalid'))
-      end.to raise_error(Puppet::DataBinding::LookupError)
-    end
-  end
-end

data/spec/shared_behaviours/iterative_functions.rb

@@ -1,68 +0,0 @@
-shared_examples_for 'all iterative functions hash handling' do |func|
-  it 'passes a hash entry as an array of the key and value' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      {a=>1}.#{func} |$v| { notify { "${v[0]} ${v[1]}": } }
-    MANIFEST
-
-    expect(catalog.resource(:notify, "a 1")).not_to be_nil
-  end
-end
-
-shared_examples_for 'all iterative functions argument checks' do |func|
-
-  it 'raises an error when used against an unsupported type' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        3.14.#{func} |$k, $v| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects an Iterable value, got Float/)
-  end
-
-  it 'raises an error when called with any parameters besides a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].#{func}(1,2) |$v,$y| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects (?:between 1 and 2 arguments|1 argument), got 3/)
-  end
-
-  it 'raises an error when called without a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].#{func}
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects a block/)
-  end
-
-  it 'raises an error when called with something that is not a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].#{func}(1,2)
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects (?:between 1 and 2 arguments|1 argument), got 3/)
-  end
-
-  it 'raises an error when called with a block with too many required parameters' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].#{func}() |$v1, $v2, $v3| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /block expects(?: between 1 and)? 2 arguments, got 3/)
-  end
-
-  it 'raises an error when called with a block with too few parameters' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].#{func}() | | {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /block expects(?: between 1 and)? 2 arguments, got none/)
-  end
-
-  it 'does not raise an error when called with a block with too many but optional arguments' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].#{func}() |$v1, $v2, $v3=extra| {  }
-      MANIFEST
-    end.to_not raise_error
-  end
-end

data/spec/shared_behaviours/memory_terminus.rb

@@ -1,28 +0,0 @@
-shared_examples_for "A Memory Terminus" do
-  it "should find no instances by default" do
-    expect(@searcher.find(@request)).to be_nil
-  end
-
-  it "should be able to find instances that were previously saved" do
-    @searcher.save(@request)
-    expect(@searcher.find(@request)).to equal(@instance)
-  end
-
-  it "should replace existing saved instances when a new instance with the same name is saved" do
-    @searcher.save(@request)
-    two = double('second', :name => @name)
-    trequest = double('request', :key => @name, :instance => two)
-    @searcher.save(trequest)
-    expect(@searcher.find(@request)).to equal(two)
-  end
-
-  it "should be able to remove previously saved instances" do
-    @searcher.save(@request)
-    @searcher.destroy(@request)
-    expect(@searcher.find(@request)).to be_nil
-  end
-
-  it "should fail when asked to destroy an instance that does not exist" do
-    expect { @searcher.destroy(@request) }.to raise_error(ArgumentError)
-  end
-end

data/spec/shared_behaviours/path_parameters.rb

@@ -1,160 +0,0 @@
-# In order to use this correctly you must define a method to get an instance
-# of the type being tested, so that this code can remain generic:
-#
-#    it_should_behave_like "all path parameters", :path do
-#      def instance(path)
-#        Puppet::Type.type(:example).new(
-#          :name => 'foo', :require => 'bar', :path_param => path
-#        )
-#      end
-#
-# That method will be invoked for each test to create the instance that we
-# subsequently test through the system; you should ensure that the minimum of
-# possible attributes are set to keep the tests clean.
-#
-# You must also pass the symbolic name of the parameter being tested to the
-# block, and optionally can pass a hash of additional options to the block.
-#
-# The known options are:
-#  :array :: boolean, does this support arrays of paths, default true.
-
-shared_examples_for "all pathname parameters with arrays" do |win32|
-  path_types = {
-    "unix absolute"            => %q{/foo/bar},
-    "unix relative"            => %q{foo/bar},
-    "win32 non-drive absolute" => %q{\foo\bar},
-    "win32 non-drive relative" => %q{foo\bar},
-    "win32 drive absolute"     => %q{c:\foo\bar},
-    "win32 drive relative"     => %q{c:foo\bar}
-  }
-
-  describe "when given an array of paths" do
-    (1..path_types.length).each do |n|
-      path_types.keys.combination(n) do |set|
-        data = path_types.collect { |k, v| set.member?(k) ? v : nil } .compact
-
-        has_relative = set.find { |k| k =~ /relative/ or k =~ /non-drive/ }
-        has_windows = set.find { |k| k =~ /win32/ }
-        has_unix = set.find { |k| k =~ /unix/ }
-
-        if has_relative or (has_windows and !win32) or (has_unix and win32)
-          reject = true
-        else
-          reject = false
-        end
-
-        it "should #{reject ? 'reject' : 'accept'} #{set.join(", ")}" do
-          if reject then
-            expect { instance(data) }.
-              to raise_error Puppet::Error, /fully qualified/
-          else
-            instance = instance(data)
-            expect(instance[@param]).to eq(data)
-          end
-        end
-
-        it "should #{reject ? 'reject' : 'accept'} #{set.join(", ")} doubled" do
-          if reject then
-            expect { instance(data + data) }.
-              to raise_error Puppet::Error, /fully qualified/
-          else
-            instance = instance(data + data)
-            expect(instance[@param]).to eq(data + data)
-          end
-        end
-      end
-    end
-  end
-end
-
-
-shared_examples_for "all path parameters" do |param, options|
-  # Extract and process options to the block.
-  options ||= {}
-  array = options[:array].nil? ? true : options.delete(:array)
-  if options.keys.length > 0 then
-    fail "unknown options for 'all path parameters': " +
-      options.keys.sort.join(', ')
-  end
-
-  def instance(path)
-    fail "we didn't implement the 'instance(path)' method in the it_should_behave_like block"
-  end
-
-  ########################################################################
-  # The actual testing code...
-  before :all do
-    @param = param
-  end
-
-  describe "on a Unix-like platform it", :if => Puppet.features.posix? do
-    if array then
-      it_should_behave_like "all pathname parameters with arrays", false
-    end
-
-    it "should accept a fully qualified path" do
-      path = File.join('', 'foo')
-      instance = instance(path)
-      expect(instance[@param]).to eq(path)
-    end
-
-    it "should give a useful error when the path is not absolute" do
-      path = 'foo'
-      expect { instance(path) }.
-        to raise_error Puppet::Error, /fully qualified/
-    end
-
-    { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
-      %w{q Q a A z Z c C}.sort.each do |drive|
-        it "should reject drive letter '#{drive}' with #{style} path separators" do
-          path = "#{drive}:#{slash}Program Files"
-          expect { instance(path) }.
-            to raise_error Puppet::Error, /fully qualified/
-        end
-      end
-    end
-  end
-
-  describe "on a Windows-like platform it", :if => Puppet::Util::Platform.windows? do
-    if array then
-      it_should_behave_like "all pathname parameters with arrays", true
-    end
-
-    it "should reject a fully qualified unix path" do
-      path = '/foo'
-      expect { instance(path) }.to raise_error(Puppet::Error, /fully qualified/)
-    end
-
-    it "should give a useful error when the path is not absolute" do
-      path = 'foo'
-      expect { instance(path) }.
-        to raise_error Puppet::Error, /fully qualified/
-    end
-
-    it "also accepts Unix style path separators" do
-      path = 'C:/Program Files'
-      instance = instance(path)
-      expect(instance[@param]).to eq(path)
-    end
-
-    { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
-      %w{q Q a A z Z c C}.sort.each do |drive|
-        it "should accept drive letter '#{drive}' with #{style} path separators " do
-          path = "#{drive}:#{slash}Program Files"
-          instance = instance(path)
-          expect(instance[@param]).to eq(path)
-        end
-      end
-    end
-
-    { "UNC paths"            => %q{\\\\foo\bar},
-      "unparsed local paths" => %q{\\\\?\c:\foo},
-      "unparsed UNC paths"   => %q{\\\\?\foo\bar}
-    }.each do |name, path|
-      it "should accept #{name} as absolute" do
-        instance = instance(path)
-        expect(instance[@param]).to eq(path)
-      end
-    end
-  end
-end

data/spec/shared_behaviours/store_configs_terminus.rb

@@ -1,21 +0,0 @@
-shared_examples_for "a StoreConfigs terminus" do
-  before :each do
-    Puppet[:storeconfigs] = true
-    Puppet[:storeconfigs_backend] = "store_configs_testing"
-  end
-
-  api = [:find, :search, :save, :destroy, :head]
-
-  api.each do |name|
-    it { is_expected.to respond_to(name) }
-  end
-
-  it "should fail if an invalid backend is configured" do
-    Puppet[:storeconfigs_backend] = "synergy"
-    expect { subject }.to raise_error(ArgumentError, /could not find terminus synergy/i)
-  end
-
-  it "should wrap the declared backend" do
-    expect(subject.target.class.name).to eq(:store_configs_testing)
-  end
-end

data/spec/shared_behaviours/things_that_declare_options.rb

@@ -1,262 +0,0 @@
-# encoding: UTF-8
-shared_examples_for "things that declare options" do
-  it "should support options without arguments" do
-    thing = add_options_to { option "--bar" }
-    expect(thing).to be_option :bar
-  end
-
-  it "should support options with an empty block" do
-    thing = add_options_to do
-      option "--foo" do
-        # this section deliberately left blank
-      end
-    end
-    expect(thing).to be
-    expect(thing).to be_option :foo
-  end
-
-  { "--foo=" => :foo }.each do |input, option|
-    it "should accept #{name.inspect}" do
-      thing = add_options_to { option input }
-      expect(thing).to be_option option
-    end
-  end
-
-  it "should support option documentation" do
-    text = "Sturm und Drang (German pronunciation: [ˈʃtʊʁm ʊnt ˈdʁaŋ]) …"
-
-    thing = add_options_to do
-      option "--foo" do
-        description text
-        summary text
-      end
-    end
-
-    expect(thing.get_option(:foo).description).to eq(text)
-  end
-
-  it "should list all the options" do
-    thing = add_options_to do
-      option "--foo"
-      option "--bar", '-b'
-      option "-q", "--quux"
-      option "-f"
-      option "--baz"
-    end
-    expect(thing.options).to eq([:foo, :bar, :quux, :f, :baz])
-  end
-
-  it "should detect conflicts in long options" do
-    expect {
-      add_options_to do
-        option "--foo"
-        option "--foo"
-      end
-    }.to raise_error ArgumentError, /Option foo conflicts with existing option foo/i
-  end
-
-  it "should detect conflicts in short options" do
-    expect {
-      add_options_to do
-        option "-f"
-        option "-f"
-      end
-    }.to raise_error ArgumentError, /Option f conflicts with existing option f/
-  end
-
-  ["-f", "--foo"].each do |option|
-    ["", " FOO", "=FOO", " [FOO]", "=[FOO]"].each do |argument|
-      input = option + argument
-      it "should detect conflicts within a single option like #{input.inspect}" do
-        expect {
-          add_options_to do
-            option input, input
-          end
-        }.to raise_error ArgumentError, /duplicates existing alias/
-      end
-    end
-  end
-
-
-  # Verify the range of interesting conflicts to check for ordering causing
-  # the behaviour to change, or anything exciting like that.
-  [ %w{--foo}, %w{-f}, %w{-f --foo}, %w{--baz -f},
-    %w{-f --baz}, %w{-b --foo}, %w{--foo -b}
-  ].each do |conflict|
-    base = %w{--foo -f}
-    it "should detect conflicts between #{base.inspect} and #{conflict.inspect}" do
-      expect {
-        add_options_to do
-          option(*base)
-          option(*conflict)
-        end
-      }.to raise_error ArgumentError, /conflicts with existing option/
-    end
-  end
-
-  it "should fail if we are not consistent about taking an argument" do
-    expect { add_options_to do option "--foo=bar", "--bar" end }.
-      to raise_error ArgumentError, /inconsistent about taking an argument/
-  end
-
-  it "should not accept optional arguments" do
-    expect do
-      thing = add_options_to do option "--foo=[baz]", "--bar=[baz]" end
-      [:foo, :bar].each do |name|
-        expect(thing).to be_option name
-      end
-    end.to raise_error(ArgumentError, /optional arguments are not supported/)
-  end
-
-  describe "#takes_argument?" do
-    it "should detect an argument being absent" do
-      thing = add_options_to do option "--foo" end
-      expect(thing.get_option(:foo)).not_to be_takes_argument
-    end
-    ["=FOO", " FOO"].each do |input|
-      it "should detect an argument given #{input.inspect}" do
-        thing = add_options_to do option "--foo#{input}" end
-        expect(thing.get_option(:foo)).to be_takes_argument
-      end
-    end
-  end
-
-  describe "#optional_argument?" do
-    it "should be false if no argument is present" do
-      option = add_options_to do option "--foo" end.get_option(:foo)
-      expect(option).not_to be_takes_argument
-      expect(option).not_to be_optional_argument
-    end
-
-    ["=FOO", " FOO"].each do |input|
-      it "should be false if the argument is mandatory (like #{input.inspect})" do
-        option = add_options_to do option "--foo#{input}" end.get_option(:foo)
-      expect(option).to be_takes_argument
-      expect(option).not_to be_optional_argument
-      end
-    end
-
-    ["=[FOO]", " [FOO]"].each do |input|
-      it "should fail if the argument is optional (like #{input.inspect})" do
-        expect do
-          option = add_options_to do option "--foo#{input}" end.get_option(:foo)
-          expect(option).to be_takes_argument
-          expect(option).to be_optional_argument
-        end.to raise_error(ArgumentError, /optional arguments are not supported/)
-      end
-    end
-  end
-
-  describe "#default_to" do
-    it "should not have a default value by default" do
-      option = add_options_to do option "--foo" end.get_option(:foo)
-      expect(option).not_to be_has_default
-    end
-
-    it "should accept a block for the default value" do
-      option = add_options_to do
-        option "--foo" do
-          default_to do
-            12
-          end
-        end
-      end.get_option(:foo)
-
-      expect(option).to be_has_default
-    end
-
-    it "should invoke the block when asked for the default value" do
-      invoked = false
-      option = add_options_to do
-        option "--foo" do
-          default_to do
-            invoked = true
-          end
-        end
-      end.get_option(:foo)
-
-      expect(option).to be_has_default
-      expect(option.default).to be_truthy
-      expect(invoked).to be_truthy
-    end
-
-    it "should return the value of the block when asked for the default" do
-      option = add_options_to do
-        option "--foo" do
-          default_to do
-            12
-          end
-        end
-      end.get_option(:foo)
-
-      expect(option).to be_has_default
-      expect(option.default).to eq(12)
-    end
-
-    it "should invoke the block every time the default is requested" do
-      option = add_options_to do
-        option "--foo" do
-          default_to do
-            {}
-          end
-        end
-      end.get_option(:foo)
-
-      first  = option.default.object_id
-      second = option.default.object_id
-      third  = option.default.object_id
-
-      expect(first).not_to eq(second)
-      expect(first).not_to eq(third)
-      expect(second).not_to eq(third)
-    end
-
-    it "should fail if the option has a default and is required" do
-      expect {
-        add_options_to do
-          option "--foo" do
-            required
-            default_to do 12 end
-          end
-        end
-      }.to raise_error ArgumentError, /can't be optional and have a default value/
-
-      expect {
-        add_options_to do
-          option "--foo" do
-            default_to do 12 end
-            required
-          end
-        end
-      }.to raise_error ArgumentError, /can't be optional and have a default value/
-    end
-
-    it "should fail if default_to has no block" do
-      expect { add_options_to do option "--foo" do default_to end end }.
-        to raise_error ArgumentError, /default_to requires a block/
-    end
-
-    it "should fail if default_to is invoked twice" do
-      expect {
-        add_options_to do
-          option "--foo" do
-            default_to do 12 end
-            default_to do "fun" end
-          end
-        end
-      }.to raise_error ArgumentError, /already has a default value/
-    end
-
-    [ "one", "one, two", "one, *two" ].each do |input|
-      it "should fail if the block has the wrong arity (#{input})" do
-        expect {
-          add_options_to do
-            option "--foo" do
-              eval "default_to do |#{input}| 12 end"
-            end
-          end
-        }.to raise_error ArgumentError, /should not take any arguments/
-      end
-    end
-  end
-end