puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/ssl/key_spec.rb

@@ -71,7 +71,7 @@ describe Puppet::SSL::Key do
     end
 
     it "should not try to use the provided password file if the file does not exist" do
-      FileTest.stubs(:exist?).returns false
+      Puppet::FileSystem::File.stubs(:exist?).returns false
       @key.password_file = "/path/to/password"
 
       path = "/my/path"
@@ -84,7 +84,7 @@ describe Puppet::SSL::Key do
     end
 
     it "should read the key with the password retrieved from the password file if one is provided" do
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
       @key.password_file = "/path/to/password"
 
       path = "/my/path"
@@ -154,7 +154,7 @@ describe Puppet::SSL::Key do
 
     describe "with a password file set" do
       it "should return a nil password if the password file does not exist" do
-        FileTest.expects(:exist?).with("/path/to/pass").returns false
+        Puppet::FileSystem::File.expects(:exist?).with("/path/to/pass").returns false
         File.expects(:read).with("/path/to/pass").never
 
         @instance.password_file = "/path/to/pass"
@@ -163,7 +163,7 @@ describe Puppet::SSL::Key do
       end
 
       it "should return the contents of the password file as its password" do
-        FileTest.expects(:exist?).with("/path/to/pass").returns true
+        Puppet::FileSystem::File.expects(:exist?).with("/path/to/pass").returns true
         File.expects(:read).with("/path/to/pass").returns "my password"
 
         @instance.password_file = "/path/to/pass"

data/spec/unit/ssl/oids_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'puppet/ssl/oids'
+
+describe Puppet::SSL::Oids do
+  describe "defining application OIDs" do
+
+    {
+      'puppetlabs' => '1.3.6.1.4.1.34380',
+      'ppCertExt' => '1.3.6.1.4.1.34380.1',
+      'ppRegCertExt' => '1.3.6.1.4.1.34380.1.1',
+      'pp_uuid' => '1.3.6.1.4.1.34380.1.1.1',
+      'pp_instance_id' => '1.3.6.1.4.1.34380.1.1.2',
+      'pp_image_name' => '1.3.6.1.4.1.34380.1.1.3',
+      'pp_preshared_key' => '1.3.6.1.4.1.34380.1.1.4',
+      'ppPrivCertExt' => '1.3.6.1.4.1.34380.1.2',
+    }.each_pair do |sn, oid|
+      it "defines #{sn} as #{oid}" do
+        object_id = OpenSSL::ASN1::ObjectId.new(sn)
+        expect(object_id.oid).to eq oid
+      end
+    end
+  end
+
+  describe "checking if an OID is a subtree of another OID" do
+
+    it "can determine if an OID is contained in another OID" do
+      described_class.subtree_of?('1.3.6.1', '1.3.6.1.4.1').should be_true
+      described_class.subtree_of?('1.3.6.1.4.1', '1.3.6.1').should be_false
+    end
+
+    it "returns true if an OID is compared against itself and exclusive is false" do
+      described_class.subtree_of?('1.3.6.1', '1.3.6.1', false).should be_true
+    end
+
+    it "returns false if an OID is compared against itself and exclusive is true" do
+      described_class.subtree_of?('1.3.6.1', '1.3.6.1', true).should be_false
+    end
+
+    it "can compare OIDs defined as short names" do
+      described_class.subtree_of?('IANA', '1.3.6.1.4.1').should be_true
+      described_class.subtree_of?('1.3.6.1', 'enterprises').should be_true
+    end
+
+    it "returns false when an invalid OID shortname is passed" do
+      described_class.subtree_of?('IANA', 'bananas').should be_false
+    end
+  end
+end

data/spec/unit/ssl/validator_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
-require 'puppet/ssl/validator'
+require 'puppet/ssl'
 require 'puppet/ssl/configuration'
 
-describe Puppet::SSL::Validator do
+describe Puppet::SSL::Validator::DefaultValidator do
   let(:ssl_context) do
     mock('OpenSSL::X509::StoreContext')
   end
@@ -14,8 +14,16 @@ describe Puppet::SSL::Validator do
       :ca_auth_file  => Puppet[:ssl_client_ca_auth])
   end
 
+  let(:ssl_host) do
+    stub('ssl_host',
+         :ssl_store => nil,
+         :certificate => stub('cert', :content => nil),
+         :key => stub('key', :content => nil))
+  end
+
   subject do
