puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/confine/exists_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/confine/exists'
-
-describe Puppet::Confine::Exists do
-  before do
-    @confine = Puppet::Confine::Exists.new("/my/file")
-    @confine.label = "eh"
-  end
-
-  it "should be named :exists" do
-    expect(Puppet::Confine::Exists.name).to eq(:exists)
-  end
-  
-  it "should not pass if exists is nil" do
-    confine = Puppet::Confine::Exists.new(nil)
-    confine.label = ":exists => nil"
-    expect(confine).to receive(:pass?).with(nil)
-    expect(confine).not_to be_valid
-  end
-
-  it "should use the 'pass?' method to test validity" do
-    expect(@confine).to receive(:pass?).with("/my/file")
-    @confine.valid?
-  end
-
-  it "should return false if the value is false" do
-    expect(@confine.pass?(false)).to be_falsey
-  end
-
-  it "should return false if the value does not point to a file" do
-    expect(Puppet::FileSystem).to receive(:exist?).with("/my/file").and_return(false)
-    expect(@confine.pass?("/my/file")).to be_falsey
-  end
-
-  it "should return true if the value points to a file" do
-    expect(Puppet::FileSystem).to receive(:exist?).with("/my/file").and_return(true)
-    expect(@confine.pass?("/my/file")).to be_truthy
-  end
-
-  it "should produce a message saying that a file is missing" do
-    expect(@confine.message("/my/file")).to be_include("does not exist")
-  end
-
-  describe "and the confine is for binaries" do
-    before do
-      allow(@confine).to receive(:for_binary).and_return(true)
-    end
-
-    it "should use its 'which' method to look up the full path of the file" do
-      expect(@confine).to receive(:which).and_return(nil)
-      @confine.pass?("/my/file")
-    end
-
-    it "should return false if no executable can be found" do
-      expect(@confine).to receive(:which).with("/my/file").and_return(nil)
-      expect(@confine.pass?("/my/file")).to be_falsey
-    end
-
-    it "should return true if the executable can be found" do
-      expect(@confine).to receive(:which).with("/my/file").and_return("/my/file")
-      expect(@confine.pass?("/my/file")).to be_truthy
-    end
-  end
-
-  it "should produce a summary containing all missing files" do
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    expect(Puppet::FileSystem).to receive(:exist?).with("/two").and_return(false)
-    expect(Puppet::FileSystem).to receive(:exist?).with("/four").and_return(false)
-
-    confine = Puppet::Confine::Exists.new %w{/one /two /three /four}
-    expect(confine.summary).to eq(%w{/two /four})
-  end
-
-  it "should summarize multiple instances by returning a flattened array of their summaries" do
-    c1 = double('1', :summary => %w{one})
-    c2 = double('2', :summary => %w{two})
-    c3 = double('3', :summary => %w{three})
-
-    expect(Puppet::Confine::Exists.summarize([c1, c2, c3])).to eq(%w{one two three})
-  end
-end

