puppet 7.27.0 → 7.29.0

data/spec/unit/util/command_line_utils/puppet_option_parser_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/command_line/puppet_option_parser'
-
-describe Puppet::Util::CommandLine::PuppetOptionParser do
-  let(:option_parser) { described_class.new }
-
-  describe "an option with a value" do
-    it "parses a 'long' option with a value" do
-      parses(
-        :option => ["--angry", "Angry", :REQUIRED],
-        :from_arguments => ["--angry", "foo"],
-        :expects => "foo"
-      )
-    end
-
-    it "parses a 'short' option with a value" do
-      parses(
-        :option => ["--angry", "-a", "Angry", :REQUIRED],
-        :from_arguments => ["-a", "foo"],
-        :expects => "foo"
-      )
-    end
-
-    it "overrides a previous argument with a later one" do
-      parses(
-        :option => ["--later", "Later", :REQUIRED],
-        :from_arguments => ["--later", "tomorrow", "--later", "morgen"],
-        :expects => "morgen"
-      )
-    end
-  end
-
-  describe "an option without a value" do
-    it "parses a 'long' option" do
-      parses(
-        :option => ["--angry", "Angry", :NONE],
-        :from_arguments => ["--angry"],
-        :expects => true
-      )
-    end
-
-    it "parses a 'short' option" do
-      parses(
-        :option => ["--angry", "-a", "Angry", :NONE],
-        :from_arguments => ["-a"],
-        :expects => true
-      )
-    end
-
-    it "supports the '--no-blah' syntax" do
-      parses(
-        :option => ["--[no-]rage", "Rage", :NONE],
-        :from_arguments => ["--no-rage"],
-        :expects => false
-      )
-    end
-
-    it "overrides a previous argument with a later one" do
-      parses(
-        :option => ["--[no-]rage", "Rage", :NONE],
-        :from_arguments => ["--rage", "--no-rage"],
-        :expects => false
-      )
-    end
-  end
-
-  it "does not accept an unknown option specification" do
-    expect {
-      option_parser.on("not", "enough")
-    }.to raise_error(ArgumentError, /this method only takes 3 or 4 arguments/)
-  end
-
-  it "does not modify the original argument array" do
-    option_parser.on("--foo", "Foo", :NONE) { |val| }
-    args = ["--foo"]
-
-    option_parser.parse(args)
-
-    expect(args.length).to eq(1)
-  end
-
-  # The ruby stdlib OptionParser has an awesome "feature" that you cannot disable, whereby if
-  #  it sees a short option that you haven't specifically registered with it (e.g., "-r"), it
-  #  will automatically attempt to expand it out to whatever long options that you might have
-  #  registered.  Since we need to do our option parsing in two passes (one pass against only
-  #  the global/puppet-wide settings definitions, and then a second pass that includes the
-  #  application or face settings--because we can't load the app/face until we've determined
-  #  the libdir), it is entirely possible that we intend to define our "short" option as part
-  #  of the second pass.  Therefore, if the option parser attempts to expand it out into a
-  #  long option during the first pass, terrible things will happen.
-  #
-  # A long story short: we need to have the ability to control this kind of behavior in our
-  #  option parser, and this test simply affirms that we do.
-  it "does not try to expand short options that weren't explicitly registered" do
-
-    [
-     ["--ridiculous", "This is ridiculous", :REQUIRED],
-     ["--rage-inducing", "This is rage-inducing", :REQUIRED]
-    ].each do |option|
-      option_parser.on(*option) {}
-    end
-
-    expect { option_parser.parse(["-r"]) }.to raise_error(Puppet::Util::CommandLine::PuppetOptionError)
-  end
-
-  it "respects :ignore_invalid_options" do
-    option_parser.ignore_invalid_options = true
-    expect { option_parser.parse(["--unknown-option"]) }.not_to raise_error
-  end
-
-  it "raises if there is an invalid option and :ignore_invalid_options is not set" do
-    expect { option_parser.parse(["--unknown-option"]) }.to raise_error(Puppet::Util::CommandLine::PuppetOptionError)
-  end
-
-  def parses(option_case)
-    option = option_case[:option]
-    expected_value = option_case[:expects]
-    arguments = option_case[:from_arguments]
-
-    seen_value = nil
-    option_parser.on(*option) do |val|
-      seen_value = val
-    end
-
-    option_parser.parse(arguments)
-
-    expect(seen_value).to eq(expected_value)
-  end
-end

