puppet 4.5.3-x64-mingw32 → 4.6.1-x64-mingw32

data/spec/integration/parser/functions/require_spec.rb

@@ -15,7 +15,7 @@ describe "The require function" do
   end
 
   it "should add a dependency between the 'required' class and our class" do
-    @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass")
+    @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass")
 
     @scope.function_require(["requiredclass"])
     expect(@scope.resource["require"]).not_to be_nil
@@ -25,8 +25,8 @@ describe "The require function" do
   end
 
   it "should queue relationships between the 'required' class and our classes" do
-    @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass1")
-    @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass2")
+    @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass1")
+    @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass2")
 
     @scope.function_require(["requiredclass1"])
     @scope.function_require(["requiredclass2"])

data/spec/integration/parser/parameter_defaults_spec.rb

@@ -26,12 +26,16 @@ require 'puppet_spec/language'
 
     let (:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('specification')) }
 
+    let (:topscope) { compiler.topscope }
+
     def collect_notices(code)
       logs = []
       Puppet[:code] = code
       Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-        compiler.compile
-        yield
+          compiler.compile do |catalog|
+            yield
+            catalog
+          end
       end
       logs.select { |log| log.level == :notice }.map { |log| log.message }
     end

data/spec/integration/parser/pcore_resource_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet_spec/compiler'
+
+require 'puppet/face'
+
+describe 'when pcore described resources types are in use' do
+  include PuppetSpec::Files
+  include PuppetSpec::Compiler
+
+  let(:genface) { Puppet::Face[:generate, :current] }
+
+  context "in an environment with two modules" do
+    let(:dir) do
+      dir_containing('environments', { 'production' => {
+        'environment.conf' => "modulepath = modules",
+        'manifests' => { 'site.pp' => "" },
+        'modules' => {
+          'm1' => {
+            'lib' => { 'puppet' => { 'type' => {
+              'test1.rb' => <<-EOF
+              module Puppet
+              Type.newtype(:test1) do
+                @doc = "Docs for resource"
+                newproperty(:message) do
+                  desc "Docs for 'message' property"
+                end
+                newparam(:name) do
+                  desc "Docs for 'name' parameter"
+                  isnamevar
+                end
+                newparam(:whatever) do
+                  desc "Docs for 'whatever' parameter"
+                end
+              end; end
+              EOF
+             } }
+          },
+        },
+        'm2' => { 
+          'lib' => { 'puppet' => { 'type' => {
+            'test2.rb' => <<-EOF
+            module Puppet
+            Type.newtype(:test2) do
+              @doc = "Docs for resource"
+              @isomorphic = false
+              newproperty(:message) do
+                desc "Docs for 'message' property"
+              end
+              newparam(:name) do
+                desc "Docs for 'name' parameter"
+                isnamevar
+              end
+              newparam(:color) do
+                desc "Docs for 'color' parameter"
+                newvalues(:red, :green, :blue, /#[0-9A-Z]{6}/)
+              end
+            end;end
+            EOF
+           } } },
+        }
+      }}})
+    end
+
+    let(:modulepath) do
+      File.join(dir, 'production', 'modules')
+    end
+
+    let(:m1) do
+      File.join(modulepath, 'm1')
+    end
+
+    let(:m2) do
+      File.join(modulepath, 'm2')
+    end
+
+    let(:outputdir) do
+      File.join(dir, 'production', '.resource_types')
+    end
+
+    around(:each) do |example|
+      Puppet.settings.initialize_global_settings
+      Puppet[:manifest] = ''
+      loader = Puppet::Environments::Directories.new(dir, [])
+      Puppet.override(:environments => loader) do
+        Puppet.override(:current_environment => loader.get('production')) do
+          example.run
+        end
+      end
+    end
+
+    it 'can use generated types to compile a catalog' do
+      genface.types
+      catalog = compile_to_catalog(<<-MANIFEST)
+        test1 { 'a':
+          message => 'a works'
+        }
+        # Several instances of the type can be created - implicit test
+        test1 { 'another a':
+          message => 'another a works'
+        }
+        test2 { 'b':
+          message => 'b works'
+        }
+      MANIFEST
+      expect(catalog.resource(:test1, "a")['message']).to eq('a works')
+      expect(catalog.resource(:test2, "b")['message']).to eq('b works')
+    end
+
+    it 'the validity of attribute names are checked' do
+      genface.types
+      expect do 
+        compile_to_catalog(<<-MANIFEST)
+          test1 { 'a':
+            mezzage => 'a works'
+          }
+        MANIFEST
+      end.to raise_error(/no parameter named 'mezzage'/)
+    end
+
+    it 'meta-parameters such as noop can be used' do
+      genface.types
+      catalog = compile_to_catalog(<<-MANIFEST)
+        test1 { 'a':
+          message => 'noop works',
+          noop => true
+        }
+      MANIFEST
+      expect(catalog.resource(:test1, "a")['noop']).to eq(true)
+    end
+
+    it 'a generated type describes if it is isomorphic' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.isomorphic?).to be(true)
+        t2 = find_resource_type(compiler.topscope, 'test2')
+        expect(t2.isomorphic?).to be(false)
+      end
+    end
+
+    it 'a generated type returns parameters defined in pcore' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.parameters.size).to be(2)
+        expect(t1.parameters[0].name).to eql('name')
+        expect(t1.parameters[1].name).to eql('whatever')
+      end
+    end
+
+    it 'a generated type picks up and returns if a parameter is a namevar' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.parameters[0].name_var).to be(true)
+        expect(t1.parameters[1].name_var).to be(false)
+      end
+    end
+
+    it 'a generated type returns properties defined in pcore' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.properties.size).to be(1)
+        expect(t1.properties[0].name).to eql('message')
+      end
+    end
+
+    it 'a generated type returns [[/(.*)/m, <first attr>]] as default title_pattern when there is a namevar but no pattern specified' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.title_patterns.size).to be(1)
+        expect(t1.title_patterns[0][0]).to eql(/(.*)/m)
+      end
+    end
+
+    it "the compiler asserts the type of parameters" do
+      pending "assertion of parameter types not yet implemented"
+      genface.types
+      expect {
+      catalog = compile_to_catalog(<<-MANIFEST)
+        test2 { 'b':
+          color => 'white is not a color'
+        }
+      MANIFEST
+      }.to raise_error(/an error indicating that color cannot have that value/) # ERROR TBD.
+    end
+  end
+
+  def find_resource_type(scope, name)
+    t1 = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, name)
+  end
+
+  def generate_and_in_a_compilers_context(&block)
+    genface.types
+    # Since an instance of a compiler is needed and it starts an initial import that evaluates
+    # code, and that code will be loaded from manifests with a glob (go figure)
+    # the only way to stop that is to set 'code' to something as that overrides "importing" files.
+    Puppet[:code] = "undef"
+    node = Puppet::Node.new('test')
+    # All loading must be done in a context configured as the compiler does it.
+    # (Therefore: use the context a compiler creates as this test logic must otherwise
+    #  know how to do this).
+    #
+    compiler = Puppet::Parser::Compiler.new(node)
+    Puppet::override(compiler.context_overrides) do
+      block.call(compiler)
+    end
+  end
+
+end

