Elep

require 'spec_helper'
require 'puppet/util/package'

describe Puppet::Type.type(:augeas).provider(:augeas) do
  let(:resource) do
    Puppet::Type.type(:augeas).new(
      name: 'test',
      root: my_fixture_dir,
      provider: :augeas,
    )
  end

let(:provider) do
    resource.provider
  end

let(:logs) do
    # rubocop:disable RSpec/InstanceVariable
    @logs
    # rubocop:enable RSpec/InstanceVariable
  end

after(:each) do
    provider.close_augeas
  end

def my_fixture_dir
    File.expand_path(File.join(File.dirname(__FILE__), '../../../fixtures/unit/provider/augeas/augeas'))
  end

def tmpfile(name)
    Puppet::FileSystem.expand_path(make_tmpname(name, nil).encode(Encoding::UTF_8), Dir.tmpdir)
  end

# Copied from ruby 2.4 source
  def make_tmpname((prefix, suffix), n)
    prefix = (String.try_convert(prefix) ||
              raise(ArgumentError, "unexpected prefix: #{prefix.inspect}"))
    suffix &&= (String.try_convert(suffix) ||
                raise(ArgumentError, "unexpected suffix: #{suffix.inspect}"))
    t = Time.now.strftime('%Y%m%d')
    path = "#{prefix}#{t}-#{$PROCESS_ID}-#{rand(0x100000000).to_s(36)}".dup
    path << "-#{n}" if n
    path << suffix if suffix
    path
  end

describe 'command parsing' do
    it 'ignores nil values when parsing commands' do
      commands = [nil, 'set Jar/Jar Binks']
      tokens = provider.parse_commands(commands)
      expect(tokens.size).to eq(1)
      expect(tokens[0].size).to eq(3)
      expect(tokens[0][0]).to eq('set')
      expect(tokens[0][1]).to eq('Jar/Jar')
      expect(tokens[0][2]).to eq('Binks')
    end

it 'breaks apart a single line into three tokens and clean up the context' do
      resource[:context] = '/context'
      tokens = provider.parse_commands('set Jar/Jar Binks')
      expect(tokens.size).to eq(1)
      expect(tokens[0].size).to eq(3)
      expect(tokens[0][0]).to eq('set')
      expect(tokens[0][1]).to eq('/context/Jar/Jar')
      expect(tokens[0][2]).to eq('Binks')
    end

it 'breaks apart a multiple line into six tokens' do
      tokens = provider.parse_commands("set /Jar/Jar Binks\nrm anakin")
      expect(tokens.size).to eq(2)
      expect(tokens[0].size).to eq(3)
      expect(tokens[1].size).to eq(2)
      expect(tokens[0][0]).to eq('set')
      expect(tokens[0][1]).to eq('/Jar/Jar')
      expect(tokens[0][2]).to eq('Binks')
      expect(tokens[1][0]).to eq('rm')
      expect(tokens[1][1]).to eq('anakin')
    end

it 'strips whitespace and ignore blank lines' do
      tokens = provider.parse_commands("  set /Jar/Jar Binks \t\n  \n\n  rm anakin ")
      expect(tokens.size).to eq(2)
      expect(tokens[0].size).to eq(3)
      expect(tokens[1].size).to eq(2)
      expect(tokens[0][0]).to eq('set')
      expect(tokens[0][1]).to eq('/Jar/Jar')
      expect(tokens[0][2]).to eq('Binks')
      expect(tokens[1][0]).to eq('rm')
      expect(tokens[1][1]).to eq('anakin')
    end

it 'handles arrays' do
      resource[:context] = '/foo/'
      commands = ['set /Jar/Jar Binks', 'rm anakin']
      tokens = provider.parse_commands(commands)
      expect(tokens.size).to eq(2)
      expect(tokens[0].size).to eq(3)
      expect(tokens[1].size).to eq(2)
      expect(tokens[0][0]).to eq('set')
      expect(tokens[0][1]).to eq('/Jar/Jar')
      expect(tokens[0][2]).to eq('Binks')
      expect(tokens[1][0]).to eq('rm')
      expect(tokens[1][1]).to eq('/foo/anakin')
    end

# This is not supported in the new parsing class
    # it "should concat the last values" do
    #    provider = provider_class.new
    #    tokens = provider.parse_commands("set /Jar/Jar Binks is my copilot")
    #    tokens.size.should == 1
    #    tokens[0].size.should == 3
    #    tokens[0][0].should == "set"
    #    tokens[0][1].should == "/Jar/Jar"
    #    tokens[0][2].should == "Binks is my copilot"
    # end

it 'accepts spaces in the value and single ticks' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands("set JarJar 'Binks is my copilot'")
      expect(tokens.size).to eq(1)
      expect(tokens[0].size).to eq(3)
      expect(tokens[0][0]).to eq('set')
      expect(tokens[0][1]).to eq('/foo/JarJar')
      expect(tokens[0][2]).to eq('Binks is my copilot')
    end

it 'accepts spaces in the value and double ticks' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands('set /JarJar "Binks is my copilot"')
      expect(tokens.size).to eq(1)
      expect(tokens[0].size).to eq(3)
      expect(tokens[0][0]).to eq('set')
      expect(tokens[0][1]).to eq('/JarJar')
      expect(tokens[0][2]).to eq('Binks is my copilot')
    end

