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

data/spec/unit/interface/face_collection_spec.rb

@@ -1,219 +0,0 @@
-require 'spec_helper'
-
-require 'tmpdir'
-require 'puppet/interface'
-
-describe Puppet::Interface::FaceCollection do
-
-  # To prevent conflicts with other specs that use faces, we must save and restore global state.
-  # Because there are specs that do 'describe Puppet::Face[...]', we must restore the same objects otherwise
-  # the 'subject' of the specs will differ.
-  before :all do
-    # Save FaceCollection's global state
-    faces = described_class.instance_variable_get(:@faces)
-    @faces = faces.dup
-    faces.each do |k, v|
-      @faces[k] = v.dup
-    end
-    @faces_loaded = described_class.instance_variable_get(:@loaded)
-
-    # Save the already required face files
-    @required = []
-    $".each do |path|
-      @required << path if path =~ /face\/.*\.rb$/
-    end
-
-    # Save Autoload's global state
-    @loaded = Puppet::Util::Autoload.instance_variable_get(:@loaded).dup
-  end
-
-  after :all do
-    # Restore global state
-    described_class.instance_variable_set :@faces, @faces
-    described_class.instance_variable_set :@loaded, @faces_loaded
-    $".delete_if { |path| path =~ /face\/.*\.rb$/ }
-    @required.each { |path| $".push path unless $".include? path }
-    Puppet::Util::Autoload.instance_variable_set(:@loaded, @loaded)
-  end
-
-  before :each do
-    # Before each test, clear the faces
-    subject.instance_variable_get(:@faces).clear
-    subject.instance_variable_set(:@loaded, false)
-    Puppet::Util::Autoload.instance_variable_get(:@loaded).clear
-    $".delete_if { |path| path =~ /face\/.*\.rb$/ }
-  end
-
-  describe "::[]" do
-    before :each do
-      subject.instance_variable_get("@faces")[:foo][SemanticPuppet::Version.parse('0.0.1')] = 10
-    end
-
-    it "should return the face with the given name" do
-      expect(subject["foo", '0.0.1']).to eq(10)
-    end
-
-    it "should attempt to load the face if it isn't found" do
-      expect(subject).to receive(:require).once.with('puppet/face/bar')
-      expect(subject).to receive(:require).once.with('puppet/face/0.0.1/bar')
-      subject["bar", '0.0.1']
-    end
-
-    it "should attempt to load the default face for the specified version :current" do
-      expect(subject).to receive(:require).with('puppet/face/fozzie')
-      subject['fozzie', :current]
-    end
-
-    it "should return true if the face specified is registered" do
-      subject.instance_variable_get("@faces")[:foo][SemanticPuppet::Version.parse('0.0.1')] = 10
-      expect(subject["foo", '0.0.1']).to eq(10)
-    end
-
-    it "should attempt to require the face if it is not registered" do
-      expect(subject).to receive(:require) do |file|
-        subject.instance_variable_get("@faces")[:bar][SemanticPuppet::Version.parse('0.0.1')] = true
-        expect(file).to eq('puppet/face/bar')
-      end
-
-      expect(subject["bar", '0.0.1']).to be_truthy
-    end
-
-    it "should return false if the face is not registered" do
-      allow(subject).to receive(:require).and_return(true)
-      expect(subject["bar", '0.0.1']).to be_falsey
-    end
-
-    it "should return false if the face file itself is missing" do
-      num_calls = 0
-      allow(subject).to receive(:require) do
-        num_calls += 1
-        if num_calls == 1
-          raise LoadError.new('no such file to load -- puppet/face/bar')
-        else
-          raise LoadError.new('no such file to load -- puppet/face/0.0.1/bar')
-        end
-      end
-
-      expect(subject["bar", '0.0.1']).to be_falsey
-    end
-
-    it "should register the version loaded by `:current` as `:current`" do
-      expect(subject).to receive(:require) do |file|
-        subject.instance_variable_get("@faces")[:huzzah]['2.0.1'] = :huzzah_face
-        expect(file).to eq('puppet/face/huzzah')
-      end
-      subject["huzzah", :current]
-      expect(subject.instance_variable_get("@faces")[:huzzah][:current]).to eq(:huzzah_face)
-    end
-
-    context "with something on disk" do
-      it "should register the version loaded from `puppet/face/{name}` as `:current`" do
-        expect(subject["huzzah", '2.0.1']).to be
-        expect(subject["huzzah", :current]).to be
-        expect(Puppet::Face[:huzzah, '2.0.1']).to eq(Puppet::Face[:huzzah, :current])
-      end
-
-      it "should index :current when the code was pre-required" do
-        expect(subject.instance_variable_get("@faces")[:huzzah]).not_to be_key :current
-        require 'puppet/face/huzzah'
-        expect(subject[:huzzah, :current]).to be_truthy
-      end
-    end
-
-    it "should not cause an invalid face to be enumerated later" do
-      expect(subject[:there_is_no_face, :current]).to be_falsey
-      expect(subject.faces).not_to include :there_is_no_face
-    end
-  end
-
-  describe "::get_action_for_face" do
-    it "should return an action on the current face" do
-      expect(Puppet::Face::FaceCollection.get_action_for_face(:huzzah, :bar, :current)).
-        to be_an_instance_of Puppet::Interface::Action
-    end
-
-    it "should return an action on an older version of a face" do
-      action = Puppet::Face::FaceCollection.
-        get_action_for_face(:huzzah, :obsolete, :current)
-
-      expect(action).to be_an_instance_of Puppet::Interface::Action
-      expect(action.face.version).to eq(SemanticPuppet::Version.parse('1.0.0'))
-    end
-
-    it "should load the full older version of a face" do
-      action = Puppet::Face::FaceCollection.
-        get_action_for_face(:huzzah, :obsolete, :current)
-
-      expect(action.face.version).to eq(SemanticPuppet::Version.parse('1.0.0'))
-      expect(action.face).to be_action :obsolete_in_core
-    end
-
-    it "should not add obsolete actions to the current version" do
-      action = Puppet::Face::FaceCollection.
-        get_action_for_face(:huzzah, :obsolete, :current)
-
-      expect(action.face.version).to eq(SemanticPuppet::Version.parse('1.0.0'))
-      expect(action.face).to be_action :obsolete_in_core
-
-      current = Puppet::Face[:huzzah, :current]
-      expect(current.version).to eq(SemanticPuppet::Version.parse('2.0.1'))
-      expect(current).not_to be_action :obsolete_in_core
-      expect(current).not_to be_action :obsolete
-    end
-  end
-
-  describe "::register" do
-    it "should store the face by name" do
-      face = Puppet::Face.new(:my_face, '0.0.1')
-      subject.register(face)
-      expect(subject.instance_variable_get("@faces")).to eq({
-        :my_face => { face.version => face }
-      })
-    end
-  end
-
-  describe "::underscorize" do
-    faulty = [1, "23foo", "#foo", "$bar", "sturm und drang", :"sturm und drang"]
-    valid  = {
-      "Foo"       => :foo,
-      :Foo        => :foo,
-      "foo_bar"   => :foo_bar,
-      :foo_bar    => :foo_bar,
-      "foo-bar"   => :foo_bar,
-      :"foo-bar"  => :foo_bar,
-      "foo_bar23" => :foo_bar23,
-      :foo_bar23  => :foo_bar23,
-    }
-
-    valid.each do |input, expect|
-      it "should map #{input.inspect} to #{expect.inspect}" do
-        result = subject.underscorize(input)
-        expect(result).to eq(expect)
-      end
-    end
-
-    faulty.each do |input|
-      it "should fail when presented with #{input.inspect} (#{input.class})" do
-        expect { subject.underscorize(input) }.
-          to raise_error ArgumentError, /not a valid face name/
-      end
-    end
-  end
-
-  context "faulty faces" do
-    before :each do
-      $:.unshift "#{PuppetSpec::FIXTURE_DIR}/faulty_face"
-    end
-
-    after :each do
-      $:.delete_if {|x| x == "#{PuppetSpec::FIXTURE_DIR}/faulty_face"}
-    end
-
-    it "should not die if a face has a syntax error" do
-      expect(subject.faces).to be_include :help
-      expect(subject.faces).not_to be_include :syntax
-      expect(@logs).not_to be_empty
-      expect(@logs.first.message).to match(/syntax error/)
-    end
-  end
-end

