puppet 0.24.6 → 0.24.7

data/spec/unit/node/environment.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/node/environment'
+
+describe Puppet::Node::Environment do
+    it "should use the default environment if no name is provided while initializing an environment" do
+        Puppet.settings.expects(:value).with(:environment).returns("one")
+        Puppet::Node::Environment.new().name.should == :one
+    end
+
+    it "should treat environment instances as singletons" do
+        Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one"))
+    end
+
+    it "should treat an environment specified as names or strings as equivalent" do
+        Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one"))
+    end
+end
+
+describe Puppet::Node::Environment, " when modeling a specific environment" do
+    it "should have a method for returning the environment name" do
+        Puppet::Node::Environment.new("testing").name.should == :testing
+    end
+
+    it "should provide an array-like accessor method for returning any environment-specific setting" do
+        env = Puppet::Node::Environment.new("testing")
+        env.should respond_to(:[])
+    end
+
+    it "should ask the Puppet settings instance for the setting qualified with the environment name" do
+        Puppet.settings.expects(:value).with("myvar", :testing).returns("myval")
+        env = Puppet::Node::Environment.new("testing")
+        env["myvar"].should == "myval"
+    end
+end

data/spec/unit/node/facts.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/node/facts'
+
+describe Puppet::Node::Facts, " when indirecting" do
+    before do
+        @indirection = stub 'indirection', :request => mock('request'), :name => :facts
+
+        # We have to clear the cache so that the facts ask for our indirection stub,
+        # instead of anything that might be cached.
+        Puppet::Indirector::Indirection.clear_cache
+        @facts = Puppet::Node::Facts.new("me", "one" => "two")
+    end
+
+    it "should redirect to the specified fact store for retrieval" do
+        Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
+        @indirection.expects(:find)
+        Puppet::Node::Facts.find(:my_facts)
+    end
+
+    it "should redirect to the specified fact store for storage" do
+        Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
+        @indirection.expects(:save)
+        @facts.save
+    end
+
+    it "should default to the 'facter' terminus" do
+        Puppet::Node::Facts.indirection.terminus_class.should == :facter
+    end
+
+    after do
+        mocha_verify
+        Puppet::Indirector::Indirection.clear_cache
+    end
+end
+
+describe Puppet::Node::Facts, " when storing and retrieving" do
+    it "should add metadata to the facts" do
+        facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four")
+        facts.values[:_timestamp].should be_instance_of(Time)
+    end
+end

data/spec/unit/other/checksum.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/checksum'
+
+describe Puppet::Checksum do
+    it "should have 'Checksum' and the checksum algorithm when converted to a string" do
+        inst = Puppet::Checksum.new("whatever", "md5")
+        inst.to_s.should == "Checksum<{md5}#{inst.checksum}>"
+    end
+
+    it "should convert algorithm names to symbols when they are set after checksum creation" do
+        sum = Puppet::Checksum.new("whatever")
+        sum.algorithm = "md5"
+        sum.algorithm.should == :md5
+    end
+
+    it "should return the checksum as the name" do
+        sum = Puppet::Checksum.new("whatever")
+        sum.checksum.should == sum.name
+    end
+end
+
+describe Puppet::Checksum, " when initializing" do
+    before do
+        @content = "this is some content"
+        @sum = Puppet::Checksum.new(@content)
+    end
+
+    it "should require content" do
+        proc { Puppet::Checksum.new(nil) }.should raise_error(ArgumentError)
+    end
+
+    it "should set the content appropriately" do
+        @sum.content.should == @content
+    end
+
+    it "should calculate the checksum" do
+        require 'digest/md5'
+        Digest::MD5.expects(:hexdigest).with(@content).returns(:mychecksum)
+        @sum.checksum.should == :mychecksum
+    end
+
+    it "should not calculate the checksum until it is asked for" do
+        require 'digest/md5'
+        Digest::MD5.expects(:hexdigest).never
+        sum = Puppet::Checksum.new(@content, :md5)
+    end
+
+    it "should remove the old checksum value if the algorithm is changed" do
+        Digest::MD5.expects(:hexdigest).with(@content).returns(:oldsum)
+        oldsum = @sum.checksum
+        @sum.algorithm = :sha1
+        Digest::SHA1.expects(:hexdigest).with(@content).returns(:newsum)
+        @sum.checksum.should == :newsum
+    end
+
+    it "should default to 'md5' as the checksum algorithm if the algorithm is not in the name" do
+        @sum.algorithm.should == :md5
+    end
+
+    it "should support specifying the algorithm during initialization" do
+        sum = Puppet::Checksum.new(@content, :sha1)
+        sum.algorithm.should == :sha1
+    end
+
+    it "should fail when an unsupported algorithm is used" do
+        proc { Puppet::Checksum.new(@content, :nope) }.should raise_error(ArgumentError)
+    end
+end
+
+describe Puppet::Checksum, " when using back-ends" do
+    it "should redirect using Puppet::Indirector" do
+        Puppet::Indirector::Indirection.instance(:checksum).model.should equal(Puppet::Checksum)
+    end
+
+    it "should have a :save instance method" do
+        Puppet::Checksum.new("mysum").should respond_to(:save)
+    end
+
+    it "should respond to :find" do
+        Puppet::Checksum.should respond_to(:find)
+    end
+
+    it "should respond to :destroy" do
+        Puppet::Checksum.should respond_to(:destroy)
+    end
+end

