puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/property/list_spec.rb

@@ -8,7 +8,7 @@ list_class = Puppet::Property::List
 describe list_class do
 
   it "should be a subclass of Property" do
-    list_class.superclass.must == Puppet::Property
+    expect(list_class.superclass).to eq(Puppet::Property)
   end
 
   describe "as an instance" do
@@ -20,11 +20,11 @@ describe list_class do
     end
 
     it "should have a , as default delimiter" do
-      @property.delimiter.should == ","
+      expect(@property.delimiter).to eq(",")
     end
 
     it "should have a :membership as default membership" do
-      @property.membership.should == :membership
+      expect(@property.membership).to eq(:membership)
     end
 
     it "should return the same value passed into should_to_s" do
@@ -32,24 +32,24 @@ describe list_class do
     end
 
     it "should return the passed in array values joined with the delimiter from is_to_s" do
-      @property.is_to_s(["foo","bar"]).should == "foo,bar"
+      expect(@property.is_to_s(["foo","bar"])).to eq("foo,bar")
     end
 
     it "should be able to correctly convert ':absent' to a string" do
-      @property.is_to_s(:absent).should == "absent"
+      expect(@property.is_to_s(:absent)).to eq("absent")
     end
 
     describe "when adding should to current" do
       it "should add the arrays when current is an array" do
-        @property.add_should_with_current(["foo"], ["bar"]).should == ["foo", "bar"]
+        expect(@property.add_should_with_current(["foo"], ["bar"])).to eq(["foo", "bar"])
       end
 
       it "should return should if current is not an array" do
-        @property.add_should_with_current(["foo"], :absent).should == ["foo"]
+        expect(@property.add_should_with_current(["foo"], :absent)).to eq(["foo"])
       end
 
       it "should return only the uniq elements" do
-        @property.add_should_with_current(["foo", "bar"], ["foo", "baz"]).should == ["foo", "bar", "baz"]
+        expect(@property.add_should_with_current(["foo", "bar"], ["foo", "baz"])).to eq(["foo", "bar", "baz"])
       end
     end
 
@@ -63,32 +63,32 @@ describe list_class do
       it "should return true when @resource[membership] == inclusive" do
         @property.stubs(:membership).returns(:membership)
         @resource.stubs(:[]).with(:membership).returns(:inclusive)
-        @property.inclusive?.must == true
+        expect(@property.inclusive?).to eq(true)
       end
 
       it "should return false when @resource[membership] != inclusive" do
         @property.stubs(:membership).returns(:membership)
         @resource.stubs(:[]).with(:membership).returns(:minimum)
-        @property.inclusive?.must == false
+        expect(@property.inclusive?).to eq(false)
       end
     end
 
     describe "when calling should" do
       it "should return nil if @should is nil" do
-        @property.should.must == nil
+        expect(@property.should).to eq(nil)
       end
 
       it "should return the sorted values of @should as a string if inclusive" do
         @property.should = ["foo", "bar"]
         @property.expects(:inclusive?).returns(true)
-        @property.should.must == "bar,foo"
+        expect(@property.should).to eq("bar,foo")
       end
 
       it "should return the uniq sorted values of @should + retrieve as a string if !inclusive" do
         @property.should = ["foo", "bar"]
         @property.expects(:inclusive?).returns(false)
         @property.expects(:retrieve).returns(["foo","baz"])
-        @property.should.must == "bar,baz,foo"
+        expect(@property.should).to eq("bar,baz,foo")
       end
     end
 
@@ -127,12 +127,12 @@ describe list_class do
 
     describe "when calling safe_insync?" do
       it "should return true unless @should is defined and not nil" do
-        @property.must be_safe_insync("foo")
+        expect(@property).to be_safe_insync("foo")
       end
 
       it "should return true unless the passed in values is not nil" do
         @property.should = "foo"
-        @property.must be_safe_insync(nil)
+        expect(@property).to be_safe_insync(nil)
       end
 
       it "should call prepare_is_for_comparison with value passed in and should" do
@@ -145,19 +145,19 @@ describe list_class do
       it "should return true if 'is' value is array of comma delimited should values" do
         @property.should = "bar,foo"
         @property.expects(:inclusive?).returns(true)
