puppet 4.10.0 → 5.0.0

data/spec/unit/transaction/report_spec.rb

@@ -15,97 +15,107 @@ describe Puppet::Transaction::Report do
 
   it "should set its host name to the node_name_value" do
     Puppet[:node_name_value] = 'mynode'
-    expect(Puppet::Transaction::Report.new("apply").host).to eq("mynode")
+    expect(Puppet::Transaction::Report.new.host).to eq("mynode")
   end
 
   it "should return its host name as its name" do
-    r = Puppet::Transaction::Report.new("apply")
+    r = Puppet::Transaction::Report.new
     expect(r.name).to eq(r.host)
   end
 
   it "should create an initialization timestamp" do
     Time.expects(:now).returns "mytime"
-    expect(Puppet::Transaction::Report.new("apply").time).to eq("mytime")
+    expect(Puppet::Transaction::Report.new.time).to eq("mytime")
   end
 
-  it "should take a 'kind' as an argument" do
-    expect(Puppet::Transaction::Report.new("inspect").kind).to eq("inspect")
+  it "should take a 'configuration_version' as an argument" do
+    expect(Puppet::Transaction::Report.new("some configuration version", "some environment").configuration_version).to eq("some configuration version")
   end
 
-  it "should take a 'configuration_version' as an argument" do
-    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").configuration_version).to eq("some configuration version")
+  it "should take a 'transaction_uuid' as an argument" do
+    expect(Puppet::Transaction::Report.new("some configuration version", "some environment", "some transaction uuid").transaction_uuid).to eq("some transaction uuid")
   end
 
   it "should take a 'transaction_uuid' as an argument" do
-    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment", "some transaction uuid").transaction_uuid).to eq("some transaction uuid")
+    expect(Puppet::Transaction::Report.new("some configuration version", "some environment", "some transaction uuid").transaction_uuid).to eq("some transaction uuid")
+  end
+
+  it "should take a 'job_id' as an argument" do
+    expect(Puppet::Transaction::Report.new('cv', 'env', 'tid', 'some job id').job_id).to eq('some job id')
   end
 
   it "should be able to set configuration_version" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.configuration_version = "some version"
     expect(report.configuration_version).to eq("some version")
   end
 
   it "should be able to set transaction_uuid" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.transaction_uuid = "some transaction uuid"
     expect(report.transaction_uuid).to eq("some transaction uuid")
   end
 
+  it "should be able to set job_id" do
+    report = Puppet::Transaction::Report.new
+    report.job_id = "some job id"
+    expect(report.job_id).to eq("some job id")
+  end
+
   it "should be able to set code_id" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.code_id = "some code id"
     expect(report.code_id).to eq("some code id")
   end
 
   it "should be able to set catalog_uuid" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.catalog_uuid = "some catalog uuid"
     expect(report.catalog_uuid).to eq("some catalog uuid")
   end
 
   it "should be able to set cached_catalog_status" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.cached_catalog_status = "explicitly_requested"
     expect(report.cached_catalog_status).to eq("explicitly_requested")
   end
 
   it "should set noop to true if Puppet[:noop] is true" do
     Puppet[:noop] = true
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     expect(report.noop).to be_truthy
   end
 
   it "should set noop to false if Puppet[:noop] is false" do
     Puppet[:noop] = false
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     expect(report.noop).to be_falsey
   end
 
   it "should set noop to false if Puppet[:noop] is unset" do
     Puppet[:noop] = nil
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     expect(report.noop).to be_falsey
   end
 
   it "should take 'environment' as an argument" do
