chef 18.8.11 → 18.8.54

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

@@ -1,135 +0,0 @@
-#
-# Author:: Kapil Chouhan (<kapil.chouhan@msystechnologies.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"
-
-describe Chef::Provider::Package::Deb do
-  let(:node) do
-    node = Chef::Node.new
-    node.automatic_attrs[:platform] = :just_testing
-    node.automatic_attrs[:platform_version] = :just_testing
-    node
-  end
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:logger) { double("Mixlib::Log::Child").as_null_object }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:new_resource) { Chef::Resource::AptPackage.new("emacs", run_context) }
-  let(:current_resource) { Chef::Resource::AptPackage.new("emacs", run_context) }
-  let(:candidate_version) { "1.0" }
-  let(:provider) do
-    provider = Chef::Provider::Package::Apt.new(new_resource, run_context) { include Chef::Provider::Package::Deb }
-    provider.current_resource = current_resource
-    provider.candidate_version = candidate_version
-    provider
-  end
-
-  before do
-    allow(run_context).to receive(:logger).and_return(logger)
-  end
-
-  describe "when reconfiguring the package" do
-    before(:each) do
-      allow(provider).to receive(:reconfig_package).and_return(true)
-    end
-
-    context "when reconfigure the package" do
-      it "reconfigure the package and update the resource" do
-        allow(provider).to receive(:get_current_versions).and_return("1.0")
-        allow(new_resource).to receive(:response_file).and_return(true)
-        expect(provider).to receive(:get_preseed_file).and_return("/var/cache/preseed-test")
-        allow(provider).to receive(:preseed_package).and_return(true)
-        allow(provider).to receive(:reconfig_package).and_return(true)
-        expect(logger).to receive(:info).with("apt_package[emacs] reconfigured")
-        expect(provider).to receive(:reconfig_package)
-        provider.run_action(:reconfig)
-        expect(new_resource).to be_updated
-        expect(new_resource).to be_updated_by_last_action
-      end
-    end
-
-    context "when not reconfigure the package" do
-      it "does not reconfigure the package if the package is not installed" do
-        allow(provider).to receive(:get_current_versions).and_return(nil)
-        allow(provider.load_current_resource).to receive(:version).and_return(nil)
-        expect(logger).to receive(:debug).with("apt_package[emacs] is NOT installed - nothing to do")
-        expect(provider).not_to receive(:reconfig_package)
-        provider.run_action(:reconfig)
-        expect(new_resource).not_to be_updated_by_last_action
-      end
-
-      it "does not reconfigure the package if no response_file is given" do
-        allow(provider).to receive(:get_current_versions).and_return("1.0")
-        allow(new_resource).to receive(:response_file).and_return(nil)
-        expect(logger).to receive(:debug).with("apt_package[emacs] no response_file provided - nothing to do")
-        expect(provider).not_to receive(:reconfig_package)
-        provider.run_action(:reconfig)
-        expect(new_resource).not_to be_updated_by_last_action
-      end
-
-      it "does not reconfigure the package if the response_file has not changed" do
-        allow(provider).to receive(:get_current_versions).and_return("1.0")
-        allow(new_resource).to receive(:response_file).and_return(true)
-        expect(provider).to receive(:get_preseed_file).and_return(false)
-        allow(provider).to receive(:preseed_package).and_return(false)
-        expect(logger).to receive(:debug).with("apt_package[emacs] preseeding has not changed - nothing to do")
-        expect(provider).not_to receive(:reconfig_package)
-        provider.run_action(:reconfig)
-        expect(new_resource).not_to be_updated_by_last_action
-      end
-    end
-  end
-
-  describe "Subclass with use_multipackage_api" do
-    class MyDebianPackageResource < Chef::Resource::Package
-    end
-
-    class MyDebianPackageProvider < Chef::Provider::Package
-      include Chef::Provider::Package::Deb
-      use_multipackage_api
-    end
-    let(:node) { Chef::Node.new }
-    let(:events) { Chef::EventDispatch::Dispatcher.new }
-    let(:run_context) { Chef::RunContext.new(node, {}, events) }
-    let(:new_resource) { MyDebianPackageResource.new("installs the packages") }
-    let(:current_resource) { MyDebianPackageResource.new("installs the packages") }
-    let(:provider) do
-      provider = MyDebianPackageProvider.new(new_resource, run_context)
-      provider.current_resource = current_resource
-      provider
-    end
-
-    it "has use_multipackage_api? methods on the class and instance" do
-      expect(MyDebianPackageProvider.use_multipackage_api?).to be true
-      expect(provider.use_multipackage_api?).to be true
-    end
-
-    it "when user passes string to package_name, passes arrays to reconfig_package" do
-      new_resource.package_name "vim"
-      current_resource.package_name "vim"
-      current_resource.version [ "1.0" ]
-      allow(new_resource).to receive(:response_file).and_return(true)
-      allow(new_resource).to receive(:resource_name).and_return(:apt_package)
-      expect(provider).to receive(:get_preseed_file).and_return("/var/cache/preseed-test")
-      allow(provider).to receive(:preseed_package).and_return(true)
-      allow(provider).to receive(:reconfig_package).and_return(true)
-      expect(provider).to receive(:reconfig_package).with([ "vim" ]).and_return(true)
-      provider.run_action(:reconfig)
-      expect(new_resource).to be_updated_by_last_action
-    end
-  end
-end

