puppet 7.30.0-universal-darwin → 8.0.1-universal-darwin

data/spec/unit/resource/catalog_spec.rb

@@ -0,0 +1,1160 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'matchers/json'
+
+describe Puppet::Resource::Catalog, "when compiling" do
+  include JSONMatchers
+  include PuppetSpec::Files
+
+  before do
+    @basepath = make_absolute("/somepath")
+    # stub this to not try to create state.yaml
+    allow(Puppet::Util::Storage).to receive(:store)
+  end
+
+  it "should support json, dot, yaml" do
+    # msgpack and pson are optional, so using include instead of eq
+    expect(Puppet::Resource::Catalog.supported_formats).to include(:json, :dot, :yaml)
+  end
+
+  # audit only resources are unmanaged
+  # as are resources without properties with should values
+  it "should write its managed resources' types, namevars" do
+    catalog = Puppet::Resource::Catalog.new("host")
+
+    resourcefile = tmpfile('resourcefile')
+    Puppet[:resourcefile] = resourcefile
+
+    res = Puppet::Type.type('file').new(:title => File.expand_path('/tmp/sam'), :ensure => 'present')
+    res.file = 'site.pp'
+    res.line = 21
+
+    res2 = Puppet::Type.type('exec').new(:title => 'bob', :command => "#{File.expand_path('/bin/rm')} -rf /")
+    res2.file = File.expand_path('/modules/bob/manifests/bob.pp')
+    res2.line = 42
+
+    res3 = Puppet::Type.type('file').new(:title => File.expand_path('/tmp/susan'), :audit => 'all')
+    res3.file = 'site.pp'
+    res3.line = 63
+
+    res4 = Puppet::Type.type('file').new(:title => File.expand_path('/tmp/lilly'))
+    res4.file = 'site.pp'
+    res4.line = 84
+
+    comp_res = Puppet::Type.type('component').new(:title => 'Class[Main]')
+
+    catalog.add_resource(res, res2, res3, res4, comp_res)
+    catalog.write_resource_file
+    expect(File.readlines(resourcefile).map(&:chomp)).to match_array([
+      "file[#{res.title.downcase}]",
+      "exec[#{res2.title.downcase}]"
+    ])
+  end
+
+  it "should log an error if unable to write to the resource file" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    Puppet[:resourcefile] = File.expand_path('/not/writable/file')
+
+    catalog.add_resource(Puppet::Type.type('file').new(:title => File.expand_path('/tmp/foo')))
+    catalog.write_resource_file
+    expect(@logs.size).to eq(1)
+    expect(@logs.first.message).to match(/Could not create resource file/)
+    expect(@logs.first.level).to eq(:err)
+  end
+
+  it "should be able to write its list of classes to the class file" do
+    @catalog = Puppet::Resource::Catalog.new("host")
+
+    @catalog.add_class "foo", "bar"
+
+    Puppet[:classfile] = File.expand_path("/class/file")
+
+    fh = double('filehandle')
+    classfile = Puppet.settings.setting(:classfile)
+    expect(Puppet::FileSystem).to receive(:open).with(classfile.value, classfile.mode.to_i(8), "w:UTF-8").and_yield(fh)
+
+    expect(fh).to receive(:puts).with("foo\nbar")
+
+    @catalog.write_class_file
+  end
+
+  it "should have a client_version attribute" do
+    @catalog = Puppet::Resource::Catalog.new("host")
+    @catalog.client_version = 5
+    expect(@catalog.client_version).to eq(5)
+  end
+
+  it "should have a server_version attribute" do
+    @catalog = Puppet::Resource::Catalog.new("host")
+    @catalog.server_version = 5
+    expect(@catalog.server_version).to eq(5)
+  end
+
+  it "defaults code_id to nil" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.code_id).to be_nil
+  end
+
+  it "should include a catalog_uuid" do
+    allow(SecureRandom).to receive(:uuid).and_return("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.catalog_uuid).to eq("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+  end
+
+  it "should include the current catalog_format" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.catalog_format).to eq(2)
+  end
+
+  describe "when compiling" do
+    it "should accept tags" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      config.tag("one")
+      expect(config).to be_tagged("one")
+    end
+
+    it "should accept multiple tags at once" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      config.tag("one", "two")
+      expect(config).to be_tagged("one")
+      expect(config).to be_tagged("two")
+    end
+
+    it "should convert all tags to strings" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      config.tag("one", :two)
+      expect(config).to be_tagged("one")
+      expect(config).to be_tagged("two")
+    end
+
+    it "should tag with both the qualified name and the split name" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      config.tag("one::two")
+      expect(config).to be_tagged("one")
+      expect(config).to be_tagged("one::two")
+    end
+
+    it "should accept classes" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      config.add_class("one")
+      expect(config.classes).to eq(%w{one})
+      config.add_class("two", "three")
+      expect(config.classes).to eq(%w{one two three})
+    end
+
+    it "should tag itself with passed class names" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      config.add_class("one")
+      expect(config).to be_tagged("one")
+    end
+
+    it "handles resource titles with brackets" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      expect(config.title_key_for_ref("Notify[[foo]bar]")).to eql(["Notify", "[foo]bar"])
+    end
+  end
+
+  describe "when converting to a RAL catalog" do
+    before do
+      @original = Puppet::Resource::Catalog.new("mynode")
+      @original.tag(*%w{one two three})
+      @original.add_class(*%w{four five six})
+
+      @top            = Puppet::Resource.new :class, 'top'
+      @topobject      = Puppet::Resource.new :file, @basepath+'/topobject'
+      @middle         = Puppet::Resource.new :class, 'middle'
+      @middleobject   = Puppet::Resource.new :file, @basepath+'/middleobject'
+      @bottom         = Puppet::Resource.new :class, 'bottom'
+      @bottomobject   = Puppet::Resource.new :file, @basepath+'/bottomobject'
+
+      @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
+
+      @original.add_resource(*@resources)
+
+      @original.add_edge(@top, @topobject)
+      @original.add_edge(@top, @middle)
+      @original.add_edge(@middle, @middleobject)
+      @original.add_edge(@middle, @bottom)
+      @original.add_edge(@bottom, @bottomobject)
+
+      @original.catalog_format = 1
+      @catalog = @original.to_ral
+    end
+
+    it "should add all resources as RAL instances" do
+      @resources.each do |resource|
+        # Warning: a failure here will result in "global resource iteration is
+        # deprecated" being raised, because the rspec rendering to get the
+        # result tries to call `each` on the resource, and that raises.
+        expect(@catalog.resource(resource.ref)).to be_a_kind_of(Puppet::Type)
+      end
+    end
+
+    it "should raise if an unknown resource is being converted" do
+      @new_res = Puppet::Resource.new "Unknown", "type", :kind => 'compilable_type'
+      @resource_array = [@new_res]
+
+      @original.add_resource(*@resource_array)
+      @original.add_edge(@bottomobject, @new_res)
+
+      @original.catalog_format = 2
+
+      expect { @original.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
+    end
+
+    it "should copy the tag list to the new catalog" do
+      expect(@catalog.tags.sort).to eq(@original.tags.sort)
+    end
+
+    it "should copy the class list to the new catalog" do
+      expect(@catalog.classes).to eq(@original.classes)
+    end
+
+    it "should duplicate the original edges" do
+      @original.edges.each do |edge|
+        expect(@catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref))).to be_truthy
+      end
+    end
+
+    it "should set itself as the catalog for each converted resource" do
+      @catalog.vertices.each { |v| expect(v.catalog.object_id).to eql(@catalog.object_id) }
+    end
+
+    # This tests #931.
+    it "should not lose track of resources whose names vary" do
+      changer = Puppet::Resource.new :file, @basepath+'/test/', :parameters => {:ensure => :directory}
+
+      config = Puppet::Resource::Catalog.new('test')
+      config.add_resource(changer)
+      config.add_resource(@top)
+
+      config.add_edge(@top, changer)
+
+      catalog = config.to_ral
+      expect(catalog.resource("File[#{@basepath}/test/]")).to equal(catalog.resource("File[#{@basepath}/test]"))
+    end
+
+    after do
+      # Remove all resource instances.
+      @catalog.clear(true)
+    end
+  end
+
+  describe "when filtering" do
+    before :each do
+      @original = Puppet::Resource::Catalog.new("mynode")
+      @original.tag(*%w{one two three})
+      @original.add_class(*%w{four five six})
+
+      @r1 = double(
+        'r1',
+        :ref      => "File[/a]",
+        :[]       => nil,
+        :virtual  => nil,
+        :catalog= => nil,
+      )
+      allow(@r1).to receive(:respond_to?)
+      allow(@r1).to receive(:respond_to?).with(:ref).and_return(true)
+      allow(@r1).to receive(:copy_as_resource).and_return(@r1)
+      allow(@r1).to receive(:is_a?).with(Puppet::Resource).and_return(true)
+
+      @r2 = double(
+        'r2',
+        :ref      => "File[/b]",
+        :[]       => nil,
+        :virtual  => nil,
+        :catalog= => nil,
+      )
+      allow(@r2).to receive(:respond_to?)
+      allow(@r2).to receive(:respond_to?).with(:ref).and_return(true)
+      allow(@r2).to receive(:copy_as_resource).and_return(@r2)
+      allow(@r2).to receive(:is_a?).with(Puppet::Resource).and_return(true)
+
+      @resources = [@r1,@r2]
+
+      @original.add_resource(@r1,@r2)
+    end
+
+    it "should transform the catalog to a resource catalog" do
+      expect(@original).to receive(:to_catalog).with(:to_resource)
+
+      @original.filter
+    end
+
+    it "should scan each catalog resource in turn and apply filtering block" do
+      @resources.each { |r| expect(r).to receive(:test?) }
+      @original.filter do |r|
+        r.test?
+      end
+    end
+
+    it "should filter out resources which produce true when the filter block is evaluated" do
+      expect(@original.filter do |r|
+        r == @r1
+      end.resource("File[/a]")).to be_nil
+    end
+
+    it "should not consider edges against resources that were filtered out" do
+      @original.add_edge(@r1,@r2)
+      expect(@original.filter do |r|
+        r == @r1
+      end.edge?(@r1,@r2)).not_to be
+    end
+
+    it "copies the version" do
+      @original.version = '123'
+      expect(@original.filter.version).to eq(@original.version)
+    end
+
+    it 'copies the code_id' do
+      @original.code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      expect(@original.filter.code_id).to eq(@original.code_id)
+    end
+
+    it 'copies the catalog_uuid' do
+      @original.catalog_uuid = '827a74c8-cf98-44da-9ff7-18c5e4bee41e'
+      expect(@original.filter.catalog_uuid).to eq(@original.catalog_uuid)
+    end
+
+    it 'copies the catalog_format' do
+      @original.catalog_format = 42
+      expect(@original.filter.catalog_format).to eq(@original.catalog_format)
+    end
+  end
+
+  describe "when functioning as a resource container" do
+    before do
+      @catalog = Puppet::Resource::Catalog.new("host")
+      @one = Puppet::Type.type(:notify).new :name => "one"
+      @two = Puppet::Type.type(:notify).new :name => "two"
+      @three = Puppet::Type.type(:notify).new :name => "three"
+      @dupe = Puppet::Type.type(:notify).new :name => "one"
+    end
+
+    it "should provide a method to add one or more resources" do
+      @catalog.add_resource @one, @two
+      expect(@catalog.resource(@one.ref)).to equal(@one)
+      expect(@catalog.resource(@two.ref)).to equal(@two)
+    end
+
+    it "should add resources to the relationship graph if it exists" do
+      relgraph = @catalog.relationship_graph
+
+      @catalog.add_resource @one
+
+      expect(relgraph).to be_vertex(@one)
+    end
+
+    it "should set itself as the resource's catalog if it is not a relationship graph" do
+      expect(@one).to receive(:catalog=).with(@catalog)
+      @catalog.add_resource @one
+    end
+
+    it "should make all vertices available by resource reference" do
+      @catalog.add_resource(@one)
+      expect(@catalog.resource(@one.ref)).to equal(@one)
+      expect(@catalog.vertices.find { |r| r.ref == @one.ref }).to equal(@one)
+    end
+
+    it "tracks the container through edges" do
+      @catalog.add_resource(@two)
+      @catalog.add_resource(@one)
+
+      @catalog.add_edge(@one, @two)
+
+      expect(@catalog.container_of(@two)).to eq(@one)
+    end
+
+    it "a resource without a container is contained in nil" do
+      @catalog.add_resource(@one)
+
+      expect(@catalog.container_of(@one)).to be_nil
+    end
+
+    it "should canonize how resources are referred to during retrieval when both type and title are provided" do
+      @catalog.add_resource(@one)
+      expect(@catalog.resource("notify", "one")).to equal(@one)
+    end
+
+    it "should canonize how resources are referred to during retrieval when just the title is provided" do
+      @catalog.add_resource(@one)
+      expect(@catalog.resource("notify[one]", nil)).to equal(@one)
+    end
+
+    it "adds resources before an existing resource" do
+      @catalog.add_resource(@one)
+      @catalog.add_resource_before(@one, @two, @three)
+
+      expect(@catalog.resources).to eq([@two, @three, @one])
+    end
+
+    it "raises if adding a resource before a resource not in the catalog" do
+      expect {
+        @catalog.add_resource_before(@one, @two)
+      }.to raise_error(ArgumentError, "Cannot add resource Notify[two] before Notify[one] because Notify[one] is not yet in the catalog")
+    end
+
+    it "adds resources after an existing resource in reverse order" do
+      @catalog.add_resource(@one)
+      @catalog.add_resource_after(@one, @two, @three)
+
+      expect(@catalog.resources).to eq([@one, @three, @two])
+    end
+
+    it "raises if adding a resource after a resource not in the catalog" do
+      expect {
+        @catalog.add_resource_after(@one, @two)
+      }.to raise_error(ArgumentError, "Cannot add resource Notify[two] after Notify[one] because Notify[one] is not yet in the catalog")
+    end
+
+    describe 'with a duplicate resource' do
+      def resource_at(type, name, file, line)
+        resource = Puppet::Resource.new(type, name)
+        resource.file = file
+        resource.line = line
+
+        Puppet::Type.type(type).new(resource)
+      end
+
+      let(:orig) { resource_at(:notify, 'duplicate-title', '/path/to/orig/file', 42) }
+      let(:dupe) { resource_at(:notify, 'duplicate-title', '/path/to/dupe/file', 314) }
+
+      it "should print the locations of the original duplicated resource" do
+        @catalog.add_resource(orig)
+
+        expect { @catalog.add_resource(dupe) }.to raise_error { |error|
+          expect(error).to be_a Puppet::Resource::Catalog::DuplicateResourceError
+
+          expect(error.message).to match %r[Duplicate declaration: Notify\[duplicate-title\] is already declared]
+          expect(error.message).to match %r[at \(file: /path/to/orig/file, line: 42\)]
+          expect(error.message).to match %r[cannot redeclare]
+          expect(error.message).to match %r[\(file: /path/to/dupe/file, line: 314\)]
+        }
+      end
+    end
+
+    it "should remove all resources when asked" do
+      @catalog.add_resource @one
+      @catalog.add_resource @two
+      expect(@one).to receive(:remove)
+      expect(@two).to receive(:remove)
+      @catalog.clear(true)
+    end
+
+    it "should support a mechanism for finishing resources" do
+      expect(@one).to receive(:finish)
+      expect(@two).to receive(:finish)
+      @catalog.add_resource @one
+      @catalog.add_resource @two
+
+      @catalog.finalize
+    end
+
+    it "should make default resources when finalizing" do
+      expect(@catalog).to receive(:make_default_resources)
+      @catalog.finalize
+    end
+
+    it "should add default resources to the catalog upon creation" do
+      @catalog.make_default_resources
+      expect(@catalog.resource(:schedule, "daily")).not_to be_nil
+    end
+
+    it "should optionally support an initialization block and should finalize after such blocks" do
+      expect(@one).to receive(:finish)
+      expect(@two).to receive(:finish)
+      Puppet::Resource::Catalog.new("host") do |conf|
+        conf.add_resource @one
+        conf.add_resource @two
+      end
+    end
+
+    it "should inform the resource that it is the resource's catalog" do
+      expect(@one).to receive(:catalog=).with(@catalog)
+      @catalog.add_resource @one
+    end
+
+    it "should be able to find resources by reference" do
+      @catalog.add_resource @one
+      expect(@catalog.resource(@one.ref)).to equal(@one)
+    end
+
+    it "should be able to find resources by reference or by type/title tuple" do
+      @catalog.add_resource @one
+      expect(@catalog.resource("notify", "one")).to equal(@one)
+    end
+
+    it "should have a mechanism for removing resources" do
+      @catalog.add_resource(@one)
+      expect(@catalog.resource(@one.ref)).to be
+      expect(@catalog.vertex?(@one)).to be_truthy
+
+      @catalog.remove_resource(@one)
+      expect(@catalog.resource(@one.ref)).to be_nil
+      expect(@catalog.vertex?(@one)).to be_falsey
+    end
+
+    it "should have a method for creating aliases for resources" do
+      @catalog.add_resource @one
+      @catalog.alias(@one, "other")
+      expect(@catalog.resource("notify", "other")).to equal(@one)
+    end
+
+    it "should ignore conflicting aliases that point to the aliased resource" do
+      @catalog.alias(@one, "other")
+      expect { @catalog.alias(@one, "other") }.not_to raise_error
+    end
+
+    it "should create aliases for isomorphic resources whose names do not match their titles" do
+      resource = Puppet::Type::File.new(:title => "testing", :path => @basepath+"/something")
+
+      @catalog.add_resource(resource)
+
+      expect(@catalog.resource(:file, @basepath+"/something")).to equal(resource)
+    end
+
+    it "should not create aliases for non-isomorphic resources whose names do not match their titles" do
+      resource = Puppet::Type.type(:exec).new(:title => "testing", :command => "echo", :path => %w{/bin /usr/bin /usr/local/bin})
+
+      @catalog.add_resource(resource)
+
+      # Yay, I've already got a 'should' method
+      expect(@catalog.resource(:exec, "echo").object_id).to eq(nil.object_id)
+    end
+
+    # This test is the same as the previous, but the behaviour should be explicit.
+    it "should alias using the class name from the resource reference, not the resource class name" do
+      @catalog.add_resource @one
+      @catalog.alias(@one, "other")
+      expect(@catalog.resource("notify", "other")).to equal(@one)
+    end
+
+    it "should fail to add an alias if the aliased name already exists" do
+      @catalog.add_resource @one
+      expect { @catalog.alias @two, "one" }.to raise_error(ArgumentError)
+    end
+
+    it "should not fail when a resource has duplicate aliases created" do
+      @catalog.add_resource @one
+      expect { @catalog.alias @one, "one" }.not_to raise_error
+    end
+
+    it "should not create aliases that point back to the resource" do
+      @catalog.alias(@one, "one")
+      expect(@catalog.resource(:notify, "one")).to be_nil
+    end
+
+    it "should be able to look resources up by their aliases" do
+      @catalog.add_resource @one
+      @catalog.alias @one, "two"
+      expect(@catalog.resource(:notify, "two")).to equal(@one)
+    end
+
+    it "should remove resource aliases when the target resource is removed" do
+      @catalog.add_resource @one
+      @catalog.alias(@one, "other")
+      expect(@one).to receive(:remove)
+      @catalog.remove_resource(@one)
+      expect(@catalog.resource("notify", "other")).to be_nil
+    end
+
+    it "should add an alias for the namevar when the title and name differ on isomorphic resource types" do
+      resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
+      expect(resource).to receive(:isomorphic?).and_return(true)
+      @catalog.add_resource(resource)
+      expect(@catalog.resource(:file, "other")).to equal(resource)
+      expect(@catalog.resource(:file, @basepath+"/something").ref).to eq(resource.ref)
+    end
+
+    it "should not add an alias for the namevar when the title and name differ on non-isomorphic resource types" do
+      resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
+      expect(resource).to receive(:isomorphic?).and_return(false)
+      @catalog.add_resource(resource)
+      expect(@catalog.resource(:file, resource.title)).to equal(resource)
+      # We can't use .should here, because the resources respond to that method.
+      raise "Aliased non-isomorphic resource" if @catalog.resource(:file, resource.name)
+    end
+
+    it "should provide a method to create additional resources that also registers the resource" do
+      args = {:name => "/yay", :ensure => :file}
+      resource = double('file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay")
+      expect(Puppet::Type.type(:file)).to receive(:new).with(args).and_return(resource)
+      @catalog.create_resource :file, args
+      expect(@catalog.resource("File[/yay]")).to equal(resource)
+    end
+
+    describe "when adding resources with multiple namevars" do
+      before :each do
+        Puppet::Type.newtype(:multiple) do
+          newparam(:color, :namevar => true)
+          newparam(:designation, :namevar => true)
+
+          def self.title_patterns
+            [ [
+                /^(\w+) (\w+)$/,
+                [
+                  [:color,  lambda{|x| x}],
+                  [:designation, lambda{|x| x}]
+                ]
+            ] ]
+          end
+        end
+      end
+
+      it "should add an alias using the uniqueness key" do
+        @resource = Puppet::Type.type(:multiple).new(:title => "some resource", :color => "red", :designation => "5")
+
+        @catalog.add_resource(@resource)
+        expect(@catalog.resource(:multiple, "some resource")).to eq(@resource)
+        expect(@catalog.resource("Multiple[some resource]")).to eq(@resource)
+        expect(@catalog.resource("Multiple[red 5]")).to eq(@resource)
+      end
+
+      it "should conflict with a resource with the same uniqueness key" do
+        @resource = Puppet::Type.type(:multiple).new(:title => "some resource", :color => "red", :designation => "5")
+        @other    = Puppet::Type.type(:multiple).new(:title => "another resource", :color => "red", :designation => "5")
+
+        @catalog.add_resource(@resource)
+        expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias Multiple\[another resource\] to \["red", "5"\].*resource \["Multiple", "red", "5"\] already declared/)
+      end
+
+      it "should conflict when its uniqueness key matches another resource's title" do
+        path = make_absolute("/tmp/foo")
+        @resource = Puppet::Type.type(:file).new(:title => path)
+        @other    = Puppet::Type.type(:file).new(:title => "another file", :path => path)
+
+        @catalog.add_resource(@resource)
+        expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias File\[another file\] to \["#{Regexp.escape(path)}"\].*resource \["File", "#{Regexp.escape(path)}"\] already declared/)
+      end
+
+      it "should conflict when its uniqueness key matches the uniqueness key derived from another resource's title" do
+        @resource = Puppet::Type.type(:multiple).new(:title => "red leader")
+        @other    = Puppet::Type.type(:multiple).new(:title => "another resource", :color => "red", :designation => "leader")
+
+        @catalog.add_resource(@resource)
+        expect { @catalog.add_resource(@other) }.to raise_error(ArgumentError, /Cannot alias Multiple\[another resource\] to \["red", "leader"\].*resource \["Multiple", "red", "leader"\] already declared/)
+      end
+    end
+  end
+
+  describe "when applying" do
+    before :each do
+      @catalog = Puppet::Resource::Catalog.new("host")
+
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
+      allow(Puppet::Transaction).to receive(:new).and_return(@transaction)
+      allow(@transaction).to receive(:evaluate)
+      allow(@transaction).to receive(:for_network_device=)
+
+      allow(Puppet.settings).to receive(:use)
+    end
+
+    it "should create and evaluate a transaction" do
+      expect(@transaction).to receive(:evaluate)
+      @catalog.apply
+    end
+
+    it "should add a transaction evalution time to the report" do
+      expect(@transaction.report).to receive(:add_times).with(:transaction_evaluation, kind_of(Numeric))
+      @catalog.apply
+    end
+
+    it "should return the transaction" do
+      expect(@catalog.apply).to equal(@transaction)
+    end
+
+    it "should yield the transaction if a block is provided" do
+      @catalog.apply do |trans|
+        expect(trans).to equal(@transaction)
+      end
+    end
+
+    it "should default to being a host catalog" do
+      expect(@catalog.host_config).to be_truthy
+    end
+
+    it "should be able to be set to a non-host_config" do
+      @catalog.host_config = false
+      expect(@catalog.host_config).to be_falsey
+    end
+
+    it "should pass supplied tags on to the transaction" do
+      expect(@transaction).to receive(:tags=).with(%w{one two})
+      @catalog.apply(:tags => %w{one two})
+    end
+
+    it "should set ignoreschedules on the transaction if specified in apply()" do
+      expect(@transaction).to receive(:ignoreschedules=).with(true)
+      @catalog.apply(:ignoreschedules => true)
+    end
+
+    it "should detect transaction failure and report it" do
+      allow(@transaction).to receive(:evaluate).and_raise(RuntimeError, 'transaction failed.')
+      report = Puppet::Transaction::Report.new('apply')
+
+      expect { @catalog.apply(:report => report) }.to raise_error(RuntimeError)
+      report.finalize_report
+
+      expect(report.status).to eq('failed')
+    end
+
+    describe "host catalogs" do
+      # super() doesn't work in the setup method for some reason
+      before do
+        @catalog.host_config = true
+        allow(Puppet::Util::Storage).to receive(:store)
+      end
+
+      it "should initialize the state database before applying a catalog" do
+        expect(Puppet::Util::Storage).to receive(:load)
+
+        # Short-circuit the apply, so we know we're loading before the transaction
+        expect(Puppet::Transaction).to receive(:new).and_raise(ArgumentError)
+        expect { @catalog.apply }.to raise_error(ArgumentError)
+      end
+
+      it "should sync the state database after applying" do
+        expect(Puppet::Util::Storage).to receive(:store)
+        allow(@transaction).to receive(:any_failed?).and_return(false)
+        @catalog.apply
+      end
+    end
+
+    describe "non-host catalogs" do
+      before do
+        @catalog.host_config = false
+      end
+
+      it "should never send reports" do
+        Puppet[:report] = true
+        Puppet[:summarize] = true
+        @catalog.apply
+      end
+
+      it "should never modify the state database" do
+        expect(Puppet::Util::Storage).not_to receive(:load)
+        expect(Puppet::Util::Storage).not_to receive(:store)
+        @catalog.apply
+      end
+    end
+  end
+
+  describe "when creating a relationship graph" do
+    before do
+      @catalog = Puppet::Resource::Catalog.new("host")
+    end
+
+    it "should get removed when the catalog is cleaned up" do
+      expect(@catalog.relationship_graph).to receive(:clear)
+
+      @catalog.clear
+
+      expect(@catalog.instance_variable_get("@relationship_graph")).to be_nil
+    end
+  end
+
+  describe "when writing dot files" do
+    before do
+      @catalog = Puppet::Resource::Catalog.new("host")
+      @name = :test
+      @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
+    end
+
+    it "should only write when it is a host catalog" do
+      expect(Puppet::FileSystem).not_to receive(:open).with(@file, 0640, "w:UTF-8")
+      @catalog.host_config = false
+      Puppet[:graph] = true
+      @catalog.write_graph(@name)
+    end
+  end
+
+  describe "when indirecting" do
+    before do
+      @real_indirection = Puppet::Resource::Catalog.indirection
+
+      @indirection = double('indirection', :name => :catalog)
+    end
+
+    it "should use the value of the 'catalog_terminus' setting to determine its terminus class" do
+      # Puppet only checks the terminus setting the first time you ask
+      # so this returns the object to the clean state
+      # at the expense of making this test less pure
+      Puppet::Resource::Catalog.indirection.reset_terminus_class
+
+      Puppet.settings[:catalog_terminus] = "rest"
+      expect(Puppet::Resource::Catalog.indirection.terminus_class).to eq(:rest)
+    end
+
+    it "should allow the terminus class to be set manually" do
+      Puppet::Resource::Catalog.indirection.terminus_class = :rest
+      expect(Puppet::Resource::Catalog.indirection.terminus_class).to eq(:rest)
+    end
+
+    after do
+      @real_indirection.reset_terminus_class
+    end
+  end
+
+  describe "when converting to yaml" do
+    before do
+      @catalog = Puppet::Resource::Catalog.new("me")
+      @catalog.add_edge("one", "two")
+    end
+
+    it "should be able to be dumped to yaml" do
+      expect(YAML.dump(@catalog)).to be_instance_of(String)
+    end
+  end
+
+  describe "when converting from yaml" do
+    before do
+      @catalog = Puppet::Resource::Catalog.new("me")
+      @catalog.add_edge("one", "two")
+
+      text = YAML.dump(@catalog)
+      @newcatalog = Puppet::Util::Yaml.safe_load(text, [Puppet::Resource::Catalog])
+    end
+
+    it "should get converted back to a catalog" do
+      expect(@newcatalog).to be_instance_of(Puppet::Resource::Catalog)
+    end
+
+    it "should have all vertices" do
+      expect(@newcatalog.vertex?("one")).to be_truthy
+      expect(@newcatalog.vertex?("two")).to be_truthy
+    end
+
+    it "should have all edges" do
+      expect(@newcatalog.edge?("one", "two")).to be_truthy
+    end
+  end
+end
+
+describe Puppet::Resource::Catalog, "when converting a resource catalog to json" do
+  include JSONMatchers
+  include PuppetSpec::Compiler
+
+  it "should validate an empty catalog against the schema" do
+    empty_catalog = compile_to_catalog("")
+    expect(empty_catalog.to_json).to validate_against('api/schemas/catalog.json')
+  end
+
+  it "should validate a noop catalog against the schema" do
+    noop_catalog = compile_to_catalog("create_resources('file', {})")
+    expect(noop_catalog.to_json).to validate_against('api/schemas/catalog.json')
+  end
+
+  it "should validate a single resource catalog against the schema" do
+    catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
+  end
+
+  it "should validate a virtual resource catalog against the schema" do
+    catalog = compile_to_catalog("create_resources('@file', {'/etc/foo'=>{'ensure'=>'present'}})\nrealize(File['/etc/foo'])")
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
+  end
+
+  it "should validate a single exported resource catalog against the schema" do
+    catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}})")
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
+  end
+
+  it "should validate a single sensitive parameter resource catalog against the schema" do
+    catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present','content'=>Sensitive('hunter2')}})")
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
+  end
+
+  it "should validate a two resource catalog against the schema" do
+    catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
+  end
+
+  it "should validate a two parameter class catalog against the schema" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class multi_param_class ($one, $two) {
+        notify {'foo':
+          message => "One is $one, two is $two",
+        }
+      }
+
+      class {'multi_param_class':
+        one => 'hello',
+        two => 'world',
+      }
+    MANIFEST
+    expect(catalog.to_json).to validate_against('api/schemas/catalog.json')
+  end
+
+  context 'when dealing with parameters that have non-Data values' do
+    context 'and rich_data is enabled' do
+      before(:each) do
+        Puppet.push_context(
+          :loaders => Puppet::Pops::Loaders.new(Puppet.lookup(:environments).get(Puppet[:environment])),
+          :rich_data => true)
+      end
+
+      after(:each) do
+        Puppet.pop_context
+      end
+
+      let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
+
+      it 'should generate rich value hash for parameter values that are not Data' do
+        s = catalog_w_regexp.to_json
+        expect(s).to include('"parameters":{"message":{"__ptype":"Regexp","__pvalue":"[a-z]+"}}')
+      end
+
+      it 'should read and convert rich value hash containing Regexp from json' do
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog_w_regexp.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Regexp)
+        expect(message).to eql(/[a-z]+/)
+      end
+
+      it 'should read and convert rich value hash containing Version from json' do
+        catalog = compile_to_catalog("notify {'foo': message => SemVer('1.0.0') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(SemanticPuppet::Version)
+        expect(message).to eql(SemanticPuppet::Version.parse('1.0.0'))
+      end
+
+      it 'should read and convert rich value hash containing VersionRange from json' do
+        catalog = compile_to_catalog("notify {'foo': message => SemVerRange('>=1.0.0') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(SemanticPuppet::VersionRange)
+        expect(message).to eql(SemanticPuppet::VersionRange.parse('>=1.0.0'))
+      end
+
+      it 'should read and convert rich value hash containing Timespan from json' do
+        catalog = compile_to_catalog("notify {'foo': message => Timespan(1234) }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Puppet::Pops::Time::Timespan)
+        expect(message).to eql(Puppet::Pops::Time::Timespan.parse('1234', '%S'))
+      end
+
+      it 'should read and convert rich value hash containing Timestamp from json' do
+        catalog = compile_to_catalog("notify {'foo': message => Timestamp('2016-09-15T08:32:16.123 UTC') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Puppet::Pops::Time::Timestamp)
+        expect(message).to eql(Puppet::Pops::Time::Timestamp.parse('2016-09-15T08:32:16.123 UTC'))
+      end
+
+      it 'should read and convert rich value hash containing hash with rich data from json' do
+        catalog = compile_to_catalog("notify {'foo': message => { 'version' => SemVer('1.0.0'), 'time' => Timestamp('2016-09-15T08:32:16.123 UTC') }}")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Hash)
+        expect(message['version']).to eql(SemanticPuppet::Version.parse('1.0.0'))
+        expect(message['time']).to eql(Puppet::Pops::Time::Timestamp.parse('2016-09-15T08:32:16.123 UTC'))
+      end
+
+      it 'should read and convert rich value hash containing an array with rich data from json' do
+        catalog = compile_to_catalog("notify {'foo': message => [ SemVer('1.0.0'), Timestamp('2016-09-15T08:32:16.123 UTC') ] }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Array)
+        expect(message[0]).to eql(SemanticPuppet::Version.parse('1.0.0'))
+        expect(message[1]).to eql(Puppet::Pops::Time::Timestamp.parse('2016-09-15T08:32:16.123 UTC'))
+      end
+    end
+
+    context 'and rich_data is disabled' do
+      before(:each) do
+        Puppet[:rich_data] = false 
+        Puppet[:strict] = :warning # do not want to stub out behavior in tests
+      end
+
+      let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
+
+      it 'should not generate rich value hash for parameter values that are not Data' do
+        expect(catalog_w_regexp.to_json).not_to include('"__ptype"')
+      end
+
+      it 'should convert parameter containing Regexp into strings' do
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog_w_regexp.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('/[a-z]+/')
+      end
+
+      it 'should convert parameter containing Version into string' do
+        catalog = compile_to_catalog("notify {'foo': message => SemVer('1.0.0') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('1.0.0')
+      end
+
+      it 'should convert parameter containing VersionRange into string' do
+        catalog = compile_to_catalog("notify {'foo': message => SemVerRange('>=1.0.0') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('>=1.0.0')
+      end
+
+      it 'should convert parameter containing Timespan into string' do
+        catalog = compile_to_catalog("notify {'foo': message => Timespan(1234) }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('0-00:20:34.0')
+      end
+
+      it 'should convert parameter containing Timestamp into string' do
+        catalog = compile_to_catalog("notify {'foo': message => Timestamp('2016-09-15T08:32:16.123 UTC') }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(String)
+        expect(message).to eql('2016-09-15T08:32:16.123000000 UTC')
+      end
+
+      it 'should convert param containing array with :undef entries' do
+        catalog = compile_to_catalog("notify {'foo': message => [ 10, undef, 20 ] }")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Array)
+        expect(message[0]).to eql(10)
+        expect(message[1]).to eql(nil)
+        expect(message[2]).to eql(20)
+      end
+
+      it 'should convert param containing hash with :undef entries' do
+        catalog = compile_to_catalog("notify {'foo': message => {a => undef, b => 10}}")
+        catalog2 = Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json))
+        message = catalog2.resource('notify', 'foo')['message']
+        expect(message).to be_a(Hash)
+        expect(message.has_key?('a')).to eql(true)
+        expect(message['a']).to eql(nil)
+        expect(message['b']).to eql(10)
+      end
+
+      it 'should raise an error by default when trying to convert parameter with rich data' do
+        Puppet[:strict] = :error
+        expect {
+          catalog = compile_to_catalog("notify {'foo': message => Timestamp('2016-09-15T08:32:16.123 UTC') }")
+          Puppet::Resource::Catalog.from_data_hash(JSON.parse(catalog.to_json)) 
+        }.to raise_error(/Evaluation Error: Notify\[foo\]\['message'\] contains a Puppet::Pops::Time::Timestamp value. It will be converted to the String '2016-09-15T08:32:16.123000000 UTC'/)
+      end
+    end
+  end
+end
+
+describe Puppet::Resource::Catalog, "when converting to json" do
+  before do
+    @catalog = Puppet::Resource::Catalog.new("myhost")
+  end
+
+  { :name => 'myhost',
+    :version => 42,
+    :code_id => 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe',
+    :catalog_uuid => '827a74c8-cf98-44da-9ff7-18c5e4bee41e',
+    :catalog_format => 42
+  }.each do |param, value|
+    it "emits a #{param} equal to #{value.inspect}" do
+      @catalog.send(param.to_s + "=", value)
+      json = JSON.parse(@catalog.to_json)
+
+      expect(json[param.to_s]).to eq(@catalog.send(param))
+    end
+  end
+
+  it "emits an array of classes" do
+    @catalog.add_class('foo')
+    json = JSON.parse(@catalog.to_json)
+
+    expect(json['classes']).to eq(['foo'])
+  end
+
+  it "should convert its resources to a JSON-encoded array and store it as the 'resources' data" do
+    one = double('one', :to_data_hash => "one_resource", :ref => "Foo[one]")
+    two = double('two', :to_data_hash => "two_resource", :ref => "Foo[two]")
+
+    expect(one).to receive(:'[]').with(:alias).and_return(nil)
+    expect(two).to receive(:'[]').with(:alias).and_return(nil)
+
+    @catalog.add_resource(one)
+    @catalog.add_resource(two)
+
+    # TODO this should really guarantee sort order
+    expect(JSON.parse(@catalog.to_json,:create_additions => false)['resources'].sort).to eq(["one_resource", "two_resource"].sort)
+  end
+
+  it "should convert its edges to a JSON-encoded array and store it as the 'edges' data" do
+    one   = double('one',   :to_data_hash => "one_resource",   :ref => 'Foo[one]')
+    two   = double('two',   :to_data_hash => "two_resource",   :ref => 'Foo[two]')
+    three = double('three', :to_data_hash => "three_resource", :ref => 'Foo[three]')
+
+    @catalog.add_edge(one, two)
+    @catalog.add_edge(two, three)
+
+    expect(@catalog.edges_between(one, two  )[0]).to receive(:to_data_hash).and_return("one_two_json")
+    expect(@catalog.edges_between(two, three)[0]).to receive(:to_data_hash).and_return("two_three_json")
+
+    expect(JSON.parse(@catalog.to_json,:create_additions => false)['edges'].sort).to eq(%w{one_two_json two_three_json}.sort)
+  end
+end
+
+describe Puppet::Resource::Catalog, "when converting from json" do
+  before do
+    @data = {
+      'name' => "myhost"
+    }
+  end
+
+  it 'should create it with the provided name' do
+    @data['version'] = 50
+    @data['code_id'] = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+    @data['catalog_uuid'] = '827a74c8-cf98-44da-9ff7-18c5e4bee41e'
+    @data['catalog_format'] = 42
+    @data['tags'] = %w{one two}
+    @data['classes'] = %w{one two}
+    @data['edges'] = [Puppet::Relationship.new('File[/foo]', 'File[/bar]',
+                                               :event => :one,
+                                               :callback => :refresh).to_data_hash]
+    @data['resources'] = [Puppet::Resource.new(:file, '/foo').to_data_hash,
+                          Puppet::Resource.new(:file, '/bar').to_data_hash]
+
+
+    catalog = Puppet::Resource::Catalog.from_data_hash JSON.parse @data.to_json
+
+    expect(catalog.name).to eq('myhost')
+    expect(catalog.version).to eq(@data['version'])
+    expect(catalog.code_id).to eq(@data['code_id'])
+    expect(catalog.catalog_uuid).to eq(@data['catalog_uuid'])
+    expect(catalog.catalog_format).to eq(@data['catalog_format'])
+    expect(catalog).to be_tagged('one')
+    expect(catalog).to be_tagged('two')
+
+    expect(catalog.classes).to eq(@data['classes'])
+    expect(catalog.resources.collect(&:ref)).to eq(['File[/foo]', 'File[/bar]'])
+
+    expect(catalog.edges.collect(&:event)).to eq([:one])
+    expect(catalog.edges[0].source).to eq(catalog.resource(:file, '/foo'))
+    expect(catalog.edges[0].target).to eq(catalog.resource(:file, '/bar'))
+  end
+
+  it "defaults the catalog_format to 0" do
+    catalog = Puppet::Resource::Catalog.from_data_hash JSON.parse @data.to_json
+    expect(catalog.catalog_format).to eq(0)
+  end
+
+  it "should fail if the source resource cannot be found" do
+    @data['edges'] = [Puppet::Relationship.new("File[/missing]", "File[/bar]").to_data_hash]
+    @data['resources'] = [Puppet::Resource.new(:file, "/bar").to_data_hash]
+
+    expect { Puppet::Resource::Catalog.from_data_hash JSON.parse @data.to_json }.to raise_error(ArgumentError, /Could not find relationship source/)
+  end
+
+  it "should fail if the target resource cannot be found" do
+    @data['edges'] = [Puppet::Relationship.new("File[/bar]", "File[/missing]").to_data_hash]
+    @data['resources'] = [Puppet::Resource.new(:file, "/bar").to_data_hash]
+
+    expect { Puppet::Resource::Catalog.from_data_hash JSON.parse @data.to_json }.to raise_error(ArgumentError, /Could not find relationship target/)
+  end
+end