data/spec/unit/confine/false_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/confine/false'
-
-describe Puppet::Confine::False do
-  it "should be named :false" do
-    expect(Puppet::Confine::False.name).to eq(:false)
-  end
-
-  it "should require a value" do
-    expect { Puppet::Confine.new }.to raise_error(ArgumentError)
-  end
-
-  describe "when passing in a lambda as a value for lazy evaluation" do
-    it "should accept it" do
-      confine = Puppet::Confine::False.new(lambda { false })
-      expect(confine.values).to eql([false])
-    end
-
-    describe "when enforcing cache-positive behavior" do
-      def cached_value_of(confine)
-        confine.instance_variable_get(:@cached_value)
-      end
-
-      it "should cache a false value" do
-        confine = Puppet::Confine::False.new(lambda { false })
-        confine.values
-
-        expect(cached_value_of(confine)).to eql([false])
-      end
-
-      it "should not cache a true value" do
-        confine = Puppet::Confine::False.new(lambda { true })
-        confine.values
-
-        expect(cached_value_of(confine)).to be_nil
-      end
-    end
-  end
-
-  describe "when testing values" do
-    before { @confine = Puppet::Confine::False.new("foo") }
-
-    it "should use the 'pass?' method to test validity" do
-      @confine = Puppet::Confine::False.new("foo")
-      @confine.label = "eh"
-      expect(@confine).to receive(:pass?).with("foo")
-      @confine.valid?
-    end
-
-    it "should return true if the value is false" do
-      expect(@confine.pass?(false)).to be_truthy
-    end
-
-    it "should return false if the value is not false" do
-      expect(@confine.pass?("else")).to be_falsey
-    end
-
-    it "should produce a message that a value is true" do
-      @confine = Puppet::Confine::False.new("foo")
-      expect(@confine.message("eh")).to be_include("true")
-    end
-  end
-
-  it "should be able to produce a summary with the number of incorrectly true values" do
-    confine = Puppet::Confine::False.new %w{one two three four}
-    expect(confine).to receive(:pass?).exactly(4).times.and_return(true, false, true, false)
-    expect(confine.summary).to eq(2)
-  end
-
-  it "should summarize multiple instances by summing their summaries" do
-    c1 = double('1', :summary => 1)
-    c2 = double('2', :summary => 2)
-    c3 = double('3', :summary => 3)
-
-    expect(Puppet::Confine::False.summarize([c1, c2, c3])).to eq(6)
-  end
-end

data/spec/unit/confine/feature_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/confine/feature'
-
-describe Puppet::Confine::Feature do
-  it "should be named :feature" do
-    expect(Puppet::Confine::Feature.name).to eq(:feature)
-  end
-
-  it "should require a value" do
-    expect { Puppet::Confine::Feature.new }.to raise_error(ArgumentError)
-  end
-
-  it "should always convert values to an array" do
-    expect(Puppet::Confine::Feature.new("/some/file").values).to be_instance_of(Array)
-  end
-
-  describe "when testing values" do
-    before do
-      @confine = Puppet::Confine::Feature.new("myfeature")
-      @confine.label = "eh"
-    end
-
-    it "should use the Puppet features instance to test validity" do
-      Puppet.features.add(:myfeature) do true end
-      @confine.valid?
-    end
-
-    it "should return true if the feature is present" do
-      Puppet.features.add(:myfeature) do true end
-      expect(@confine.pass?("myfeature")).to be_truthy
-    end
-
-    it "should return false if the value is false" do
-      Puppet.features.add(:myfeature) do false end
-      expect(@confine.pass?("myfeature")).to be_falsey
-    end
-
-    it "should log that a feature is missing" do
-      expect(@confine.message("myfeat")).to be_include("missing")
-    end
-  end
-
-  it "should summarize multiple instances by returning a flattened array of all missing features" do
-    confines = []
-    confines << Puppet::Confine::Feature.new(%w{one two})
-    confines << Puppet::Confine::Feature.new(%w{two})
-    confines << Puppet::Confine::Feature.new(%w{three four})
-
-    features = double('feature')
-    allow(features).to receive(:one?)
-    allow(features).to receive(:two?)
-    allow(features).to receive(:three?)
-    allow(features).to receive(:four?)
-    allow(Puppet).to receive(:features).and_return(features)
-
-    expect(Puppet::Confine::Feature.summarize(confines).sort).to eq(%w{one two three four}.sort)
-  end
-end