data/spec/unit/provider/package/dnf/python_helper_spec.rb

@@ -1,36 +0,0 @@
-#
-# 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"
-
-# NOTE: most of the tests of this functionality are baked into the func tests for the dnf package provider
-
-# run this test only for following platforms.
-exclude_test = !(%w{rhel fedora amazon}.include?(ohai[:platform_family]) && File.exist?("/usr/bin/dnf"))
-describe Chef::Provider::Package::Dnf::PythonHelper, :requires_root, external: exclude_test do
-  let(:helper) { Chef::Provider::Package::Dnf::PythonHelper.instance }
-  before(:each) { Singleton.__init__(Chef::Provider::Package::Dnf::PythonHelper) }
-
-  it "propagates stacktraces on stderr from the forked subprocess", :rhel do
-    allow(helper).to receive(:dnf_command).and_return("ruby -e 'raise \"your hands in the air\"'")
-    expect { helper.package_query(:whatprovides, "tcpdump") }.to raise_error(/your hands in the air/)
-  end
-
-  it "compares EVRAs with dots in the release correctly" do
-    expect(helper.compare_versions("0:1.8.29-6.el8.x86_64", "0:1.8.29-6.el8_3.1.x86_64")).to eql(-1)
-  end
-end

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

@@ -1,314 +0,0 @@
-# Author:: Bryan McLellan (btm@loftninjas.org)
-# Copyright:: Copyright 2009-2016, Bryan McLellan
-# 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::Dpkg do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:package) { "wget" }
-  let(:source) { "/tmp/wget_1.11.4-1ubuntu1_amd64.deb" }
-  let(:new_resource) do
-    new_resource = Chef::Resource::DpkgPackage.new(package)
-    new_resource.source source
-    new_resource
-  end
-  let(:provider) { Chef::Provider::Package::Dpkg.new(new_resource, run_context) }
-
-  let(:dpkg_deb_version) { "1.11.4" }
-  let(:dpkg_deb_status) { status = double(stdout: "#{package}\t#{dpkg_deb_version}", exitstatus: 0) }
-  let(:dpkg_s_version) { "1.11.4-1ubuntu1" }
-  let(:dpkg_s_status) do
-    stdout = <<~DPKG_S
-      Package: #{package}
-      Status: install ok installed
-      Priority: important
-      Section: web
-      Installed-Size: 1944
-      Maintainer: Ubuntu Core developers <ubuntu-devel-discuss@lists.ubuntu.com>
-      Architecture: amd64
-      Version: #{dpkg_s_version}
-      Config-Version: #{dpkg_s_version}
-      Depends: libc6 (>= 2.8~20080505), libssl0.9.8 (>= 0.9.8f-5)
-      Conflicts: wget-ssl
-    DPKG_S
-    status = double(stdout: stdout, exitstatus: 1)
-  end
-
-  before(:each) do
-    allow(provider).to receive(:shell_out_compacted!).with("dpkg-deb", "-W", source, timeout: 900).and_return(dpkg_deb_status)
-    allow(provider).to receive(:shell_out_compacted!).with("dpkg", "-s", package, timeout: 900, returns: [0, 1]).and_return(double(stdout: "", exitstatus: 1))
-  end
-
-  describe "#define_resource_requirements" do
-    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
-
-    # FIXME?  we're saying we ignore source, but should supplying source on :remove or :purge be an actual error?
-    it "should not raise an exception if a source is supplied but not found when :remove" do
-      allow(::File).to receive(:exist?).with(source).and_return(false)
-      expect(provider).to receive(:action_remove)
-      expect { provider.run_action(:remove) }.not_to raise_error
-    end
-
-    it "should not raise an exception if a source is supplied but not found when :purge" do
-      allow(::File).to receive(:exist?).with(source).and_return(false)
-      expect(provider).to receive(:action_purge)
-      expect { provider.run_action(:purge) }.not_to raise_error
-    end
-
-    context "when source is nil" do
-      let(:source) { nil }
-
-      it "should raise an exception if a source is nil when :install" do
-        expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
-      end
-
-      it "should raise an exception if a source is nil when :upgrade" do
-        expect { provider.run_action(:upgrade) }.to raise_error(Chef::Exceptions::Package)
-      end
-
-      it "should not raise an exception if a source is nil when :remove" do
-        expect(provider).to receive(:action_remove)
-        expect { provider.run_action(:remove) }.not_to raise_error
-      end
-
-      it "should not raise an exception if a source is nil when :purge" do
-        expect(provider).to receive(:action_purge)
-        expect { provider.run_action(:purge) }.not_to raise_error
-      end
-    end
-  end
-
-  describe "when loading the current resource state" do
-    before(:each) do
-      allow(::File).to receive(:exist?).with(source).and_return(true)
-    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(["wget"])
-    end
-
-    describe "gets the source package version from dpkg-deb" do
-      def check_version(version)
-        status = double(stdout: "wget\t#{version}", exitstatus: 0)
-        expect(provider).to receive(:shell_out_compacted!).with("dpkg-deb", "-W", source, timeout: 900).and_return(status)
-        provider.load_current_resource
-        expect(provider.current_resource.package_name).to eq(["wget"])
-        expect(provider.candidate_version).to eq([version])
-      end
-
-      it "if short version provided" do
-        check_version("1.11.4")
-      end
-
-      it "if extended version provided" do
-        check_version("1.11.4-1ubuntu1")
-      end
-
-      it "if distro-specific version provided" do
-        check_version("1.11.4-1ubuntu1~lucid")
-      end
-
-      it "returns the version if an epoch is used" do
-        check_version("1:1.8.3-2")
-      end
-    end
-
-    describe "when the package name has `-', `+' or `.' characters" do
-      let(:package) { "f.o.o-pkg++2" }
-
-      it "gets the source package name from dpkg-deb correctly" do
-        provider.load_current_resource
-        expect(provider.current_resource.package_name).to eq(["f.o.o-pkg++2"])
-      end
-    end
-
-    describe "when the package version has `~', `-', `+' or `.' characters" do
-      let(:package) { "b.a.r-pkg++1" }
-      let(:dpkg_deb_version) { "1.2.3+3141592-1ubuntu1~lucid" }
-      let(:dpkg_s_version) { "1.2.3+3141592-1ubuntu1~lucid" }
-
-      it "gets the source package version from dpkg-deb correctly when the package version has `~', `-', `+' or `.' characters" do
-        provider.load_current_resource
-        expect(provider.candidate_version).to eq(["1.2.3+3141592-1ubuntu1~lucid"])
-      end
-    end
-
-    describe "when the source is not set" do
-      let(:source) { nil }
-
-      it "should raise an exception if the source is not set but we are installing" do
-        expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
-      end
-    end
-
-    it "should return the current version installed if found by dpkg" do
-      allow(provider).to receive(:shell_out_compacted!).with("dpkg", "-s", package, timeout: 900, returns: [0, 1]).and_return(dpkg_s_status)
-      provider.load_current_resource
-      expect(provider.current_resource.version).to eq(["1.11.4-1ubuntu1"])
-    end
-
-    it "on new debian/ubuntu we get an exit(1) and no stdout from dpkg -s for uninstalled" do
-      dpkg_s_status = double(
-        exitstatus: 1, stdout: "", stderr: <<~EOF
-          dpkg-query: package '#{package}' is not installed and no information is available
-          Use dpkg --info (= dpkg-deb --info) to examine archive files,
-          and dpkg --contents (= dpkg-deb --contents) to list their contents.
-        EOF
-      )
-      expect(provider).to receive(:shell_out_compacted!).with("dpkg", "-s", package, returns: [0, 1], timeout: 900).and_return(dpkg_s_status)
-      provider.load_current_resource
-      expect(provider.current_resource.version).to eq([nil])
-    end
-
-    it "on old debian/ubuntu we get an exit(0) and we get info on stdout from dpkg -s for uninstalled" do
-      dpkg_s_status = double(
-        exitstatus: 0, stderr: "", stdout: <<~EOF
-          Package: #{package}
-          Status: unknown ok not-installed
-          Priority: extra
-          Section: ruby
-        EOF
-      )
-      expect(provider).to receive(:shell_out_compacted!).with("dpkg", "-s", package, returns: [0, 1], timeout: 900).and_return(dpkg_s_status)
-      provider.load_current_resource
-      expect(provider.current_resource.version).to eq([nil])
-    end
-
-    it "and we should raise if we get any other exit codes from dpkg -s" do
-      dpkg_s_status = double(
-        exitstatus: 3, stderr: "i am very, very angry with you.  i'm very, very cross.  go to your room.", stdout: ""
-      )
-      expect(provider).to receive(:shell_out_compacted!).with("dpkg", "-s", package, returns: [0, 1], timeout: 900).and_raise(Mixlib::ShellOut::ShellCommandFailed)
-      expect { provider.load_current_resource }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
-    end
-
-    it "should raise an exception if dpkg-deb -W fails to run" do
-      status = double(stdout: "", exitstatus: -1)
-      expect(provider).to receive(:shell_out_compacted!).with("dpkg-deb", "-W", "/tmp/wget_1.11.4-1ubuntu1_amd64.deb", timeout: 900).and_raise(Mixlib::ShellOut::ShellCommandFailed)
-      expect { provider.load_current_resource }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
-    end
-  end
-
-  describe Chef::Provider::Package::Dpkg, "install and upgrade" do
-    before(:each) do
-      allow(::File).to receive(:exist?).with(source).and_return(true)
-    end
-
-    it "should run dpkg -i with the package source" do
-      expect(provider).to receive(:run_noninteractive).with(
-        "dpkg", "-i", "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
-      )
-      provider.load_current_resource
-      provider.run_action(:install)
-    end
-
-    it "should run dpkg -i if the package is a path and the source is nil" do
-      new_resource.name "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
-      expect(provider).to receive(:run_noninteractive).with(
-        "dpkg", "-i", "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
-      )
-      provider.run_action(:install)
-    end
-
-    it "should run dpkg -i if the package is a path and the source is nil for an upgrade" do
-      new_resource.name "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
-      expect(provider).to receive(:run_noninteractive).with(
-        "dpkg", "-i", "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
-      )
-      provider.run_action(:upgrade)
-    end
-
-    it "should run dpkg -i with the package source and options if specified" do
-      new_resource.options "--force-yes"
-      expect(provider).to receive(:run_noninteractive).with(
-        "dpkg", "-i", "--force-yes", "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
-      )
-      provider.run_action(:install)
-    end
-
-    it "should upgrade by running install_package" do
-      expect(provider).to receive(:install_package).with(["wget"], ["1.11.4-1ubuntu1"])
-      provider.upgrade_package(["wget"], ["1.11.4-1ubuntu1"])
-    end
-  end
-
-  describe Chef::Provider::Package::Dpkg, "remove and purge" do
-    it "should run dpkg -r to remove the package" do
-      expect(provider).to receive(:run_noninteractive).with(
-        "dpkg", "-r", "wget"
-      )
-      provider.remove_package(["wget"], ["1.11.4-1ubuntu1"])
-    end
-
-    it "should run dpkg -r to remove the package with options if specified" do
-      expect(provider).to receive(:run_noninteractive).with(
-        "dpkg", "-r", "--force-yes", "wget"
-      )
-      allow(new_resource).to receive(:options).and_return("--force-yes")
-
-      provider.remove_package(["wget"], ["1.11.4-1ubuntu1"])
-    end
-
-    it "should run dpkg -P to purge the package" do
-      expect(provider).to receive(:run_noninteractive).with(
-        "dpkg", "-P", "wget"
-      )
-      provider.purge_package(["wget"], ["1.11.4-1ubuntu1"])
-    end
-
-    it "should run dpkg -P to purge the package with options if specified" do
-      expect(provider).to receive(:run_noninteractive).with(
-        "dpkg", "-P", "--force-yes", "wget"
-      )
-      allow(new_resource).to receive(:options).and_return("--force-yes")
-
-      provider.purge_package(["wget"], ["1.11.4-1ubuntu1"])
-    end
-  end
-
-  describe "when given a response file" do
-    it_behaves_like "given a response file" do
-      before do
-        @provider = Chef::Provider::Package::Dpkg.new(new_resource, run_context)
-      end
-      let(:new_resource) do
-        new_resource = Chef::Resource::DpkgPackage.new("wget", run_context)
-        new_resource.response_file("wget.response")
-        new_resource.cookbook_name = "wget"
-        new_resource
-      end
-      let(:path) { "preseed/wget" }
-      let(:tmp_path) { "/tmp/preseed/wget" }
-      let(:package_name) { "wget" }
-      let(:package_version) { "1.11.4" }
-      let(:response) { "wget.response" }
-      let(:tmp_preseed_path) { "/tmp/preseed/wget/wget-1.11.4.seed" }
-      let(:preseed_path) { "/preseed--wget--wget-1.11.4.seed" }
-    end
-  end
-end