-    described_class.new(:ssl_configuration => ssl_configuration)
+    described_class.new(ssl_configuration,
+                        ssl_host)
   end
 
   before :each do
@@ -49,17 +57,20 @@ describe Puppet::SSL::Validator do
         before :each do
           ssl_context.stubs(:error_string).returns("Something went wrong.")
         end
+
         it 'does not make the error available via #verify_errors' do
           subject.call(true, ssl_context)
           subject.verify_errors.should == []
         end
       end
+
       context 'and the chain is valid' do
         it 'is true for each CA certificate in the chain' do
           (cert_chain.length - 1).times do
             subject.call(true, ssl_context).should be_true
           end
         end
+
         it 'is true for the SSL certificate ending the chain' do
           (cert_chain.length - 1).times do
             subject.call(true, ssl_context)
@@ -67,17 +78,20 @@ describe Puppet::SSL::Validator do
           subject.call(true, ssl_context).should be_true
         end
       end
+
       context 'and the chain is invalid' do
         before :each do
           ssl_configuration.stubs(:read_file).
             with(Puppet[:localcacert]).
             returns(agent_ca)
         end
+
         it 'is true for each CA certificate in the chain' do
           (cert_chain.length - 1).times do
             subject.call(true, ssl_context).should be_true
           end
         end
+
         it 'is false for the SSL certificate ending the chain' do
           (cert_chain.length - 1).times do
             subject.call(true, ssl_context)
@@ -85,13 +99,16 @@ describe Puppet::SSL::Validator do
           subject.call(true, ssl_context).should be_false
         end
       end
+
       context 'an error is raised inside of #call' do
         before :each do
           ssl_context.expects(:current_cert).raises(StandardError, "BOOM!")
         end
+
         it 'is false' do
           subject.call(true, ssl_context).should be_false
         end
+
         it 'makes the error available through #verify_errors' do
           subject.call(true, ssl_context)
           subject.verify_errors.should == ["BOOM!"]
@@ -100,11 +117,28 @@ describe Puppet::SSL::Validator do
     end
   end
 
-  describe '#register_verify_callback' do
-    it 'registers itself using #verify_callback' do
+  describe '#setup_connection' do
+    it 'updates the connection for verification' do
+      subject.stubs(:ssl_certificates_are_present?).returns(true)
       connection = mock('Net::HTTP')
+
+      connection.expects(:cert_store=).with(ssl_host.ssl_store)
+      connection.expects(:ca_file=).with(ssl_configuration.ca_auth_file)
+      connection.expects(:cert=).with(ssl_host.certificate.content)
+      connection.expects(:key=).with(ssl_host.key.content)
       connection.expects(:verify_callback=).with(subject)
-      subject.register_verify_callback(connection)
+      connection.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+
+      subject.setup_connection(connection)
+    end
+
+    it 'does not perform verification if certificate files are missing' do
+      subject.stubs(:ssl_certificates_are_present?).returns(false)
+      connection = mock('Net::HTTP')
+
+      connection.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+
+      subject.setup_connection(connection)
     end
   end
 
@@ -120,17 +154,21 @@ describe Puppet::SSL::Validator do
       before :each do
         subject.stubs(:has_authz_peer_cert).returns(true)
       end
+
       it 'is true' do
         subject.valid_peer?.should be_true
       end
     end
+
     context 'when the peer presents an invalid chain' do
       before :each do
         subject.stubs(:has_authz_peer_cert).returns(false)
       end
+
       it 'is false' do
         subject.valid_peer?.should be_false
       end
+
       it 'makes a helpful error message available via #verify_errors' do
         subject.valid_peer?
         subject.verify_errors.should == [expected_authz_error_msg]
@@ -143,22 +181,27 @@ describe Puppet::SSL::Validator do
       it 'returns true when the SSL cert is issued by the Master CA' do
         subject.has_authz_peer_cert(cert_chain, [root_ca_cert]).should be_true
       end
+
       it 'returns true when the SSL cert is issued by the Agent CA' do
         subject.has_authz_peer_cert(cert_chain_agent_ca, [root_ca_cert]).should be_true
       end
     end
+
     context 'when the Master CA is listed as authorized' do
       it 'returns false when the SSL cert is issued by the Master CA' do
         subject.has_authz_peer_cert(cert_chain, [master_ca_cert]).should be_true
       end