it 'accepts mixed ticks' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands('set JarJar "Some \'Test\'"')
      expect(tokens.size).to eq(1)
      expect(tokens[0].size).to eq(3)
      expect(tokens[0][0]).to eq('set')
      expect(tokens[0][1]).to eq('/foo/JarJar')
      expect(tokens[0][2]).to eq("Some \'Test\'")
    end

it 'handles predicates with literals' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands("rm */*[module='pam_console.so']")
      expect(tokens).to eq([['rm', "/foo/*/*[module='pam_console.so']"]])
    end

it 'handles whitespace in predicates' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands("ins 42 before /files/etc/hosts/*/ipaddr[ . = '127.0.0.1' ]")
      expect(tokens).to eq([['ins', '42', 'before', "/files/etc/hosts/*/ipaddr[ . = '127.0.0.1' ]"]])
    end

it 'handles multiple predicates' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands("clear pam.d/*/*[module = 'system-auth'][type = 'account']")
      expect(tokens).to eq([['clear', "/foo/pam.d/*/*[module = 'system-auth'][type = 'account']"]])
    end

it 'handles nested predicates' do
      resource[:context] = '/foo/'
      args = ['clear', "/foo/pam.d/*/*[module[ ../type = 'type] = 'system-auth'][type[last()] = 'account']"]
      tokens = provider.parse_commands(args.join(' '))
      expect(tokens).to eq([args])
    end

it 'handles escaped doublequotes in doublequoted string' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands("set /foo \"''\\\"''\"")
      expect(tokens).to eq([['set', '/foo', "''\"''"]])
    end

it 'preserves escaped single quotes in double quoted strings' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands("set /foo \"\\'\"")
      expect(tokens).to eq([['set', '/foo', "\\'"]])
    end

it 'allows escaped spaces and brackets in paths' do
      resource[:context] = '/foo/'
      args = ['set', '/white\\ space/\\[section', 'value']
      tokens = provider.parse_commands(args.join(" \t "))
      expect(tokens).to eq([args])
    end

it 'allows single quoted escaped spaces in paths' do
      resource[:context] = '/foo/'
      args = ['set', "'/white\\ space/key'", 'value']
      tokens = provider.parse_commands(args.join(" \t "))
      expect(tokens).to eq([['set', '/white\\ space/key', 'value']])
    end

it 'allows double quoted escaped spaces in paths' do
      resource[:context] = '/foo/'
      args = ['set', '"/white\\ space/key"', 'value']
      tokens = provider.parse_commands(args.join(" \t "))
      expect(tokens).to eq([['set', '/white\\ space/key', 'value']])
    end

it 'removes trailing slashes' do
      resource[:context] = '/foo/'
      tokens = provider.parse_commands('set foo/ bar')
      expect(tokens).to eq([['set', '/foo/foo', 'bar']])
    end
  end

describe 'get filters' do
    let(:augeas) { instance_double('Augeas', get: 'value') }

before(:each) do
      allow(augeas).to receive('close')
      provider.aug = augeas
    end

it 'returns false for a = nonmatch' do
      command = ['get', 'fake value', '==', 'value']
      expect(provider.process_get(command)).to eq(true)
    end

it 'returns true for a != match' do
      command = ['get', 'fake value', '!=', 'value']
      expect(provider.process_get(command)).to eq(false)
    end

it 'returns true for a =~ match' do
      command = ['get', 'fake value', '=~', 'val*']
      expect(provider.process_get(command)).to eq(true)
    end

it 'returns false for a == nonmatch' do
      command = ['get', 'fake value', '=~', 'num*']
      expect(provider.process_get(command)).to eq(false)
    end
  end

describe 'values filters' do
    let(:augeas) { instance_double('Augeas', match: ['set', 'of', 'values']) }

before(:each) do
      allow(augeas).to receive(:get).and_return('set', 'of', 'values')
      allow(augeas).to receive('close')
      provider.aug = augeas
    end

it 'returns true for includes match' do
      command = ['values', 'fake value', 'include values']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns false for includes non match' do
      command = ['values', 'fake value', 'include JarJar']
      expect(provider.process_values(command)).to eq(false)
    end

it 'returns true for not_include non match' do
      command = ['values', 'fake value', 'not_include JarJar']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns false for non_include match' do
      command = ['values', 'fake value', 'not_include values']
      expect(provider.process_values(command)).to eq(false)
    end

it 'returns true for an array match' do
      command = ['values', 'fake value', "== ['set', 'of', 'values']"]
      expect(provider.process_values(command)).to eq(true)
    end
    it 'returns true for an array match with double quotes and spaces' do
      command = ['values', 'fake value', '==   [  "set"  ,  "of" , "values"  ]  ']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an array match with internally escaped single quotes' do
      allow(provider.aug).to receive(:match).and_return(['set', "o'values", 'here'])
      allow(provider.aug).to receive(:get).and_return('set', "o'values", 'here')
      command = ['values', 'fake value', "== [ 'set', 'o\\'values', 'here']"]
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an array match with octal character sequences' do
      command = ['values', 'fake value', '== ["\\x73et", "of", "values"]']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an array match with hex character sequences' do
      command = ['values', 'fake value', '== ["\\163et", "of", "values"]']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an array match with short unicode escape sequences' do
      command = ['values', 'fake value', '== ["\\u0073et", "of", "values"]']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an array match with single character long unicode escape sequences' do
      command = ['values', 'fake value', '== ["\\u{0073}et", "of", "values"]']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an array match with multi-character long unicode escape sequences' do
      command = ['values', 'fake value', '== ["\\u{0073 0065 0074}", "of", "values"]']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an array match with literal backslashes' do
      allow(provider.aug).to receive(:match).and_return(['set', 'o\\values', 'here'])
      allow(provider.aug).to receive(:get).and_return('set', 'o\\values', 'here')
      command = ['values', 'fake value', '== [ "set", "o\\\\values", "here"]']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns false for an array non match' do
      command = ['values', 'fake value', "== ['this', 'should', 'not', 'match']"]
      expect(provider.process_values(command)).to eq(false)
    end

