puppet 6.4.5-x64-mingw32 → 6.5.0-x64-mingw32

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -448,6 +448,10 @@ describe 'loaders' do
       function = loader.load_typed(typed_name(:function, 'good_func_load')).value
       expect(function.call(scope)).to eql(Float("3.14"))
     end
+
+    it "a function with syntax error has helpful error message" do
+      expect { loader.load_typed(typed_name(:function, 'func_with_syntax_error')) }.to raise_error(/syntax error, unexpected keyword_end/)
+    end
   end
 
   context 'when a 3x load has illegal method added' do

data/spec/unit/pops/loaders/module_loaders_spec.rb

@@ -163,43 +163,6 @@ describe 'FileBased module loader' do
       expect(module_loader.load_typed(typed_name(:task, 'testmodule::baz'))).not_to be_nil
       expect { module_loader.load_typed(typed_name(:task, 'testmodule::qux')) }.to raise_error(/No source besides task metadata was found/)
     end
-
-    it 'raises and error when `parameters` is not a hash' do
-      metadata = { 'parameters' => 'foo' }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-      expect{module_loader.load_typed(typed_name(:task, 'testmodule::foo'))}
-        .to raise_error(Puppet::ParseError, /Failed to load metadata for task testmodule::foo: 'parameters' must be a hash/)
-    end
-
-    it 'raises and error when `implementations` `requirements` key is not an array' do
-      metadata = { 'implementations' => { 'name' => 'foo.py', 'requirements' => 'foo'} }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-      expect{module_loader.load_typed(typed_name(:task, 'testmodule::foo'))}
-        .to raise_error(Puppet::Module::Task::InvalidMetadata,
-        /Task metadata for task testmodule::foo does not specify implementations as an array/)
-    end
-
-    it 'raises and error when top-level `files` is not an array' do
-      metadata = { 'files' => 'foo' }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-      expect{module_loader.load_typed(typed_name(:task, 'testmodule::foo'))}
-        .to raise_error(Puppet::Module::Task::InvalidMetadata, /The 'files' task metadata expects an array, got foo/)
-    end
-
-    it 'raises and error when `files` nested in `interpreters` is not an array' do
-      metadata = { 'implementations' => [{'name' => 'foo.py', 'files' => 'foo'}] }
-      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => metadata.to_json})
-
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
-      expect{module_loader.load_typed(typed_name(:task, 'testmodule::foo'))}
-        .to raise_error(Puppet::Module::Task::InvalidMetadata, /The 'files' task metadata expects an array, got foo/)
-    end
   end
 
   def typed_name(type, name)

data/spec/unit/pops/types/types_spec.rb

@@ -219,6 +219,33 @@ describe 'Puppet Type System' do
     end
   end
 
+  context 'Regexp type' do
+    it 'parameterized type is assignable to base type' do
+      code = <<-CODE
+        notice(Regexp[a] < Regexp)
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true'])
+    end
+
+    it 'new function creates a new regexp' do
+      code = <<-CODE
+        $r = Regexp('abc')
+        notice('abc' =~ $r)
+        notice(type($r) =~ Type[Regexp])
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
+
+    it 'special characters are escaped with second parameter to Regexp.new set to true' do
+      code = <<-CODE
+        $r = Regexp('.[]', true)
+        notice('.[]' =~ $r)
+        notice(String($r) == "\\.\\[\\]")
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+    end
+  end
+
   context 'Iterable type' do
     it 'can be parameterized with element type' do
       code = <<-CODE

data/spec/unit/provider/exec_spec.rb

@@ -1,12 +1,7 @@
 require 'spec_helper'
 require 'puppet/provider/exec'
-require 'puppet_spec/compiler'
-require 'puppet_spec/files'
 
 describe Puppet::Provider::Exec do
-  include PuppetSpec::Compiler
-  include PuppetSpec::Files
-
   describe "#extractexe" do
     it "should return the first element of an array" do
       expect(subject.extractexe(['one', 'two'])).to eq('one')
@@ -36,208 +31,4 @@ describe Puppet::Provider::Exec do
       end
     end
   end