data/spec/integration/parser/resource_expressions_spec.rb

@@ -164,8 +164,10 @@ describe "Puppet resource expressions" do
              path => '/somewhere',
              * => $y }"  => "File[$t][mode] == '0666' and File[$t][owner] == 'the_x' and File[$t][path] == '/somewhere'")
 
-    produces("notify{title:}; Notify[title] { * => { message => set}}" => "Notify[title][message] == 'set'")
-    produces("Notify { * => { message => set}}; notify{title:}"      => "Notify[title][message] == 'set'")
+    produces("notify{title:}; Notify[title] { * => { message => set}}"  => "Notify[title][message] == 'set'")
+    produces("Notify { * => { message => set}}; notify{title:}"         => "Notify[title][message] == 'set'")
+    produces('define foo($x) { notify { "title": message =>"aaa${x}bbb"} } foo{ test: x => undef }' => "Notify[title][message] == 'aaabbb'")
+    produces('define foo($x="xx") { notify { "title": message =>"aaa${x}bbb"} } foo{ test: x => undef }' => "Notify[title][message] == 'aaaxxbbb'")
 
     fails("notify { title: unknown => value }" => /no parameter named 'unknown'/)
 

data/spec/integration/provider/yumrepo_spec.rb

@@ -87,7 +87,7 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile), '(integration)',
     properties = {"bandwidth"      => "42M",
                   "baseurl"        => "http://er0ck",
                   "cost"           => "42",
-                  "enabled"        => "Yes",
+                  "enabled"        => "yes",
                   "exclude"        => "er0ckSet2.0",
                   "failovermethod" => "roundrobin",
                   "include"        => "https://er0ck",
@@ -107,6 +107,9 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile), '(integration)',
       apply_with_error_check(manifest)
       file_lines = File.read(File.join(@yumrepo_dir, super_creative + '.repo'))
       properties.each do |property_key, property_value|
