Bundles puppetlabs-stdlib 4.25.1.

13 files changed, 1340 insertions, 0 deletions

diff --git a/code/environments/production/modules/stdlib/spec/unit/facter/facter_dot_d_spec.rb b/code/environments/production/modules/stdlib/spec/unit/facter/facter_dot_d_spec.rb
new file mode 100644
index 0000000..49707ab
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/facter/facter_dot_d_spec.rb
@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'facter/facter_dot_d'
+
+describe Facter::Util::DotD do # rubocop:disable RSpec/FilePath : Spec path is as it should be
+  context 'with a simple fact' do
+    before :each do
+      Facter.stubs(:version).returns('1.6.1')
+      subject.stubs(:entries).returns(['/etc/facter/facts.d/fake_fact.txt'])
+      File.stubs(:readlines).with('/etc/facter/facts.d/fake_fact.txt').returns(['fake_fact=fake fact'])
+      subject.create
+    end
+
+    it 'returns successfully' do
+      expect(Facter.fact(:fake_fact).value).to eq('fake fact')
+    end
+  end
+
+  context 'with a fact with equals signs' do
+    before :each do
+      Facter.stubs(:version).returns('1.6.1')
+      subject.stubs(:entries).returns(['/etc/facter/facts.d/foo.txt'])
+      File.stubs(:readlines).with('/etc/facter/facts.d/foo.txt').returns(['foo=1+1=2'])
+      subject.create
+    end
+
+    it 'returns successfully' do
+      expect(Facter.fact(:foo).value).to eq('1+1=2')
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/facter/package_provider_spec.rb b/code/environments/production/modules/stdlib/spec/unit/facter/package_provider_spec.rb
new file mode 100644
index 0000000..2ebfe2d
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/facter/package_provider_spec.rb
@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'puppet/type'
+require 'puppet/type/package'
+
+describe 'package_provider', :type => :fact do
+  before(:each) { Facter.clear }
+  after(:each) { Facter.clear }
+
+  ['4.2.2', '3.7.1 (Puppet Enterprise 3.2.1)'].each do |puppetversion|
+    describe "on puppet ''#{puppetversion}''" do
+      before :each do
+        Facter.stubs(:value).returns puppetversion
+      end
+
+      context 'when darwin' do
+        it 'returns pkgdmg' do
+          provider = Puppet::Type.type(:package).provider(:pkgdmg)
+          Puppet::Type.type(:package).stubs(:defaultprovider).returns provider
+
+          expect(Facter.fact(:package_provider).value).to eq('pkgdmg')
+        end
+      end
+
+      context 'when centos 7' do
+        it 'returns yum' do
+          provider = Puppet::Type.type(:package).provider(:yum)
+          Puppet::Type.type(:package).stubs(:defaultprovider).returns provider
+
+          expect(Facter.fact(:package_provider).value).to eq('yum')
+        end
+      end
+
+      context 'when ubuntu' do
+        it 'returns apt' do
+          provider = Puppet::Type.type(:package).provider(:apt)
+          Puppet::Type.type(:package).stubs(:defaultprovider).returns provider
+
+          expect(Facter.fact(:package_provider).value).to eq('apt')
+        end
+      end
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/facter/pe_version_spec.rb b/code/environments/production/modules/stdlib/spec/unit/facter/pe_version_spec.rb
new file mode 100644
index 0000000..73c4bfd
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/facter/pe_version_spec.rb
@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe 'PE Version specs' do
+  before :each do
+    # Explicitly load the pe_version.rb file which contains generated facts
+    # that cannot be automatically loaded.  Puppet 2.x implements
+    # Facter.collection.load while Facter 1.x markes Facter.collection.load as
+    # a private method.
+    if Facter.collection.respond_to? :load
+      Facter.collection.load(:pe_version)
+    else
+      Facter.collection.loader.load(:pe_version)
+    end
+  end
+
+  context 'when puppetversion is nil' do
+    before :each do
+      Facter.fact(:puppetversion).stubs(:value).returns(nil)
+    end
+
+    it 'puppetversion is nil' do
+      expect(Facter.fact(:puppetversion).value).to be_nil
+    end
+
+    it 'pe_version is nil' do
+      expect(Facter.fact(:pe_version).value).to be_nil
+    end
+  end
+
+  context 'when PE is installed' do
+    %w[2.6.1 2.10.300].each do |version|
+      puppetversion = "2.7.19 (Puppet Enterprise #{version})"
+      context "puppetversion => #{puppetversion}" do
+        before :each do
+          Facter.fact(:puppetversion).stubs(:value).returns(puppetversion)
+        end
+
+        (major, minor, patch) = version.split('.')
+
+        it 'returns true' do
+          expect(Facter.fact(:is_pe).value).to eq(true)
+        end
+
+        it "Should have a version of #{version}" do
+          expect(Facter.fact(:pe_version).value).to eq(version)
+        end
+
+        it "Should have a major version of #{major}" do
+          expect(Facter.fact(:pe_major_version).value).to eq(major)
+        end
+
+        it "Should have a minor version of #{minor}" do
+          expect(Facter.fact(:pe_minor_version).value).to eq(minor)
+        end
+
+        it "Should have a patch version of #{patch}" do
+          expect(Facter.fact(:pe_patch_version).value).to eq(patch)
+        end
+      end
+    end
+  end
+
+  context 'when PE is not installed' do
+    before :each do
+      Facter.fact(:puppetversion).stubs(:value).returns('2.7.19')
+    end
+
+    it 'is_pe is false' do
+      expect(Facter.fact(:is_pe).value).to eq(false)
+    end
+
+    it 'pe_version is nil' do
+      expect(Facter.fact(:pe_version).value).to be_nil
+    end
+
+    it 'pe_major_version is nil' do
+      expect(Facter.fact(:pe_major_version).value).to be_nil
+    end
+
+    it 'pe_minor_version is nil' do
+      expect(Facter.fact(:pe_minor_version).value).to be_nil
+    end
+
+    it 'has a patch version' do
+      expect(Facter.fact(:pe_patch_version).value).to be_nil
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/facter/root_home_spec.rb b/code/environments/production/modules/stdlib/spec/unit/facter/root_home_spec.rb
new file mode 100644
index 0000000..656f65d
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/facter/root_home_spec.rb
@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'facter/root_home'
+describe 'Root Home Specs' do
+  describe Facter::Util::RootHome do
+    context 'when solaris' do
+      let(:root_ent) { 'root:x:0:0:Super-User:/:/sbin/sh' }
+      let(:expected_root_home) { '/' }
+
+      it 'returns /' do
+        Facter::Util::Resolution.expects(:exec).with('getent passwd root').returns(root_ent)
+        expect(described_class.returnt_root_home).to eq(expected_root_home)
+      end
+    end
+    context 'when linux' do
+      let(:root_ent) { 'root:x:0:0:root:/root:/bin/bash' }
+      let(:expected_root_home) { '/root' }
+
+      it 'returns /root' do
+        Facter::Util::Resolution.expects(:exec).with('getent passwd root').returns(root_ent)
+        expect(described_class.returnt_root_home).to eq(expected_root_home)
+      end
+    end
+    context 'when windows' do
+      before :each do
+        Facter::Util::Resolution.expects(:exec).with('getent passwd root').returns(nil)
+      end
+      it 'is nil on windows' do
+        expect(described_class.returnt_root_home).to be_nil
+      end
+    end
+  end
+
+  describe 'root_home', :type => :fact do
+    before(:each) { Facter.clear }
+    after(:each) { Facter.clear }
+
+    context 'when macosx' do
+      before(:each) do
+        Facter.fact(:kernel).stubs(:value).returns('Darwin')
+        Facter.fact(:osfamily).stubs(:value).returns('Darwin')
+      end
+      let(:expected_root_home) { '/var/root' }
+
+      sample_dscacheutil = File.read(fixtures('dscacheutil', 'root'))
+
+      it 'returns /var/root' do
+        Facter::Util::Resolution.stubs(:exec).with('dscacheutil -q user -a name root').returns(sample_dscacheutil)
+        expect(Facter.fact(:root_home).value).to eq(expected_root_home)
+      end
+    end
+
+    context 'when aix' do
+      before(:each) do
+        Facter.fact(:kernel).stubs(:value).returns('AIX')
+        Facter.fact(:osfamily).stubs(:value).returns('AIX')
+      end
+      let(:expected_root_home) { '/root' }
+
+      sample_lsuser = File.read(fixtures('lsuser', 'root'))
+
+      it 'returns /root' do
+        Facter::Util::Resolution.stubs(:exec).with('lsuser -c -a home root').returns(sample_lsuser)
+        expect(Facter.fact(:root_home).value).to eq(expected_root_home)
+      end
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/facter/service_provider_spec.rb b/code/environments/production/modules/stdlib/spec/unit/facter/service_provider_spec.rb
new file mode 100644
index 0000000..202f7c0
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/facter/service_provider_spec.rb
@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'puppet/type'
+require 'puppet/type/service'
+
+describe 'service_provider', :type => :fact do
+  before(:each) { Facter.clear }
+  after(:each) { Facter.clear }
+
+  context 'when macosx' do
+    it 'returns launchd' do
+      provider = Puppet::Type.type(:service).provider(:launchd)
+      Puppet::Type.type(:service).stubs(:defaultprovider).returns provider
+
+      expect(Facter.fact(:service_provider).value).to eq('launchd')
+    end
+  end
+
+  context 'when systemd' do
+    it 'returns systemd' do
+      provider = Puppet::Type.type(:service).provider(:systemd)
+      Puppet::Type.type(:service).stubs(:defaultprovider).returns provider
+
+      expect(Facter.fact(:service_provider).value).to eq('systemd')
+    end
+  end
+
+  context 'when redhat' do
+    it 'returns redhat' do
+      provider = Puppet::Type.type(:service).provider(:redhat)
+      Puppet::Type.type(:service).stubs(:defaultprovider).returns provider
+
+      expect(Facter.fact(:service_provider).value).to eq('redhat')
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/facter/util/puppet_settings_spec.rb b/code/environments/production/modules/stdlib/spec/unit/facter/util/puppet_settings_spec.rb
new file mode 100644
index 0000000..dd870bb
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/facter/util/puppet_settings_spec.rb
@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'facter/util/puppet_settings'
+
+describe Facter::Util::PuppetSettings do
+  describe '#with_puppet' do
+    context 'without Puppet loaded' do
+      before(:each) do
+        Module.expects(:const_get).with('Puppet').raises(NameError)
+      end
+
+      it 'is nil' do
+        expect(subject.with_puppet { Puppet[:vardir] }).to be_nil
+      end
+      it 'does not yield to the block' do
+        Puppet.expects(:[]).never
+        expect(subject.with_puppet { Puppet[:vardir] }).to be_nil
+      end
+    end
+    context 'with Puppet loaded' do
+      module Puppet; end
+      let(:vardir) { '/var/lib/puppet' }
+
+      before :each do
+        Puppet.expects(:[]).with(:vardir).returns vardir
+      end
+
+      it 'yields to the block' do
+        subject.with_puppet { Puppet[:vardir] }
+      end
+      it 'returns the nodes vardir' do
+        expect(subject.with_puppet { Puppet[:vardir] }).to eq vardir
+      end
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/puppet/parser/functions/enclose_ipv6_spec.rb b/code/environments/production/modules/stdlib/spec/unit/puppet/parser/functions/enclose_ipv6_spec.rb
new file mode 100644
index 0000000..c2a237e
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/puppet/parser/functions/enclose_ipv6_spec.rb
@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'the enclose_ipv6 function' do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  it 'exists' do
+    expect(Puppet::Parser::Functions.function('enclose_ipv6')).to eq('function_enclose_ipv6')
+  end
+
+  it 'raises a ParseError if there is less than 1 arguments' do
+    expect { scope.function_enclose_ipv6([]) }.to(raise_error(Puppet::ParseError))
+  end
+
+  it 'raises a ParseError if there is more than 1 arguments' do
+    expect { scope.function_enclose_ipv6(%w[argument1 argument2]) }.to(raise_error(Puppet::ParseError))
+  end
+
+  it 'raises a ParseError when given garbage' do
+    expect { scope.function_enclose_ipv6(['garbage']) }.to(raise_error(Puppet::ParseError))
+  end
+
+  it 'raises a ParseError when given something else than a string or an array' do
+    expect { scope.function_enclose_ipv6([['1' => '127.0.0.1']]) }.to(raise_error(Puppet::ParseError))
+  end
+
+  it 'does not raise a ParseError when given a single ip string' do
+    expect { scope.function_enclose_ipv6(['127.0.0.1']) }.not_to raise_error
+  end
+
+  it 'does not raise a ParseError when given * as ip string' do
+    expect { scope.function_enclose_ipv6(['*']) }.not_to raise_error
+  end
+
+  it 'does not raise a ParseError when given an array of ip strings' do
+    expect { scope.function_enclose_ipv6([['127.0.0.1', 'fe80::1']]) }.not_to raise_error
+  end
+
+  it 'does not raise a ParseError when given differently notations of ip addresses' do
+    expect { scope.function_enclose_ipv6([['127.0.0.1', 'fe80::1', '[fe80::1]']]) }.not_to raise_error
+  end
+
+  it 'raises a ParseError when given a wrong ipv4 address' do
+    expect { scope.function_enclose_ipv6(['127..0.0.1']) }.to(raise_error(Puppet::ParseError))
+  end
+
+  it 'raises a ParseError when given a ipv4 address with square brackets' do
+    expect { scope.function_enclose_ipv6(['[127.0.0.1]']) }.to(raise_error(Puppet::ParseError))
+  end
+
+  it 'raises a ParseError when given a wrong ipv6 address' do
+    expect { scope.function_enclose_ipv6(['fe80:::1']) }.to(raise_error(Puppet::ParseError))
+  end
+
+  it 'embraces ipv6 adresses within an array of ip addresses' do
+    result = scope.function_enclose_ipv6([['127.0.0.1', 'fe80::1', '[fe80::2]']])
+    expect(result).to(eq(['127.0.0.1', '[fe80::1]', '[fe80::2]']))
+  end
+
+  it 'embraces a single ipv6 adresse' do
+    result = scope.function_enclose_ipv6(['fe80::1'])
+    expect(result).to(eq(['[fe80::1]']))
+  end
+
+  it 'does not embrace a single ipv4 adresse' do
+    result = scope.function_enclose_ipv6(['127.0.0.1'])
+    expect(result).to(eq(['127.0.0.1']))
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/puppet/parser/functions/is_absolute_path_spec.rb b/code/environments/production/modules/stdlib/spec/unit/puppet/parser/functions/is_absolute_path_spec.rb
new file mode 100644
index 0000000..589ad82
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/puppet/parser/functions/is_absolute_path_spec.rb
@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe 'is_absolute_path' do
+  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+  let(:function_args) do
+    []
+  end
+
+  let(:function) do
+    scope.function_is_absolute_path(function_args)
+  end
+
+  describe 'validate arity' do
+    let(:function_args) do
+      [1, 2]
+    end
+
+    it 'raises a ParseError if there is more than 1 arguments' do
+      -> { function }.should(raise_error(ArgumentError))
+    end
+  end
+
+  it 'exists' do
+    Puppet::Parser::Functions.function(subject).should == "function_#{subject}"
+  end
+
+  # help enforce good function defination
+  it 'contains arity' do
+  end
+
+  it 'raises a ParseError if there is less than 1 arguments' do
+    -> { function }.should(raise_error(ArgumentError))
+  end
+
+  describe 'should retrun true' do
+    let(:return_value) do
+      true
+    end
+
+    describe 'windows' do
+      let(:function_args) do
+        ['c:\temp\test.txt']
+      end
+
+      it 'returns data' do
+        function.should eq(return_value)
+      end
+    end
+
+    describe 'non-windows' do
+      let(:function_args) do
+        ['/temp/test.txt']
+      end
+
+      it 'returns data' do
+        function.should eq(return_value)
+      end
+    end
+  end
+
+  describe 'should return false' do
+    let(:return_value) do
+      false
+    end
+
+    describe 'windows' do
+      let(:function_args) do
+        ['..\temp\test.txt']
+      end
+
+      it 'returns data' do
+        function.should eq(return_value)
+      end
+    end
+
+    describe 'non-windows' do
+      let(:function_args) do
+        ['../var/lib/puppet']
+      end
+
+      it 'returns data' do
+        function.should eq(return_value)
+      end
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec.rb b/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec.rb
new file mode 100644
index 0000000..d0f653a
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec.rb
@@ -0,0 +1,258 @@
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:file_line).provider(:ruby)
+#  These tests fail on windows when run as part of the rake task. Individually they pass
+describe provider_class, :unless => Puppet::Util::Platform.windows? do
+  include PuppetlabsSpec::Files
+
+  let :tmpfile do
+    tmpfilename('file_line_test')
+  end
+  let :content do
+    ''
+  end
+  let :params do
+    {}
+  end
+  let :resource do
+    Puppet::Type::File_line.new({
+      :name => 'foo',
+      :path => tmpfile,
+      :line => 'foo',
+    }.merge(params))
+  end
+  let :provider do
+    provider_class.new(resource)
+  end
+
+  before :each do
+    File.open(tmpfile, 'w') do |fh|
+      fh.write(content)
+    end
+  end
+
+  describe 'line parameter' do
+    context 'when line exists' do
+      let(:content) { 'foo' }
+
+      it 'detects the line' do
+        expect(provider).to be_exists
+      end
+    end
+    context 'when line does not exist' do
+      let(:content) { 'foo bar' }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'appends the line' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eq("foo bar\nfoo")
+      end
+    end
+  end
+
+  describe 'match parameter' do
+    let(:params) { { :match => '^bar' } }
+
+    describe 'does not match line - line does not exist - replacing' do
+      let(:content) { "foo bar\nbar" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the match' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eq("foo bar\nfoo")
+      end
+    end
+
+    describe 'does not match line - line does not exist - appending' do
+      let(:params) { super().merge(:replace => false) }
+      let(:content) { "foo bar\nbar" }
+
+      it 'does not request changes' do
+        expect(provider).to be_exists
+      end
+    end
+
+    context 'when does not match line - line exists' do
+      let(:content) { "foo\nbar" }
+
+      it 'detects the line' do
+        expect(provider).to be_exists
+      end
+    end
+
+    context 'when matches line - line exists' do
+      let(:params) { { :match => '^foo' } }
+      let(:content) { "foo\nbar" }
+
+      it 'detects the line' do
+        expect(provider).to be_exists
+      end
+    end
+
+    context 'when matches line - line does not exist' do
+      let(:params) { { :match => '^foo' } }
+      let(:content) { "foo bar\nbar" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the match' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eq("foo\nbar")
+      end
+    end
+  end
+
+  describe 'append_on_no_match' do
+    let(:params) do
+      {
+        :append_on_no_match => false,
+        :match => '^foo1$',
+      }
+    end
+
+    context 'when matching' do
+      let(:content) { "foo1\nbar" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the match' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo\nbar")
+      end
+    end
+    context 'when not matching' do
+      let(:content) { "foo3\nbar" }
+
+      it 'does not affect the file' do
+        expect(provider).to be_exists
+      end
+    end
+  end
+
+  describe 'replace_all_matches_not_matching_line' do
+    context 'when replace is false' do
+      let(:params) do
+        {
+          :replace_all_matches_not_matching_line => true,
+          :replace => false,
+        }
+      end
+
+      it 'raises an error' do
+        expect { provider.exists? }.to raise_error(Puppet::Error, %r{replace must be true})
+      end
+    end
+
+    context 'when match matches line - when there are more matches than lines' do
+      let(:params) do
+        {
+          :replace_all_matches_not_matching_line => true,
+          :match => '^foo',
+          :multiple => true,
+        }
+      end
+      let(:content) { "foo\nfoo bar\nbar\nfoo baz" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the matches' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo\nfoo\nbar\nfoo")
+      end
+    end
+
+    context 'when match matches line - when there are the same matches and lines' do
+      let(:params) do
+        {
+          :replace_all_matches_not_matching_line => true,
+          :match => '^foo',
+          :multiple => true,
+        }
+      end
+      let(:content) { "foo\nfoo\nbar" }
+
+      it 'does not request changes' do
+        expect(provider).to be_exists
+      end
+    end
+
+    context 'when match does not match line - when there are more matches than lines' do
+      let(:params) do
+        {
+          :replace_all_matches_not_matching_line => true,
+          :match => '^bar',
+          :multiple => true,
+        }
+      end
+      let(:content) { "foo\nfoo bar\nbar\nbar baz" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the matches' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo\nfoo bar\nfoo\nfoo")
+      end
+    end
+
+    context 'when match does not match line - when there are the same matches and lines' do
+      let(:params) do
+        {
+          :replace_all_matches_not_matching_line => true,
+          :match => '^bar',
+          :multiple => true,
+        }
+      end
+      let(:content) { "foo\nfoo\nbar\nbar baz" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the matches' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo\nfoo\nfoo\nfoo")
+      end
+    end
+  end
+
+  context 'when match does not match line - when there are no matches' do
+    let(:params) do
+      {
+        :replace_all_matches_not_matching_line => true,
+        :match => '^bar',
+        :multiple => true,
+      }
+    end
+    let(:content) { "foo\nfoo bar" }
+
+    it 'does not request changes' do
+      expect(provider).to be_exists
+    end
+  end
+
+  context 'when match does not match line - when there are no matches or lines' do
+    let(:params) do
+      {
+        :replace_all_matches_not_matching_line => true,
+        :match => '^bar',
+        :multiple => true,
+      }
+    end
+    let(:content) { 'foo bar' }
+
+    it 'requests changes' do
+      expect(provider).not_to be_exists
+    end
+    it 'appends the line' do
+      provider.create
+      expect(File.read(tmpfile).chomp).to eql("foo bar\nfoo")
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec_alter.rb b/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec_alter.rb
new file mode 100644
index 0000000..c2b30ff
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec_alter.rb
@@ -0,0 +1,374 @@
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:file_line).provider(:ruby)
+#  These tests fail on windows when run as part of the rake task. Individually they pass
+describe provider_class, :unless => Puppet::Util::Platform.windows? do
+  include PuppetlabsSpec::Files
+
+  let :tmpfile do
+    tmpfilename('file_line_test')
+  end
+  let :content do
+    ''
+  end
+  let :params do
+    {}
+  end
+  let :resource do
+    Puppet::Type::File_line.new({
+      :name => 'foo',
+      :path => tmpfile,
+      :line => 'foo',
+    }.merge(params))
+  end
+  let :provider do
+    provider_class.new(resource)
+  end
+
+  before :each do
+    File.open(tmpfile, 'w') do |fh|
+      fh.write(content)
+    end
+  end
+
+  describe '#create' do
+    context 'when adding' do
+      pending('To be added.')
+    end
+    context 'when replacing' do
+      let :params do
+        {
+          :line => 'foo = bar',
+          :match => '^foo\s*=.*$',
+          :replace => false,
+        }
+      end
+      let(:content) { "foo1\nfoo=blah\nfoo2\nfoo3" }
+
+      it "providor 'be_exists'" do
+        expect(provider).to be_exists
+      end
+      it 'does not replace the matching line' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo1\nfoo=blah\nfoo2\nfoo3")
+      end
+      it 'appends the line if no matches are found' do
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo2") }
+        expect(provider.exists?).to be false
+        provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo1\nfoo2\nfoo = bar")
+      end
+      it 'raises an error with invalid values' do
+        expect {
+          @resource = Puppet::Type::File_line.new(
+            :name => 'foo', :path => tmpfile, :line => 'foo = bar', :match => '^foo\s*=.*$', :replace => 'asgadga',
+          )
+        }.to raise_error(Puppet::Error, %r{Invalid value "asgadga"\. Valid values are true, false\.})
+      end
+    end
+  end
+  describe '#destroy' do
+    pending('To be added?')
+  end
+  context 'when matching' do
+    # rubocop:disable RSpec/InstanceVariable : replacing before with let breaks the tests, variables need to be altered within it block : multi
+    before :each do
+      @resource = Puppet::Type::File_line.new(
+        :name => 'foo',
+        :path => tmpfile,
+        :line => 'foo = bar',
+        :match => '^foo\s*=.*$',
+      )
+      @provider = provider_class.new(@resource)
+    end
+    describe 'using match' do
+      it 'raises an error if more than one line matches, and should not have modified the file' do
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo=blah\nfoo2\nfoo=baz") }
+        expect { @provider.create }.to raise_error(Puppet::Error, %r{More than one line.*matches})
+        expect(File.read(tmpfile)).to eql("foo1\nfoo=blah\nfoo2\nfoo=baz")
+      end
+
+      it 'replaces all lines that matches' do
+        @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :line => 'foo = bar', :match => '^foo\s*=.*$', :multiple => true)
+        @provider = provider_class.new(@resource)
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo=blah\nfoo2\nfoo=baz") }
+        @provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2\nfoo = bar")
+      end
+
+      it 'replaces all lines that match, even when some lines are correct' do
+        @resource = Puppet::Type::File_line.new(:name => 'neil', :path => tmpfile, :line => "\thard\tcore\t0\n", :match => '^[ \t]hard[ \t]+core[ \t]+.*', :multiple => true)
+        @provider = provider_class.new(@resource)
+        File.open(tmpfile, 'w') { |fh| fh.write("\thard\tcore\t90\n\thard\tcore\t0\n") }
+        @provider.create
+        expect(File.read(tmpfile).chomp).to eql("\thard\tcore\t0\n\thard\tcore\t0")
+      end
+
+      it 'raises an error with invalid values' do
+        expect {
+          @resource = Puppet::Type::File_line.new(
+            :name => 'foo', :path => tmpfile, :line => 'foo = bar', :match => '^foo\s*=.*$', :multiple => 'asgadga',
+          )
+        }.to raise_error(Puppet::Error, %r{Invalid value "asgadga"\. Valid values are true, false\.})
+      end
+
+      it 'replaces a line that matches' do
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo=blah\nfoo2") }
+        @provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2")
+      end
+      it 'adds a new line if no lines match' do
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo2") }
+        @provider.create
+        expect(File.read(tmpfile)).to eql("foo1\nfoo2\nfoo = bar\n")
+      end
+      it 'does nothing if the exact line already exists' do
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo = bar\nfoo2") }
+        @provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2")
+      end
+    end
+    describe 'using match+append_on_no_match - when there is a match' do
+      it 'replaces line' do
+        @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :line => 'inserted = line', :match => '^foo3$', :append_on_no_match => false)
+        @provider = provider_class.new(@resource)
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo = blah\nfoo2\nfoo = baz") }
+        expect(File.read(tmpfile).chomp).to eql("foo1\nfoo = blah\nfoo2\nfoo = baz")
+      end
+    end
+    describe 'using match+append_on_no_match - when there is no match' do
+      it 'does not add line after no matches found' do
+        @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :line => 'inserted = line', :match => '^foo3$', :append_on_no_match => false)
+        @provider = provider_class.new(@resource)
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo = blah\nfoo2\nfoo = baz") }
+        expect(File.read(tmpfile).chomp).to eql("foo1\nfoo = blah\nfoo2\nfoo = baz")
+      end
+    end
+  end
+  context 'when match+replace+append_on_no_match' do
+    pending('to do')
+  end
+  context 'when after' do
+    let :resource do
+      Puppet::Type::File_line.new(
+        :name => 'foo',
+        :path => tmpfile,
+        :line => 'inserted = line',
+        :after => '^foo1',
+      )
+    end
+
+    let :provider do
+      provider_class.new(resource)
+    end
+
+    context 'when match and after set' do
+      shared_context 'when resource_create' do
+        let(:match) { '^foo2$' }
+        let(:after) { '^foo1$' }
+        let(:resource) do
+          Puppet::Type::File_line.new(
+            :name => 'foo',
+            :path => tmpfile,
+            :line => 'inserted = line',
+            :after => after,
+            :match => match,
+          )
+        end
+      end
+      before :each do
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo2\nfoo = baz") }
+      end
+      describe 'inserts at match' do
+        include_context 'resource_create'
+        it {
+          provider.create
+          expect(File.read(tmpfile).chomp).to eq("foo1\ninserted = line\nfoo = baz")
+        }
+      end
+      describe 'inserts a new line after when no match' do
+        include_context 'resource_create' do
+          let(:match) { '^nevergoingtomatch$' }
+        end
+        it {
+          provider.create
+          expect(File.read(tmpfile).chomp).to eq("foo1\ninserted = line\nfoo2\nfoo = baz")
+        }
+      end
+      describe 'append to end of file if no match for both after and match' do
+        include_context 'resource_create' do
+          let(:match) { '^nevergoingtomatch$' }
+          let(:after) { '^stillneverafter' }
+        end
+        it {
+          provider.create
+          expect(File.read(tmpfile).chomp).to eq("foo1\nfoo2\nfoo = baz\ninserted = line")
+        }
+      end
+    end
+    context 'with one line matching the after expression' do
+      before :each do
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo = blah\nfoo2\nfoo = baz") }
+      end
+
+      it 'inserts the specified line after the line matching the "after" expression' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo1\ninserted = line\nfoo = blah\nfoo2\nfoo = baz")
+      end
+    end
+    context 'with multiple lines matching the after expression' do
+      before :each do
+        File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo = blah\nfoo2\nfoo1\nfoo = baz") }
+      end
+
+      it 'errors out stating "One or no line must match the pattern"' do
+        expect { provider.create }.to raise_error(Puppet::Error, %r{One or no line must match the pattern})
+      end
+
+      it 'adds the line after all lines matching the after expression' do
+        @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :line => 'inserted = line', :after => '^foo1$', :multiple => true)
+        @provider = provider_class.new(@resource)
+        @provider.create
+        expect(File.read(tmpfile).chomp).to eql("foo1\ninserted = line\nfoo = blah\nfoo2\nfoo1\ninserted = line\nfoo = baz")
+      end
+    end
+    context 'with no lines matching the after expression' do
+      let :content do
+        "foo3\nfoo = blah\nfoo2\nfoo = baz\n"
+      end
+
+      before :each do
+        File.open(tmpfile, 'w') { |fh| fh.write(content) }
+      end
+
+      it 'appends the specified line to the file' do
+        provider.create
+        expect(File.read(tmpfile)).to eq(content << resource[:line] << "\n")
+      end
+    end
+  end
+  context 'when removing with a line' do
+    before :each do
+      # TODO: these should be ported over to use the PuppetLabs spec_helper
+      #  file fixtures once the following pull request has been merged:
+      # https://github.com/puppetlabs/puppetlabs-stdlib/pull/73/files
+      @resource = Puppet::Type::File_line.new(
+        :name => 'foo',
+        :path => tmpfile,
+        :line => 'foo',
+        :ensure => 'absent',
+      )
+      @provider = provider_class.new(@resource)
+    end
+    it 'removes the line if it exists' do
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2")
+    end
+    it 'removes the line without touching the last new line' do
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2\n") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2\n")
+    end
+    it 'removes any occurence of the line' do
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2\nfoo\nfoo") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2\n")
+    end
+    it 'example in the docs' do
+      @resource = Puppet::Type::File_line.new(:name => 'bashrc_proxy', :ensure => 'absent', :path => tmpfile, :line => 'export HTTP_PROXY=http://squid.puppetlabs.vm:3128')
+      @provider = provider_class.new(@resource)
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo2\nexport HTTP_PROXY=http://squid.puppetlabs.vm:3128\nfoo4\n") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2\nfoo4\n")
+    end
+  end
+  context 'when removing with a match' do
+    before :each do
+      @resource = Puppet::Type::File_line.new(
+        :name => 'foo',
+        :path => tmpfile,
+        :line => 'foo2',
+        :ensure => 'absent',
+        :match => 'o$',
+        :match_for_absence => true,
+      )
+      @provider = provider_class.new(@resource)
+    end
+
+    it 'finds a line to match' do
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2") }
+      expect(@provider.exists?).to be true
+    end
+
+    it 'removes one line if it matches' do
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2")
+    end
+
+    it 'the line parameter is actually not used at all but is silently ignored if here' do
+      @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :line => 'supercalifragilisticexpialidocious', :ensure => 'absent', :match => 'o$', :match_for_absence => true)
+      @provider = provider_class.new(@resource)
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2")
+    end
+
+    it 'and may not be here and does not need to be here' do
+      @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :ensure => 'absent', :match => 'o$', :match_for_absence => true)
+      @provider = provider_class.new(@resource)
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2")
+    end
+
+    it 'raises an error if more than one line matches' do
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2\nfoo\nfoo") }
+      expect { @provider.destroy }.to raise_error(Puppet::Error, %r{More than one line})
+    end
+
+    it 'removes multiple lines if :multiple is true' do
+      @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :line => 'foo2', :ensure => 'absent', :match => 'o$', :multiple => true, :match_for_absence => true)
+      @provider = provider_class.new(@resource)
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2\nfoo\nfoo") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2\n")
+    end
+
+    it 'ignores the match if match_for_absence is not specified' do
+      @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :line => 'foo2', :ensure => 'absent', :match => 'o$')
+      @provider = provider_class.new(@resource)
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo\n")
+    end
+
+    it 'ignores the match if match_for_absence is false' do
+      @resource = Puppet::Type::File_line.new(:name => 'foo', :path => tmpfile, :line => 'foo2', :ensure => 'absent', :match => 'o$', :match_for_absence => false)
+      @provider = provider_class.new(@resource)
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo\nfoo2") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo\n")
+    end
+
+    it 'example in the docs' do
+      @resource = Puppet::Type::File_line.new(
+        :name => 'bashrc_proxy', :ensure => 'absent', :path => tmpfile, :line => 'export HTTP_PROXY=http://squid.puppetlabs.vm:3128',
+        :match => '^export\ HTTP_PROXY\=', :match_for_absence => true
+      )
+      @provider = provider_class.new(@resource)
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo2\nexport HTTP_PROXY=foo\nfoo4\n") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2\nfoo4\n")
+    end
+
+    it 'example in the docs showing line is redundant' do
+      @resource = Puppet::Type::File_line.new(:name => 'bashrc_proxy', :ensure => 'absent', :path => tmpfile, :match => '^export\ HTTP_PROXY\=', :match_for_absence => true)
+      @provider = provider_class.new(@resource)
+      File.open(tmpfile, 'w') { |fh| fh.write("foo1\nfoo2\nexport HTTP_PROXY=foo\nfoo4\n") }
+      @provider.destroy
+      expect(File.read(tmpfile)).to eql("foo1\nfoo2\nfoo4\n")
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec_use_cases.rb b/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec_use_cases.rb
new file mode 100644
index 0000000..5114dec
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/puppet/provider/file_line/ruby_spec_use_cases.rb
@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:file_line).provider(:ruby)
+#  These tests fail on windows when run as part of the rake task. Individually they pass
+describe provider_class, :unless => Puppet::Util::Platform.windows? do
+  include PuppetlabsSpec::Files
+
+  let :tmpfile do
+    tmpfilename('file_line_test')
+  end
+  let :content do
+    ''
+  end
+  let :params do
+    {}
+  end
+  let :resource do
+    Puppet::Type::File_line.new({
+      :name => 'foo',
+      :path => tmpfile,
+      :line => 'foo',
+    }.merge(params))
+  end
+  let :provider do
+    provider_class.new(resource)
+  end
+
+  before :each do
+    File.open(tmpfile, 'w') do |fh|
+      fh.write(content)
+    end
+  end
+
+  describe 'customer use cases - no lines' do
+    describe 'MODULES-5003' do
+      let(:params) do
+        {
+          :line => "*\thard\tcore\t0",
+          :match => "^[ \t]*\\*[ \t]+hard[ \t]+core[ \t]+.*",
+          :multiple => true,
+        }
+      end
+      let(:content) { "*	hard	core	90\n*	hard	core	10\n" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the matches' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eq("*	hard	core	0\n*	hard	core	0")
+      end
+    end
+
+    describe 'MODULES-5003 - one match, one line - just ensure the line exists' do
+      let(:params) do
+        {
+          :line => "*\thard\tcore\t0",
+          :match => "^[ \t]*\\*[ \t]+hard[ \t]+core[ \t]+.*",
+          :multiple => true,
+        }
+      end
+      let(:content) { "*	hard	core	90\n*	hard	core	0\n" }
+
+      it 'does not request changes' do
+        expect(provider).to be_exists
+      end
+    end
+
+    describe 'MODULES-5003 - one match, one line - replace all matches, even when line exists' do
+      let(:params) do
+        {
+          :line => "*\thard\tcore\t0",
+          :match => "^[ \t]*\\*[ \t]+hard[ \t]+core[ \t]+.*",
+          :multiple => true,
+
+        }.merge(:replace_all_matches_not_matching_line => true)
+      end
+      let(:content) { "*	hard	core	90\n*	hard	core	0\n" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the matches' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eq("*	hard	core	0\n*	hard	core	0")
+      end
+    end
+
+    describe 'MODULES-5651 - match, no line' do
+      let(:params) do
+        {
+          :line => 'LogLevel=notice',
+          :match => '^#LogLevel$',
+        }
+      end
+      let(:content) { "#LogLevel\nstuff" }
+
+      it 'requests changes' do
+        expect(provider).not_to be_exists
+      end
+      it 'replaces the match' do
+        provider.create
+        expect(File.read(tmpfile).chomp).to eq("LogLevel=notice\nstuff")
+      end
+    end
+
+    describe 'MODULES-5651 - match, line' do
+      let(:params) do
+        {
+          :line => 'LogLevel=notice',
+          :match => '^#LogLevel$',
+        }
+      end
+      let(:content) { "#Loglevel\nLogLevel=notice\nstuff" }
+
+      it 'does not request changes' do
+        expect(provider).to be_exists
+      end
+    end
+
+    describe 'MODULES-5651 - no match, line' do
+      let(:params) do
+        {
+          :line => 'LogLevel=notice',
+          :match => '^#LogLevel$',
+        }
+      end
+      let(:content) { "LogLevel=notice\nstuff" }
+
+      it 'does not request changes' do
+        expect(provider).to be_exists
+      end
+    end
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/puppet/type/anchor_spec.rb b/code/environments/production/modules/stdlib/spec/unit/puppet/type/anchor_spec.rb
new file mode 100644
index 0000000..c2d9779
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/puppet/type/anchor_spec.rb
@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+anchor = Puppet::Type.type(:anchor).new(:name => 'ntp::begin')
+
+describe anchor do
+  it 'stringifies normally' do
+    expect(anchor.to_s).to eq('Anchor[ntp::begin]')
+  end
+end
diff --git a/code/environments/production/modules/stdlib/spec/unit/puppet/type/file_line_spec.rb b/code/environments/production/modules/stdlib/spec/unit/puppet/type/file_line_spec.rb
new file mode 100644
index 0000000..627bdf0
--- /dev/null
+++ b/code/environments/production/modules/stdlib/spec/unit/puppet/type/file_line_spec.rb
@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'tempfile'
+describe Puppet::Type.type(:file_line) do
+  let :tmp_path do
+    if Puppet::Util::Platform.windows?
+      'C:\tmp\path'
+    else
+      '/tmp/path'
+    end
+  end
+  let :my_path do
+    if Puppet::Util::Platform.windows?
+      'C:\my\path'
+    else
+      '/my/path'
+    end
+  end
+  let :file_line do
+    Puppet::Type.type(:file_line).new(:name => 'foo', :line => 'line', :path => tmp_path)
+  end
+
+  it 'accepts a line' do
+    file_line[:line] = 'my_line'
+    expect(file_line[:line]).to eq('my_line')
+  end
+  it 'accepts a path' do
+    file_line[:path] = my_path
+    expect(file_line[:path]).to eq(my_path)
+  end
+  it 'accepts a match regex' do
+    file_line[:match] = '^foo.*$'
+    expect(file_line[:match]).to eq('^foo.*$')
+  end
+
+  it 'accepts a match regex that does not match the specified line' do
+    expect {
+      Puppet::Type.type(:file_line).new(
+        :name => 'foo', :path => my_path, :line => 'foo=bar', :match => '^bar=blah$',
+      )
+    }.not_to raise_error
+  end
+  it 'accepts a match regex that does match the specified line' do
+    expect {
+      Puppet::Type.type(:file_line).new(
+        :name => 'foo', :path => my_path, :line => 'foo=bar', :match => '^\s*foo=.*$',
+      )
+    }.not_to raise_error
+  end
+  it 'accepts utf8 characters' do
+    expect {
+      Puppet::Type.type(:file_line).new(
+        :name => 'ƒồỗ', :path => my_path, :line => 'ƒồỗ=ьåя', :match => '^ьåя=βļάħ$',
+      )
+    }.not_to raise_error
+  end
+  it 'accepts double byte characters' do
+    expect {
+      Puppet::Type.type(:file_line).new(
+        :name => 'フーバー', :path => my_path, :line => 'この=それ', :match => '^この=ああ$',
+      )
+    }.not_to raise_error
+  end
+  it 'accepts posix filenames' do
+    file_line[:path] = tmp_path
+    expect(file_line[:path]).to eq(tmp_path)
+  end
+  it 'does not accept unqualified path' do
+    expect { file_line[:path] = 'file' }.to raise_error(Puppet::Error, %r{File paths must be fully qualified})
+  end
+  it 'requires that a line is specified' do
+    expect { Puppet::Type.type(:file_line).new(:name => 'foo', :path => tmp_path) }.to raise_error(Puppet::Error, %r{line is a required attribute})
+  end
+  it 'does not require that a line is specified when matching for absence' do
+    expect { Puppet::Type.type(:file_line).new(:name => 'foo', :path => tmp_path, :ensure => :absent, :match_for_absence => :true, :match => 'match') }.not_to raise_error # rubocop:disable Metrics/LineLength
+  end
+  it 'although if a line is specified anyway when matching for absence it still works and the line is silently ignored' do
+    expect { Puppet::Type.type(:file_line).new(:name => 'foo', :path => tmp_path, :line => 'i_am_irrelevant', :ensure => :absent, :match_for_absence => :true, :match => 'match') }.not_to raise_error # rubocop:disable Metrics/LineLength
+  end
+  it 'requires that a file is specified' do
+    expect { Puppet::Type.type(:file_line).new(:name => 'foo', :line => 'path') }.to raise_error(Puppet::Error, %r{path is a required attribute})
+  end
+  it 'defaults to ensure => present' do
+    expect(file_line[:ensure]).to eq :present
+  end
+  it 'defaults to replace => true' do
+    expect(file_line[:replace]).to eq :true
+  end
+  it 'defaults to encoding => UTF-8' do
+    expect(file_line[:encoding]).to eq 'UTF-8'
+  end
+  it 'accepts encoding => iso-8859-1' do
+    expect { Puppet::Type.type(:file_line).new(:name => 'foo', :path => tmp_path, :ensure => :present, :encoding => 'iso-8859-1', :line => 'bar') }.not_to raise_error
+  end
+
+  it 'autorequires the file it manages' do
+    catalog = Puppet::Resource::Catalog.new
+    file = Puppet::Type.type(:file).new(:name => tmp_path)
+    catalog.add_resource file
+    catalog.add_resource file_line
+    relationship = file_line.autorequire.find do |rel|
+      (rel.source.to_s == "File[#{tmp_path}]") && (rel.target.to_s == file_line.to_s)
+    end
+    expect(relationship).to be_a Puppet::Relationship
+  end
+
+  it 'does not autorequire the file it manages if it is not managed' do
+    catalog = Puppet::Resource::Catalog.new
+    catalog.add_resource file_line
+    expect(file_line.autorequire).to be_empty
+  end
+end