-    expect(Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").environment).to eq("some environment")
+    expect(Puppet::Transaction::Report.new("some configuration version", "some environment").environment).to eq("some environment")
   end
 
   it "should be able to set environment" do
-    report = Puppet::Transaction::Report.new("inspect")
+    report = Puppet::Transaction::Report.new
     report.environment = "some environment"
     expect(report.environment).to eq("some environment")
   end
 
   it "should be able to set resources_failed_to_generate" do
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     report.resources_failed_to_generate = true
     expect(report.resources_failed_to_generate).to be_truthy
   end
 
   it "resources_failed_to_generate should not be true by default" do
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     expect(report.resources_failed_to_generate).to be_falsey
   end
 
@@ -118,7 +128,7 @@ describe Puppet::Transaction::Report do
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource(file)
 
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
 
     catalog.apply(:report => report)
     report.finalize_report
@@ -129,7 +139,7 @@ describe Puppet::Transaction::Report do
 
   describe "when accepting logs" do
     before do
-      @report = Puppet::Transaction::Report.new("apply")
+      @report = Puppet::Transaction::Report.new
     end
 
     it "should add new logs to the log list" do
@@ -146,7 +156,7 @@ describe Puppet::Transaction::Report do
   describe "#as_logging_destination" do
     it "makes the report collect logs during the block " do
       log_string = 'Hello test report!'
-      report = Puppet::Transaction::Report.new('test')
+      report = Puppet::Transaction::Report.new
       report.as_logging_destination do
         Puppet.err(log_string)
       end
@@ -157,7 +167,7 @@ describe Puppet::Transaction::Report do
 
   describe "when accepting resource statuses" do
     before do
-      @report = Puppet::Transaction::Report.new("apply")
+      @report = Puppet::Transaction::Report.new
     end
 
     it "should add each status to its status list" do
@@ -172,7 +182,7 @@ describe Puppet::Transaction::Report do
       Facter.stubs(:value).returns("eh")
       @indirection = stub 'indirection', :name => :report
       Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       @indirection.expects(:save)
       Puppet::Transaction::Report.indirection.save(report)
     end
@@ -182,7 +192,7 @@ describe Puppet::Transaction::Report do
     end
 
     it "should delegate its name attribute to its host method" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.expects(:host).returns "me"
       expect(report.name).to eq("me")
     end
@@ -190,21 +200,21 @@ describe Puppet::Transaction::Report do
 
   describe "when computing exit status" do
     it "should produce 2 if changes are present" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 0})
       expect(report.exit_status).to eq(2)
     end
 
     it "should produce 4 if failures are present" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 1})
       expect(report.exit_status).to eq(4)
     end
 
     it "should produce 4 if failures to restart are present" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 0})
       report.add_metric("resources", {"failed_to_restart" => 1})
@@ -212,7 +222,7 @@ describe Puppet::Transaction::Report do
     end
 
     it "should produce 6 if both changes and failures are present" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 1})
       expect(report.exit_status).to eq(6)
@@ -221,14 +231,14 @@ describe Puppet::Transaction::Report do
 
   describe "before finalizing the report" do
     it "should have a status of 'failed'" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       expect(report.status).to eq('failed')
     end
   end
 
   describe "when finalizing the report" do
     before do
-      @report = Puppet::Transaction::Report.new("apply")
+      @report = Puppet::Transaction::Report.new
     end
 
     def metric(name, value)
@@ -282,6 +292,12 @@ describe Puppet::Transaction::Report do
         expect(@report.status).to eq('failed')
       end
 
+      it "should mark the report as 'failed' if resources failed to restart" do
+        add_statuses(1) { |status| status.failed_to_restart = true }
+        @report.finalize_report
+        expect(@report.status).to eq('failed')
+      end
+
       it "should mark the report as 'failed' if resources_failed_to_generate" do
         @report.resources_failed_to_generate = true
         @report.finalize_report
@@ -468,67 +484,89 @@ describe Puppet::Transaction::Report do
 
   describe "when outputting yaml" do
     it "should not include @external_times" do
-      report = Puppet::Transaction::Report.new('apply')
+      report = Puppet::Transaction::Report.new
       report.add_times('config_retrieval', 1.0)
-      expect(report.to_yaml_properties).not_to include('@external_times')
+      expect(report.to_data_hash.keys).not_to include('external_times')
     end
 
     it "should not include @resources_failed_to_generate" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       report.resources_failed_to_generate = true
