puppet 0.25.5 → 2.6.0

data/spec/unit/property/list_spec.rb

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/property/list'
+
+list_class = Puppet::Property::List
+
+describe list_class do
+
+  it "should be a subclass of Property" do
+    list_class.superclass.must == Puppet::Property
+  end
+
+  describe "as an instance" do
+    before do
+      # Wow that's a messy interface to the resource.
+      list_class.initvars
+      @resource = stub 'resource', :[]= => nil, :property => nil
+      @property = list_class.new(:resource => @resource)
+    end
+
+    it "should have a , as default delimiter" do
+      @property.delimiter.should == ","
+    end
+
+    it "should have a :membership as default membership" do
+      @property.membership.should == :membership
+    end
+
+    it "should return the same value passed into should_to_s" do
+      @property.should_to_s("foo") == "foo"
+    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"
+    end
+
+    it "should be able to correctly convert ':absent' to a string" do
+      @property.is_to_s(:absent).should == "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"]
+      end
+
+      it "should return should if current is not a array" do
+        @property.add_should_with_current(["foo"], :absent).should == ["foo"]
+      end
+
+      it "should return only the uniq elements" do
+        @property.add_should_with_current(["foo", "bar"], ["foo", "baz"]).should == ["foo", "bar", "baz"]
+      end
+    end
+
+    describe "when calling inclusive?" do
+      it "should use the membership method to look up on the @resource" do
+        @property.expects(:membership).returns(:membership)
+        @resource.expects(:[]).with(:membership)
+        @property.inclusive?
+      end
+
+      it "should return true when @resource[membership] == inclusive" do
+        @property.stubs(:membership).returns(:membership)
+        @resource.stubs(:[]).with(:membership).returns(:inclusive)
+        @property.inclusive?.must == 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
+      end
+    end
+
+    describe "when calling should" do
+      it "should return nil if @should is nil" do
+        @property.should.must == 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"
+      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"
+      end
+    end
+
+    describe "when calling retrieve" do
+      before do
+        @provider = mock("provider")
+        @property.stubs(:provider).returns(@provider)
+      end
+
+      it "should send 'name' to the provider" do
+        @provider.expects(:send).with(:group)
+        @property.expects(:name).returns(:group)
+        @property.retrieve
+      end
+
+      it "should return an array with the provider returned info" do
+        @provider.stubs(:send).with(:group).returns("foo,bar,baz")
+        @property.stubs(:name).returns(:group)
+        @property.retrieve == ["foo", "bar", "baz"]
+      end
+
+      it "should return :absent when the provider returns :absent" do
+        @provider.stubs(:send).with(:group).returns(:absent)
+        @property.stubs(:name).returns(:group)
+        @property.retrieve == :absent
+      end
+    end
+
+    describe "when calling insync?" do
+      it "should return true unless @should is defined and not nil" do
+        @property.must be_insync("foo")
+      end
+
+      it "should return true unless the passed in values is not nil" do
+        @property.should = "foo"
+        @property.must be_insync(nil)
+      end
+
+      it "should call prepare_is_for_comparison with value passed in and should" do
+        @property.should = "foo"
+        @property.expects(:prepare_is_for_comparison).with("bar")
+        @property.expects(:should)
+        @property.insync?("bar")
+      end
+
+      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_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_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_insync(["bar","foo"])
+      end
+    end
+
+    describe "when calling dearrayify" do
+      it "should sort and join the array with 'delimiter'" do
+        array = mock "array"
+        array.expects(:sort).returns(array)
+        array.expects(:join).with(@property.delimiter)
+        @property.dearrayify(array)
+      end
+    end
+  end
+end

data/spec/unit/property/ordered_list_spec.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/property/ordered_list'
+
+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
+  end
+
+  describe "as an instance" do
+    before do
+      # Wow that's a messy interface to the resource.
+      ordered_list_class.initvars
+      @resource = stub 'resource', :[]= => nil, :property => nil
+      @property = ordered_list_class.new(:resource => @resource)
+    end
+
+    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"]
+      end
+
+      it "should return 'should' if current is not a array" do
+        @property.add_should_with_current(["should"], :absent).should == ["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"]
+      end
+    end
+
+    describe "when calling should" do
+      it "should return nil if @should is nil" do
+        @property.should.must == 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"
+      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"
+      end
+    end
+
+    describe "when calling dearrayify" do
+      it "should join the array with the delimiter" do
+        array = mock "array"
+        array.expects(:join).with(@property.delimiter)
+        @property.dearrayify(array)
+      end
+    end
+  end
+end

data/spec/unit/property_spec.rb

