chef 18.8.11 → 18.8.54

data/spec/unit/resource/locale_spec.rb

@@ -1,189 +0,0 @@
-#
-# Author:: Nimesh Patni (<nimesh.patni@msystechnologies.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::Locale do
-
-  let(:resource) { Chef::Resource::Locale.new("fakey_fakerton") }
-  let(:provider) { resource.provider_for_action(:update) }
-
-  describe "default:" do
-    it "name would be locale" do
-      expect(resource.resource_name).to eq(:locale)
-    end
-    it "lang would be nil" do
-      expect(resource.lang).to be_nil
-    end
-    it "lc_env would be an empty hash" do
-      expect(resource.lc_env).to be_a(Hash)
-      expect(resource.lc_env).to be_empty
-    end
-    it "action would be :update" do
-      expect(resource.action).to eql([:update])
-    end
-  end
-
-  describe "validations:" do
-    let(:validation) { Chef::Exceptions::ValidationFailed }
-    context "lang" do
-      it "is non empty" do
-        expect { resource.lang("") }.to raise_error(validation)
-      end
-      it "does not contain any leading whitespaces" do
-        expect { resource.lang("  XX") }.to raise_error(validation)
-      end
-    end
-
-    context "lc_env" do
-      it "is non empty" do
-        expect { resource.lc_env({ "LC_TIME" => "" }) }.to raise_error(validation)
-      end
-      it "does not contain any leading whitespaces" do
-        expect { resource.lc_env({ "LC_TIME" => " XX" }) }.to raise_error(validation)
-      end
-      it "keys are valid and case sensitive" do
-        expect { resource.lc_env({ "LC_TIMES" => " XX" }) }.to raise_error(validation)
-        expect { resource.lc_env({ "Lc_Time" => " XX" }) }.to raise_error(validation)
-        expect(resource.lc_env({ "LC_TIME" => "XX" })).to eql({ "LC_TIME" => "XX" })
-      end
-    end
-  end
-
-  describe "#unavailable_locales" do
-    let(:available_locales) do
-      <<~LOC
-        C
-        C.UTF-8
-        en_AG
-        en_AG.utf8
-        en_US
-        POSIX
-      LOC
-    end
-    before do
-      dummy = Mixlib::ShellOut.new
-      allow_any_instance_of(Chef::Mixin::ShellOut).to receive(:shell_out!).with("locale -a").and_return(dummy)
-      allow(dummy).to receive(:stdout).and_return(available_locales)
-    end
-    context "when all locales are available on system" do
-      context "with both properties" do
-        it "returns an empty array" do
-          resource.lang("en_US")
-          resource.lc_env({ "LC_TIME" => "en_AG.utf8", "LC_MESSAGES" => "en_AG.utf8" })
-          expect(provider.unavailable_locales).to eq([])
-        end
-      end
-      context "without lang" do
-        it "returns an empty array" do
-          resource.lang
-          resource.lc_env({ "LC_TIME" => "en_AG.utf8", "LC_MESSAGES" => "en_AG.utf8" })
-          expect(provider.unavailable_locales).to eq([])
-        end
-      end
-      context "without lc_env" do
-        it "returns an empty array" do
-          resource.lang("en_US")
-          resource.lc_env
-          expect(provider.unavailable_locales).to eq([])
-        end
-      end
-      context "without both" do
-        it "returns an empty array" do
-          resource.lang
-          resource.lc_env
-          expect(provider.unavailable_locales).to eq([])
-        end
-      end
-    end
-
-    context "when some locales are not available" do
-      context "with both properties" do
-        it "returns list" do
-          resource.lang("de_DE")
-          resource.lc_env({ "LC_TIME" => "en_AG.utf8", "LC_MESSAGES" => "en_US.utf8" })
-          expect(provider.unavailable_locales).to eq(["de_DE", "en_US.utf8"])
-        end
-      end
-      context "without lang" do
-        it "returns list" do
-          resource.lang
-          resource.lc_env({ "LC_TIME" => "en_AG.utf8", "LC_MESSAGES" => "en_US.utf8" })
-          expect(provider.unavailable_locales).to eq(["en_US.utf8"])
-        end
-      end
-      context "without lc_env" do
-        it "returns list" do
-          resource.lang("de_DE")
-          resource.lc_env
-          expect(provider.unavailable_locales).to eq(["de_DE"])
-        end
-      end
-      context "without both" do
-        it "returns an empty array" do
-          resource.lang
-          resource.lc_env
-          expect(provider.unavailable_locales).to eq([])
-        end
-      end
-    end
-  end
-
-  describe "#new_content" do
-    context "with both properties" do
-      before do
-        resource.lang("en_US")
-        resource.lc_env({ "LC_TIME" => "en_AG.utf8", "LC_MESSAGES" => "en_AG.utf8" })
-      end
-      it "returns string" do
-        expect(provider.new_content).to be_a(String)
-        expect(provider.new_content).not_to be_empty
-      end
-      it "keys will be sorted" do
-        expect(provider.new_content.split("\n").map { |x| x.split("=") }.collect(&:first)).to eq(%w{LANG LC_MESSAGES LC_TIME})
-      end
-      it "ends with a new-line character" do
-        expect(provider.new_content[-1]).to eq("\n")
-      end
-      it "returns a valid string" do
-        expect(provider.new_content).to eq("LANG=en_US\nLC_MESSAGES=en_AG.utf8\nLC_TIME=en_AG.utf8\n")
-      end
-    end
-    context "without lang" do
-      it "returns a valid string" do
-        resource.lang
-        resource.lc_env({ "LC_TIME" => "en_AG.utf8", "LC_MESSAGES" => "en_AG.utf8" })
-        expect(provider.new_content).to eq("LC_MESSAGES=en_AG.utf8\nLC_TIME=en_AG.utf8\n")
-      end
-    end
-    context "without lc_env" do
-      it "returns a valid string" do
-        resource.lang("en_US")
-        resource.lc_env
-        expect(provider.new_content).to eq("LANG=en_US\n")
-      end
-    end
-    context "without both" do
-      it "returns string with only new-line character" do
-        resource.lang
-        resource.lc_env
-        expect(provider.new_content).to eq("\n")
-      end
-    end
-  end
-end

