puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

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

@@ -1,327 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:zypper) do
-  before(:each) do
-    # Create a mock resource
-    @resource = double('resource')
-
-    # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
-
-    # But set name and source
-    allow(@resource).to receive(:[]).with(:name).and_return("mypackage")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
-    allow(@resource).to receive(:command).with(:zypper).and_return("/usr/bin/zypper")
-
-    @provider = described_class.new(@resource)
-  end
-
-  it "should have an install method" do
-    @provider = described_class.new
-    expect(@provider).to respond_to(:install)
-  end
-
-  it "should have an uninstall method" do
-    @provider = described_class.new
-    expect(@provider).to respond_to(:uninstall)
-  end
-
-  it "should have an update method" do
-    @provider = described_class.new
-    expect(@provider).to respond_to(:update)
-  end
-
-  it "should have a latest method" do
-    @provider = described_class.new
-    expect(@provider).to respond_to(:latest)
-  end
-
-  it "should have a install_options method" do
-    @provider = described_class.new
-    expect(@provider).to respond_to(:install_options)
-  end
-
-  context "when installing with zypper version >= 1.0" do
-    it "should use a command-line with versioned package'" do
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
-
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage-1.2.3-4.5.6')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
-      @provider.install
-    end
-
-    it "should use a command-line without versioned package" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:latest)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
-      @provider.install
-    end
-  end
-
-  context "when installing with zypper version = 0.6.104" do
-    it "should use a command-line with versioned package'" do
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.104")
-
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage-1.2.3-4.5.6')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
-      @provider.install
-    end
-
-    it "should use a command-line without versioned package" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:latest)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.104")
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
-      @provider.install
-    end
-  end
-
-  context "when installing with zypper version = 0.6.13" do
-    it "should use a command-line with versioned package'" do
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.13")
-
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--no-confirm', 'mypackage-1.2.3-4.5.6')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
-      @provider.install
-    end
-
-    it "should use a command-line without versioned package" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:latest)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.13")
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
-      @provider.install
-    end
-  end
-
-  context "when updating" do
-    it "should call install method of instance" do
-      expect(@provider).to receive(:install)
-      @provider.update
-    end
-  end
-
-  context "when getting latest version" do
-    after { described_class.reset! }
-
-    context "when the package has available update" do
-      it "should return a version string with valid list-updates data from SLES11sp1" do
-        fake_data = File.read(my_fixture('zypper-list-updates-SLES11sp1.out'))
-        allow(@resource).to receive(:[]).with(:name).and_return("at")
-        expect(described_class).to receive(:zypper).with("list-updates").and_return(fake_data)
-        expect(@provider.latest).to eq("3.1.8-1069.18.2")
-      end
-    end
-
-    context "when the package is in the latest version" do
-      it "should return nil with valid list-updates data from SLES11sp1" do
-        fake_data = File.read(my_fixture('zypper-list-updates-SLES11sp1.out'))
-        allow(@resource).to receive(:[]).with(:name).and_return("zypper-log")
-        expect(described_class).to receive(:zypper).with("list-updates").and_return(fake_data)
-        expect(@provider.latest).to eq(nil)
-      end
-    end
-
-    context "when there are no updates available" do
-      it "should return nil" do
-        fake_data_empty = File.read(my_fixture('zypper-list-updates-empty.out'))
-        allow(@resource).to receive(:[]).with(:name).and_return("at")
-        expect(described_class).to receive(:zypper).with("list-updates").and_return(fake_data_empty)
-        expect(@provider.latest).to eq(nil)
-      end
-    end
-  end
-
-  context "should install a virtual package" do
-    it "when zypper version = 0.6.13" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
-      allow(@resource).to receive(:allow_virtual?).and_return(true)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.13")
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
-      @provider.install
-    end
-
-    it "when zypper version >= 1.0.0" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
-      allow(@resource).to receive(:allow_virtual?).and_return(true)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
-      @provider.install
-    end
-  end
-
-  context "when installing with zypper install options" do
-    it "should install the package without checking keys" do
-      allow(@resource).to receive(:[]).with(:name).and_return("php5")
-      allow(@resource).to receive(:[]).with(:install_options).and_return(['--no-gpg-check', {'-p' => '/vagrant/files/localrepo/'}])
-      allow(@resource).to receive(:should).with(:ensure).and_return("5.4.10-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
-
-      expect(@provider).to receive(:zypper).with('--quiet', '--no-gpg-check', :install,
-        '--auto-agree-with-licenses', '--no-confirm', '-p=/vagrant/files/localrepo/', 'php5-5.4.10-4.5.6')
-      expect(@provider).to receive(:query).and_return("php5 0 5.4.10 4.5.6 x86_64")
-      @provider.install
-    end
-
-    it "should install the package with --no-gpg-checks" do
-      allow(@resource).to receive(:[]).with(:name).and_return("php5")
-      allow(@resource).to receive(:[]).with(:install_options).and_return(['--no-gpg-checks', {'-p' => '/vagrant/files/localrepo/'}])
-      allow(@resource).to receive(:should).with(:ensure).and_return("5.4.10-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
-
-      expect(@provider).to receive(:zypper).with('--quiet', '--no-gpg-checks', :install,
-        '--auto-agree-with-licenses', '--no-confirm', '-p=/vagrant/files/localrepo/', 'php5-5.4.10-4.5.6')
-      expect(@provider).to receive(:query).and_return("php5 0 5.4.10 4.5.6 x86_64")
-      @provider.install
-    end
-
-    it "should install package with hash install options" do
-      allow(@resource).to receive(:[]).with(:name).and_return('vim')
-      allow(@resource).to receive(:[]).with(:install_options).and_return([{ '--a' => 'foo', '--b' => '"quoted bar"' }])
-      allow(@resource).to receive(:should).with(:ensure).and_return(:present)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-
-      allow(@provider).to receive(:zypper_version).and_return('1.2.8')
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a=foo', '--b="quoted bar"', '--name', 'vim')
-      expect(@provider).to receive(:query).and_return('package vim is not installed')
-      @provider.install
-    end
-
-    it "should install package with array install options" do
-      allow(@resource).to receive(:[]).with(:name).and_return('vim')
-      allow(@resource).to receive(:[]).with(:install_options).and_return([['--a', '--b', '--c']])
-      allow(@resource).to receive(:should).with(:ensure).and_return(:present)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-
-      allow(@provider).to receive(:zypper_version).and_return('1.2.8')
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a', '--b', '--c', '--name', 'vim')
-      expect(@provider).to receive(:query).and_return('package vim is not installed')
-      @provider.install
-    end
-
-    it "should install package with string install options" do
-      allow(@resource).to receive(:[]).with(:name).and_return('vim')
-      allow(@resource).to receive(:[]).with(:install_options).and_return(['--a --b --c'])
-      allow(@resource).to receive(:should).with(:ensure).and_return(:present)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-
-      allow(@provider).to receive(:zypper_version).and_return('1.2.8')
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a --b --c', '--name', 'vim')
-      expect(@provider).to receive(:query).and_return('package vim is not installed')
-      @provider.install
-    end
-  end
-
-  context 'when uninstalling' do
-    it 'should use remove to uninstall on zypper version 1.6 and above' do
-      allow(@provider).to receive(:zypper_version).and_return('1.6.308')
-      expect(@provider).to receive(:zypper).with(:remove, '--no-confirm', 'mypackage')
-      @provider.uninstall
-    end
-
-    it 'should use remove  --force-solution to uninstall on zypper versions between 1.0 and 1.6' do
-      allow(@provider).to receive(:zypper_version).and_return('1.0.2')
-      expect(@provider).to receive(:zypper).with(:remove, '--no-confirm', '--force-resolution', 'mypackage')
-      @provider.uninstall
-    end
-  end
-
-  context 'when installing with VersionRange' do
-    let(:search_output) { File.read(my_fixture('zypper-search-uninstalled.out')) }
-
-    before(:each) do
-      allow(@resource).to receive(:[]).with(:name).and_return('vim')
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return('1.0.2')
-
-      expect(@provider).to receive(:zypper).with('search', '--match-exact', '--type', 'package', '--uninstalled-only', '-s', 'vim')
-                                           .and_return(search_output)
-    end
-
-    it 'does install the package if version is available' do
-      expect(@resource).to receive(:should).with(:ensure).and_return('>1.0')
-
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'vim-1.0.20040813-19.9')
-      expect(@provider).to receive(:query).and_return('vim 0 1.0.20040813 19.9 x86_64')
-
-      @provider.install
-    end
-
-    it 'does consider range as version if version in range is not available' do
-      allow(@resource).to receive(:should).with(:ensure).and_return('>2.0')
-
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'vim->2.0')
-                             .and_raise(Puppet::ExecutionFailure.new('My Error'))
-
-      expect { @provider.install }.to raise_error(Puppet::ExecutionFailure, 'My Error')
-    end
-  end
-
-  describe 'insync?' do
-    subject { @provider.insync?('1.19-2') }
-
-    context 'when versions are matching' do
-      before { allow(@resource).to receive(:[]).with(:ensure).and_return('1.19-2') }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when version are not matching' do
-      before { allow(@resource).to receive(:[]).with(:ensure).and_return('1.19-3') }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when version is in gt range' do
-      before { allow(@resource).to receive(:[]).with(:ensure).and_return('>1.19-0') }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when version is not in gt range' do
-      before { allow(@resource).to receive(:[]).with(:ensure).and_return('>1.19-2') }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when version is in min-max range' do
-      before { allow(@resource).to receive(:[]).with(:ensure).and_return('>1.19-0 <1.19-3') }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when version is not in min-max range' do
-      before { allow(@resource).to receive(:[]).with(:ensure).and_return('>1.19-0 <1.19-2') }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when using eq range' do
-      context 'when ensure without release' do
-        before { allow(@resource).to receive(:[]).with(:ensure).and_return('1.19') }
-
-        it { is_expected.to be true }
-      end
-
-      context 'when ensure with release' do
-        before { allow(@resource).to receive(:[]).with(:ensure).and_return('1.19-2') }
-
-        it { is_expected.to be true }
-      end
-    end
-  end
-end

