puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/property_spec.rb

@@ -1,563 +0,0 @@
-require 'spec_helper'
-require 'puppet/property'
-
-Puppet::Type.newtype(:property_test) do
-  newparam(:name, isnamevar: true)
-end
-Puppet::Type.type(:property_test).provide(:property_test) do
-  attr_accessor :foo
-end
-
-describe Puppet::Property do
-  let :resource do
-    Puppet::Type.type(:property_test).new(:name => "foo")
-  end
-
-  let :subclass do
-    # We need a completely fresh subclass every time, because we modify both
-    # class and instance level things inside the tests.
-    subclass = Class.new(Puppet::Property) do
-      class << self
-        attr_accessor :name
-      end
-      @name = :foo
-    end
-    subclass.initvars
-    subclass
-  end
-
-  let :property do subclass.new :resource => resource end
-
-  it "should be able to look up the modified name for a given value" do
-    subclass.newvalue(:foo)
-    expect(subclass.value_name("foo")).to eq(:foo)
-  end
-
-  it "should be able to look up the modified name for a given value matching a regex" do
-    subclass.newvalue(%r{.})
-    expect(subclass.value_name("foo")).to eq(%r{.})
-  end
-
-  it "should be able to look up a given value option" do
-    subclass.newvalue(:foo, :event => :whatever)
-    expect(subclass.value_option(:foo, :event)).to eq(:whatever)
-  end
-
-  it "should be able to specify required features" do
-    expect(subclass).to respond_to(:required_features=)
-  end
-
-  {"one" => [:one],:one => [:one],%w{a} => [:a],[:b] => [:b],%w{one two} => [:one,:two],[:a,:b] => [:a,:b]}.each { |in_value,out_value|
-    it "should always convert required features into an array of symbols (e.g. #{in_value.inspect} --> #{out_value.inspect})" do
-      subclass.required_features = in_value
-      expect(subclass.required_features).to eq(out_value)
-    end
-  }
-
-  it "should return its name as a string when converted to a string" do
-    expect(property.to_s).to eq(property.name.to_s)
-  end
-
-  describe "when returning the default event name" do
-    it "should use the current 'should' value to pick the event name" do
-      expect(property).to receive(:should).and_return("myvalue")
-      expect(subclass).to receive(:value_option).with('myvalue', :event).and_return(:event_name)
-
-      property.event_name
-    end
-
-    it "should return any event defined with the specified value" do
-      expect(property).to receive(:should).and_return(:myval)
-      expect(subclass).to receive(:value_option).with(:myval, :event).and_return(:event_name)
-
-      expect(property.event_name).to eq(:event_name)
-    end
-
-    describe "and the property is 'ensure'" do
-      before :each do
-        allow(property).to receive(:name).and_return(:ensure)
-        expect(resource).to receive(:type).and_return(:mytype)
-      end
-
-      it "should use <type>_created if the 'should' value is 'present'" do
-        expect(property).to receive(:should).and_return(:present)
-        expect(property.event_name).to eq(:mytype_created)
-      end
-
-      it "should use <type>_removed if the 'should' value is 'absent'" do
-        expect(property).to receive(:should).and_return(:absent)
-        expect(property.event_name).to eq(:mytype_removed)
-      end
-
-      it "should use <type>_changed if the 'should' value is not 'absent' or 'present'" do
-        expect(property).to receive(:should).and_return(:foo)
-        expect(property.event_name).to eq(:mytype_changed)
-      end
-
-      it "should use <type>_changed if the 'should value is nil" do
-        expect(property).to receive(:should).and_return(nil)
-        expect(property.event_name).to eq(:mytype_changed)
-      end
-    end
-
-    it "should use <property>_changed if the property is not 'ensure'" do
-      allow(property).to receive(:name).and_return(:myparam)
-      expect(property).to receive(:should).and_return(:foo)
-      expect(property.event_name).to eq(:myparam_changed)
-    end
-
-    it "should use <property>_changed if no 'should' value is set" do
-      allow(property).to receive(:name).and_return(:myparam)
-      expect(property).to receive(:should).and_return(nil)
-      expect(property.event_name).to eq(:myparam_changed)
-    end
-  end
-
-  describe "when creating an event" do
-    before :each do
-      allow(property).to receive(:should).and_return("myval")
-    end
-
-    it "should use an event from the resource as the base event" do
-      event = Puppet::Transaction::Event.new
-      expect(resource).to receive(:event).and_return(event)
-
-      expect(property.event).to equal(event)
-    end
-
-    it "should have the default event name" do
-      expect(property).to receive(:event_name).and_return(:my_event)
-      expect(property.event.name).to eq(:my_event)
-    end
-
-    it "should have the property's name" do
-      expect(property.event.property).to eq(property.name.to_s)
-    end
-
-    it "should have the 'should' value set" do
-      allow(property).to receive(:should).and_return("foo")
-      expect(property.event.desired_value).to eq("foo")
-    end
-
-    it "should provide its path as the source description" do
-      allow(property).to receive(:path).and_return("/my/param")
-      expect(property.event.source_description).to eq("/my/param")
-    end
-
-    it "should have the 'invalidate_refreshes' value set if set on a value" do
-      allow(property).to receive(:event_name).and_return(:my_event)
-      allow(property).to receive(:should).and_return("foo")
-      foo = double()
-      expect(foo).to receive(:invalidate_refreshes).and_return(true)
-      collection = double()
-      expect(collection).to receive(:match?).with("foo").and_return(foo)
-      allow(property.class).to receive(:value_collection).and_return(collection)
-      expect(property.event.invalidate_refreshes).to be_truthy
-    end
-
-    it "sets the redacted field on the event when the property is sensitive" do
-      property.sensitive = true
-      expect(property.event.redacted).to eq true
-    end
-  end
-
-  describe "when defining new values" do
-    it "should define a method for each value created with a block that's not a regex" do
-      subclass.newvalue(:foo) { }
-      expect(property).to respond_to(:set_foo)
-    end
-  end
-
-  describe "when assigning the value" do
-    it "should just set the 'should' value" do
-      property.value = "foo"
-      expect(property.should).to eq("foo")
-    end
-
-    it "should validate each value separately" do
-      expect(property).to receive(:validate).with("one")
-      expect(property).to receive(:validate).with("two")
-
-      property.value = %w{one two}
-    end
-
-    it "should munge each value separately and use any result as the actual value" do
-      expect(property).to receive(:munge).with("one").and_return(:one)
-      expect(property).to receive(:munge).with("two").and_return(:two)
-
-      # Do this so we get the whole array back.
-      subclass.array_matching = :all
-
-      property.value = %w{one two}
-      expect(property.should).to eq([:one, :two])
-    end
-
-    it "should return any set value" do
-      expect(property.value = :one).to eq(:one)
-    end
-  end
-
-  describe "when returning the value" do
-    it "should return nil if no value is set" do
-      expect(property.should).to be_nil
-    end
-
-    it "should return the first set 'should' value if :array_matching is set to :first" do
-      subclass.array_matching = :first
-      property.should = %w{one two}
-      expect(property.should).to eq("one")
-    end
-
-    it "should return all set 'should' values as an array if :array_matching is set to :all" do
-      subclass.array_matching = :all
-      property.should = %w{one two}
-      expect(property.should).to eq(%w{one two})
-    end
-
-    it "should default to :first array_matching" do
-      expect(subclass.array_matching).to eq(:first)
-    end
-
-    it "should unmunge the returned value if :array_matching is set to :first" do
-      property.class.unmunge do |v| v.to_sym end
-      subclass.array_matching = :first
-      property.should = %w{one two}
-
-      expect(property.should).to eq(:one)
-    end
-
-    it "should unmunge all the returned values if :array_matching is set to :all" do
-      property.class.unmunge do |v| v.to_sym end
-      subclass.array_matching = :all
-      property.should = %w{one two}
-
-      expect(property.should).to eq([:one, :two])
-    end
-  end
-
-  describe "when validating values" do
-    it "should do nothing if no values or regexes have been defined" do
-      expect { property.should = "foo" }.not_to raise_error
-    end
-
-    it "should fail if the value is not a defined value or alias and does not match a regex" do
-      subclass.newvalue(:foo)
-
-      expect { property.should = "bar" }.to raise_error(Puppet::Error, /Invalid value "bar"./)
-    end
-
-    it "should succeeed if the value is one of the defined values" do
-      subclass.newvalue(:foo)
-
-      expect { property.should = :foo }.not_to raise_error
-    end
-
-    it "should succeeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
-      subclass.newvalue(:foo)
-
-      expect { property.should = "foo" }.not_to raise_error
-    end
-
-    it "should succeeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
-      subclass.newvalue("foo")
-
-      expect { property.should = :foo }.not_to raise_error
-    end
-
-    it "should succeed if the value is one of the defined aliases" do
-      subclass.newvalue("foo")
-      subclass.aliasvalue("bar", "foo")
-
-      expect { property.should = :bar }.not_to raise_error
-    end
-
-    it "should succeed if the value matches one of the regexes" do
-      subclass.newvalue(/./)
-
-      expect { property.should = "bar" }.not_to raise_error
-    end
-
-    it "should validate that all required features are present" do
-      subclass.newvalue(:foo, :required_features => [:a, :b])
-
-      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(true)
-
-      property.should = :foo
-    end
-
-    it "should fail if required features are missing" do
-      subclass.newvalue(:foo, :required_features => [:a, :b])
-
-      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(false)
-
-      expect { property.should = :foo }.to raise_error(Puppet::Error)
-    end
-
-    it "should internally raise an ArgumentError if required features are missing" do
-      subclass.newvalue(:foo, :required_features => [:a, :b])
-
-      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(false)
-
-      expect { property.validate_features_per_value :foo }.to raise_error(ArgumentError)
-    end
-
-    it "should validate that all required features are present for regexes" do
-      subclass.newvalue(/./, :required_features => [:a, :b])
-
-      expect(resource.provider).to receive(:satisfies?).with([:a, :b]).and_return(true)
-
-      property.should = "foo"
-    end
-
-    it "should support specifying an individual required feature" do
-      subclass.newvalue(/./, :required_features => :a)
-
-      expect(resource.provider).to receive(:satisfies?).and_return(true)
-
-      property.should = "foo"
-    end
-  end
-
-  describe "when munging values" do
-    it "should do nothing if no values or regexes have been defined" do
-      expect(property.munge("foo")).to eq("foo")
-    end
-
-    it "should return return any matching defined values" do
-      subclass.newvalue(:foo)
-      expect(property.munge("foo")).to eq(:foo)
-    end
-
-    it "should return any matching aliases" do
-      subclass.newvalue(:foo)
-      subclass.aliasvalue(:bar, :foo)
-      expect(property.munge("bar")).to eq(:foo)
-    end
-
-    it "should return the value if it matches a regex" do
-      subclass.newvalue(/./)
-      expect(property.munge("bar")).to eq("bar")
-    end
-
-    it "should return the value if no other option is matched" do
-      subclass.newvalue(:foo)
-      expect(property.munge("bar")).to eq("bar")
-    end
-  end
-
-  describe "when syncing the 'should' value" do
-    it "should set the value" do
-      subclass.newvalue(:foo)
-      property.should = :foo
-      expect(property).to receive(:set).with(:foo)
-      property.sync
-    end
-  end
-
-  describe "when setting a value" do
-    it "should catch exceptions and raise Puppet::Error" do
-      subclass.newvalue(:foo) { raise "eh" }
-      expect { property.set(:foo) }.to raise_error(Puppet::Error)
-    end
-
-    it "fails when the provider does not handle the attribute" do
-      subclass.name = "unknown"
-      expect { property.set(:a_value) }.to raise_error(Puppet::Error)
-    end
-
-    it "propogates the errors about missing methods from the provider" do
-      provider = resource.provider
-      def provider.bad_method=(value)
-        value.this_method_does_not_exist
-      end
-
-      subclass.name = :bad_method
-      expect { property.set(:a_value) }.to raise_error(NoMethodError, /this_method_does_not_exist/)
-    end
-
-    describe "that was defined without a block" do
-      it "should call the settor on the provider" do
-        subclass.newvalue(:bar)
-        expect(resource.provider).to receive(:foo=).with(:bar)
-        property.set(:bar)
-      end
-
-       it "should generate setter named from :method argument and propagate call to the provider" do
-        subclass.newvalue(:bar, :method => 'set_vv')
-        expect(resource.provider).to receive(:foo=).with(:bar)
-        property.set_vv(:bar)
-      end
-    end
-
-    describe "that was defined with a block" do
-      it "should call the method created for the value if the value is not a regex" do
-        subclass.newvalue(:bar) {}
-        expect(property).to receive(:set_bar)
-        property.set(:bar)
-      end
-
-      it "should call the provided block if the value is a regex" do
-        thing = double
-        subclass.newvalue(/./) { thing.test }
-        expect(thing).to receive(:test)
-        property.set("foo")
-      end
-    end
-  end
-
-  describe "when producing a change log" do
-    it "should say 'defined' when the current value is 'absent'" do
-      expect(property.change_to_s(:absent, "foo")).to match(/^defined/)
-    end
-
-    it "should say 'undefined' when the new value is 'absent'" do
-      expect(property.change_to_s("foo", :absent)).to match(/^undefined/)
-    end
-
-    it "should say 'changed' when neither value is 'absent'" do
-      expect(property.change_to_s("foo", "bar")).to match(/changed/)
-    end
-  end
-
-  shared_examples_for "#insync?" do
-    # We share a lot of behaviour between the all and first matching, so we
-    # use a shared behaviour set to emulate that.  The outside world makes
-    # sure the class, etc, point to the right content.
-    [[], [12], [12, 13]].each do |input|
-      it "should return true if should is empty with is => #{input.inspect}" do
-        property.should = []
-        expect(property).to be_insync(input)
-        expect(property.insync_values?([], input)).to be true
-      end
-    end
-  end
-
-  describe "#insync?" do
-    context "array_matching :all" do
-      # `@should` is an array of scalar values, and `is` is an array of scalar values.
-      before :each do
-        property.class.array_matching = :all
-      end
-
-      it_should_behave_like "#insync?"
-
-      context "if the should value is an array" do
-        let(:input) { [1,2] }
-        before :each do property.should = input end
-
-        it "should match if is exactly matches" do
-          val = [1, 2]
-          expect(property).to be_insync val
-          expect(property.insync_values?(input, val)).to be true
-        end
-
-        it "should match if it matches, but all stringified" do
-          val = ["1", "2"]
-          expect(property).to be_insync val
-          expect(property.insync_values?(input, val)).to be true
-        end
-
-        it "should not match if some-but-not-all values are stringified" do
-          val = ["1", 2]
-          expect(property).to_not be_insync val
-          expect(property.insync_values?(input, val)).to_not be true
-          val = [1, "2"]
-          expect(property).to_not be_insync val
-          expect(property.insync_values?(input, val)).to_not be true
-        end
-
-        it "should not match if order is different but content the same" do
-          val = [2, 1]
-          expect(property).to_not be_insync val
-          expect(property.insync_values?(input, val)).to_not be true
-        end
-
-        it "should not match if there are more items in should than is" do
-          val = [1]
-          expect(property).to_not be_insync val
-          expect(property.insync_values?(input, val)).to_not be true
-        end
-
-        it "should not match if there are less items in should than is" do
-          val = [1, 2, 3]
-          expect(property).to_not be_insync val
-          expect(property.insync_values?(input, val)).to_not be true
-        end
-
-        it "should not match if `is` is empty but `should` isn't" do
-          val = []
-          expect(property).to_not be_insync val
-          expect(property.insync_values?(input, val)).to_not be true
-        end
-      end
-    end
-
-    context "array_matching :first" do
-      # `@should` is an array of scalar values, and `is` is a scalar value.
-      before :each do
-        property.class.array_matching = :first
-      end
-
-      it_should_behave_like "#insync?"
-
-      [[1],                     # only the value
-       [1, 2],                  # matching value first
-       [2, 1],                  # matching value last
-       [0, 1, 2],               # matching value in the middle
-      ].each do |input|
-        it "should by true if one unmodified should value of #{input.inspect} matches what is" do
-          val = 1
-          property.should = input
-          expect(property).to be_insync val
-          expect(property.insync_values?(input, val)).to be true
-        end
-
-        it "should be true if one stringified should value of #{input.inspect} matches what is" do
-          val = "1"
-          property.should = input
-          expect(property).to be_insync val
-          expect(property.insync_values?(input, val)).to be true
-        end
-      end
-
-      it "should not match if we expect a string but get the non-stringified value" do
-        property.should = ["1"]
-        expect(property).to_not be_insync 1
-        expect(property.insync_values?(["1"], 1)).to_not be true
-      end
-
-      [[0], [0, 2]].each do |input|
-        it "should not match if no should values match what is" do
-          property.should = input
-          expect(property).to_not be_insync 1
-          expect(property.insync_values?(input, 1)).to_not be true
-          expect(property).to_not be_insync "1" # shouldn't match either.
-          expect(property.insync_values?(input, "1")).to_not be true
-        end
-      end
-    end
-  end
-
-  describe "#property_matches?" do
-    [1, "1", [1], :one].each do |input|
-      it "should treat two equal objects as equal (#{input.inspect})" do
-        expect(property.property_matches?(input, input)).to be_truthy
-      end
-    end
-
-    it "should treat two objects as equal if the first argument is the stringified version of the second" do
-      expect(property.property_matches?("1", 1)).to be_truthy
-    end
-
-    it "should NOT treat two objects as equal if the first argument is not a string, and the second argument is a string, even if it stringifies to the first" do
-      expect(property.property_matches?(1, "1")).to be_falsey
-    end
-  end
-
-  describe "#insync_values?" do
-    it "should log an exception when insync? throws one" do
-      expect(property).to receive(:insync?).and_raise(ArgumentError)
-      expect(property.insync_values?("foo","bar")).to be nil
-    end
-  end
-end

data/spec/unit/provider/README.markdown

@@ -1,4 +0,0 @@
-Provider Specs
-==============
-
-Define specs for your providers under this directory.