data/spec/unit/confine/true_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/confine/true'
-
-describe Puppet::Confine::True do
-  it "should be named :true" do
-    expect(Puppet::Confine::True.name).to eq(:true)
-  end
-
-  it "should require a value" do
-    expect { Puppet::Confine::True.new }.to raise_error(ArgumentError)
-  end
-
-  describe "when passing in a lambda as a value for lazy evaluation" do
-    it "should accept it" do
-      confine = Puppet::Confine::True.new(lambda { true })
-      expect(confine.values).to eql([true])
-    end
-
-    describe "when enforcing cache-positive behavior" do
-      def cached_value_of(confine)
-        confine.instance_variable_get(:@cached_value)
-      end
-
-      it "should cache a true value" do
-        confine = Puppet::Confine::True.new(lambda { true })
-        confine.values
-
-        expect(cached_value_of(confine)).to eql([true])
-      end
-
-      it "should not cache a false value" do
-        confine = Puppet::Confine::True.new(lambda { false })
-        confine.values
-
-        expect(cached_value_of(confine)).to be_nil
-      end
-    end
-  end
-
-  describe "when testing values" do
-    before do
-      @confine = Puppet::Confine::True.new("foo")
-      @confine.label = "eh"
-    end
-
-    it "should use the 'pass?' method to test validity" do
-      expect(@confine).to receive(:pass?).with("foo")
-      @confine.valid?
-    end
-
-    it "should return true if the value is not false" do
-      expect(@confine.pass?("else")).to be_truthy
-    end
-
-    it "should return false if the value is false" do
-      expect(@confine.pass?(nil)).to be_falsey
-    end
-
-    it "should produce the message that a value is false" do
-      expect(@confine.message("eh")).to be_include("false")
-    end
-  end
-
-  it "should produce the number of false values when asked for a summary" do
-    @confine = Puppet::Confine::True.new %w{one two three four}
-    expect(@confine).to receive(:pass?).exactly(4).times.and_return(true, false, true, false)
-    expect(@confine.summary).to eq(2)
-  end
-
-  it "should summarize multiple instances by summing their summaries" do
-    c1 = double('1', :summary => 1)
-    c2 = double('2', :summary => 2)
-    c3 = double('3', :summary => 3)
-
-    expect(Puppet::Confine::True.summarize([c1, c2, c3])).to eq(6)
-  end
-end

data/spec/unit/confine/variable_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/confine/variable'
-
-describe Puppet::Confine::Variable do
-  it "should be named :variable" do
-    expect(Puppet::Confine::Variable.name).to eq(:variable)
-  end
-
-  it "should require a value" do
-    expect { Puppet::Confine::Variable.new }.to raise_error(ArgumentError)
-  end
-
-  it "should always convert values to an array" do
-    expect(Puppet::Confine::Variable.new("/some/file").values).to be_instance_of(Array)
-  end
-
-  it "should have an accessor for its name" do
-    expect(Puppet::Confine::Variable.new(:bar)).to respond_to(:name)
-  end
-
-  describe "when testing values" do
-    before do
-      @confine = Puppet::Confine::Variable.new("foo")
-      @confine.name = :myvar
-    end
-
-    it "should use settings if the variable name is a valid setting" do
-      expect(Puppet.settings).to receive(:valid?).with(:myvar).and_return(true)
-      expect(Puppet.settings).to receive(:value).with(:myvar).and_return("foo")
-      @confine.valid?
-    end
-
-    it "should use Facter if the variable name is not a valid setting" do
-      expect(Puppet.settings).to receive(:valid?).with(:myvar).and_return(false)
-      expect(Facter).to receive(:value).with(:myvar).and_return("foo")
-      @confine.valid?
-    end
-
-    it "should be valid if the value matches the facter value" do
-      expect(@confine).to receive(:test_value).and_return("foo")
-
-      expect(@confine).to be_valid
-    end
-
-    it "should return false if the value does not match the facter value" do
-      expect(@confine).to receive(:test_value).and_return("fee")
-
-      expect(@confine).not_to be_valid
-    end
-
-    it "should be case insensitive" do
-      expect(@confine).to receive(:test_value).and_return("FOO")
-
-      expect(@confine).to be_valid
-    end
-
-    it "should not care whether the value is a string or symbol" do
-      expect(@confine).to receive(:test_value).and_return("FOO")
-
-      expect(@confine).to be_valid
-    end
-
-    it "should produce a message that the fact value is not correct" do
-      @confine = Puppet::Confine::Variable.new(%w{bar bee})
-      @confine.name = "eh"
-      message = @confine.message("value")
-      expect(message).to be_include("facter")
-      expect(message).to be_include("bar,bee")
-    end
-
-    it "should be valid if the test value matches any of the provided values" do
-      @confine = Puppet::Confine::Variable.new(%w{bar bee})
-      expect(@confine).to receive(:test_value).and_return("bee")
-      expect(@confine).to be_valid
-    end
-  end
-
-  describe "when summarizing multiple instances" do
-    it "should return a hash of failing variables and their values" do
-      c1 = Puppet::Confine::Variable.new("one")
-      c1.name = "uno"
-      expect(c1).to receive(:valid?).and_return(false)
-      c2 = Puppet::Confine::Variable.new("two")
-      c2.name = "dos"
-      expect(c2).to receive(:valid?).and_return(true)
-      c3 = Puppet::Confine::Variable.new("three")
-      c3.name = "tres"
-      expect(c3).to receive(:valid?).and_return(false)
-
-      expect(Puppet::Confine::Variable.summarize([c1, c2, c3])).to eq({"uno" => %w{one}, "tres" => %w{three}})
-    end
-
-    it "should combine the values of multiple confines with the same fact" do
-      c1 = Puppet::Confine::Variable.new("one")
-      c1.name = "uno"
-      expect(c1).to receive(:valid?).and_return(false)
-      c2 = Puppet::Confine::Variable.new("two")
-      c2.name = "uno"
-      expect(c2).to receive(:valid?).and_return(false)
-
-      expect(Puppet::Confine::Variable.summarize([c1, c2])).to eq({"uno" => %w{one two}})
-    end
-  end
-end

