chef 18.8.11 → 18.8.54

data/spec/support/shared/unit/provider/package/package_shared.rb

@@ -1,95 +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.
-#
-
-shared_examples_for "given a response file" do
-  let(:cookbook_repo) { File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks")) }
-  let(:cookbook_loader) do
-    Chef::Cookbook::FileVendor.fetch_from_disk(cookbook_repo)
-    Chef::CookbookLoader.new(cookbook_repo)
-  end
-  let(:cookbook_collection) do
-    cookbook_loader.load_cookbooks
-    Chef::CookbookCollection.new(cookbook_loader)
-  end
-  let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
-
-  describe "creating the cookbook file resource to fetch the response file" do
-    before do
-      expect(Chef::FileCache).to receive(:create_cache_path).with(path).and_return(tmp_path)
-    end
-
-    it "sets the preseed resource's runcontext to its own run context" do
-      cookbook_collection
-      allow(Chef::FileCache).to receive(:create_cache_path).and_return(tmp_path)
-      expect(@provider.preseed_resource(package_name, package_version).run_context).not_to be_nil
-      expect(@provider.preseed_resource(package_name, package_version).run_context).to equal(@provider.run_context)
-    end
-
-    it "should set the cookbook name of the remote file to the new resources cookbook name" do
-      expect(@provider.preseed_resource(package_name, package_version).cookbook_name).to eq(package_name)
-    end
-
-    it "should set remote files source to the new resources response file" do
-      expect(@provider.preseed_resource(package_name, package_version).source).to eq(response)
-    end
-
-    it "should never back up the cached response file" do
-      expect(@provider.preseed_resource(package_name, package_version).backup).to be_falsey
-    end
-
-    it "sets the install path of the resource to $file_cache/$cookbook/$pkg_name-$pkg_version.seed" do
-      expect(@provider.preseed_resource(package_name, package_version).path).to eq(tmp_preseed_path)
-    end
-  end
-
-  describe "when installing the preseed file to the cache location" do
-    let(:response_file_destination) { Dir.tmpdir + preseed_path }
-    let(:response_file_resource) do
-      response_file_resource = Chef::Resource::CookbookFile.new(response_file_destination, run_context)
-      response_file_resource.cookbook_name = package_name
-      response_file_resource.backup(false)
-      response_file_resource.source(response)
-      response_file_resource
-    end
-
-    before do
-      expect(@provider).to receive(:preseed_resource).with(package_name, package_version).and_return(response_file_resource)
-    end
-
-    after do
-      FileUtils.rm(response_file_destination) if ::File.exist?(response_file_destination)
-    end
-
-    it "creates the preseed file in the cache" do
-      expect(response_file_resource).to receive(:run_action).with(:create)
-      @provider.get_preseed_file(package_name, package_version)
-    end
-
-    it "returns the path to the response file if the response file was updated" do
-      expect(@provider.get_preseed_file(package_name, package_version)).to eq(response_file_destination)
-    end
-
-    it "should return false if the response file has not been updated" do
-      response_file_resource.updated_by_last_action(false)
-      expect(response_file_resource).not_to be_updated_by_last_action
-      # don't let the response_file_resource set updated to true
-      expect(response_file_resource).to receive(:run_action).with(:create)
-      expect(@provider.get_preseed_file(package_name, package_version)).to be(false)
-    end
-  end
-end

data/spec/support/shared/unit/provider/useradd_based_user_provider.rb

@@ -1,410 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# 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.
-#
-
-# XXX: this used to be shared by solaris and linux classes, but at some
-# point became linux-specific.  it is now a misnomer to call these 'shared'
-# examples and they should either realy get turned into shared examples or
-# should be copypasta'd back directly into the linux tests.
-
-shared_examples_for "a useradd-based user provider" do |supported_useradd_options|
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-
-    @new_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
-    @new_resource.comment "Adam Jacob"
-    @new_resource.uid 1000
-    @new_resource.gid 1000
-    @new_resource.home "/home/adam"
-    @new_resource.shell "/usr/bin/zsh"
-    @new_resource.password "abracadabra"
-    @new_resource.system false
-    @new_resource.manage_home false
-    @new_resource.force false
-    @new_resource.non_unique false
-    @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
-    @current_resource.comment "Adam Jacob"
-    @current_resource.uid 1000
-    @current_resource.gid 1000
-    @current_resource.home "/home/adam"
-    @current_resource.shell "/usr/bin/zsh"
-    @current_resource.password "abracadabra"
-    @current_resource.system false
-    @current_resource.manage_home false
-    @current_resource.force false
-    @current_resource.non_unique false
-  end
-
-  describe "when setting option" do
-
-    supported_useradd_options.each do |attribute, option|
-      it "should check for differences in #{attribute} between the new and current resources" do
-        expect(@current_resource).to receive(attribute)
-        expect(@new_resource).to receive(attribute)
-        provider.universal_options
-      end
-
-      it "should set the option for #{attribute} if the new resources #{attribute} is not nil" do
-        allow(@new_resource).to receive(attribute).and_return("hola")
-        expect(provider.universal_options).to eql([option, "hola"])
-      end
-
-      it "should set the option for #{attribute} if the new resources #{attribute} is not nil, without homedir management" do
-        allow(@new_resource).to receive(:supports).and_return({ manage_home: false,
-                                                                non_unique: false })
-        allow(@new_resource).to receive(attribute).and_return("hola")
-        expect(provider.universal_options).to eql([option, "hola"])
-      end
-
-      it "should set the option for #{attribute} if the new resources #{attribute} is not nil, without homedir management (using real attributes)" do
-        @new_resource.manage_home(false)
-        @new_resource.non_unique(false)
-        @new_resource.non_unique(false)
-        allow(@new_resource).to receive(attribute).and_return("hola")
-        expect(provider.universal_options).to eql([option, "hola"])
-      end
-    end
-
-    it "should combine all the possible options" do
-      combined_opts = []
-      supported_useradd_options.sort_by { |a| a[0] }.each do |attribute, option|
-        allow(@new_resource).to receive(attribute).and_return("hola")
-        combined_opts << option << "hola"
-      end
-      expect(provider.universal_options).to eql(combined_opts)
-    end
-
-    describe "when we want to create a system user" do
-      before do
-        @new_resource.manage_home(true)
-        @new_resource.non_unique(false)
-      end
-
-      it "should set useradd -r" do
-        @new_resource.system(true)
-        expect(provider.useradd_options).to eq([ "-r", "-m" ])
-      end
-    end
-
-    describe "when the resource has a different home directory and supports home directory management" do
-      before do
-        @new_resource.home "/banana"
-        @new_resource.manage_home true
-      end
-
-      it "should set -m -d /homedir" do
-        expect(provider.universal_options).to eq(%w{-d /banana})
-        expect(provider.usermod_options).to eq(%w{-m})
-      end
-    end
-
-    describe "when the resource has a different home directory and supports home directory management (using real attributes)" do
-      before do
-        @new_resource.home("/banana")
-        @new_resource.manage_home true
-        @new_resource.non_unique false
-      end
-
-      it "should set -m -d /homedir" do
-        expect(provider.universal_options).to eq(%w{-d /banana})
-        expect(provider.usermod_options).to eq(%w{-m})
-      end
-    end
-
-    it "when non_unique is false should not set -m" do
-      @new_resource.non_unique false
-      expect(provider.universal_options).to eql([ ])
-    end
-
-    it "when non_unique is true should set -o" do
-      @new_resource.non_unique true
-      expect(provider.universal_options).to eql([ "-o" ])
-    end
-  end
-
-  describe "when creating a user" do
-    before(:each) do
-      @current_resource = Chef::Resource::User::LinuxUser.new(@new_resource.name, @run_context)
-      @current_resource.username(@new_resource.username)
-      provider.current_resource = @current_resource
-      provider.new_resource.manage_home true
-      provider.new_resource.home "/Users/mud"
-      provider.new_resource.gid "23"
-    end
-
-    it "runs useradd with the computed command options" do
-      command = ["useradd",
-                  "-c", "Adam Jacob",
-                  "-g", "23" ]
-      command.concat(["-p", "abracadabra"]) if supported_useradd_options.key?("password")
-      command.concat([ "-s", "/usr/bin/zsh",
-                       "-u", "1000",
-                       "-d", "/Users/mud",
-                       "-m",
-                       "adam"])
-      expect(provider).to receive(:shell_out_compacted!).with(*command).and_return(true)
-      provider.create_user
-    end
-
-    describe "and home is not specified for new system user resource" do
-
-      before do
-        provider.new_resource.system true
-        # there is no public API to set attribute's value to nil
-        provider.new_resource.instance_variable_set(:@home, nil)
-      end
-
-      it "should not include -m or -d in the command options" do
-        command = ["useradd",
-                    "-c", "Adam Jacob",
-                    "-g", "23"]
-        command.concat(["-p", "abracadabra"]) if supported_useradd_options.key?("password")
-        command.concat([ "-s", "/usr/bin/zsh",
-                         "-u", "1000",
-                         "-r", "-m",
-                         "adam"])
-        expect(provider).to receive(:shell_out_compacted!).with(*command).and_return(true)
-        provider.create_user
-      end
-
-    end
-
-  end
-
-  describe "when managing a user" do
-    let(:manage_u_status) do
-      double("Mixlib::ShellOut command", exitstatus: 0, stdout: @stdout, stderr: @stderr, error!: nil)
-    end
-
-    before(:each) do
-      provider.new_resource.manage_home true
-      provider.new_resource.home "/Users/mud"
-      provider.new_resource.gid "23"
-      @stderr = ""
-    end
-
-    # CHEF-3423, -m must come before the username
-    # CHEF-4305, -d must come before -m to support CentOS/RHEL 5
-    it "runs usermod with the computed command options" do
-      command = ["usermod",
-                  "-g", "23",
-                  "-d", "/Users/mud",
-                  "-m",
-                  "adam"]
-      command.concat([ { returns: [0, 12] } ])
-      expect(provider).to receive(:shell_out_compacted).with(*command).and_return(manage_u_status)
-      provider.manage_user
-    end
-
-    it "does not set the -r option to usermod" do
-      @new_resource.system(true)
-      command = ["usermod",
-                  "-g", "23",
-                  "-d", "/Users/mud",
-                  "-m",
-                  "adam"]
-      command.concat([ { returns: [0, 12] } ])
-      expect(provider).to receive(:shell_out_compacted).with(*command).and_return(manage_u_status)
-      provider.manage_user
-    end
-
-    it "CHEF-3429: does not set -m if we aren't changing the home directory" do
-      expect(provider).to receive(:updating_home?).at_least(:once).and_return(false)
-      command = ["usermod",
-                  "-g", "23",
-                  "adam"]
-      command.concat([ { returns: [0, 12] } ])
-      expect(provider).to receive(:shell_out_compacted).with(*command).and_return(manage_u_status)
-      provider.manage_user
-    end
-  end
-
-  describe "when removing a user" do
-
-    it "should run userdel with the new resources user name" do
-      expect(provider).to receive(:shell_out_compacted!).with("userdel", @new_resource.username).and_return(true)
-      provider.remove_user
-    end
-
-    it "should run userdel with the new resources user name and -r if manage_home is true" do
-      @new_resource.manage_home true
-      expect(provider).to receive(:shell_out_compacted!).with("userdel", "-r", @new_resource.username).and_return(true)
-      provider.remove_user
-    end
-
-    it "should run userdel with the new resources user name if non_unique is true" do
-      expect(provider).to receive(:shell_out_compacted!).with("userdel", @new_resource.username).and_return(true)
-      provider.remove_user
-    end
-
-    it "should run userdel with the new resources user name and -f if force is true" do
-      @new_resource.force(true)
-      expect(provider).to receive(:shell_out_compacted!).with("userdel", "-f", @new_resource.username).and_return(true)
-      provider.remove_user
-    end
-  end
-
-  describe "when checking the lock" do
-    # lazy initialize so we can modify stdout and stderr strings
-    let(:passwd_s_status) do
-      double("Mixlib::ShellOut command", exitstatus: 0, stdout: @stdout, stderr: @stderr, error!: nil)
-    end
-
-    before(:each) do
-      # @node = Chef::Node.new
-      # @new_resource = double("Chef::Resource::User",
-      #   :nil_object => true,
-      #   :username => "adam"
-      # )
-      # provider = Chef::Provider::User::Useradd.new(@node, @new_resource)
-      @stdout = "root P 09/02/2008 0 99999 7 -1"
-      @stderr = ""
-    end
-
-    it "should return false if status begins with P" do
-      expect(provider).to receive(:shell_out)
-        .with("passwd", "-S", @new_resource.username, { returns: [0, 1] })
-        .and_return(passwd_s_status)
-      expect(provider.check_lock).to eql(false)
-    end
-
-    it "should return false if status begins with N" do
-      @stdout = "root N"
-      expect(provider).to receive(:shell_out)
-        .with("passwd", "-S", @new_resource.username, { returns: [0, 1] })
-        .and_return(passwd_s_status)
-      expect(provider.check_lock).to eql(false)
-    end
-
-    it "should return true if status begins with L" do
-      @stdout = "root L"
-      expect(provider).to receive(:shell_out)
-        .with("passwd", "-S", @new_resource.username, { returns: [0, 1] })
-        .and_return(passwd_s_status)
-      expect(provider.check_lock).to eql(true)
-    end
-
-    it "should raise a ShellCommandFailed exception if passwd -S exits with something other than 0 or 1" do
-      expect(passwd_s_status).to receive(:error!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
-      expect(provider).to receive(:shell_out)
-        .with("passwd", "-S", @new_resource.username, { returns: [0, 1] })
-        .and_return(passwd_s_status)
-      expect { provider.check_lock }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
-    end
-
-    it "should raise an error if the output isn't parsable" do
-      expect(passwd_s_status).to receive(:stdout).and_return("")
-      expect(passwd_s_status).to receive(:stderr).and_return("")
-      expect(provider).to receive(:shell_out)
-        .with("passwd", "-S", @new_resource.username, { returns: [0, 1] })
-        .and_return(passwd_s_status)
-      expect { provider.check_lock }.to raise_error(Chef::Exceptions::User)
-    end
-
-    context "when in why run mode" do
-      before do
-        passwd_status = double("Mixlib::ShellOut command", exitstatus: 0, stdout: "", stderr: "passwd: user 'chef-test' does not exist\n")
-        expect(provider).to receive(:shell_out)
-          .with("passwd", "-S", @new_resource.username, { returns: [0, 1] })
-          .and_return(passwd_status)
-        # ubuntu returns 252 on user-does-not-exist so will raise if #error! is called or if
-        # shell_out! is used
-        allow(passwd_status).to receive(:error!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
-        Chef::Config[:why_run] = true
-      end
-
-      it "should return false if the user does not exist" do
-        expect(provider.check_lock).to eql(false)
-      end
-
-      it "should not raise an error if the user does not exist" do
-        expect { provider.check_lock }.not_to raise_error
-      end
-    end
-  end
-
-  describe "when locking the user" do
-    it "should run usermod -L with the new resources username" do
-      expect(provider).to receive(:shell_out_compacted!).with("usermod", "-L", @new_resource.username)
-      provider.lock_user
-    end
-  end
-
-  describe "when unlocking the user" do
-    it "should run usermod -L with the new resources username" do
-      expect(provider).to receive(:shell_out_compacted!).with("usermod", "-U", @new_resource.username)
-      provider.unlock_user
-    end
-  end
-
-  describe "when checking if home needs updating" do
-    [
-     {
-       "action" => "should return false if home matches",
-       "current_resource_home" => [ "/home/laurent" ],
-       "new_resource_home" => [ "/home/laurent" ],
-       "expected_result" => false,
-     },
-     {
-       "action" => "should return true if home doesn't match",
-       "current_resource_home" => [ "/home/laurent" ],
-       "new_resource_home" => [ "/something/else" ],
-       "expected_result" => true,
-     },
-     {
-       "action" => "should return false if home only differs by trailing slash",
-       "current_resource_home" => [ "/home/laurent" ],
-       "new_resource_home" => [ "/home/laurent/", "/home/laurent" ],
-       "expected_result" => false,
-     },
-     {
-       "action" => "should return false if home is an equivalent path",
-       "current_resource_home" => [ "/home/laurent" ],
-       "new_resource_home" => [ "/home/./laurent", "/home/laurent" ],
-       "expected_result" => false,
-     },
-    ].each do |home_check|
-      it home_check["action"] do
-        provider.current_resource.home home_check["current_resource_home"].first
-        @current_home_mock = double("Pathname")
-        provider.new_resource.home home_check["new_resource_home"].first
-        @new_home_mock = double("Pathname")
-
-        expect(Pathname).to receive(:new).with(@current_resource.home).and_return(@current_home_mock)
-        expect(@current_home_mock).to receive(:cleanpath).and_return(home_check["current_resource_home"].last)
-        expect(Pathname).to receive(:new).with(@new_resource.home).and_return(@new_home_mock)
-        expect(@new_home_mock).to receive(:cleanpath).and_return(home_check["new_resource_home"].last)
-
-        expect(provider.send(:updating_home?)).to eq(home_check["expected_result"])
-      end
-    end
-    it "should return true if the current home does not exist but a home is specified by the new resource" do
-      @new_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
-      @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
-      provider = Chef::Provider::User::Linux.new(@new_resource, @run_context)
-      provider.current_resource = @current_resource
-      @current_resource.home nil
-      @new_resource.home "/home/kitten"
-
-      expect(provider.send(:updating_home?)).to eq(true)
-    end
-  end
-end

data/spec/support/shared/unit/resource/static_provider_resolution.rb

@@ -1,63 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@chef.io>)
-# 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.
-#
-
-#
-# This is for typical "static" provider resolution which maps resources onto
-# providers based only on the node data.  Its not really 'static' because it
-# all goes through the Chef::ProviderResolver, but the effective result is
-# a static mapping for the node (unlike the service resource which is
-# complicated).
-#
-def static_provider_resolution(opts = {})
-  action           = opts[:action]
-  provider_class   = opts[:provider]
-  resource_class   = opts[:resource]
-  name             = opts[:name]
-  os               = opts[:os]
-  platform_family  = opts[:platform_family]
-  platform_version = opts[:platform_version]
-
-  describe resource_class, "static provider initialization" do
-    let(:node) do
-      node = Chef::Node.new
-      node.automatic_attrs[:os] = os
-      node.automatic_attrs[:platform_family] = platform_family
-      node.automatic_attrs[:platform_version] = platform_version
-      node
-    end
-    let(:events) { Chef::EventDispatch::Dispatcher.new }
-    let(:run_context) { Chef::RunContext.new(node, {}, events) }
-    let(:resource) { resource_class.new("foo", run_context) }
-
-    it "should return a #{resource_class}" do
-      expect(resource).to be_a_kind_of(resource_class)
-    end
-
-    it "should set the resource_name to #{name}" do
-      expect(resource.resource_name).to eql(name)
-    end
-
-    it "should leave the provider nil" do
-      expect(resource.provider).to eql(nil)
-    end
-
-    it "should resolve to a #{provider_class}" do
-      expect(resource.provider_for_action(action)).to be_a(provider_class)
-    end
-  end
-end

data/spec/support/shared/unit/script_resource.rb

@@ -1,74 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Tyler Cloke (<tyler@chef.io>)
-# 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.
-#
-
-shared_examples_for "a script resource" do
-
-  it "should create a new Chef::Resource::Script" do
-    expect(script_resource).to be_a_kind_of(Chef::Resource)
-    expect(script_resource).to be_a_kind_of(Chef::Resource::Script)
-  end
-
-  it "should have a resource name of :script" do
-    expect(script_resource.resource_name).to eql(resource_name)
-  end
-
-  it "should set command to nil on the resource" do
-    expect(script_resource.command).to be nil
-  end
-
-  it "should accept a string for the code" do
-    script_resource.code "hey jude"
-    expect(script_resource.code).to eql("hey jude")
-  end
-
-  it "should accept a string for the flags" do
-    script_resource.flags "-f"
-    expect(script_resource.flags.strip).to eql("-f")
-  end
-
-  it "should raise an exception if users set command on the resource" do
-    expect { script_resource.command("foo") }.to raise_error(Chef::Exceptions::Script)
-  end
-
-  describe "when executing guards" do
-    it "inherits exactly the :cwd, :domain, :environment, :group, :password, :path, :user, :umask, and :login attributes from a parent resource class" do
-      inherited_difference = Chef::Resource::Script.guard_inherited_attributes -
-        %i{cwd domain environment group password path user umask login}
-
-      expect(inherited_difference).to eq([])
-    end
-
-    it "when guard_interpreter is set to the default value, the guard command string should be evaluated by command execution and not through a resource" do
-      expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:evaluate_block)
-      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).not_to receive(:evaluate)
-      expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:evaluate).and_return(true)
-      script_resource.only_if "echo hi"
-      expect(script_resource.should_skip?(:run)).to eq(nil)
-    end
-
-    it "when a valid guard_interpreter resource is specified, a block should be used to evaluate the guard" do
-      expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:evaluate_block)
-      expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:evaluate)
-      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate).and_return(true)
-      script_resource.guard_interpreter :script
-      script_resource.only_if "echo hi"
-      expect(script_resource.should_skip?(:run)).to eq(nil)
-    end
-  end
-end