data/spec/unit/interface/option_builder_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-require 'puppet/interface'
-
-describe Puppet::Interface::OptionBuilder do
-  let :face do Puppet::Interface.new(:option_builder_testing, '0.0.1') end
-
-  it "should be able to construct an option without a block" do
-    expect(Puppet::Interface::OptionBuilder.build(face, "--foo")).
-      to be_an_instance_of Puppet::Interface::Option
-  end
-
-  Puppet.settings.each do |name, value|
-    it "should fail when option #{name.inspect} already exists in puppet core" do
-      expect do
-        Puppet::Interface::OptionBuilder.build(face, "--#{name}")
-      end.to raise_error ArgumentError, /already defined/
-    end
-  end
-
-  it "should work with an empty block" do
-    option = Puppet::Interface::OptionBuilder.build(face, "--foo") do
-      # This block deliberately left blank.
-    end
-
-    expect(option).to be_an_instance_of Puppet::Interface::Option
-  end
-
-  [:description, :summary].each do |doc|
-    it "should support #{doc} declarations" do
-      text = "this is the #{doc}"
-      option = Puppet::Interface::OptionBuilder.build(face, "--foo") do
-        self.send doc, text
-      end
-      expect(option).to be_an_instance_of Puppet::Interface::Option
-      expect(option.send(doc)).to eq(text)
-    end
-  end
-
-  context "before_action hook" do
-    it "should support a before_action hook" do
-      option = Puppet::Interface::OptionBuilder.build(face, "--foo") do
-        before_action do |a,b,c| :whatever end
-      end
-      expect(option.before_action).to be_an_instance_of UnboundMethod
-    end
-
-    it "should fail if the hook block takes too few arguments" do
-      expect do
-        Puppet::Interface::OptionBuilder.build(face, "--foo") do
-          before_action do |one, two| true end
-        end
-      end.to raise_error ArgumentError, /takes three arguments/
-    end
-
-    it "should fail if the hook block takes too many arguments" do
-      expect do
-        Puppet::Interface::OptionBuilder.build(face, "--foo") do
-          before_action do |one, two, three, four| true end
-        end
-      end.to raise_error ArgumentError, /takes three arguments/
-    end
-
-    it "should fail if the hook block takes a variable number of arguments" do
-      expect do
-        Puppet::Interface::OptionBuilder.build(face, "--foo") do
-          before_action do |*blah| true end
-        end
-      end.to raise_error ArgumentError, /takes three arguments/
-    end
-
-    it "should support simple required declarations" do
-      opt = Puppet::Interface::OptionBuilder.build(face, "--foo") do
-        required
-      end
-      expect(opt).to be_required
-    end
-
-    it "should support arguments to the required property" do
-      opt = Puppet::Interface::OptionBuilder.build(face, "--foo") do
-        required(false)
-      end
-      expect(opt).not_to be_required
-    end
-    
-  end
-end

