chef 18.8.11 → 18.8.54

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

@@ -1,110 +0,0 @@
-#
-# Author:: Trevor O (trevoro@joyent.com)
-# Author:: Yukihiko Sawanobori (sawanoboriyu@higanworks.com)
-# Copyright:: Copyright 2012-2016, Opscode
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "ostruct"
-
-describe Chef::Provider::Package::SmartOS, "load_current_resource" do
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @new_resource = Chef::Resource::Package.new("varnish")
-    @current_resource = Chef::Resource::Package.new("varnish")
-
-    @status = double("Status", exitstatus: 0)
-    @provider = Chef::Provider::Package::SmartOS.new(@new_resource, @run_context)
-    allow(Chef::Resource::Package).to receive(:new).and_return(@current_resource)
-    @stdin = StringIO.new
-    @stdout = "varnish-2.1.5nb2\n"
-    @stderr = StringIO.new
-    @pid = 10
-    @shell_out = OpenStruct.new(stdout: @stdout, stdin: @stdin, stderr: @stderr, status: @status, exitstatus: 0)
-  end
-
-  describe "when loading current resource" do
-
-    it "should create a current resource with the name of the new_resource" do
-      expect(@provider).to receive(:shell_out_compacted!).and_return(@shell_out)
-      expect(Chef::Resource::Package).to receive(:new).and_return(@current_resource)
-      @provider.load_current_resource
-    end
-
-    it "should set the current resource package name" do
-      expect(@provider).to receive(:shell_out_compacted!).and_return(@shell_out)
-      expect(@current_resource).to receive(:package_name).with(@new_resource.package_name)
-      @provider.load_current_resource
-    end
-
-    it "should set the installed version if it is installed" do
-      expect(@provider).to receive(:shell_out_compacted!).and_return(@shell_out)
-      @provider.load_current_resource
-      expect(@current_resource.version).to eq("2.1.5nb2")
-    end
-
-    it "should set the installed version to nil if it's not installed" do
-      out = OpenStruct.new(stdout: nil)
-      expect(@provider).to receive(:shell_out_compacted!).and_return(out)
-      @provider.load_current_resource
-      expect(@current_resource.version).to eq(nil)
-    end
-
-  end
-
-  describe "candidate_version" do
-    it "should return the candidate_version variable if already setup" do
-      @provider.candidate_version = "2.1.1"
-      expect(@provider).not_to receive(:shell_out_compacted!)
-      @provider.candidate_version
-    end
-
-    it "should lookup the candidate_version if the variable is not already set (pkgin separated by spaces)" do
-      search = double
-      expect(search).to receive(:each_line)
-        .and_yield("something-varnish-1.1.1   something varnish like\n")
-        .and_yield("varnish-2.3.4             actual varnish\n")
-      @shell_out = double("shell_out!", stdout: search)
-      expect(@provider).to receive(:shell_out_compacted!).with("/opt/local/bin/pkgin", "se", "varnish", env: nil, returns: [0, 1], timeout: 900).and_return(@shell_out)
-      expect(@provider.candidate_version).to eq("2.3.4")
-    end
-
-    it "should lookup the candidate_version if the variable is not already set (pkgin separated by semicolons)" do
-      search = double
-      expect(search).to receive(:each_line)
-        .and_yield("something-varnish-1.1.1;;something varnish like\n")
-        .and_yield("varnish-2.3.4;;actual varnish\n")
-      @shell_out = double("shell_out!", stdout: search)
-      expect(@provider).to receive(:shell_out_compacted!).with("/opt/local/bin/pkgin", "se", "varnish", env: nil, returns: [0, 1], timeout: 900).and_return(@shell_out)
-      expect(@provider.candidate_version).to eq("2.3.4")
-    end
-  end
-
-  describe "when manipulating a resource" do
-
-    it "run pkgin and install the package" do
-      out = OpenStruct.new(stdout: nil)
-      expect(@provider).to receive(:shell_out_compacted!).with("/opt/local/sbin/pkg_info", "-E", "varnish*", { env: nil, returns: [0, 1], timeout: 900 }).and_return(@shell_out)
-      expect(@provider).to receive(:shell_out_compacted!).with("/opt/local/bin/pkgin", "-y", "install", "varnish-2.1.5nb2", { env: nil, timeout: 900 }).and_return(out)
-      @provider.load_current_resource
-      @provider.install_package("varnish", "2.1.5nb2")
-    end
-
-  end
-
-end

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

