puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/defaults_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'puppet/settings'
+
+describe "Defaults" do
+  describe ".default_diffargs" do
+    describe "on AIX" do
+      before(:each) do
+        Facter.stubs(:value).with(:kernel).returns("AIX")
+      end
+      describe "on 5.3" do
+        before(:each) do
+          Facter.stubs(:value).with(:kernelmajversion).returns("5300")
+        end
+        it "should be empty" do
+          Puppet.default_diffargs.should == ""
+        end
+      end
+      [ "",
+        nil,
+        "6300",
+        "7300",
+      ].each do |kernel_version|
+        describe "on kernel version #{kernel_version.inspect}" do
+          before(:each) do
+            Facter.stubs(:value).with(:kernelmajversion).returns(kernel_version)
+          end
+
+          it "should be '-u'" do
+            Puppet.default_diffargs.should == "-u"
+          end
+        end
+      end
+    end
+    describe "on everything else" do
+      before(:each) do
+        Facter.stubs(:value).with(:kernel).returns("NOT_AIX")
+      end
+
+      it "should be '-u'" do
+        Puppet.default_diffargs.should == "-u"
+      end
+    end
+  end
+end

data/spec/unit/face/node_spec.rb

@@ -67,8 +67,8 @@ describe Puppet::Face[:node, '0.0.1'] do
 
     it "should accept the option --unexport" do
       expect {
-        subject.help('hostname', :unexport => true)
-      }.to_not raise_error(ArgumentError)
+        subject.clean('hostname', :unexport => true)
+      }.to_not raise_error
     end
 
     context "clean action" do

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -3,30 +3,20 @@ require 'spec_helper'
 
 require 'puppet/file_serving/configuration/parser'
 
-describe Puppet::FileServing::Configuration::Parser do
-  it "should subclass the LoadedFile class" do
-    Puppet::FileServing::Configuration::Parser.superclass.should equal(Puppet::Util::LoadedFile)
-  end
-end
-
 
 module FSConfigurationParserTesting
-  def mock_file_content(content)
+  def write_config_file(content)
     # We want an array, but we actually want our carriage returns on all of it.
-    lines = content.split("\n").collect { |l| l + "\n" }
-    @filehandle.stubs(:each_line).multiple_yields(*lines)
-    @filehandle.expects(:each).never
+    File.open(@path, 'w') {|f| f.puts content}
   end
 end
 
 describe Puppet::FileServing::Configuration::Parser do
+  include PuppetSpec::Files
+
   before :each do
-    @path = "/my/config.conf"
-    FileTest.stubs(:exists?).with(@path).returns(true)
-    FileTest.stubs(:readable?).with(@path).returns(true)
-    @filehandle = mock 'filehandle'
-    @filehandle.expects(:each).never
-    File.expects(:open).with(@path).yields(@filehandle)
+    @path = tmpfile('fileserving_config')
+    FileUtils.touch(@path)
     @parser = Puppet::FileServing::Configuration::Parser.new(@path)
   end
 
@@ -34,12 +24,12 @@ describe Puppet::FileServing::Configuration::Parser do
     include FSConfigurationParserTesting
 
     it "should allow comments" do
-      @filehandle.expects(:each_line).yields("# this is a comment\n")
+      write_config_file("# this is a comment\n")
       proc { @parser.parse }.should_not raise_error
     end
 
     it "should allow blank lines" do
-      @filehandle.expects(:each_line).yields("\n")
+      write_config_file("\n")
       proc { @parser.parse }.should_not raise_error
     end
 
@@ -48,7 +38,7 @@ describe Puppet::FileServing::Configuration::Parser do
       mount2 = mock 'two', :validate => true
       Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
       Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
-      mock_file_content "[one]\n[two]\n"
+      write_config_file "[one]\n[two]\n"
       @parser.parse
     end
 
@@ -58,7 +48,7 @@ describe Puppet::FileServing::Configuration::Parser do
       mount2 = mock 'two', :validate => true
       Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
       Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
-      mock_file_content "[one]\n[two]\n"
+      write_config_file "[one]\n[two]\n"
 
       result = @parser.parse
       result["one"].should equal(mount1)
@@ -66,19 +56,19 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should only allow mount names that are alphanumeric plus dashes" do
-      mock_file_content "[a*b]\n"
+      write_config_file "[a*b]\n"
       proc { @parser.parse }.should raise_error(ArgumentError)
     end
 
     it "should fail if the value for path/allow/deny starts with an equals sign" do