-
-  context "when handling sensitive data" do
-    before :each do
-      Puppet[:log_level] = 'debug'
-    end
-
-    let(:supersecret) { 'supersecret' }
-    let(:path) do
-      if Puppet::Util::Platform.windows?
-        # The `apply_compiled_manifest` helper doesn't add the `path` fact, so
-        # we can't reference that in our manifest. Windows PATHs can contain
-        # double quotes and trailing backslashes, which confuse HEREDOC
-        # interpolation below. So sanitize it:
-        ENV['PATH'].split(File::PATH_SEPARATOR).map do |dir|
-          dir.gsub(/"/, '\"').gsub(/\\$/, '')
-        end.join(File::PATH_SEPARATOR)
-      else
-        ENV['PATH']
-      end
-    end
-
-    def ruby_exit_0
-      "ruby -e 'exit 0'"
-    end
-
-    def echo_from_ruby_exit_0(message)
-      # Escape double quotes due to HEREDOC interpolation below
-      "ruby -e 'puts \"#{message}\"; exit 0'".gsub(/"/, '\"')
-    end
-
-    def echo_from_ruby_exit_1(message)
-      # Escape double quotes due to HEREDOC interpolation below
-      "ruby -e 'puts \"#{message}\"; exit 1'".gsub(/"/, '\"')
-    end
-
-    context "when validating the command" do
-      it "redacts the arguments if the command is relative" do
-        expect {
-          apply_compiled_manifest(<<-MANIFEST)
-            exec { 'echo':
-              command => Sensitive.new('echo #{supersecret}')
-            }
-          MANIFEST
-        }.to raise_error do |err|
-          expect(err).to be_a(Puppet::Error)
-          expect(err.message).to match(/'echo' is not qualified and no path was specified. Please qualify the command or specify a path./)
-          expect(err.message).to_not match(/#{supersecret}/)
-        end
-      end
-
-      it "redacts the arguments if the command is a directory" do
-        dir = tmpdir('exec')
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{dir} #{supersecret}'),
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /'#{dir}' is a directory, not a file/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-
-      it "redacts the arguments if the command isn't executable" do
-        file = tmpfile('exec')
-        Puppet::FileSystem.touch(file)
-        Puppet::FileSystem.chmod(0644, file)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{file} #{supersecret}'),
-          }
-        MANIFEST
-        # Execute permission works differently on Windows, but execute will fail since the
-        # file doesn't have a valid extension and isn't a valid executable. The raised error
-        # will be Errno::EIO, which is not useful. The Windows execute code needs to raise
-        # Puppet::Util::Windows::Error so the Win32 error message is preserved.
-        pending("PUP-3561 Needs to raise a meaningful Puppet::Error") if Puppet::Util::Platform.windows?
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /'#{file}' is not executable/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-
-      it "redacts the arguments if the relative command cannot be resolved using the path parameter" do
-        file = File.basename(tmpfile('exec'))
-        dir = tmpdir('exec')
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'echo':
-            command => Sensitive.new('#{file} #{supersecret}'),
-            path    => "#{dir}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :err, message: /Could not find command '#{file}'/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-      end
-    end
-
-    it "redacts the command on success", unless: Puppet::Util::Platform.jruby? do
-      command = echo_from_ruby_exit_0(supersecret)
-
-      apply_compiled_manifest(<<-MANIFEST)
-        exec { 'true':
-          command => Sensitive.new("#{command}"),
-          path    => "#{path}",
-        }
-      MANIFEST
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-      expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-      expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-    end
-
-    it "redacts the command on failure", unless: Puppet::Util::Platform.jruby? do
-      command = echo_from_ruby_exit_1(supersecret)
-
-      apply_compiled_manifest(<<-MANIFEST)
-        exec { 'false':
-          command => Sensitive.new("#{command}"),
-          path    => "#{path}",
-        }
-      MANIFEST
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[false\]/))
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-      expect(@logs).to include(an_object_having_attributes(level: :err, message: "[command redacted] returned 1 instead of one of [0]"))
-      expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-    end
-
-    context "when handling checks", unless: Puppet::Util::Platform.jruby? do
-      let(:onlyifsecret) { "onlyifsecret" }
-      let(:unlesssecret) { "unlesssecret" }
-
-      it "redacts command and onlyif outputs" do
-        onlyif = echo_from_ruby_exit_0(onlyifsecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{ruby_exit_0}"),
-            onlyif  => Sensitive.new("#{onlyif}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{onlyifsecret}/))
-      end
-
-      it "redacts the command that would have been executed but didn't due to onlyif" do
-        command = echo_from_ruby_exit_0(supersecret)
-        onlyif = echo_from_ruby_exit_1(onlyifsecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{command}"),
-            onlyif  => Sensitive.new("#{onlyif}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "'[command redacted]' won't be executed because of failed check 'onlyif'"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{onlyifsecret}/))
-      end
-
-      it "redacts command and unless outputs" do
-        unlesscmd = echo_from_ruby_exit_1(unlesssecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{ruby_exit_0}"),
-            unless  => Sensitive.new("#{unlesscmd}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{unlesssecret}/))
-      end
-
-      it "redacts the command that would have been executed but didn't due to unless" do
-        command = echo_from_ruby_exit_0(supersecret)
-        unlesscmd = echo_from_ruby_exit_0(unlesssecret)
-
-        apply_compiled_manifest(<<-MANIFEST)
-          exec { 'true':
-            command => Sensitive.new("#{command}"),
-            unless  => Sensitive.new("#{unlesscmd}"),
-            path    => "#{path}",
-          }
-        MANIFEST
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
-        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "'[command redacted]' won't be executed because of failed check 'unless'"))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
-        expect(@logs).to_not include(an_object_having_attributes(message: /#{unlesssecret}/))
-      end
-    end
-  end
 end

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

@@ -16,7 +16,7 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
     end
 
     def rpm_args
-      ['-q', 'faff', '--nosignature', '--nodigest', '--qf', "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n"]
+      ['-q', 'faff', '--nosignature', '--nodigest', '--qf', "'%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n'"]
     end
 
     it "should report purged packages" do

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

@@ -44,12 +44,5 @@ describe Puppet::Type.type(:package).provider(:dnf) do
     end
   end
 
-  describe 'provider features' do
-    it { is_expected.to be_versionable }
-    it { is_expected.to be_install_options }
-    it { is_expected.to be_virtual_packages }
-    it { is_expected.to be_install_only }
-  end
-
   it_behaves_like 'RHEL package provider', described_class, 'dnf'
 end

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

@@ -1,20 +1,18 @@
 require 'spec_helper'
 require 'stringio'
 
-describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Platform.jruby? do
+describe Puppet::Type.type(:package).provider(:dpkg) do
   let(:bash_version) { '4.2-5ubuntu3' }
   let(:bash_installed_output) { "install ok installed bash #{bash_version}\n" }
   let(:bash_installed_io) { StringIO.new(bash_installed_output) }
   let(:vim_installed_output) { "install ok installed vim 2:7.3.547-6ubuntu5\n" }
   let(:all_installed_io) { StringIO.new([bash_installed_output, vim_installed_output].join) }
   let(:args) { ['-W', '--showformat', %Q{'${Status} ${Package} ${Version}\\n'}] }
-  let(:args_with_provides) { ['/bin/dpkg-query','-W', '--showformat', %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}]}
   let(:execute_options) do
     {:failonfail => true, :combine => true, :custom_environment => {}}
   end
-  let(:resource_name) { 'python' }
+  let(:resource_name) { 'package' }
   let(:resource) { double('resource', :[] => resource_name) }
-  let(:dpkg_query_result) { 'install ok installed python 2.7.13' }
   let(:provider) { described_class.new(resource) }
 
   it "has documentation" do
@@ -70,247 +68,105 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
     end
 
-    def dpkg_query_execution_with_multiple_args_returns(output, *args)
-      args.each do |arg|
-        allow(Puppet::Util::Execution).to receive(:execute).with(arg, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
-      end
-    end
-
     before do
       allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
     end
 
     it "considers the package purged if dpkg-query fails" do
-      allow(resource).to receive(:allow_virtual?).and_return(false)
       allow(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
 
       expect(provider.query[:ensure]).to eq(:purged)
     end
 
-    context "allow_virtual true" do
-      before do
-        allow(resource).to receive(:allow_virtual?).and_return(true)
-      end
+    it "returns a hash of the found package status for an installed package" do
+      dpkg_query_execution_returns(bash_installed_output)
 
-      context "virtual_packages" do
-        let(:query_output) { 'install ok installed python 2.7.13 [python-ctypes, python-email, python-importlib, python-profiler, python-wsgiref, python-gold]' }
-        let(:virtual_packages_query_args) do
-          result = args_with_provides.dup
-          result.push(resource_name)
-        end
-
-        it "considers the package purged if dpkg-query fails" do
-          allow(Puppet::Util::Execution).to receive(:execute).with(args_with_provides, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
-          expect(provider.query[:ensure]).to eq(:purged)
-        end
-
-        it "returns a hash of the found package status for an installed package" do
-          dpkg_query_execution_with_multiple_args_returns(query_output, args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result, args, query_args)
-          expect(provider.query).to eq(:ensure => "2.7.13", :error => "ok", :desired => "install", :name => "python", :status => "installed", :provider => :dpkg)
-        end
-
-        it "considers the package absent if the dpkg-query result cannot be interpreted" do
-          dpkg_query_execution_with_multiple_args_returns('some-bad-data',args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns('some-bad-data', args, query_args)
-          expect(provider.query[:ensure]).to eq(:absent)
-        end
-
-        it "fails if an error is discovered" do
-          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("ok","error"),args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("ok","error"), args, query_args)
-          expect { provider.query }.to raise_error(Puppet::Error,  /Package python, version 2.7.13 is in error state: error/)
-        end
-
-        it "considers the package purged if it is marked 'not-installed" do
-          not_installed_query = query_output.gsub("installed", "not-installed").delete!('2.7.13')
-          dpkg_query_execution_with_multiple_args_returns(not_installed_query, args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed", "not-installed").delete!('2.7.13'), args, query_args)
-          expect(provider.query[:ensure]).to eq(:purged)
-        end
-
-        it "considers the package absent if it is marked 'config-files'" do
-          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("installed","config-files"),args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed","config-files"), args, query_args)
-          expect(provider.query[:ensure]).to eq(:absent)
-        end
-
-        it "considers the package absent if it is marked 'half-installed'" do
-          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("installed","half-installed"),args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed","half-installed"), args, query_args)
-          expect(provider.query[:ensure]).to eq(:absent)
-        end
-
-        it "considers the package absent if it is marked 'unpacked'" do
-          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("installed","unpacked"),args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed","unpacked"), args, query_args)
-          expect(provider.query[:ensure]).to eq(:absent)
-        end
-
-        it "considers the package absent if it is marked 'half-configured'" do
-          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("installed","half-configured"),args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("installed","half-configured"), args, query_args)
-          expect(provider.query[:ensure]).to eq(:absent)
-        end
-
-        it "considers the package held if its state is 'hold'" do
-          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("install","hold"),args_with_provides,virtual_packages_query_args)
-          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("install","hold"), args, query_args)
-          expect(provider.query[:ensure]).to eq(:held)
-        end
-
-        context "regex check for query search" do
-          let(:resource_name) { 'python-email' }
-          let(:resource) { instance_double('Puppet::Type::Package') }
-          before do
-            allow(resource).to receive(:[]).with(:name).and_return(resource_name)
-            allow(resource).to receive(:[]=)
-          end
-
-          it "checks if virtual package regex for query is correctand phisical package is installed" do
-            dpkg_query_execution_with_multiple_args_returns(query_output,args_with_provides,virtual_packages_query_args)
-            dpkg_query_execution_with_multiple_args_returns(dpkg_query_result, args, query_args)
-            expect(provider.query).to match({:desired=>"install", :ensure=>"2.7.13", :error=>"ok", :name=>"python", :provider=>:dpkg, :status=>"installed"})
-          end
-
-          context "regex check with no partial matching" do
-            let(:resource_name) { 'python-em' }
-
-            it "checks if virtual package regex for query is correct and regext dosen't make partial matching" do
-              expect(provider).to receive(:dpkgquery).with('-W', '--showformat', %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}).and_return(query_output)
-              expect(provider).to receive(:dpkgquery).with('-W', '--showformat', %Q{'${Status} ${Package} ${Version}\\n'}, resource_name).and_return("#{dpkg_query_result} #{resource_name}")
-
-              provider.query
-            end
-
-            context "regex check with special characters" do
-              let(:resource_name) { 'g++' }
-
-              it "checks if virtual package regex for query is correct and regext dosen't make partial matching" do
-                expect(Puppet).to_not receive(:info).with(/is virtual/)
-                expect(provider).to receive(:dpkgquery).with('-W', '--showformat', %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}).and_return(query_output)
-                expect(provider).to receive(:dpkgquery).with('-W', '--showformat', %Q{'${Status} ${Package} ${Version}\\n'}, resource_name).and_return("#{dpkg_query_result} #{resource_name}")
-
-                provider.query
-              end
-            end
-          end
-        end
-      end
+      expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
     end
 
-    context "allow_virtual false" do
-      before do
-        allow(resource).to receive(:allow_virtual?).and_return(false)
-      end
+    it "considers the package absent if the dpkg-query result cannot be interpreted" do
+      dpkg_query_execution_returns('some-bad-data')
 
-      it "returns a hash of the found package status for an installed package" do
-        dpkg_query_execution_returns(bash_installed_output)
+      expect(provider.query[:ensure]).to eq(:absent)
+    end
 
-        expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
-      end
+    it "fails if an error is discovered" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("ok","error"))
 
-      it "considers the package absent if the dpkg-query result cannot be interpreted" do
-        allow(resource).to receive(:allow_virtual?).and_return(false)
-        dpkg_query_execution_returns('some-bad-data')
-        expect(provider.query[:ensure]).to eq(:absent)
-      end
+      expect { provider.query }.to raise_error(Puppet::Error)
+    end
 
-      it "fails if an error is discovered" do
-        dpkg_query_execution_returns(bash_installed_output.gsub("ok","error"))
-        expect { provider.query }.to raise_error(Puppet::Error)
-      end
+    it "considers the package purged if it is marked 'not-installed'" do
+      not_installed_bash = bash_installed_output.gsub("installed", "not-installed")
+      not_installed_bash.gsub!(bash_version, "")
+      dpkg_query_execution_returns(not_installed_bash)
 
-      it "considers the package purged if it is marked 'not-installed'" do
-        not_installed_bash = bash_installed_output.gsub("installed", "not-installed")
-        not_installed_bash.gsub!(bash_version, "")
-        dpkg_query_execution_returns(not_installed_bash)
+      expect(provider.query[:ensure]).to eq(:purged)
+    end
 
-        expect(provider.query[:ensure]).to eq(:purged)
-      end
+    it "considers the package absent if it is marked 'config-files'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("installed","config-files"))
+      expect(provider.query[:ensure]).to eq(:absent)
+    end
 
-      it "considers the package absent if it is marked 'config-files'" do
-        dpkg_query_execution_returns(bash_installed_output.gsub("installed","config-files"))
-        expect(provider.query[:ensure]).to eq(:absent)
-      end
+    it "considers the package absent if it is marked 'half-installed'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-installed"))
+      expect(provider.query[:ensure]).to eq(:absent)
+    end
 
-      it "considers the package absent if it is marked 'half-installed'" do
-        dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-installed"))
-        expect(provider.query[:ensure]).to eq(:absent)
+    it "considers the package absent if it is marked 'unpacked'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("installed","unpacked"))
+      expect(provider.query[:ensure]).to eq(:absent)
+    end
+
+    it "considers the package absent if it is marked 'half-configured'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-configured"))
+      expect(provider.query[:ensure]).to eq(:absent)
+    end
+
+    it "considers the package held if its state is 'hold'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("install","hold"))
+      expect(provider.query[:ensure]).to eq(:held)
+    end
+
+    context "parsing tests" do
+      let(:resource_name) { 'name' }
+      let(:package_hash) do
+        {
+          :desired => 'desired',
+          :error => 'ok',
+          :status => 'status',
+          :name => resource_name,
+          :ensure => 'ensure',
+          :provider => :dpkg,
+        }
       end