data/spec/unit/interface/option_spec.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-require 'puppet/interface'
-
-describe Puppet::Interface::Option do
-  let :face do Puppet::Interface.new(:option_testing, '0.0.1') end
-
-  describe "#optparse_to_name" do
-    ["", "=BAR", " BAR", "=bar", " bar"].each do |postfix|
-      { "--foo" => :foo, "-f" => :f }.each do |base, expect|
-        input = base + postfix
-        it "should map #{input.inspect} to #{expect.inspect}" do
-          option = Puppet::Interface::Option.new(face, input)
-          expect(option.name).to eq(expect)
-        end
-      end
-    end
-
-    [:foo, 12, nil, {}, []].each do |input|
-      it "should fail sensible when given #{input.inspect}" do
-        expect {
-          Puppet::Interface::Option.new(face, input)
-        }.to raise_error ArgumentError, /is not valid for an option argument/
-      end
-    end
-
-    ["-foo", "-foo=BAR", "-foo BAR"].each do |input|
-      it "should fail with a single dash for long option #{input.inspect}" do
-        expect {
-          Puppet::Interface::Option.new(face, input)
-        }.to raise_error ArgumentError, /long options need two dashes \(--\)/
-      end
-    end
-  end
-
-  it "requires a face when created" do
-    expect {
-      Puppet::Interface::Option.new
-    }.to raise_error ArgumentError, /wrong number of arguments/
-  end
-
-  it "also requires some declaration arguments when created" do
-    expect {
-      Puppet::Interface::Option.new(face)
-    }.to raise_error ArgumentError, /No option declarations found/
-  end
-
-  it "should infer the name from an optparse string" do
-    option = Puppet::Interface::Option.new(face, "--foo")
-    expect(option.name).to eq(:foo)
-  end
-
-  it "should infer the name when multiple optparse string are given" do
-    option = Puppet::Interface::Option.new(face, "--foo", "-f")
-    expect(option.name).to eq(:foo)
-  end
-
-  it "should prefer the first long option name over a short option name" do
-    option = Puppet::Interface::Option.new(face, "-f", "--foo")
-    expect(option.name).to eq(:foo)
-  end
-
-  it "should create an instance when given a face and name" do
-    expect(Puppet::Interface::Option.new(face, "--foo")).
-      to be_instance_of Puppet::Interface::Option
-  end
-
-  Puppet.settings.each do |name, value|
-    it "should fail when option #{name.inspect} already exists in puppet core" do
-      expect do
-        Puppet::Interface::Option.new(face, "--#{name}")
-      end.to raise_error ArgumentError, /already defined/
-    end
-  end
-
-  describe "#to_s" do
-    it "should transform a symbol into a string" do
-      option = Puppet::Interface::Option.new(face, "--foo")
-      expect(option.name).to eq(:foo)
-      expect(option.to_s).to eq("foo")
-    end
-
-    it "should use - rather than _ to separate words in strings but not symbols" do
-      option = Puppet::Interface::Option.new(face, "--foo-bar")
-      expect(option.name).to eq(:foo_bar)
-      expect(option.to_s).to eq("foo-bar")
-    end
-  end
-
-  %w{before after}.each do |side|
-    describe "#{side} hooks" do
-      subject { Puppet::Interface::Option.new(face, "--foo") }
-      let :proc do Proc.new do :from_proc end end
-
-      it { is_expected.to respond_to "#{side}_action" }
-      it { is_expected.to respond_to "#{side}_action=" }
-
-      it "should set the #{side}_action hook" do
-        expect(subject.send("#{side}_action")).to be_nil
-        subject.send("#{side}_action=", proc)
-        expect(subject.send("#{side}_action")).to be_an_instance_of UnboundMethod
-      end
-
-      data = [1, "foo", :foo, Object.new, method(:hash), method(:hash).unbind]
-      data.each do |input|
-        it "should fail if a #{input.class} is added to the #{side} hooks" do
-          expect { subject.send("#{side}_action=", input) }.
-            to raise_error ArgumentError, /not a proc/
-        end
-      end
-    end
-  end
-
-  context "defaults" do
-    subject { Puppet::Interface::Option.new(face, "--foo") }
-
-    it "should work sanely if member variables are used for state" do
-      subject.default = proc { @foo ||= 0; @foo += 1 }
-      expect(subject.default).to eq(1)
-      expect(subject.default).to eq(2)
-      expect(subject.default).to eq(3)
-    end
-
-    context "with no default" do
-      it { is_expected.not_to be_has_default }
-      its :default do should be_nil end
-
-      it "should set a proc as default" do
-        expect { subject.default = proc { 12 } }.to_not raise_error
-      end
-
-      [1, {}, [], Object.new, "foo"].each do |input|
-        it "should reject anything but a proc (#{input.class})" do
-          expect { subject.default = input }.to raise_error ArgumentError, /not a proc/
-        end
-      end
-    end
-
-    context "with a default" do
-      before :each do subject.default = proc { [:foo] } end
-
-      it { is_expected.to be_has_default }
-      its :default do should == [:foo] end
-
-      it "should invoke the block every time" do
-        expect(subject.default.object_id).not_to eq(subject.default.object_id)
-        expect(subject.default).to eq(subject.default)
-      end
-
-      it "should allow replacing the default proc" do
-        expect(subject.default).to eq([:foo])
-        subject.default = proc { :bar }
-        expect(subject.default).to eq(:bar)
-      end
-    end
-  end
-end