chef 18.8.11 → 18.8.54

data/spec/unit/resource/conditional_spec.rb

@@ -1,254 +0,0 @@
-#
-# 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.
-#
-
-require "spec_helper"
-require "ostruct"
-
-describe Chef::Resource::Conditional do
-  before do
-    allow_any_instance_of(Mixlib::ShellOut).to receive(:run_command).and_return(nil)
-    @status = OpenStruct.new(success?: true)
-    allow_any_instance_of(Mixlib::ShellOut).to receive(:status).and_return(@status)
-    @parent_resource = Chef::Resource.new("", Chef::Node.new)
-  end
-
-  it "raises an exception when neither a block or command is given" do
-    expect { Chef::Resource::Conditional.send(:new, :always, @parent_resource, nil, {}) }.to raise_error(ArgumentError, /requires either a command or a block/)
-  end
-
-  it "does not evaluate a guard interpreter on initialization of the conditional" do
-    expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:configure)
-    expect(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:new)
-    expect(Chef::GuardInterpreter::ResourceGuardInterpreter).not_to receive(:new)
-    Chef::Resource::Conditional.only_if(@parent_resource, "true")
-  end
-
-  describe "configure" do
-    it "raises an exception when a guard_interpreter is specified and a block is given" do
-      @parent_resource.guard_interpreter :canadian_mounties
-      conditional = Chef::Resource::Conditional.send(:new, :always, @parent_resource, nil, {}) { True }
-      expect { conditional.configure }.to raise_error(ArgumentError, /does not support blocks/)
-    end
-  end
-
-  describe "when created as an `only_if`" do
-    describe "after running a successful command given as a string" do
-      before do
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource, "true")
-      end
-
-      it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_truthy
-      end
-    end
-
-    describe "after running a negative/false command given as a string" do
-      before do
-        @status.send(:"success?=", false)
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource, "false")
-      end
-
-      it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_falsey
-      end
-    end
-
-    describe "after running a successful command given as an array" do
-      before do
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource, ["true"])
-      end
-
-      it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be true
-      end
-    end
-
-    describe "after running a negative/false command given as an array" do
-      before do
-        @status.send(:"success?=", false)
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource, ["false"])
-      end
-
-      it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be false
-      end
-    end
-
-    describe "after running a command which timed out" do
-      before do
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource, "false")
-        allow_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:shell_out).and_raise(Chef::Exceptions::CommandTimeout)
-      end
-
-      it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_falsey
-      end
-
-      it "logs a warning" do
-        expect(Chef::Log).to receive(:warn).with("Command 'false' timed out")
-        @conditional.continue?
-      end
-    end
-
-    describe "after running a block that returns a truthy value" do
-      before do
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource) { Object.new }
-      end
-
-      it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_truthy
-      end
-    end
-
-    describe "after running a block that returns a falsey value" do
-      before do
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource) { nil }
-      end
-
-      it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_falsey
-      end
-    end
-
-    describe "after running a block that returns a string value" do
-      before do
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource) { "some command" }
-      end
-
-      it "logs a warning" do
-        expect(Chef::Log).to receive(:warn).with("only_if block for [] returned \"some command\", did you mean to run a command? If so use 'only_if \"some command\"' in your code.")
-        @conditional.evaluate
-      end
-    end
-
-    describe "after running a block that returns a string value on a sensitive resource" do
-      before do
-        @parent_resource.sensitive(true)
-        @conditional = Chef::Resource::Conditional.only_if(@parent_resource) { "some command" }
-      end
-
-      it "logs a warning" do
-        expect(Chef::Log).to receive(:warn).with("only_if block for [] returned a string, did you mean to run a command?")
-        @conditional.evaluate
-      end
-    end
-  end
-
-  describe "when created as a `not_if`" do
-    describe "after running a successful/true command given as a string" do
-      before do
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource, "true")
-      end
-
-      it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_falsey
-      end
-    end
-
-    describe "after running a failed/false command given as a string" do
-      before do
-        @status.send(:"success?=", false)
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource, "false")
-      end
-
-      it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_truthy
-      end
-    end
-
-    describe "after running a successful/true command given as an array" do
-      before do
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource, ["true"])
-      end
-
-      it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be false
-      end
-    end
-
-    describe "after running a failed/false command given as an array" do
-      before do
-        @status.send(:"success?=", false)
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource, ["false"])
-      end
-
-      it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be true
-      end
-    end
-
-    describe "after running a command which timed out" do
-      before do
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource, "false")
-        allow_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:shell_out).and_raise(Chef::Exceptions::CommandTimeout)
-      end
-
-      it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_truthy
-      end
-
-      it "logs a warning" do
-        expect(Chef::Log).to receive(:warn).with("Command 'false' timed out")
-        @conditional.continue?
-      end
-    end
-
-    describe "after running a block that returns a truthy value" do
-      before do
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource) { Object.new }
-      end
-
-      it "indicates that resource convergence should not continue" do
-        expect(@conditional.continue?).to be_falsey
-      end
-    end
-
-    describe "after running a block that returns a falsey value" do
-      before do
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource) { nil }
-      end
-
-      it "indicates that resource convergence should continue" do
-        expect(@conditional.continue?).to be_truthy
-      end
-    end
-
-    describe "after running a block that returns a string value" do
-      before do
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource) { "some command" }
-      end
-
-      it "logs a warning" do
-        expect(Chef::Log).to receive(:warn).with("not_if block for [] returned \"some command\", did you mean to run a command? If so use 'not_if \"some command\"' in your code.")
-        @conditional.evaluate
-      end
-    end
-
-    describe "after running a block that returns a string value on a sensitive resource" do
-      before do
-        @parent_resource.sensitive(true)
-        @conditional = Chef::Resource::Conditional.not_if(@parent_resource) { "some command" }
-      end
-
-      it "logs a warning" do
-        expect(Chef::Log).to receive(:warn).with("not_if block for [] returned a string, did you mean to run a command?")
-        @conditional.evaluate
-      end
-    end
-  end
-end