data/spec/unit/provider/package_targetable_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-require 'puppet'
-require 'puppet/provider/package_targetable'
-require 'puppet/provider/package/gem'
-
-describe Puppet::Provider::Package::Targetable do
-  let(:provider) { Puppet::Type.type(:package).provider(:gem) }
-  let(:command)  { '/opt/bin/gem' }
-
-  describe "when prefetching" do
-    context "with a package without a command attribute" do
-      let(:resource) { Puppet::Type.type(:package).new(:name => 'noo', :provider => 'gem', :ensure => :present) }
-      let(:catalog)  { Puppet::Resource::Catalog.new }
-      let(:instance) { provider.new(resource) }
-      let(:packages) { { 'noo' => resource } }
-
-      it "should pass a command to the instances method of the provider" do
-        catalog.add_resource(resource)
-        expect(provider).to receive(:instances).with(nil).and_return([instance])
-        expect(provider.prefetch(packages)).to eq([nil]) # prefetch arbitrarily returns the array of commands for a provider in the catalog
-      end
-    end
-
-    context "with a package with a command attribute" do
-      let(:resource) { Puppet::Type.type(:package).new(:name => 'noo', :provider => 'gem', :ensure => :present) }
-      let(:resource_targeted) { Puppet::Type.type(:package).new(:name => 'yes', :provider => 'gem', :command => command, :ensure => :present) }
-      let(:catalog)  { Puppet::Resource::Catalog.new }
-      let(:instance) { provider.new(resource) }
-      let(:instance_targeted) { provider.new(resource_targeted) }
-      let(:packages) { { 'noo' => resource, 'yes' => resource_targeted } }
-
-      it "should pass the command to the instances method of the provider" do
-        catalog.add_resource(resource)
-        catalog.add_resource(resource_targeted)
-        expect(provider).to receive(:instances).with(nil).and_return([instance])
-        expect(provider).to receive(:instances).with(command).and_return([instance_targeted]).once
-        expect(provider.prefetch(packages)).to eq([nil, command]) # prefetch arbitrarily returns the array of commands for a provider in the catalog
-      end
-    end
-  end
-
-  describe "when validating a command" do
-    context "with no command" do
-      it "report not functional" do
-        expect { provider.validate_command(nil) }.to raise_error(Puppet::Error, "Provider gem package command is not functional on this host")
-      end
-    end
-    context "with a missing command" do
-      it "report does not exist" do
-        expect { provider.validate_command(command) }.to raise_error(Puppet::Error, "Provider gem package command '#{command}' does not exist on this host")
-      end
-    end
-    context "with an existing command" do
-      it "validates" do
-        allow(File).to receive(:file?).with(command).and_return(true)
-        expect { provider.validate_command(command) }.not_to raise_error
-      end
-    end
-  end
-end