+      let(:package_not_found_hash) do
+        {:ensure => :purged, :status => 'missing', :name => resource_name, :error => 'ok'}
+      end
+
+      def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
+        dpkg_query_execution_returns(dpkg_output_string)
+        expect(Puppet).not_to receive(:warning)
+        expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times
 
-      it "considers the package absent if it is marked 'unpacked'" do
-        dpkg_query_execution_returns(bash_installed_output.gsub("installed","unpacked"))
-        expect(provider.query[:ensure]).to eq(:absent)
+        expect(provider.query).to eq(gold_hash)
       end
 
-      it "considers the package absent if it is marked 'half-configured'" do
-        dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-configured"))
-        expect(provider.query[:ensure]).to eq(:absent)
+      it "parses properly even if optional ensure field is missing" do
+        no_ensure = 'desired ok status name '
+        parser_test(no_ensure, package_hash.merge(:ensure => ''))
       end
 
-      it "considers the package held if its state is 'hold'" do
-        dpkg_query_execution_returns(bash_installed_output.gsub("install","hold"))
-        expect(provider.query[:ensure]).to eq(:held)
+      it "provides debug logging of unparsable lines" do
+        parser_test('an unexpected dpkg msg with an exit code of 0', package_not_found_hash.merge(:ensure => :absent), 1)
       end
 
