puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/graph/sequential_prioritizer_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'puppet/graph'
+
+describe Puppet::Graph::SequentialPrioritizer do
+  let(:priorities) { Puppet::Graph::SequentialPrioritizer.new }
+
+  it "generates priorities that maintain the sequence" do
+    first = priorities.generate_priority_for("one")
+    second = priorities.generate_priority_for("two")
+    third = priorities.generate_priority_for("three")
+
+    expect(first).to be < second
+    expect(second).to be < third
+  end
+
+  it "prioritizes contained keys after the container" do
+    parent = priorities.generate_priority_for("one")
+    child = priorities.generate_priority_contained_in("one", "child 1")
+    sibling = priorities.generate_priority_contained_in("one", "child 2")
+    uncle = priorities.generate_priority_for("two")
+
+    expect(parent).to be < child
+    expect(child).to be < sibling
+    expect(sibling).to be < uncle
+  end
+
+  it "fails to prioritize a key contained in an unknown container" do
+    expect do
+      priorities.generate_priority_contained_in("unknown", "child 1")
+    end.to raise_error
+  end
+end

data/spec/unit/{simple_graph_spec.rb → graph/simple_graph.rb}

@@ -1,27 +1,27 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'puppet/simple_graph'
+require 'puppet/graph'
 
-describe Puppet::SimpleGraph do
+describe Puppet::Graph::SimpleGraph do
   it "should return the number of its vertices as its length" do
-    @graph = Puppet::SimpleGraph.new
+    @graph = Puppet::Graph::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
+    Puppet::Graph::SimpleGraph.new.directed?.should be_true
   end
 
   it "should provide a method for reversing the graph" do
-    @graph = Puppet::SimpleGraph.new
+    @graph = Puppet::Graph::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 = Puppet::Graph::SimpleGraph.new
     @graph.add_edge(:one, :two)
 
     expect { @graph.to_dot_graph }.to_not raise_error
@@ -29,7 +29,7 @@ describe Puppet::SimpleGraph do
 
   describe "when managing vertices" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
     end
 
     it "should provide a method to add a vertex" do
@@ -78,7 +78,7 @@ describe Puppet::SimpleGraph do
 
   describe "when managing edges" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
     end
 
     it "should provide a method to test whether a given vertex pair is an edge" do
@@ -179,7 +179,7 @@ describe Puppet::SimpleGraph do
 
   describe "when finding adjacent vertices" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
       @one_two = Puppet::Relationship.new(:one, :two)
       @two_three = Puppet::Relationship.new(:two, :three)
       @one_three = Puppet::Relationship.new(:one, :three)
@@ -212,7 +212,7 @@ describe Puppet::SimpleGraph do
 
     # Bug #2111
     it "should not consider a vertex adjacent just because it was asked about previously" do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
       @graph.add_vertex("a")
       @graph.add_vertex("b")
       @graph.edge?("a", "b")
@@ -222,7 +222,7 @@ describe Puppet::SimpleGraph do
 
   describe "when clearing" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
       one = Puppet::Relationship.new(:one, :two)
       two = Puppet::Relationship.new(:two, :three)
       @graph.add_edge(one)
@@ -242,7 +242,7 @@ describe Puppet::SimpleGraph do
 
   describe "when reversing graphs" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
     end
 
     it "should provide a method for reversing the graph" do
@@ -265,7 +265,7 @@ describe Puppet::SimpleGraph do
 
   describe "when reporting cycles in the graph" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
     end
 
     # This works with `add_edges` to auto-vivify the resource instances.
@@ -282,9 +282,9 @@ describe Puppet::SimpleGraph do
     end
 
     def simplify(cycles)
-      cycles.map do |x|
-        x.map do |y|
-          y.to_s.match(/^Notify\[(.*)\]$/)[1]
+      cycles.map do |cycle|
+        cycle.map do |resource|
+          resource.name
         end
       end
     end
@@ -322,18 +322,20 @@ describe Puppet::SimpleGraph do
       add_edges "b" => "a"
       add_edges "b" => "c"
 