data/spec/unit/provider/package/freebsd/pkgng_spec.rb

@@ -1,147 +0,0 @@
-#
-# Authors:: Richard Manyanza (liseki@nyikacraftsmen.com)
-# Copyright:: Copyright 2014-2016, Richard Manyanza
-# 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::Freebsd::Port 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("zsh")
-    @provider = Chef::Provider::Package::Freebsd::Pkgng.new(@new_resource, @run_context)
-  end
-
-  describe "initialization" do
-    it "should create a current resource with the name of the new resource" do
-      expect(@provider.current_resource.is_a?(Chef::Resource::Package)).to be_truthy
-      expect(@provider.current_resource.name).to eq("zsh")
-    end
-  end
-
-  describe "loading current resource" do
-    before(:each) do
-      allow(@provider).to receive(:current_installed_version)
-      allow(@provider).to receive(:candidate_version)
-    end
-
-    it "should set the package name" do
-      @provider.load_current_resource
-      expect(@provider.current_resource.package_name).to eq("zsh")
-    end
-
-    it "should set the current version" do
-      expect(@provider).to receive(:current_installed_version).and_return("5.0.2")
-      @provider.load_current_resource
-      expect(@provider.current_resource.version).to eq("5.0.2")
-    end
-
-    it "should set the candidate version" do
-      expect(@provider).to receive(:candidate_version).and_return("5.0.5")
-      @provider.load_current_resource
-      expect(@provider.instance_variable_get(:"@candidate_version")).to eq("5.0.5")
-    end
-  end
-
-  describe "determining current installed version" do
-    before(:each) do
-      @pkg_info = OpenStruct.new(stdout: "zsh-3.1.7\nVersion             : 3.1.7\n")
-    end
-
-    it "should query pkg database" do
-      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "zsh", env: nil, returns: [0, 1, 70], timeout: 900).and_return(@pkg_info)
-      expect(@provider.current_installed_version).to eq("3.1.7")
-    end
-  end
-
-  describe "determining candidate version" do
-    it "should query repository" do
-      pkg_query = OpenStruct.new(stdout: "5.0.5\n", exitstatus: 0)
-      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "rquery", "%v", "zsh", env: nil, timeout: 900).and_return(pkg_query)
-      expect(@provider.candidate_version).to eq("5.0.5")
-    end
-
-    it "should query specified repository when given option" do
-      @provider.new_resource.options("-r LocalMirror") # This requires LocalMirror repo configuration.
-      pkg_query = OpenStruct.new(stdout: "5.0.3\n", exitstatus: 0)
-      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "rquery", "-r", "LocalMirror", "%v", "zsh", env: nil, timeout: 900).and_return(pkg_query)
-      expect(@provider.candidate_version).to eq("5.0.3")
-    end
-
-    it "should return candidate version from file when given a file" do
-      @provider.new_resource.source("/nas/pkg/repo/zsh-5.0.1.txz")
-      expect(@provider.candidate_version).to eq("5.0.1")
-    end
-  end
-
-  describe "installing a binary package" do
-    before(:each) do
-      @install_result = OpenStruct.new(status: true)
-    end
-
-    it "should handle package source from file" do
-      @provider.new_resource.source("/nas/pkg/repo/zsh-5.0.1.txz")
-      expect(@provider).to receive(:shell_out_compacted!)
-        .with("pkg", "add", "/nas/pkg/repo/zsh-5.0.1.txz", env: { "LC_ALL" => nil }, timeout: 900)
-        .and_return(@install_result)
-      @provider.install_package("zsh", "5.0.1")
-    end
-
-    it "should handle package source over ftp or http" do
-      @provider.new_resource.source("http://repo.example.com/zsh-5.0.1.txz")
-      expect(@provider).to receive(:shell_out_compacted!)
-        .with("pkg", "add", "http://repo.example.com/zsh-5.0.1.txz", env: { "LC_ALL" => nil }, timeout: 900)
-        .and_return(@install_result)
-      @provider.install_package("zsh", "5.0.1")
-    end
-
-    it "should handle a package name" do
-      expect(@provider).to receive(:shell_out_compacted!)
-        .with("pkg", "install", "-y", "zsh", env: { "LC_ALL" => nil }, timeout: 900).and_return(@install_result)
-      @provider.install_package("zsh", "5.0.1")
-    end
-
-    it "should handle a package name with a specified repo" do
-      @provider.new_resource.options("-r LocalMirror") # This requires LocalMirror repo configuration.
-      expect(@provider).to receive(:shell_out_compacted!)
-        .with("pkg", "install", "-y", "-r", "LocalMirror", "zsh", env: { "LC_ALL" => nil }, timeout: 900).and_return(@install_result)
-      @provider.install_package("zsh", "5.0.1")
-    end
-  end
-
-  describe "removing a binary package" do
-    before(:each) do
-      @install_result = OpenStruct.new(status: true)
-    end
-
-    it "should call pkg delete" do
-      expect(@provider).to receive(:shell_out_compacted!)
-        .with("pkg", "delete", "-y", "zsh-5.0.1", env: nil, timeout: 900).and_return(@install_result)
-      @provider.remove_package("zsh", "5.0.1")
-    end
-
-    it "should not include repo option in pkg delete" do
-      @provider.new_resource.options("-r LocalMirror") # This requires LocalMirror repo configuration.
-      expect(@provider).to receive(:shell_out_compacted!)
-        .with("pkg", "delete", "-y", "zsh-5.0.1", env: nil, timeout: 900).and_return(@install_result)
-      @provider.remove_package("zsh", "5.0.1")
-    end
-  end
-end