-      mock_file_content "[one]\npath = /testing"
+      write_config_file "[one]\npath = /testing"
       proc { @parser.parse }.should raise_error(ArgumentError)
     end
 
     it "should validate each created mount" do
       mount1 = mock 'one'
       Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
-      mock_file_content "[one]\n"
+      write_config_file "[one]\n"
 
       mount1.expects(:validate)
 
@@ -88,7 +78,7 @@ describe Puppet::FileServing::Configuration::Parser do
     it "should fail if any mount does not pass validation" do
       mount1 = mock 'one'
       Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
-      mock_file_content "[one]\n"
+      write_config_file "[one]\n"
 
       mount1.expects(:validate).raises RuntimeError
 
@@ -106,14 +96,14 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should set the mount path to the path attribute from that section" do
-      mock_file_content "[one]\npath /some/path\n"
+      write_config_file "[one]\npath /some/path\n"
 
       @mount.expects(:path=).with("/some/path")
       @parser.parse
     end
 
     it "should tell the mount to allow any allow values from the section" do
-      mock_file_content "[one]\nallow something\n"
+      write_config_file "[one]\nallow something\n"
 
       @mount.expects(:info)
       @mount.expects(:allow).with("something")
@@ -121,7 +111,7 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should support inline comments" do
-      mock_file_content "[one]\nallow something \# will it work?\n"
+      write_config_file "[one]\nallow something \# will it work?\n"
 
       @mount.expects(:info)
       @mount.expects(:allow).with("something")
@@ -129,7 +119,7 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should tell the mount to deny any deny values from the section" do
-      mock_file_content "[one]\ndeny something\n"
+      write_config_file "[one]\ndeny something\n"
 
       @mount.expects(:info)
       @mount.expects(:deny).with("something")
@@ -137,7 +127,7 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should fail on any attributes other than path, allow, and deny" do
-      mock_file_content "[one]\ndo something\n"
+      write_config_file "[one]\ndo something\n"
 
       proc { @parser.parse }.should raise_error(ArgumentError)
     end
@@ -151,14 +141,14 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should create an instance of the Modules Mount class" do
-      mock_file_content "[modules]\n"
+      write_config_file "[modules]\n"
 
       Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns @mount
       @parser.parse
     end
 
     it "should warn if a path is set" do
-      mock_file_content "[modules]\npath /some/path\n"
+      write_config_file "[modules]\npath /some/path\n"
       Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns(@mount)
 
       Puppet.expects(:warning)
@@ -174,14 +164,14 @@ describe Puppet::FileServing::Configuration::Parser do
     end
 
     it "should create an instance of the Plugins Mount class" do
-      mock_file_content "[plugins]\n"
+      write_config_file "[plugins]\n"
 
       Puppet::FileServing::Mount::Plugins.expects(:new).with("plugins").returns @mount
       @parser.parse
     end
 
     it "should warn if a path is set" do
-      mock_file_content "[plugins]\npath /some/path\n"
+      write_config_file "[plugins]\npath /some/path\n"
 
       Puppet.expects(:warning)
       @parser.parse

data/spec/unit/file_serving/configuration_spec.rb

@@ -167,13 +167,13 @@ describe Puppet::FileServing::Configuration do
     it "should fail if the mount name is not alpha-numeric" do
       request.expects(:key).returns "foo&bar/asdf"
 
-      lambda { config.split_path(request) }.should raise_error(ArgumentError)
+      expect { config.split_path(request) }.to raise_error(ArgumentError)
     end
 
     it "should support dashes in the mount name" do
       request.expects(:key).returns "foo-bar/asdf"
 
-      lambda { config.split_path(request) }.should_not raise_error(ArgumentError)
+      expect { config.split_path(request) }.to_not raise_error
     end
 
     it "should use the mount name and environment to find the mount" do

data/spec/unit/file_serving/mount/file_spec.rb

@@ -11,7 +11,7 @@ end
 
 describe Puppet::FileServing::Mount::File do
   it "should be invalid if it does not have a path" do
-    lambda { Puppet::FileServing::Mount::File.new("foo").validate }.should raise_error(ArgumentError)
+    expect { Puppet::FileServing::Mount::File.new("foo").validate }.to raise_error(ArgumentError)
   end
 
   it "should be valid if it has a path" do