it 'returns false for an array match with noteq' do
      command = ['values', 'fake value', "!= ['set', 'of', 'values']"]
      expect(provider.process_values(command)).to eq(false)
    end

it 'returns true for an array non match with noteq' do
      command = ['values', 'fake value', "!= ['this', 'should', 'not', 'match']"]
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an array non match with double quotes and spaces' do
      command = ['values', 'fake value', '!=   [  "this"  ,  "should" ,"not",  "match"  ]  ']
      expect(provider.process_values(command)).to eq(true)
    end

it 'returns true for an empty array match' do
      allow(provider.aug).to receive(:match).and_return([])
      allow(provider.aug).to receive(:get)
      command = ['values', 'fake value', '== []']
      expect(provider.process_values(command)).to eq(true)
    end
  end

describe 'match filters' do
    let(:augeas) { instance_double('Augeas', match: ['set', 'of', 'values']) }

before(:each) do
      allow(augeas).to receive('close')
      provider.aug = augeas
    end

it 'returns true for size match' do
      command = ['match', 'fake value', 'size == 3']
      expect(provider.process_match(command)).to eq(true)
    end

it 'returns false for a size non match' do
      command = ['match', 'fake value', 'size < 3']
      expect(provider.process_match(command)).to eq(false)
    end

it 'returns true for includes match' do
      command = ['match', 'fake value', 'include values']
      expect(provider.process_match(command)).to eq(true)
    end

it 'returns false for includes non match' do
      command = ['match', 'fake value', 'include JarJar']
      expect(provider.process_match(command)).to eq(false)
    end

it 'returns true for not_includes non match' do
      command = ['match', 'fake value', 'not_include JarJar']
      expect(provider.process_match(command)).to eq(true)
    end

it 'returns false for not_includes match' do
      command = ['match', 'fake value', 'not_include values']
      expect(provider.process_match(command)).to eq(false)
    end

it 'returns true for an array match' do
      command = ['match', 'fake value', "== ['set', 'of', 'values']"]
      expect(provider.process_match(command)).to eq(true)
    end

it 'returns true for an array match with double quotes and spaces' do
      command = ['match', 'fake value', '==   [  "set"  ,  "of" , "values"  ]  ']
      expect(provider.process_match(command)).to eq(true)
    end

it 'returns false for an array non match' do
      command = ['match', 'fake value', "== ['this', 'should', 'not', 'match']"]
      expect(provider.process_match(command)).to eq(false)
    end

it 'returns false for an array match with noteq' do
      command = ['match', 'fake value', "!= ['set', 'of', 'values']"]
      expect(provider.process_match(command)).to eq(false)
    end

it 'returns true for an array non match with noteq' do
      command = ['match', 'fake value', "!= ['this', 'should', 'not', 'match']"]
      expect(provider.process_match(command)).to eq(true)
    end

it 'returns true for an array non match with double quotes and spaces' do
      command = ['match', 'fake value', '!=   [  "this"  ,  "should" ,"not",  "match"  ]  ']
      expect(provider.process_match(command)).to eq(true)
    end
  end

describe 'need to run' do
    let(:augeas) { instance_double('Augeas') }

before(:each) do
      allow(augeas).to receive('close')
      provider.aug = augeas

# These tests pretend to be an earlier version so the provider doesn't
      # attempt to make the change in the need_to_run? method
      allow(provider).to receive(:get_augeas_version).and_return('0.3.5')
    end

it 'handles no filters' do
      allow(augeas).to receive('match').and_return(['set', 'of', 'values'])
      expect(provider.need_to_run?).to eq(true)
    end

it 'returns true when a get filter matches' do
      resource[:onlyif] = 'get path == value'
      allow(augeas).to receive('get').and_return('value')
      expect(provider.need_to_run?).to eq(true)
    end

describe 'performing numeric comparisons (#22617)' do
      it 'returns true when a get string compare is true' do
        resource[:onlyif] = 'get bpath > a'
        allow(augeas).to receive('get').and_return('b')
        expect(provider.need_to_run?).to eq(true)
      end

it 'returns false when a get string compare is false' do
        resource[:onlyif] = 'get a19path > a2'
        allow(augeas).to receive('get').and_return('a19')
        expect(provider.need_to_run?).to eq(false)
      end

it 'returns true when a get int gt compare is true' do
        resource[:onlyif] = 'get path19 > 2'
        allow(augeas).to receive('get').and_return('19')
        expect(provider.need_to_run?).to eq(true)
      end

it 'returns true when a get int ge compare is true' do
        resource[:onlyif] = 'get path19 >= 2'
        allow(augeas).to receive('get').and_return('19')
        expect(provider.need_to_run?).to eq(true)
      end

