puppet 0.24.6 → 0.24.7

data/spec/unit/reports.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/reports'
+
+describe Puppet::Reports do
+    it "should instance-load report types" do
+        Puppet::Reports.instance_loader(:report).should be_instance_of(Puppet::Util::Autoload)
+    end
+
+    it "should have a method for registering report types" do
+        Puppet::Reports.should respond_to(:register_report)
+    end
+
+    it "should have a method for retrieving report types by name" do
+        Puppet::Reports.should respond_to(:report)
+    end
+
+    it "should provide a method for returning documentation for all reports" do
+        Puppet::Reports.expects(:loaded_instances).with(:report).returns([:one, :two])
+        one = mock 'one', :doc => "onedoc"
+        two = mock 'two', :doc => "twodoc"
+        Puppet::Reports.expects(:report).with(:one).returns(one)
+        Puppet::Reports.expects(:report).with(:two).returns(two)
+
+        doc = Puppet::Reports.reportdocs
+        doc.include?("onedoc").should be_true
+        doc.include?("twodoc").should be_true
+    end
+end
+
+
+describe Puppet::Reports, " when loading report types" do
+    it "should use the instance loader to retrieve report types" do
+        Puppet::Reports.expects(:loaded_instance).with(:report, :myreporttype)
+        Puppet::Reports.report(:myreporttype)
+    end
+end
+
+describe Puppet::Reports, " when registering report types" do
+    it "should evaluate the supplied block as code for a module" do
+        Puppet::Reports.expects(:genmodule).returns(Module.new)
+        Puppet::Reports.register_report(:testing) { }
+    end
+
+    it "should extend the report type with the Puppet::Util::Docs module" do
+        mod = stub 'module', :define_method => true
+
+        Puppet::Reports.expects(:genmodule).with { |name, options, block| options[:extend] == Puppet::Util::Docs }.returns(mod)
+        Puppet::Reports.register_report(:testing) { }
+    end
+
+    it "should define a :report_name method in the module that returns the name of the report" do
+        mod = mock 'module'
+        mod.expects(:define_method).with(:report_name)
+
+        Puppet::Reports.expects(:genmodule).returns(mod)
+        Puppet::Reports.register_report(:testing) { }
+    end
+end

data/spec/unit/resource_reference.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/resource_reference'
+
+describe Puppet::ResourceReference do
+    it "should have a :title attribute" do
+        Puppet::ResourceReference.new(:file, "foo").title.should == "foo"
+    end
+
+    it "should canonize types to capitalized strings" do
+        Puppet::ResourceReference.new(:file, "foo").type.should == "File"
+    end
+
+    it "should canonize qualified types so all strings are capitalized" do
+        Puppet::ResourceReference.new("foo::bar", "foo").type.should == "Foo::Bar"
+    end
+
+    it "should set its type to 'Class' and its title to the passed title if the passed type is :component and the title has no square brackets in it" do
+        ref = Puppet::ResourceReference.new(:component, "foo")
+        ref.type.should == "Class"
+        ref.title.should == "foo"
+    end
+
+    it "should interpret the title as a reference and assign appropriately if the type is :component and the title contains square brackets" do
+        ref = Puppet::ResourceReference.new(:component, "foo::bar[yay]")
+        ref.type.should == "Foo::Bar"
+        ref.title.should == "yay"
+    end
+
+    it "should set the type to 'Class' if it is nil and the title contains no square brackets" do
+        ref = Puppet::ResourceReference.new(nil, "yay")
+        ref.type.should == "Class"
+        ref.title.should == "yay"
+    end
+
+    it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains square brackets" do
+        ref = Puppet::ResourceReference.new(nil, "foo::bar[yay]")
+        ref.type.should == "Foo::Bar"
+        ref.title.should == "yay"
+    end
+
+    it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains nested square brackets" do
+        ref = Puppet::ResourceReference.new(nil, "foo::bar[baz[yay]]")
+        ref.type.should == "Foo::Bar"
+        ref.title.should =="baz[yay]"
+    end
+end
+
+describe Puppet::ResourceReference, "when resolving resources without a catalog" do
+    it "should be able to resolve builtin resources from their types" do
+        Puppet::Type.type(:file).expects(:[]).with("myfile").returns(:myfile)
+        Puppet::ResourceReference.new(:file, "myfile").resolve.should == :myfile
+    end
+
+    it "should be able to resolve defined resources from Components" do
+        Puppet::Type.type(:component).expects(:[]).with("Foo::Bar[yay]").returns(:mything)
+        Puppet::ResourceReference.new("foo::bar", "yay").resolve.should == :mything
+    end
+end
+
+describe Puppet::ResourceReference, "when resolving resources with a catalog" do
+    it "should resolve all resources using the catalog" do
+        config = mock 'catalog'
+        ref = Puppet::ResourceReference.new("foo::bar", "yay")
+        ref.catalog = config
+
+        config.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
+
+        ref.resolve.should == :myresource
+    end
+end