+
       it 'returns true when the SSL cert is issued by the Agent CA' do
         subject.has_authz_peer_cert(cert_chain_agent_ca, [master_ca_cert]).should be_false
       end
     end
+
     context 'when the Agent CA is listed as authorized' do
       it 'returns true when the SSL cert is issued by the Master CA' do
         subject.has_authz_peer_cert(cert_chain, [agent_ca_cert]).should be_false
       end
+
       it 'returns true when the SSL cert is issued by the Agent CA' do
         subject.has_authz_peer_cert(cert_chain_agent_ca, [agent_ca_cert]).should be_true
       end

data/spec/unit/status_spec.rb

@@ -37,4 +37,13 @@ describe Puppet::Status do
     new_status = Puppet::Status.convert_from('yaml', status.render('yaml'))
     new_status.should equal_attributes_of(status)
   end
+
+  it "serializes to PSON that conforms to the status schema", :unless => Puppet.features.microsoft_windows? do
+    schema = JSON.parse(File.read('api/schemas/status.json'))
+    status = Puppet::Status.new
+    status.version = Puppet.version
+
+    JSON::Validator.validate!(JSON_META_SCHEMA, schema)
+    JSON::Validator.validate!(schema, status.render('pson'))
+  end
 end

data/spec/unit/transaction/event_spec.rb

@@ -15,14 +15,6 @@ end
 describe Puppet::Transaction::Event do
   include PuppetSpec::Files
 
-  [:previous_value, :desired_value, :property, :name, :message, :file, :line, :tags, :audited].each do |attr|
-    it "should support #{attr}" do
-      event = Puppet::Transaction::Event.new
-      event.send(attr.to_s + "=", "foo")
-      event.send(attr).should == "foo"
-    end
-  end
-
   it "should support resource" do
     event = Puppet::Transaction::Event.new
     event.resource = TestResource.new
@@ -101,7 +93,7 @@ describe Puppet::Transaction::Event do
     end
 
     it "should set the tags to the event tags" do
-      Puppet::Util::Log.expects(:new).with { |args| args[:tags] == %w{one two} }
+      Puppet::Util::Log.expects(:new).with { |args| args[:tags].to_a.should =~ %w{one two} }
       Puppet::Transaction::Event.new(:tags => %w{one two}).send_log
     end
 

data/spec/unit/transaction/report_spec.rb

@@ -4,6 +4,19 @@ require 'spec_helper'
 require 'puppet'
 require 'puppet/transaction/report'
 
+# the json-schema gem doesn't support windows
+if not Puppet.features.microsoft_windows?
+  REPORT_SCHEMA_URI = File.join(File.dirname(__FILE__),    '../../../api/schemas/report.json')
+  REPORT_SCHEMA = JSON.parse(File.read(REPORT_SCHEMA_URI))
+
+  describe "report schema" do
+    it "should validate against the json meta-schema" do
+      JSON::Validator.validate!(JSON_META_SCHEMA, REPORT_SCHEMA)
+    end
+  end
+
+end
+
 describe Puppet::Transaction::Report do
   include PuppetSpec::Files
   before do
@@ -392,6 +405,12 @@ describe Puppet::Transaction::Report do
     expect_equivalent_reports(tripped, report)
   end
 
+  it "generates pson which validates against the report schema", :unless => Puppet.features.microsoft_windows? do
+    Puppet[:report_serialization_format] = "pson"
+    report = generate_report
+    JSON::Validator.validate!(REPORT_SCHEMA, report.render)
+  end
+
   it "can make a round trip through yaml" do
     Puppet[:report_serialization_format] = "yaml"
     report = generate_report
@@ -458,7 +477,7 @@ describe Puppet::Transaction::Report do
     status = Puppet::Resource::Status.new(Puppet::Type.type(:notify).new(:title => "a resource"))
     status.changed = true
 
