puppet 3.3.0 → 3.3.1.rc1

data/spec/unit/network/http/handler_spec.rb

@@ -146,7 +146,11 @@ describe Puppet::Network::HTTP::Handler do
   end
 
   describe "when processing a request" do
-    let(:response) { mock('http response') }
+    let(:response) do
+      obj = stub "http 200 ok"
+      obj.stubs(:[]=).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION, Puppet.version)
+      obj
+    end
 
     before do
       handler.stubs(:check_authorization)
@@ -230,13 +234,13 @@ describe Puppet::Network::HTTP::Handler do
     it "should set the format to text/plain when serializing an exception" do
       handler.expects(:set_content_type).with(response, "text/plain")
 
-      handler.do_exception(response, "A test", 404)
+      handler.do_exception(response, Exception.new("A test"), 404)
     end
 
     it "sends an exception string with the given status" do
       handler.expects(:set_response).with(response, "A test", 404)
 
-      handler.do_exception(response, "A test", 404)
+      handler.do_exception(response, Exception.new("A test"), 404)
     end
 
     it "sends an exception error with the exception's status" do
@@ -249,6 +253,16 @@ describe Puppet::Network::HTTP::Handler do
       handler.process(request, response)
     end
 
+    it "logs an HTTP response exception at info level (most are harmless)" do
+      data = Puppet::TestModel.new("not_found", "not found")
+      error = Puppet::Network::HTTP::Handler::HTTPNotFoundError.new("Could not find test_model not_found")
+
+      request = a_request_that_finds(data, :accept_header => "pson")
+      Puppet.expects(:info).with(error.message)
+
+      handler.process(request, response)
+    end
+
     it "should raise an error if the request is formatted in an unknown format" do
       handler.stubs(:content_type_header).returns "unknown format"
       lambda { handler.request_format(request) }.should raise_error

data/spec/unit/pops/adaptable_spec.rb

@@ -92,8 +92,6 @@ describe Puppet::Pops::Adaptable::Adapter do
     a.value = 10
     b = Farm::FarmAdapter.get(d)
     b.value.should == 10
-    # Test implementation detail
-    d.instance_variables.include?(:@Farm_FarmAdapter).should == true
   end
 
   it "should be able to clear the adapter" do

data/spec/unit/provider/package/dpkg_spec.rb

@@ -49,7 +49,7 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
   end
 
   it "should have documentation" do
-    provider_class.doc.should be_instance_of(String)
+    expect(provider_class.doc).to be_instance_of(String)
   end
 
   describe "when listing all instances" do
@@ -66,7 +66,7 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
       installed = mock 'bash'
       provider_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :description => "GNU Bourne Again SHell", :provider => :dpkg).returns installed
 
-      provider_class.instances.should == [installed]
+      expect(provider_class.instances).to eq([installed])
     end
 
     it "should parse multiple dpkg-query multi-line entries in the output" do
@@ -77,7 +77,7 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
       vim = mock 'vim'
       provider_class.expects(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :description => "Vi IMproved - enhanced vi editor", :provider => :dpkg).returns vim
 
-      provider_class.instances.should == [bash, vim]
+      expect(provider_class.instances).to eq([bash, vim])
     end
 
     it "should warn on and ignore any lines it does not understand" do
@@ -86,7 +86,7 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
       Puppet.expects(:warning)
       provider_class.expects(:new).never
 
-      provider_class.instances.should == []
+      expect(provider_class.instances).to eq([])
     end
 
     it "should not warn on extra multiline description lines which we are ignoring" do
@@ -105,7 +105,7 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
       vim = mock 'vim'
       provider_class.expects(:new).twice.returns(bash, vim)
 
-      provider_class.instances.should == [bash, vim]
+      expect(provider_class.instances).to eq([bash, vim])
     end
 
     it "should warn on a broken entry while still parsing a good one" do
@@ -122,7 +122,7 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
       saved = mock('saved')
       provider_class.expects(:new).twice.returns(bash, vim)
 
-      provider_class.instances.should == [bash, vim]
+      expect(provider_class.instances).to eq([bash, vim])
     end
   end
 
@@ -148,25 +148,25 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
     it "should consider the package purged if dpkg-query fails" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).raises Puppet::ExecutionFailure.new("eh")
 
-      provider.query[:ensure].should == :purged
+      expect(provider.query[:ensure]).to eq(:purged)
     end
 
     it "should return a hash of the found package status for an installed package" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields bash_installed_io
 