@@ -19,7 +19,7 @@ describe Puppet::FileServing::Mount::File do
     FileTest.stubs(:readable?).returns true
     mount = Puppet::FileServing::Mount::File.new("foo")
     mount.path = "/foo"
-    lambda { mount.validate }.should_not raise_error(ArgumentError)
+    expect { mount.validate }.not_to raise_error
   end
 
   describe "when setting the path" do
@@ -30,13 +30,13 @@ describe Puppet::FileServing::Mount::File do
 
     it "should fail if the path is not a directory" do
       FileTest.expects(:directory?).returns(false)
-      proc { @mount.path = @dir }.should raise_error(ArgumentError)
+      expect { @mount.path = @dir }.to raise_error(ArgumentError)
     end
 
     it "should fail if the path is not readable" do
       FileTest.expects(:directory?).returns(true)
       FileTest.expects(:readable?).returns(false)
-      proc { @mount.path = @dir }.should raise_error(ArgumentError)
+      expect { @mount.path = @dir }.to raise_error(ArgumentError)
     end
   end
 

data/spec/unit/forge/repository_spec.rb

@@ -11,39 +11,19 @@ describe Puppet::Forge::Repository do
   let(:ssl_repository) { Puppet::Forge::Repository.new('https://fake.com', consumer_version) }
 
   it "retrieve accesses the cache" do
-    uri = URI.parse('http://some.url.com')
-    repository.cache.expects(:retrieve).with(uri)
+    path = '/module/foo.tar.gz'
+    repository.cache.expects(:retrieve)
 
-    repository.retrieve(uri)
+    repository.retrieve(path)
   end
 
-  describe 'http_proxy support' do
-    after :each do
-      ENV["http_proxy"] = nil
-    end
-
-    it "supports environment variable for port and host" do
-      ENV["http_proxy"] = "http://test.com:8011"
-
-      repository.http_proxy_host.should == "test.com"
-      repository.http_proxy_port.should == 8011
-    end
-
-    it "supports puppet configuration for port and host" do
-      ENV["http_proxy"] = nil
-      proxy_settings_of('test.com', 7456)
+  it "retrieve merges forge URI and path specified" do
+    path = '/module/foo.tar.gz'
+    repo_uri = 'http://fake.com/test'
+    repository = Puppet::Forge::Repository.new(repo_uri, consumer_version)
+    repository.cache.expects(:retrieve).with(URI.parse(repo_uri+path))
 
-      repository.http_proxy_port.should == 7456
-      repository.http_proxy_host.should == "test.com"
-    end
-
-    it "uses environment variable before puppet settings" do
-      ENV["http_proxy"] = "http://test1.com:8011"
-      proxy_settings_of('test2.com', 7456)
-
-      repository.http_proxy_host.should == "test1.com"
-      repository.http_proxy_port.should == 8011
-    end
+    repository.retrieve(path)
   end
 
   describe "making a request" do

data/spec/unit/graph/key_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+require 'puppet/graph'
+
+describe Puppet::Graph::Key do
+  it "produces the next in the sequence" do
+    key = Puppet::Graph::Key.new
+
+    expect(key.next).to be > key
+  end
+
+  it "produces a key after itself but before next" do
+    key = Puppet::Graph::Key.new
+    expect(key.down).to be > key
+    expect(key.down).to be < key.next
+  end
+
+  it "downward keys of the same group are in sequence" do
+    key = Puppet::Graph::Key.new
+
+    first = key.down
+    middle = key.down.next
+    last = key.down.next.next
+
+    expect(first).to be < middle
+    expect(middle).to be < last
+    expect(last).to be < key.next
+  end
+
+  it "downward keys in sequential groups are in sequence" do
+    key = Puppet::Graph::Key.new
+
+    first = key.down
+    middle = key.next
+    last = key.next.down
+
+    expect(first).to be < middle
+    expect(middle).to be < last
+    expect(last).to be < key.next.next
+  end
+end

data/spec/unit/{rb_tree_map_spec.rb → graph/rb_tree_map_spec.rb}

@@ -2,9 +2,9 @@
 
 require 'spec_helper'
 
-require 'puppet/rb_tree_map'
+require 'puppet/graph'
 
-describe Puppet::RbTreeMap do
+describe Puppet::Graph::RbTreeMap do
   describe "#push" do
     it "should allow a new element to be added" do
       subject[5] = 'foo'