-        @property.must be_safe_insync(["bar","foo"])
+        expect(@property).to be_safe_insync(["bar","foo"])
       end
 
       it "should return true if 'is' value is :absent and should value is empty string" do
         @property.should = ""
         @property.expects(:inclusive?).returns(true)
-        @property.must be_safe_insync([])
+        expect(@property).to be_safe_insync([])
       end
 
       it "should return false if prepared value != should value" do
         @property.should = "bar,baz,foo"
         @property.expects(:inclusive?).returns(true)
-        @property.must_not be_safe_insync(["bar","foo"])
+        expect(@property).to_not be_safe_insync(["bar","foo"])
       end
     end
 

data/spec/unit/property/ordered_list_spec.rb

@@ -8,7 +8,7 @@ ordered_list_class = Puppet::Property::OrderedList
 describe ordered_list_class do
 
   it "should be a subclass of List" do
-    ordered_list_class.superclass.must == Puppet::Property::List
+    expect(ordered_list_class.superclass).to eq(Puppet::Property::List)
   end
 
   describe "as an instance" do
@@ -21,34 +21,34 @@ describe ordered_list_class do
 
     describe "when adding should to current" do
       it "should add the arrays when current is an array" do
-        @property.add_should_with_current(["should"], ["current"]).should == ["should", "current"]
+        expect(@property.add_should_with_current(["should"], ["current"])).to eq(["should", "current"])
       end
 
       it "should return 'should' if current is not an array" do
-        @property.add_should_with_current(["should"], :absent).should == ["should"]
+        expect(@property.add_should_with_current(["should"], :absent)).to eq(["should"])
       end
 
       it "should return only the uniq elements leading with the order of 'should'" do
-        @property.add_should_with_current(["this", "is", "should"], ["is", "this", "current"]).should == ["this", "is", "should", "current"]
+        expect(@property.add_should_with_current(["this", "is", "should"], ["is", "this", "current"])).to eq(["this", "is", "should", "current"])
       end
     end
 
     describe "when calling should" do
       it "should return nil if @should is nil" do
-        @property.should.must == nil
+        expect(@property.should).to eq(nil)
       end
 
       it "should return the values of @should (without sorting) as a string if inclusive" do
         @property.should = ["foo", "bar"]
         @property.expects(:inclusive?).returns(true)
-        @property.should.must == "foo,bar"
+        expect(@property.should).to eq("foo,bar")
       end
 
       it "should return the uniq values of @should + retrieve as a string if !inclusive with the @ values leading" do
         @property.should = ["foo", "bar"]
         @property.expects(:inclusive?).returns(false)
         @property.expects(:retrieve).returns(["foo","baz"])
-        @property.should.must == "foo,bar,baz"
+        expect(@property.should).to eq("foo,bar,baz")
       end
     end
 

data/spec/unit/property_spec.rb

@@ -22,36 +22,32 @@ describe Puppet::Property do
 
   it "should be able to look up the modified name for a given value" do
     subclass.newvalue(:foo)
-    subclass.value_name("foo").should == :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{.})
-    subclass.value_name("foo").should == %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)
-    subclass.value_option(:foo, :event).should == :whatever
+    expect(subclass.value_option(:foo, :event)).to eq(:whatever)
   end
 
   it "should be able to specify required features" do
-    subclass.should respond_to(:required_features=)
+    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
-      subclass.required_features.should == out_value
+      expect(subclass.required_features).to eq(out_value)
     end
   }
 
   it "should return its name as a string when converted to a string" do
-    property.to_s.should == property.name.to_s
-  end
-
-  it "should be able to shadow metaparameters" do
-    property.must respond_to(:shadow)
+    expect(property.to_s).to eq(property.name.to_s)
   end
 
   describe "when returning the default event name" do
@@ -66,7 +62,7 @@ describe Puppet::Property do
       property.expects(:should).returns :myval
       subclass.expects(:value_option).with(:myval, :event).returns :event_name
 
-      property.event_name.should == :event_name
+      expect(property.event_name).to eq(:event_name)
     end
 
     describe "and the property is 'ensure'" do
@@ -77,35 +73,35 @@ describe Puppet::Property do
 
       it "should use <type>_created if the 'should' value is 'present'" do
         property.expects(:should).returns :present