-      provider.query.should == {:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg, :description => "GNU Bourne Again SHell"}
+      expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg, :description => "GNU Bourne Again SHell"})
     end
 
     it "should consider the package absent if the dpkg-query result cannot be interpreted" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields StringIO.new("somebaddata")
 
-      provider.query[:ensure].should == :absent
+      expect(provider.query[:ensure]).to eq(:absent)
     end
 
     it "should fail if an error is discovered" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("ok", "error")
 
-      lambda { provider.query }.should raise_error(Puppet::Error)
+      expect { provider.query }.to raise_error(Puppet::Error)
     end
 
     it "should consider the package purged if it is marked 'not-installed'" do
@@ -174,32 +174,32 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
       not_installed_bash.gsub!(bash_version, "")
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields StringIO.new(not_installed_bash)
 
-      provider.query[:ensure].should == :purged
+      expect(provider.query[:ensure]).to eq(:purged)
     end
 
     it "should consider the package absent if it is marked 'config-files'" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "config-files")
-      provider.query[:ensure].should == :absent
+      expect(provider.query[:ensure]).to eq(:absent)
     end
 
     it "should consider the package absent if it is marked 'half-installed'" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "half-installed")
-      provider.query[:ensure].should == :absent
+      expect(provider.query[:ensure]).to eq(:absent)
     end
 
     it "should consider the package absent if it is marked 'unpacked'" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "unpacked")
-      provider.query[:ensure].should == :absent
+      expect(provider.query[:ensure]).to eq(:absent)
     end
 
     it "should consider the package absent if it is marked 'half-configured'" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "half-configured")
-      provider.query[:ensure].should == :absent
+      expect(provider.query[:ensure]).to eq(:absent)
     end
 
     it "should consider the package held if its state is 'hold'" do
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("install", "hold")
-      provider.query[:ensure].should == :held
+      expect(provider.query[:ensure]).to eq(:held)
     end
   end
 
@@ -233,12 +233,12 @@ desired ok status next-pkg ensure :DESC: next summary
       Puppet.expects(:warning).times(4)
 
       pipe = StringIO.new(broken_description)
-      provider_class.parse_multi_line(pipe).should == package_hash
+      expect(provider_class.parse_multi_line(pipe)).to eq(package_hash)
 
       next_package = package_hash.merge(:name => 'next-pkg', :description => 'next summary')
 
       hash = provider_class.parse_multi_line(pipe) until hash # warn about bad lines
-      hash.should == next_package
+      expect(hash).to eq(next_package)
     end
 
     def parser_test(dpkg_output_string, gold_hash)
@@ -246,7 +246,7 @@ desired ok status next-pkg ensure :DESC: next summary
       Puppet::Util::Execution.expects(:execpipe).with(query_args).yields pipe
       Puppet.expects(:warning).never
 
-      provider.query.should == gold_hash
+      expect(provider.query).to eq(gold_hash)
     end
 
     it "should parse properly even if delimiter is in version" do
@@ -289,10 +289,18 @@ desired ok status name ensure :DESC: summary text
       no_description = "desired ok status name ensure :DESC: \n:DESC:"
       parser_test(no_description, package_hash.merge(:description => ''))
     end
+
+    it "parses dpkg reporting that package does not exist without warning about a failed match (#22529)" do
+      Puppet.expects(:warning).never
+      pipe = StringIO.new("No packages found matching non-existent-package")
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields(pipe).raises(Puppet::ExecutionFailure.new('no package found'))
+
+      expect(provider.query).to eq({:ensure=>:purged, :status=>"missing", :name=>"name", :error=>"ok"})
+    end
   end
 
   it "should be able to install" do
-    provider.should respond_to(:install)
+    expect(provider).to respond_to(:install)
   end
 
   describe "when installing" do
@@ -303,7 +311,7 @@ desired ok status name ensure :DESC: summary text
     it "should fail to install if no source is specified in the resource" do
       resource.expects(:[]).with(:source).returns nil
 
-      lambda { provider.install }.should raise_error(ArgumentError)
+      expect { provider.install }.to raise_error(ArgumentError)
     end
 
     it "should use 'dpkg -i' to install the package" do
@@ -373,7 +381,7 @@ desired ok status name ensure :DESC: summary text
     it "should return the version found by dpkg-deb" do
       resource.expects(:[]).with(:source).returns "myfile"
       provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "package\t1.0"
-      provider.latest.should == "1.0"
+      expect(provider.latest).to eq("1.0")
     end
 
     it "should warn if the package file contains a different package" do