@@ -0,0 +1,410 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'puppet/property'
+
+describe Puppet::Property do
+  before do
+    @class = Class.new(Puppet::Property) do
+      @name = :foo
+    end
+    @class.initvars
+    @provider = mock 'provider'
+    @resource = stub 'resource', :provider => @provider
+    @resource.stub_everything
+    @property = @class.new :resource => @resource
+  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 look up the modified name for a given value" do
+    @class.newvalue(:foo)
+    @class.value_name("foo").should == :foo
+  end
+
+  it "should be able to look up the modified name for a given value matching a regex" do
+    @class.newvalue(%r{.})
+    @class.value_name("foo").should == %r{.}
+  end
+
+  it "should be able to look up a given value option" do
+    @class.newvalue(:foo, :event => :whatever)
+    @class.value_option(:foo, :event).should == :whatever
+  end
+
+  it "should be able to specify required features" do
+    @class.should 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
+      @class.required_features = in_value
+      @class.required_features.should == out_value
+    end
+  }
+
+  it "should be able to shadow metaparameters" do
+    @property.must respond_to(:shadow)
+  end
+
+  describe "when returning the default event name" do
+    before do
+      @resource = stub 'resource'
+      @instance = @class.new(:resource => @resource)
+      @instance.stubs(:should).returns "myval"
+    end
+
+    it "should use the current 'should' value to pick the event name" do
+      @instance.expects(:should).returns "myvalue"
+      @class.expects(:value_option).with('myvalue', :event).returns :event_name
+
+      @instance.event_name
+    end
+
+    it "should return any event defined with the specified value" do
+      @instance.expects(:should).returns :myval
+      @class.expects(:value_option).with(:myval, :event).returns :event_name
+
+      @instance.event_name.should == :event_name
+    end
+
+    describe "and the property is 'ensure'" do
+      before do
+        @instance.stubs(:name).returns :ensure
+        @resource.expects(:type).returns :mytype
+      end
+
+      it "should use <type>_created if the 'should' value is 'present'" do
+        @instance.expects(:should).returns :present
+        @instance.event_name.should == :mytype_created
+      end
+
+      it "should use <type>_removed if the 'should' value is 'absent'" do
+        @instance.expects(:should).returns :absent
+        @instance.event_name.should == :mytype_removed
+      end
+
+      it "should use <type>_changed if the 'should' value is not 'absent' or 'present'" do
+        @instance.expects(:should).returns :foo
+        @instance.event_name.should == :mytype_changed
+      end
+
+      it "should use <type>_changed if the 'should value is nil" do
+        @instance.expects(:should).returns nil
+        @instance.event_name.should == :mytype_changed
+      end
+    end
+
+    it "should use <property>_changed if the property is not 'ensure'" do
+      @instance.stubs(:name).returns :myparam
+      @instance.expects(:should).returns :foo
+      @instance.event_name.should == :myparam_changed
+    end
+
+    it "should use <property>_changed if no 'should' value is set" do
+      @instance.stubs(:name).returns :myparam
+      @instance.expects(:should).returns nil
+      @instance.event_name.should == :myparam_changed
+    end
+  end
+
+  describe "when creating an event" do
+    before do
+      @event = Puppet::Transaction::Event.new
+
+      # Use a real resource so we can test the event creation integration
+      @resource = Puppet::Type.type(:mount).new :name => "foo"
+      @instance = @class.new(:resource => @resource)
+      @instance.stubs(:should).returns "myval"
+    end
+
+    it "should use an event from the resource as the base event" do
+      event = Puppet::Transaction::Event.new
+      @resource.expects(:event).returns event
+
+      @instance.event.should equal(event)
+    end
+
+    it "should have the default event name" do
+      @instance.expects(:event_name).returns :my_event
+      @instance.event.name.should == :my_event
+    end
+
+    it "should have the property's name" do
+      @instance.event.property.should == @instance.name.to_s
+    end
+
+    it "should have the 'should' value set" do
+      @instance.stubs(:should).returns "foo"
+      @instance.event.desired_value.should == "foo"
+    end
+
+    it "should provide its path as the source description" do
+      @instance.stubs(:path).returns "/my/param"
+      @instance.event.source_description.should == "/my/param"
+    end
+  end
+
+  describe "when shadowing metaparameters" do
+    before do
+      @shadow_class = Class.new(Puppet::Property) do
+        @name = :alias
+      end
+      @shadow_class.initvars
+    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")
+    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
+      @class.newvalue(:foo) { }
+      @property.must 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"
+    end
+
+    it "should validate each value separately" do
+      @property.expects(:validate).with("one")
+      @property.expects(:validate).with("two")
+
+      @property.value = %w{one two}
+    end
+
+    it "should munge each value separately and use any result as the actual value" do
+      @property.expects(:munge).with("one").returns :one
+      @property.expects(:munge).with("two").returns :two
+
+      # Do this so we get the whole array back.
+      @class.array_matching = :all
+
+      @property.value = %w{one two}
+      @property.should.must == [:one, :two]
+    end
+
+    it "should return any set value" do
+      (@property.value = :one).should == :one
+    end
+  end
+
+  describe "when returning the value" do
+    it "should return nil if no value is set" do
+      @property.should.must be_nil
+    end
+
+    it "should return the first set 'should' value if :array_matching is set to :first" do
+      @class.array_matching = :first
+      @property.should = %w{one two}
+      @property.should.must == "one"
+    end
+
+    it "should return all set 'should' values as an array if :array_matching is set to :all" do
+      @class.array_matching = :all
+      @property.should = %w{one two}
+      @property.should.must == %w{one two}
+    end
+
+    it "should default to :first array_matching" do
+      @class.array_matching.should == :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
+      @class.array_matching = :first
+      @property.should = %w{one two}
+
+      @property.should.must == :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
+      @class.array_matching = :all
+      @property.should = %w{one two}
+
+      @property.should.must == [: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
+    end
+
+    it "should fail if the value is not a defined value or alias and does not match a regex" do
+      @class.newvalue(:foo)
+
+      lambda { @property.should = "bar" }.should raise_error
+    end
+
+    it "should succeeed if the value is one of the defined values" do
+      @class.newvalue(:foo)
+
+      lambda { @property.should = :foo }.should_not 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
+      @class.newvalue(:foo)
+
+      lambda { @property.should = "foo" }.should_not 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
+      @class.newvalue("foo")
+
+      lambda { @property.should = :foo }.should_not raise_error
+    end
+
+    it "should succeed if the value is one of the defined aliases" do
+      @class.newvalue("foo")
+      @class.aliasvalue("bar", "foo")
+
+      lambda { @property.should = :bar }.should_not raise_error
+    end
+
+    it "should succeed if the value matches one of the regexes" do
+      @class.newvalue(/./)
+
+      lambda { @property.should = "bar" }.should_not raise_error
+    end
+
+    it "should validate that all required features are present" do
+      @class.newvalue(:foo, :required_features => [:a, :b])
+
+      @provider.expects(:satisfies?).with([:a, :b]).returns true
+
+      @property.should = :foo
+    end
+
+    it "should fail if required features are missing" do
+      @class.newvalue(:foo, :required_features => [:a, :b])
+
+      @provider.expects(:satisfies?).with([:a, :b]).returns false
+
+      lambda { @property.should = :foo }.should raise_error(Puppet::Error)
+    end
+
+    it "should internally raise an ArgumentError if required features are missing" do
+      @class.newvalue(:foo, :required_features => [:a, :b])
+
+      @provider.expects(:satisfies?).with([:a, :b]).returns false
+
+      lambda { @property.validate_features_per_value :foo }.should raise_error(ArgumentError)
+    end
+
+    it "should validate that all required features are present for regexes" do
+      value = @class.newvalue(/./, :required_features => [:a, :b])
+
+      @provider.expects(:satisfies?).with([:a, :b]).returns true
+
+      @property.should = "foo"
+    end
+
+    it "should support specifying an individual required feature" do
+      value = @class.newvalue(/./, :required_features => :a)
+
+      @provider.expects(:satisfies?).returns true
+
+      @property.should = "foo"
+    end
+  end
+
+  describe "when munging values" do
+    it "should do nothing if no values or regexes have been defined" do
+      @property.munge("foo").should == "foo"
+    end
+
+    it "should return return any matching defined values" do
+      @class.newvalue(:foo)
+      @property.munge("foo").should == :foo
+    end
+
+    it "should return any matching aliases" do
+      @class.newvalue(:foo)
+      @class.aliasvalue(:bar, :foo)
+      @property.munge("bar").should == :foo
+    end
+
+    it "should return the value if it matches a regex" do
+      @class.newvalue(/./)
+      @property.munge("bar").should == "bar"
+    end
+
+    it "should return the value if no other option is matched" do
+      @class.newvalue(:foo)
+      @property.munge("bar").should == "bar"
+    end
+  end
+
+  describe "when syncing the 'should' value" do
+    it "should set the value" do
+      @class.newvalue(:foo)
+      @property.should = :foo
+      @property.expects(:set).with(:foo)
+      @property.sync
+    end
+  end
+
+  describe "when setting a value" do
+    it "should catch exceptions and raise Puppet::Error" do
+      @class.newvalue(:foo) { raise "eh" }
+      lambda { @property.set(:foo) }.should raise_error(Puppet::Error)
+    end
+
+    describe "that was defined without a block" do
+      it "should call the settor on the provider" do
+        @class.newvalue(:bar)
+        @provider.expects(:foo=).with :bar
+        @property.set(: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
+        @class.newvalue(:bar) {}
+        @property.expects(:set_bar)
+        @property.set(:bar)
+      end
+
+      it "should call the provided block if the value is a regex" do
+        @class.newvalue(/./) { self.test }
+        @property.expects(: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
+      @property.change_to_s(:absent, "foo").should =~ /^defined/
+    end
+
+    it "should say 'undefined' when the new value is 'absent'" do
+      @property.change_to_s("foo", :absent).should =~ /^undefined/
+    end
+
+    it "should say 'changed' when neither value is 'absent'" do
+      @property.change_to_s("foo", "bar").should =~ /changed/
+    end
+  end
+end