data/spec/unit/resource/cookbook_file_spec.rb

@@ -1,93 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Author:: Tyler Cloke (<tyler@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# p 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::CookbookFile do
-  let(:resource) { Chef::Resource::CookbookFile.new("/foo/bar/sourcecode_tarball.tgz") }
-
-  it "sets the default action as :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "supports :create, :create_if_missing, :delete, :touch actions" do
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :create_if_missing }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-    expect { resource.action :touch }.not_to raise_error
-  end
-
-  it "uses the basepath of the resource name for the source property" do
-    expect(resource.source).to eq("sourcecode_tarball.tgz")
-  end
-
-  it "source property accepts Strings" do
-    resource.source("config_file.conf")
-    expect(resource.source).to eq("config_file.conf")
-  end
-
-  it "cookbook property defaults to nil (current cookbook will be used)" do
-    expect(resource.cookbook).to be_nil
-  end
-
-  it "has a cookbook property that accepts Strings" do
-    resource.cookbook("munin")
-    expect(resource.cookbook).to eq("munin")
-  end
-
-  describe "when it has a backup number, group, mode, owner, source, checksum, and cookbook on nix or path, rights, deny_rights, checksum on windows" do
-    before do
-      if ChefUtils.windows?
-        resource.path("C:/temp/origin/file.txt")
-        resource.rights(:read, "Everyone")
-        resource.deny_rights(:full_control, "Clumsy_Sam")
-      else
-        resource.path("/tmp/origin/file.txt")
-        resource.group("wheel")
-        resource.mode("0664")
-        resource.owner("root")
-        resource.source("/tmp/foo.txt")
-        resource.cookbook("/tmp/cookbooks/cooked.rb")
-      end
-      resource.checksum("1" * 64)
-    end
-
-    it "describes the state" do
-      state = resource.state_for_resource_reporter
-      if ChefUtils.windows?
-        puts state
-        expect(state[:rights]).to eq([{ permissions: :read, principals: "Everyone" }])
-        expect(state[:deny_rights]).to eq([{ permissions: :full_control, principals: "Clumsy_Sam" }])
-      else
-        expect(state[:group]).to eq("wheel")
-        expect(state[:mode]).to eq("0664")
-        expect(state[:owner]).to eq("root")
-      end
-      expect(state[:checksum]).to eq("1" * 64)
-    end
-
-    it "returns the path as its identity" do
-      if ChefUtils.windows?
-        expect(resource.identity).to eq("C:/temp/origin/file.txt")
-      else
-        expect(resource.identity).to eq("/tmp/origin/file.txt")
-      end
-    end
-  end
-end

