puppet 7.28.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/util/symbolic_file_mode_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/symbolic_file_mode'
-
-describe Puppet::Util::SymbolicFileMode do
-  include Puppet::Util::SymbolicFileMode
-
-  describe "#valid_symbolic_mode?" do
-    %w{
-         0  0000  1  1  7  11  77  111  777  11
-         0 00000 01 01 07 011 077 0111 0777 011
-         = - + u= g= o= a= u+ g+ o+ a+ u- g- o- a- ugo= ugoa= ugugug=
-         a=,u=,g= a=,g+
-         =rwx +rwx -rwx
-         644 go-w =rw,+X +X 755 u=rwx,go=rx u=rwx,go=u-w go= g=u-w
-         755 0755
-    }.each do |input|
-      it "should treat #{input.inspect} as valid" do
-        expect(valid_symbolic_mode?(input)).to be_truthy
-      end
-    end
-
-    [0000, 0111, 0640, 0755, 0777].each do |input|
-      it "should treat the int #{input.to_s(8)} as value" do
-        expect(valid_symbolic_mode?(input)).to be_truthy
-      end
-    end
-
-    %w{
-          -1  -8  8  9  18  19  91  81  000000  11111  77777
-         0-1 0-8 08 09 018 019 091 081 0000000 011111 077777
-         u g o a ug uo ua ag
-    }.each do |input|
-      it "should treat #{input.inspect} as invalid" do
-        expect(valid_symbolic_mode?(input)).to be_falsey
-      end
-    end
-  end
-
-  describe "#normalize_symbolic_mode" do
-    it "should turn an int into a string" do
-      expect(normalize_symbolic_mode(12)).to be_an_instance_of String
-    end
-
-    it "should not add a leading zero to an int" do
-      expect(normalize_symbolic_mode(12)).not_to match(/^0/)
-    end
-
-    it "should not add a leading zero to a string with a number" do
-      expect(normalize_symbolic_mode("12")).not_to match(/^0/)
-    end
-
-    it "should string a leading zero from a number" do
-      expect(normalize_symbolic_mode("012")).to eq('12')
-    end
-
-    it "should pass through any other string" do
-      expect(normalize_symbolic_mode("u=rwx")).to eq('u=rwx')
-    end
-  end
-
-  describe "#symbolic_mode_to_int" do
-    {
-      "0654"            => 00654,
-      "u+r"             => 00400,
-      "g+r"             => 00040,
-      "a+r"             => 00444,
-      "a+x"             => 00111,
-      "o+t"             => 01000,
-      ["o-t", 07777]    => 06777,
-      ["a-x", 07777]    => 07666,
-      ["a-rwx", 07777]  => 07000,
-      ["ug-rwx", 07777] => 07007,
-      "a+x,ug-rwx"      => 00001,
-      # My experimentation on debian suggests that +g ignores the sgid flag
-      ["a+g", 02060]    => 02666,
-      # My experimentation on debian suggests that -g ignores the sgid flag
-      ["a-g", 02666]    => 02000,
-      "g+x,a+g"         => 00111,
-      # +X without exec set in the original should not set anything
-      "u+x,g+X"         => 00100,
-      "g+X"             => 00000,
-      # +X only refers to the original, *unmodified* file mode!
-      ["u+x,a+X", 0600] => 00700,
-      # Examples from the MacOS chmod(1) manpage
-      "0644"            => 00644,
-      ["go-w", 07777]   => 07755,
-      ["=rw,+X", 07777] => 07777,
-      ["=rw,+X", 07766] => 07777,
-      ["=rw,+X", 07676] => 07777,
-      ["=rw,+X", 07667] => 07777,
-      ["=rw,+X", 07666] => 07666,
-      "0755"            => 00755,
-      "u=rwx,go=rx"     => 00755,
-      "u=rwx,go=u-w"    => 00755,
-      ["go=", 07777]    => 07700,
-      ["g=u-w", 07777]  => 07757,
-      ["g=u-w", 00700]  => 00750,
-      ["g=u-w", 00600]  => 00640,
-      ["g=u-w", 00500]  => 00550,
-      ["g=u-w", 00400]  => 00440,
-      ["g=u-w", 00300]  => 00310,
-      ["g=u-w", 00200]  => 00200,
-      ["g=u-w", 00100]  => 00110,
-      ["g=u-w", 00000]  => 00000,
-      # Cruel, but legal, use of the action set.
-      ["g=u+r-w", 0300] => 00350,
-      # Empty assignments.
-      ["u=",  00000]    => 00000,
-      ["u=",  00600]    => 00000,
-      ["ug=", 00000]    => 00000,
-      ["ug=", 00600]    => 00000,
-      ["ug=", 00660]    => 00000,
-      ["ug=", 00666]    => 00006,
-      ["=",   00000]    => 00000,
-      ["=",   00666]    => 00000,
-      ["+",   00000]    => 00000,
-      ["+",   00124]    => 00124,
-      ["-",   00000]    => 00000,
-      ["-",   00124]    => 00124,
-    }.each do |input, result|
-      from = input.is_a?(Array) ? "#{input[0]}, 0#{input[1].to_s(8)}" : input
-      it "should map #{from.inspect} to #{result.inspect}" do
-        expect(symbolic_mode_to_int(*input)).to eq(result)
-      end
-    end
-
-    # Now, test some failure modes.
-    it "should fail if no mode is given" do
-      expect { symbolic_mode_to_int('') }.
-        to raise_error Puppet::Error, /empty mode string/
-    end
-
-    %w{u g o ug uo go ugo a uu u/x u!x u=r,,g=r}.each do |input|
-      it "should fail if no (valid) action is given: #{input.inspect}" do
-        expect { symbolic_mode_to_int(input) }.
-          to raise_error Puppet::Error, /Missing action/
-      end
-    end
-
-    %w{u+q u-rwF u+rw,g+rw,o+RW}.each do |input|
-      it "should fail with unknown op #{input.inspect}" do
-        expect { symbolic_mode_to_int(input) }.
-          to raise_error Puppet::Error, /Unknown operation/
-      end
-    end
-
-    it "should refuse to subtract the conditional execute op" do
-      expect { symbolic_mode_to_int("o-rwX") }.
-        to raise_error Puppet::Error, /only works with/
-    end
-
-    it "should refuse to set to the conditional execute op" do
-      expect { symbolic_mode_to_int("o=rwX") }.
-        to raise_error Puppet::Error, /only works with/
-    end
-
-    %w{8 08 9 09 118 119}.each do |input|
-      it "should fail for decimal modes: #{input.inspect}" do
-        expect { symbolic_mode_to_int(input) }.
-          to raise_error Puppet::Error, /octal/
-      end
-    end
-
-    it "should set the execute bit on a directory, without exec in original" do
-      expect(symbolic_mode_to_int("u+X", 0444, true).to_s(8)).to eq("544")
-      expect(symbolic_mode_to_int("g+X", 0444, true).to_s(8)).to eq("454")
-      expect(symbolic_mode_to_int("o+X", 0444, true).to_s(8)).to eq("445")
-      expect(symbolic_mode_to_int("+X",  0444, true).to_s(8)).to eq("555")
-    end
-
-    it "should set the execute bit on a file with exec in the original" do
-      expect(symbolic_mode_to_int("+X", 0544).to_s(8)).to eq("555")
-    end
-
-    it "should not set the execute bit on a file without exec on the original even if set by earlier DSL" do
-      expect(symbolic_mode_to_int("u+x,go+X", 0444).to_s(8)).to eq("544")
-    end
-  end
-end

