puppet 7.31.0-universal-darwin → 8.0.1-universal-darwin

data/spec/unit/util/symbolic_file_mode_spec.rb

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,246 @@
+# 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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,52 @@
+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