@@ -386,7 +394,7 @@ desired ok status name ensure :DESC: summary text
       resource = stub 'resource', :[] => "package++"
       provider = provider_class.new(resource)
       provider.expects(:dpkg_deb).returns "package++\t1.0"
-      provider.latest.should == "1.0"
+      expect(provider.latest).to eq("1.0")
     end
   end
 

data/spec/unit/provider/package/rpm_spec.rb

@@ -76,7 +76,7 @@ describe provider_class do
 
       installed_packages = subject.instances
 
-      installed_packages[0].properties.should ==
+      expect(installed_packages[0].properties).to eq(
         {
           :provider => :rpm,
           :name => "cracklib-dicts",
@@ -87,7 +87,8 @@ describe provider_class do
           :ensure => "2.8.9-3.3",
           :description => "The standard CrackLib dictionaries",
         }
-      installed_packages[1].properties.should ==
+      )
+      expect(installed_packages[1].properties).to eq(
         {
           :provider => :rpm,
           :name => "basesystem",
@@ -98,7 +99,8 @@ describe provider_class do
           :ensure => "8.0-5.1.1.el5.centos",
           :description => "The skeleton package which defines a simple Red Hat Enterprise Linux system",
         }
-      installed_packages[2].properties.should ==
+      )
+      expect(installed_packages[2].properties).to eq(
         {
           :provider => :rpm,
           :name => "chkconfig",
@@ -109,7 +111,8 @@ describe provider_class do
           :ensure => "1.3.30.2-2.el5",
           :description => "A system tool for maintaining the /etc/rc*.d hierarchy",
         }
-      installed_packages.last.properties.should ==
+      )
+      expect(installed_packages.last.properties).to eq(
         {
           :provider    => :rpm,
           :name        => "mysummaryless",
@@ -120,6 +123,7 @@ describe provider_class do
           :ensure      => "1.2.3.4-5.el4",
           :description => "",
         }
+      )
     end
   end
 
@@ -157,7 +161,7 @@ describe provider_class do
     it "should retrieve version string after querying rpm for version from source file" do
       resource.expects(:[]).with(:source).returns('source-string')
       Puppet::Util::Execution.expects(:execfail).with(["/bin/rpm", "-q", "--qf", nevra_format, "-p", "source-string"], Puppet::Error).returns("myresource 0 1.2.3.4 5.el4 noarch :DESC:\n")
-      provider.latest.should == "1.2.3.4-5.el4"
+      expect(provider.latest).to eq("1.2.3.4-5.el4")
     end
   end
 
@@ -201,7 +205,7 @@ describe provider_class do
     def parser_test(rpm_output_string, gold_hash, number_of_warnings = 0)
       Puppet.expects(:warning).times(number_of_warnings)
       Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format], execute_options).returns(rpm_output_string)
-      provider.query.should == gold_hash
+      expect(provider.query).to eq(gold_hash)
     end
 
     let(:resource_name) { 'name' }
@@ -258,6 +262,10 @@ describe provider_class do
     it "should warn but not fail if line is unparseable" do
       parser_test('bad data', {}, 1)
     end
+
+    it "should not warn and not fail if rpm returns package not found" do
+      parser_test('package foo is not installed', {}, 0)
+    end
   end
 
   describe ".nodigest" do
@@ -271,7 +279,7 @@ describe provider_class do
       describe "when current version is #{version}" do
         it "should return #{expected.inspect}" do
           subject.stubs(:current_version).returns(version)
-          subject.nodigest.should == expected
+          expect(subject.nodigest).to eq(expected)
         end
       end
     end
@@ -287,7 +295,7 @@ describe provider_class do
       describe "when current version is #{version}" do
         it "should return #{expected.inspect}" do
           subject.stubs(:current_version).returns(version)
-          subject.nosignature.should == expected
+          expect(subject.nosignature).to eq(expected)
         end
       end
     end

data/spec/unit/provider/parsedfile_spec.rb

@@ -2,8 +2,14 @@
 require 'spec_helper'
 require 'puppet_spec/files'
 
+require 'puppet'
 require 'puppet/provider/parsedfile'
 
+Puppet::Type.newtype(:parsedfile_type) do
+  newparam(:name)
+  newproperty(:target)
+end
+
 # Most of the tests for this are still in test/ral/provider/parsedfile.rb.
 describe Puppet::Provider::ParsedFile do
   # The ParsedFile provider class is meant to be used as an abstract base class