-      expect(report.to_yaml_properties).not_to include('@resources_failed_to_generate')
+      expect(report.to_data_hash.keys).not_to include('resources_failed_to_generate')
+    end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(generate_report.to_data_hash)).to be_truthy
     end
   end
 
-  it "defaults to serializing to pson" do
-    expect(Puppet::Transaction::Report.default_format).to eq(:pson)
+  it "defaults to serializing to json" do
+    expect(Puppet::Transaction::Report.default_format).to eq(:json)
   end
 
-  it "supports both yaml and pson" do
-    expect(Puppet::Transaction::Report.supported_formats).to eq([:pson, :yaml])
+  it "supports both json, pson and yaml" do
+    # msgpack is optional, so using include instead of eq
+    expect(Puppet::Transaction::Report.supported_formats).to include(:json, :pson, :yaml)
   end
 
-  it "can make a round trip through pson" do
-    report = generate_report
+  context 'can make a round trip through' do
+    before(:each) do
+      Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(Puppet.lookup(:current_environment)))
+    end
+
+    after(:each) { Puppet.pop_context }
 
-    tripped = Puppet::Transaction::Report.convert_from(:pson, report.render)
+    it 'pson' do
+      report = generate_report
 
-    expect_equivalent_reports(tripped, report)
+      tripped = Puppet::Transaction::Report.convert_from(:pson, report.render)
+
+      expect_equivalent_reports(tripped, report)
+    end
+
+    it 'json' do
+      report = generate_report
+
+      tripped = Puppet::Transaction::Report.convert_from(:json, report.render)
+
+      expect_equivalent_reports(tripped, report)
+    end
+
+    it 'yaml' do
+      report = generate_report
+
+      yaml_output = report.render(:yaml)
+      tripped = Puppet::Transaction::Report.convert_from(:yaml, yaml_output)
+
+      expect(yaml_output).to match(/^--- /)
+      expect_equivalent_reports(tripped, report)
+    end
   end
 
-  it "generates pson which validates against the report schema" do
+  it "generates json which validates against the report schema" do
     report = generate_report
     expect(report.render).to validate_against('api/schemas/report.json')
   end
 
-  it "generates pson for error report which validates against the report schema" do
+  it "generates json for error report which validates against the report schema" do
     error_report = generate_report_with_error
     expect(error_report.render).to validate_against('api/schemas/report.json')
   end
 
-  it "can make a round trip through yaml" do
-    report = generate_report
-
-    yaml_output = report.render(:yaml)
-    tripped = Puppet::Transaction::Report.convert_from(:yaml, yaml_output)
-
-    expect(yaml_output).to match(/^--- /)
-    expect_equivalent_reports(tripped, report)
-  end
-
   def expect_equivalent_reports(tripped, report)
     expect(tripped.host).to eq(report.host)
     expect(tripped.time.to_i).to eq(report.time.to_i)
     expect(tripped.configuration_version).to eq(report.configuration_version)
     expect(tripped.transaction_uuid).to eq(report.transaction_uuid)
+    expect(tripped.job_id).to eq(report.job_id)
     expect(tripped.code_id).to eq(report.code_id)
     expect(tripped.catalog_uuid).to eq(report.catalog_uuid)
     expect(tripped.cached_catalog_status).to eq(report.cached_catalog_status)
     expect(tripped.report_format).to eq(report.report_format)
     expect(tripped.puppet_version).to eq(report.puppet_version)
-    expect(tripped.kind).to eq(report.kind)
     expect(tripped.status).to eq(report.status)
     expect(tripped.environment).to eq(report.environment)
+    expect(tripped.corrective_change).to eq(report.corrective_change)
 
     expect(logs_as_strings(tripped)).to eq(logs_as_strings(report))
     expect(metrics_as_hashes(tripped)).to eq(metrics_as_hashes(report))