it 'returns true when a get int lt compare is true' do
        resource[:onlyif] = 'get path2 < 19'
        allow(augeas).to receive('get').and_return('2')
        expect(provider.need_to_run?).to eq(true)
      end

it 'returns false when a get int le compare is false' do
        resource[:onlyif] = 'get path39 <= 4'
        allow(augeas).to receive('get').and_return('39')
        expect(provider.need_to_run?).to eq(false)
      end
    end
    describe 'performing is_numeric checks (#22617)' do
      it 'returns false for nil' do
        expect(provider.numeric?(nil)).to eq(false)
      end
      it 'returns true for Integers' do
        expect(provider.numeric?(9)).to eq(true)
      end
      it 'returns true for numbers in Strings' do
        expect(provider.numeric?('9')).to eq(true)
      end
      it 'returns false for non-number Strings' do
        expect(provider.numeric?('x9')).to eq(false)
      end
      it 'returns false for other types' do
        expect(provider.numeric?([true])).to eq(false)
      end
    end

it 'returns false when a get filter does not match' do
      resource[:onlyif] = 'get path == another value'
      allow(augeas).to receive('get').and_return('value')
      expect(provider.need_to_run?).to eq(false)
    end

it 'returns true when a match filter matches' do
      resource[:onlyif] = 'match path size == 3'
      allow(augeas).to receive('match').and_return(['set', 'of', 'values'])
      expect(provider.need_to_run?).to eq(true)
    end

it 'returns false when a match filter does not match' do
      resource[:onlyif] = 'match path size == 2'
      allow(augeas).to receive('match').and_return(['set', 'of', 'values'])
      expect(provider.need_to_run?).to eq(false)
    end

# Now setting force to true
    it 'setting force should not change the above logic' do
      resource[:force] = true
      resource[:onlyif] = 'match path size == 2'
      allow(augeas).to receive('match').and_return(['set', 'of', 'values'])
      expect(provider.need_to_run?).to eq(false)
    end

# Ticket 5211 testing
    it 'returns true when a size != the provided value' do
      resource[:onlyif] = 'match path size != 17'
      allow(augeas).to receive('match').and_return(['set', 'of', 'values'])
      expect(provider.need_to_run?).to eq(true)
    end

# Ticket 5211 testing
    it 'returns false when a size does equal the provided value' do
      resource[:onlyif] = 'match path size != 3'
      allow(augeas).to receive('match').and_return(['set', 'of', 'values'])
      expect(provider.need_to_run?).to eq(false)
    end

[true, false].product([true, false]) do |cfg, param|
      describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
        let(:file) { '/some/random/file' }

before(:each) do
          Puppet[:show_diff] = cfg
          resource[:show_diff] = param

resource[:root] = ''
          resource[:context] = '/files'
          resource[:changes] = ["set #{file}/foo bar"]

allow(File).to receive(:delete)
          allow(provider).to receive(:get_augeas_version).and_return('0.10.0')
          allow(provider).to receive('diff').with(file.to_s, "#{file}.augnew").and_return('diff')

allow(augeas).to receive(:set).and_return(true)
          allow(augeas).to receive(:save).and_return(true)
          allow(augeas).to receive(:match).with('/augeas/events/saved').and_return(['/augeas/events/saved'])
          allow(augeas).to receive(:get).with('/augeas/events/saved').and_return("/files#{file}")
          allow(augeas).to receive(:set).with('/augeas/save', 'newfile')
        end

if cfg && param
          it 'displays a diff' do
            expect(provider).to be_need_to_run

expect(logs[0].message).to eq("\ndiff")
          end
        else
          it 'does not display a diff' do
            expect(provider).to be_need_to_run

expect(logs).to be_empty
          end
        end
      end
    end

# Ticket 2728 (diff files)
    describe 'and configured to show diffs' do
      before(:each) do
        Puppet[:show_diff] = true
        resource[:show_diff] = true

resource[:root] = ''
        allow(provider).to receive(:get_augeas_version).and_return('0.10.0')
        allow(augeas).to receive(:set).and_return(true)
        allow(augeas).to receive(:save).and_return(true)
      end

it 'displays a diff when a single file is shown to have been changed' do
        file = '/etc/hosts'
        allow(File).to receive(:delete)

resource[:loglevel] = 'crit'
        resource[:context] = '/files'
        resource[:changes] = ["set #{file}/foo bar"]

allow(augeas).to receive(:match).with('/augeas/events/saved').and_return(['/augeas/events/saved'])
        allow(augeas).to receive(:get).with('/augeas/events/saved').and_return("/files#{file}")
        expect(augeas).to receive(:set).with('/augeas/save', 'newfile')
        expect(provider).to receive('diff').with(file.to_s, "#{file}.augnew").and_return('diff')

expect(provider).to be_need_to_run

expect(logs[0].message).to eq("\ndiff")
        expect(logs[0].level).to eq(:crit)
      end

it 'displays a diff for each file that is changed when changing many files' do
        file1 = '/etc/hosts'
        file2 = '/etc/resolv.conf'
        allow(File).to receive(:delete)

resource[:context] = '/files'
        resource[:changes] = ["set #{file1}/foo bar", "set #{file2}/baz biz"]