-      cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
-      simplify(cycles).should be == [["a", "b"]]
+      simplify(@graph.find_cycles_in_graph).should be == [["a", "b"]]
+    end
+
+    it "cycle discovery handles a self-loop cycle" do
+      add_edges :a => :a
+
+      simplify(@graph.find_cycles_in_graph).should be == [["a"]]
     end
 
     it "cycle discovery should handle two distinct cycles" do
       add_edges "a" => "a1", "a1" => "a"
       add_edges "b" => "b1", "b1" => "b"
 
-      cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
-      simplify(cycles).should be == [["a1", "a"], ["b1", "b"]]
+      simplify(@graph.find_cycles_in_graph).should be == [["a1", "a"], ["b1", "b"]]
     end
 
     it "cycle discovery should handle two cycles in a connected graph" do
@@ -341,9 +343,7 @@ describe Puppet::SimpleGraph do
       add_edges "a" => "a1", "a1" => "a"
       add_edges "c" => "c1", "c1" => "c2", "c2" => "c3", "c3" => "c"
 
-      cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
-      simplify(cycles).should be == [%w{a1 a}, %w{c1 c2 c3 c}]
+      simplify(@graph.find_cycles_in_graph).should be == [%w{a1 a}, %w{c1 c2 c3 c}]
     end
 
     it "cycle discovery should handle a complicated cycle" do
@@ -352,18 +352,14 @@ describe Puppet::SimpleGraph do
       add_edges "c" => "c1", "c1" => "a"
       add_edges "c" => "c2", "c2" => "b"
 
-      cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
-      simplify(cycles).should be == [%w{a b c1 c2 c}]
+      simplify(@graph.find_cycles_in_graph).should be == [%w{a b c1 c2 c}]
     end
 
     it "cycle discovery should not fail with large data sets" do
       limit = 3000
       (1..(limit - 1)).each do |n| add_edges n.to_s => (n+1).to_s end
 
-      cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
-      simplify(cycles).should be == []
+      simplify(@graph.find_cycles_in_graph).should be == []
     end
 
     it "path finding should work with a simple cycle" do
@@ -415,7 +411,7 @@ describe Puppet::SimpleGraph do
 
   describe "when writing dot files" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
       @name = :test
       @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
     end
@@ -432,15 +428,11 @@ describe Puppet::SimpleGraph do
       Puppet[:graph] = true
       @graph.write_graph(@name)
     end
-
-    after do
-      Puppet.settings.clear
-    end
   end
 
-  describe Puppet::SimpleGraph do
+  describe Puppet::Graph::SimpleGraph do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
     end
 
     it "should correctly clear vertices and edges when asked" do
@@ -454,7 +446,7 @@ describe Puppet::SimpleGraph do
 
   describe "when matching edges" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
 
       # The Ruby 1.8 semantics for String#[] are that treating it like an
       # array and asking for `"a"[:whatever]` returns `nil`.  Ruby 1.9
@@ -496,7 +488,7 @@ describe Puppet::SimpleGraph do
 
   describe "when determining dependencies" do
     before do
-      @graph = Puppet::SimpleGraph.new
+      @graph = Puppet::Graph::SimpleGraph.new
 
       @graph.add_edge("a", "b")
       @graph.add_edge("a", "c")
@@ -528,212 +520,8 @@ describe Puppet::SimpleGraph do
     end
   end
 