data/spec/unit/other/pgraph.rb

@@ -0,0 +1,210 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-12.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/pgraph'
+require 'puppet/util/graph'
+
+class Container
+    include Puppet::Util::Graph
+    include Enumerable
+    attr_accessor :name
+    def each
+        @children.each do |c| yield c end
+    end
+    
+    def initialize(name, ary)
+        @name = name
+        @children = ary
+    end
+    
+    def push(*ary)
+        ary.each { |c| @children.push(c)}
+    end
+    
+    def to_s
+        @name
+    end
+end
+
+describe Puppet::PGraph do
+    before do
+        @graph = Puppet::PGraph.new
+    end
+
+    it "should correctly clear vertices and edges when asked" do
+	    @graph.add_edge("a", "b")
+	    @graph.add_vertex "c"
+        @graph.clear
+        @graph.vertices.should be_empty
+        @graph.edges.should be_empty
+    end
+end
+
+describe Puppet::PGraph, " when matching edges" do
+    before do
+        @graph = Puppet::PGraph.new
+	    @event = Puppet::Transaction::Event.new(:yay, "a")
+	    @none = Puppet::Transaction::Event.new(:NONE, "a")
+
+	    @edges = {}
+	    @edges["a/b"] = Puppet::Relationship.new("a", "b", {:event => :yay, :callback => :refresh})
+	    @edges["a/c"] = Puppet::Relationship.new("a", "c", {:event => :yay, :callback => :refresh})
+	    @graph.add_edge(@edges["a/b"])
+    end
+
+    it "should match edges whose source matches the source of the event" do
+	    @graph.matching_edges([@event]).should == [@edges["a/b"]]
+    end
+
+    it "should match always match nothing when the event is :NONE" do
+	    @graph.matching_edges([@none]).should be_empty
+    end
+
+    it "should match multiple edges" do
+	    @graph.add_edge(@edges["a/c"])
+        edges = @graph.matching_edges([@event])
+        edges.should be_include(@edges["a/b"])
+        edges.should be_include(@edges["a/c"])
+    end
+end
+
+describe Puppet::PGraph, " when determining dependencies" do
+    before do
+        @graph = Puppet::PGraph.new
+        
+        @graph.add_edge("a", "b")
+        @graph.add_edge("a", "c")
+        @graph.add_edge("b", "d")
+    end
+
+    it "should find all dependents when they are on multiple levels" do
+        @graph.dependents("a").sort.should == %w{b c d}.sort
+    end
+
+    it "should find single dependents" do
+        @graph.dependents("b").sort.should == %w{d}.sort
+    end
+
+    it "should return an empty array when there are no dependents" do
+        @graph.dependents("c").sort.should == [].sort
+    end
+
+    it "should find all dependencies when they are on multiple levels" do
+        @graph.dependencies("d").sort.should == %w{a b}
+    end
+
+    it "should find single dependencies" do
+        @graph.dependencies("c").sort.should == %w{a}
+    end
+    
+    it "should return an empty array when there are no dependencies" do
+        @graph.dependencies("a").sort.should == []
+    end
+end
+
+describe Puppet::PGraph, " when splicing the relationship graph" do
+    def container_graph
+        @one = Container.new("one", %w{a b})
+        @two = Container.new("two", ["c", "d"])
+        @three = Container.new("three", ["i", "j"])
+        @middle = Container.new("middle", ["e", "f", @two])
+        @top = Container.new("top", ["g", "h", @middle, @one, @three])
+        @empty = Container.new("empty", [])
+
+        @contgraph = @top.to_graph
+
+        # We have to add the container to the main graph, else it won't
+        # be spliced in the dependency graph.
+        @contgraph.add_vertex(@empty)
+    end
+
+    def dependency_graph
+        @depgraph = Puppet::PGraph.new
+        @contgraph.vertices.each do |v|
+            @depgraph.add_vertex(v)
+        end
+
+        # We have to specify a relationship to our empty container, else it
+        # never makes it into the dep graph in the first place.
+        {@one => @two, "f" => "c", "h" => @middle, "c" => @empty}.each do |source, target|
+            @depgraph.add_edge(source, target, :callback => :refresh)
+        end
+    end
+
+    def splice
+        @depgraph.splice!(@contgraph, Container)
+    end
+
+    before do
+        container_graph
+        dependency_graph
+        splice
+    end
+
+    # This is the real heart of splicing -- replacing all containers in
+    # our relationship and exploding their relationships so that each
+    # relationship to a container gets copied to all of its children.
+    it "should remove all Container objects from the dependency graph" do
+        @depgraph.vertices.find_all { |v| v.is_a?(Container) }.should be_empty
+    end
+
+    it "should add container relationships to contained objects" do
+        @contgraph.leaves(@middle).each do |leaf|
+            @depgraph.should be_edge("h", leaf)
+        end
+    end
+
+    it "should explode container-to-container relationships, making edges between all respective contained objects" do
+        @one.each do |oobj|
+            @two.each do |tobj|
+                @depgraph.should be_edge(oobj, tobj)
+            end
+        end
+    end
+
+    it "should no longer contain anything but the non-container objects" do
+        @depgraph.vertices.find_all { |v| ! v.is_a?(String) }.should be_empty
+    end
+
+    it "should copy labels" do
+        @depgraph.edges.each do |edge|
+            edge.label.should == {:callback => :refresh}
+        end
+    end
+
+    it "should not add labels to edges that have none" do
+        @depgraph.add_edge(@two, @three)
+        splice
+        @depgraph.edge_label("c", "i").should == {}
+    end
+
+    it "should copy labels over edges that have none" do
+        @depgraph.add_edge("c", @three, {:callback => :refresh})
+        splice
+        # And make sure the label got copied.
+        @depgraph.edge_label("c", "i").should == {:callback => :refresh}
+    end
+
+    it "should not replace a label with a nil label" do
+        # Lastly, add some new label-less edges and make sure the label stays.
+        @depgraph.add_edge(@middle, @three)
+        @depgraph.add_edge("c", @three, {:callback => :refresh})
+        splice
+        @depgraph.edge_label("c", "i").should == {:callback => :refresh}
+    end
+
+    it "should copy labels to all created edges" do
+        @depgraph.add_edge(@middle, @three)
+        @depgraph.add_edge("c", @three, {:callback => :refresh})
+        splice
+        @three.each do |child|
+            edge = Puppet::Relationship.new("c", child)
+            @depgraph.should be_edge(edge.source, edge.target)
+            @depgraph.edge_label(edge.source, edge.target).should == {:callback => :refresh}
+        end
+    end
+end