data/spec/unit/confine_collection_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/confine_collection'
-
-describe Puppet::ConfineCollection do
-  it "should be able to add confines" do
-    expect(Puppet::ConfineCollection.new("label")).to respond_to(:confine)
-  end
-
-  it "should require a label at initialization" do
-    expect { Puppet::ConfineCollection.new }.to raise_error(ArgumentError)
-  end
-
-  it "should make its label available" do
-    expect(Puppet::ConfineCollection.new("mylabel").label).to eq("mylabel")
-  end
-
-  describe "when creating confine instances" do
-    it "should create an instance of the named test with the provided values" do
-      test_class = double('test_class')
-      expect(test_class).to receive(:new).with(%w{my values}).and_return(double('confine', :label= => nil))
-      expect(Puppet::Confine).to receive(:test).with(:foo).and_return(test_class)
-
-      Puppet::ConfineCollection.new("label").confine :foo => %w{my values}
-    end
-
-    it "should copy its label to the confine instance" do
-      confine = double('confine')
-      test_class = double('test_class')
-      expect(test_class).to receive(:new).and_return(confine)
-      expect(Puppet::Confine).to receive(:test).and_return(test_class)
-
-      expect(confine).to receive(:label=).with("label")
-
-      Puppet::ConfineCollection.new("label").confine :foo => %w{my values}
-    end
-
-    describe "and the test cannot be found" do
-      it "should create a Facter test with the provided values and set the name to the test name" do
-        confine = Puppet::Confine.test(:variable).new(%w{my values})
-        expect(confine).to receive(:name=).with(:foo)
-        expect(confine.class).to receive(:new).with(%w{my values}).and_return(confine)
-        Puppet::ConfineCollection.new("label").confine(:foo => %w{my values})
-      end
-    end
-
-    describe "and the 'for_binary' option was provided" do
-      it "should mark the test as a binary confine" do
-        confine = Puppet::Confine.test(:exists).new(:bar)
-        expect(confine).to receive(:for_binary=).with(true)
-        expect(Puppet::Confine.test(:exists)).to receive(:new).with(:bar).and_return(confine)
-        Puppet::ConfineCollection.new("label").confine :exists => :bar, :for_binary => true
-      end
-    end
-  end
-
-  it "should be valid if no confines are present" do
-    expect(Puppet::ConfineCollection.new("label")).to be_valid
-  end
-
-  it "should be valid if all confines pass" do
-    c1 = double('c1', :valid? => true, :label= => nil)
-    c2 = double('c2', :valid? => true, :label= => nil)
-
-    expect(Puppet::Confine.test(:true)).to receive(:new).and_return(c1)
-    expect(Puppet::Confine.test(:false)).to receive(:new).and_return(c2)
-
-    confiner = Puppet::ConfineCollection.new("label")
-    confiner.confine :true => :bar, :false => :bee
-
-    expect(confiner).to be_valid
-  end
-
-  it "should not be valid if any confines fail" do
-    c1 = double('c1', :valid? => true, :label= => nil)
-    c2 = double('c2', :valid? => false, :label= => nil)
-
-    expect(Puppet::Confine.test(:true)).to receive(:new).and_return(c1)
-    expect(Puppet::Confine.test(:false)).to receive(:new).and_return(c2)
-
-    confiner = Puppet::ConfineCollection.new("label")
-    confiner.confine :true => :bar, :false => :bee
-
-    expect(confiner).not_to be_valid
-  end
-
-  describe "when providing a summary" do
-    before do
-      @confiner = Puppet::ConfineCollection.new("label")
-    end
-
-    it "should return a hash" do
-      expect(@confiner.summary).to be_instance_of(Hash)
-    end
-
-    it "should return an empty hash if the confiner is valid" do
-      expect(@confiner.summary).to eq({})
-    end
-
-    it "should add each test type's summary to the hash" do
-      @confiner.confine :true => :bar, :false => :bee
-      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return(:tsumm)
-      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
-
-      expect(@confiner.summary).to eq({:true => :tsumm, :false => :fsumm})
-    end
-
-    it "should not include tests that return 0" do
-      @confiner.confine :true => :bar, :false => :bee
-      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return(0)
-      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
-
-      expect(@confiner.summary).to eq({:false => :fsumm})
-    end
-
-    it "should not include tests that return empty arrays" do
-      @confiner.confine :true => :bar, :false => :bee
-      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return([])
-      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
-
-      expect(@confiner.summary).to eq({:false => :fsumm})
-    end
-
-    it "should not include tests that return empty hashes" do
-      @confiner.confine :true => :bar, :false => :bee
-      expect(Puppet::Confine.test(:true)).to receive(:summarize).and_return({})
-      expect(Puppet::Confine.test(:false)).to receive(:summarize).and_return(:fsumm)
-
-      expect(@confiner.summary).to eq({:false => :fsumm})
-    end
-  end
-end