-        property.event_name.should == :mytype_created
+        expect(property.event_name).to eq(:mytype_created)
       end
 
       it "should use <type>_removed if the 'should' value is 'absent'" do
         property.expects(:should).returns :absent
-        property.event_name.should == :mytype_removed
+        expect(property.event_name).to eq(:mytype_removed)
       end
 
       it "should use <type>_changed if the 'should' value is not 'absent' or 'present'" do
         property.expects(:should).returns :foo
-        property.event_name.should == :mytype_changed
+        expect(property.event_name).to eq(:mytype_changed)
       end
 
       it "should use <type>_changed if the 'should value is nil" do
         property.expects(:should).returns nil
-        property.event_name.should == :mytype_changed
+        expect(property.event_name).to eq(:mytype_changed)
       end
     end
 
     it "should use <property>_changed if the property is not 'ensure'" do
       property.stubs(:name).returns :myparam
       property.expects(:should).returns :foo
-      property.event_name.should == :myparam_changed
+      expect(property.event_name).to eq(:myparam_changed)
     end
 
     it "should use <property>_changed if no 'should' value is set" do
       property.stubs(:name).returns :myparam
       property.expects(:should).returns nil
-      property.event_name.should == :myparam_changed
+      expect(property.event_name).to eq(:myparam_changed)
     end
   end
 
@@ -118,26 +114,26 @@ describe Puppet::Property do
       event = Puppet::Transaction::Event.new
       resource.expects(:event).returns event
 
-      property.event.should equal(event)
+      expect(property.event).to equal(event)
     end
 
     it "should have the default event name" do
       property.expects(:event_name).returns :my_event
-      property.event.name.should == :my_event
+      expect(property.event.name).to eq(:my_event)
     end
 
     it "should have the property's name" do
-      property.event.property.should == property.name.to_s
+      expect(property.event.property).to eq(property.name.to_s)
     end
 
     it "should have the 'should' value set" do
       property.stubs(:should).returns "foo"
-      property.event.desired_value.should == "foo"
+      expect(property.event.desired_value).to eq("foo")
     end
 
     it "should provide its path as the source description" do
       property.stubs(:path).returns "/my/param"
-      property.event.source_description.should == "/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
@@ -148,47 +144,21 @@ describe Puppet::Property do
       collection = mock()
       collection.expects(:match?).with("foo").returns(foo)
       property.class.stubs(:value_collection).returns(collection)
-      property.event.invalidate_refreshes.should be_true
-    end
-  end
-
-  describe "when shadowing metaparameters" do
-    let :shadow_class do
-      shadow_class = Class.new(Puppet::Property) do
-        @name = :alias
-      end
-      shadow_class.initvars
-      shadow_class
-    end
-
-    it "should create an instance of the metaparameter at initialization" do
-      Puppet::Type.metaparamclass(:alias).expects(:new).with(:resource => resource)
-
-      shadow_class.new :resource => resource
-    end
-
-    it "should munge values using the shadow's munge method" do
-      shadow = mock 'shadow'
-      Puppet::Type.metaparamclass(:alias).expects(:new).returns shadow
-
-      shadow.expects(:munge).with "foo"
-
-      property = shadow_class.new :resource => resource
-      property.munge("foo")
+      expect(property.event.invalidate_refreshes).to be_truthy
     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) { }
-      property.must respond_to(:set_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"
-      property.should.must == "foo"
+      expect(property.should).to eq("foo")
     end
 
     it "should validate each value separately" do
@@ -206,33 +176,33 @@ describe Puppet::Property do
       subclass.array_matching = :all
 
       property.value = %w{one two}
-      property.should.must == [:one, :two]
+      expect(property.should).to eq([:one, :two])
     end
 
     it "should return any set value" do
-      (property.value = :one).should == :one
+      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
-      property.should.must be_nil
+      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}
-      property.should.must == "one"
+      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}
-      property.should.must == %w{one two}
+      expect(property.should).to eq(%w{one two})
     end
 
     it "should default to :first array_matching" do
-      subclass.array_matching.should == :first
+      expect(subclass.array_matching).to eq(:first)
     end
 
     it "should unmunge the returned value if :array_matching is set to :first" do