@@ -11,64 +17,68 @@ describe Puppet::Provider::ParsedFile do
   # sharing data between classes we construct an anonymous class that inherits
   # the ParsedFile provider instead of directly working with the ParsedFile
   # provider itself.
-  subject { Puppet::Type.newtype(:parsedfile_type).provide(:parsedfile_provider, :parent => described_class) }
+  let(:parsed_type) do
+    Puppet::Type.type(:parsedfile_type)
+  end
+
+  let!(:provider) { parsed_type.provide(:parsedfile_provider, :parent => described_class) }
 
   describe "when looking up records loaded from disk" do
     it "should return nil if no records have been loaded" do
-      subject.record?("foo").should be_nil
+      provider.record?("foo").should be_nil
     end
   end
 
   describe "when generating a list of instances" do
     it "should return an instance for each record parsed from all of the registered targets" do
-      subject.expects(:targets).returns %w{/one /two}
-      subject.stubs(:skip_record?).returns false
+      provider.expects(:targets).returns %w{/one /two}
+      provider.stubs(:skip_record?).returns false
       one = [:uno1, :uno2]
       two = [:dos1, :dos2]
-      subject.expects(:prefetch_target).with("/one").returns one
-      subject.expects(:prefetch_target).with("/two").returns two
+      provider.expects(:prefetch_target).with("/one").returns one
+      provider.expects(:prefetch_target).with("/two").returns two
 
       results = []
       (one + two).each do |inst|
         results << inst.to_s + "_instance"
-        subject.expects(:new).with(inst).returns(results[-1])
+        provider.expects(:new).with(inst).returns(results[-1])
       end
 
-      subject.instances.should == results
+      provider.instances.should == results
     end
 
     it "should ignore target when retrieve fails" do