@@ -566,7 +604,7 @@ describe Puppet::Transaction::Report do
       expect(status.skipped).to eq(expected.skipped)
       expect(status.change_count).to eq(expected.change_count)
       expect(status.out_of_sync_count).to eq(expected.out_of_sync_count)
-      expect(status.events.map(&:to_data_hash)).to eq(expected.events.map(&:to_data_hash))
+      expect(status.events).to eq(expected.events)
     end
   end
 
@@ -574,8 +612,8 @@ describe Puppet::Transaction::Report do
     event_hash = {
       :audited => false,
       :property => 'message',
-      :previous_value => 'absent',
-      :desired_value => 'a resource',
+      :previous_value => SemanticPuppet::VersionRange.parse('>=1.0.0'),
+      :desired_value => SemanticPuppet::VersionRange.parse('>=1.2.0'),
       :historical_value => nil,
       :message => "defined 'message' as 'a resource'",
       :name => :message_changed,
@@ -587,7 +625,7 @@ describe Puppet::Transaction::Report do
     status.changed = true
     status.add_event(event)
 
-    report = Puppet::Transaction::Report.new('apply', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
+    report = Puppet::Transaction::Report.new(1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749", '42')
     report << Puppet::Util::Log.new(:level => :warning, :message => "log message")
     report.add_times("timing", 4)
     report.code_id = "some code id"
@@ -604,7 +642,7 @@ describe Puppet::Transaction::Report do
     status.changed = true
     status.failed_because("bad stuff happened")
 
-    report = Puppet::Transaction::Report.new('apply', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
+    report = Puppet::Transaction::Report.new(1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749", '42')
     report << Puppet::Util::Log.new(:level => :warning, :message => "log message")
     report.add_times("timing", 4)
     report.code_id = "some code id"

data/spec/unit/transaction/resource_harness_spec.rb

@@ -233,7 +233,7 @@ describe Puppet::Transaction::ResourceHarness do
         @harness.evaluate(resource)
       end.to raise_error(Exception)
 
-      expect(@logs.first.message).to eq("change from absent to present failed: Exception")
+      expect(@logs.first.message).to eq("change from 'absent' to 'present' failed: Exception")
       expect(@logs.first.level).to eq(:err)
     end
 
@@ -296,7 +296,7 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should log and pass the exception through" do
       expect { @harness.evaluate(@resource) }.to raise_error(Exception, /baz/)
-      expect(@logs.first.message).to eq("change from absent to 1 failed: baz")
+      expect(@logs.first.message).to eq("change from 'absent' to 1 failed: baz")
       expect(@logs.first.level).to eq(:err)
     end
   end
@@ -325,7 +325,7 @@ describe Puppet::Transaction::ResourceHarness do
 
     it "should log and pass the exception through" do
       expect { @harness.evaluate(@resource) }.to raise_error(Exception, /slithy/)
-      expect(@logs.first.message).to eq("change from absent to 1 failed: slithy")
+      expect(@logs.first.message).to eq("change from 'absent' to 1 failed: slithy")
       expect(@logs.first.level).to eq(:err)
     end
   end

data/spec/unit/transaction_spec.rb

@@ -50,7 +50,7 @@ describe Puppet::Transaction do
     expect(transaction.report.resource_statuses[resource.to_s]).to equal(status)
   end
 
-  it "should not consider there to be failed resources if no statuses are marked failed" do
+  it "should not consider there to be failed or failed_to_restart resources if no statuses are marked failed" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
     transaction = transaction_with_resource(resource)
     transaction.evaluate
@@ -59,7 +59,7 @@ describe Puppet::Transaction do
   end
 
   it "should use the provided report object" do
-    report = Puppet::Transaction::Report.new("apply")
+    report = Puppet::Transaction::Report.new
     transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, report, nil)
 
     expect(transaction.report).to eq(report)
@@ -86,7 +86,7 @@ describe Puppet::Transaction do
 
     it "should set retrieval time on the report" do
       catalog = Puppet::Resource::Catalog.new
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new
       catalog.retrieval_duration = 5
 
       report.expects(:add_times).with(:config_retrieval, 5)
@@ -174,6 +174,13 @@ describe Puppet::Transaction do
 
       expect(@transaction).to be_any_failed
     end
+
+    it "should report any_failed if any resources failed to restart" do
+      @transaction.evaluate
+      @transaction.report.resource_statuses[@resource.to_s].failed_to_restart = true
+
+      expect(@transaction).to be_any_failed
+    end
   end
 
   describe "#unblock" do
@@ -330,7 +337,7 @@ describe Puppet::Transaction do
   describe "after resource traversal" do
     let(:catalog) { Puppet::Resource::Catalog.new }
     let(:prioritizer) { Puppet::Graph::RandomPrioritizer.new }
-    let(:report) { Puppet::Transaction::Report.new("apply") }
+    let(:report) { Puppet::Transaction::Report.new }
     let(:transaction) { Puppet::Transaction.new(catalog, report, prioritizer) }
     let(:generator) { Puppet::Transaction::AdditionalResourceGenerator.new(catalog, nil, prioritizer) }
 
@@ -675,23 +682,26 @@ describe Puppet::Transaction do
   end
 
   it "errors with a dependency cycle for a resource that requires itself" do
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: require => Notify[cycle] }
       MANIFEST
-    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
   end
 
   it "errors with a dependency cycle for a self-requiring resource also required by another resource" do
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: require => Notify[cycle] }
         notify { other: require => Notify[cycle] }
       MANIFEST
-    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
   end
 
   it "errors with a dependency cycle for a resource that requires itself and another resource" do
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle:
@@ -699,10 +709,11 @@ describe Puppet::Transaction do
         }
         notify { other: }
       MANIFEST
-    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
   end
 
   it "errors with a dependency cycle for a resource that is later modified to require itself" do
+    Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m))
     expect do
       apply_compiled_manifest(<<-MANIFEST)
         notify { cycle: }
