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, pson, dot, yaml" do
    # msgpack is optional, so using include instead of eq
    expect(Puppet::Resource::Catalog.supported_formats).to include(:json, :pson, :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
      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
    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