@@ -32,7 +32,7 @@ describe Puppet::RbTreeMap do
 
       subject[5] = 'foo'
 
-      subject.instance_variable_get(:@root).should be_a(Puppet::RbTreeMap::Node)
+      subject.instance_variable_get(:@root).should be_a(Puppet::Graph::RbTreeMap::Node)
     end
   end
 
@@ -395,14 +395,14 @@ describe Puppet::RbTreeMap do
 
   describe "#isred" do
     it "should return true if the node is red" do
-      node = Puppet::RbTreeMap::Node.new(1,2)
+      node = Puppet::Graph::RbTreeMap::Node.new(1,2)
       node.color = :red
 
       subject.send(:isred, node).should == true
     end
 
     it "should return false if the node is black" do
-      node = Puppet::RbTreeMap::Node.new(1,2)
+      node = Puppet::Graph::RbTreeMap::Node.new(1,2)
       node.color = :black
 
       subject.send(:isred, node).should == false
@@ -414,8 +414,8 @@ describe Puppet::RbTreeMap do
   end
 end
 
-describe Puppet::RbTreeMap::Node do
-  let(:tree) { Puppet::RbTreeMap.new }
+describe Puppet::Graph::RbTreeMap::Node do
+  let(:tree) { Puppet::Graph::RbTreeMap.new }
   let(:subject) { tree.instance_variable_get(:@root) }
 
   before :each do

data/spec/unit/graph/relationship_graph_spec.rb