data/spec/unit/util/tag_set_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/tag_set'
-
-RSpec::Matchers.define :be_one_of do |*expected|
-  match do |actual|
-    expected.include? actual
-  end
-
-  failure_message do |actual|
-    "expected #{actual.inspect} to be one of #{expected.map(&:inspect).join(' or ')}"
-  end
-end
-
-describe Puppet::Util::TagSet do
-  let(:set) { Puppet::Util::TagSet.new }
-
-  it 'serializes to yaml as an array' do
-    array = ['a', :b, 1, 5.4]
-    set.merge(array)
-
-    expect(Set.new(Puppet::Util::Yaml.safe_load(set.to_yaml, [Symbol, Puppet::Util::TagSet]))).to eq(Set.new(array))
-  end
-
-  it 'deserializes from a yaml array' do
-    array = ['a', :b, 1, 5.4]
-
-    expect(Puppet::Util::TagSet.from_yaml(array.to_yaml)).to eq(Puppet::Util::TagSet.new(array))
-  end
-
-  it 'round trips through json' do
-    array = ['a', 'b', 1, 5.4]
-    set.merge(array)
-
-    tes = Puppet::Util::TagSet.from_data_hash(JSON.parse(set.to_json))
-    expect(tes).to eq(set)
-  end
-
-  it 'can join its elements with a string separator' do
-    array = ['a', 'b']
-    set.merge(array)
-
-    expect(set.join(', ')).to be_one_of('a, b', 'b, a')
-  end
-
-  it 'raises when deserializing unacceptable objects' do
-    yaml = [Object.new].to_yaml
-    expect {
-      Puppet::Util::TagSet.from_yaml(yaml)
-    }.to raise_error(Puppet::Util::Yaml::YamlLoadError, /Tried to load unspecified class: Object/)
-  end
-end