data/spec/unit/resource/cron_access_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"
-
-describe Chef::Resource::CronAccess do
-  let(:resource) { Chef::Resource::CronAccess.new("bob") }
-
-  it "has a default action of [:deny]" do
-    expect(resource.action).to eql([:allow])
-  end
-
-  it "accepts create or delete for action" do
-    expect { resource.action :allow }.not_to raise_error
-    expect { resource.action :deny }.not_to raise_error
-    expect { resource.action :lolcat }.to raise_error(ArgumentError)
-  end
-
-  it "the user property is the name_property" do
-    expect(resource.user).to eql("bob")
-  end
-end

data/spec/unit/resource/cron_d_spec.rb

@@ -1,84 +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"
-
-describe Chef::Resource::CronD do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::CronD.new("cronify", run_context) }
-  let(:provider) { resource.provider_for_action(:create) }
-
-  it "has a default action of [:create]" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "accepts create or delete for action" do
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-    expect { resource.action :lolcat }.to raise_error(ArgumentError)
-  end
-
-  it "the cron_name property is the name_property" do
-    expect(resource.cron_name).to eql("cronify")
-  end
-
-  context "on linux" do
-    before(:each) do
-      node.automatic_attrs[:os] = "linux"
-    end
-
-    it "the cron_name property is valid" do
-      provider.define_resource_requirements
-
-      expect { resource.cron_name "cron-job";   provider.process_resource_requirements }.not_to raise_error
-      expect { resource.cron_name "cron_job_0"; provider.process_resource_requirements }.not_to raise_error
-      expect { resource.cron_name "CronJob";    provider.process_resource_requirements }.not_to raise_error
-      expect { resource.cron_name "cron!";      provider.process_resource_requirements }.to raise_error "The cron job name should contain letters, numbers, hyphens and underscores only."
-      expect { resource.cron_name "cron job";   provider.process_resource_requirements }.to raise_error "The cron job name should contain letters, numbers, hyphens and underscores only."
-    end
-  end
-
-  context "not on linux" do
-    before(:each) do
-      node.automatic_attrs[:os] = "aix"
-    end
-
-    it "all cron names are valid" do
-      provider.define_resource_requirements
-
-      expect { resource.cron_name "cron-job";   provider.process_resource_requirements }.not_to raise_error
-      expect { resource.cron_name "cron_job_0"; provider.process_resource_requirements }.not_to raise_error
-      expect { resource.cron_name "CronJob";    provider.process_resource_requirements }.not_to raise_error
-      expect { resource.cron_name "cron!";      provider.process_resource_requirements }.not_to raise_error
-      expect { resource.cron_name "cron job";   provider.process_resource_requirements }.not_to raise_error
-    end
-  end
-
-  it "the mode property defaults to '0600'" do
-    expect(resource.mode).to eql("0600")
-  end
-
-  it "the user property defaults to 'root'" do
-    expect(resource.user).to eql("root")
-  end
-
-  it "the command property is required" do
-    expect { resource.command nil }.to raise_error(Chef::Exceptions::ValidationFailed)
-  end
-end

data/spec/unit/resource/cron_spec.rb