data/spec/unit/resource/log_spec.rb

@@ -1,64 +0,0 @@
-#
-# Author:: Cary Penniman (<cary@rightscale.com>)
-# 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::Log do
-
-  let(:log_str) { "this is my string to log" }
-  let(:resource) { Chef::Resource::Log.new(log_str) }
-
-  it "has a name of log" do
-    expect(resource.resource_name).to eq(:log)
-  end
-
-  it "the message property is the name_property" do
-    expect(resource.message).to eql("this is my string to log")
-  end
-
-  it "sets the default action as :write" do
-    expect(resource.action).to eql([:write])
-  end
-
-  it "supports :write action" do
-    expect { resource.action :write }.not_to raise_error
-  end
-
-  it "accepts a string for the log message" do
-    resource.message "this is different"
-    expect(resource.message).to eq("this is different")
-  end
-
-  it "accepts a vaild level option" do
-    resource.level :debug
-    resource.level :info
-    resource.level :warn
-    resource.level :error
-    resource.level :fatal
-    expect { resource.level :unsupported }.to raise_error(ArgumentError)
-  end
-
-  describe "when the identity is defined" do
-    let(:resource) { Chef::Resource::Log.new("ery day I'm loggin-in") }
-
-    it "returns the log string as its identity" do
-      expect(resource.identity).to eq("ery day I'm loggin-in")
-    end
-  end
-end

data/spec/unit/resource/macos_pkg_spec.rb

@@ -1,38 +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::MacosPkg do
-  let(:resource) { Chef::Resource::MacosPkg.new("fakey_fakerton") }
-
-  it "has a resource name of :macos_pkg" do
-    expect(resource.resource_name).to eql(:macos_pkg)
-  end
-
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
-  end
-
-  it "supports :install action" do
-    expect { resource.action :install }.not_to raise_error
-  end
-
-  it "target property defaults to /" do
-    expect(resource.target).to eql("/")
-  end
-end

data/spec/unit/resource/macos_user_defaults_spec.rb

@@ -1,76 +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::MacosUserDefaults, :macos_only do
-  let(:test_value) { "fakest_key_value" }
-  let(:test_key) { "fakest_key" }
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) {
-    Chef::Resource::MacosUserDefaults.new("foo", run_context).tap do |r|
-      r.value test_value
-      r.key test_key
-    end
-  }
-
-  context "has a default value" do
-    it ":macos_userdefaults for resource name" do
-      expect(resource.resource_name).to eq(:macos_userdefaults)
-    end
-
-    it "NSGlobalDomain for the domain property" do
-      expect(resource.domain).to eq("NSGlobalDomain")
-    end
-
-    it ":all for the host property" do
-      expect(resource.host).to eq(:all)
-    end
-
-    it ":current for the user property" do
-      expect(resource.user).to eq(:current)
-    end
-
-    it ":write for resource action" do
-      expect(resource.action).to eq([:write])
-    end
-  end
-
-  context ":write" do
-    it "is a supported action" do
-      expect { resource.action :write }.not_to raise_error
-    end
-
-    it "successfully updates the preference" do
-      resource.run_action(:write)
-      expect(resource.get_preference resource).eql? test_value
-    end
-  end
-
-  context ":delete" do
-    it "is a supported action" do
-      expect { resource.action :delete }.not_to raise_error
-    end
-
-    it "successfully deletes the preference" do
-      resource.run_action(:delete)
-      expect(resource.get_preference resource).to be_nil
-    end
-  end
-end