data/spec/unit/provider/parsedfile_spec.rb

@@ -1,263 +0,0 @@
-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
-  # but also stores a lot of state within the singleton class. To avoid
-  # sharing data between classes we construct an anonymous class that inherits
-  # the ParsedFile provider instead of directly working with the ParsedFile
-  # provider itself.
-  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
-      expect(provider.record?("foo")).to 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
-      expect(provider).to receive(:targets).and_return(%w{/one /two})
-      allow(provider).to receive(:skip_record?).and_return(false)
-      one = [:uno1, :uno2]
-      two = [:dos1, :dos2]
-      expect(provider).to receive(:prefetch_target).with("/one").and_return(one)
-      expect(provider).to receive(:prefetch_target).with("/two").and_return(two)
-
-      results = []
-      (one + two).each do |inst|
-        results << inst.to_s + "_instance"
-        expect(provider).to receive(:new).with(inst).and_return(results[-1])
-      end
-
-      expect(provider.instances).to eq(results)
-    end
-
-    it "should ignore target when retrieve fails" do
-      expect(provider).to receive(:targets).and_return(%w{/one /two /three})
-      allow(provider).to receive(:skip_record?).and_return(false)
-      expect(provider).to receive(:retrieve).with("/one").and_return([
-        {:name => 'target1_record1'},
-        {:name => 'target1_record2'}
-      ])
-      expect(provider).to receive(:retrieve).with("/two").and_raise(Puppet::Util::FileType::FileReadError, "some error")
-      expect(provider).to receive(:retrieve).with("/three").and_return([
-        {:name => 'target3_record1'},
-        {:name => 'target3_record2'}
-      ])
-      expect(Puppet).to receive(:err).with('Could not prefetch parsedfile_type provider \'parsedfile_provider\' target \'/two\': some error. Treating as empty')
-      expect(provider).to receive(:new).with({:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present}).and_return('r1')
-      expect(provider).to receive(:new).with({:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present}).and_return('r2')
-      expect(provider).to receive(:new).with({:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present}).and_return('r3')
-      expect(provider).to receive(:new).with({:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present}).and_return('r4')
-
-      expect(provider.instances).to eq(%w{r1 r2 r3 r4})
-    end
-
-    it "should skip specified records" do
-      expect(provider).to receive(:targets).and_return(%w{/one})
-      expect(provider).to receive(:skip_record?).with(:uno).and_return(false)
-      expect(provider).to receive(:skip_record?).with(:dos).and_return(true)
-      one = [:uno, :dos]
-      expect(provider).to receive(:prefetch_target).and_return(one)
-
-      expect(provider).to receive(:new).with(:uno).and_return("eh")
-      expect(provider).not_to receive(:new).with(:dos)
-
-      provider.instances
-    end
-
-    it "should raise if parsing returns nil" do
-      expect(provider).to receive(:targets).and_return(%w{/one})
-      expect_any_instance_of(Puppet::Util::FileType::FileTypeFlat).to receive(:read).and_return('a=b')
-      expect(provider).to receive(:parse).and_return(nil)
-
-      expect {
-        provider.instances
-      }.to raise_error(Puppet::DevError, %r{Prefetching /one for provider parsedfile_provider returned nil})
-    end
-  end
-
-  describe "when matching resources to existing records" do
-    let(:first_resource) { double(:one, :name => :one) }
-    let(:second_resource) { double(:two, :name => :two) }
-
-    let(:resources) {{:one => first_resource, :two => second_resource}}
-
-    it "returns a resource if the record name matches the resource name" do
-      record = {:name => :one}
-      expect(provider.resource_for_record(record, resources)).to be first_resource
-    end
-
-    it "doesn't return a resource if the record name doesn't match any resource names" do
-      record = {:name => :three}
-      expect(provider.resource_for_record(record, resources)).to 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.
-      allow(provider).to receive(:retrieve).and_return([])
-      provider.default_target = "/foo/bar"
-      provider.initvars
-      provider.prefetch
-
-      @filetype = Puppet::Util::FileType.filetype(:flat).new("/my/file")
-      allow(Puppet::Util::FileType.filetype(:flat)).to receive(:new).with("/my/file").and_return(@filetype)
-
-      allow(@filetype).to receive(:write)
-    end
-
-    it "should back up the file being written if the filetype can be backed up" do
-      expect(@filetype).to receive(:backup)
-
-      provider.flush_target("/my/file")
-    end
-
-    it "should not try to back up the file if the filetype cannot be backed up" do
-      @filetype = Puppet::Util::FileType.filetype(:ram).new("/my/file")
-      expect(Puppet::Util::FileType.filetype(:flat)).to receive(:new).and_return(@filetype)
-
-      allow(@filetype).to receive(:write)
-
-      provider.flush_target("/my/file")
-    end
-
-    it "should not back up the file more than once between calls to 'prefetch'" do
-      expect(@filetype).to receive(:backup).once
-
-      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
-      expect(@filetype).to receive(:backup).twice
-
-      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
-        allow(provider).to receive(:backup_target)
-
-        bad_file = 'broken'
-        good_file = 'writable'
-
-        bad_writer = double('bad')
-        expect(bad_writer).to receive(:write).and_raise(Exception, "Failed to write to bad file")
-
-        good_writer = double('good')
-        expect(good_writer).to receive(:write).and_return(nil)
-
-        allow(provider).to receive(:target_object).with(bad_file).and_return(bad_writer)
-        allow(provider).to receive(:target_object).with(good_file).and_return(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
-
-describe "A very basic provider based on ParsedFile" do
-  include PuppetSpec::Files
-
-  let(:input_text) { File.read(my_fixture('simple.txt')) }
-  let(:target) { tmpfile('parsedfile_spec') }
-
-  let(:provider) do
-    example_provider_class = Class.new(Puppet::Provider::ParsedFile)
-    example_provider_class.default_target = target
-    # Setup some record rules
-    example_provider_class.instance_eval do
-      text_line :text, :match => %r{.}
-    end
-    example_provider_class.initvars
-    example_provider_class.prefetch
-    # evade a race between multiple invocations of the header method
-    allow(example_provider_class).to receive(:header).
-      and_return("# HEADER As added by puppet.\n")
-    example_provider_class
-  end
-
-  context "writing file contents back to disk" do
-    it "should not change anything except from adding a header" do
-      input_records = provider.parse(input_text)
-      expect(provider.to_file(input_records)).
-        to 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) { provider.parse(input_text) }
-
-    before :each do
-      allow(provider).to receive(:native_header_regex).and_return(regex)
-    end
-
-    it "should move the native header to the top" do
-      expect(provider.to_file(input_records)).not_to match(/\A#{provider.header}/)
-    end
-
-    context "and dropping native headers found in input" do
-      before :each do
-        allow(provider).to receive(:drop_native_header).and_return(true)
-      end
-
-      it "should not include the native header in the output" do
-        expect(provider.to_file(input_records)).not_to match regex
-      end
-    end
-  end
-
-  context 'parsing a record type' do
-    let(:input_text) { File.read(my_fixture('aliases.txt')) }
-    let(:target) { tmpfile('parsedfile_spec') }
-    let(:provider) do
-      example_provider_class = Class.new(Puppet::Provider::ParsedFile)
-      example_provider_class.default_target = target
-      # Setup some record rules
-      example_provider_class.instance_eval do
-        record_line :aliases, :fields =>  %w{manager alias}, :separator => ':'
-      end
-      example_provider_class.initvars
-      example_provider_class.prefetch
-      example_provider_class
-    end
-    let(:expected_result) do
-      [
-        {:manager=>"manager", :alias=>"  root", :record_type=>:aliases},
-        {:manager=>"dumper", :alias=>"   postmaster", :record_type=>:aliases}
-      ]
-    end
-
-    subject { provider.parse(input_text) }
-
-    it { is_expected.to  match_array(expected_result) }
-  end
-end