chef 18.7.10 → 18.8.46

data/spec/unit/provider/apt_preference_spec.rb

@@ -1,91 +0,0 @@
-#
-# Author:: Thom May (<thom@chef.io>)
-# Author:: Tim Smith (<tim@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.
-#
-
-require "spec_helper"
-require "chef/resource/apt_preference"
-
-# FIXME: provider has been moved to a custom resource, should migrate the unit tests
-#
-describe "Chef::Provider::AptPreference" do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:collection) { double("resource collection") }
-  let(:new_resource) { Chef::Resource::AptPreference.new("libmysqlclient16.1*", run_context) }
-  let(:pref_dir) { Dir.mktmpdir("apt_pref_d") }
-  let(:provider) { new_resource.provider_for_action(:add) }
-
-  before do
-    node.automatic["platform_family"] = "debian"
-    Chef::Resource::AptPreference.send(:remove_const, :APT_PREFERENCE_DIR)
-    Chef::Resource::AptPreference.const_set(:APT_PREFERENCE_DIR, pref_dir)
-
-    new_resource.pin = "1.0.1"
-    new_resource.pin_priority 1001
-  end
-
-  it "responds to load_current_resource" do
-    expect(provider).to respond_to(:load_current_resource)
-  end
-
-  context "#action_add" do
-    context "without a preferences.d directory" do
-      before do
-        FileUtils.rmdir pref_dir
-      end
-
-      it "creates the preferences.d directory" do
-        provider.run_action(:add)
-        expect(new_resource).to be_updated_by_last_action
-        expect(File.exist?(pref_dir)).to be true
-        expect(File.directory?(pref_dir)).to be true
-      end
-    end
-
-    context "with a preferences.d directory" do
-      before do
-        FileUtils.mkdir pref_dir unless ::File.exist?(pref_dir)
-        FileUtils.touch("#{pref_dir}/libmysqlclient16.1*.pref")
-        FileUtils.touch("#{pref_dir}/libmysqlclient16.1*")
-      end
-
-      # FileUtils.touch throws "Invalid argument @ utime_failed" in appveyer
-      it "creates a sanitized .pref file and removes the legacy cookbook files", :unix_only do
-        provider.run_action(:add)
-        expect(new_resource).to be_updated_by_last_action
-        expect(File).not_to exist("#{pref_dir}/libmysqlclient16.1*.pref")
-        expect(File).not_to exist("#{pref_dir}/libmysqlclient16.1*")
-        expect(File.read(::File.join(pref_dir, "libmysqlclient16_1wildcard.pref"))).to match(/Package: libmysqlclient16.1*.*Pin: 1.0.1.*Pin-Priority: 1001/m)
-      end
-    end
-  end
-
-  context "#action_delete" do
-    before do
-      FileUtils.mkdir pref_dir unless ::File.exist?(pref_dir)
-      FileUtils.touch("#{pref_dir}/libmysqlclient16_1wildcard.pref")
-    end
-
-    it "deletes the name sanitized .pref file" do
-      provider.run_action(:remove)
-      expect(new_resource).to be_updated_by_last_action
-      expect(File).not_to exist("#{pref_dir}/libmysqlclient16_1wildcard.pref")
-    end
-  end
-end

data/spec/unit/provider/apt_repository_spec.rb