data/spec/unit/simple_graph.rb

@@ -0,0 +1,280 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-11-1.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'puppet/simple_graph'
+
+describe Puppet::SimpleGraph do
+    it "should return the number of its vertices as its length" do
+        @graph = Puppet::SimpleGraph.new
+        @graph.add_vertex("one")
+        @graph.add_vertex("two")
+        @graph.size.should == 2
+    end
+
+    it "should consider itself a directed graph" do
+        Puppet::SimpleGraph.new.directed?.should be_true
+    end
+
+    it "should provide a method for reversing the graph" do
+        @graph = Puppet::SimpleGraph.new
+        @graph.add_edge(:one, :two)
+        @graph.reversal.edge?(:two, :one).should be_true
+    end
+
+    it "should be able to produce a dot graph" do
+        @graph = Puppet::SimpleGraph.new
+        @graph.add_edge(:one, :two)
+
+        proc { @graph.to_dot_graph }.should_not raise_error
+    end
+end
+
+describe Puppet::SimpleGraph, " when managing vertices" do
+    before do
+        @graph = Puppet::SimpleGraph.new
+    end
+
+    it "should provide a method to add a vertex" do
+        @graph.add_vertex(:test)
+        @graph.vertex?(:test).should be_true
+    end
+
+    it "should ignore already-present vertices when asked to add a vertex" do
+        @graph.add_vertex(:test)
+        proc { @graph.add_vertex(:test) }.should_not raise_error
+    end
+
+    it "should return true when asked if a vertex is present" do
+        @graph.add_vertex(:test)
+        @graph.vertex?(:test).should be_true
+    end
+
+    it "should return false when asked if a non-vertex is present" do
+        @graph.vertex?(:test).should be_false
+    end
+
+    it "should return all set vertices when asked" do
+        @graph.add_vertex(:one)
+        @graph.add_vertex(:two)
+        @graph.vertices.length.should == 2
+        @graph.vertices.should include(:one)
+        @graph.vertices.should include(:two)
+    end
+
+    it "should remove a given vertex when asked" do
+        @graph.add_vertex(:one)
+        @graph.remove_vertex!(:one)
+        @graph.vertex?(:one).should be_false
+    end
+
+    it "should do nothing when a non-vertex is asked to be removed" do
+        proc { @graph.remove_vertex!(:one) }.should_not raise_error
+    end
+end
+
+describe Puppet::SimpleGraph, " when managing edges" do
+    before do
+        @graph = Puppet::SimpleGraph.new
+    end
+
+    it "should provide a method to test whether a given vertex pair is an edge" do
+        @graph.should respond_to(:edge?)
+    end
+
+    it "should provide a method to add an edge as an instance of the edge class" do
+        edge = Puppet::Relationship.new(:one, :two)
+        @graph.add_edge(edge)
+        @graph.edge?(:one, :two).should be_true
+    end
+
+    it "should provide a method to add an edge by specifying the two vertices" do
+        @graph.add_edge(:one, :two)
+        @graph.edge?(:one, :two).should be_true
+    end
+
+    it "should provide a method to add an edge by specifying the two vertices and a label" do
+        @graph.add_edge(:one, :two, :stuff => :awesome)
+        @graph.edge?(:one, :two).should be_true
+    end
+
+    it "should provide a method for retrieving an edge label" do
+        edge = Puppet::Relationship.new(:one, :two, :stuff => :awesome)
+        @graph.add_edge(edge)
+        @graph.edge_label(:one, :two).should == {:stuff => :awesome}
+    end
+
+    it "should provide a method for retrieving an edge" do
+        edge = Puppet::Relationship.new(:one, :two)
+        @graph.add_edge(edge)
+        @graph.edge(:one, :two).should equal(edge)
+    end
+
+    it "should add the edge source as a vertex if it is not already" do
+        edge = Puppet::Relationship.new(:one, :two)
+        @graph.add_edge(edge)
+        @graph.vertex?(:one).should be_true
+    end
+
+    it "should add the edge target as a vertex if it is not already" do
+        edge = Puppet::Relationship.new(:one, :two)
+        @graph.add_edge(edge)
+        @graph.vertex?(:two).should be_true
+    end
+
+    it "should return all edges as edge instances when asked" do
+        one = Puppet::Relationship.new(:one, :two)
+        two = Puppet::Relationship.new(:two, :three)
+        @graph.add_edge(one)
+        @graph.add_edge(two)
+        edges = @graph.edges
+        edges.length.should == 2
+        edges.should include(one)
+        edges.should include(two)
+    end
+
+    it "should remove an edge when asked" do
+        edge = Puppet::Relationship.new(:one, :two)
+        @graph.add_edge(edge)
+        @graph.remove_edge!(edge)
+        @graph.edge?(edge.source, edge.target).should be_false
+    end
+
+    it "should remove all related edges when a vertex is removed" do
+        one = Puppet::Relationship.new(:one, :two)
+        two = Puppet::Relationship.new(:two, :three)
+        @graph.add_edge(one)
+        @graph.add_edge(two)
+        @graph.remove_vertex!(:two)
+        @graph.edge?(:one, :two).should be_false
+        @graph.edge?(:two, :three).should be_false
+        @graph.edges.length.should == 0
+    end
+end
+
+describe Puppet::SimpleGraph, " when finding adjacent vertices" do
+    before do
+        @graph = Puppet::SimpleGraph.new
+        @one_two = Puppet::Relationship.new(:one, :two)
+        @two_three = Puppet::Relationship.new(:two, :three)
+        @one_three = Puppet::Relationship.new(:one, :three)
+        @graph.add_edge(@one_two)
+        @graph.add_edge(@one_three)
+        @graph.add_edge(@two_three)
+    end
+
+    it "should return adjacent vertices" do
+        adj = @graph.adjacent(:one)
+        adj.should be_include(:three)
+        adj.should be_include(:two)
+    end
+
+    it "should default to finding :out vertices" do
+        @graph.adjacent(:two).should == [:three]
+    end
+
+    it "should support selecting :in vertices" do
+        @graph.adjacent(:two, :direction => :in).should == [:one]
+    end
+
+    it "should default to returning the matching vertices as an array of vertices" do
+        @graph.adjacent(:two).should == [:three]
+    end
+
+    it "should support returning an array of matching edges" do
+        @graph.adjacent(:two, :type => :edges).should == [@two_three]
+    end
+end
+
+describe Puppet::SimpleGraph, " when clearing" do
+    before do
+        @graph = Puppet::SimpleGraph.new
+        one = Puppet::Relationship.new(:one, :two)
+        two = Puppet::Relationship.new(:two, :three)
+        @graph.add_edge(one)
+        @graph.add_edge(two)
+
+        @graph.clear
+    end
+
+    it "should remove all vertices" do
+        @graph.vertices.should be_empty
+    end
+
+    it "should remove all edges" do
+        @graph.edges.should be_empty
+    end
+end
+
+describe Puppet::SimpleGraph, " when reversing graphs" do
+    before do
+        @graph = Puppet::SimpleGraph.new
+    end
+
+    it "should provide a method for reversing the graph" do
+        @graph.add_edge(:one, :two)
+        @graph.reversal.edge?(:two, :one).should be_true
+    end
+
+    it "should add all vertices to the reversed graph" do
+        @graph.add_edge(:one, :two)
+        @graph.vertex?(:one).should be_true
+        @graph.vertex?(:two).should be_true
+    end
+    
+    it "should retain labels on edges" do
+        @graph.add_edge(:one, :two, :stuff => :awesome)
+        edge = @graph.reversal.edge(:two, :one)
+        edge.label.should == {:stuff => :awesome}
+    end
+end
+
+describe Puppet::SimpleGraph, " when sorting the graph" do
+    before do
+        @graph = Puppet::SimpleGraph.new
+    end
+
+    def add_edges(hash)
+        hash.each do |a,b|
+            @graph.add_edge(a, b)
+        end
+    end
+
+    it "should sort the graph topologically" do
+        add_edges :a => :b, :b => :c
+        @graph.topsort.should == [:a, :b, :c]
+    end
+
+    it "should fail on two-vertex loops" do
+        add_edges :a => :b, :b => :a
+        proc { @graph.topsort }.should raise_error(Puppet::Error)
+    end
+
+    it "should fail on multi-vertex loops" do
+        add_edges :a => :b, :b => :c, :c => :a
+        proc { @graph.topsort }.should raise_error(Puppet::Error)
+    end
+
+    it "should fail when a larger tree contains a small cycle" do
+        add_edges :a => :b, :b => :a, :c => :a, :d => :c
+        proc { @graph.topsort }.should raise_error(Puppet::Error)
+    end
+
+    it "should succeed on trees with no cycles" do
+        add_edges :a => :b, :b => :e, :c => :a, :d => :c
+        proc { @graph.topsort }.should_not raise_error
+    end
+
+    # Our graph's add_edge method is smart enough not to add
+    # duplicate edges, so we use the objects, which it doesn't
+    # check.
+    it "should be able to sort graphs with duplicate edges" do
+        one = Puppet::Relationship.new(:a, :b)
+        @graph.add_edge(one)
+        two = Puppet::Relationship.new(:a, :b)
+        @graph.add_edge(two)
+        proc { @graph.topsort }.should_not raise_error
+    end
+end