data/spec/unit/resource/macosx_service.rb

@@ -1,37 +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::MacosxService do
-  let(:resource) { Chef::Resource::MacosxService.new("chef") }
-
-  it "sets the resource_name to :macosx_service" do
-    expect(resource.resource_name).to eql(:macosx_service)
-  end
-
-  it "accepts a String for the session_type property" do
-    resource.session_type "foo"
-    expect(resource.session_type).to eql("foo")
-  end
-
-  it "accepts a String for the plist property" do
-    resource.plist "foo"
-    expect(resource.plist).to eql("foo")
-  end
-end

data/spec/unit/resource/macports_package_spec.rb

@@ -1,51 +0,0 @@
-#
-# Author:: David Balatero (<dbalatero@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"
-require "support/shared/unit/resource/static_provider_resolution"
-
-describe Chef::Resource::MacportsPackage, "initialize" do
-
-  static_provider_resolution(
-    resource: Chef::Resource::MacportsPackage,
-    provider: Chef::Provider::Package::Macports,
-    name: :macports_package,
-    action: :install,
-    os: "mac_os_x"
-  )
-
-end
-
-describe Chef::Resource::MacportsPackage, "defaults" do
-  let(:resource) { Chef::Resource::MacportsPackage.new("foo") }
-
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
-  end
-
-  it "supports :install, :lock, :purge, :reconfig, :remove, :unlock, :upgrade actions" do
-    expect { resource.action :install }.not_to raise_error
-    expect { resource.action :lock }.not_to raise_error
-    expect { resource.action :purge }.not_to raise_error
-    expect { resource.action :reconfig }.not_to raise_error
-    expect { resource.action :remove }.not_to raise_error
-    expect { resource.action :unlock }.not_to raise_error
-    expect { resource.action :upgrade }.not_to raise_error
-  end
-
-end

data/spec/unit/resource/mdadm_spec.rb

@@ -1,104 +0,0 @@
-#
-# Author:: Joe Williams (<joe@joetify.com>)
-# Author:: Tyler Cloke (<tyler@chef.io>)
-# Copyright:: Copyright 2009-2016, Joe Williams
-# 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::Mdadm do
-
-  let(:resource) { Chef::Resource::Mdadm.new("fakey_fakerton") }
-
-  it "has a resource name of :mdadm" do
-    expect(resource.resource_name).to eql(:mdadm)
-  end
-
-  it "the raid_device property is the name_property" do
-    expect(resource.raid_device).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :create" do
-    expect(resource.action).to eql([:create])
-  end
-
-  it "supports :assemble, :create, :stop actions" do
-    expect { resource.action :assemble }.not_to raise_error
-    expect { resource.action :create }.not_to raise_error
-    expect { resource.action :stop }.not_to raise_error
-  end
-
-  it "allows you to set the raid_device property" do
-    resource.raid_device "/dev/md3"
-    expect(resource.raid_device).to eql("/dev/md3")
-  end
-
-  it "allows you to set the chunk property" do
-    resource.chunk 256
-    expect(resource.chunk).to eql(256)
-  end
-
-  it "allows you to set the level property" do
-    resource.level 1
-    expect(resource.level).to eql(1)
-  end
-
-  it "allows you to set the metadata property" do
-    resource.metadata "1.2"
-    expect(resource.metadata).to eql("1.2")
-  end
-
-  it "allows you to set the bitmap property" do
-    resource.bitmap "internal"
-    expect(resource.bitmap).to eql("internal")
-  end
-
-  it "allows you to set the layout property" do
-    resource.layout "f2"
-    expect(resource.layout).to eql("f2")
-  end
-
-  it "allows you to set the devices property" do
-    resource.devices ["/dev/sda", "/dev/sdb"]
-    expect(resource.devices).to eql(["/dev/sda", "/dev/sdb"])
-  end
-
-  it "allows you to set the exists property" do
-    resource.exists true
-    expect(resource.exists).to eql(true)
-  end
-
-  describe "when it has devices, level, and chunk" do
-    before do
-      resource.raid_device("raider")
-      resource.devices(%w{device1 device2})
-      resource.level(1)
-      resource.chunk(42)
-    end
-
-    it "describes its state" do
-      state = resource.state_for_resource_reporter
-      expect(state[:devices]).to eql(%w{device1 device2})
-      expect(state[:level]).to eq(1)
-      expect(state[:chunk]).to eq(42)
-    end
-
-    it "returns the raid device as its identity" do
-      expect(resource.identity).to eq("raider")
-    end
-  end
-
-end