data/spec/unit/util/constant_inflector_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/constant_inflector'
-
-describe Puppet::Util::ConstantInflector, "when converting file names to constants" do
-  it "should capitalize terms" do
-    expect(subject.file2constant("file")).to eq("File")
-  end
-
-  it "should switch all '/' characters to double colons" do
-    expect(subject.file2constant("file/other")).to eq("File::Other")
-  end
-
-  it "should remove underscores and capitalize the proceeding letter" do
-    expect(subject.file2constant("file_other")).to eq("FileOther")
-  end
-
-  it "should correctly replace as many underscores as exist in the file name" do
-    expect(subject.file2constant("two_under_scores/with_some_more_underscores")).to eq("TwoUnderScores::WithSomeMoreUnderscores")
-  end
-
-  it "should collapse multiple underscores" do
-    expect(subject.file2constant("many___scores")).to eq("ManyScores")
-  end
-
-  it "should correctly handle file names deeper than two directories" do
-    expect(subject.file2constant("one_two/three_four/five_six")).to eq("OneTwo::ThreeFour::FiveSix")
-  end
-end
-
-describe Puppet::Util::ConstantInflector, "when converting constnats to file names" do
-  it "should convert them to a string if necessary" do
-    expect(subject.constant2file(Puppet::Util::ConstantInflector)).to be_instance_of(String)
-  end
-
-  it "should accept string inputs" do
-    expect(subject.constant2file("Puppet::Util::ConstantInflector")).to be_instance_of(String)
-  end
-
-  it "should downcase all terms" do
-    expect(subject.constant2file("Puppet")).to eq("puppet")
-  end
-
-  it "should convert '::' to '/'" do
-    expect(subject.constant2file("Puppet::Util::Constant")).to eq("puppet/util/constant")
-  end
-
-  it "should convert mid-word capitalization to an underscore" do
-    expect(subject.constant2file("OneTwo::ThreeFour")).to eq("one_two/three_four")
-  end
-
-  it "should correctly handle constants with more than two parts" do
-    expect(subject.constant2file("OneTwoThree::FourFiveSixSeven")).to eq("one_two_three/four_five_six_seven")
-  end
-end

data/spec/unit/util/diff_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/diff'
-require 'puppet/util/execution'
-
-describe Puppet::Util::Diff do
-  let(:baz_output) { Puppet::Util::Execution::ProcessOutput.new('baz', 0) }
-
-  describe ".diff" do
-    it "should execute the diff command with arguments" do
-      Puppet[:diff] = 'foo'
-      Puppet[:diff_args] = 'bar'
-
-      expect(Puppet::Util::Execution).to receive(:execute)
-        .with(['foo', 'bar', 'a', 'b'], {:failonfail => false, :combine => false})
-        .and_return(baz_output)
-      expect(subject.diff('a', 'b')).to eq('baz')
-    end
-
-    it "should execute the diff command with multiple arguments" do
-      Puppet[:diff] = 'foo'
-      Puppet[:diff_args] = 'bar qux'
-
-      expect(Puppet::Util::Execution).to receive(:execute)
-        .with(['foo', 'bar', 'qux', 'a', 'b'], anything)
-        .and_return(baz_output)
-      expect(subject.diff('a', 'b')).to eq('baz')
-    end
-
-    it "should omit diff arguments if none are specified" do
-      Puppet[:diff] = 'foo'
-      Puppet[:diff_args] = ''
-
-      expect(Puppet::Util::Execution).to receive(:execute)
-        .with(['foo', 'a', 'b'], {:failonfail => false, :combine => false})
-        .and_return(baz_output)
-      expect(subject.diff('a', 'b')).to eq('baz')
-    end
-
-    it "should return empty string if the diff command is empty" do
-      Puppet[:diff] = ''
-
-      expect(Puppet::Util::Execution).not_to receive(:execute)
-      expect(subject.diff('a', 'b')).to eq('')
-    end
-  end
-end