-    report = Puppet::Transaction::Report.new('testy', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
+    report = Puppet::Transaction::Report.new('apply', 1357986, 'test_environment', "df34516e-4050-402d-a166-05b03b940749")
     report << Puppet::Util::Log.new(:level => :warning, :message => "log message")
     report.add_times("timing", 4)
     report.add_resource_status(status)

data/spec/unit/transaction/resource_harness_spec.rb

@@ -127,6 +127,34 @@ describe Puppet::Transaction::ResourceHarness do
           false
         end
       end
+
+      newproperty(:brillig) do
+        desc "A property that raises a StandardError exception when you test if it's insync?"
+        def sync
+        end
+
+        def retrieve
+          :absent
+        end
+
+        def insync?(reference_value)
+          raise ZeroDivisionError.new('brillig')
+        end
+      end
+
+      newproperty(:slithy) do
+        desc "A property that raises an Exception when you test if it's insync?"
+        def sync
+        end
+
+        def retrieve
+          :absent
+        end
+
+        def insync?(reference_value)
+          raise Exception.new('slithy')
+        end
+      end
     end
     stubProvider
   end
@@ -164,6 +192,35 @@ describe Puppet::Transaction::ResourceHarness do
     end
   end
 
+  describe "when a StandardError exception occurs during insync?" do
+    before :each do
+      stub_provider = make_stub_provider
+      @resource = stub_provider.new :name => 'name', :brillig => 1
+      @resource.expects(:err).never
+    end
+
+    it "should record a failure event" do
+      @status = @harness.evaluate(@resource)
+      @status.events[0].name.to_s.should == 'brillig_changed'
+      @status.events[0].property.should == 'brillig'
+      @status.events[0].status.should == 'failure'
+    end
+  end
+
+  describe "when an Exception occurs during insync?" do
+    before :each do
+      stub_provider = make_stub_provider
+      @resource = stub_provider.new :name => 'name', :slithy => 1
+      @resource.expects(:err).never
+    end
+
+    it "should log and pass the exception through" do
+      lambda { @harness.evaluate(@resource) }.should raise_error(Exception, /slithy/)
+      @logs.first.message.should == "change from absent to 1 failed: slithy"
+      @logs.first.level.should == :err
+    end
+  end
+
   describe "when auditing" do
     it "should not call insync? on parameters that are merely audited" do
       stub_provider = make_stub_provider
@@ -180,7 +237,9 @@ describe Puppet::Transaction::ResourceHarness do
       File.open(test_file, 'w').close
       resource = Puppet::Type.type(:file).new :path => test_file, :audit => ['group'], :backup => false
       resource.expects(:err).never # make sure no exceptions get swallowed
+
       status = @harness.evaluate(resource)
+
       status.events.each do |event|
         event.status.should != 'failure'
       end
@@ -188,222 +247,13 @@ describe Puppet::Transaction::ResourceHarness do
   end
 
   describe "when applying changes" do
-    [false, true].each do |noop_mode|; describe (noop_mode ? "in noop mode" : "in normal mode") do
-      [nil, @mode_750].each do |machine_state|; describe (machine_state ? "with a file initially present" : "with no file initially present") do
-        [nil, @mode_750, @mode_755].each do |yaml_mode|
-          [nil, :file, :absent].each do |yaml_ensure|; describe "with mode=#{yaml_mode.inspect} and ensure=#{yaml_ensure.inspect} stored in state.yml" do
-            [false, true].each do |auditing_ensure|
-              [false, true].each do |auditing_mode|
-                auditing = []
-                auditing.push(:mode) if auditing_mode
-                auditing.push(:ensure) if auditing_ensure
-                [nil, :file, :absent].each do |ensure_property| # what we set "ensure" to in the manifest
-                  [nil, @mode_750, @mode_755].each do |mode_property| # what we set "mode" to in the manifest
-                    manifest_settings = {}
-                    manifest_settings[:audit] = auditing if !auditing.empty?
-                    manifest_settings[:ensure] = ensure_property if ensure_property
-                    manifest_settings[:mode] = mode_property if mode_property
-                    describe "with manifest settings #{manifest_settings.inspect}" do; it "should behave properly" do
-                      # Set up preconditions
-                      test_file = tmpfile('foo')
-                      if machine_state
-                        File.open(test_file, 'w', machine_state.to_i(8)).close
-                      end
-
-                      Puppet[:noop] = noop_mode
-                      params = { :path => test_file, :backup => false }
-                      params.merge!(manifest_settings)
-                      resource = Puppet::Type.type(:file).new params
-
-                      @harness.cache(resource, :mode, yaml_mode) if yaml_mode
-                      @harness.cache(resource, :ensure, yaml_ensure) if yaml_ensure
-
-                      fake_time = Time.utc(2011, 'jan', 3, 12, 24, 0)
-                      Time.stubs(:now).returns(fake_time) # So that Puppet::Resource::Status objects will compare properly
-
-                      resource.expects(:err).never # make sure no exceptions get swallowed
-                      status = @harness.evaluate(resource) # do the thing
-
-                      # check that the state of the machine has been properly updated
-                      expected_logs = []
-                      expected_status_events = []
-                      if auditing_mode
-                        @harness.cached(resource, :mode).should == (machine_state || :absent)
-                      else
-                        @harness.cached(resource, :mode).should == yaml_mode
-                      end
-                      if auditing_ensure
-                        @harness.cached(resource, :ensure).should == (machine_state ? :file : :absent)
-                      else
-                        @harness.cached(resource, :ensure).should == yaml_ensure
-                      end
-                      if ensure_property == :file
-                        file_would_be_there_if_not_noop = true
-                      elsif ensure_property == nil
-                        file_would_be_there_if_not_noop = machine_state != nil
-                      else # ensure_property == :absent
-                        file_would_be_there_if_not_noop = false
-                      end
-                      file_should_be_there = noop_mode ? machine_state != nil : file_would_be_there_if_not_noop
-                      File.exists?(test_file).should == file_should_be_there
-                      if file_should_be_there
-                        if noop_mode
-                          expected_file_mode = machine_state
-                        else
-                          expected_file_mode = mode_property || machine_state
-                        end
-                        if !expected_file_mode
-                          # we didn't specify a mode and the file was created, so mode comes from umode
-                        else
-                          file_mode = File.stat(test_file).mode & 0777
-                          file_mode.should == expected_file_mode.to_i(8)
-                        end
-                      end
-
-                      # Test log output for the "mode" parameter
-                      previously_recorded_mode_already_logged = false
-                      mode_status_msg = nil
-                      if machine_state && file_would_be_there_if_not_noop && mode_property && machine_state != mode_property
-                        if noop_mode
-                          what_happened = "current_value #{machine_state}, should be #{mode_property} (noop)"
-                          expected_status = 'noop'
-                        else
-                          what_happened = "mode changed '#{machine_state}' to '#{mode_property}'"
-                          expected_status = 'success'
-                        end
-                        if auditing_mode && yaml_mode && yaml_mode != machine_state
-                          previously_recorded_mode_already_logged = true
-                          mode_status_msg = "#{what_happened} (previously recorded value was #{yaml_mode})"
-                        else
-                          mode_status_msg = what_happened
-                        end
-                        expected_logs << "notice: /#{resource}/mode: #{mode_status_msg}"
-                      end
-                      if @harness.cached(resource, :mode) && @harness.cached(resource, :mode) != yaml_mode
-                        if yaml_mode
-                          unless previously_recorded_mode_already_logged
-                            mode_status_msg = "audit change: previously recorded value #{yaml_mode} has been changed to #{@harness.cached(resource, :mode)}"
-                            expected_logs << "notice: /#{resource}/mode: #{mode_status_msg}"
-                            expected_status = 'audit'
-                          end
-                        else
-                          expected_logs << "notice: /#{resource}/mode: audit change: newly-recorded value #{@harness.cached(resource, :mode)}"
-                        end
-                      end
-                      if mode_status_msg
-                        expected_status_events << Puppet::Transaction::Event.new(
-                            :source_description => "/#{resource}/mode", :resource => resource, :file => nil,
-                            :line => nil, :tags => %w{file}, :desired_value => mode_property,
-                            :historical_value => yaml_mode, :message => mode_status_msg, :name => :mode_changed,
-                            :previous_value => machine_state || :absent, :property => :mode, :status => expected_status,
-                            :audited => auditing_mode)
-                      end
-
-                      # Test log output for the "ensure" parameter
-                      previously_recorded_ensure_already_logged = false
-                      ensure_status_msg = nil
-                      if file_would_be_there_if_not_noop != (machine_state != nil)
-                        if noop_mode
-                          what_happened = "current_value #{machine_state ? 'file' : 'absent'}, should be #{file_would_be_there_if_not_noop ? 'file' : 'absent'} (noop)"
-                          expected_status = 'noop'
-                        else
-                          what_happened = file_would_be_there_if_not_noop ? 'created' : 'removed'
-                          expected_status = 'success'
-                        end
-                        if auditing_ensure && yaml_ensure && yaml_ensure != (machine_state ? :file : :absent)
-                          previously_recorded_ensure_already_logged = true
-                          ensure_status_msg = "#{what_happened} (previously recorded value was #{yaml_ensure})"
-                        else
-                          ensure_status_msg = "#{what_happened}"
-                        end
-                        expected_logs << "notice: /#{resource}/ensure: #{ensure_status_msg}"
-                      end
-                      if @harness.cached(resource, :ensure) && @harness.cached(resource, :ensure) != yaml_ensure
-                        if yaml_ensure
-                          unless previously_recorded_ensure_already_logged
-                            ensure_status_msg = "audit change: previously recorded value #{yaml_ensure} has been changed to #{@harness.cached(resource, :ensure)}"
-                            expected_logs << "notice: /#{resource}/ensure: #{ensure_status_msg}"
-                            expected_status = 'audit'
-                          end
-                        else
-                          expected_logs << "notice: /#{resource}/ensure: audit change: newly-recorded value #{@harness.cached(resource, :ensure)}"
-                        end
-                      end
-                      if ensure_status_msg
-                        if ensure_property == :file
-                          ensure_event_name = :file_created
-                        elsif ensure_property == nil
-                          ensure_event_name = :file_changed
-                        else # ensure_property == :absent
-                          ensure_event_name = :file_removed
-                        end
-                        expected_status_events << Puppet::Transaction::Event.new(
-                            :source_description => "/#{resource}/ensure", :resource => resource, :file => nil,
-                            :line => nil, :tags => %w{file}, :desired_value => ensure_property,
-                            :historical_value => yaml_ensure, :message => ensure_status_msg, :name => ensure_event_name,
-                            :previous_value => machine_state ? :file : :absent, :property => :ensure,
-                            :status => expected_status, :audited => auditing_ensure)
-                      end
-
-                      # Actually check the logs.
-                      @logs.map {|l| "#{l.level}: #{l.source}: #{l.message}"}.should =~ expected_logs
-
-                      # All the log messages should show up as events except the "newly-recorded" ones.
-                      expected_event_logs = @logs.reject {|l| l.message =~ /newly-recorded/ }
-                      status.events.map {|e| e.message}.should =~ expected_event_logs.map {|l| l.message }
-                      events_to_hash(status.events).should =~ events_to_hash(expected_status_events)
-
-                      # Check change count - this is the number of changes that actually occurred.
-                      expected_change_count = 0
-                      if (machine_state != nil) != file_should_be_there
-                        expected_change_count = 1
-                      elsif machine_state != nil
-                        if expected_file_mode != machine_state
-                          expected_change_count = 1
-                        end
-                      end
-                      status.change_count.should == expected_change_count
-
-                      # Check out of sync count - this is the number
-                      # of changes that would have occurred in
-                      # non-noop mode.
-                      expected_out_of_sync_count = 0
-                      if (machine_state != nil) != file_would_be_there_if_not_noop
-                        expected_out_of_sync_count = 1
-                      elsif machine_state != nil
-                        if mode_property != nil && mode_property != machine_state
-                          expected_out_of_sync_count = 1
-                        end
-                      end
-                      if !noop_mode
-                        expected_out_of_sync_count.should == expected_change_count
-                      end
-                      status.out_of_sync_count.should == expected_out_of_sync_count
-
-                      # Check legacy summary fields
-                      status.changed.should == (expected_change_count != 0)
-                      status.out_of_sync.should == (expected_out_of_sync_count != 0)
-
-                      # Check the :synced field on state.yml
-                      synced_should_be_set = !noop_mode && status.changed
-                      (@harness.cached(resource, :synced) != nil).should == synced_should_be_set
-                    end; end
-                  end
-                end
-              end
-            end
-          end; end
-        end
-      end; end
-    end; end
-
     it "should not apply changes if allow_changes?() returns false" do
       test_file = tmpfile('foo')
       resource = Puppet::Type.type(:file).new :path => test_file, :backup => false, :ensure => :file
       resource.expects(:err).never # make sure no exceptions get swallowed
       @harness.expects(:allow_changes?).with(resource).returns false
       status = @harness.evaluate(resource)
-      File.exists?(test_file).should == false
+      Puppet::FileSystem::File.exist?(test_file).should == false
     end
   end