@@ -1,208 +0,0 @@
-# Author:: S.Cavallo (smcavallo@hotmail.com)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "chef/provider/package"
-require "chef/provider/package/snap"
-require "json"
-
-describe Chef::Provider::Package::Snap do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:package) { "hello" }
-  let(:source) { "/tmp/hello_20.snap" }
-  let(:new_resource) do
-    new_resource = Chef::Resource::SnapPackage.new(package)
-    new_resource.source source
-    new_resource
-  end
-  let(:provider) { Chef::Provider::Package::Snap.new(new_resource, run_context) }
-  let(:snap_status) do
-    stdout = <<~SNAP_S
-      path:    "/tmp/hello_20.snap"
-      name:    hello
-      summary: GNU Hello, the "hello world" snap
-      version: 2.10 -
-    SNAP_S
-    status = double(stdout: stdout, stderr: "", exitstatus: 0)
-    allow(status).to receive(:error!).with(no_args).and_return(false)
-    status
-  end
-
-  before(:each) do
-    allow(provider).to receive(:shell_out_compacted!).with("snap", "info", source, timeout: 900).and_return(snap_status)
-  end
-
-  # Example output from https://github.com/snapcore/snapd/wiki/REST-API
-  find_result_success = JSON.parse(File.read(File.join(CHEF_SPEC_DATA, "snap_package", "find_result_success.json")))
-  find_result_fail = JSON.parse(File.read(File.join(CHEF_SPEC_DATA, "snap_package", "find_result_failure.json")))
-  get_by_name_result_success = JSON.parse(File.read(File.join(CHEF_SPEC_DATA, "snap_package", "get_by_name_result_success.json")))
-  get_by_name_result_fail = JSON.parse(File.read(File.join(CHEF_SPEC_DATA, "snap_package", "get_by_name_result_failure.json")))
-  async_result_success = JSON.parse(File.read(File.join(CHEF_SPEC_DATA, "snap_package", "async_result_success.json")))
-  result_fail = JSON.parse(File.read(File.join(CHEF_SPEC_DATA, "snap_package", "result_failure.json")))
-  change_id_result = JSON.parse(File.read(File.join(CHEF_SPEC_DATA, "snap_package", "change_id_result.json")))
-  get_conf_success = JSON.parse(File.read(File.join(CHEF_SPEC_DATA, "snap_package", "get_conf_success.json")))
-
-  describe "#define_resource_requirements" do
-
-    before do
-      allow_any_instance_of(Chef::Provider::Package::Snap).to receive(:call_snap_api).with("GET", "/v2/snaps/#{package}").and_return(get_by_name_result_success)
-    end
-
-    it "should raise an exception if a source is supplied but not found when :install" do
-      allow(::File).to receive(:exist?).with(source).and_return(false)
-      expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
-    end
-
-    it "should raise an exception if a source is supplied but not found when :upgrade" do
-      allow(::File).to receive(:exist?).with(source).and_return(false)
-      expect { provider.run_action(:upgrade) }.to raise_error(Chef::Exceptions::Package)
-    end
-  end
-
-  describe "when using a local file source" do
-    let(:source) { "/tmp/hello_20.snap" }
-
-    before do
-      allow_any_instance_of(Chef::Provider::Package::Snap).to receive(:call_snap_api).with("GET", "/v2/snaps/#{package}").and_return(get_by_name_result_success)
-    end
-
-    it "should create a current resource with the name of the new_resource" do
-      provider.load_current_resource
-      expect(provider.current_resource.package_name).to eq("hello")
-    end
-
-    describe "gets the candidate version from the source package" do
-
-      def check_version(version)
-        provider.load_current_resource
-        expect(provider.current_resource.package_name).to eq("hello")
-        expect(provider.get_current_versions).to eq(["1.15.71"])
-        expect(provider.candidate_version).to eq([version])
-      end
-
-      it "checks the installed and local candidate versions" do
-        check_version("2.10")
-      end
-
-      it "generates multipart form data" do
-        expected = <<~SNAP_S
-          Host:
-          Content-Type: multipart/form-data; boundary=foo
-          Content-Length: 20480
-
-          --foo
-          Content-Disposition: form-data; name="action"
-
-          install
-          --foo
-          Content-Disposition: form-data; name="devmode"
-
-          true
-          --foo
-          Content-Disposition: form-data; name="snap"; filename="hello-world_27.snap"
-
-          <20480 bytes of snap file data>
-          --foo
-        SNAP_S
-
-        options = {}
-        options["devmode"] = true
-        path = "hello-world_27.snap"
-        content_length = "20480"
-
-        result = provider.send(:generate_multipart_form_data, "foo", "install", options, path, content_length)
-
-        expect(result).to eq(expected)
-
-      end
-
-    end
-  end
-
-  describe "when using the snap store" do
-    let(:source) { nil }
-    describe "gets the candidate version from the snap store" do
-      before do
-        allow_any_instance_of(Chef::Provider::Package::Snap).to receive(:call_snap_api).with("GET", "/v2/find?name=#{package}").and_return(find_result_success)
-        allow_any_instance_of(Chef::Provider::Package::Snap).to receive(:call_snap_api).with("GET", "/v2/snaps/#{package}").and_return(get_by_name_result_success)
-      end
-
-      def check_version(version)
-        provider.load_current_resource
-        expect(provider.current_resource.package_name).to eq("hello")
-        expect(provider.get_current_versions).to eq(["1.15.71"])
-        expect(provider.candidate_version).to eq([version])
-      end
-
-      it "checks the installed and store candidate versions" do
-        check_version("2.10")
-      end
-
-    end
-
-    describe "fails to get the candidate version from the snap store" do
-      before do
-        allow_any_instance_of(Chef::Provider::Package::Snap).to receive(:call_snap_api).with("GET", "/v2/find?name=#{package}").and_return(find_result_fail)
-        allow_any_instance_of(Chef::Provider::Package::Snap).to receive(:call_snap_api).with("GET", "/v2/snaps/#{package}").and_return(get_by_name_result_fail)
-      end
-
-      it "throws an error if candidate version not found" do
-        provider.load_current_resource
-        expect { provider.candidate_version }.to raise_error(Chef::Exceptions::Package)
-      end
-
-      it "does not throw an error if installed version not found" do
-        provider.load_current_resource
-        expect(provider.get_current_versions).to eq([])
-      end
-    end
-  end
-
-  describe "when calling async operations" do
-
-    it "should should throw if the async response is an error" do
-      expect { provider.send(:get_id_from_async_response, result_fail) }.to raise_error(RuntimeError)
-    end
-
-    it "should get the id from an async response" do
-      result = provider.send(:get_id_from_async_response, async_result_success)
-      expect(result).to eq("401")
-    end
-
-    it "should wait for change completion" do
-      result = provider.send(:get_id_from_async_response, async_result_success)
-      expect(result).to eq("401")
-    end
-  end
-
-  describe Chef::Provider::Package::Snap do
-
-    it "should post the correct json" do
-      snap_names = ["hello"]
-      action = "install"
-      channel = "stable"
-      options = {}
-      revision = nil
-      actual = provider.send(:generate_snap_json, snap_names, action, channel, options, revision)
-
-      expect(actual).to eq("action" => "install", "snaps" => ["hello"], "channel" => "stable")
-    end
-
-  end
-end

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