@@ -1,293 +0,0 @@
-#
-# Author:: Thom May (<thom@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.
-#
-
-require "spec_helper"
-
-describe "Chef::Provider::AptRepository" do
-  # Now we are using the option --with-colons that works across old os versions
-  # as well as the latest (16.10). This for both `apt-key` and `gpg` commands
-  #
-  # Output of the command:
-  # => apt-key adv --list-public-keys --with-fingerprint --with-colons
-  APT_KEY_FINGER = <<~EOF.freeze
-    tru:t:1:1488924856:0:3:1:5
-    pub:-:1024:17:40976EAF437D05B5:2004-09-12:::-:Ubuntu Archive Automatic Signing Key <ftpmaster@ubuntu.com>::scESC:
-    fpr:::::::::630239CC130E1A7FD81A27B140976EAF437D05B5:
-    sub:-:2048:16:251BEFF479164387:2004-09-12::::::e:
-    pub:-:1024:17:46181433FBB75451:2004-12-30:::-:Ubuntu CD Image Automatic Signing Key <cdimage@ubuntu.com>::scSC:
-    fpr:::::::::C5986B4F1257FFA86632CBA746181433FBB75451:
-    pub:-:4096:1:3B4FE6ACC0B21F32:2012-05-11:::-:Ubuntu Archive Automatic Signing Key (2012) <ftpmaster@ubuntu.com>::scSC:
-    fpr:::::::::790BC7277767219C42C86F933B4FE6ACC0B21F32:
-    pub:-:4096:1:D94AA3F0EFE21092:2012-05-11:::-:Ubuntu CD Image Automatic Signing Key (2012) <cdimage@ubuntu.com>::scSC:
-    fpr:::::::::843938DF228D22F7B3742BC0D94AA3F0EFE21092:
-  EOF
-
-  # Output of the command:
-  # => gpg --with-fingerprint --with-colons [FILE]
-  APG_GPG_FINGER = <<~EOF.freeze
-    pub:-:1024:17:327574EE02A818DD:2009-04-22:::-:Cloudera Apt Repository:
-    fpr:::::::::F36A89E33CC1BD0F71079007327574EE02A818DD:
-    sub:-:2048:16:84080586D1CA74A1:2009-04-22::::
-  EOF
-
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:collection) { double("resource collection") }
-  let(:new_resource) { Chef::Resource::AptRepository.new("multiverse", run_context) }
-  let(:provider) { new_resource.provider_for_action(:add) }
-
-  let(:apt_key_finger_cmd) do
-    %w{apt-key adv --list-public-keys --with-fingerprint --with-colons}
-  end
-
-  let(:apt_key_finger) do
-    double("shell_out", stdout: APT_KEY_FINGER, exitstatus: 0, error?: false)
-  end
-
-  let(:gpg_finger) do
-    double("shell_out", stdout: APG_GPG_FINGER, exitstatus: 0, error?: false)
-  end
-
-  let(:gpg_shell_out_success) do
-    double("shell_out", stdout: "pub  2048R/7BD9BF62 2011-08-19 nginx signing key <signing-key@nginx.com>",
-                        exitstatus: 0, error?: false)
-  end
-
-  let(:gpg_shell_out_failure) do
-    double("shell_out", stderr: "gpg: no valid OpenPGP data found.\n
-                                    gpg: processing message failed: eof",
-                        exitstatus: 1, error?: true)
-  end
-
-  let(:apt_fingerprints) do
-    %w{630239CC130E1A7FD81A27B140976EAF437D05B5
-C5986B4F1257FFA86632CBA746181433FBB75451
-790BC7277767219C42C86F933B4FE6ACC0B21F32
-843938DF228D22F7B3742BC0D94AA3F0EFE21092}
-  end
-
-  let(:apt_public_keys) do
-    %w{
-      pub:-:1024:17:40976EAF437D05B5:2004-09-12
-      pub:-:1024:17:46181433FBB75451:2004-12-30
-      pub:-:4096:1:3B4FE6ACC0B21F32:2012-05-11
-      pub:-:4096:1:D94AA3F0EFE21092:2012-05-11
-    }
-  end
-
-  it "responds to load_current_resource" do
-    expect(provider).to respond_to(:load_current_resource)
-  end
-
-  describe "#is_key_id?" do
-    it "detects a key" do
-      expect(provider.is_key_id?("A4FF2279")).to be_truthy
-    end
-    it "detects a key with a hex signifier" do
-      expect(provider.is_key_id?("0xA4FF2279")).to be_truthy
-    end
-    it "rejects a key with the wrong length" do
-      expect(provider.is_key_id?("4FF2279")).to be_falsey
-    end
-    it "rejects a key with non-hex characters" do
-      expect(provider.is_key_id?("A4KF2279")).to be_falsey
-    end
-  end
-
-  describe "#extract_fingerprints_from_cmd" do
-    it "runs the desired command" do
-      expect(provider).to receive(:shell_out).and_return(apt_key_finger)
-      provider.extract_fingerprints_from_cmd(*apt_key_finger_cmd)
-    end
-
-    it "returns a list of key fingerprints" do
-      expect(provider).to receive(:shell_out).and_return(apt_key_finger)
-      expect(provider.extract_fingerprints_from_cmd(*apt_key_finger_cmd)).to eql(apt_fingerprints)
-    end
-  end
-
-  describe "#extract_public_keys_from_cmd" do
-    it "runs the desired command" do
-      expect(provider).to receive(:shell_out).and_return(apt_key_finger)
-      provider.extract_public_keys_from_cmd(*apt_key_finger_cmd)
-    end
-
-    it "returns a list of key fingerprints" do
-      expect(provider).to receive(:shell_out).and_return(apt_key_finger)
-      expect(provider.extract_public_keys_from_cmd(*apt_key_finger_cmd)).to eql(apt_public_keys)
-    end
-  end
-
-  describe "#cookbook_name" do
-    it "returns 'test' when the cookbook property is set" do
-      new_resource.cookbook("test")
-      expect(provider.cookbook_name).to eq("test")
-    end
-  end
-
-  describe "#no_new_keys?" do
-    before do
-      allow(provider).to receive(:extract_public_keys_from_cmd).with(*apt_key_finger_cmd).and_return(apt_public_keys)
-    end
-
-    let(:file) { "/tmp/remote-gpg-keyfile" }
-
-    it "matches a set of keys" do
-      allow(provider).to receive(:extract_public_keys_from_cmd)
-        .with("gpg", "--with-fingerprint", "--with-colons", file)
-        .and_return([apt_public_keys.first])
-      expect(provider.no_new_keys?(file)).to be_truthy
-    end
-
-    it "notices missing keys" do
-      allow(provider).to receive(:extract_public_keys_from_cmd)
-        .with("gpg", "--with-fingerprint", "--with-colons", file)
-        .and_return(%w{pub:-:4096:1:871920D1991BC93C:1537196506})
-      expect(provider.no_new_keys?(file)).to be_falsey
-    end
-  end
-
-  describe "#key_type" do
-    it "returns :remote_file with an http URL" do
-      expect(provider.key_type("https://www.chef.io/key")).to eq(:remote_file)
-    end
-
-    it "returns :cookbook_file with a chef managed file" do
-      expect(provider).to receive(:has_cookbook_file?).and_return(true)
-      expect(provider.key_type("/foo/bar.key")).to eq(:cookbook_file)
-    end
-
-    it "throws exception if an unknown file specified" do
-      expect(provider).to receive(:has_cookbook_file?).and_return(false)
-      expect { provider.key_type("/foo/bar.key") }.to raise_error(Chef::Exceptions::FileNotFound)
-    end
-  end
-
-  describe "#keyserver_install_cmd" do
-    it "returns keyserver install command" do
-      expect(provider.keyserver_install_cmd("ABC", "gpg.mit.edu")).to eq("apt-key adv --no-tty --recv --keyserver hkp://gpg.mit.edu:80 ABC")
-    end
-
-    it "uses proxy if key_proxy property is set" do
-      new_resource.key_proxy("proxy.mycorp.dmz:3128")
-      expect(provider.keyserver_install_cmd("ABC", "gpg.mit.edu")).to eq("apt-key adv --no-tty --recv --keyserver-options http-proxy=proxy.mycorp.dmz:3128 --keyserver hkp://gpg.mit.edu:80 ABC")
-    end
-
-    it "properly handles keyservers passed with hkp:// URIs" do
-      expect(provider.keyserver_install_cmd("ABC", "hkp://gpg.mit.edu")).to eq("apt-key adv --no-tty --recv --keyserver hkp://gpg.mit.edu ABC")
-    end
-  end
-
-  describe "#is_ppa_url" do
-    it "returns true if the URL starts with ppa:" do
-      expect(provider.is_ppa_url?("ppa://example.com")).to be_truthy
-    end
-
-    it "returns false if the URL does not start with ppa:" do
-      expect(provider.is_ppa_url?("example.com")).to be_falsey
-    end
-  end
-
-  describe "#repo_components" do
-    it "returns 'main' if a PPA and components property not set" do
-      expect(provider).to receive(:is_ppa_url?).and_return(true)
-      expect(provider.repo_components).to eq("main")
-    end
-
-    it "returns components property if a PPA and components is set" do
-      new_resource.components(["foo"])
-      expect(provider).to receive(:is_ppa_url?).and_return(true)
-      expect(provider.repo_components).to eq(["foo"])
-    end
-
-    it "returns components property if not a PPA" do
-      new_resource.components(["foo"])
-      expect(provider).to receive(:is_ppa_url?).and_return(false)
-      expect(provider.repo_components).to eq(["foo"])
-    end
-  end
-
-  describe "#install_ppa_key" do
-    let(:url) { "https://launchpad.net/api/1.0/~chef/+archive/main" }
-    let(:key) { "C5986B4F1257FFA86632CBA746181433FBB75451" }
-
-    it "gets a key" do
-      simples = double("HTTP")
-      allow(simples).to receive(:get).and_return("\"#{key}\"")
-      expect(Chef::HTTP::Simple).to receive(:new).with(url).and_return(simples)
-      expect(provider).to receive(:install_key_from_keyserver).with(key, "keyserver.ubuntu.com")
-      provider.install_ppa_key("chef", "main")
-    end
-  end
-
-  describe "#make_ppa_url" do
-    it "creates a URL" do
-      expect(provider).to receive(:install_ppa_key).with("chef", "main").and_return(true)
-      expect(provider.make_ppa_url("ppa:chef/main")).to eql("http://ppa.launchpad.net/chef/main/ubuntu")
-    end
-  end
-
-  describe "#build_repo" do
-    it "creates a repository string" do
-      target = "deb      http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, nil, [])).to eql(target)
-    end
-
-    it "creates a repository string with spaces" do
-      target = "deb      http://test/uri%20with%20spaces unstable main\n"
-      expect(provider.build_repo("http://test/uri with spaces", "unstable", "main", false, nil, nil, [])).to eql(target)
-    end
-
-    it "creates a repository string with no distribution" do
-      target = "deb      http://test/uri main\n"
-      expect(provider.build_repo("http://test/uri", nil, "main", false, nil, nil, [])).to eql(target)
-    end
-
-    it "creates a repository string with source" do
-      target = "deb      http://test/uri unstable main\ndeb-src  http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, nil, [], true)).to eql(target)
-    end
-
-    it "creates a repository string with trusted" do
-      target = "deb      [trusted=yes] http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", true, nil, nil, [])).to eql(target)
-    end
-
-    it "creates a repository string with signed-by" do
-      target = "deb      [signed-by=/etc/apt/keyrings/test.gpg] http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, "/etc/apt/keyrings/test.gpg", [])).to eql(target)
-    end
-
-    it "creates a repository string with custom options" do
-      target = "deb      [by-hash=no] http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", false, nil, nil, ["by-hash=no"])).to eql(target)
-    end
-
-    it "creates a repository string with trusted, arch, and custom options" do
-      target = "deb      [arch=amd64 trusted=yes by-hash=no] http://test/uri unstable main\n"
-      expect(provider.build_repo("http://test/uri", "unstable", "main", true, "amd64", nil, ["by-hash=no"])).to eql(target)
-    end
-
-    it "handles a ppa repo" do
-      target = "deb      http://ppa.launchpad.net/chef/main/ubuntu unstable main\n"
-      expect(provider).to receive(:make_ppa_url).with("ppa:chef/main").and_return("http://ppa.launchpad.net/chef/main/ubuntu")
-      expect(provider.build_repo("ppa:chef/main", "unstable", "main", false, nil, nil, [])).to eql(target)
-    end
-  end
-end