allow(augeas).to receive(:match).with('/augeas/events/saved').and_return(['/augeas/events/saved[1]', '/augeas/events/saved[2]'])
        allow(augeas).to receive(:get).with('/augeas/events/saved[1]').and_return("/files#{file1}")
        allow(augeas).to receive(:get).with('/augeas/events/saved[2]').and_return("/files#{file2}")
        expect(augeas).to receive(:set).with('/augeas/save', 'newfile')
        expect(provider).to receive(:diff).with(file1.to_s, "#{file1}.augnew").and_return("diff #{file1}")
        expect(provider).to receive(:diff).with(file2.to_s, "#{file2}.augnew").and_return("diff #{file2}")

expect(provider).to be_need_to_run

expect(logs.map(&:message)).to include("\ndiff #{file1}", "\ndiff #{file2}")
        expect(logs.map(&:level)).to eq([:notice, :notice])
      end

describe 'and resource[:root] is set' do
        it 'calls diff when a file is shown to have been changed' do
          root = '/tmp/foo'
          file = '/etc/hosts'
          allow(File).to receive(:delete)

resource[:context] = '/files'
          resource[:changes] = ["set #{file}/foo bar"]
          resource[:root] = root

allow(augeas).to receive(:match).with('/augeas/events/saved').and_return(['/augeas/events/saved'])
          allow(augeas).to receive(:get).with('/augeas/events/saved').and_return("/files#{file}")
          expect(augeas).to receive(:set).with('/augeas/save', 'newfile')
          expect(provider).to receive(:diff).with("#{root}#{file}", "#{root}#{file}.augnew").and_return('diff')

expect(provider).to be_need_to_run

expect(logs[0].message).to eq("\ndiff")
          expect(logs[0].level).to eq(:notice)
        end
      end

it 'does not call diff if no files change' do
        file = '/etc/hosts'

resource[:context] = '/files'
        resource[:changes] = ["set #{file}/foo bar"]

allow(augeas).to receive(:match).with('/augeas/events/saved').and_return([])
        expect(augeas).to receive(:set).with('/augeas/save', 'newfile')
        expect(augeas).to receive(:get).with('/augeas/events/saved').never
        expect(augeas).to receive(:close)

expect(provider).to receive(:diff).never
        expect(provider).not_to be_need_to_run
      end

it 'cleanups the .augnew file' do
        file = '/etc/hosts'

resource[:context] = '/files'
        resource[:changes] = ["set #{file}/foo bar"]

expect(File).to receive(:delete).with(file + '.augnew')

expect(provider).to receive(:diff).with(file.to_s, "#{file}.augnew").and_return('')
        expect(provider).to be_need_to_run
      end

# Workaround for Augeas bug #264 which reports filenames twice
      it 'handles duplicate /augeas/events/saved filenames' do
        file = '/etc/hosts'

resource[:context] = '/files'
        resource[:changes] = ["set #{file}/foo bar"]

allow(augeas).to receive(:match).with('/augeas/events/saved').and_return(['/augeas/events/saved[1]', '/augeas/events/saved[2]'])
        allow(augeas).to receive(:get).with('/augeas/events/saved[1]').and_return("/files#{file}")
        allow(augeas).to receive(:get).with('/augeas/events/saved[2]').and_return("/files#{file}")
        expect(augeas).to receive(:set).with('/augeas/save', 'newfile')
        expect(augeas).to receive(:close)

expect(File).to receive(:delete).with(file + '.augnew').once

expect(provider).to receive(:diff).with(file.to_s, "#{file}.augnew").and_return('').once
        expect(provider).to be_need_to_run
      end

it 'fails with an error if saving fails' do
        file = '/etc/hosts'

resource[:context] = '/files'
        resource[:changes] = ["set #{file}/foo bar"]

allow(augeas).to receive(:save).and_return(false)
        allow(augeas).to receive(:match).with('/augeas/events/saved').and_return([])
        expect(augeas).to receive(:close)

expect(provider).to receive(:diff).never
        expect(provider).to receive(:print_put_errors)
        expect { provider.need_to_run? }.to raise_error(Puppet::Error)
      end
    end
  end

describe 'augeas execution integration' do
    let(:augeas) { instance_double('Augeas', load: nil) }

before(:each) do
      allow(augeas).to receive('close')
      allow(augeas).to receive(:match).with('/augeas/events/saved').and_return([])

provider.aug = augeas
      allow(provider).to receive(:get_augeas_version).and_return('0.3.5')
    end

it 'handles set commands' do
      resource[:changes] = 'set JarJar Binks'
      resource[:context] = '/some/path/'
      expect(augeas).to receive(:set).with('/some/path/JarJar', 'Binks').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles rm commands' do
      resource[:changes] = 'rm /Jar/Jar'
      expect(augeas).to receive(:rm).with('/Jar/Jar')
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles remove commands' do
      resource[:changes] = 'remove /Jar/Jar'
      expect(augeas).to receive(:rm).with('/Jar/Jar')
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles clear commands' do
      resource[:changes] = 'clear Jar/Jar'
      resource[:context] = '/foo/'
      expect(augeas).to receive(:clear).with('/foo/Jar/Jar').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

describe 'touch command' do
      it 'clears missing path' do
        resource[:changes] = 'touch Jar/Jar'
        resource[:context] = '/foo/'
        expect(augeas).to receive(:match).with('/foo/Jar/Jar').and_return([])
        expect(augeas).to receive(:clear).with('/foo/Jar/Jar').and_return(true)
        expect(augeas).to receive(:save).and_return(true)
        expect(augeas).to receive(:close)
        expect(provider.execute_changes).to eq(:executed)
      end

