chef 18.8.11 → 18.8.54

data/spec/functional/resource/template_spec.rb

@@ -1,245 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@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
-
-  def binread(file)
-    File.binread(file)
-  end
-
-  include_context Chef::Resource::File
-
-  let(:file_base) { "template_spec" }
-  let(:expected_content) { "slappiness is a warm gun" }
-
-  let(:node) do
-    node = Chef::Node.new
-    node.normal[:slappiness] = "a warm gun"
-    node.normal[:nested][:secret] = "value"
-    node
-  end
-
-  def create_resource
-    cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
-    Chef::Cookbook::FileVendor.fetch_from_disk(cookbook_repo)
-    cl = Chef::CookbookLoader.new(cookbook_repo)
-    cl.load_cookbooks
-    cookbook_collection = Chef::CookbookCollection.new(cl)
-    events = Chef::EventDispatch::Dispatcher.new
-    run_context = Chef::RunContext.new(node, cookbook_collection, events)
-    resource = Chef::Resource::Template.new(path, run_context)
-    resource.source("openldap_stuff.conf.erb")
-    resource.cookbook("openldap")
-
-    # NOTE: partials rely on `cookbook_name` getting set by chef internals and
-    # ignore the user-set `cookbook` attribute.
-    resource.cookbook_name = "openldap"
-
-    resource
-  end
-
-  let(:resource) do
-    create_resource
-  end
-
-  let(:default_mode) { (0666 & ~File.umask).to_s(8) }
-
-  it_behaves_like "a file resource"
-
-  it_behaves_like "a securable resource with reporting"
-
-  context "when the target file does not exist" do
-    it "creates the template with the rendered content using the variable attribute when the :create action is run" do
-      resource.source("openldap_variable_stuff.conf.erb")
-      resource.variables(secret: "nutella")
-      resource.run_action(:create)
-      expect(IO.read(path)).to eq("super secret is nutella")
-    end
-
-    it "creates the template with the rendered content using a local erb file when the :create action is run" do
-      resource.source(File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks", "openldap", "templates", "default", "openldap_stuff.conf.erb")))
-      resource.cookbook(nil)
-      resource.local(true)
-      resource.run_action(:create)
-      expect(IO.read(path)).to eq(expected_content)
-    end
-  end
-
-  describe "when the template resource defines helper methods" do
-
-    include_context "diff disabled"
-
-    let(:resource) do
-      r = create_resource
-      r.source "helper_test.erb"
-      r
-    end
-
-    let(:expected_content) { "value from helper method" }
-
-    shared_examples "a template with helpers" do
-      it "generates expected content by calling helper methods" do
-        resource.run_action(:create)
-        expect(binread(path).strip).to eq(expected_content)
-      end
-    end
-
-    context "using single helper syntax" do
-      before do
-        resource.helper(:helper_method) { "value from helper method" }
-      end
-
-      it_behaves_like "a template with helpers"
-    end
-
-    context "using single helper syntax referencing @node" do
-      before do
-        node.normal[:helper_test_attr] = "value from helper method"
-        resource.helper(:helper_method) { (@node[:helper_test_attr]).to_s }
-      end
-
-      it_behaves_like "a template with helpers"
-    end
-
-    context "using an inline block to define helpers" do
-      before do
-        resource.helpers do
-          def helper_method
-            "value from helper method"
-          end
-        end
-      end
-
-      it_behaves_like "a template with helpers"
-    end
-
-    context "using an inline block referencing @node" do
-      before do
-        node.normal[:helper_test_attr] = "value from helper method"
-
-        resource.helpers do
-          def helper_method
-            @node[:helper_test_attr]
-          end
-        end
-      end
-
-      it_behaves_like "a template with helpers"
-
-    end
-
-    context "using a module from a library" do
-
-      module ExampleModule
-        def helper_method
-          "value from helper method"
-        end
-      end
-
-      before do
-        resource.helpers(ExampleModule)
-      end
-
-      it_behaves_like "a template with helpers"
-
-    end
-    context "using a module from a library referencing @node" do
-
-      module ExampleModuleReferencingATNode
-        def helper_method
-          @node[:helper_test_attr]
-        end
-      end
-
-      before do
-        node.normal[:helper_test_attr] = "value from helper method"
-
-        resource.helpers(ExampleModuleReferencingATNode)
-      end
-
-      it_behaves_like "a template with helpers"
-
-    end
-
-    context "using helpers with partial templates" do
-      before do
-        resource.source("helpers_via_partial_test.erb")
-        resource.helper(:helper_method) { "value from helper method" }
-      end
-
-      it_behaves_like "a template with helpers"
-
-    end
-  end
-
-  describe "when template source contains windows style line endings" do
-    include_context "diff disabled"
-
-    %w{all some no}.each do |test_case|
-      context "for #{test_case} lines" do
-        let(:resource) do
-          r = create_resource
-          r.source "#{test_case}_windows_line_endings.erb"
-          r
-        end
-
-        it "output should contain platform's line endings" do
-          resource.run_action(:create)
-          binread(path).each_line do |line|
-            expect(line).to end_with(ChefUtils.windows? ? "\r\n" : "\n")
-          end
-        end
-      end
-    end
-  end
-
-  describe "when template variables contain lazy{} calls" do
-    it "resolves the DelayedEvaluator" do
-      resource.source("openldap_variable_stuff.conf.erb")
-      resource.variables(secret: Chef::DelayedEvaluator.new { "nutella" })
-      resource.run_action(:create)
-      expect(IO.read(path)).to eq("super secret is nutella")
-    end
-
-    it "does not mutate the resource variables" do
-      resource.source("openldap_variable_stuff.conf.erb")
-      resource.variables(secret: Chef::DelayedEvaluator.new { "nutella" })
-      resource.run_action(:create)
-      expect(resource.variables[:secret]).to be_a Chef::DelayedEvaluator
-    end
-
-    it "resolves the DelayedEvaluator when deeply nested" do
-      resource.source("openldap_nested_variable_stuff.erb")
-      resource.variables(secret: [{ "key" => Chef::DelayedEvaluator.new { "nutella" } }])
-      resource.run_action(:create)
-      expect(IO.read(path)).to eq("super secret is nutella")
-    end
-  end
-
-  describe "when passing a node attribute mash as a template variable" do
-    it "uses the node attributes like a hash" do
-      resource.source("openldap_variable_stuff.conf.erb")
-      resource.variables(node[:nested])
-      resource.run_action(:create)
-      expect(IO.read(path)).to eq("super secret is value")
-    end
-  end
-
-end

data/spec/functional/resource/timezone_spec.rb

@@ -1,41 +0,0 @@
-#
-# Author:: Gary Bright (<digitalgaz@hotmail.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::Timezone, :windows_only do
-  let(:timezone) { "GMT Standard Time" }
-
-  def timezone_resource
-    run_context = Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
-
-    Chef::Resource::Timezone.new(timezone, run_context)
-  end
-
-  describe "when a timezone is provided on windows" do
-    it "should set a timezone" do
-      timezone_resource.run_action(:set)
-    end
-  end
-
-  describe "when a timezone is not provided on windows" do
-    let(:timezone) { nil }
-    it "raises an exception" do
-      expect { timezone_resource.run_action(:set) }.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-  end
-end

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

@@ -1,127 +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"
-require "chef/mixin/shell_out"
-
-metadata = {
-  requires_root: true,
-  linux_only: true,
-}
-
-describe "Chef::Resource::User with Chef::Provider::User::LinuxUser provider", metadata do
-  include Chef::Mixin::ShellOut
-
-  def clean_user
-    shell_out!("/usr/sbin/userdel #{username}")
-  rescue Mixlib::ShellOut::ShellCommandFailed
-    # Raised when the user is already cleaned
-  end
-
-  def ensure_file_cache_path_exists
-    path = Chef::Config["file_cache_path"]
-    FileUtils.mkdir_p(path) unless File.directory?(path)
-  end
-
-  def user_should_exist
-    expect(shell_out("grep -q #{username} /etc/passwd").error?).to be(false)
-  end
-
-  def check_password(pass, user)
-    expect(shell_out("grep ^#{user}: /etc/shadow | cut -d: -f2 | grep ^#{pass}$").exitstatus).to eq(0)
-  end
-
-  let(:node) do
-    n = Chef::Node.new
-    n.consume_external_attrs(OHAI_SYSTEM.data.dup, {})
-    n
-  end
-
-  let(:events) do
-    Chef::EventDispatch::Dispatcher.new
-  end
-
-  let(:run_context) do
-    Chef::RunContext.new(node, {}, events)
-  end
-
-  let(:username) do
-    "greatchef"
-  end
-
-  let(:uid) { nil }
-  let(:gid) do
-    # SLES 15 doesn't have the "20" group and
-    # so lets just pick the last group... no,
-    # Etc.group.map(&:gid).last does not work
-    Etc.enum_for(:group).map(&:gid).last
-  end
-  let(:home) { nil }
-  let(:manage_home) { false }
-  let(:password) { "XXXYYYZZZ" }
-  let(:comment) { "Great Chef" }
-  let(:shell) { "/bin/bash" }
-  let(:salt) { nil }
-
-  let(:user_resource) do
-    r = Chef::Resource::User::LinuxUser.new("TEST USER RESOURCE", run_context)
-    r.username(username)
-    r.uid(uid)
-    r.gid(gid)
-
-    r.home(home)
-    r.shell(shell)
-    r.comment(comment)
-    r.manage_home(manage_home)
-    r.password(password)
-    r.salt(salt)
-    r
-  end
-
-  before do
-    clean_user
-    ensure_file_cache_path_exists
-  end
-
-  after(:each) do
-    clean_user
-  end
-
-  describe "action :create" do
-    it "should create the user" do
-      user_resource.run_action(:create)
-      user_should_exist
-      check_password(password, username)
-    end
-  end
-
-  describe "when user exists" do
-    before do
-      existing_resource = user_resource.dup
-      existing_resource.run_action(:create)
-      user_should_exist
-    end
-
-    describe "when password is updated" do
-      it "should update the password of the user" do
-        user_resource.password("mykitchen")
-        user_resource.run_action(:create)
-        check_password("mykitchen", username)
-      end
-    end
-  end
-end

data/spec/functional/resource/user/mac_user_spec.rb

@@ -1,207 +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"
-require "chef/mixin/shell_out"
-
-metadata = {
-  requires_root: true,
-  macos_only: true,
- }
-
-describe "Chef::Resource::User with Chef::Provider::User::MacUser provider", metadata do
-  include Chef::Mixin::ShellOut
-
-  def clean_user
-    shell_out!("/usr/bin/dscl . -delete '/Users/#{username}'")
-  rescue Mixlib::ShellOut::ShellCommandFailed
-    # Raised when the user is already cleaned
-  end
-
-  def ensure_file_cache_path_exists
-    path = Chef::Config["file_cache_path"]
-    FileUtils.mkdir_p(path) unless File.directory?(path)
-  end
-
-  def user_should_exist
-    expect(shell_out("/usr/bin/dscl . -read /Users/#{username}").error?).to be(false)
-  end
-
-  def check_password(pass)
-    # In order to test the password we use dscl passwd command since
-    # that's the only command that gets the user password from CLI.
-    expect(shell_out("dscl . -passwd /Users/greatchef #{pass} new_password").exitstatus).to eq(0)
-    # Now reset the password back
-    expect(shell_out("dscl . -passwd /Users/greatchef new_password #{pass}").exitstatus).to eq(0)
-  end
-
-  let(:node) do
-    n = Chef::Node.new
-    n.consume_external_attrs(OHAI_SYSTEM.data.dup, {})
-    n
-  end
-
-  let(:events) do
-    Chef::EventDispatch::Dispatcher.new
-  end
-
-  let(:run_context) do
-    Chef::RunContext.new(node, {}, events)
-  end
-
-  let(:username) do
-    "greatchef"
-  end
-
-  let(:uid) { nil }
-  let(:gid) { 20 }
-  let(:home) { nil }
-  let(:manage_home) { false }
-  let(:password) { "XXXYYYZZZ" }
-  let(:comment) { "Great Chef" }
-  let(:shell) { "/bin/bash" }
-  let(:salt) { nil }
-  let(:iterations) { nil }
-
-  let(:user_resource) do
-    r = Chef::Resource::User::MacUser.new("TEST USER RESOURCE", run_context)
-    r.username(username)
-    r.uid(uid)
-    r.gid(gid)
-    r.home(home)
-    r.shell(shell)
-    r.comment(comment)
-    r.manage_home(manage_home)
-    r.password(password)
-    r.salt(salt)
-    r.iterations(iterations)
-    r
-  end
-
-  before do
-    clean_user
-    ensure_file_cache_path_exists
-  end
-
-  after(:each) do
-    clean_user
-  end
-
-  describe "action :create" do
-    it "should create the user" do
-      user_resource.run_action(:create)
-      user_should_exist
-      check_password(password)
-    end
-  end
-
-  describe "when user exists" do
-    before do
-      existing_resource = user_resource.dup
-      existing_resource.run_action(:create)
-      user_should_exist
-    end
-
-    describe "when password is updated" do
-      it "should update the password of the user" do
-        user_resource.password("mykitchen")
-        user_resource.run_action(:create)
-        check_password("mykitchen")
-      end
-    end
-  end
-
-  describe "when password is being set via shadow hash" do
-    let(:password) do
-      "c734b6e4787c3727bb35e29fdd92b97c\
-1de12df509577a045728255ec7c6c5f5\
-c18efa05ed02b682ffa7ebc05119900e\
-b1d4880833aa7a190afc13e2bf0936b8\
-20123e8c98f0f9bcac2a629d9163caac\
-9464a8c234f3919082400b4f939bb77b\
-c5adbbac718b7eb99463a7b679571e0f\
-1c9fef2ef08d0b9e9c2bcf644eed2ffc"
-    end
-
-    let(:iterations) { 25000 }
-    let(:salt) { "9e2e7d5ee473b496fd24cf0bbfcaedfcb291ee21740e570d1e917e874f8788ca" }
-
-    it "action :create should create the user" do
-      user_resource.run_action(:create)
-      user_should_exist
-      check_password("soawesome")
-    end
-
-    describe "when user exists" do
-      before do
-        existing_resource = user_resource.dup
-        existing_resource.run_action(:create)
-        user_should_exist
-      end
-
-      describe "when password is updated" do
-        describe "without salt" do
-          let(:salt) { nil }
-
-          it "it sets the password" do
-            user_resource.password("mykitchen")
-            user_resource.run_action(:create)
-            check_password("mykitchen")
-          end
-        end
-
-        describe "with salt and plaintext password" do
-          it "raises Chef::Exceptions::User" do
-            expect do
-              user_resource.password("notasha512")
-              user_resource.run_action(:create)
-            end.to raise_error(Chef::Exceptions::User)
-          end
-        end
-      end
-    end
-  end
-
-  describe "when a user is member of some groups" do
-    let(:groups) { %w{staff operator} }
-
-    before do
-      existing_resource = user_resource.dup
-      existing_resource.run_action(:create)
-
-      groups.each do |group|
-        shell_out!("/usr/bin/dscl . -append '/Groups/#{group}' GroupMembership #{username}")
-      end
-    end
-
-    after do
-      groups.each do |group|
-        # Do not raise an error when user is correctly removed
-        shell_out("/usr/bin/dscl . -delete '/Groups/#{group}' GroupMembership #{username}")
-      end
-    end
-
-    it ":remove action removes the user from the groups and deletes the user" do
-      user_resource.run_action(:remove)
-      groups.each do |group|
-        # Do not raise an error when group is empty
-        expect(shell_out("dscl . read /Groups/staff GroupMembership").stdout).not_to include(group)
-      end
-    end
-  end
-
-end