chef 18.8.11 → 18.8.46

data/spec/unit/resource/template_spec.rb

@@ -1,222 +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::Template do
-  let(:resource) { Chef::Resource::Template.new("fakey_fakerton") }
-
-  describe "initialize" do
-    it "is a subclass of Chef::Resource::File" do
-      expect(resource).to be_a_kind_of(Chef::Resource::File)
-    end
-  end
-
-  describe "name" do
-    it "the path property is the name_property" do
-      expect(resource.path).to eql("fakey_fakerton")
-    end
-  end
-
-  describe "Actions" do
-    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
-  end
-
-  describe "source" do
-    it "accepts a string for the template source" do
-      resource.source "something"
-      expect(resource.source).to eql("something")
-    end
-
-    it "has a default based on the param name with .erb appended" do
-      expect(resource.source).to eql("fakey_fakerton.erb")
-    end
-
-    it "uses only the basename of the file as the default" do
-      r = Chef::Resource::Template.new("/tmp/obit/fakey_fakerton")
-      expect(r.source).to eql("fakey_fakerton.erb")
-    end
-  end
-
-  describe "variables" do
-    it "accepts a hash for the variable list" do
-      resource.variables({ reluctance: :awkward })
-      expect(resource.variables).to eq({ reluctance: :awkward })
-    end
-  end
-
-  describe "cookbook" do
-    it "accepts a string for the cookbook name" do
-      resource.cookbook("foo")
-      expect(resource.cookbook).to eq("foo")
-    end
-
-    it "defaults to nil" do
-      expect(resource.cookbook).to eq(nil)
-    end
-  end
-
-  describe "local" do
-    it "accepts a boolean for whether a template is local or remote" do
-      resource.local(true)
-      expect(resource.local).to eq(true)
-    end
-
-    it "defaults to false" do
-      expect(resource.local).to eq(false)
-    end
-  end
-
-  describe "when it has a path, owner, group, mode, and checksum" do
-    before do
-      resource.path("/tmp/foo.txt")
-      resource.owner("root")
-      resource.group("wheel")
-      resource.mode("0644")
-      resource.checksum("1" * 64)
-    end
-
-    context "on unix", :unix_only do
-      it "describes its state" do
-        state = resource.state_for_resource_reporter
-        expect(state[:owner]).to eq("root")
-        expect(state[:group]).to eq("wheel")
-        expect(state[:mode]).to eq("0644")
-        expect(state[:checksum]).to eq("1" * 64)
-      end
-    end
-
-    context "on windows", :windows_only do
-      # according to Chef::Resource::File, windows state properties are rights + deny_rights
-      skip "it describes its state"
-    end
-
-    it "returns the file path as its identity" do
-      expect(resource.identity).to eq("/tmp/foo.txt")
-    end
-  end
-
-  describe "defining helper methods" do
-
-    module ExampleHelpers
-      def static_example
-        "static_example"
-      end
-    end
-
-    it "collects helper method bodies as blocks" do
-      resource.helper(:example_1) { "example_1" }
-      resource.helper(:example_2) { "example_2" }
-      expect(resource.inline_helper_blocks[:example_1].call).to eq("example_1")
-      expect(resource.inline_helper_blocks[:example_2].call).to eq("example_2")
-    end
-
-    it "compiles helper methods into a module" do
-      resource.helper(:example_1) { "example_1" }
-      resource.helper(:example_2) { "example_2" }
-      modules = resource.helper_modules
-      expect(modules.size).to eq(1)
-      o = Object.new
-      modules.each { |m| o.extend(m) }
-      expect(o.example_1).to eq("example_1")
-      expect(o.example_2).to eq("example_2")
-    end
-
-    it "compiles helper methods with arguments into a module" do
-      resource.helper(:shout, &:upcase)
-      modules = resource.helper_modules
-      o = Object.new
-      modules.each { |m| o.extend(m) }
-      expect(o.shout("shout")).to eq("SHOUT")
-    end
-
-    it "raises an error when attempting to define a helper method without a method body" do
-      expect { resource.helper(:example) }.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-
-    it "raises an error when attempting to define a helper method with a non-Symbod method name" do
-      expect { resource.helper("example") { "fail" } }.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-
-    it "collects helper module bodies as blocks" do
-      resource.helpers do
-        def example_1
-          "example_1"
-        end
-      end
-      module_body = resource.inline_helper_modules.first
-      expect(module_body).to be_a(Proc)
-    end
-
-    it "compiles helper module bodies into modules" do
-      resource.helpers do
-        def example_1
-          "example_1"
-        end
-      end
-      modules = resource.helper_modules
-      expect(modules.size).to eq(1)
-      o = Object.new
-      modules.each { |m| o.extend(m) }
-      expect(o.example_1).to eq("example_1")
-    end
-
-    it "raises an error when no block or module name is given for helpers definition" do
-      expect { resource.helpers }.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-
-    it "raises an error when a non-module is given for helpers definition" do
-      expect { resource.helpers("NotAModule") }.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-
-    it "raises an error when a module name and block are both given for helpers definition" do
-      expect { resource.helpers(ExampleHelpers) { module_code } }.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-
-    it "collects helper modules" do
-      resource.helpers(ExampleHelpers)
-      expect(resource.helper_modules).to include(ExampleHelpers)
-    end
-
-    it "combines all helpers into a set of compiled modules" do
-      resource.helpers(ExampleHelpers)
-      resource.helpers do
-        def inline_module
-          "inline_module"
-        end
-      end
-      resource.helper(:inline_method) { "inline_method" }
-      expect(resource.helper_modules.size).to eq(3)
-
-      o = Object.new
-      resource.helper_modules.each { |m| o.extend(m) }
-      expect(o.static_example).to eq("static_example")
-      expect(o.inline_module).to eq("inline_module")
-      expect(o.inline_method).to eq("inline_method")
-    end
-  end
-end