@@ -240,7 +210,7 @@ describe Puppet::Property do
       subclass.array_matching = :first
       property.should = %w{one two}
 
-      property.should.must == :one
+      expect(property.should).to eq(:one)
     end
 
     it "should unmunge all the returned values if :array_matching is set to :all" do
@@ -248,50 +218,50 @@ describe Puppet::Property do
       subclass.array_matching = :all
       property.should = %w{one two}
 
-      property.should.must == [: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
-      lambda { property.should = "foo" }.should_not raise_error
+      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)
 
-      lambda { property.should = "bar" }.should raise_error
+      expect { property.should = "bar" }.to raise_error
     end
 
     it "should succeeed if the value is one of the defined values" do
       subclass.newvalue(:foo)
 
-      lambda { property.should = :foo }.should_not raise_error
+      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)
 
-      lambda { property.should = "foo" }.should_not raise_error
+      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")
 
-      lambda { property.should = :foo }.should_not raise_error
+      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")
 
-      lambda { property.should = :bar }.should_not raise_error
+      expect { property.should = :bar }.not_to raise_error
     end
 
     it "should succeed if the value matches one of the regexes" do
       subclass.newvalue(/./)
 
-      lambda { property.should = "bar" }.should_not raise_error
+      expect { property.should = "bar" }.not_to raise_error
     end
 
     it "should validate that all required features are present" do
@@ -307,7 +277,7 @@ describe Puppet::Property do
 
       resource.provider.expects(:satisfies?).with([:a, :b]).returns false
 
-      lambda { property.should = :foo }.should raise_error(Puppet::Error)
+      expect { property.should = :foo }.to raise_error(Puppet::Error)
     end
 
     it "should internally raise an ArgumentError if required features are missing" do
@@ -315,7 +285,7 @@ describe Puppet::Property do
 
       resource.provider.expects(:satisfies?).with([:a, :b]).returns false
 
-      lambda { property.validate_features_per_value :foo }.should raise_error(ArgumentError)
+      expect { property.validate_features_per_value :foo }.to raise_error(ArgumentError)
     end
 
     it "should validate that all required features are present for regexes" do
@@ -337,28 +307,28 @@ describe Puppet::Property do
 
   describe "when munging values" do
     it "should do nothing if no values or regexes have been defined" do
-      property.munge("foo").should == "foo"
+      expect(property.munge("foo")).to eq("foo")
     end
 
     it "should return return any matching defined values" do
       subclass.newvalue(:foo)
-      property.munge("foo").should == :foo
+      expect(property.munge("foo")).to eq(:foo)
     end
 
     it "should return any matching aliases" do
       subclass.newvalue(:foo)
       subclass.aliasvalue(:bar, :foo)
-      property.munge("bar").should == :foo
+      expect(property.munge("bar")).to eq(:foo)
     end
 
     it "should return the value if it matches a regex" do
       subclass.newvalue(/./)
-      property.munge("bar").should == "bar"
+      expect(property.munge("bar")).to eq("bar")
     end
 
     it "should return the value if no other option is matched" do
       subclass.newvalue(:foo)
-      property.munge("bar").should == "bar"
+      expect(property.munge("bar")).to eq("bar")
     end
   end
 
@@ -374,12 +344,12 @@ describe Puppet::Property do
   describe "when setting a value" do
     it "should catch exceptions and raise Puppet::Error" do
       subclass.newvalue(:foo) { raise "eh" }
-      lambda { property.set(:foo) }.should raise_error(Puppet::Error)
+      expect { property.set(:foo) }.to raise_error(Puppet::Error)
     end
 
     it "fails when the provider does not handle the attribute" do
       subclass.name = "unknown"
-      lambda { property.set(:a_value) }.should raise_error(Puppet::Error)
+      expect { property.set(:a_value) }.to raise_error(Puppet::Error)
     end
 
     it "propogates the errors about missing methods from the provider" do
@@ -389,7 +359,7 @@ describe Puppet::Property do
       end
 
       subclass.name = :bad_method
