puppet 5.0.0 → 6.0.0

data/spec/integration/provider/mount_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/file_bucket/dipper'
-
-describe "mount provider (integration)", :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-
-  family = Facter.value(:osfamily)
-
-  def create_fake_fstab(initially_contains_entry)
-    File.open(@fake_fstab, 'w') do |f|
-      if initially_contains_entry
-        f.puts("/dev/disk1s1\t/Volumes/foo_disk\tmsdos\tlocal\t0\t0")
-      end
-    end
-  end
-
-  before :each do
-    @fake_fstab = tmpfile('fstab')
-    @current_options = "local"
-    @current_device = "/dev/disk1s1"
-    Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
-    Facter.stubs(:value).with(:hostname).returns('some_host')
-    Facter.stubs(:value).with(:domain).returns('some_domain')
-    Facter.stubs(:value).with(:kernel).returns('Linux')
-    Facter.stubs(:value).with(:operatingsystem).returns('RedHat')
-    Facter.stubs(:value).with(:osfamily).returns('RedHat')
-    Puppet::Util::ExecutionStub.set do |command, options|
-      case command[0]
-      when %r{/s?bin/mount}
-        if command.length == 1
-          if @mounted
-            "#{@current_device} on /Volumes/foo_disk (msdos, #{@current_options})\n"
-          else
-            ''
-          end
-        else
-          expect(command.last).to eq('/Volumes/foo_disk')
-          @current_device = check_fstab(true)
-          @mounted = true
-          ''
-        end
-      when %r{/s?bin/umount}
-        expect(command.length).to eq(2)
-        expect(command[1]).to eq('/Volumes/foo_disk')
-        expect(@mounted).to eq(true) # "umount" doesn't work when device not mounted (see #6632)
-        @mounted = false
-        ''
-      else
-        fail "Unexpected command #{command.inspect} executed"
-      end
-    end
-  end
-
-  after :each do
-    Puppet::Type::Mount::ProviderParsed.clear # Work around bug #6628
-  end
-
-  def check_fstab(expected_to_be_present)
-    # Verify that the fake fstab has the expected data in it
-    fstab_contents = File.read(@fake_fstab).split("\n").reject { |x| x =~ /^#|^$/ }
-    if expected_to_be_present
-      expect(fstab_contents.length()).to eq(1)
-      device, rest_of_line = fstab_contents[0].split(/\t/,2)
-      expect(rest_of_line).to eq("/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0")
-      device
-    else
-      expect(fstab_contents.length()).to eq(0)
-      nil
-    end
-  end
-
-  def run_in_catalog(settings)
-    resource = Puppet::Type.type(:mount).new(settings.merge(:name => "/Volumes/foo_disk",
-                                             :device => "/dev/disk1s1", :fstype => "msdos"))
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
-    resource.expects(:err).never
-    catalog = Puppet::Resource::Catalog.new
-    catalog.host_config = false # Stop Puppet from doing a bunch of magic
-    catalog.add_resource resource
-    catalog.apply
-  end
-
-  [false, true].each do |initial_state|
-    describe "When initially #{initial_state ? 'mounted' : 'unmounted'}" do
-      before :each do
-        @mounted = initial_state
-      end
-
-      [false, true].each do |initial_fstab_entry|
-        describe "When there is #{initial_fstab_entry ? 'an' : 'no'} initial fstab entry" do
-          before :each do
-            create_fake_fstab(initial_fstab_entry)
-          end
-
-          [:defined, :present, :mounted, :unmounted, :absent].each do |ensure_setting|
-            expected_final_state = case ensure_setting
-              when :mounted
-                true
-              when :unmounted, :absent
-                false
-              when :defined, :present
-                initial_state
-              else
-                fail "Unknown ensure_setting #{ensure_setting}"
-            end
-            expected_fstab_data = (ensure_setting != :absent)
-            describe "When setting ensure => #{ensure_setting}" do
-              ["local", "journaled", "", nil].each do |options_setting|
-                describe "When setting options => '#{options_setting}'" do
-                  it "should leave the system in the #{expected_final_state ? 'mounted' : 'unmounted'} state, #{expected_fstab_data ? 'with' : 'without'} data in /etc/fstab" do
-                    if family == "Solaris"
-                      skip("Solaris: The mock :operatingsystem value does not get changed in lib/puppet/provider/mount/parsed.rb")
-                    else
-                      if options_setting && options_setting.empty?
-                        expect { run_in_catalog(:ensure=>ensure_setting, :options => options_setting) }.to raise_error Puppet::ResourceError
-                      else
-                        if options_setting
-                          @desired_options = options_setting
-                          run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
-                        else
-                          if initial_fstab_entry
-                            @desired_options = @current_options
-                          else
-                            @desired_options = 'defaults'
-                          end
-                          run_in_catalog(:ensure=>ensure_setting)
-                        end
-                        expect(@mounted).to eq(expected_final_state)
-                        if expected_fstab_data
-                          expect(check_fstab(expected_fstab_data)).to eq("/dev/disk1s1")
-                        else
-                          expect(check_fstab(expected_fstab_data)).to eq(nil)
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe "When the wrong device is mounted" do
-    it "should remount the correct device" do
-      pending "Due to bug 6309"
-      @mounted = true
-      @current_device = "/dev/disk2s2"
-      create_fake_fstab(true)
-      @desired_options = "local"
-      run_in_catalog(:ensure=>:mounted, :options=>'local')
-      expect(@current_device).to eq("/dev/disk1s1")
-      expect(@mounted).to eq(true)
-      expect(@current_options).to eq('local')
-      expect(check_fstab(true)).to eq("/dev/disk1s1")
-    end
-  end
-end

data/spec/integration/provider/ssh_authorized_key_spec.rb

@@ -1,219 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'puppet/file_bucket/dipper'
-
-describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration)', :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-
-  let :fake_userfile do
-    tmpfile('authorized_keys.user')
-  end
-
-  let :fake_rootfile do
-    tmpfile('authorized_keys.root')
-  end
-
-  let :sample_rsa_keys do
-    [
-      'AAAAB3NzaC1yc2EAAAADAQABAAAAgQCi18JBZOq10X3w4f67nVhO0O3s5Y1vHH4UgMSM3ZnQwbC5hjGyYSi9UULOoQQoQynI/a0I9NL423/Xk/XJVIKCHcS8q6V2Wmjd+fLNelOjxxoW6mbIytEt9rDvwgq3Mof3/m21L3t2byvegR00a+ikKbmInPmKwjeWZpexCIsHzQ==', # 1024 bit
-      'AAAAB3NzaC1yc2EAAAADAQABAAAAgQDLClyvi3CsJw5Id6khZs2/+s11qOH4Gdp6iDioDsrIp0m8kSiPr71VGyQYAfPzzvHemHS7Xg0NkG1Kc8u9tRqBQfTvz7ubq0AT/g01+4P2hQ/soFkuwlUG/HVnnaYb6N0Qp5SHWvD5vBE2nFFQVpP5GrSctPtHSjzJq/i+6LYhmQ==', # 1024 bit
-      'AAAAB3NzaC1yc2EAAAADAQABAAABAQDLygAO6txXkh9FNV8xSsBkATeqLbHzS7sFjGI3gt0Dx6q3LjyKwbhQ1RLf28kd5G6VWiXmClU/RtiPdUz8nrGuun++2mrxzrXrvpR9dq1lygLQ2wn2cI35dN5bjRMtXy3decs6HUhFo9MoNwX250rUWfdCyNPhGIp6OOfmjdy+UeLGNxq9wDx6i4bT5tVVSqVRtsEfw9+ICXchzl85QudjneVVpP+thriPZXfXA5eaGwAo/dmoKOIhUwF96gpdLqzNtrGQuxPbV80PTbGv9ZtAtTictxaDz8muXO7he9pXmchUpxUKtMFjHkL0FAZ9tRPmv3RA30sEr2fZ8+LKvnE50w0' #2048 Bit
-    ]
-  end
-
-  let :sample_dsa_keys do
-    [
-      'AAAAB3NzaC1kc3MAAACBAOPck2O8MIDSqxPSnvENt6tzRrKJ5oOhB6Nc6oEcWm+VEH1gvuxdiRqwoMgRwyEf1yUd+UAcLw3a6Jn+EtFyEBN/5WF+4Tt4xTxZ0Pfik2Wc5uqHbQ2dkmOoXiAOYPiD3JUQ1Xwm/J0CgetjitoLfzAGdCNhMqguqAuHcVJ78ZZbAAAAFQCIBKFYZ+I18I+dtgteirXh+VVEEwAAAIEAs1yvQ/wnLLrRCM660pF4kBiw3D6dJfMdCXWQpn0hZmkBQSIzZv4Wuk3giei5luxscDxNc+y3CTXtnyG4Kt1Yi2sOdvhRI3rX8tD+ejn8GHazM05l5VIo9uu4AQPIE32iV63IqgApSBbJ6vDJW91oDH0J492WdLCar4BS/KE3cRwAAACBAN0uSDyJqYLRsfYcFn4HyVf6TJxQm1IcwEt6GcJVzgjri9VtW7FqY5iBqa9B9Zdh5XXAYJ0XLsWQCcrmMHM2XGHGpA4gL9VlCJ/0QvOcXxD2uK7IXwAVUA7g4V4bw8EVnFv2Flufozhsp+4soo1xiYc5jiFVHwVlk21sMhAtKAeF' # 1024 Bit
-    ]
-  end
-
-  let :sample_lines do
-    [
-      "ssh-rsa #{sample_rsa_keys[1]} root@someotherhost",
-      "ssh-dss #{sample_dsa_keys[0]} root@anywhere",
-      "ssh-rsa #{sample_rsa_keys[2]} paul",
-      "ssh-rsa #{sample_rsa_keys[2]} dummy"
-    ]
-  end
-
-  let :dummy do
-    Puppet::Type.type(:ssh_authorized_key).new(
-      :name   => 'dummy',
-      :target => fake_userfile,
-      :user   => 'nobody',
-      :ensure => :absent
-    )
-  end
-
-  before :each do
-    File.stubs(:chown)
-    File.stubs(:chmod)
-    Puppet::Util::SUIDManager.stubs(:asuser).yields
-  end
-
-  after :each do
-    described_class.clear # Work around bug #6628
-  end
-
-  def create_fake_key(username, content)
-    filename = (username == :root ? fake_rootfile : fake_userfile )
-    File.open(filename, 'w') do |f|
-      content.each do |line|
-        f.puts line
-      end
-    end
-  end
-
-  def check_fake_key(username, expected_content)
-    filename = (username == :root ? fake_rootfile : fake_userfile )
-    content = File.readlines(filename).map(&:chomp).sort.reject{ |x| x =~ /^# HEADER:/ }
-    expect(content.join("\n")).to eq(expected_content.sort.join("\n"))
-  end
-
-  def run_in_catalog(*resources)
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
-    catalog = Puppet::Resource::Catalog.new
-    catalog.host_config = false
-    resources.each do |resource|
-      resource.expects(:err).never
-      catalog.add_resource(resource)
-    end
-    catalog.apply
-  end
-
-  it "should not complain about empty lines and comments" do
-    described_class.expects(:flush).never
-    sample = ['',sample_lines[0],'   ',sample_lines[1],'# just a comment','#and another']
-    create_fake_key(:user,sample)
-    run_in_catalog(dummy)
-    check_fake_key(:user, sample)
-  end
-
-  it "should keep empty lines and comments when modifying a file" do
-    create_fake_key(:user, ['',sample_lines[0],'   ',sample_lines[3],'# just a comment','#and another'])
-    run_in_catalog(dummy)
-    check_fake_key(:user, ['',sample_lines[0],'   ','# just a comment','#and another'])
-  end
-
-  describe "when managing one resource" do
-
-    describe "with ensure set to absent" do
-      let :resource do
-        Puppet::Type.type(:ssh_authorized_key).new(
-          :name     => 'root@hostname',
-          :type     => :rsa,
-          :key      => sample_rsa_keys[0],
-          :target   => fake_rootfile,
-          :user     => 'root',
-          :ensure   => :absent
-        )
-      end
-
-      it "should not modify root's keyfile if resource is currently not present" do
-        create_fake_key(:root, sample_lines)
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines)
-      end
-
-      it "remove the key from root's keyfile if resource is currently present" do
-        create_fake_key(:root, sample_lines + ["ssh-rsa #{sample_rsa_keys[0]} root@hostname"])
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines)
-      end
-    end
-
-    describe "when ensure is present" do
-      let :resource do
-        Puppet::Type.type(:ssh_authorized_key).new(
-          :name     => 'root@hostname',
-          :type     => :rsa,
-          :key      => sample_rsa_keys[0],
-          :target   => fake_rootfile,
-          :user     => 'root',
-          :ensure   => :present
-        )
-      end
-
-      # just a dummy so the parsedfile provider is aware
-      # of the user's authorized_keys file
-
-      it "should add the key if it is not present" do
-        create_fake_key(:root, sample_lines)
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines + ["ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should modify the type if type is out of sync" do
-        create_fake_key(:root,sample_lines + [ "ssh-dss #{sample_rsa_keys[0]} root@hostname" ])
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines + [ "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should modify the key if key is out of sync" do
-        create_fake_key(:root,sample_lines + [ "ssh-rsa #{sample_rsa_keys[1]} root@hostname" ])
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines + [ "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should remove the key from old file if target is out of sync" do
-        create_fake_key(:user, [ sample_lines[0], "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-        create_fake_key(:root, [ sample_lines[1], sample_lines[2] ])
-        run_in_catalog(resource, dummy)
-        check_fake_key(:user, [ sample_lines[0] ])
-        #check_fake_key(:root, [ sample_lines[1], sample_lines[2], "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should add the key to new file if target is out of sync" do
-        create_fake_key(:user, [ sample_lines[0], "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-        create_fake_key(:root, [ sample_lines[1], sample_lines[2] ])
-        run_in_catalog(resource, dummy)
-        #check_fake_key(:user, [ sample_lines[0] ])
-        check_fake_key(:root, [ sample_lines[1], sample_lines[2], "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should modify options if options are out of sync" do
-        resource[:options]=[ 'from="*.domain1,host1.domain2"', 'no-port-forwarding', 'no-pty' ]
-        create_fake_key(:root, sample_lines + [ "from=\"*.false,*.false2\",no-port-forwarding,no-pty ssh-rsa #{sample_rsa_keys[0]} root@hostname"])
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines + [ "from=\"*.domain1,host1.domain2\",no-port-forwarding,no-pty ssh-rsa #{sample_rsa_keys[0]} root@hostname"] )
-      end
-    end
-  end
-
-  describe "when managing two resource" do
-    let :examples do
-      resources = []
-      resources << Puppet::Type.type(:ssh_authorized_key).new(
-        :name     => 'root@hostname',
-        :type     => :rsa,
-        :key      => sample_rsa_keys[0],
-        :target   => fake_rootfile,
-        :user     => 'root',
-        :ensure   => :present
-      )
-      resources << Puppet::Type.type(:ssh_authorized_key).new(
-        :name   => 'user@hostname',
-        :key    => sample_rsa_keys[1],
-        :type   => :rsa,
-        :target => fake_userfile,
-        :user   => 'nobody',
-        :ensure => :present
-      )
-      resources
-    end
-
-    describe "and both keys are absent" do
-      before :each do
-        create_fake_key(:root, sample_lines)
-        create_fake_key(:user, sample_lines)
-      end
-
-      it "should add both keys" do
-        run_in_catalog(*examples)
-        check_fake_key(:root, sample_lines + [ "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-        check_fake_key(:user, sample_lines + [ "ssh-rsa #{sample_rsa_keys[1]} user@hostname" ])
-      end
-    end
-  end
-end

data/spec/integration/provider/sshkey_spec.rb

@@ -1,159 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'puppet/file_bucket/dipper'
-require 'puppet_spec/files'
-require 'puppet_spec/compiler'
-
-describe Puppet::Type.type(:sshkey).provider(:parsed), '(integration)',
-  :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-
-  before :each do
-    # Don't backup to filebucket
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup)
-    # We don't want to execute anything
-    described_class.stubs(:filetype).
-      returns Puppet::Util::FileType::FileTypeFlat
-
-    @sshkey_file = tmpfile('sshkey_integration_specs')
-    FileUtils.cp(my_fixture('sample'), @sshkey_file)
-  end
-
-  after :each do
-    # sshkey provider class
-    described_class.clear
-  end
-
-  let(:type_under_test) { 'sshkey' }
-
-  describe "when managing a ssh known hosts file it..." do
-
-    let(:super_unique) { "my.super.unique.host" }
-    it "should create a new known_hosts file with mode 0644" do
-      target   = tmpfile('ssh_known_hosts')
-      manifest = "#{type_under_test} { '#{super_unique}':
-                    ensure => 'present',
-                    type   => 'rsa',
-                    key    => 'TESTKEY',
-                    target => '#{target}' }"
-      apply_with_error_check(manifest)
-      expect_file_mode(target, "644")
-    end
-
-    it "should create an SSH host key entry (ensure present)" do
-      manifest = "#{type_under_test} { '#{super_unique}':
-                    ensure => 'present',
-                    type   => 'rsa',
-                    key    => 'mykey',
-                    target => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).to match(/#{super_unique}.*mykey/)
-    end
-
-    let(:sshkey_name) { 'kirby.madstop.com' }
-    it "should delete an entry for an SSH host key" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure => 'absent',
-                    target => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).not_to match(/#{sshkey_name}.*Yqk0=/)
-    end
-
-    it "should update an entry for an SSH host key" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure => 'present',
-                    type   => 'rsa',
-                    key    => 'mynewshinykey',
-                    target => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).to match(/#{sshkey_name}.*mynewshinykey/)
-      expect(File.read(@sshkey_file)).not_to match(/#{sshkey_name}.*Yqk0=/)
-    end
-
-    # test all key types
-    types = ["ssh-dss",     "dsa",
-             "ssh-ed25519", "ed25519",
-             "ssh-rsa",     "rsa",
-             "ecdsa-sha2-nistp256",
-             "ecdsa-sha2-nistp384",
-             "ecdsa-sha2-nistp521"]
-    # these types are treated as aliases for sshkey <ahem> type
-    #   so they are populated as the *values* below
-    aliases = {"dsa"     => "ssh-dss",
-               "ed25519" => "ssh-ed25519",
-               "rsa"     => "ssh-rsa"}
-    types.each do |type|
-      it "should update an entry with #{type} type" do
-        manifest = "#{type_under_test} { '#{sshkey_name}':
-                      ensure => 'present',
-                      type   => '#{type}',
-                      key    => 'mynewshinykey',
-                      target => '#{@sshkey_file}' }"
-
-        apply_with_error_check(manifest)
-        if aliases.has_key?(type)
-          full_type = aliases[type]
-          expect(File.read(@sshkey_file)).
-            to match(/#{sshkey_name}.*#{full_type}.*mynew/)
-        else
-          expect(File.read(@sshkey_file)).
-            to match(/#{sshkey_name}.*#{type}.*mynew/)
-        end
-      end
-    end
-
-    # test unknown key type fails
-    let(:invalid_type) { 'ssh-er0ck' }
-    it "should raise an error with an unknown type" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure => 'present',
-                    type   => '#{invalid_type}',
-                    key    => 'mynewshinykey',
-                    target => '#{@sshkey_file}' }"
-      expect {
-      apply_compiled_manifest(manifest)
-      }.to raise_error(Puppet::ResourceError, /Invalid value "#{invalid_type}"/)
-    end
-
-    #single host_alias
-    let(:host_alias) { 'r0ckdata.com' }
-    it "should update an entry with new host_alias" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure       => 'present',
-                    host_aliases => '#{host_alias}',
-                    target       => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).to match(/#{sshkey_name},#{host_alias}\s/)
-      expect(File.read(@sshkey_file)).not_to match(/#{sshkey_name}\s/)
-    end
-
-    #array host_alias
-    let(:host_aliases) { "r0ckdata.com,erict.net" }
-    it "should update an entry with new host_alias" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure       => 'present',
-                    host_aliases => '#{host_alias}',
-                    target       => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).to match(/#{sshkey_name},#{host_alias}\s/)
-      expect(File.read(@sshkey_file)).not_to match(/#{sshkey_name}\s/)
-    end
-
-    #puppet resource sshkey
-    it "should fetch an entry from resources" do
-      @resource_app = Puppet::Application[:resource]
-      @resource_app.preinit
-      @resource_app.command_line.stubs(:args).
-        returns([type_under_test, sshkey_name, "target=#{@sshkey_file}"])
-
-      @resource_app.expects(:puts).with do |args|
-        expect(args).to match(/#{sshkey_name}/)
-      end
-      @resource_app.main
-    end
-
-  end
-
-end

data/spec/integration/provider/yumrepo_spec.rb

@@ -1,130 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'puppet/file_bucket/dipper'
-require 'puppet_spec/files'
-require 'puppet_spec/compiler'
-
-describe Puppet::Type.type(:yumrepo).provider(:inifile), '(integration)',
-  :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-
-  before :each do
-    # Don't backup to filebucket
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup)
-    # We don't want to execute anything
-    described_class.stubs(:filetype).
-      returns Puppet::Util::FileType::FileTypeFlat
-
-    @yumrepo_dir  = tmpdir('yumrepo_integration_specs')
-    @yumrepo_file = tmpfile('yumrepo_file', @yumrepo_dir)
-    @yumrepo_conf_file = tmpfile('yumrepo_conf_file', @yumrepo_dir)
-    # this mocks the reposdir logic in the provider and thus won't test for
-    # issues like PUP-2916. Cover these types of issues in acceptance
-    described_class.stubs(:reposdir).returns [@yumrepo_dir]
-    described_class.stubs(:repofiles).returns [@yumrepo_conf_file]
-  end
-
-  after :each do
-    # yumrepo provider class
-    described_class.clear
-  end
-
-  let(:type_under_test) { :yumrepo }
-
-  describe 'when managing a yumrepo file it...' do
-    let(:super_creative) { 'my.super.creati.ve' }
-    let(:manifest) {
-      "#{type_under_test} { '#{super_creative}':
-                    baseurl => 'http://#{super_creative}',
-                    target  => '#{@yumrepo_file}' }"
-    }
-    let(:expected_match) { "\[#{super_creative}\]\nbaseurl=http:\/\/my\.super\.creati\.ve" }
-
-    it 'should create a new yumrepo file with mode 0644 and yumrepo entry' do
-      apply_with_error_check(manifest)
-      expect_file_mode(File.join(@yumrepo_dir, super_creative + '.repo'), "644")
-      expect(File.read(File.join(@yumrepo_dir, super_creative + '.repo'))).
-        to match(expected_match + "\n")
-    end
-
-    it 'should remove a managed yumrepo entry' do
-      apply_with_error_check(manifest)
-      manifest = "#{type_under_test} { '#{super_creative}':
-                    ensure => absent,
-                    target  => '#{@yumrepo_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(File.join(@yumrepo_dir, super_creative + '.repo'))).
-        to be_empty
-    end
-
-    it 'should update a managed yumrepo entry' do
-      apply_with_error_check(manifest)
-      manifest = "#{type_under_test} { '#{super_creative}':
-                    baseurl => 'http://#{super_creative}.updated',
-                    target  => '#{@yumrepo_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(File.join(@yumrepo_dir, super_creative + '.repo'))).
-        to match(expected_match + ".updated\n")
-    end
-
-    it 'should create all properties of a yumrepo entry' do
-      manifest = "#{type_under_test} { '#{super_creative}':
-                    baseurl => 'http://#{super_creative}',
-                    target  => '#{@yumrepo_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(File.join(@yumrepo_dir, super_creative + '.repo'))).
-        to match("\[#{super_creative}\]")
-    end
-
-    # The unit-tests cover all properties
-    #   and we have to hard-code the "should" values here.
-    # Puppet::Type.type(:yumrepo).validproperties contains the full list
-    #   but we can't get the property "should" values from the yumrepo-type
-    #   without having an instance of type, which is what yumrepo defines...
-    #   Just cover the most probable used properties.
-    properties = {"bandwidth"      => "42M",
-                  "baseurl"        => "http://er0ck",
-                  "cost"           => "42",
-                  "enabled"        => "yes",
-                  "exclude"        => "er0ckSet2.0",
-                  "failovermethod" => "roundrobin",
-                  "include"        => "https://er0ck",
-                  "mirrorlist"     => "https://er0ckMirr0r.co",
-                  "priority"       => "99",
-                  "retries"        => "413189",
-                  "timeout"        => "666"
-    }
-
-    it "should create an entry with various properties" do
-      manifest = "#{type_under_test} { '#{super_creative}':
-                          target  => '#{@yumrepo_file}',\n"
-      properties.each do |property_key, property_value|
-        manifest << "#{property_key} => '#{property_value}',\n"
-      end
-      manifest << "}"
-      apply_with_error_check(manifest)
-      file_lines = File.read(File.join(@yumrepo_dir, super_creative + '.repo'))
-      properties.each do |property_key, property_value|
-        if property_value =~ /^(true|false|no|yes)$/
-          property_value = property_value.capitalize
-        end
-        expect(file_lines).to match(/^#{property_key}=#{Regexp.escape(property_value)}$/)
-      end
-    end
-
-    ##puppet resource yumrepo
-    it "should fetch the yumrepo entries from resource face" do
-      @resource_app = Puppet::Application[:resource]
-      @resource_app.preinit
-      @resource_app.command_line.stubs(:args).
-        returns([type_under_test, super_creative])
-
-      @resource_app.expects(:puts).with  do |args|
-        expect(args).to match(/#{super_creative}/)
-      end
-      @resource_app.main
-    end
-  end
-end