data/spec/unit/provider/apt_update_spec.rb

@@ -1,119 +0,0 @@
-#
-# Author:: Thom May (<thom@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.
-#
-
-require "spec_helper"
-
-describe "Chef::Provider::AptUpdate" do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:collection) { double("resource collection") }
-  let(:new_resource) { Chef::Resource::AptUpdate.new("update", run_context) }
-  let(:provider) { new_resource.provider_for_action(:update) }
-
-  let(:config_dir) { Dir.mktmpdir("apt_update_apt_conf_d") }
-  let(:config_file) { File.join(config_dir, "15update-stamp") }
-  let(:stamp_dir) { Dir.mktmpdir("apt_update_periodic") }
-
-  before do
-    new_resource.class.send(:remove_const, :APT_CONF_DIR)
-    new_resource.class.send(:const_set, :APT_CONF_DIR, config_dir)
-    new_resource.class.send(:remove_const, :STAMP_DIR)
-    new_resource.class.send(:const_set, :STAMP_DIR, stamp_dir)
-    node.automatic["platform_family"] = "debian"
-  end
-
-  let(:apt_update_cmd) { %w{apt-get -q update} }
-
-  it "responds to load_current_resource" do
-    expect(provider).to respond_to(:load_current_resource)
-  end
-
-  context "when the apt config directory does not exist" do
-    before do
-      FileUtils.rmdir config_dir
-      expect(File.exist?(config_dir)).to be false
-      allow_any_instance_of(Chef::Provider::Execute).to receive(:shell_out_compacted!).with(*apt_update_cmd, anything)
-    end
-
-    it "should create the directory" do
-      provider.run_action(:update)
-      expect(File.exist?(config_dir)).to be true
-      expect(File.directory?(config_dir)).to be true
-    end
-
-    it "should create the config file" do
-      provider.run_action(:update)
-      expect(File.exist?(config_file)).to be true
-      expect(File.read(config_file)).to match(/^APT::Update.*#{stamp_dir}/)
-    end
-  end
-
-  describe "#action_update" do
-    it "should update the apt cache" do
-      provider.load_current_resource
-      expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out_compacted!).with(*apt_update_cmd, anything)
-      provider.run_action(:update)
-      expect(new_resource).to be_updated_by_last_action
-    end
-  end
-
-  describe "#action_periodic" do
-    before do
-      allow(File).to receive(:exist?).with(config_file).and_return(true)
-      allow(File).to receive(:exist?).with(config_dir).and_return(true)
-      allow(File).to receive(:exist?).with(stamp_dir).and_return(true)
-      allow(File).to receive(:exist?).with(Dir.tmpdir).and_return(true)
-      expect(File).to receive(:exist?).with("#{stamp_dir}/update-success-stamp").and_return(true)
-    end
-
-    it "should run if the time stamp is old" do
-      expect(File).to receive(:mtime).with("#{stamp_dir}/update-success-stamp").and_return(Time.now - 86_500)
-      expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out_compacted!).with(*apt_update_cmd, anything)
-      provider.run_action(:periodic)
-      expect(new_resource).to be_updated_by_last_action
-    end
-
-    it "should not run if the time stamp is new" do
-      expect(File).to receive(:mtime).with("#{stamp_dir}/update-success-stamp").and_return(Time.now)
-      expect_any_instance_of(Chef::Provider::Execute).not_to receive(:shell_out_compacted!).with(*apt_update_cmd, anything)
-      provider.run_action(:periodic)
-      expect(new_resource).to_not be_updated_by_last_action
-    end
-
-    context "with a different frequency" do
-      before do
-        new_resource.frequency(400)
-      end
-
-      it "should run if the time stamp is old" do
-        expect(File).to receive(:mtime).with("#{stamp_dir}/update-success-stamp").and_return(Time.now - 500)
-        expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out_compacted!).with(*apt_update_cmd, anything)
-        provider.run_action(:periodic)
-        expect(new_resource).to be_updated_by_last_action
-      end
-
-      it "should not run if the time stamp is new" do
-        expect(File).to receive(:mtime).with("#{stamp_dir}/update-success-stamp").and_return(Time.now - 300)
-        expect_any_instance_of(Chef::Provider::Execute).not_to receive(:shell_out_compacted!).with(*apt_update_cmd, anything)
-        provider.run_action(:periodic)
-        expect(new_resource).to_not be_updated_by_last_action
-      end
-    end
-  end
-end

