puppet 0.25.5 → 2.6.0

data/spec/unit/other/transobject_spec.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transportable'
+
+describe Puppet::TransObject do
+  it "should canonize resource references" do
+    resource = Puppet::TransObject.new("me", "foo::bar")
+    resource.ref.should == 'Foo::Bar[me]'
+  end
+
+  it "should lower-case resource types for backward compatibility with 0.23.2" do
+    resource = Puppet::TransObject.new("me", "Foo")
+    resource.type.should == 'foo'
+  end
+end
+
+describe Puppet::TransObject, " when serializing" do
+  before do
+    @resource = Puppet::TransObject.new("/my/file", "file")
+    @resource["one"] = "test"
+    @resource["two"] = "other"
+  end
+
+  it "should be able to be dumped to yaml" do
+    proc { YAML.dump(@resource) }.should_not raise_error
+  end
+
+  it "should produce an equivalent yaml object" do
+    text = YAML.dump(@resource)
+
+    newresource = YAML.load(text)
+    newresource.name.should == "/my/file"
+    newresource.type.should == "file"
+    %w{one two}.each do |param|
+      newresource[param].should == @resource[param]
+    end
+  end
+end
+
+describe Puppet::TransObject, " when converting to a Puppet::Resource" do
+  before do
+    @trans = Puppet::TransObject.new("/my/file", "file")
+    @trans["one"] = "test"
+    @trans["two"] = "other"
+  end
+
+  it "should create a resource with the correct type and title" do
+    result = @trans.to_resource
+    result.type.should == "File"
+    result.title.should == "/my/file"
+  end
+
+  it "should add all of its parameters to the created resource" do
+    @trans[:noop] = true
+    @trans.to_resource[:noop].should be_true
+  end
+
+  it "should copy over the tags" do
+    @trans.tags = %w{foo bar}
+    result = @trans.to_resource
+    result.should be_tagged("foo")
+    result.should be_tagged("bar")
+  end
+end
+
+describe Puppet::TransObject, " when converting to a RAL resource" do
+  before do
+    @resource = Puppet::TransObject.new("/my/file", "file")
+    @resource["one"] = "test"
+    @resource["two"] = "other"
+  end
+
+  it "should use a Puppet::Resource to create the resource" do
+    resource = mock 'resource'
+    @resource.expects(:to_resource).returns resource
+    resource.expects(:to_ral).returns "myral"
+    @resource.to_ral.should == "myral"
+  end
+end
+
+describe Puppet::TransObject, " when converting to a RAL component instance" do
+  before do
+    @resource = Puppet::TransObject.new("/my/file", "one::two")
+    @resource["one"] = "test"
+    @resource["noop"] = "other"
+  end
+
+  it "should use a new TransObject whose name is a resource reference of the type and title of the original TransObject" do
+    Puppet::Type::Component.expects(:new).with { |resource| resource.type == "component" and resource.name == "One::Two[/my/file]" }.returns(:yay)
+    @resource.to_component.should == :yay
+  end
+
+  it "should pass the resource parameters on to the newly created TransObject" do
+    Puppet::Type::Component.expects(:new).with { |resource| resource["noop"] == "other" }.returns(:yay)
+    @resource.to_component.should == :yay
+  end
+
+  it "should copy over the catalog" do
+    @resource.catalog = "mycat"
+    Puppet::Type::Component.expects(:new).with { |resource| resource.catalog == "mycat" }.returns(:yay)
+    @resource.to_component
+  end
+
+  # LAK:FIXME This really isn't the design we want going forward, but it's
+  # good enough for now.
+  it "should not pass resource parameters that are not metaparams" do
+    Puppet::Type::Component.expects(:new).with { |resource| resource["one"].nil? }.returns(:yay)
+    @resource.to_component.should == :yay
+  end
+end