@@ -0,0 +1,393 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/graph'
+
+require 'puppet_spec/compiler'
+require 'matchers/include_in_order'
+require 'matchers/relationship_graph_matchers'
+
+describe Puppet::Graph::RelationshipGraph do
+  include PuppetSpec::Files
+  include PuppetSpec::Compiler
+  include RelationshipGraphMatchers
+
+  let(:graph) { Puppet::Graph::RelationshipGraph.new(Puppet::Graph::SequentialPrioritizer.new) }
+
+  it "allows adding a new vertex with a specific priority" do
+    vertex = stub_vertex('something')
+
+    graph.add_vertex(vertex, 2)
+
+    expect(graph.resource_priority(vertex)).to eq(2)
+  end
+
+  it "returns resource priority based on the order added" do
+    # strings chosen so the old hex digest method would put these in the
+    # wrong order
+    first = stub_vertex('aa')
+    second = stub_vertex('b')
+
+    graph.add_vertex(first)
+    graph.add_vertex(second)
+
+    expect(graph.resource_priority(first)).to be < graph.resource_priority(second)
+  end
+
+  it "retains the first priority when a resource is added more than once" do
+    first = stub_vertex(1)
+    second = stub_vertex(2)
+
+    graph.add_vertex(first)
+    graph.add_vertex(second)
+    graph.add_vertex(first)
+
+    expect(graph.resource_priority(first)).to be < graph.resource_priority(second)
+  end
+
+  it "forgets the priority of a removed resource" do
+    vertex = stub_vertex(1)
+
+    graph.add_vertex(vertex)
+    graph.remove_vertex!(vertex)
+
+    expect(graph.resource_priority(vertex)).to be_nil
+  end
+
+  it "does not give two resources the same priority" do
+    first = stub_vertex(1)
+    second = stub_vertex(2)
+    third = stub_vertex(3)
+
+    graph.add_vertex(first)
+    graph.add_vertex(second)
+    graph.remove_vertex!(first)
+    graph.add_vertex(third)
+
+    expect(graph.resource_priority(second)).to be < graph.resource_priority(third)
+  end
+
+  context "order of traversal" do
+    it "traverses independent resources in the order they are added" do
+      relationships = compile_to_relationship_graph(<<-MANIFEST)
+        notify { "first": }
+        notify { "second": }
+        notify { "third": }
+        notify { "fourth": }
+        notify { "fifth": }
+      MANIFEST
+
+      expect(order_resources_traversed_in(relationships)).to(
+        include_in_order("Notify[first]",
+                         "Notify[second]",
+                         "Notify[third]",
+                         "Notify[fourth]",
+                         "Notify[fifth]"))
+    end
+
+    it "traverses resources generated during catalog creation in the order inserted" do
+      relationships = compile_to_relationship_graph(<<-MANIFEST)
+        create_resources(notify, { "first" => {} })
+        create_resources(notify, { "second" => {} })
+        notify{ "third": }
+        create_resources(notify, { "fourth" => {} })
+        create_resources(notify, { "fifth" => {} })
+      MANIFEST
+
+      expect(order_resources_traversed_in(relationships)).to(
+        include_in_order("Notify[first]",
+                         "Notify[second]",
+                         "Notify[third]",
+                         "Notify[fourth]",
+                         "Notify[fifth]"))
+    end
+
+    it "traverses all independent resources before traversing dependent ones" do
+      relationships = compile_to_relationship_graph(<<-MANIFEST)
+        notify { "first": require => Notify[third] }
+        notify { "second": }
+        notify { "third": }
+      MANIFEST
+
+      expect(order_resources_traversed_in(relationships)).to(
+        include_in_order("Notify[second]", "Notify[third]", "Notify[first]"))
+    end
+
+    it "traverses all independent resources before traversing dependent ones (with a backwards require)" do
+      relationships = compile_to_relationship_graph(<<-MANIFEST)
+        notify { "first": }
+        notify { "second": }
+        notify { "third": require => Notify[second] }
+        notify { "fourth": }
+      MANIFEST
+
+      expect(order_resources_traversed_in(relationships)).to(
+        include_in_order("Notify[first]", "Notify[second]", "Notify[third]", "Notify[fourth]"))
+    end
+
+    it "traverses resources in classes in the order they are added" do
+      relationships = compile_to_relationship_graph(<<-MANIFEST)
+        class c1 {
+            notify { "a": }
+            notify { "b": }
+        }
+        class c2 {
+            notify { "c": require => Notify[b] }
+        }
+        class c3 {
+            notify { "d": }
+        }
+        include c2
+        include c1
+        include c3
+      MANIFEST
+
+      expect(order_resources_traversed_in(relationships)).to(
+        include_in_order("Notify[a]", "Notify[b]", "Notify[c]", "Notify[d]"))
+    end
+
+    it "traverses resources in defines in the order they are added" do
+      relationships = compile_to_relationship_graph(<<-MANIFEST)
+        define d1() {
+          notify { "a": }
+          notify { "b": }
+        }
+        define d2() {
+          notify { "c": require => Notify[b]}
+        }
+        define d3() {
+            notify { "d": }
+        }
+        d2 { "c": }
+        d1 { "d": }
+        d3 { "e": }
+      MANIFEST
+
+      expect(order_resources_traversed_in(relationships)).to(
+        include_in_order("Notify[a]", "Notify[b]", "Notify[c]", "Notify[d]"))
+    end
+
+    def order_resources_traversed_in(relationships)
+      order_seen = []
+      relationships.traverse { |resource| order_seen << resource.ref }
+      order_seen
+    end
+  end
+
+  describe "when interrupting traversal" do
+    def collect_canceled_resources(relationships, trigger_on)
+      continue = true
+      continue_while = lambda { continue }
+
+      canceled_resources = []
+      canceled_resource_handler = lambda { |resource| canceled_resources << resource.ref }
+
+      relationships.traverse(:while => continue_while,
+                             :canceled_resource_handler => canceled_resource_handler) do |resource|
+        if resource.ref == trigger_on
+          continue = false
+        end
+      end
+
+      canceled_resources
+    end
+
+    it "enumerates the remaining resources" do
+      relationships = compile_to_relationship_graph(<<-MANIFEST)
+      notify { "a": }
+      notify { "b": }
+      notify { "c": }
+    MANIFEST
+      resources = collect_canceled_resources(relationships, 'Notify[b]')
+
+      expect(resources).to include('Notify[c]')
+    end
+
+    it "enumerates the remaining blocked resources" do
+      relationships = compile_to_relationship_graph(<<-MANIFEST)
+      notify { "a": }
+      notify { "b": }
+      notify { "c": }
+      notify { "d": require => Notify["c"] }
+    MANIFEST
+      resources = collect_canceled_resources(relationships, 'Notify[b]')
+
+      expect(resources).to include('Notify[d]')
+    end
+  end
+
+  describe "when constructing dependencies" do
+    let(:child) { make_absolute('/a/b') }
+    let(:parent) { make_absolute('/a') }
+
+    it "does not create an automatic relationship that would interfere with a manual relationship" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        file { "#{child}": }
+
+        file { "#{parent}": require => File["#{child}"] }
+      MANIFEST
+
+      relationship_graph.should enforce_order_with_edge("File[#{child}]", "File[#{parent}]")
+    end
+
+    it "creates automatic relationships defined by the type" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        file { "#{child}": }
+
+        file { "#{parent}": }
+      MANIFEST
+
+      relationship_graph.should enforce_order_with_edge("File[#{parent}]", "File[#{child}]")
+    end
+  end
+
+  describe "when reconstructing containment relationships" do
+    def admissible_sentinel_of(ref)
+      "Admissible_#{ref}"
+    end
+
+    def completed_sentinel_of(ref)
+      "Completed_#{ref}"
+    end
+
+    it "an empty container's completed sentinel should depend on its admissible sentinel" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        class a { }
+
+        include a
+      MANIFEST
+
+      relationship_graph.should enforce_order_with_edge(
+        admissible_sentinel_of("class[A]"),
+        completed_sentinel_of("class[A]"))
+    end
+
+    it "a container with children does not directly connect the completed sentinel to its admissible sentinel" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        class a { notify { "a": } }
+
+        include a
+      MANIFEST
+
+      relationship_graph.should_not enforce_order_with_edge(
+        admissible_sentinel_of("class[A]"),
+        completed_sentinel_of("class[A]"))
+    end
+
+    it "all contained objects should depend on their container's admissible sentinel" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        class a {
+          notify { "class a": }
+        }
+
+        include a
+      MANIFEST
+
+      relationship_graph.should enforce_order_with_edge(
+        admissible_sentinel_of("class[A]"),
+        "Notify[class a]")
+    end
+
+    it "completed sentinels should depend on their container's contents" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        class a {
+          notify { "class a": }
+        }
+
+        include a
+      MANIFEST
+
+      relationship_graph.should enforce_order_with_edge(
+          "Notify[class a]",
+          completed_sentinel_of("class[A]"))
+    end
+
+    it "should remove all Component objects from the dependency graph" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        class a {
+          notify { "class a": }
+        }
+        define b() {
+          notify { "define b": }
+        }
+
+        include a
+        b { "testing": }
+      MANIFEST
+
+      relationship_graph.vertices.find_all { |v| v.is_a?(Puppet::Type.type(:component)) }.should be_empty
+    end
+
+    it "should remove all Stage resources from the dependency graph" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        notify { "class a": }
+      MANIFEST
+
+      relationship_graph.vertices.find_all { |v| v.is_a?(Puppet::Type.type(:stage)) }.should be_empty
+    end
+
+    it "should retain labels on non-containment edges" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        class a {
+          notify { "class a": }
+        }
+        define b() {
+          notify { "define b": }
+        }
+
+        include a
+        Class[a] ~> b { "testing": }
+      MANIFEST
+
+      relationship_graph.edges_between(
+        vertex_called(relationship_graph, completed_sentinel_of("class[A]")),
+        vertex_called(relationship_graph, admissible_sentinel_of("b[testing]")))[0].label.
+        should == {:callback => :refresh, :event => :ALL_EVENTS}
+    end
+
+    it "should not add labels to edges that have none" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        class a {
+          notify { "class a": }
+        }
+        define b() {
+          notify { "define b": }
+        }
+
+        include a
+        Class[a] -> b { "testing": }
+      MANIFEST
+
+      relationship_graph.edges_between(
+        vertex_called(relationship_graph, completed_sentinel_of("class[A]")),
+        vertex_called(relationship_graph, admissible_sentinel_of("b[testing]")))[0].label.
+        should be_empty
+    end
+
+    it "should copy notification labels to all created edges" do
+      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
+        class a {
+          notify { "class a": }
+        }
+        define b() {
+          notify { "define b": }
+        }
+
+        include a
+        Class[a] ~> b { "testing": }
+      MANIFEST
+
+      relationship_graph.edges_between(
+        vertex_called(relationship_graph, admissible_sentinel_of("b[testing]")),
+        vertex_called(relationship_graph, "Notify[define b]"))[0].label.
+        should == {:callback => :refresh, :event => :ALL_EVENTS}
+    end
+  end
+
+  def vertex_called(graph, name)
+    graph.vertices.find { |v| v.ref =~ /#{Regexp.escape(name)}/ }
+  end
+
+  def stub_vertex(name)
+    stub "vertex #{name}", :ref => name
+  end
+end