data/spec/unit/util/tagging_spec.rb

@@ -1,246 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-require 'puppet/util/tagging'
-
-describe Puppet::Util::Tagging do
-  let(:tagger) { Object.new.extend(Puppet::Util::Tagging) }
-
-  it "should add tags to the returned tag list" do
-    tagger.tag("one")
-    expect(tagger.tags).to include("one")
-  end
-
-  it "should add all provided tags to the tag list" do
-    tagger.tag("one", "two")
-    expect(tagger.tags).to include("one")
-    expect(tagger.tags).to include("two")
-  end
-
-  it "should fail on tags containing '*' characters" do
-    expect { tagger.tag("bad*tag") }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should fail on tags starting with '-' characters" do
-    expect { tagger.tag("-badtag") }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should fail on tags containing ' ' characters" do
-    expect { tagger.tag("bad tag") }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should fail on tags containing newline characters" do
-    expect { tagger.tag("bad\ntag") }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should allow alpha tags" do
-    expect { tagger.tag("good_tag") }.not_to raise_error
-  end
-
-  it "should allow tags containing '.' characters" do
-    expect { tagger.tag("good.tag") }.to_not raise_error
-  end
-
-  # different UTF-8 widths
-  # 1-byte A
-  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
-  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
-  # 4-byte ܎ - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
-  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ܎
-
-  it "should allow UTF-8 alphanumeric characters" do
-    expect { tagger.tag(mixed_utf8) }.not_to raise_error
-  end
-
-  # completely non-exhaustive list of a few UTF-8 punctuation characters
-  # http://www.fileformat.info/info/unicode/block/general_punctuation/utf8test.htm
-  [
-    "\u2020", # dagger †
-    "\u203B", # reference mark ※
-    "\u204F", # reverse semicolon ⁏
-    "!",
-    "@",
-    "#",
-    "$",
-    "%",
-    "^",
-    "&",
-    "*",
-    "(",
-    ")",
-    "-",
-    "+",
-    "=",
-    "{",
-    "}",
-    "[",
-    "]",
-    "|",
-    "\\",
-    "/",
-    "?",
-    "<",
-    ">",
-    ",",
-    ".",
-    "~",
-    ",",
-    ":",
-    ";",
-    "\"",
-    "'",
-  ].each do |char|
-    it "should not allow UTF-8 punctuation characters, e.g. #{char}" do
-      expect { tagger.tag(char) }.to raise_error(Puppet::ParseError)
-    end
-  end
-
-  it "should allow encodings that can be coerced to UTF-8" do
-     chinese = "標記你是它".force_encoding(Encoding::UTF_8)
-     ascii   = "tags--".force_encoding(Encoding::ASCII_8BIT)
-     jose    = "jos\xE9".force_encoding(Encoding::ISO_8859_1)
-
-     [chinese, ascii, jose].each do |tag|
-       expect(tagger.valid_tag?(tag)).to be_truthy
-     end
-  end
-
-  it "should not allow strings that cannot be converted to UTF-8" do
-    invalid = "\xA0".force_encoding(Encoding::ASCII_8BIT)
-    expect(tagger.valid_tag?(invalid)).to be_falsey
-  end
-
-  it "should add qualified classes as tags" do
-    tagger.tag("one::two")
-    expect(tagger.tags).to include("one::two")
-  end
-
-  it "should add each part of qualified classes as tags" do
-    tagger.tag("one::two::three")
-    expect(tagger.tags).to include('one')
-    expect(tagger.tags).to include("two")
-    expect(tagger.tags).to include("three")
-  end
-
-  it "should indicate when the object is tagged with a provided tag" do
-    tagger.tag("one")
-    expect(tagger).to be_tagged("one")
-  end
-
-  it "should indicate when the object is not tagged with a provided tag" do
-    expect(tagger).to_not be_tagged("one")
-  end
-
-  it "should indicate when the object is tagged with any tag in an array" do
-    tagger.tag("one")
-    expect(tagger).to be_tagged("one","two","three")
-  end
-
-  it "should indicate when the object is not tagged with any tag in an array" do
-    tagger.tag("one")
-    expect(tagger).to_not be_tagged("two","three")
-  end
-
-  context "when tagging" do
-    it "converts symbols to strings" do
-      tagger.tag(:hello)
-      expect(tagger.tags).to include('hello')
-    end
-
-    it "downcases tags" do
-      tagger.tag(:HEllO)
-      tagger.tag("GooDByE")
-      expect(tagger).to be_tagged("hello")
-      expect(tagger).to be_tagged("goodbye")
-    end
-
-    it "downcases tag arguments" do
-      tagger.tag("hello")
-      tagger.tag("goodbye")
-      expect(tagger).to be_tagged(:HEllO)
-      expect(tagger).to be_tagged("GooDByE")
-    end
-
-    it "accepts hyphenated tags" do
-      tagger.tag("my-tag")
-      expect(tagger).to be_tagged("my-tag")
-    end
-
-    it 'skips undef /nil tags' do
-      tagger.tag('before')
-      tagger.tag(nil)
-      tagger.tag('after')
-      expect(tagger).to_not be_tagged(nil)
-      expect(tagger).to_not be_tagged('')
-      expect(tagger).to_not be_tagged('undef')
-      expect(tagger).to be_tagged('before')
-      expect(tagger).to be_tagged('after')
-    end
-  end
-
-  context "when querying if tagged" do
-    it "responds true if queried on the entire set" do
-      tagger.tag("one", "two")
-      expect(tagger).to be_tagged("one", "two")
-    end
-
-    it "responds true if queried on a subset" do
-      tagger.tag("one", "two", "three")
-      expect(tagger).to be_tagged("two", "one")
-    end
-
-    it "responds true if queried on an overlapping but not fully contained set" do
-      tagger.tag("one", "two")
-      expect(tagger).to be_tagged("zero", "one")
-    end
-
-    it "responds false if queried on a disjoint set" do
-      tagger.tag("one", "two", "three")
-      expect(tagger).to_not be_tagged("five")
-    end
-
-    it "responds false if queried on the empty set" do
-      expect(tagger).to_not be_tagged
-    end
-  end
-
-  context "when assigning tags" do
-    it "splits a string on ','" do
-      tagger.tags = "one, two, three"
-      expect(tagger).to be_tagged("one")
-      expect(tagger).to be_tagged("two")
-      expect(tagger).to be_tagged("three")
-    end
-
-    it "protects against empty tags" do
-      expect { tagger.tags = "one,,two"}.to raise_error(/Invalid tag ''/)
-    end
-
-    it "takes an array of tags" do
-      tagger.tags = ["one", "two"]
-
-      expect(tagger).to be_tagged("one")
-      expect(tagger).to be_tagged("two")
-    end
-
-    it "removes any existing tags when reassigning" do
-      tagger.tags = "one, two"
-
-      tagger.tags = "three, four"
-
-      expect(tagger).to_not be_tagged("one")
-      expect(tagger).to_not be_tagged("two")
-      expect(tagger).to be_tagged("three")
-      expect(tagger).to be_tagged("four")
-    end
-
-    it "allows empty tags that are generated from :: separated tags" do
-      tagger.tags = "one::::two::three"
-
-      expect(tagger).to be_tagged("one")
-      expect(tagger).to be_tagged("")
-      expect(tagger).to be_tagged("two")
-      expect(tagger).to be_tagged("three")
-    end
-  end
-end