data/spec/unit/resource/timezone_spec.rb

@@ -1,102 +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::Timezone do
-  let(:resource) { Chef::Resource::Timezone.new("fakey_fakerton") }
-
-  let(:shellout_tzutil) do
-    double("shell_out", stdout: "UTC\n", exitstatus: 0, error?: false)
-  end
-
-  # note: This weird indention is correct
-  let(:shellout_timedatectl) do
-    double("shell_out", exitstatus: 0, error?: false, stdout: <<-OUTPUT)
-    Local time: Tue 2020-08-18 20:55:05 UTC
-    Universal time: Tue 2020-08-18 20:55:05 UTC
-          RTC time: Tue 2020-08-18 20:55:05
-         Time zone: Etc/UTC (UTC, +0000)
-System clock synchronized: yes
-systemd-timesyncd.service active: yes
-   RTC in local TZ: no
-    OUTPUT
-  end
-
-  let(:shellout_systemsetup_fail) do
-    double("shell_out!", stdout: "You need administrator access to run this tool... exiting!", exitstatus: 0, error?: false) # yes it's a non-error exit
-  end
-
-  let(:shellout_systemsetup) do
-    double("shell_out!", stdout: "Time Zone: UTC", exitstatus: 0, error?: false)
-  end
-
-  it "sets resource name as :timezone" do
-    expect(resource.resource_name).to eql(:timezone)
-  end
-
-  it "the timezone property is the name_property" do
-    expect(resource.timezone).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :set" do
-    expect(resource.action).to eql([:set])
-  end
-
-  it "supports the :set action only" do
-    expect { resource.action :set }.not_to raise_error
-    expect { resource.action :unset }.to raise_error(Chef::Exceptions::ValidationFailed)
-  end
-
-  describe "#current_macos_tz" do
-    context "with admin privs" do
-      it "returns the TZ" do
-        expect(resource).to receive(:shell_out!).and_return(shellout_systemsetup)
-        expect(resource.current_macos_tz).to eql("UTC")
-      end
-    end
-
-    context "without admin privs" do
-      it "returns the TZ" do
-        expect(resource).to receive(:shell_out!).and_return(shellout_systemsetup_fail)
-        expect { resource.current_macos_tz }.to raise_error(RuntimeError, "The timezone resource requires administrative privileges to run on macOS hosts!")
-      end
-    end
-  end
-
-  describe "#current_systemd_tz" do
-    it "returns the TZ" do
-      expect(resource).to receive(:shell_out).and_return(shellout_timedatectl)
-      expect(resource.current_systemd_tz).to eql("Etc/UTC")
-    end
-  end
-
-  describe "#current_windows_tz" do
-    it "returns the TZ" do
-      expect(resource).to receive(:shell_out).and_return(shellout_tzutil)
-      expect(resource.current_windows_tz).to eql("UTC")
-    end
-  end
-
-  describe "#current_rhel_tz" do
-    it "returns the TZ" do
-      allow(File).to receive(:exist?).with("/etc/sysconfig/clock").and_return true
-      expect(File).to receive(:read).with("/etc/sysconfig/clock").and_return 'ZONE="UTC"'
-      expect(resource.current_rhel_tz).to eql("UTC")
-    end
-  end
-end