@@ -1,168 +0,0 @@
-#
-# Author:: Toomas Pelberg (<toomasp@gmx.net>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-require "spec_helper"
-
-describe Chef::Provider::Package::Solaris do
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-
-    @new_resource = Chef::Resource::Package.new("SUNWbash")
-    @new_resource.source("/tmp/bash.pkg")
-
-    @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
-    allow(::File).to receive(:exist?).and_return(true)
-  end
-
-  describe "assessing the current package status" do
-    before do
-      @pkginfo = <<~PKGINFO
-        PKGINST:  SUNWbash
-        NAME:  GNU Bourne-Again shell (bash)
-        CATEGORY:  system
-        ARCH:  sparc
-        VERSION:  11.10.0,REV=2005.01.08.05.16
-        BASEDIR:  /
-        VENDOR:  Sun Microsystems, Inc.
-        DESC:  GNU Bourne-Again shell (bash) version 3.0
-        PSTAMP:  sfw10-patch20070430084444
-        INSTDATE:  Nov 04 2009 01:02
-        HOTLINE:  Please contact your local service provider
-      PKGINFO
-
-      @status = double("Status", stdout: "", exitstatus: 0)
-    end
-
-    it "should create a current resource with the name of new_resource" do
-      allow(@provider).to receive(:shell_out_compacted).and_return(@status)
-      @provider.load_current_resource
-      expect(@provider.current_resource.name).to eq("SUNWbash")
-    end
-
-    it "should set the current resource package name to the new resource package name" do
-      allow(@provider).to receive(:shell_out_compacted).and_return(@status)
-      @provider.load_current_resource
-      expect(@provider.current_resource.package_name).to eq("SUNWbash")
-    end
-
-    it "should raise an exception if a source is supplied but not found" do
-      allow(@provider).to receive(:shell_out_compacted).and_return(@status)
-      allow(::File).to receive(:exist?).and_return(false)
-      @provider.load_current_resource
-      @provider.action = :install
-      @provider.define_resource_requirements
-      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Package)
-    end
-
-    it "should get the source package version from pkginfo if provided" do
-      status = double(stdout: @pkginfo, exitstatus: 0)
-      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(status)
-      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(@status)
-      @provider.load_current_resource
-
-      expect(@provider.current_resource.package_name).to eq("SUNWbash")
-      expect(@new_resource.version).to eq("11.10.0,REV=2005.01.08.05.16")
-    end
-
-    it "should return the current version installed if found by pkginfo" do
-      status = double(stdout: @pkginfo, exitstatus: 0)
-      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(@status)
-      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(status)
-      @provider.load_current_resource
-      expect(@provider.current_resource.version).to eq("11.10.0,REV=2005.01.08.05.16")
-    end
-
-    it "should raise an exception if the source is not set but we are installing" do
-      @new_resource = Chef::Resource::Package.new("SUNWbash")
-      @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
-      allow(@provider).to receive(:shell_out_compacted).and_return(@status)
-      expect { @provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
-    end
-
-    it "should raise an exception if pkginfo fails to run" do
-      status = double(stdout: "", exitstatus: -1)
-      allow(@provider).to receive(:shell_out_compacted).and_return(status)
-      expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Package)
-    end
-
-    it "should return a current resource with a nil version if the package is not found" do
-      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(@status)
-      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(@status)
-      @provider.load_current_resource
-      expect(@provider.current_resource.version).to be_nil
-    end
-  end
-
-  describe "candidate_version" do
-    it "should return the candidate_version variable if already setup" do
-      @provider.candidate_version = "11.10.0,REV=2005.01.08.05.16"
-      expect(@provider).not_to receive(:shell_out_compacted)
-      @provider.candidate_version
-    end
-
-    it "should lookup the candidate_version if the variable is not already set" do
-      status = double(stdout: "", exitstatus: 0)
-      allow(@provider).to receive(:shell_out_compacted).and_return(status)
-      expect(@provider).to receive(:shell_out_compacted)
-      @provider.candidate_version
-    end
-
-    it "should throw and exception if the exitstatus is not 0" do
-      status = double(stdout: "", exitstatus: 1)
-      allow(@provider).to receive(:shell_out_compacted).and_return(status)
-      expect { @provider.candidate_version }.to raise_error(Chef::Exceptions::Package)
-    end
-
-  end
-
-  describe "install and upgrade" do
-    it "should run pkgadd -n -d with the package source to install" do
-      expect(@provider).to receive(:shell_out_compacted!).with("pkgadd", "-n", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
-      @provider.install_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
-    end
-
-    it "should run pkgadd -n -d when the package is a path to install" do
-      @new_resource = Chef::Resource::Package.new("/tmp/bash.pkg")
-      @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
-      expect(@new_resource.source).to eq("/tmp/bash.pkg")
-      expect(@provider).to receive(:shell_out_compacted!).with("pkgadd", "-n", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
-      @provider.install_package("/tmp/bash.pkg", "11.10.0,REV=2005.01.08.05.16")
-    end
-
-    it "should run pkgadd -n -a /tmp/myadmin -d with the package options -a /tmp/myadmin" do
-      @new_resource.options "-a /tmp/myadmin"
-      expect(@provider).to receive(:shell_out_compacted!).with("pkgadd", "-n", "-a", "/tmp/myadmin", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
-      @provider.install_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
-    end
-  end
-
-  describe "remove" do
-    it "should run pkgrm -n to remove the package" do
-      expect(@provider).to receive(:shell_out_compacted!).with("pkgrm", "-n", "SUNWbash", { timeout: 900 })
-      @provider.remove_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
-    end
-
-    it "should run pkgrm -n -a /tmp/myadmin with options -a /tmp/myadmin" do
-      @new_resource.options "-a /tmp/myadmin"
-      expect(@provider).to receive(:shell_out_compacted!).with("pkgrm", "-n", "-a", "/tmp/myadmin", "SUNWbash", { timeout: 900 })
-      @provider.remove_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
-    end
-
-  end
-end

data/spec/unit/provider/package/windows/exe_spec.rb

@@ -1,201 +0,0 @@
-#
-# Author:: Matt Wrock <matt@mattwrock.com>
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "chef/provider/package/windows/exe"
-
-unless ChefUtils.windows?
-  class Chef
-    module ReservedNames::Win32
-      class File
-        def version_info
-          nil
-        end
-      end
-    end
-  end
-end
-
-describe Chef::Provider::Package::Windows::Exe do
-  let(:package_name) { "calculator" }
-  let(:resource_source) { "calculator.exe" }
-  let(:new_resource) do
-    new_resource = Chef::Resource::WindowsPackage.new(package_name)
-    new_resource.source(resource_source)
-    new_resource
-  end
-  let(:uninstall_hash) do
-    [{
-      "DisplayVersion" => "outdated",
-      "UninstallString" => File.join("uninst_dir", "uninst_file"),
-    }]
-  end
-  let(:uninstall_entry) do
-    entries = []
-    uninstall_hash.each do |entry|
-      entries.push(Chef::Provider::Package::Windows::RegistryUninstallEntry.new("hive", "key", entry))
-    end
-    entries
-  end
-  let(:provider) { Chef::Provider::Package::Windows::Exe.new(new_resource, :nsis, uninstall_entry) }
-
-  before(:each) do
-    allow(::File).to receive(:exist?).with(Chef::Util::PathHelper.canonical_path(resource_source, false)).and_return(true)
-  end
-
-  it "responds to shell_out!" do
-    expect(provider).to respond_to(:shell_out!)
-  end
-
-  describe "expand_options" do
-    it "returns an empty string if passed no options" do
-      expect(provider.expand_options(nil)).to eql ""
-    end
-
-    it "returns a string with a leading space if passed options" do
-      expect(provider.expand_options("--train nope --town no_way")).to eql(" --train nope --town no_way")
-    end
-  end
-
-  describe "installed_version" do
-    it "returns the installed version" do
-      expect(provider.installed_version).to eql(["outdated"])
-    end
-
-    context "no versions installed" do
-      let(:uninstall_hash) { [] }
-
-      it "returns the installed version" do
-        expect(provider.installed_version).to eql(nil)
-      end
-    end
-  end
-
-  describe "package_version" do
-    before { new_resource.version(nil) }
-
-    context "source file does not exist" do
-      before do
-        allow(::File).to receive(:exist?).with(Chef::Util::PathHelper.canonical_path(resource_source, false)).and_return(false)
-      end
-
-      it "returns nil" do
-        expect(provider.package_version).to eql(nil)
-      end
-    end
-
-    it "returns the version property if given" do
-      new_resource.version("v55555")
-      expect(provider.package_version).to eql("v55555")
-    end
-
-    it "returns nil if no version given" do
-      expect(provider.package_version).to eql(nil)
-    end
-  end
-
-  describe "remove_package" do
-    before do
-      allow(::File).to receive(:exist?).and_return(false)
-    end
-
-    context "no version given and one package installed with unquoted uninstall string" do
-      it "removes installed package and quotes uninstall string" do
-        allow(::File).to receive(:exist?).with("uninst_dir/uninst_file").and_return(true)
-        expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"uninst_dir/uninst_file\" /S /NCRC & exit %%%%ERRORLEVEL%%%%}, kind_of(Hash))
-        provider.remove_package
-      end
-    end
-
-    context "When timeout value is passed" do
-      it "removes installed package and quotes uninstall string" do
-        new_resource.timeout = 300
-        allow(::File).to receive(:exist?).with("uninst_dir/uninst_file").and_return(true)
-        expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"uninst_dir/uninst_file\" /S /NCRC & exit %%%%ERRORLEVEL%%%%}, default_env: false, timeout: 300, returns: [0, 3010])
-        provider.remove_package
-      end
-    end
-
-    context "several packages installed with quoted uninstall strings" do
-      let(:uninstall_hash) do
-        [
-          {
-          "DisplayVersion" => "v1",
-          "UninstallString" => "\"#{File.join("uninst_dir1", "uninst_file1")}\"",
-          },
-          {
-          "DisplayVersion" => "v2",
-          "UninstallString" => "\"#{File.join("uninst_dir2", "uninst_file2")}\"",
-          },
-        ]
-      end
-
-      context "version given and installed" do
-        it "removes given version" do
-          new_resource.version("v2")
-          expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"uninst_dir2/uninst_file2\" /S /NCRC & exit %%%%ERRORLEVEL%%%%}, kind_of(Hash))
-          provider.remove_package
-        end
-      end
-
-      context "no version given" do
-        it "removes both versions" do
-          expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"uninst_dir1/uninst_file1\" /S /NCRC & exit %%%%ERRORLEVEL%%%%}, kind_of(Hash))
-          expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"uninst_dir2/uninst_file2\" /S /NCRC & exit %%%%ERRORLEVEL%%%%}, kind_of(Hash))
-          provider.remove_package
-        end
-      end
-    end
-  end
-
-  context "installs nsis installer" do
-    let(:provider) { Chef::Provider::Package::Windows::Exe.new(new_resource, :nsis, uninstall_entry) }
-
-    it "calls installer with the correct flags" do
-      expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"#{Regexp.quote(new_resource.source)}\" /S /NCRC  & exit %%%%ERRORLEVEL%%%%}, kind_of(Hash))
-      provider.install_package
-    end
-  end
-
-  context "installs installshield installer" do
-    let(:provider) { Chef::Provider::Package::Windows::Exe.new(new_resource, :installshield, uninstall_entry) }
-
-    it "calls installer with the correct flags" do
-      expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"#{Regexp.quote(new_resource.source)}\" /s /sms  & exit %%%%ERRORLEVEL%%%%}, kind_of(Hash))
-      provider.install_package
-    end
-  end
-
-  context "installs inno installer" do
-    let(:provider) { Chef::Provider::Package::Windows::Exe.new(new_resource, :inno, uninstall_entry) }
-
-    it "calls installer with the correct flags" do
-      expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"#{Regexp.quote(new_resource.source)}\" /VERYSILENT /SUPPRESSMSGBOXES /NORESTART  & exit %%%%ERRORLEVEL%%%%}, kind_of(Hash))
-      provider.install_package
-    end
-  end
-
-  context "installs wise installer" do
-    let(:provider) { Chef::Provider::Package::Windows::Exe.new(new_resource, :wise, uninstall_entry) }
-
-    it "calls installer with the correct flags" do
-      expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"#{Regexp.quote(new_resource.source)}\" /s  & exit %%%%ERRORLEVEL%%%%}, kind_of(Hash))
-      provider.install_package
-    end
-  end
-end