data/spec/unit/parameter/value_collection_spec.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/parameter'
+
+describe Puppet::Parameter::ValueCollection do
+  before do
+    @collection = Puppet::Parameter::ValueCollection.new
+  end
+
+  it "should have a method for defining new values" do
+    @collection.should respond_to(:newvalues)
+  end
+
+  it "should have a method for adding individual values" do
+    @collection.should respond_to(:newvalue)
+  end
+
+  it "should be able to retrieve individual values" do
+    value = @collection.newvalue(:foo)
+    @collection.value(:foo).should equal(value)
+  end
+
+  it "should be able to add an individual value with a block" do
+    @collection.newvalue(:foo) { raise "testing" }
+    @collection.value(:foo).block.should be_instance_of(Proc)
+  end
+
+  it "should be able to add values that are empty strings" do
+    lambda { @collection.newvalue('') }.should_not raise_error
+  end
+
+  it "should be able to add values that are empty strings" do
+    value = @collection.newvalue('')
+    @collection.match?('').should equal(value)
+  end
+
+  it "should set :call to :none when adding a value with no block" do
+    value = @collection.newvalue(:foo)
+    value.call.should == :none
+  end
+
+  describe "when adding a value with a block" do
+    it "should set the method name to 'set_' plus the value name" do
+      value = @collection.newvalue(:myval) { raise "testing" }
+      value.method.should == "set_myval"
+    end
+  end
+
+  it "should be able to add an individual value with options" do
+    value = @collection.newvalue(:foo, :call => :bar)
+    value.call.should == :bar
+  end
+
+  it "should have a method for validating a value" do
+    @collection.should respond_to(:validate)
+  end
+
+  it "should have a method for munging a value" do
+    @collection.should respond_to(:munge)
+  end
+
+  it "should be able to generate documentation when it has both values and regexes" do
+    @collection.newvalues :foo, "bar", %r{test}
+    @collection.doc.should be_instance_of(String)
+  end
+
+  it "should correctly generate documentation for values" do
+    @collection.newvalues :foo
+    @collection.doc.should be_include("Valid values are ``foo``")
+  end
+
+  it "should correctly generate documentation for regexes" do
+    @collection.newvalues %r{\w+}
+    @collection.doc.should be_include("Values can match ``/\\w+/``")
+  end
+
+  it "should be able to find the first matching value" do
+    @collection.newvalues :foo, :bar
+    @collection.match?("foo").should be_instance_of(Puppet::Parameter::Value)
+  end
+
+  it "should be able to match symbols" do
+    @collection.newvalues :foo, :bar
+    @collection.match?(:foo).should be_instance_of(Puppet::Parameter::Value)
+  end
+
+  it "should be able to match symbols when a regex is provided" do
+    @collection.newvalues %r{.}
+    @collection.match?(:foo).should be_instance_of(Puppet::Parameter::Value)
+  end
+
+  it "should be able to match values using regexes" do
+    @collection.newvalues %r{.}
+    @collection.match?("foo").should_not be_nil
+  end
+
+  it "should prefer value matches to regex matches" do
+    @collection.newvalues %r{.}, :foo
+    @collection.match?("foo").name.should == :foo
+  end
+
+  describe "when validating values" do
+    it "should do nothing if no values or regexes have been defined" do
+      @collection.validate("foo")
+    end
+
+    it "should fail if the value is not a defined value or alias and does not match a regex" do
+      @collection.newvalues :foo
+      lambda { @collection.validate("bar") }.should raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value is one of the defined values" do
+      @collection.newvalues :foo
+      lambda { @collection.validate(:foo) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
+      @collection.newvalues :foo
+      lambda { @collection.validate("foo") }.should_not raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
+      @collection.newvalues "foo"
+      lambda { @collection.validate(:foo) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value is one of the defined aliases" do
+      @collection.newvalues :foo
+      @collection.aliasvalue :bar, :foo
+      lambda { @collection.validate("bar") }.should_not raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value matches one of the regexes" do
+      @collection.newvalues %r{\d}
+      lambda { @collection.validate("10") }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe "when munging values" do
+    it "should do nothing if no values or regexes have been defined" do
+      @collection.munge("foo").should == "foo"
+    end
+
+    it "should return return any matching defined values" do
+      @collection.newvalues :foo, :bar
+      @collection.munge("foo").should == :foo
+    end
+
+    it "should return any matching aliases" do
+      @collection.newvalues :foo
+      @collection.aliasvalue :bar, :foo
+      @collection.munge("bar").should == :foo
+    end
+
+    it "should return the value if it matches a regex" do
+      @collection.newvalues %r{\w}
+      @collection.munge("bar").should == "bar"
+    end
+
+    it "should return the value if no other option is matched" do
+      @collection.newvalues :foo
+      @collection.munge("bar").should == "bar"
+    end
+  end
+end

data/spec/unit/parameter/value_spec.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/parameter'
+
+describe Puppet::Parameter::Value do
+  it "should require a name" do
+    lambda { Puppet::Parameter::Value.new }.should raise_error(ArgumentError)
+  end
+
+  it "should set its name" do
+    Puppet::Parameter::Value.new(:foo).name.should == :foo
+  end
+
+  it "should support regexes as names" do
+    lambda { Puppet::Parameter::Value.new(%r{foo}) }.should_not raise_error
+  end
+
+  it "should mark itself as a regex if its name is a regex" do
+    Puppet::Parameter::Value.new(%r{foo}).should be_regex
+  end
+
+  it "should always convert its name to a symbol if it is not a regex" do
+    Puppet::Parameter::Value.new("foo").name.should == :foo
+    Puppet::Parameter::Value.new(true).name.should == :true
+  end
+
+  it "should support adding aliases" do
+    Puppet::Parameter::Value.new("foo").should respond_to(:alias)
+  end
+
+  it "should be able to return its aliases" do
+    value = Puppet::Parameter::Value.new("foo")
+    value.alias("bar")
+    value.alias("baz")
+    value.aliases.should == [:bar, :baz]
+  end
+
+  [:block, :call, :method, :event, :required_features].each do |attr|
+    it "should support a #{attr} attribute" do
+      value = Puppet::Parameter::Value.new("foo")
+      value.should respond_to(attr.to_s + "=")
+      value.should respond_to(attr)
+    end
+  end
+
+  it "should default to :instead for :call if a block is provided" do
+    Puppet::Parameter::Value.new("foo").call.should == :instead
+  end
+
+  it "should always return events as symbols" do
+    value = Puppet::Parameter::Value.new("foo")
+    value.event = "foo_test"
+    value.event.should == :foo_test
+  end
+
+  describe "when matching" do
+    describe "a regex" do
+      it "should return true if the regex matches the value" do
+        Puppet::Parameter::Value.new(/\w/).should be_match("foo")
+      end
+
+      it "should return false if the regex does not match the value" do
+        Puppet::Parameter::Value.new(/\d/).should_not be_match("foo")
+      end
+    end
+
+    describe "a non-regex" do
+      it "should return true if the value, converted to a symbol, matches the name" do
+        Puppet::Parameter::Value.new("foo").should be_match("foo")
+        Puppet::Parameter::Value.new(:foo).should be_match(:foo)
+        Puppet::Parameter::Value.new(:foo).should be_match("foo")
+        Puppet::Parameter::Value.new("foo").should be_match(:foo)
+      end
+
+      it "should return false if the value, converted to a symbol, does not match the name" do
+        Puppet::Parameter::Value.new(:foo).should_not be_match(:bar)
+      end
+
+      it "should return true if any of its aliases match" do
+        value = Puppet::Parameter::Value.new("foo")
+        value.alias("bar")
+        value.should be_match("bar")
+      end
+    end
+  end
+end

data/spec/unit/parameter_spec.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/parameter'
+
+describe Puppet::Parameter do
+  before do
+    @class = Class.new(Puppet::Parameter) do
+      @name = :foo
+    end
+    @class.initvars
+    @resource = mock 'resource'
+    @resource.stub_everything
+    @parameter = @class.new :resource => @resource
+  end
+
+  it "should create a value collection" do
+    @class = Class.new(Puppet::Parameter)
+    @class.value_collection.should be_nil
+    @class.initvars
+    @class.value_collection.should be_instance_of(Puppet::Parameter::ValueCollection)
+  end
+
+  it "should return its name as a string when converted to a string" do
+    @parameter.to_s.should == @parameter.name.to_s
+  end
+
+  it "should be able to use cached attributes" do
+    Puppet::Parameter.ancestors.should be_include(Puppet::Util::Cacher)
+  end
+
+  it "should use the resource catalog for expiration" do
+    catalog = mock 'catalog'
+    @resource.stubs(:catalog).returns catalog
+    @parameter.expirer.should equal(catalog)
+  end
+
+  [:line, :file, :version].each do |data|
+    it "should return its resource's #{data} as its #{data}" do
+      @resource.expects(data).returns "foo"
+      @parameter.send(data).should == "foo"
+    end
+  end
+
+  it "should return the resource's tags plus its name as its tags" do
+    @resource.expects(:tags).returns %w{one two}
+    @parameter.tags.should == %w{one two foo}
+  end
+
+  it "should provide source_descriptors" do
+    @resource.expects(:line).returns 10
+    @resource.expects(:file).returns "file"
+    @resource.expects(:tags).returns %w{one two}
+    @resource.expects(:version).returns 50
+    @parameter.source_descriptors.should == {:tags=>["one", "two", "foo"], :path=>"//foo", :version=>50, :file => "file", :line => 10}
+  end
+
+  describe "when returning the value" do
+    it "should return nil if no value is set" do
+      @parameter.value.should be_nil
+    end
+
+    it "should validate the value" do
+      @parameter.expects(:validate).with("foo")
+      @parameter.value = "foo"
+    end
+
+    it "should munge the value and use any result as the actual value" do
+      @parameter.expects(:munge).with("foo").returns "bar"
+      @parameter.value = "foo"
+      @parameter.value.should == "bar"
+    end
+
+    it "should unmunge the value when accessing the actual value" do
+      @parameter.class.unmunge do |value| value.to_sym end
+      @parameter.value = "foo"
+      @parameter.value.should == :foo
+    end
+
+    it "should return the actual value by default when unmunging" do
+      @parameter.unmunge("bar").should == "bar"
+    end
+
+    it "should return any set value" do
+      @parameter.value = "foo"
+      @parameter.value.should == "foo"
+    end
+  end
+
+  describe "when validating values" do
+    it "should do nothing if no values or regexes have been defined" do
+      @parameter.validate("foo")
+    end
+
+    it "should catch abnormal failures thrown during validation" do
+      @class.validate { |v| raise "This is broken" }
+      lambda { @parameter.validate("eh") }.should raise_error(Puppet::DevError)
+    end
+
+    it "should fail if the value is not a defined value or alias and does not match a regex" do
+      @class.newvalues :foo
+      lambda { @parameter.validate("bar") }.should raise_error(Puppet::Error)
+    end
+
+    it "should succeed if the value is one of the defined values" do
+      @class.newvalues :foo
+      lambda { @parameter.validate(:foo) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
+      @class.newvalues :foo
+      lambda { @parameter.validate("foo") }.should_not raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
+      @class.newvalues "foo"
+      lambda { @parameter.validate(:foo) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value is one of the defined aliases" do
+      @class.newvalues :foo
+      @class.aliasvalue :bar, :foo
+      lambda { @parameter.validate("bar") }.should_not raise_error(ArgumentError)
+    end
+
+    it "should succeed if the value matches one of the regexes" do
+      @class.newvalues %r{\d}
+      lambda { @parameter.validate("10") }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe "when munging values" do
+    it "should do nothing if no values or regexes have been defined" do
+      @parameter.munge("foo").should == "foo"
+    end
+
+    it "should catch abnormal failures thrown during munging" do
+      @class.munge { |v| raise "This is broken" }
+      lambda { @parameter.munge("eh") }.should raise_error(Puppet::DevError)
+    end
+
+    it "should return return any matching defined values" do
+      @class.newvalues :foo, :bar
+      @parameter.munge("foo").should == :foo
+    end
+
+    it "should return any matching aliases" do
+      @class.newvalues :foo
+      @class.aliasvalue :bar, :foo
+      @parameter.munge("bar").should == :foo
+    end
+
+    it "should return the value if it matches a regex" do
+      @class.newvalues %r{\w}
+      @parameter.munge("bar").should == "bar"
+    end
+
+    it "should return the value if no other option is matched" do
+      @class.newvalues :foo
+      @parameter.munge("bar").should == "bar"
+    end
+  end
+
+  describe "when logging" do
+    it "should use its resource's log level and the provided message" do
+      @resource.expects(:[]).with(:loglevel).returns :notice
+      @parameter.expects(:send_log).with(:notice, "mymessage")
+      @parameter.log "mymessage"
+    end
+  end
+end