data/spec/unit/confine_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/confine'
-
-class Puppet::TestConfine < Puppet::Confine
-  def pass?(value)
-    false
-  end
-end
-
-describe Puppet::Confine do
-  it "should require a value" do
-    expect { Puppet::Confine.new }.to raise_error(ArgumentError)
-  end
-
-  it "should always convert values to an array" do
-    expect(Puppet::Confine.new("/some/file").values).to be_instance_of(Array)
-  end
-
-  it "should have a 'true' test" do
-    expect(Puppet::Confine.test(:true)).to be_instance_of(Class)
-  end
-
-  it "should have a 'false' test" do
-    expect(Puppet::Confine.test(:false)).to be_instance_of(Class)
-  end
-
-  it "should have a 'feature' test" do
-    expect(Puppet::Confine.test(:feature)).to be_instance_of(Class)
-  end
-
-  it "should have an 'exists' test" do
-    expect(Puppet::Confine.test(:exists)).to be_instance_of(Class)
-  end
-
-  it "should have a 'variable' test" do
-    expect(Puppet::Confine.test(:variable)).to be_instance_of(Class)
-  end
-
-  describe "when testing all values" do
-    before do
-      @confine = Puppet::TestConfine.new(%w{a b c})
-      @confine.label = "foo"
-    end
-
-    it "should be invalid if any values fail" do
-      allow(@confine).to receive(:pass?).and_return(true)
-      expect(@confine).to receive(:pass?).with("b").and_return(false)
-      expect(@confine).not_to be_valid
-    end
-
-    it "should be valid if all values pass" do
-      allow(@confine).to receive(:pass?).and_return(true)
-      expect(@confine).to be_valid
-    end
-
-    it "should short-cut at the first failing value" do
-      expect(@confine).to receive(:pass?).once.and_return(false)
-      @confine.valid?
-    end
-
-    it "should log failing confines with the label and message" do
-      Puppet[:log_level] = 'debug'
-      allow(@confine).to receive(:pass?).and_return(false)
-      expect(@confine).to receive(:message).and_return("My message")
-      expect(@confine).to receive(:label).and_return("Mylabel")
-      expect(Puppet).to receive(:debug) { |&b| expect(b.call).to eq("Mylabel: My message") }
-      @confine.valid?
-    end
-  end
-
-  describe "when testing the result of the values" do
-    before { @confine = Puppet::TestConfine.new(%w{a b c d}) }
-
-    it "should return an array with the result of the test for each value" do
-      allow(@confine).to receive(:pass?).and_return(true)
-      expect(@confine).to receive(:pass?).with("b").and_return(false)
-      expect(@confine).to receive(:pass?).with("d").and_return(false)
-
-      expect(@confine.result).to eq([true, false, true, false])
-    end
-  end
-
-  describe "when requiring" do
-    it "does not cache failed requires when always_retry_plugins is true" do
-      Puppet[:always_retry_plugins] = true
-      expect(Puppet::Confine).to receive(:require).with('puppet/confine/osfamily').twice.and_raise(LoadError)
-      Puppet::Confine.test(:osfamily)
-      Puppet::Confine.test(:osfamily)
-    end
-
-    it "caches failed requires when always_retry_plugins is false" do
-      Puppet[:always_retry_plugins] = false
-      expect(Puppet::Confine).to receive(:require).with('puppet/confine/osfamily').once.and_raise(LoadError)
-      Puppet::Confine.test(:osfamily)
-      Puppet::Confine.test(:osfamily)
-    end
-  end
-end