-      subject.expects(:targets).returns %w{/one /two /three}
-      subject.stubs(:skip_record?).returns false
-      subject.expects(:retrieve).with("/one").returns [
+      provider.expects(:targets).returns %w{/one /two /three}
+      provider.stubs(:skip_record?).returns false
+      provider.expects(:retrieve).with("/one").returns [
         {:name => 'target1_record1'},
         {:name => 'target1_record2'}
       ]
-      subject.expects(:retrieve).with("/two").raises Puppet::Util::FileType::FileReadError, "some error"
-      subject.expects(:retrieve).with("/three").returns [
+      provider.expects(:retrieve).with("/two").raises Puppet::Util::FileType::FileReadError, "some error"
+      provider.expects(:retrieve).with("/three").returns [
         {:name => 'target3_record1'},
         {:name => 'target3_record2'}
       ]
       Puppet.expects(:err).with('Could not prefetch parsedfile_type provider \'parsedfile_provider\' target \'/two\': some error. Treating as empty')
-      subject.expects(:new).with(:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present).returns 'r1'
-      subject.expects(:new).with(:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present).returns 'r2'
-      subject.expects(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).returns 'r3'
-      subject.expects(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).returns 'r4'
+      provider.expects(:new).with(:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present).returns 'r1'
+      provider.expects(:new).with(:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present).returns 'r2'
+      provider.expects(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).returns 'r3'
+      provider.expects(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).returns 'r4'
 
-      subject.instances.should == %w{r1 r2 r3 r4}
+      provider.instances.should == %w{r1 r2 r3 r4}
     end
 
     it "should skip specified records" do
-      subject.expects(:targets).returns %w{/one}
-      subject.expects(:skip_record?).with(:uno).returns false
-      subject.expects(:skip_record?).with(:dos).returns true
+      provider.expects(:targets).returns %w{/one}
+      provider.expects(:skip_record?).with(:uno).returns false
+      provider.expects(:skip_record?).with(:dos).returns true
       one = [:uno, :dos]
-      subject.expects(:prefetch_target).returns one
+      provider.expects(:prefetch_target).returns one
 
-      subject.expects(:new).with(:uno).returns "eh"
-      subject.expects(:new).with(:dos).never
+      provider.expects(:new).with(:uno).returns "eh"
+      provider.expects(:new).with(:dos).never
 
-      subject.instances
+      provider.instances
     end
   end
 
@@ -80,22 +90,22 @@ describe Puppet::Provider::ParsedFile do
 
     it "returns a resource if the record name matches the resource name" do
       record = {:name => :one}
-      subject.resource_for_record(record, resources).should be first_resource
+      provider.resource_for_record(record, resources).should be first_resource
     end
 
     it "doesn't return a resource if the record name doesn't match any resource names" do
       record = {:name => :three}
-      subject.resource_for_record(record, resources).should be_nil
+      provider.resource_for_record(record, resources).should be_nil
     end
   end
 
   describe "when flushing a file's records to disk" do
     before do
       # This way we start with some @records, like we would in real life.
-      subject.stubs(:retrieve).returns []
-      subject.default_target = "/foo/bar"
-      subject.initvars
-      subject.prefetch
+      provider.stubs(:retrieve).returns []
+      provider.default_target = "/foo/bar"
+      provider.initvars
+      provider.prefetch
 
       @filetype = Puppet::Util::FileType.filetype(:flat).new("/my/file")
       Puppet::Util::FileType.filetype(:flat).stubs(:new).with("/my/file").returns @filetype
@@ -106,7 +116,7 @@ describe Puppet::Provider::ParsedFile do
     it "should back up the file being written if the filetype can be backed up" do
       @filetype.expects(:backup)
 
-      subject.flush_target("/my/file")
+      provider.flush_target("/my/file")
     end
 
     it "should not try to back up the file if the filetype cannot be backed up" do
@@ -115,22 +125,51 @@ describe Puppet::Provider::ParsedFile do
 
       @filetype.stubs(:write)
 
-      subject.flush_target("/my/file")
+      provider.flush_target("/my/file")
     end
 
     it "should not back up the file more than once between calls to 'prefetch'" do
       @filetype.expects(:backup).once
 
-      subject.flush_target("/my/file")
-      subject.flush_target("/my/file")
+      provider.flush_target("/my/file")
+      provider.flush_target("/my/file")
     end
 
     it "should back the file up again once the file has been reread" do
       @filetype.expects(:backup).times(2)
 
-      subject.flush_target("/my/file")
-      subject.prefetch
-      subject.flush_target("/my/file")
+      provider.flush_target("/my/file")
+      provider.prefetch
+      provider.flush_target("/my/file")
+    end
+  end
+
+  describe "when flushing multiple files" do
+    describe "and an error is encountered" do
+      it "the other file does not fail" do
+        provider.stubs(:backup_target)
+
+        bad_file = 'broken'
+        good_file = 'writable'
+
+        bad_writer = mock 'bad'
+        bad_writer.expects(:write).raises(Exception, "Failed to write to bad file")
+
+        good_writer = mock 'good'
+        good_writer.expects(:write).returns(nil)
+
+        provider.stubs(:target_object).with(bad_file).returns(bad_writer)
+        provider.stubs(:target_object).with(good_file).returns(good_writer)
+
+        bad_resource = parsed_type.new(:name => 'one', :target => bad_file)
+        good_resource = parsed_type.new(:name => 'two', :target => good_file)
+
+        expect {
+          bad_resource.flush
+        }.to raise_error(Exception, "Failed to write to bad file")
+
+        good_resource.flush
+      end
     end
   end
 end
@@ -141,7 +180,7 @@ describe "A very basic provider based on ParsedFile" do
   let(:input_text) { File.read(my_fixture('simple.txt')) }
   let(:target) { tmpfile('parsedfile_spec') }
 
-  subject do
+  let(:provider) do
     example_provider_class = Class.new(Puppet::Provider::ParsedFile)
     example_provider_class.default_target = target
     # Setup some record rules
@@ -158,31 +197,31 @@ describe "A very basic provider based on ParsedFile" do
 
   context "writing file contents back to disk" do
     it "should not change anything except from adding a header" do
-      input_records = subject.parse(input_text)
-      subject.to_file(input_records).
-        should match subject.header + input_text
+      input_records = provider.parse(input_text)
+      provider.to_file(input_records).
+        should match provider.header + input_text
     end
   end
 
   context "rewriting a file containing a native header" do
     let(:regex) { %r/^# HEADER.*third party\.\n/ }
-    let(:input_records) { subject.parse(input_text) }
+    let(:input_records) { provider.parse(input_text) }
 
     before :each do
-      subject.stubs(:native_header_regex).returns(regex)
+      provider.stubs(:native_header_regex).returns(regex)
     end
 
     it "should move the native header to the top" do
-      subject.to_file(input_records).should_not match /\A#{subject.header}/
+      provider.to_file(input_records).should_not match /\A#{provider.header}/
     end
 
     context "and dropping native headers found in input" do
       before :each do
-        subject.stubs(:drop_native_header).returns(true)
+        provider.stubs(:drop_native_header).returns(true)
       end
 
       it "should not include the native header in the output" do
-        subject.to_file(input_records).should_not match regex
+        provider.to_file(input_records).should_not match regex
       end
     end
   end