puppet 0.24.6 → 0.24.7

data/spec/unit/parser/resource/reference.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::Resource::Reference do
+    before do
+        @type = Puppet::Parser::Resource::Reference
+    end
+
+    it "should require a type" do
+        proc { @type.new(:title => "yay") }.should raise_error(Puppet::DevError)
+    end
+
+    it "should require a title" do
+        proc { @type.new(:type => "file") }.should raise_error(Puppet::DevError)
+    end
+
+    it "should know when it refers to a builtin type" do
+        ref = @type.new(:type => "file", :title => "/tmp/yay")
+        ref.builtin?.should be_true
+        ref.builtintype.should equal(Puppet::Type.type(:file))
+    end
+
+    it "should return a downcased relationship-style resource reference for defined types" do
+        ref = @type.new(:type => "file", :title => "/tmp/yay")
+        ref.to_ref.should == ["file", "/tmp/yay"]
+    end
+
+    it "should return a capitalized relationship-style resource reference for defined types" do
+        ref = @type.new(:type => "whatever", :title => "/tmp/yay")
+        ref.to_ref.should == ["Whatever", "/tmp/yay"]
+    end
+
+    it "should return a resource reference string when asked" do
+        ref = @type.new(:type => "file", :title => "/tmp/yay")
+        ref.to_s.should == "File[/tmp/yay]"
+    end
+
+    it "should canonize resource references" do
+        ref = @type.new(:type => "foo::bar", :title => "/tmp/yay")
+        ref.to_s.should == "Foo::Bar[/tmp/yay]"
+    end
+end
+
+describe Puppet::Parser::Resource::Reference, " when modeling defined types" do
+    before do
+        @type = Puppet::Parser::Resource::Reference
+
+        @parser = Puppet::Parser::Parser.new :Code => ""
+        @definition = @parser.newdefine "mydefine"
+        @class = @parser.newclass "myclass"
+        @nodedef = @parser.newnode("mynode")[0]
+        @node = Puppet::Node.new("yaynode")
+
+        @compiler = Puppet::Parser::Compiler.new(@node, @parser)
+    end
+
+    it "should be able to find defined types" do
+        ref = @type.new(:type => "mydefine", :title => "/tmp/yay", :scope => @compiler.topscope)
+        ref.builtin?.should be_false
+        ref.definedtype.should equal(@definition)
+    end
+
+    it "should be able to find classes" do
+        ref = @type.new(:type => "class", :title => "myclass", :scope => @compiler.topscope)
+        ref.builtin?.should be_false
+        ref.definedtype.should equal(@class)
+    end
+
+    it "should be able to find nodes" do
+        ref = @type.new(:type => "node", :title => "mynode", :scope => @compiler.topscope)
+        ref.builtin?.should be_false
+        ref.definedtype.object_id.should  == @nodedef.object_id
+    end
+
+    it "should only look for fully qualified classes" do
+        top = @parser.newclass "top"
+        sub = @parser.newclass "other::top"
+
+        scope = @compiler.topscope.class.new(:parent => @compiler.topscope, :namespace => "other", :parser => @parser)
+
+        ref = @type.new(:type => "class", :title => "top", :scope => scope)
+        ref.definedtype.classname.should equal(top.classname)
+    end
+
+    it "should only look for fully qualified definitions" do
+        top = @parser.newdefine "top"
+        sub = @parser.newdefine "other::top"
+
+        scope = @compiler.topscope.class.new(:parent => @compiler.topscope, :namespace => "other", :parser => @parser)
+
+        ref = @type.new(:type => "top", :title => "foo", :scope => scope)
+        ref.definedtype.classname.should equal(top.classname)
+    end
+end