data/spec/unit/other/transaction.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transaction'
+
+describe Puppet::Transaction, " when determining tags" do
+    before do
+        @config = Puppet::Node::Catalog.new
+        @transaction = Puppet::Transaction.new(@config)
+    end
+
+    it "should default to the tags specified in the :tags setting" do
+        Puppet.expects(:[]).with(:tags).returns("one")
+        @transaction.tags.should == %w{one}
+    end
+
+    it "should split tags based on ','" do
+        Puppet.expects(:[]).with(:tags).returns("one,two")
+        @transaction.tags.should == %w{one two}
+    end
+
+    it "should use any tags set after creation" do
+        Puppet.expects(:[]).with(:tags).never
+        @transaction.tags = %w{one two}
+        @transaction.tags.should == %w{one two}
+    end
+
+    it "should always convert assigned tags to an array" do
+        @transaction.tags = "one::two"
+        @transaction.tags.should == %w{one::two}
+    end
+end

data/spec/unit/other/transbucket.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::TransBucket do
+    before do
+        @bucket = Puppet::TransBucket.new
+    end
+
+    it "should be able to produce a RAL component" do
+        @bucket.name = "luke"
+        @bucket.type = "user"
+
+        resource = nil
+        proc { resource = @bucket.to_type }.should_not raise_error
+        resource.should be_instance_of(Puppet::Type::Component)
+        resource.title.should == "User[luke]"
+    end
+
+    it "should accept TransObjects into its children list" do
+        object = Puppet::TransObject.new("luke", "user")
+        proc { @bucket.push(object) }.should_not raise_error
+        @bucket.each do |o|
+            o.should equal(object)
+        end
+    end
+
+    it "should accept TransBuckets into its children list" do
+        object = Puppet::TransBucket.new()
+        proc { @bucket.push(object) }.should_not raise_error
+        @bucket.each do |o|
+            o.should equal(object)
+        end
+    end
+
+    it "should refuse to accept any children that are not TransObjects or TransBuckets" do
+        proc { @bucket.push "a test" }.should raise_error
+    end
+
+    it "should return use 'node' as the type and the provided name as the title if only a type is provided" do
+        @bucket.type = "mystuff"
+        @bucket.to_ref.should == "Node[mystuff]"
+    end
+
+    it "should return use 'component' as the type and the provided type as the title if only a name is provided" do
+        @bucket.name = "mystuff"
+        @bucket.to_ref.should == "Class[mystuff]"
+    end
+
+    it "should return nil as its reference when type and name are missing" do
+        @bucket.to_ref.should be_nil
+    end
+
+    it "should return the title as its reference" do
+        @bucket.name = "luke"
+        @bucket.type = "user"
+        @bucket.to_ref.should == "User[luke]"
+    end
+
+    it "should canonize resource references when the type is 'component'" do
+        @bucket.name = 'something'
+        @bucket.type = 'foo::bar'
+
+        @bucket.to_ref.should == "Foo::Bar[something]"
+    end
+end
+
+describe Puppet::TransBucket, " when generating a catalog" do
+    before do
+        @bottom = Puppet::TransBucket.new
+        @bottom.type = "fake"
+        @bottom.name = "bottom"
+        @bottomobj = Puppet::TransObject.new("bottom", "user")
+        @bottom.push @bottomobj
+
+        @middle = Puppet::TransBucket.new
+        @middle.type = "fake"
+        @middle.name = "middle"
+        @middleobj = Puppet::TransObject.new("middle", "user")
+        @middle.push(@middleobj)
+        @middle.push(@bottom)
+
+        @top = Puppet::TransBucket.new
+        @top.type = "fake"
+        @top.name = "top"
+        @topobj = Puppet::TransObject.new("top", "user")
+        @top.push(@topobj)
+        @top.push(@middle)
+
+        @users = %w{top middle bottom}
+        @fakes = %w{Fake[bottom] Fake[middle] Fake[top]}
+    end
+
+    after do
+        Puppet::Type.allclear
+    end
+
+    it "should convert all transportable objects to RAL resources" do
+        @catalog = @top.to_catalog
+        @users.each do |name|
+            @catalog.vertices.find { |r| r.class.name == :user and r.title == name }.should be_instance_of(Puppet::Type.type(:user))
+        end
+    end
+
+    it "should fail if any transportable resources fail to convert to RAL resources" do
+        @bottomobj.expects(:to_type).raises ArgumentError
+        lambda { @bottom.to_catalog }.should raise_error(ArgumentError)
+    end
+
+    it "should convert all transportable buckets to RAL components" do
+        @catalog = @top.to_catalog
+        @fakes.each do |name|
+            @catalog.vertices.find { |r| r.class.name == :component and r.title == name }.should be_instance_of(Puppet::Type.type(:component))
+        end
+    end
+
+    it "should add all resources to the graph's resource table" do
+        @catalog = @top.to_catalog
+        @catalog.resource("fake[top]").should equal(@top)
+    end
+
+    it "should finalize all resources" do
+        @catalog = @top.to_catalog
+        @catalog.vertices.each do |vertex| vertex.should be_finalized end
+    end
+
+    it "should only call to_type on each resource once" do
+        # We just raise exceptions here because we're not interested in
+        # what happens with the result, only that the method only
+        # gets called once.
+        resource = @topobj.to_type
+        @topobj.expects(:to_type).once.returns resource
+        @top.to_catalog
+    end
+
+    it "should set each TransObject's catalog before converting to a RAL resource" do
+        @middleobj.expects(:catalog=).with { |c| c.is_a?(Puppet::Node::Catalog) }
+        @top.to_catalog
+    end
+
+    it "should set each TransBucket's catalog before converting to a RAL resource" do
+        # each bucket is seen twice in the loop, so we have to handle the case where the config
+        # is set twice
+        @bottom.expects(:catalog=).with { |c| c.is_a?(Puppet::Node::Catalog) }.at_least_once
+        @top.to_catalog
+    end
+end
+
+describe Puppet::TransBucket, " when serializing" do
+    before do
+        @bucket = Puppet::TransBucket.new(%w{one two})
+        @bucket.name = "one"
+        @bucket.type = "two"
+    end
+
+    it "should be able to be dumped to yaml" do
+        proc { YAML.dump(@bucket) }.should_not raise_error
+    end
+
+    it "should dump YAML that produces an equivalent object" do
+        result = YAML.dump(@bucket)
+
+        newobj = YAML.load(result)
+        newobj.name.should == "one"
+        newobj.type.should == "two"
+        children = []
+        newobj.each do |o|
+            children << o
+        end
+        children.should == %w{one two}
+    end
+end