-      lambda { property.set(:a_value) }.should raise_error(NoMethodError, /this_method_does_not_exist/)
+      expect { property.set(:a_value) }.to raise_error(NoMethodError, /this_method_does_not_exist/)
     end
 
     describe "that was defined without a block" do
@@ -398,6 +368,12 @@ describe Puppet::Property do
         resource.provider.expects(: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')
+        resource.provider.expects(:foo=).with :bar
+        property.set_vv(:bar)
+      end
     end
 
     describe "that was defined with a block" do
@@ -417,15 +393,15 @@ describe Puppet::Property do
 
   describe "when producing a change log" do
     it "should say 'defined' when the current value is 'absent'" do
-      property.change_to_s(:absent, "foo").should =~ /^defined/
+      expect(property.change_to_s(:absent, "foo")).to match(/^defined/)
     end
 
     it "should say 'undefined' when the new value is 'absent'" do
-      property.change_to_s("foo", :absent).should =~ /^undefined/
+      expect(property.change_to_s("foo", :absent)).to match(/^undefined/)
     end
 
     it "should say 'changed' when neither value is 'absent'" do
-      property.change_to_s("foo", "bar").should =~ /changed/
+      expect(property.change_to_s("foo", "bar")).to match(/changed/)
     end
   end
 
@@ -436,7 +412,7 @@ describe Puppet::Property do
     [[], [12], [12, 13]].each do |input|
       it "should return true if should is empty with is => #{input.inspect}" do
         property.should = []
-        property.must be_insync(input)
+        expect(property).to be_insync(input)
       end
     end
   end
@@ -454,32 +430,32 @@ describe Puppet::Property do
         before :each do property.should = [1, 2] end
 
         it "should match if is exactly matches" do
-          property.must be_insync [1, 2]
+          expect(property).to be_insync [1, 2]
         end
 
         it "should match if it matches, but all stringified" do
-          property.must be_insync ["1", "2"]
+          expect(property).to be_insync ["1", "2"]
         end
 
         it "should not match if some-but-not-all values are stringified" do
-          property.must_not be_insync ["1", 2]
-          property.must_not be_insync [1, "2"]
+          expect(property).to_not be_insync ["1", 2]
+          expect(property).to_not be_insync [1, "2"]
         end
 
         it "should not match if order is different but content the same" do
-          property.must_not be_insync [2, 1]
+          expect(property).to_not be_insync [2, 1]
         end
 
         it "should not match if there are more items in should than is" do
-          property.must_not be_insync [1]
+          expect(property).to_not be_insync [1]
         end
 
         it "should not match if there are less items in should than is" do
-          property.must_not be_insync [1, 2, 3]
+          expect(property).to_not be_insync [1, 2, 3]
         end
 
         it "should not match if `is` is empty but `should` isn't" do
-          property.must_not be_insync []
+          expect(property).to_not be_insync []
         end
       end
     end
@@ -499,25 +475,25 @@ describe Puppet::Property do
       ].each do |input|
         it "should by true if one unmodified should value of #{input.inspect} matches what is" do
           property.should = input
-          property.must be_insync 1
+          expect(property).to be_insync 1
         end
 
         it "should be true if one stringified should value of #{input.inspect} matches what is" do
           property.should = input
-          property.must be_insync "1"
+          expect(property).to be_insync "1"
         end
       end
 
       it "should not match if we expect a string but get the non-stringified value" do
         property.should = ["1"]
-        property.must_not be_insync 1
+        expect(property).to_not be_insync 1
       end
 
       [[0], [0, 2]].each do |input|
         it "should not match if no should values match what is" do
           property.should = input
-          property.must_not be_insync 1
-          property.must_not be_insync "1" # shouldn't match either.
+          expect(property).to_not be_insync 1
+          expect(property).to_not be_insync "1" # shouldn't match either.
         end
       end
     end
@@ -526,16 +502,16 @@ describe Puppet::Property do
   describe "#property_matches?" do
     [1, "1", [1], :one].each do |input|
       it "should treat two equal objects as equal (#{input.inspect})" do
-        property.property_matches?(input, input).should be_true
+        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
-      property.property_matches?("1", 1).should be_true
+      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
-      property.property_matches?(1, "1").should be_false
+      expect(property.property_matches?(1, "1")).to be_falsey
     end
   end
 end