it 'does not change on existing path' do
        resource[:changes] = 'touch Jar/Jar'
        resource[:context] = '/foo/'
        expect(augeas).to receive(:match).with('/foo/Jar/Jar').and_return(['/foo/Jar/Jar'])
        expect(augeas).to receive(:clear).never
        expect(augeas).to receive(:save).and_return(true)
        expect(augeas).to receive(:close)
        expect(provider.execute_changes).to eq(:executed)
      end
    end

it 'handles ins commands with before' do
      resource[:changes] = 'ins Binks before Jar/Jar'
      resource[:context] = '/foo'
      expect(augeas).to receive(:insert).with('/foo/Jar/Jar', 'Binks', true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles ins commands with after' do
      resource[:changes] = 'ins Binks after /Jar/Jar'
      resource[:context] = '/foo'
      expect(augeas).to receive(:insert).with('/Jar/Jar', 'Binks', false)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles ins with no context' do
      resource[:changes] = 'ins Binks after /Jar/Jar'
      expect(augeas).to receive(:insert).with('/Jar/Jar', 'Binks', false)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles multiple commands' do
      resource[:changes] = ['ins Binks after /Jar/Jar', 'clear Jar/Jar']
      resource[:context] = '/foo/'
      expect(augeas).to receive(:insert).with('/Jar/Jar', 'Binks', false)
      expect(augeas).to receive(:clear).with('/foo/Jar/Jar').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles defvar commands' do
      resource[:changes] = 'defvar myjar Jar/Jar'
      resource[:context] = '/foo/'
      expect(augeas).to receive(:defvar).with('myjar', '/foo/Jar/Jar').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'passes through augeas variables without context' do
      resource[:changes] = ['defvar myjar Jar/Jar', 'set $myjar/Binks 1']
      resource[:context] = '/foo/'
      expect(augeas).to receive(:defvar).with('myjar', '/foo/Jar/Jar').and_return(true)
      # this is the important bit, shouldn't be /foo/$myjar/Binks
      expect(augeas).to receive(:set).with('$myjar/Binks', '1').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles defnode commands' do
      resource[:changes] = 'defnode newjar Jar/Jar[last()+1] Binks'
      resource[:context] = '/foo/'
      expect(augeas).to receive(:defnode).with('newjar', '/foo/Jar/Jar[last()+1]', 'Binks').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles mv commands' do
      resource[:changes] = 'mv Jar/Jar Binks'
      resource[:context] = '/foo/'
      expect(augeas).to receive(:mv).with('/foo/Jar/Jar', '/foo/Binks').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles rename commands' do
      resource[:changes] = 'rename Jar/Jar Binks'
      resource[:context] = '/foo/'
      expect(augeas).to receive(:rename).with('/foo/Jar/Jar', 'Binks').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'handles setm commands' do
      resource[:changes] = ['set test[1]/Jar/Jar Foo', 'set test[2]/Jar/Jar Bar', 'setm test Jar/Jar Binks']
      resource[:context] = '/foo/'
      expect(augeas).to receive(:respond_to?).with('setm').and_return(true)
      expect(augeas).to receive(:set).with('/foo/test[1]/Jar/Jar', 'Foo').and_return(true)
      expect(augeas).to receive(:set).with('/foo/test[2]/Jar/Jar', 'Bar').and_return(true)
      expect(augeas).to receive(:setm).with('/foo/test', 'Jar/Jar', 'Binks').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'throws error if setm command not supported' do
      resource[:changes] = ['set test[1]/Jar/Jar Foo', 'set test[2]/Jar/Jar Bar', 'setm test Jar/Jar Binks']
      resource[:context] = '/foo/'
      expect(augeas).to receive(:respond_to?).with('setm').and_return(false)
      expect(augeas).to receive(:set).with('/foo/test[1]/Jar/Jar', 'Foo').and_return(true)
      expect(augeas).to receive(:set).with('/foo/test[2]/Jar/Jar', 'Bar').and_return(true)
      expect { provider.execute_changes }.to raise_error RuntimeError, %r{command 'setm' not supported}
    end

it 'handles clearm commands' do
      resource[:changes] = ['set test[1]/Jar/Jar Foo', 'set test[2]/Jar/Jar Bar', 'clearm test Jar/Jar']
      resource[:context] = '/foo/'
      expect(augeas).to receive(:respond_to?).with('clearm').and_return(true)
      expect(augeas).to receive(:set).with('/foo/test[1]/Jar/Jar', 'Foo').and_return(true)
      expect(augeas).to receive(:set).with('/foo/test[2]/Jar/Jar', 'Bar').and_return(true)
      expect(augeas).to receive(:clearm).with('/foo/test', 'Jar/Jar').and_return(true)
      expect(augeas).to receive(:save).and_return(true)
      expect(augeas).to receive(:close)
      expect(provider.execute_changes).to eq(:executed)
    end

it 'throws error if clearm command not supported' do
      resource[:changes] = ['set test[1]/Jar/Jar Foo', 'set test[2]/Jar/Jar Bar', 'clearm test Jar/Jar']
      resource[:context] = '/foo/'
      expect(augeas).to receive(:respond_to?).with('clearm').and_return(false)
      expect(augeas).to receive(:set).with('/foo/test[1]/Jar/Jar', 'Foo').and_return(true)
      expect(augeas).to receive(:set).with('/foo/test[2]/Jar/Jar', 'Bar').and_return(true)
      expect { provider.execute_changes }.to raise_error(RuntimeError, %r{command 'clearm' not supported})
    end

it 'throws error if saving failed' do
      resource[:changes] = ['set test[1]/Jar/Jar Foo', 'set test[2]/Jar/Jar Bar', 'clearm test Jar/Jar']
      resource[:context] = '/foo/'
      expect(augeas).to receive(:respond_to?).with('clearm').and_return(true)
      expect(augeas).to receive(:set).with('/foo/test[1]/Jar/Jar', 'Foo').and_return(true)
      expect(augeas).to receive(:set).with('/foo/test[2]/Jar/Jar', 'Bar').and_return(true)
      expect(augeas).to receive(:clearm).with('/foo/test', 'Jar/Jar').and_return(true)
      expect(augeas).to receive(:save).and_return(false)
      expect(provider).to receive(:print_put_errors)
      expect(augeas).to receive(:match).and_return([])
      expect { provider.execute_changes }.to raise_error(Puppet::Error)
    end
  end

describe 'when making changes', if: Puppet.features.augeas? do
    it "does not clobber the file if it's a symlink" do
      allow(Puppet::Util::Storage).to receive(:store)

link = tmpfile('link')
      target = tmpfile('target')
      FileUtils.touch(target)
      Puppet::FileSystem.symlink(target, link)

resource = Puppet::Type.type(:augeas).new(
        name: 'test',
        incl: link,
        lens: 'Sshd.lns',
        changes: 'set PermitRootLogin no',
      )

catalog = Puppet::Resource::Catalog.new
      catalog.add_resource resource

catalog.apply

expect(File.ftype(link)).to eq('link')
      expect(Puppet::FileSystem.readlink(link)).to eq(target)
      expect(File.read(target)).to match(%r{PermitRootLogin no})
    end
  end

describe 'load/save failure reporting' do
    let(:augeas) { instance_double('Augeas') }

before(:each) do
      allow(augeas).to receive('close')
      provider.aug = augeas
    end

describe 'should find load errors' do
      before(:each) do
        allow(augeas).to receive(:match).with('/augeas//error').and_return(['/augeas/files/foo/error'])
        allow(augeas).to receive(:match).with('/augeas/files/foo/error/*').and_return(['/augeas/files/foo/error/path', '/augeas/files/foo/error/message'])
        allow(augeas).to receive(:get).with('/augeas/files/foo/error').and_return('some_failure')
        allow(augeas).to receive(:get).with('/augeas/files/foo/error/path').and_return('/foo')
        allow(augeas).to receive(:get).with('/augeas/files/foo/error/message').and_return('Failed to...')
      end

it 'and output only to debug when no path supplied' do
        expect(provider).to receive(:debug).exactly(5).times
        expect(provider).to receive(:warning).never
        provider.print_load_errors(nil)
      end

it 'and output a warning and to debug when path supplied' do
        expect(augeas).to receive(:match).with('/augeas/files/foo//error').and_return(['/augeas/files/foo/error'])
        expect(provider).to receive(:warning).once
        expect(provider).to receive(:debug).exactly(4).times
        provider.print_load_errors('/augeas/files/foo//error')
      end

it "and output only to debug when path doesn't match" do
        expect(augeas).to receive(:match).with('/augeas/files/foo//error').and_return([])
        expect(provider).to receive(:warning).never
        expect(provider).to receive(:debug).exactly(5).times
        provider.print_load_errors('/augeas/files/foo//error')
      end
    end

it 'finds load errors from lenses' do
      expect(augeas).to receive(:match).with('/augeas//error').twice.and_return(['/augeas/load/Xfm/error'])
      expect(augeas).to receive(:match).with('/augeas/load/Xfm/error/*').and_return([])
      expect(augeas).to receive(:get).with('/augeas/load/Xfm/error').and_return(['Could not find lens php.aug'])
      expect(provider).to receive(:warning).once
      expect(provider).to receive(:debug).twice
      provider.print_load_errors('/augeas//error')
    end

it 'finds save errors and output to debug' do
      expect(augeas).to receive(:match).with("/augeas//error[. = 'put_failed']").and_return(['/augeas/files/foo/error'])
      expect(augeas).to receive(:match).with('/augeas/files/foo/error/*').and_return(['/augeas/files/foo/error/path', '/augeas/files/foo/error/message'])
      expect(augeas).to receive(:get).with('/augeas/files/foo/error').and_return('some_failure')
      expect(augeas).to receive(:get).with('/augeas/files/foo/error/path').and_return('/foo')
      expect(augeas).to receive(:get).with('/augeas/files/foo/error/message').and_return('Failed to...')
      expect(provider).to receive(:debug).exactly(5).times
      provider.print_put_errors
    end
  end

# Run initialisation tests of the real Augeas library to test our open_augeas
  # method.  This relies on Augeas and ruby-augeas on the host to be
  # functioning.
  describe 'augeas lib initialisation', if: Puppet.features.augeas? do
    # Expect lenses for fstab and hosts
    it 'has loaded standard files by default' do
      aug = provider.open_augeas
      expect(aug).not_to eq(nil)
      expect(aug.match('/files/etc/fstab')).to eq(['/files/etc/fstab'])
      expect(aug.match('/files/etc/hosts')).to eq(['/files/etc/hosts'])
      expect(aug.match('/files/etc/test')).to eq([])
    end

it 'reports load errors to debug only' do
      expect(provider).to receive(:print_load_errors).with(nil)
      aug = provider.open_augeas
      expect(aug).not_to eq(nil)
    end

# Only the file specified should be loaded
    it 'loads one file if incl/lens used' do
      resource[:incl] = '/etc/hosts'
      resource[:lens] = 'Hosts.lns'

expect(provider).to receive(:print_load_errors).with('/augeas//error')
      aug = provider.open_augeas
      expect(aug).not_to eq(nil)
      expect(aug.match('/files/etc/fstab')).to eq([])
      expect(aug.match('/files/etc/hosts')).to eq(['/files/etc/hosts'])
      expect(aug.match('/files/etc/test')).to eq([])
    end

it 'alsoes load lenses from load_path' do
      resource[:load_path] = my_fixture_dir

aug = provider.open_augeas
      expect(aug).not_to eq(nil)
      expect(aug.match('/files/etc/fstab')).to eq(['/files/etc/fstab'])
      expect(aug.match('/files/etc/hosts')).to eq(['/files/etc/hosts'])
      expect(aug.match('/files/etc/test')).to eq(['/files/etc/test'])
    end

it "alsoes load lenses from pluginsync'd path" do
      Puppet[:libdir] = my_fixture_dir

# Optimisations added for Augeas 0.8.2 or higher is available, see #7285
    describe '>= 0.8.2 optimisations', if: Puppet.features.augeas? && Facter.value(:augeasversion) && Puppet::Util::Package.versioncmp(Facter.value(:augeasversion), '0.8.2') >= 0 do
      it 'onlies load one file if relevant context given' do
        resource[:context] = '/files/etc/fstab'

expect(provider).to receive(:print_load_errors).with('/augeas/files/etc/fstab//error')
        aug = provider.open_augeas
        expect(aug).not_to eq(nil)
        expect(aug.match('/files/etc/fstab')).to eq(['/files/etc/fstab'])
        expect(aug.match('/files/etc/hosts')).to eq([])
      end

it 'onlies load one lens from load_path if context given' do
        resource[:context] = '/files/etc/test'
        resource[:load_path] = my_fixture_dir

expect(provider).to receive(:print_load_errors).with('/augeas/files/etc/test//error')
        aug = provider.open_augeas
        expect(aug).not_to eq(nil)
        expect(aug.match('/files/etc/fstab')).to eq([])
        expect(aug.match('/files/etc/hosts')).to eq([])
        expect(aug.match('/files/etc/test')).to eq(['/files/etc/test'])
      end

it "loads standard files if context isn't specific" do
        resource[:context] = '/files/etc'

expect(provider).to receive(:print_load_errors).with(nil)
        aug = provider.open_augeas
        expect(aug).not_to eq(nil)
        expect(aug.match('/files/etc/fstab')).to eq(['/files/etc/fstab'])
        expect(aug.match('/files/etc/hosts')).to eq(['/files/etc/hosts'])
      end

it 'does not optimise if the context is a complex path' do
        resource[:context] = "/files/*[label()='etc']"

describe 'get_load_path' do
    it 'offers no load_path by default' do
      expect(provider.get_load_path(resource)).to eq('')
    end

it 'offers one path from load_path' do
      resource[:load_path] = '/foo'
      expect(provider.get_load_path(resource)).to eq('/foo')
    end

it 'offers multiple colon-separated paths from load_path' do
      resource[:load_path] = '/foo:/bar:/baz'
      expect(provider.get_load_path(resource)).to eq('/foo:/bar:/baz')
    end

it 'offers multiple paths in array from load_path' do
      resource[:load_path] = ['/foo', '/bar', '/baz']
      expect(provider.get_load_path(resource)).to eq('/foo:/bar:/baz')
    end

context 'when running application is agent' do
      before(:each) do
        Puppet[:libdir] = my_fixture_dir
        allow(Puppet.run_mode).to receive(:name).and_return(:agent)
      end

it 'offers pluginsync augeas/lenses subdir' do
        expect(provider.get_load_path(resource)).to eq("#{my_fixture_dir}/augeas/lenses")
      end

it 'offers both pluginsync and load_path paths' do
        resource[:load_path] = ['/foo', '/bar', '/baz']
        expect(provider.get_load_path(resource)).to eq("/foo:/bar:/baz:#{my_fixture_dir}/augeas/lenses")
      end
    end

context 'when running application is not agent' do
      before(:each) do
        allow(Puppet.run_mode).to receive(:name).and_return(:user)

env = Puppet::Node::Environment.create('root', ['/modules/foobar'])
        allow(Puppet).to receive(:lookup).and_return(env)
        allow(env).to receive(:each_plugin_directory).and_yield('/modules/foobar')

resource[:load_path] = ['/foo', '/bar', '/baz']
      end

it 'offers both load_path and module lenses path when available' do
        allow(File).to receive(:exist?).with('/modules/foobar/augeas/lenses').and_return(true)
        expect(provider.get_load_path(resource)).to eq('/foo:/bar:/baz:/modules/foobar/augeas/lenses')
      end

it 'offers only load_path if module lenses path is not available' do
        allow(File).to receive(:exist?).with('/modules/foobar/augeas/lenses').and_return(false)
        expect(provider.get_load_path(resource)).to eq('/foo:/bar:/baz')
      end
    end
  end
end