-  require 'puppet/util/graph'
-
-  class Container < Puppet::Type::Component
-    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
-
-    def ref
-      "Container[#{self}]"
-    end
-  end
-
-  require "puppet/resource/catalog"
-  describe "when splicing the 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", [])
-
-      @whit  = Puppet::Type.type(:whit)
-      @stage = Puppet::Type.type(:stage).new(:name => "foo")
-
-      @contgraph = @top.to_graph(Puppet::Resource::Catalog.new)
-
-      # 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 containers
-      @contgraph.vertices.select { |x| !x.is_a? String }
-    end
-
-    def contents_of(x)
-      @contgraph.direct_dependents_of(x)
-    end
-
-    def dependency_graph
-      @depgraph = Puppet::SimpleGraph.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.
-      @explicit_dependencies = {@one => @two, "f" => "c", "h" => @middle, "c" => @empty}
-      @explicit_dependencies.each do |source, target|
-        @depgraph.add_edge(source, target, :callback => :refresh)
-      end
-    end
-
-    def splice
-      @contgraph.splice!(@depgraph)
-    end
-
-    def whit_called(name)
-      x = @depgraph.vertices.find { |v| v.is_a?(@whit) && v.name =~ /#{Regexp.escape(name)}/ }
-      x.should_not be_nil
-      def x.to_s
-        "Whit[#{name}]"
-      end
-      def x.inspect
-        to_s
-      end
-      x
-    end
-
-    def admissible_sentinel_of(x)
-      @depgraph.vertex?(x) ? x : whit_called("admissible_#{x.ref}")
-    end
-
-    def completed_sentinel_of(x)
-      @depgraph.vertex?(x) ? x : whit_called("completed_#{x.ref}")
-    end
-
-    before do
-      container_graph
-      dependency_graph
-      splice
-    end
-
-    # This is the real heart of splicing -- replacing all containers X in our
-    # relationship graph with a pair of whits { admissible_X and completed_X }
-    # such that that
-    #
-    #    0) completed_X depends on admissible_X
-    #    1) contents of X each depend on admissible_X
-    #    2) completed_X depends on each on the contents of X
-    #    3) everything which depended on X depends on completed_X
-    #    4) admissible_X depends on everything X depended on
-    #    5) the containers and their edges must be removed
-    #
-    # Note that this requires attention to the possible case of containers
-    # which contain or depend on other containers.
-    #
-    # Point by point:
-
-    #    0) completed_X depends on admissible_X
-    #
-    it "every container's completed sentinel should depend on its admissible sentinel" do
-      containers.each { |container|
-        @depgraph.path_between(admissible_sentinel_of(container),completed_sentinel_of(container)).should be
-      }
-    end
-
-    #    1) contents of X each depend on admissible_X
-    #
-    it "all contained objects should depend on their container's admissible sentinel" do
-      containers.each { |container|
-        contents_of(container).each { |leaf|
-          @depgraph.should be_edge(admissible_sentinel_of(container),admissible_sentinel_of(leaf))
-        }
-      }
-    end
-
-    #    2) completed_X depends on each on the contents of X
-    #
-    it "completed sentinels should depend on their container's contents" do
-      containers.each { |container|
-        contents_of(container).each { |leaf|
-          @depgraph.should be_edge(completed_sentinel_of(leaf),completed_sentinel_of(container))
-        }
-      }
-    end
-
-    #
-    #    3) everything which depended on X depends on completed_X
-
-    #
-    #    4) admissible_X depends on everything X depended on
-
-    #    5) the containers and their edges must be removed
-    #
-    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 remove all Stage resources from the dependency graph" do
-      @depgraph.vertices.find_all { |v| v.is_a?(Puppet::Type.type(:stage)) }.should be_empty
-    end
-
-    it "should no longer contain anything but the non-container objects" do
-      @depgraph.vertices.find_all { |v| ! v.is_a?(String) and ! v.is_a?(@whit)}.should be_empty
-    end
-
-    it "should retain labels on non-containment edges" do
-      @explicit_dependencies.each { |f,t|
-        @depgraph.edges_between(completed_sentinel_of(f),admissible_sentinel_of(t))[0].label.should == {:callback => :refresh}
-      }
-    end
-
-    it "should not add labels to edges that have none" do
-      @depgraph.add_edge(@two, @three)
-      splice
-      @depgraph.path_between("c", "i").any? {|segment| segment.all? {|e| e.label == {} }}.should be
-    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.path_between("c", "i").flatten.select {|e| e.label == {:callback => :refresh} }.should_not be_empty
-    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.path_between("c","i").flatten.select {|e| e.label == {:callback => :refresh} }.should_not be_empty
-    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)
-        (path = @depgraph.path_between(edge.source, edge.target)).should be
-        path.should_not be_empty
-        path.flatten.select {|e| e.label == {:callback => :refresh} }.should_not be_empty
-      end
-    end
-  end
-
   it "should serialize to YAML using the old format by default" do