@@ -710,7 +721,41 @@ describe Puppet::Transaction do
           require => Notify[cycle]
         }
       MANIFEST
-    end.to raise_error(Puppet::Error, /Found 1 dependency cycle:.*\(Notify\[cycle\] => Notify\[cycle\]\)/m)
+    end.to raise_error(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+  end
+
+  context "when generating a report for a transaction with a dependency cycle" do
+    let(:catalog) do
+      compile_to_ral(<<-MANIFEST)
+        notify { foo: require => Notify[bar] }
+        notify { bar: require => Notify[foo] }
+      MANIFEST
+    end
+
+    let(:prioritizer) { Puppet::Graph::SequentialPrioritizer.new }
+    let(:transaction) { Puppet::Transaction.new(catalog,
+                                          Puppet::Transaction::Report.new("apply"),
+                                          prioritizer) }
+
+    before(:each) do
+      expect { transaction.evaluate }.to raise_error(Puppet::Error)
+      transaction.report.finalize_report
+    end
+
+    it "should report resources involved in a dependency cycle as failed" do
+      expect(transaction.report.resource_statuses['Notify[foo]']).to be_failed
+      expect(transaction.report.resource_statuses['Notify[bar]']).to be_failed
+    end
+
+    it "should generate a failure event for a resource in a dependency cycle" do
+      status = transaction.report.resource_statuses['Notify[foo]']
+      expect(status.events.first.status).to eq('failure')
+      expect(status.events.first.message).to eq('resource is part of a dependency cycle')
+    end
+
+    it "should report that the transaction is failed" do
+      expect(transaction.report.status).to eq('failed')
+    end
   end
 
   it "reports a changed resource with a successful run" do

data/spec/unit/type/file/group_spec.rb

@@ -47,13 +47,13 @@ describe Puppet::Type.type(:file).attrclass(:group) do
       it "should use the name of the user if it can find it" do
         resource.provider.stubs(:gid2name).with(1001).returns 'foos'
 
-        expect(group.send(prop_to_s, 1001)).to eq('foos')
+        expect(group.send(prop_to_s, 1001)).to eq("'foos'")
       end
 
       it "should use the id of the user if it can't" do
         resource.provider.stubs(:gid2name).with(1001).returns nil
 
-        expect(group.send(prop_to_s, 1001)).to eq(1001)
+        expect(group.send(prop_to_s, 1001)).to eq('1001')
       end
     end
   end

data/spec/unit/type/file/mode_spec.rb

@@ -13,7 +13,7 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
     it "should reject non-string values" do
       expect {
         mode.value = 0755
-      }.to raise_error(Puppet::Error, /The file mode specification must be a string, not 'Fixnum'/)
+      }.to raise_error(Puppet::Error, /The file mode specification must be a string, not '(?:Fixnum|Integer)'/)
     end
 
     it "should accept values specified as octal numbers in strings" do