data/spec/unit/util/terminal_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/terminal'
-
-describe Puppet::Util::Terminal do
-  describe '.width' do
-    before { allow(Puppet.features).to receive(:posix?).and_return(true) }
-
-    it 'should invoke `stty` and return the width' do
-      height, width = 100, 200
-      expect(subject).to receive(:`).with('stty size 2>/dev/null').and_return("#{height} #{width}\n")
-      expect(subject.width).to eq(width)
-    end
-
-    it 'should use `tput` if `stty` is unavailable' do
-      width = 200
-      expect(subject).to receive(:`).with('stty size 2>/dev/null').and_return("\n")
-      expect(subject).to receive(:`).with('tput cols 2>/dev/null').and_return("#{width}\n")
-      expect(subject.width).to eq(width)
-    end
-
-    it 'should default to 80 columns if `tput` and `stty` are unavailable' do
-      width = 80
-      expect(subject).to receive(:`).with('stty size 2>/dev/null').and_return("\n")
-      expect(subject).to receive(:`).with('tput cols 2>/dev/null').and_return("\n")
-      expect(subject.width).to eq(width)
-    end
-
-    it 'should default to 80 columns if `tput` or `stty` raise exceptions' do
-      width = 80
-      expect(subject).to receive(:`).with('stty size 2>/dev/null').and_raise()
-      allow(subject).to receive(:`).with('tput cols 2>/dev/null').and_return("#{width + 1000}\n")
-      expect(subject.width).to eq(width)
-    end
-
-    it 'should default to 80 columns if not in a POSIX environment' do
-      width = 80
-      allow(Puppet.features).to receive(:posix?).and_return(false)
-      expect(subject.width).to eq(width)
-    end
-  end
-end

data/spec/unit/util/user_attr_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/user_attr'
-
-describe UserAttr do
-  before do
-    user_attr = ["foo::::type=role", "bar::::type=normal;profile=foobar"]
-    allow(File).to receive(:readlines).and_return(user_attr)
-  end
-
-  describe "when getting attributes by name" do
-    it "should return nil if there is no entry for that name" do
-      expect(UserAttr.get_attributes_by_name('baz')).to eq(nil)
-    end
-
-    it "should return a hash if there is an entry in /etc/user_attr" do
-      expect(UserAttr.get_attributes_by_name('foo').class).to eq(Hash)
-    end
-
-    it "should return a hash with the name value from /etc/user_attr" do
-      expect(UserAttr.get_attributes_by_name('foo')[:name]).to eq('foo')
-    end
-
-    #this test is contrived
-    #there are a bunch of possible parameters that could be in the hash
-    #the role/normal is just a the convention of the file
-    describe "when the name is a role" do
-      it "should contain :type = role" do
-        expect(UserAttr.get_attributes_by_name('foo')[:type]).to eq('role')
-      end
-    end
-
-    describe "when the name is not a role" do
-      it "should contain :type = normal" do
-        expect(UserAttr.get_attributes_by_name('bar')[:type]).to eq('normal')
-      end
-    end
-
-    describe "when the name has more attributes" do
-      it "should contain all the attributes" do
-        expect(UserAttr.get_attributes_by_name('bar')[:profile]).to eq('foobar')
-      end
-    end
-  end
-end

data/spec/unit/util/warnings_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Util::Warnings do
-  before(:all) do
-    @msg1 = "booness"
-    @msg2 = "more booness"
-  end
-
-  before(:each) do
-    Puppet.debug = true
-  end
-
-  after (:each) do
-    Puppet.debug = false
-  end
-
-  {:notice => "notice_once", :warning => "warnonce", :debug => "debug_once"}.each do |log, method|
-    describe "when registring '#{log}' messages" do
-      it "should always return nil" do
-        expect(Puppet::Util::Warnings.send(method, @msg1)).to be(nil)
-      end
-
-      it "should issue a warning" do
-        expect(Puppet).to receive(log).with(@msg1)
-        Puppet::Util::Warnings.send(method, @msg1)
-      end
-
-      it "should issue a warning exactly once per unique message" do
-        expect(Puppet).to receive(log).with(@msg1).once
-        Puppet::Util::Warnings.send(method, @msg1)
-        Puppet::Util::Warnings.send(method, @msg1)
-      end
-
-      it "should issue multiple warnings for multiple unique messages" do
-        expect(Puppet).to receive(log).twice()
-        Puppet::Util::Warnings.send(method, @msg1)
-        Puppet::Util::Warnings.send(method, @msg2)
-      end
-    end
-  end
-
-  after(:each) do
-    Puppet::Util::Warnings.clear_warnings
-  end
-end

data/spec/unit/util/watched_file_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/watched_file'
-require 'puppet/util/watcher'
-
-describe Puppet::Util::WatchedFile do
-  let(:an_absurdly_long_timeout) { Puppet::Util::Watcher::Timer.new(100000) }
-  let(:an_immediate_timeout) { Puppet::Util::Watcher::Timer.new(0) }
-
-  it "acts like a string so that it can be used as a filename" do
-    watched = Puppet::Util::WatchedFile.new("foo")
-
-    expect(watched.to_str).to eq("foo")
-  end
-
-  it "considers the file to be unchanged before the timeout expires" do
-    watched = Puppet::Util::WatchedFile.new(a_file_that_doesnt_exist, an_absurdly_long_timeout)
-
-    expect(watched).to_not be_changed
-  end
-
-  it "considers a file that is created to be changed" do
-    watched_filename = a_file_that_doesnt_exist
-    watched = Puppet::Util::WatchedFile.new(watched_filename, an_immediate_timeout)
-
-    create_file(watched_filename)
-
-    expect(watched).to be_changed
-  end
-
-  it "considers a missing file to remain unchanged" do
-    watched = Puppet::Util::WatchedFile.new(a_file_that_doesnt_exist, an_immediate_timeout)
-
-    expect(watched).to_not be_changed
-  end
-
-  it "considers a file that has changed but the timeout is not expired to still be unchanged" do
-    watched_filename = a_file_that_doesnt_exist
-    watched = Puppet::Util::WatchedFile.new(watched_filename, an_absurdly_long_timeout)
-
-    create_file(watched_filename)
-
-    expect(watched).to_not be_changed
-  end
-
-  def create_file(name)
-    File.open(name, "wb") { |file| file.puts("contents") }
-  end
-
-  def a_file_that_doesnt_exist
-    PuppetSpec::Files.tmpfile("watched_file")
-  end
-end