-    Puppet::SimpleGraph.use_new_yaml_format.should == false
+    Puppet::Graph::SimpleGraph.use_new_yaml_format.should == false
   end
 
   describe "(yaml tests)" do
@@ -780,18 +568,18 @@ describe Puppet::SimpleGraph do
     end
 
     def graph_to_yaml(graph, which_format)
-      previous_use_new_yaml_format = Puppet::SimpleGraph.use_new_yaml_format
-      Puppet::SimpleGraph.use_new_yaml_format = (which_format == :new)
+      previous_use_new_yaml_format = Puppet::Graph::SimpleGraph.use_new_yaml_format
+      Puppet::Graph::SimpleGraph.use_new_yaml_format = (which_format == :new)
       ZAML.dump(graph)
     ensure
-      Puppet::SimpleGraph.use_new_yaml_format = previous_use_new_yaml_format
+      Puppet::Graph::SimpleGraph.use_new_yaml_format = previous_use_new_yaml_format
     end
 
     # Test serialization of graph to YAML.
     [:old, :new].each do |which_format|
       all_test_graphs.each do |graph_to_test|
         it "should be able to serialize #{graph_to_test} to YAML (#{which_format} format)", :if => (RUBY_VERSION[0,3] == '1.8' or YAML::ENGINE.syck?) do
-          graph = Puppet::SimpleGraph.new
+          graph = Puppet::Graph::SimpleGraph.new
           send(graph_to_test, graph)
           yaml_form = graph_to_yaml(graph, which_format)
 
@@ -805,7 +593,7 @@ describe Puppet::SimpleGraph do
           # Check that the object contains instance variables @edges and
           # @vertices only.  @reversal is also permitted, but we don't
           # check it, because it is going to be phased out.
-          serialized_object.type_id.should == 'object:Puppet::SimpleGraph'
+          serialized_object.type_id.should == 'object:Puppet::Graph::SimpleGraph'
           serialized_object.value.keys.reject { |x| x == 'reversal' }.sort.should == ['edges', 'vertices']
 
           # Check edges by forming a set of tuples (source, target,
@@ -829,7 +617,7 @@ describe Puppet::SimpleGraph do
             vertices.should be_a(Hash)
             Set.new(vertices.keys).should == Set.new(graph.vertices)
             vertices.each do |key, value|
-              value.type_id.should == 'object:Puppet::SimpleGraph::VertexWrapper'
+              value.type_id.should == 'object:Puppet::Graph::SimpleGraph::VertexWrapper'
               value.value.keys.sort.should == %w{adjacencies vertex}
               value.value['vertex'].should equal(key)
               adjacencies = value.value['adjacencies']
@@ -867,7 +655,7 @@ describe Puppet::SimpleGraph do
       # tested.
       all_test_graphs.each do |graph_to_test|
         it "should be able to deserialize #{graph_to_test} from YAML (#{which_format} format)" do
-          reference_graph = Puppet::SimpleGraph.new
+          reference_graph = Puppet::Graph::SimpleGraph.new
           send(graph_to_test, reference_graph)
           yaml_form = graph_to_yaml(reference_graph, which_format)
           recovered_graph = YAML.load(yaml_form)
@@ -897,7 +685,7 @@ describe Puppet::SimpleGraph do
       end
 
       it "should be able to serialize a graph where the vertices contain backreferences to the graph (#{which_format} format)" do
-        reference_graph = Puppet::SimpleGraph.new
+        reference_graph = Puppet::Graph::SimpleGraph.new
         vertex = Object.new
         vertex.instance_eval { @graph = reference_graph }
         reference_graph.add_edge(vertex, :other_vertex)
@@ -915,7 +703,7 @@ describe Puppet::SimpleGraph do
     end
 
     it "should serialize properly when used as a base class" do
-      class Puppet::TestDerivedClass < Puppet::SimpleGraph
+      class Puppet::TestDerivedClass < Puppet::Graph::SimpleGraph
         attr_accessor :foo
       end
       derived = Puppet::TestDerivedClass.new