@@ -140,17 +140,17 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
   describe '#should_to_s' do
     describe 'with a 3-digit mode' do
       it 'returns a 4-digit mode with a leading zero' do
-        expect(mode.should_to_s('755')).to eq('0755')
+        expect(mode.should_to_s('755')).to eq("'0755'")
       end
     end
 
     describe 'with a 4-digit mode' do
       it 'returns the 4-digit mode when the first digit is a zero' do
-        expect(mode.should_to_s('0755')).to eq('0755')
+        expect(mode.should_to_s('0755')).to eq("'0755'")
       end
 
       it 'returns the 4-digit mode when the first digit is not a zero' do
-        expect(mode.should_to_s('1755')).to eq('1755')
+        expect(mode.should_to_s('1755')).to eq("'1755'")
       end
     end
   end
@@ -158,23 +158,23 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
   describe '#is_to_s' do
     describe 'with a 3-digit mode' do
       it 'returns a 4-digit mode with a leading zero' do
-        expect(mode.is_to_s('755')).to eq('0755')
+        expect(mode.is_to_s('755')).to eq("'0755'")
       end
     end
 
     describe 'with a 4-digit mode' do
       it 'returns the 4-digit mode when the first digit is a zero' do
-        expect(mode.is_to_s('0755')).to eq('0755')
+        expect(mode.is_to_s('0755')).to eq("'0755'")
       end
 
       it 'returns the 4-digit mode when the first digit is not a zero' do
-        expect(mode.is_to_s('1755')).to eq('1755')
+        expect(mode.is_to_s('1755')).to eq("'1755'")
       end
     end
 
     describe 'when passed :absent' do
-      it 'returns :absent' do
-        expect(mode.is_to_s(:absent)).to eq(:absent)
+      it "returns 'absent'" do
+        expect(mode.is_to_s(:absent)).to eq("'absent'")
       end
     end
   end

data/spec/unit/type/file/owner_spec.rb

@@ -45,13 +45,13 @@ describe Puppet::Type.type(:file).attrclass(:owner) do
       it "should use the name of the user if it can find it" do
         resource.provider.stubs(:uid2name).with(1001).returns 'foo'
 
-        expect(owner.send(prop_to_s, 1001)).to eq('foo')
+        expect(owner.send(prop_to_s, 1001)).to eq("'foo'")
       end
 
       it "should use the id of the user if it can't" do
         resource.provider.stubs(:uid2name).with(1001).returns nil
 
-        expect(owner.send(prop_to_s, 1001)).to eq(1001)
+        expect(owner.send(prop_to_s, 1001)).to eq('1001')
       end
     end
   end

data/spec/unit/type/file/selinux_spec.rb

@@ -10,6 +10,8 @@ require 'spec_helper'
       @path = make_absolute("/my/file")
       @resource = Puppet::Type.type(:file).new :path => @path
       @sel = property.new :resource => @resource
+      @sel.stubs(:normalize_selinux_category).with("s0").returns("s0")
+      @sel.stubs(:normalize_selinux_category).with(nil).returns(nil)
     end
 
     it "retrieve on #{param} should return :absent if the file isn't statable" do