data/spec/unit/confiner_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/confiner'
-
-describe Puppet::Confiner do
-  let(:coll) { Puppet::ConfineCollection.new('') }
-
-  before do
-    @object = Object.new
-    @object.extend(Puppet::Confiner)
-  end
-
-  it "should have a method for defining confines" do
-    expect(@object).to respond_to(:confine)
-  end
-
-  it "should have a method for returning its confine collection" do
-    expect(@object).to respond_to(:confine_collection)
-  end
-
-  it "should have a method for testing suitability" do
-    expect(@object).to respond_to(:suitable?)
-  end
-
-  it "should delegate its confine method to its confine collection" do
-    allow(@object).to receive(:confine_collection).and_return(coll)
-    expect(coll).to receive(:confine).with({:foo => :bar, :bee => :baz})
-    @object.confine(:foo => :bar, :bee => :baz)
-  end
-
-  it "should create a new confine collection if one does not exist" do
-    expect(Puppet::ConfineCollection).to receive(:new).with("mylabel").and_return("mycoll")
-    expect(@object).to receive(:to_s).and_return("mylabel")
-    expect(@object.confine_collection).to eq("mycoll")
-  end
-
-  it "should reuse the confine collection" do
-    expect(@object.confine_collection).to equal(@object.confine_collection)
-  end
-
-  describe "when testing suitability" do
-    before do
-      allow(@object).to receive(:confine_collection).and_return(coll)
-    end
-
-    it "should return true if the confine collection is valid" do
-      expect(coll).to receive(:valid?).and_return(true)
-      expect(@object).to be_suitable
-    end
-
-    it "should return false if the confine collection is invalid" do
-      expect(coll).to receive(:valid?).and_return(false)
-      expect(@object).not_to be_suitable
-    end
-
-    it "should return the summary of the confine collection if a long result is asked for" do
-      expect(coll).to receive(:summary).and_return("myresult")
-      expect(@object.suitable?(false)).to eq("myresult")
-    end
-  end
-end