data/spec/unit/transaction/change.rb

@@ -0,0 +1,187 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transaction/change'
+
+describe Puppet::Transaction::Change do
+    Change = Puppet::Transaction::Change
+
+    describe "when initializing" do
+        before do
+            @property = stub 'property', :path => "/property/path", :should => "shouldval"
+        end
+
+        it "should require the property and current value" do
+            lambda { Change.new() }.should raise_error
+        end
+
+        it "should set its property to the provided property" do
+            Change.new(@property, "value").property.should == :property
+        end
+
+        it "should set its 'is' value to the provided value" do
+            Change.new(@property, "value").is.should == "value"
+        end
+
+        it "should retrieve the 'should' value from the property" do
+            # Yay rspec :)
+            Change.new(@property, "value").should.should == @property.should
+        end
+
+        it "should set its path to the path of the property plus 'change'" do
+            Change.new(@property, "value").path.should == [@property.path, "change"]
+        end
+    end
+
+    describe "when an instance" do
+        before do
+            @property = stub 'property', :path => "/property/path", :should => "shouldval"
+            @change = Change.new(@property, "value")
+        end
+
+        it "should be noop if the property is noop" do
+            @property.expects(:noop).returns true
+            @change.noop?.should be_true
+        end
+
+        it "should set its resource to the proxy if it has one" do
+            @change.proxy = :myresource
+            @change.resource.should == :myresource
+        end
+
+        it "should set its resource to the property's resource if no proxy is set" do
+            @property.expects(:resource).returns :myresource
+            @change.resource.should == :myresource
+        end
+
+        it "should have a method for marking that it's been execution" do
+            @change.changed = true
+            @change.changed?.should be_true
+        end
+
+        describe "and creating an event" do
+            before do
+                @property.stubs(:resource).returns "myresource"
+            end
+
+            it "should produce a warning if the event name is not a symbol" do
+                @property.expects(:warning)
+                @property.stubs(:event).returns :myevent
+                @change.event("a string")
+            end
+
+            it "should use the property to generate the event name if the provided name is not a symbol" do
+                @property.stubs(:warning)
+                @property.expects(:event).with(@change.should).returns :myevent
+
+                Puppet::Transaction::Event.expects(:new).with { |name, source| name == :myevent }
+
+                @change.event("a string")
+            end
+        end
+
+        describe "and executing" do
+            describe "in noop mode" do
+                before { @change.stubs(:noop?).returns true }
+
+                it "should log that it is in noop" do
+                    @property.expects(:is_to_s)
+                    @property.expects(:should_to_s)
+                    @property.expects(:log)
+
+                    @change.stubs :event
+                    @change.forward
+                end
+                
+                it "should produce a :noop event and return" do
+                    @property.stub_everything
+
+                    @change.expects(:event).with(:noop).returns :noop_event
+
+                    @change.forward.should == [:noop_event]
+                end
+            end
+
+            describe "without noop" do
+                before do
+                    @change.stubs(:noop?).returns false
+                    @property.stub_everything
+                    @property.stubs(:resource).returns "myresource"
+                    @property.stubs(:name).returns :myprop
+                end
+
+                it "should sync the property" do
+                    @property.expects(:sync)
+
+                    @change.forward
+                end
+
+                it "should return the default event if syncing the property returns nil" do
+                    @property.stubs(:sync).returns nil
+
+                    @change.expects(:event).with(:myprop_changed).returns :myevent
+
+                    @change.forward.should == [:myevent]
+                end
+
+                it "should return the default event if syncing the property returns an empty array" do
+                    @property.stubs(:sync).returns []
+
+                    @change.expects(:event).with(:myprop_changed).returns :myevent
+
+                    @change.forward.should == [:myevent]
+                end
+
+                it "should log the change" do
+                    @property.expects(:sync).returns [:one]
+
+                    @property.expects(:log)
+                    @property.expects(:change_to_s)
+
+                    @change.forward
+                end
+
+                it "should return an array of events" do
+                    @property.expects(:sync).returns [:one, :two]
+
+                    @change.expects(:event).with(:one).returns :uno
+                    @change.expects(:event).with(:two).returns :dos
+
+                    @change.forward.should == [:uno, :dos]
+                end
+            end
+
+            describe "backward" do
+                before do
+                    @property = stub 'property'
+                    @property.stub_everything
+                    @property.stubs(:should).returns "shouldval"
+                    @change = Change.new(@property, "value")
+                    @change.stubs :go
+                end
+
+                it "should swap the 'is' and 'should' values" do
+                    @change.backward
+                    @change.is.should == "shouldval"
+                    @change.should.should == "value"
+                end
+
+                it "should set the 'should' value on the property to the previous 'is' value" do
+                    @property.expects(:should=).with "value"
+                    @change.backward
+                end
+
+                it "should log that it's reversing the change" do
+                    @property.expects(:info)
+                    @change.backward
+                end
+
+                it "should execute" do
+                    @change.expects(:go)
+                    @change.backward
+                end
+            end
+        end
+    end
+end