data/spec/unit/resource/user/linux_user_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe Chef::Resource::User, "initialize" do
-  let(:resource) { Chef::Resource::User::LinuxUser.new("notarealuser") }
-
-  describe "inactive attribute" do
-    it "allows a string" do
-      resource.inactive "100"
-      expect(resource.inactive).to eql("100")
-    end
-
-    it "allows an integer" do
-      resource.inactive 100
-      expect(resource.inactive).to eql(100)
-    end
-
-    it "does not allow a hash" do
-      expect { resource.inactive({ woot: "i found it" }) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "expire_date attribute" do
-    it "allows a string" do
-      resource.expire_date "100"
-      expect(resource.expire_date).to eql("100")
-    end
-
-    it "does not allow an integer" do
-      expect { resource.expire_date(90) }.to raise_error(ArgumentError)
-    end
-
-    it "does not allow a hash" do
-      expect { resource.expire_date({ woot: "i found it" }) }.to raise_error(ArgumentError)
-    end
-  end
-
-  %w{inactive expire_date}.each do |prop|
-    it "sets #{prop} to nil" do
-      expect(resource.send(prop)).to eql(nil)
-    end
-  end
-end

data/spec/unit/resource/user/windows_user_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::User::WindowsUser, "#uid" do
-  let(:resource) { Chef::Resource::User::WindowsUser.new("notarealuser") }
-
-  it "allows a string" do
-    resource.uid "100"
-    expect(resource.uid).to eql(100)
-  end
-
-  it "allows an integer" do
-    resource.uid 100
-    expect(resource.uid).to eql(100)
-  end
-
-  it "does not allow a hash" do
-    expect { resource.uid({ woot: "i found it" }) }.to raise_error(ArgumentError)
-  end
-end

data/spec/unit/resource/user_spec.rb

@@ -1,121 +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::User, "initialize" do
-  let(:resource) { Chef::Resource::User.new("notarealuser") }
-
-  it "sets the resource_name to nil" do
-    expect(resource.resource_name).to eql(nil)
-  end
-
-  it "username property is the name property" do
-    expect(resource.username).to eql("notarealuser")
-  end
-
-  %w{comment uid gid home shell password}.each do |prop|
-    it "sets #{prop} to nil" do
-      expect(resource.send(prop)).to eql(nil)
-    end
-  end
-
-  it "sets action to :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  %w{manage_home non_unique force system}.each do |prop|
-    it "sets #{prop} to false" do
-      expect(resource.send(prop)).to eql(false)
-    end
-  end
-
-  %w{create remove modify manage lock unlock}.each do |action|
-    it "allows action #{action}" do
-      expect(resource.allowed_actions.detect { |a| a == action.to_sym }).to eql(action.to_sym)
-    end
-  end
-
-  it "group is an alias for the gid property" do
-    resource.group(1234)
-    expect(resource.gid).to eql(1234)
-  end
-
-  it "accepts domain users (@ or \ separator) on non-windows" do
-    expect { resource.username "domain\@user" }.not_to raise_error
-    expect(resource.username).to eq("domain\@user")
-    expect { resource.username "domain\\user" }.not_to raise_error
-    expect(resource.username).to eq("domain\\user")
-  end
-end
-
-%w{username comment home shell password}.each do |attrib|
-  describe Chef::Resource::User, attrib do
-    let(:resource) { Chef::Resource::User.new("notarealuser") }
-
-    it "allows a string" do
-      resource.send(attrib, "something")
-      expect(resource.send(attrib)).to eql("something")
-    end
-
-    it "does not allow a hash" do
-      expect { resource.send(attrib, { woot: "i found it" }) }.to raise_error(ArgumentError)
-    end
-  end
-end
-
-%w{uid gid}.each do |attrib|
-  describe Chef::Resource::User, attrib do
-    let(:resource) { Chef::Resource::User.new("notarealuser") }
-
-    it "allows a string" do
-      resource.send(attrib, "100")
-      expect(resource.send(attrib)).to eql("100")
-    end
-
-    it "allows an integer" do
-      resource.send(attrib, 100)
-      expect(resource.send(attrib)).to eql(100)
-    end
-
-    it "does not allow a hash" do
-      expect { resource.send(attrib, { woot: "i found it" }) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "when it has uid, gid, and home" do
-    let(:resource) { Chef::Resource::User.new("root") }
-
-    before do
-      resource.uid(123)
-      resource.gid(456)
-      resource.home("/usr/local/root/")
-    end
-
-    it "describes its state" do
-      state = resource.state_for_resource_reporter
-      expect(state[:uid]).to eq(123)
-      expect(state[:gid]).to eq(456)
-      expect(state[:home]).to eq("/usr/local/root/")
-    end
-
-    it "returns the username as its identity" do
-      expect(resource.identity).to eq("root")
-    end
-  end
-end

data/spec/unit/resource/user_ulimit_spec.rb

@@ -1,66 +0,0 @@
-#
-# Author:: Tim Smith (<tsmith@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::UserUlimit do
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::UserUlimit.new("fakey_fakerton", run_context) }
-
-  it "the username property is the name_property" do
-    expect(resource.username).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "coerces filename value to end in .conf" do
-    resource.filename("foo")
-    expect(resource.filename).to eql("foo.conf")
-  end
-
-  it "if username is * then the filename defaults to 00_all_limits.conf" do
-    resource.username("*")
-    expect(resource.filename).to eql("00_all_limits.conf")
-  end
-
-  it "if username is NOT * then the filename defaults to USERNAME_limits.conf" do
-    expect(resource.filename).to eql("fakey_fakerton_limits.conf")
-  end
-
-  it "supports :create and :delete actions" do
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-  end
-
-  describe "sensitive attribute" do
-    context "should be insensitive by default" do
-      it { expect(resource.sensitive).to(be_falsey) }
-    end
-
-    context "when set" do
-      before { resource.sensitive(true) }
-
-      it "should be set on the resource" do
-        expect(resource.sensitive).to(be_truthy)
-      end
-    end
-  end
-end

data/spec/unit/resource/windows_ad_join_spec.rb

@@ -1,55 +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::WindowsAdJoin do
-  let(:resource) { Chef::Resource::WindowsAdJoin.new("example.com") }
-
-  it "sets resource name as :windows_ad_join" do
-    expect(resource.resource_name).to eql(:windows_ad_join)
-  end
-
-  it "the domain_name property is the name_property" do
-    expect(resource.domain_name).to eql("example.com")
-  end
-
-  it "sets the default action as :join" do
-    expect(resource.action).to eql([:join])
-  end
-
-  it "supports :join action" do
-    expect { resource.action :join }.not_to raise_error
-  end
-
-  it "supports :leave action" do
-    expect { resource.action :leave }.not_to raise_error
-  end
-
-  it "only accepts FQDNs for the domain_name property" do
-    expect { resource.domain_name "example" }.to raise_error(ArgumentError)
-  end
-
-  it "accepts :immediate, :reboot_now, :request_reboot, :delayed, or :never values for 'reboot' property" do
-    expect { resource.reboot :immediate }.not_to raise_error
-    expect { resource.reboot :delayed }.not_to raise_error
-    expect { resource.reboot :reboot_now }.not_to raise_error
-    expect { resource.reboot :request_reboot }.not_to raise_error
-    expect { resource.reboot :never }.not_to raise_error
-    expect { resource.reboot :nopenope }.to raise_error(ArgumentError)
-  end
-end