+        if property_value =~ /^(true|false|no|yes)$/
+          property_value = property_value.capitalize
+        end
         expect(file_lines).to match(/^#{property_key}=#{Regexp.escape(property_value)}$/)
       end
     end

data/spec/integration/transaction/report_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/files'
 
 describe Puppet::Transaction::Report do
   describe "when using the indirector" do
@@ -37,4 +38,669 @@ describe Puppet::Transaction::Report do
       expect(YAML.dump(report)).to_not match('Puppet::Util::TagSet')
     end
   end
+
+  describe "inference checking" do
+    include PuppetSpec::Files
+    require 'puppet/configurer'
+
+    def run_catalogs(resources1, resources2, noop1 = false, noop2 = false, &block)
+      last_run_report = nil
+      Puppet::Transaction::Report.indirection.expects(:save).twice.with do |report, x|
+        last_run_report = report
+        true
+      end
+
+      Puppet[:report] = true
+      Puppet[:noop] = noop1
+
+      configurer = Puppet::Configurer.new
+      configurer.run :catalog => new_catalog(resources1)
+
+      yield block if block
+      last_report = last_run_report
+
+      Puppet[:noop] = noop2
+
+      configurer = Puppet::Configurer.new
+      configurer.run :catalog => new_catalog(resources2)
+
+      expect(last_report).not_to eq(last_run_report)
+
+      return last_run_report
+    end
+
+    def new_blank_catalog
+      Puppet::Resource::Catalog.new("testing", Puppet.lookup(:environments).get(Puppet[:environment]))
+    end
+
+    def new_catalog(resources = [])
+      new_cat = new_blank_catalog
+      [resources].flatten.each do |resource|
+        new_cat.add_resource(resource)
+      end
+      new_cat
+    end
+
+    def get_cc_count(report)
+      cc = report.metrics["resources"].values.each do |v|
+        if v[0] == "corrective_change"
+          return v[2]
+        end
+      end
+      return nil
+    end
+
+    describe "for agent runs that contain" do
+      it "notifies with catalog change" do
+        report = run_catalogs(Puppet::Type.type(:notify).new(:title => "testing",
+                                                             :message => "foo"),
+                              Puppet::Type.type(:notify).new(:title => "testing",
+                                                             :message => "foobar"))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["Notify[testing]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "notifies with no catalog change" do
+        report = run_catalogs(Puppet::Type.type(:notify).new(:title => "testing",
+                                                             :message => "foo"),
+                              Puppet::Type.type(:notify).new(:title => "testing",
+                                                             :message => "foo"))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["Notify[testing]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "new file resource" do
+        file = tmpfile("test_file")
+        report = run_catalogs([],
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "removal of a file resource" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              [])
+
+        expect(report.status).to eq("unchanged")
+        expect(report.resource_statuses["File[#{file}]"]).to eq(nil)
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with a title change" do
+        file1 = tmpfile("test_file")
+        file2 = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file1,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file2,
+                                                           :content => "mystuff"))
+
+        expect(report.status).to eq("changed")
+
+        expect(report.resource_statuses["File[#{file1}]"]).to eq(nil)
+
+        rs = report.resource_statuses["File[#{file2}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with no catalog change" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"))
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(0)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with a new parameter" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff",
+                                                           :loglevel => :debug))
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(0)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with a removed parameter" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff",
+                                                           :loglevel => :debug),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"))
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(0)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with a property no longer managed" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file))
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(0)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with no catalog change, but file changed between runs" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff")) do
+          File.open(file, 'w') do |f|
+            f.puts "some content"
+          end
+        end
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+      end
+
+      it "file with catalog change, but file changed between runs that matched catalog change" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "some content")) do
+          File.open(file, 'w') do |f|
+            f.write "some content"
+          end
+        end
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(0)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with catalog change, but file changed between runs that did not match catalog change" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff1"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff2")) do
+          File.open(file, 'w') do |file|
+            file.write "some content"
+          end
+        end
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+      end
+
+      it "file with catalog change" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff1"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff2"))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with ensure property set to present" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :present),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :present))
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(0)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with ensure property change file => absent" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :file),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :absent))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with ensure property change present => absent" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :present),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :absent))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "link with ensure property change present => absent", :unless => Puppet.features.microsoft_windows? do
+        file = tmpfile("test_file")
+        FileUtils.symlink(file, tmpfile("test_link"))
+
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :present),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :absent))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file with ensure property change absent => present" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :absent),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :ensure => :present))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "new resource in catalog" do
+        file = tmpfile("test_file")
+        report = run_catalogs([],
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff asdf"))
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "exec with idempotence issue", :unless => Puppet.features.microsoft_windows? do
+        report = run_catalogs(Puppet::Type.type(:exec).new(:title => "exec1",
+                                                           :command => "/bin/echo foo"),
+                              Puppet::Type.type(:exec).new(:title => "exec1",
+                                                           :command => "/bin/echo foo"))
+
+        expect(report.status).to eq("changed")
+
+        # Of note here, is that the main idempotence issues lives in 'returns'
+        rs = report.resource_statuses["Exec[exec1]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+      end
+
+      it "exec with no idempotence issue", :unless => Puppet.features.microsoft_windows? do
+        report = run_catalogs(Puppet::Type.type(:exec).new(:title => "exec1",
+                                                           :command => "echo foo",
+                                                           :path => "/bin",
+                                                           :unless => "ls"),
+                              Puppet::Type.type(:exec).new(:title => "exec1",
+                                                           :command => "echo foo",
+                                                           :path => "/bin",
+                                                           :unless => "ls"))
+
+        expect(report.status).to eq("unchanged")
+
+        # Of note here, is that the main idempotence issues lives in 'returns'
+        rs = report.resource_statuses["Exec[exec1]"]
+        expect(rs.events.size).to eq(0)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "noop on second run, file with no catalog change, but file changed between runs" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              false, true) do
+          File.open(file, 'w') do |f|
+            f.puts "some content"
+          end
+        end
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.events.size).to eq(1)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+      end
+
+      it "noop on all subsequent runs, file with no catalog change, but file changed between run 1 and 2" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              false, true) do
+          File.open(file, 'w') do |f|
+            f.puts "some content"
+          end
+        end
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.events.size).to eq(1)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+
+        # Simply run the catalog twice again, but this time both runs are noop to
+        # test if the corrective field is still set.
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              true, true)
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.events.size).to eq(1)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+      end
+
+      it "noop on first run, file with no catalog change, but file changed between runs" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              true, false) do
+          File.open(file, 'w') do |f|
+            f.puts "some content"
+          end
+        end
+
+        expect(report.status).to eq("changed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.events.size).to eq(1)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+      end
+
+      it "noop on both runs, file with no catalog change, but file changed between runs" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              true, true) do
+          File.open(file, 'w') do |f|
+            f.puts "some content"
+          end
+        end
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+      end
+
+      it "noop on 4 runs, file with no catalog change, but file changed between runs 1 and 2" do
+        file = tmpfile("test_file")
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              true, true) do
+          File.open(file, 'w') do |f|
+            f.puts "some content"
+          end
+        end
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "mystuff"),
+                              true, true)
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(true)
+        expect(rs.corrective_change).to eq(true)
+
+        expect(report.corrective_change).to eq(true)
+        expect(get_cc_count(report)).to eq(1)
+      end
+
+      it "noop on both runs, file already exists but with catalog change each time" do
+        file = tmpfile("test_file")
+
+        File.open(file, 'w') do |f|
+          f.puts "some content"
+        end
+
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "a"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "b"),
+                              true, true)
+
+        expect(report.status).to eq("unchanged")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file failure should not return corrective_change" do
+        # Making the path a child path (with no parent) forces a failure
+        file = tmpfile("test_file") + "/foo"
+        report = run_catalogs(Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "a"),
+                              Puppet::Type.type(:file).new(:title => file,
+                                                           :content => "b"),
+                              false, false)
+
+        expect(report.status).to eq("failed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+
+      it "file skipped with file change between runs will not show corrective_change" do
+        # Making the path a child path (with no parent) forces a failure
+        file = tmpfile("test_file") + "/foo"
+
+        resources1 = [
+          Puppet::Type.type(:file).new(:title => file,
+                                       :content => "a",
+                                       :notify => "Notify['foo']"),
+          Puppet::Type.type(:notify).new(:title => "foo")
+        ]
+        resources2 = [
+          Puppet::Type.type(:file).new(:title => file,
+                                       :content => "a",
+                                       :notify => "Notify[foo]"),
+          Puppet::Type.type(:notify).new(:title => "foo",
+                                         :message => "foo")
+        ]
+
+        report = run_catalogs(resources1, resources2, false, false)
+
+        expect(report.status).to eq("failed")
+
+        rs = report.resource_statuses["File[#{file}]"]
+        expect(rs.events.size).to eq(1)
+        expect(rs.events[0].corrective_change).to eq(false)
+        expect(rs.corrective_change).to eq(false)
+
+        rs = report.resource_statuses["Notify[foo]"]
+        expect(rs.events.size).to eq(0)
+        expect(rs.corrective_change).to eq(false)
+
+        expect(report.corrective_change).to eq(false)
+        expect(get_cc_count(report)).to eq(0)
+      end
+    end
+  end
 end