data/spec/unit/util/docs_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Util::Docs do
-
-  describe '.scrub' do
-    let(:my_cleaned_output) do
-      %q{This resource type uses the prescribed native tools for creating
-groups and generally uses POSIX APIs for retrieving information
-about them.  It does not directly modify `/etc/passwd` or anything.
-
-* Just for fun, we'll add a list.
-* list item two,
-  which has some add'l lines included in it.
-
-And here's a code block:
-
-    this is the piece of code
-    it does something cool
-
-**Autorequires:** I would be listing autorequired resources here.}
-    end
-
-    it "strips the least common indent from multi-line strings, without mangling indentation beyond the least common indent" do
-      input = <<EOT
-        This resource type uses the prescribed native tools for creating
-        groups and generally uses POSIX APIs for retrieving information
-        about them.  It does not directly modify `/etc/passwd` or anything.
-
-        * Just for fun, we'll add a list.
-        * list item two,
-          which has some add'l lines included in it.
-
-        And here's a code block:
-
-            this is the piece of code
-            it does something cool
-
-        **Autorequires:** I would be listing autorequired resources here.
-EOT
-      output = Puppet::Util::Docs.scrub(input)
-      expect(output).to eq my_cleaned_output
-    end
-
-    it "ignores the first line when calculating least common indent" do
-      input = "This resource type uses the prescribed native tools for creating
-        groups and generally uses POSIX APIs for retrieving information
-        about them.  It does not directly modify `/etc/passwd` or anything.
-
-        * Just for fun, we'll add a list.
-        * list item two,
-          which has some add'l lines included in it.
-
-        And here's a code block:
-
-            this is the piece of code
-            it does something cool
-
-        **Autorequires:** I would be listing autorequired resources here."
-      output = Puppet::Util::Docs.scrub(input)
-      expect(output).to eq my_cleaned_output
-    end
-
-    it "strips trailing whitespace from each line, and strips trailing newlines at end" do
-      input = "This resource type uses the prescribed native tools for creating  \n        groups and generally uses POSIX APIs for retrieving information \n        about them.  It does not directly modify `/etc/passwd` or anything.  \n\n        * Just for fun, we'll add a list. \n        * list item two,\n          which has some add'l lines included in it.    \n\n        And here's a code block:\n\n            this is the piece of code \n            it does something cool \n\n        **Autorequires:** I would be listing autorequired resources here. \n\n"
-      output = Puppet::Util::Docs.scrub(input)
-      expect(output).to eq my_cleaned_output
-    end
-
-    it "has no side effects on original input string" do
-      input       = "First line \n        second line \n        \n            indented line \n        \n        last line\n\n"
-      clean_input = "First line \n        second line \n        \n            indented line \n        \n        last line\n\n"
-      Puppet::Util::Docs.scrub(input)
-      expect(input).to eq clean_input
-    end
-
-    it "does not include whitespace-only lines when calculating least common indent" do
-      input           = "First line\n        second line\n  \n            indented line\n\n        last line"
-      expected_output = "First line\nsecond line\n\n    indented line\n\nlast line"
-      #bogus_output   = "First line\nsecond line\n\n  indented line\n\nlast line"
-      output = Puppet::Util::Docs.scrub(input)
-      expect(output).to eq expected_output
-    end
-
-    it "accepts a least common indent of zero, thus not adding errors when input string is already scrubbed" do
-      expect(Puppet::Util::Docs.scrub(my_cleaned_output)).to eq my_cleaned_output
-    end
-
-    it "trims leading space from one-liners (even when they're buffered with extra newlines)" do
-      input = "
-        Updates values in the `puppet.conf` configuration file.
-      "
-      expected_output = "Updates values in the `puppet.conf` configuration file."
-      output = Puppet::Util::Docs.scrub(input)
-      expect(output).to eq expected_output
-    end
-
-
-  end
-end
-

data/spec/unit/util/errors_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/errors'
-
-class ErrorTester
-  include Puppet::Util::Errors
-  attr_accessor :line, :file
-end
-
-describe Puppet::Util::Errors do
-  before do
-    @tester = ErrorTester.new
-  end
-
-  it "should provide a 'fail' method" do
-    expect(@tester).to respond_to(:fail)
-  end
-
-  it "should provide a 'devfail' method" do
-    expect(@tester).to respond_to(:devfail)
-  end
-
-  it "should raise any provided error when failing" do
-    expect { @tester.fail(Puppet::ParseError, "stuff") }.to raise_error(Puppet::ParseError)
-  end
-
-  it "should default to Puppet::Error when failing" do
-    expect { @tester.fail("stuff") }.to raise_error(Puppet::Error)
-  end
-
-  it "should have a method for converting error context into a string" do
-    @tester.file = "/my/file"
-    @tester.line = 50
-    expect(@tester.error_context).to eq(" (file: /my/file, line: 50)")
-  end
-end