-      context "parsing tests" do
-        let(:resource_name) { 'name' }
-        let(:package_hash) do
-          {
-            :desired => 'desired',
-            :error => 'ok',
-            :status => 'status',
-            :name => resource_name,
-            :ensure => 'ensure',
-            :provider => :dpkg,
-          }
-        end
-
-        let(:package_not_found_hash) do
-          {:ensure => :purged, :status => 'missing', :name => resource_name, :error => 'ok'}
-        end
-
-        let(:output) {'an unexpected dpkg msg with an exit code of 0'}
-
-        def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
-          dpkg_query_execution_returns(dpkg_output_string)
-          expect(Puppet).not_to receive(:warning)
-          expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times
-
-          expect(provider.query).to eq(gold_hash)
-        end
-
-        it "parses properly even if optional ensure field is missing" do
-          no_ensure = 'desired ok status name '
-          parser_test(no_ensure, package_hash.merge(:ensure => ''))
-        end
-
-        it "provides debug logging of unparsable lines with allow_virtual enabled" do
-          allow(resource).to receive(:allow_virtual?).and_return(true)
-          dpkg_query_execution_with_multiple_args_returns(output, args_with_provides, query_args)
-          expect(Puppet).not_to receive(:warning)
-          expect(Puppet).to receive(:debug).exactly(1).times
-          expect(provider.query).to eq(package_not_found_hash.merge(:ensure => :absent))
-        end
-
-        it "provides debug logging of unparsable lines" do
-          parser_test('an unexpected dpkg msg with an exit code of 0', package_not_found_hash.merge(:ensure => :absent), 1)
-        end
-
-        it "does not log if execution returns with non-zero exit code with allow_virtual enabled" do
-          allow(resource).to receive(:allow_virtual?).and_return(true)
-          expect(Puppet::Util::Execution).to receive(:execute).with(args_with_provides, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
-          expect(Puppet).not_to receive(:debug)
-          expect(provider.query).to eq(package_not_found_hash)
-        end
-
-        it "does not log if execution returns with non-zero exit code" do
-          expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
-          expect(Puppet).not_to receive(:debug)
-
-          expect(provider.query).to eq(package_not_found_hash)
-        end
+      it "does not log if execution returns with non-zero exit code" do
+        expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
+        expect(Puppet).not_to receive(:debug)
+
+        expect(provider.query).to eq(package_not_found_hash)
       end
     end
   end
@@ -362,10 +218,11 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
 
     before do
       allow(tempfile).to receive(:write)
-      allow(Tempfile).to receive(:new).and_return(tempfile)
+      allow(Tempfile).to receive(:open).and_yield(tempfile)
     end
 
     it "installs first if package is not present and ensure holding" do
+
       allow(provider).to receive(:execute)
       allow(provider).to receive(:package_not_installed?).and_return(true)
       expect(provider).to receive(:install).once
@@ -401,8 +258,8 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
 
   context "when determining latest available version" do
     it "returns the version found by dpkg-deb" do
-      expect(resource).to receive(:[]).with(:source).and_return("python")
-      expect(provider).to receive(:dpkg_deb).with('--show', "python").and_return("package\t1.0")
+      expect(resource).to receive(:[]).with(:source).and_return("myfile")
+      expect(provider).to receive(:dpkg_deb).with(any_args, "myfile").and_return("package\t1.0")
       expect(provider.latest).to eq("1.0")
     end
 
@@ -430,26 +287,9 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
     provider.purge
   end
 
-  context "package_not_installed?" do
-    context "allow_virtual false" do
-        before do
-          allow(resource).to receive(:allow_virtual?).and_return(false)
-        end
-
-      it "returns true if package is not found" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_raise(Puppet::ExecutionFailure.new("eh"))
-        expect(provider.package_not_installed?).to eq(true)
-      end
-
-      it "returns true if package is not installed" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("unknown ok not-installed #{resource_name}")
-        expect(provider.package_not_installed?).to eq(true)
-      end
-
-      it "returns false if package is installed" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("install ok installed resource_name 1.2.3")
-        expect(provider.package_not_installed?).to eq(false)
-      end
-    end
+  it "raises error if package name is nil" do
+    expect {provider.package_not_installed?(nil)}.to raise_error(ArgumentError,"Package name is nil or empty")
+    expect {provider.package_not_installed?("")}.to raise_error(ArgumentError,"Package name is nil or empty")
   end
 end
+