@@ -1,167 +0,0 @@
-#
-# Author:: Bryan McLellan (btm@loftninjas.org)
-# Author:: Tyler Cloke (<tyler@chef.io>)
-# 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::Resource::Cron do
-  let(:resource) { Chef::Resource::Cron.new("cronify") }
-
-  it "sets the default action as :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "supports :create, :delete actions" do
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-  end
-
-  it "allows you to set a command" do
-    resource.command "/bin/true"
-    expect(resource.command).to eql("/bin/true")
-  end
-
-  it "allows you to set a user" do
-    resource.user "daemon"
-    expect(resource.user).to eql("daemon")
-  end
-
-  it "allows you to specify the minute" do
-    resource.minute "30"
-    expect(resource.minute).to eql("30")
-  end
-
-  it "allows you to specify the hour" do
-    resource.hour "6"
-    expect(resource.hour).to eql("6")
-  end
-
-  it "allows you to specify the day" do
-    resource.day "10"
-    expect(resource.day).to eql("10")
-  end
-
-  it "allows you to specify the month" do
-    resource.month "10"
-    expect(resource.month).to eql("10")
-  end
-
-  it "allows you to specify the weekday" do
-    resource.weekday "2"
-    expect(resource.weekday).to eql("2")
-  end
-
-  it "allows you to specify the mailto variable" do
-    resource.mailto "test@example.com"
-    expect(resource.mailto).to eql("test@example.com")
-  end
-
-  it "allows you to specify the path" do
-    resource.path "/usr/bin:/usr/sbin"
-    expect(resource.path).to eql("/usr/bin:/usr/sbin")
-  end
-
-  it "allows you to specify the home directory" do
-    resource.home "/root"
-    expect(resource.home).to eql("/root")
-  end
-
-  it "allows you to specify the shell to run the command with" do
-    resource.shell "/bin/zsh"
-    expect(resource.shell).to eql("/bin/zsh")
-  end
-
-  it "allows you to specify environment variables hash" do
-    env = { "TEST" => "LOL" }
-    resource.environment env
-    expect(resource.environment).to eql(env)
-  end
-
-  it "allows * for all time and date values" do
-    %w{minute hour day month weekday}.each do |x|
-      expect(resource.send(x, "*")).to eql("*")
-    end
-  end
-
-  it "allows ranges for all time and date values" do
-    %w{minute hour day month weekday}.each do |x|
-      expect(resource.send(x, "1-2,5")).to eql("1-2,5")
-    end
-  end
-
-  it "has a default value of * for all time and date values" do
-    %w{minute hour day month weekday}.each do |x|
-      expect(resource.send(x)).to eql("*")
-    end
-  end
-
-  it "has a default value of root for the user" do
-    expect(resource.user).to eql("root")
-  end
-
-  it "rejects any minute over 59" do
-    expect { resource.minute "60" }.to raise_error(Chef::Exceptions::ValidationFailed)
-  end
-
-  it "rejects any hour over 23" do
-    expect { resource.hour "24" }.to raise_error(Chef::Exceptions::ValidationFailed)
-  end
-
-  it "rejects any day over 31" do
-    expect { resource.day "32" }.to raise_error(Chef::Exceptions::ValidationFailed)
-  end
-
-  it "rejects any month over 12" do
-    expect { resource.month "13" }.to raise_error(Chef::Exceptions::ValidationFailed)
-  end
-
-  describe "weekday" do
-    it "rejects any weekday over 7" do
-      expect { resource.weekday "8" }.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-    it "rejects any symbols which don't represent day of week" do
-      expect { resource.weekday :foo }.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-  end
-
-  describe "when it has a time (minute, hour, day, month, weekend) and user" do
-    before do
-      resource.command("tackle")
-      resource.minute("1")
-      resource.hour("2")
-      resource.day("3")
-      resource.month("4")
-      resource.weekday("5")
-      resource.user("root")
-    end
-
-    it "describes the state" do
-      state = resource.state_for_resource_reporter
-      expect(state[:minute]).to eq("1")
-      expect(state[:hour]).to eq("2")
-      expect(state[:day]).to eq("3")
-      expect(state[:month]).to eq("4")
-      expect(state[:weekday]).to eq("5")
-      expect(state[:user]).to eq("root")
-    end
-
-    it "returns the command as its identity" do
-      expect(resource.identity).to eq("tackle")
-    end
-  end
-end

data/spec/unit/resource/csh_spec.rb

@@ -1,45 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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::Csh do
-
-  let(:resource) { Chef::Resource::Csh.new("fakey_fakerton") }
-
-  it "is a subclass of Chef::Resource::Script" do
-    expect(resource).to be_a_kind_of(Chef::Resource::Script)
-  end
-
-  it "has a resource name of :csh" do
-    expect(resource.resource_name).to eql(:csh)
-  end
-
-  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 "has an interpreter of csh" do
-    expect(resource.interpreter).to eql("csh")
-  end
-
-end