chef 18.8.11 → 18.8.46

data/spec/unit/resource/execute_spec.rb

@@ -1,282 +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.
-#
-
-require "spec_helper"
-
-describe Chef::Resource::Execute do
-  let(:resource_instance_name) { "some command" }
-  let(:resource) { Chef::Resource::Execute.new(resource_instance_name) }
-  it_behaves_like "an execute resource"
-
-  it "sets the default action as :run" do
-    expect(resource.action).to eql([:run])
-  end
-
-  it "supports :run action" do
-    expect { resource.action :run }.not_to raise_error
-  end
-
-  it "default guard interpreter is :execute interpreter" do
-    expect(resource.guard_interpreter).to be(:execute)
-  end
-
-  it "defaults to not being a guard interpreter" do
-    expect(resource.is_guard_interpreter).to eq(false)
-  end
-
-  describe "#qualify_user" do
-    let(:password) { "password" }
-    let(:domain) { nil }
-
-    context "when username is passed as user@domain" do
-      let(:username) { "user@domain" }
-
-      it "correctly parses the user and domain" do
-        identity = resource.qualify_user(username, password, domain)
-        expect(identity[:domain]).to eq("domain")
-        expect(identity[:user]).to eq("user")
-      end
-    end
-
-    context "when username is passed as domain\\user" do
-      let(:username) { "domain\\user" }
-
-      it "correctly parses the user and domain" do
-        identity = resource.qualify_user(username, password, domain)
-        expect(identity[:domain]).to eq("domain")
-        expect(identity[:user]).to eq("user")
-      end
-    end
-
-    context "when username is passed as an integer" do
-      let(:username) { 499 }
-
-      it "correctly parses the user and domain" do
-        identity = resource.qualify_user(username, password, domain)
-        expect(identity[:domain]).to eq(nil)
-        expect(identity[:user]).to eq(499)
-      end
-    end
-  end
-
-  shared_examples_for "it received valid credentials" do
-    describe "the validation method" do
-      it "does not raise an error" do
-        expect { resource.validate_identity_platform(username, password, domain) }.not_to raise_error
-      end
-    end
-
-    describe "the name qualification method" do
-      it "correctly translates the user and domain" do
-        identity = nil
-        expect { identity = resource.qualify_user(username, password, domain) }.not_to raise_error
-        expect(identity[:domain]).to eq(domain)
-        expect(identity[:user]).to eq(username)
-      end
-    end
-  end
-
-  shared_examples_for "it received invalid credentials" do
-    describe "the validation method" do
-      it "raises an error" do
-        expect { resource.validate_identity_platform(username, password, domain, elevated) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  shared_examples_for "it received invalid username and domain" do
-    describe "the validation method" do
-      it "raises an error" do
-        expect { resource.qualify_user(username, password, domain) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  shared_examples_for "it received credentials that are not valid on the platform" do
-    describe "the validation method" do
-      it "raises an error" do
-        expect { resource.validate_identity_platform(username, password, domain) }.to raise_error(Chef::Exceptions::UnsupportedPlatform)
-      end
-    end
-  end
-
-  context "when running on Windows" do
-    before do
-      allow(resource).to receive(:windows?).and_return(true)
-    end
-
-    context "when no user, domain, or password is specified" do
-      let(:username) { nil }
-      let(:domain) { nil }
-      let(:password) { nil }
-      it_behaves_like "it received valid credentials"
-    end
-
-    context "when a valid username is specified" do
-      let(:username) { "starchild" }
-      let(:elevated) { false }
-      context "when a valid domain is specified" do
-        let(:domain) { "mothership" }
-
-        context "when the password is not specified" do
-          let(:password) { nil }
-          it_behaves_like "it received invalid credentials"
-        end
-
-        context "when the password is specified" do
-          let(:password) { "we.funk!" }
-          it_behaves_like "it received valid credentials"
-        end
-      end
-
-      context "when the domain is not specified" do
-        let(:domain) { nil }
-        let(:elevated) { false }
-
-        context "when the password is not specified" do
-          let(:password) { nil }
-          it_behaves_like "it received invalid credentials"
-        end
-
-        context "when the password is specified" do
-          let(:password) { "we.funk!" }
-          it_behaves_like "it received valid credentials"
-        end
-      end
-
-      context "when username is not specified" do
-        let(:username) { nil }
-
-        context "when domain is specified" do
-          let(:domain) { "mothership" }
-          let(:password) { nil }
-          it_behaves_like "it received invalid username and domain"
-        end
-
-        context "when password is specified" do
-          let(:domain) { nil }
-          let(:password) { "we.funk!" }
-          it_behaves_like "it received invalid username and domain"
-        end
-      end
-    end
-
-    context "when invalid username is specified" do
-      let(:username) { "user@domain@domain" }
-      let(:domain) { nil }
-      let(:password) { "we.funk!" }
-      it_behaves_like "it received invalid username and domain"
-    end
-
-    context "when the domain is provided in both username and domain" do
-      let(:domain) { "some_domain" }
-      let(:password) { "we.funk!" }
-
-      context "when username is in the form domain\\user" do
-        let(:username) { "mothership\\starchild" }
-        it_behaves_like "it received invalid username and domain"
-      end
-
-      context "when username is in the form user@domain" do
-        let(:username) { "starchild@mothership" }
-        it_behaves_like "it received invalid username and domain"
-      end
-    end
-
-    context "when elevated is passed" do
-      let(:elevated) { true }
-
-      context "when username and password are not passed" do
-        let(:username) { nil }
-        let(:domain) { nil }
-        let(:password) { nil }
-        it_behaves_like "it received invalid credentials"
-      end
-
-      context "when username and password are passed" do
-        let(:username) { "user" }
-        let(:domain) { nil }
-        let(:password) { "we.funk!" }
-        it_behaves_like "it received valid credentials"
-      end
-    end
-  end
-
-  context "when not running on Windows" do
-    before do
-      allow(resource).to receive(:node).and_return({ platform_family: "ubuntu" })
-    end
-
-    context "when no user, domain, or password is specified" do
-      let(:username) { nil }
-      let(:domain) { nil }
-      let(:password) { nil }
-      it_behaves_like "it received valid credentials"
-    end
-
-    context "when the user is specified and the domain and password are not" do
-      let(:username) { "starchild" }
-      let(:domain) { nil }
-      let(:password) { nil }
-      it_behaves_like "it received valid credentials"
-
-      context "when the password is specified and the domain is not" do
-        let(:password) { "we.funk!" }
-        let(:domain) { nil }
-        it_behaves_like "it received credentials that are not valid on the platform"
-      end
-
-      context "when the domain is specified and the password is not" do
-        let(:domain) { "mothership" }
-        let(:password) { nil }
-        it_behaves_like "it received credentials that are not valid on the platform"
-      end
-
-      context "when the domain and password are specified" do
-        let(:domain) { "mothership" }
-        let(:password) { "we.funk!" }
-        it_behaves_like "it received credentials that are not valid on the platform"
-      end
-    end
-
-    context "when the user is not specified" do
-      let(:username) { nil }
-      context "when the domain is specified" do
-        let(:domain) { "mothership" }
-        context "when the password is specified" do
-          let(:password) { "we.funk!" }
-          it_behaves_like "it received credentials that are not valid on the platform"
-        end
-
-        context "when password is not specified" do
-          let(:password) { nil }
-          it_behaves_like "it received credentials that are not valid on the platform"
-        end
-      end
-
-      context "when the domain is not specified" do
-        let(:domain) { nil }
-        context "when the password is specified" do
-          let(:password) { "we.funk!" }
-          it_behaves_like "it received credentials that are not valid on the platform"
-        end
-      end
-    end
-  end
-end

data/spec/unit/resource/file/verification/json_spec.rb

@@ -1,72 +0,0 @@
-#
-# Author:: Antony Thomas (<antonydeepak@gmail.com>)
-# Copyright:: Copyright (c) Facebook, Inc. and its affiliates.
-# 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::Resource::File::Verification::Json do
-  let(:parent_resource) { Chef::Resource.new("llama") }
-
-  before(:all) do
-    @valid_json = "valid-#{Time.now.to_i}.json"
-    f = File.new(@valid_json, "w")
-    f.write('{
-      "foo": "bar"
-    }')
-    f.close
-
-    @invalid_json = "invalid-#{Time.now.to_i}.json"
-    f = File.new(@invalid_json, "w")
-    f.write("{
-      'foo': 'bar'
-    }")
-    f.close
-
-    @empty_json = "empty-#{Time.now.to_i}.json"
-    File.new(@empty_json, "w").close
-  end
-
-  context "verify" do
-    it "returns true for valid json" do
-      v = Chef::Resource::File::Verification::Json.new(parent_resource, :json, {})
-      expect(v.verify(@valid_json)).to eq(true)
-    end
-
-    it "returns false for invalid json" do
-      v = Chef::Resource::File::Verification::Json.new(parent_resource, :json, {})
-      expect(v.verify(@invalid_json)).to eq(false)
-    end
-
-    it "returns true for empty file" do
-      # Expectation here is different from that of default JSON parser included in ruby 2.4+.
-      # The default parser considers empty string as invalid JSON
-      # https://stackoverflow.com/questions/30621802/why-does-json-parse-fail-with-the-empty-string,
-      # however JSONCompat parses an empty string to `nil`.
-      # We are retaining the behavior of JSONCompat for two reasons
-      # - It is universal inside Chef codebase
-      # - It can be helpful to not throw an error when a `file` or `template` is empty
-      v = Chef::Resource::File::Verification::Json.new(parent_resource, :json, {})
-      expect(v.verify(@empty_json)).to eq(true)
-    end
-  end
-
-  after(:all) do
-    File.delete(@valid_json)
-    File.delete(@invalid_json)
-    File.delete(@empty_json)
-  end
-end

data/spec/unit/resource/file/verification/systemd_unit_spec.rb

@@ -1,103 +0,0 @@
-#
-# Author:: Mal Graty (<mal.graty@googlemail.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::Resource::File::Verification::SystemdUnit do
-  let(:command) { "#{systemd_analyze_path} verify %{path}" }
-  let(:opts) { { future: true } }
-  let(:parent_resource) { Chef::Resource.new("llama") }
-  let(:systemd_analyze_path) { "/usr/bin/systemd-analyze" }
-  let(:systemd_dir) { "/etc/systemd/system" }
-  let(:temp_path) { "/tmp" }
-  let(:unit_name) { "sysstat-collect.timer" }
-  let(:unit_path) { "#{systemd_dir}/#{unit_name}" }
-  let(:unit_temp_path) { "#{systemd_dir}/.chef-#{unit_name}" }
-  let(:unit_test_path) { "#{temp_path}/#{unit_name}" }
-
-  describe "verification registration" do
-    it "registers itself for later use" do
-      expect(Chef::Resource::File::Verification.lookup(:systemd_unit)).to eq(Chef::Resource::File::Verification::SystemdUnit)
-    end
-  end
-
-  describe "#initialize" do
-    before(:each) do
-      allow_any_instance_of(Chef::Resource::File::Verification::SystemdUnit).to receive(:which)
-        .with("systemd-analyze")
-        .and_return(systemd_analyze_path)
-    end
-
-    it "overwrites the @command variable with the verification command" do
-      v = Chef::Resource::File::Verification::SystemdUnit.new(parent_resource, :systemd_unit, {})
-      expect(v.instance_variable_get(:@command)).to eql(command)
-    end
-  end
-
-  describe "#verify" do
-    context "with the systemd-analyze binary available" do
-      before(:each) do
-        allow_any_instance_of(Chef::Resource::File::Verification::SystemdUnit).to receive(:which)
-          .with("systemd-analyze")
-          .and_return(systemd_analyze_path)
-
-        allow(parent_resource).to receive(:path)
-          .and_return(unit_path)
-        allow(Dir).to receive(:mktmpdir)
-          .with("chef-systemd-unit") { |&b| b.call temp_path }
-        allow(FileUtils).to receive(:cp)
-          .with(unit_temp_path, unit_test_path)
-      end
-
-      it "copies the temp file to secondary location under correct name" do
-        v = Chef::Resource::File::Verification::SystemdUnit.new(parent_resource, :systemd_unit, {})
-
-        expect(FileUtils).to receive(:cp).with(unit_temp_path, unit_test_path)
-        expect(v).to receive(:verify_command).with(unit_test_path, opts)
-
-        v.verify(unit_temp_path, opts)
-      end
-
-      it "returns the value given by #verify_command" do
-        v = Chef::Resource::File::Verification::SystemdUnit.new(parent_resource, :systemd_unit, {})
-
-        expect(v).to receive(:verify_command)
-          .with(unit_test_path, opts)
-          .and_return("foo")
-
-        expect(v.verify(unit_temp_path, opts)).to eql("foo")
-      end
-    end
-
-    context "with the systemd-analyze binary unavailable" do
-      before(:each) do
-        allow_any_instance_of(Chef::Resource::File::Verification::SystemdUnit).to receive(:which)
-          .with("systemd-analyze")
-          .and_return(false)
-      end
-
-      it "skips verification" do
-        v = Chef::Resource::File::Verification::SystemdUnit.new(parent_resource, :systemd_unit, {})
-
-        expect(v).to_not receive(:verify_command)
-
-        expect(v.verify(unit_temp_path)).to eq(true)
-      end
-    end
-  end
-end

data/spec/unit/resource/file/verification/yaml_spec.rb

@@ -1,67 +0,0 @@
-#
-# Author:: Antony Thomas (<antonydeepak@gmail.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::Resource::File::Verification::Yaml do
-  let(:parent_resource) { Chef::Resource.new("llama") }
-
-  before(:all) do
-    @valid_yaml = "valid-#{Time.now.to_i}.yaml"
-    f = File.new(@valid_yaml, "w")
-    f.write("# comment
-        svc:
-          mysqlPassword: sepppasswd
-        ")
-    f.close
-
-    @invalid_yaml = "invalid-#{Time.now.to_i}.yaml"
-    f = File.new(@invalid_yaml, "w")
-    f.write("# comment
-        svc:
-          mysqlPassword: 'sepppasswd
-        ")
-    f.close
-
-    @empty_yaml = "empty-#{Time.now.to_i}.yaml"
-    File.new(@empty_yaml, "w").close
-  end
-
-  context "verify" do
-    it "returns true for valid yaml" do
-      v = Chef::Resource::File::Verification::Yaml.new(parent_resource, :yaml, {})
-      expect(v.verify(@valid_yaml)).to eq(true)
-    end
-
-    it "returns false for invalid yaml" do
-      v = Chef::Resource::File::Verification::Yaml.new(parent_resource, :yaml, {})
-      expect(v.verify(@invalid_yaml)).to eq(false)
-    end
-
-    it "returns true for empty file" do
-      v = Chef::Resource::File::Verification::Yaml.new(parent_resource, :yaml, {})
-      expect(v.verify(@empty_yaml)).to eq(true)
-    end
-  end
-
-  after(:all) do
-    File.delete(@valid_yaml)
-    File.delete(@invalid_yaml)
-    File.delete(@empty_yaml)
-  end
-end

data/spec/unit/resource/file/verification_spec.rb

@@ -1,147 +0,0 @@
-#
-# Author:: Steven Danna (<steve@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::Resource::File::Verification do
-  let(:t_block) { Proc.new { true } }
-  let(:f_block) { Proc.new { false } }
-  let(:path_block) { Proc.new { |path| path } }
-  let(:temp_path) { "/tmp/foobar" }
-
-  describe "verification registration" do
-    it "registers a verification for later use" do
-      class Chef::Resource::File::Verification::Wombat < Chef::Resource::File::Verification
-        provides :tabmow
-      end
-      expect(Chef::Resource::File::Verification.lookup(:tabmow)).to eq(Chef::Resource::File::Verification::Wombat)
-    end
-
-    it "raises an error if a verification can't be found" do
-      expect { Chef::Resource::File::Verification.lookup(:dne) }.to raise_error(Chef::Exceptions::VerificationNotFound)
-    end
-  end
-
-  describe "#verify" do
-    let(:parent_resource) { Chef::Resource.new("llama") }
-
-    it "expects a string argument" do
-      v = Chef::Resource::File::Verification.new(parent_resource, nil, {}) {}
-      expect { v.verify("/foo/bar") }.to_not raise_error
-      expect { v.verify }.to raise_error(ArgumentError)
-    end
-
-    it "accepts an options hash" do
-      v = Chef::Resource::File::Verification.new(parent_resource, nil, {}) {}
-      expect { v.verify("/foo/bar", { future: true }) }.to_not raise_error
-    end
-
-    context "with a verification block" do
-      it "passes a file path to the block" do
-        v = Chef::Resource::File::Verification.new(parent_resource, nil, {}, &path_block)
-        expect(v.verify(temp_path)).to eq(temp_path)
-      end
-
-      it "returns true if the block returned true" do
-        v = Chef::Resource::File::Verification.new(parent_resource, nil, {}, &t_block)
-        expect(v.verify(temp_path)).to eq(true)
-      end
-
-      it "returns false if the block returned false" do
-        v = Chef::Resource::File::Verification.new(parent_resource, nil, {}, &f_block)
-        expect(v.verify(temp_path)).to eq(false)
-      end
-
-      it "responds to to_s" do
-        v = Chef::Resource::File::Verification.new(parent_resource, nil, {}) {}
-        expect(v.to_s).to eq("<Proc>")
-      end
-    end
-
-    context "with a verification command(String)" do
-      before(:each) do
-        allow(Chef::Log).to receive(:deprecation).and_return(nil)
-      end
-
-      def platform_specific_verify_command(variable_name)
-        if windows?
-          "if \"#{temp_path}\" == \"%{#{variable_name}}\" (exit 0) else (exit 1)"
-        else
-          "test #{temp_path} = %{#{variable_name}}"
-        end
-      end
-
-      it "raises an error when \%{file} is used" do
-        test_command = platform_specific_verify_command("file")
-        expect do
-          Chef::Resource::File::Verification.new(parent_resource, test_command, {}).verify(temp_path)
-        end.to raise_error(ArgumentError)
-      end
-
-      it "does not raise an error when \%{file} is not used" do
-        test_command = platform_specific_verify_command("path")
-        expect do
-          Chef::Resource::File::Verification.new(parent_resource, test_command, {}).verify(temp_path)
-        end.to_not raise_error
-      end
-
-      it "substitutes \%{path} with the path" do
-        test_command = platform_specific_verify_command("path")
-        v = Chef::Resource::File::Verification.new(parent_resource, test_command, {})
-        expect(v.verify(temp_path)).to eq(true)
-      end
-
-      it "returns false if the command fails" do
-        v = Chef::Resource::File::Verification.new(parent_resource, "false", {})
-        expect(v.verify(temp_path)).to eq(false)
-      end
-
-      it "returns true if the command succeeds" do
-        test_command = platform_specific_verify_command("path")
-        v = Chef::Resource::File::Verification.new(parent_resource, test_command, {})
-        expect(v.verify(temp_path)).to eq(true)
-      end
-
-      it "responds to to_s" do
-        v = Chef::Resource::File::Verification.new(parent_resource, "some command --here", {})
-        expect(v.to_s).to eq("some command --here")
-      end
-    end
-
-    context "with a named verification(Symbol)" do
-      let(:registered_verification) { double("registered_verification") }
-      subject { described_class.new(parent_resource, :cats, {}) }
-      before(:each) do
-        class Chef::Resource::File::Verification::Turtle < Chef::Resource::File::Verification
-          provides :cats
-          def verify(path, opts); end
-        end
-        allow(Chef::Resource::File::Verification::Turtle).to receive(:new).and_return(registered_verification)
-      end
-
-      it "delegates to the registered verification" do
-        expect(registered_verification).to receive(:verify).with(temp_path, {})
-        subject.verify(temp_path, {})
-      end
-
-      it "responds to to_s" do
-        expect(subject.to_s).to eq(":cats (Chef::Resource::File::Verification::Turtle)")
-      end
-    end
-  end
-end