data/spec/unit/parser/scope.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Parser::Scope do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+        @topscope = Puppet::Parser::Scope.new()
+        @scope.stubs(:parent).returns(@topscope)
+    end
+
+    describe Puppet::Parser::Scope, "when setvar is called with append=true" do
+
+        it "should raise error if the variable is already defined in this scope" do
+            @scope.setvar("var","1",nil,nil,false)
+            lambda { @scope.setvar("var","1",nil,nil,true) }.should raise_error(Puppet::ParseError)
+        end
+
+        it "it should lookup current variable value" do
+            @scope.expects(:lookupvar).with("var").returns("2")
+            @scope.setvar("var","1",nil,nil,true)
+        end
+
+        it "it should store the concatenated string '42'" do
+            @topscope.setvar("var","4",nil,nil,false)
+            @scope.setvar("var","2",nil,nil,true)
+            @scope.lookupvar("var").should == "42"
+        end
+
+        it "it should store the concatenated array [4,2]" do
+            @topscope.setvar("var",[4],nil,nil,false)
+            @scope.setvar("var",[2],nil,nil,true)
+            @scope.lookupvar("var").should == [4,2]
+        end
+
+    end
+
+    describe Puppet::Parser::Scope, "when calling number?" do
+
+        it "should return nil if called with anything not a number" do
+            Puppet::Parser::Scope.number?([2]).should be_nil
+        end
+
+        it "should return a Fixnum for a Fixnum" do
+            Puppet::Parser::Scope.number?(2).should be_an_instance_of(Fixnum)
+        end
+
+        it "should return a Float for a Float" do
+            Puppet::Parser::Scope.number?(2.34).should be_an_instance_of(Float)
+        end
+
+        it "should return 234 for '234'" do
+            Puppet::Parser::Scope.number?("234").should == 234
+        end
+
+        it "should return nil for 'not a number'" do
+            Puppet::Parser::Scope.number?("not a number").should be_nil
+        end
+
+        it "should return 23.4 for '23.4'" do
+            Puppet::Parser::Scope.number?("23.4").should == 23.4
+        end
+
+        it "should return 23.4e13 for '23.4e13'" do
+            Puppet::Parser::Scope.number?("23.4e13").should == 23.4e13
+        end
+
+        it "should understand negative numbers" do
+            Puppet::Parser::Scope.number?("-234").should == -234
+        end
+
+        it "should know how to convert exponential float numbers ala '23e13'" do
+            Puppet::Parser::Scope.number?("23e13").should == 23e13
+        end
+
+        it "should understand hexadecimal numbers" do
+            Puppet::Parser::Scope.number?("0x234").should == 0x234
+        end
+
+        it "should understand octal numbers" do
+            Puppet::Parser::Scope.number?("0755").should == 0755
+        end
+
+
+    end
+
+end

data/spec/unit/parser/templatewrapper.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Parser::TemplateWrapper do
+    before(:each) do
+        compiler = stub('compiler', :environment => "foo")
+        parser = stub('parser', :watch_file => true)
+        @scope = stub('scope', :compiler => compiler, :parser => parser, :to_hash => {})
+        @file = "fake_template"
+        Puppet::Module.stubs(:find_template).returns("/tmp/fake_template")
+        FileTest.stubs(:exists?).returns("true")
+        File.stubs(:read).with("/tmp/fake_template").returns("template content")
+        @tw = Puppet::Parser::TemplateWrapper.new(@scope)
+    end
+
+    it "should create a new object TemplateWrapper from a scope" do
+        tw = Puppet::Parser::TemplateWrapper.new(@scope)
+
+        tw.should be_a_kind_of(Puppet::Parser::TemplateWrapper)
+    end
+
+    it "should check template file existance and read its content" do
+        Puppet::Module.expects(:find_template).with("fake_template", "foo").returns("/tmp/fake_template")
+        FileTest.expects(:exists?).with("/tmp/fake_template").returns(true)
+        File.expects(:read).with("/tmp/fake_template").returns("template content")
+
+        @tw.file = @file
+    end
+
+    it "should turn into a string like template[name] for file based template" do
+        @tw.file = @file
+        @tw.to_s.should eql("template[/tmp/fake_template]")
+    end
+
+    it "should turn into a string like template[inline] for string-based template" do
+        @tw.to_s.should eql("template[inline]")
+    end
+
+    it "should return the processed template contents with a call to result" do
+        template_mock = mock("template", :result => "woot!")
+        File.expects(:read).with("/tmp/fake_template").returns("template contents")
+        ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+
+        @tw.file = @file
+        @tw.result.should eql("woot!")
+    end
+
+    it "should return the processed template contents with a call to result and a string" do
+        template_mock = mock("template", :result => "woot!")
+        ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+
+        @tw.result("template contents").should eql("woot!")
+    end
+
+    it "should return the contents of a variable if called via method_missing" do
+        @scope.expects(:lookupvar).with("chicken", false).returns("is good")
+        tw = Puppet::Parser::TemplateWrapper.new(@scope)
+        tw.chicken.should eql("is good")
+    end
+
+    it "should throw an exception if a variable is called via method_missing and it does not exist" do
+        @scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
+        tw = Puppet::Parser::TemplateWrapper.new(@scope)
+        lambda { tw.chicken }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should allow you to check whether a variable is defined with has_variable?" do
+        @scope.expects(:lookupvar).with("chicken", false).returns("is good")
+        tw = Puppet::Parser::TemplateWrapper.new(@scope)
+        tw.has_variable?("chicken").should eql(true)
+    end
+
+    it "should allow you to check whether a variable is not defined with has_variable?" do
+        @scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
+        tw = Puppet::Parser::TemplateWrapper.new(@scope)
+        tw.has_variable?("chicken").should eql(false)
+    end
+
+    it "should allow you to retrieve the defined classes with classes" do
+        catalog = mock 'catalog', :classes => ["class1", "class2"]
+        @scope.expects(:catalog).returns( catalog )
+        tw = Puppet::Parser::TemplateWrapper.new(@scope)
+        tw.classes().should == ["class1", "class2"]
+    end
+
+    it "should allow you to retrieve all the tags with all_tags" do
+        catalog = mock 'catalog', :tags => ["tag1", "tag2"]
+        @scope.expects(:catalog).returns( catalog )
+        tw = Puppet::Parser::TemplateWrapper.new(@scope)
+        tw.all_tags().should == ["tag1","tag2"]
+    end
+
+    it "should allow you to retrieve the tags defined in the current scope" do
+        @scope.expects(:tags).returns( ["tag1", "tag2"] )
+        tw = Puppet::Parser::TemplateWrapper.new(@scope)
+        tw.tags().should == ["tag1","tag2"]
+    end
+
+    it "should set all of the scope's variables as instance variables" do
+        template_mock = mock("template", :result => "woot!")
+        ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+
+        @scope.expects(:to_hash).returns("one" => "foo")
+        @tw.result("template contents")
+
+        @tw.instance_variable_get("@one").should == "foo"
+     end
+
+     it "should not error out if one of the variables is a symbol" do
+        template_mock = mock("template", :result => "woot!")
+        ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+
+        @scope.expects(:to_hash).returns(:_timestamp => "1234")
+        @tw.result("template contents")
+     end
+
+     %w{! . ; :}.each do |badchar|
+       it "should translate #{badchar} to _ when setting the instance variables" do
+        template_mock = mock("template", :result => "woot!")
+        ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+
+        @scope.expects(:to_hash).returns("one#{badchar}" => "foo")
+        @tw.result("template contents")
+
+        @tw.instance_variable_get("@one_").should == "foo"
+      end
+     end
+end