data/spec/unit/provider/batch_spec.rb

@@ -1,130 +0,0 @@
-#
-# Author:: Adam Jacob (adam@chef.io)
-# Copyright:: Copyright 2009-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"
-
-describe Chef::Provider::Batch do
-  let(:node) do
-    node = Chef::Node.new
-    node.default["kernel"] = {}
-    node.default["kernel"][:machine] = :x86_64.to_s
-    node
-  end
-
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-
-  let(:new_resource) do
-    new_resource = Chef::Resource::Batch.new("cmd.exe and conquer")
-    new_resource.code %q{echo "hello"}
-    new_resource
-  end
-
-  let(:provider) { Chef::Provider::Batch.new(new_resource, run_context) }
-
-  context "#grant_alternate_user_read_access" do
-    before do
-      allow(ChefUtils).to receive(:windows?).and_return(true)
-      stub_const("Chef::ReservedNames::Win32::API::Security::GENERIC_READ", 1)
-      stub_const("Chef::ReservedNames::Win32::API::Security::GENERIC_EXECUTE", 4)
-      stub_const("Chef::ReservedNames::Win32::Security", Class.new)
-      stub_const("Chef::ReservedNames::Win32::Security::SecurableObject", Class.new)
-      stub_const("Chef::ReservedNames::Win32::Security::SID", Class.new)
-      stub_const("Chef::ReservedNames::Win32::Security::ACE", Class.new)
-      stub_const("Chef::ReservedNames::Win32::Security::ACL", Class.new)
-
-      provider.singleton_class.send(:public, :grant_alternate_user_read_access)
-    end
-
-    context "when an alternate user is not specified" do
-      it "does not attempt to set the script file's security descriptor" do
-        expect(provider).to receive(:grant_alternate_user_read_access)
-        expect(Chef::ReservedNames::Win32::Security::SecurableObject).not_to receive(:new)
-        provider.grant_alternate_user_read_access("a fake path")
-      end
-    end
-
-    context "when an alternate user is specified" do
-      let(:security_descriptor) { instance_double("Chef::ReservedNames::Win32::Security::SecurityDescriptor", dacl: []) }
-      let(:securable_object) { instance_double("Chef::ReservedNames::Win32::Security::SecurableObject", :security_descriptor => security_descriptor, :dacl= => nil) }
-
-      it "sets the script file's security descriptor" do
-        new_resource.user("toor")
-        expect(Chef::ReservedNames::Win32::Security::SecurableObject).to receive(:new).and_return(securable_object)
-        expect(Chef::ReservedNames::Win32::Security::SID).to receive(:from_account).and_return(nil)
-        expect(Chef::ReservedNames::Win32::Security::ACE).to receive(:access_allowed).and_return(nil)
-        expect(Chef::ReservedNames::Win32::Security::ACL).to receive(:create).and_return(nil)
-        expect(securable_object).to receive(:dacl=)
-        provider.grant_alternate_user_read_access("a fake path")
-      end
-    end
-  end
-
-  describe "#with_temp_script_file" do
-    before do
-      provider.singleton_class.send(:public, :with_temp_script_file)
-      provider.singleton_class.send(:public, :script_file_path)
-    end
-
-    it "should put the contents of the script in the temp file" do
-      temp_file_contents = nil
-
-      provider.with_temp_script_file do
-        temp_file_contents = File.read(provider.script_file_path)
-      end
-
-      expect(temp_file_contents.strip).to eq(%q{echo "hello"})
-    end
-  end
-
-  describe "#command" do
-    let(:basepath) { "C:\\Windows\\system32\\" }
-    let(:interpreter) { File.join(basepath, "cmd.exe") }
-
-    before do
-      allow(provider).to receive(:basepath).and_return(basepath)
-      provider.singleton_class.send(:public, :with_temp_script_file)
-      provider.singleton_class.send(:public, :script_file_path)
-    end
-
-    it 'should set the command to "interpreter"  "tempfile"' do
-      command = nil
-      script_file_path = nil
-      provider.with_temp_script_file do
-        command = provider.command
-        script_file_path = provider.script_file_path
-      end
-
-      expect(command).to eq(%Q{"#{interpreter}"  /c "#{script_file_path}"})
-    end
-
-    it "should set the command to 'interpreter flags tempfile'" do
-      new_resource.flags "/f"
-
-      command = nil
-      script_file_path = nil
-      provider.with_temp_script_file do
-        command = provider.command
-        script_file_path = provider.script_file_path
-      end
-
-      expect(command).to eq(%Q{"#{interpreter}" /f /c "#{script_file_path}"})
-    end
-  end
-end

data/spec/unit/provider/cookbook_file/content_spec.rb

@@ -1,39 +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.
-#
-
-require "spec_helper"
-
-describe Chef::Provider::CookbookFile::Content do
-
-  let(:new_resource) { double("Chef::Resource::CookbookFile (new)", cookbook_name: "apache2", cookbook: "apache2") }
-  let(:content) do
-    @run_context = double("Chef::RunContext")
-    @current_resource = double("Chef::Resource::CookbookFile (current)")
-    Chef::Provider::CookbookFile::Content.new(new_resource, @current_resource, @run_context)
-  end
-
-  it "prefers the explicit cookbook name on the resource to the implicit one" do
-    allow(new_resource).to receive(:cookbook).and_return("nginx")
-    expect(content.send(:resource_cookbook)).to eq("nginx")
-  end
-
-  it "falls back to the implicit cookbook name on the resource" do
-    expect(content.send(:resource_cookbook)).to eq("apache2")
-  end
-
-end