data/spec/unit/property.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/property'
+
+describe Puppet::Property do
+    describe "when setting the value" do
+        it "should just set the 'should' value" do
+            @class = Class.new(Puppet::Property)
+            @class.initvars
+            @property = @class.new :resource => mock('resource')
+
+            @property.expects(:should=).with("foo")
+            @property.value = "foo"
+        end
+    end
+
+    describe "when returning the value" do
+        before do
+            @class = Class.new(Puppet::Property)
+            @class.initvars
+            @property = @class.new :resource => mock('resource')
+        end
+
+        it "should return nil if no value is set" do
+            @property.value.should be_nil
+        end
+
+        it "should return any set 'should' value" do
+            @property.should = "foo"
+            @property.value.should == "foo"
+        end
+    end
+end

data/spec/unit/property/keyvalue.rb

@@ -0,0 +1,168 @@
+#!/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/keyvalue'
+
+klass = Puppet::Property::KeyValue
+
+describe klass do
+
+    it "should be a subclass of Property" do
+        klass.superclass.must == Puppet::Property
+    end
+
+    describe "as an instance" do
+        before do
+            # Wow that's a messy interface to the resource.
+            klass.initvars
+            @resource = stub 'resource', :[]= => nil, :property => nil
+            @property = klass.new(:resource => @resource)
+        end
+
+        it "should have a , as default delimiter" do
+            @property.delimiter.should == ";"
+        end
+
+        it "should have a = as default separator" do
+            @property.separator.should == "="
+        end
+
+        it "should have a :membership as default membership" do
+            @property.membership.should == :key_value_membership
+        end
+
+        it "should return the same value passed into should_to_s" do
+            @property.should_to_s({:foo => "baz", :bar => "boo"}) == "foo=baz;bar=boo"
+        end
+
+        it "should return the passed in array values joined with the delimiter from is_to_s" do
+            @property.is_to_s({"foo" => "baz" , "bar" => "boo"}).should == "foo=baz;bar=boo"
+        end
+
+        describe "when calling inclusive?" do
+            it "should use the membership method to look up on the @resource" do
+                @property.expects(:membership).returns(:key_value_membership)
+                @resource.expects(:[]).with(:key_value_membership)
+                @property.inclusive?
+            end
+
+            it "should return true when @resource[membership] == inclusive" do
+                @property.stubs(:membership).returns(:key_value_membership)
+                @resource.stubs(:[]).with(:key_value_membership).returns(:inclusive)
+                @property.inclusive?.must == true
+            end
+
+            it "should return false when @resource[membership] != inclusive" do
+                @property.stubs(:membership).returns(:key_value_membership)
+                @resource.stubs(:[]).with(:key_value_membership).returns(:minimum)
+                @property.inclusive?.must == false
+            end
+        end
+
+        describe "when calling process_current_hash" do
+            it "should return {} if hash is :absent" do
+                @property.process_current_hash(:absent).must == {}
+            end
+
+            it "should set every key to nil if inclusive?" do
+                @property.stubs(:inclusive?).returns(true)
+                @property.process_current_hash({:foo => "bar", :do => "re"}).must == { :foo => nil, :do => nil }
+            end
+
+            it "should return the hash if !inclusive?" do
+                @property.stubs(:inclusive?).returns(false)
+                @property.process_current_hash({:foo => "bar", :do => "re"}).must == {:foo => "bar", :do => "re"}
+            end
+        end
+
+        describe "when calling should" do
+            it "should return nil if @should is nil" do
+                @property.should.must == nil
+            end
+
+            it "should call process_current_hash" do
+                @property.should = ["foo=baz", "bar=boo"]
+                @property.stubs(:retrieve).returns({:do => "re", :mi => "fa" })
+                @property.expects(:process_current_hash).returns({})
+                @property.should
+            end
+
+            it "should return the hashed values of @should and the nilled values of retrieve if inclusive" do
+                @property.should = ["foo=baz", "bar=boo"]
+                @property.expects(:retrieve).returns({:do => "re", :mi => "fa" })
+                @property.expects(:inclusive?).returns(true)
+                @property.should.must == { :foo => "baz", :bar => "boo", :do => nil, :mi => nil }
+            end
+
+            it "should return the hashed @should + the unique values of retrieve if !inclusive" do
+                @property.should = ["foo=baz", "bar=boo"]
+                @property.expects(:retrieve).returns({:foo => "diff", :do => "re", :mi => "fa"})
+                @property.expects(:inclusive?).returns(false)
+                @property.should.must == { :foo => "baz", :bar => "boo", :do => "re", :mi => "fa" }
+            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(:keys)
+                @property.expects(:name).returns(:keys)
+                @property.retrieve
+            end
+
+            it "should return a hash with the provider returned info" do
+                @provider.stubs(:send).with(:keys).returns({"do" => "re", "mi" => "fa" })
+                @property.stubs(:name).returns(:keys)
+                @property.retrieve == {"do" => "re", "mi" => "fa" }
+            end
+
+            it "should return :absent when the provider returns :absent" do
+                @provider.stubs(:send).with(:keys).returns(:absent)
+                @property.stubs(:name).returns(:keys)
+                @property.retrieve == :absent
+            end
+        end
+
+        describe "when calling hashify" do
+            it "should return the array hashified" do
+                @property.hashify(["foo=baz", "bar=boo"]).must == { :foo => "baz", :bar => "boo" }
+            end
+        end
+
+        describe "when calling insync?" do
+            before do
+                @provider = mock("provider")
+                @property.stubs(:provider).returns(@provider)
+                @property.stubs(:name).returns(:prop_name)
+            end
+
+            it "should return true unless @should is defined and not nil" do
+                @property.insync?("foo") == true
+            end
+
+            it "should return true if the passed in values is nil" do
+                @property.should = "foo"
+                @property.insync?(nil) == true
+            end
+
+            it "should return true if hashified should value == (retrieved) value passed in" do
+                @provider.stubs(:prop_name).returns({ :foo => "baz", :bar => "boo" })
+                @property.should = ["foo=baz", "bar=boo"]
+                @property.expects(:inclusive?).returns(true)
+                @property.insync?({ :foo => "baz", :bar => "boo" }).must == true
+            end
+
+            it "should return false if prepared value != should value" do
+                @provider.stubs(:prop_name).returns({ "foo" => "bee", "bar" => "boo" })
+                @property.should = ["foo=baz", "bar=boo"]
+                @property.expects(:inclusive?).returns(true)
+                @property.insync?({ "foo" => "bee", "bar" => "boo" }).must == false
+            end
+        end
+    end
+end