chef 18.8.11 → 18.8.54

data/spec/unit/resource/rhsm_register_spec.rb

@@ -1,308 +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::RhsmRegister do
-
-  let(:resource) { Chef::Resource::RhsmRegister.new("foo") }
-  let(:provider) { resource.provider_for_action(:register) }
-
-  it "has a resource name of :rhsm_register" do
-    expect(resource.resource_name).to eql(:rhsm_register)
-  end
-
-  it "sets the default action as :register" do
-    expect(resource.action).to eql([:register])
-  end
-
-  it "supports :register, :unregister actions" do
-    expect { resource.action :register }.not_to raise_error
-    expect { resource.action :unregister }.not_to raise_error
-  end
-
-  it "coerces activation_key to an array" do
-    resource.activation_key "foo"
-    expect(resource.activation_key).to eql(["foo"])
-  end
-
-  describe "#katello_cert_rpm_installed?" do
-    context "when the output contains katello-ca-consumer" do
-      let(:with_katello) { double("shell_out", stdout: <<~RPM) }
-        libevent-2.0.21-4.el7.x86_64
-        gettext-libs-0.19.8.1-3.el7.x86_64
-        yum-metadata-parser-1.1.4-10.el7.x86_64
-        pyliblzma-0.5.3-11.el7.x86_64
-        python-IPy-0.75-6.el7.noarch
-        grubby-8.28-26.el7.x86_64
-        fipscheck-lib-1.4.1-6.el7.x86_64
-        centos-logos-70.0.6-3.el7.centos.noarch
-        nss-tools-3.44.0-7.el7_7.x86_64
-        katello-ca-consumer-somehostname-1.0-1.el7.x86_64
-        rpm-4.11.3-43.el7.x86_64
-        gpgme-1.3.2-5.el7.x86_64
-        libnfsidmap-0.25-19.el7.x86_64
-      RPM
-
-      it "returns true" do
-        allow(provider).to receive(:shell_out).and_return(with_katello)
-        expect(provider.katello_cert_rpm_installed?).to eq(true)
-      end
-    end
-
-    context "when the output does not contain katello-ca-consumer" do
-      let(:without_katello) { double("shell_out", stdout: "") }
-
-      it "returns false" do
-        allow(provider).to receive(:shell_out).and_return(without_katello)
-        expect(provider.katello_cert_rpm_installed?).to eq(false)
-      end
-    end
-  end
-
-  describe "#register_command" do
-    before do
-      allow(provider).to receive(:activation_key).and_return([])
-      allow(provider).to receive(:auto_attach)
-    end
-
-    context "when activation keys exist" do
-      before do
-        allow(resource).to receive(:activation_key).and_return(%w{key1 key2})
-      end
-
-      context "when no org exists" do
-        it "raises an exception" do
-          allow(resource).to receive(:organization).and_return(nil)
-          expect { provider.register_command }.to raise_error(RuntimeError)
-        end
-      end
-
-      context "when an org exists" do
-        it "returns a command containing the keys and org" do
-          allow(resource).to receive(:organization).and_return("myorg")
-
-          expect(provider.register_command).to match("--activationkey=key1 --activationkey=key2 --org=myorg")
-        end
-      end
-
-      context "when a system_name is provided" do
-        it "returns a command containing the system name" do
-          allow(resource).to receive(:organization).and_return("myorg")
-          allow(resource).to receive(:system_name).and_return("myname")
-          expect(provider.register_command).to match("--name=myname")
-        end
-      end
-
-      context "when a system_name is not provided" do
-        it "returns a command containing the system name" do
-          allow(resource).to receive(:organization).and_return("myorg")
-          allow(resource).to receive(:system_name).and_return(nil)
-          expect(provider.register_command).not_to match("--name")
-        end
-      end
-
-      context "when auto_attach is true" do
-        it "does not return a command with --auto-attach since it is not supported with activation keys" do
-          allow(resource).to receive(:organization).and_return("myorg")
-          allow(resource).to receive(:auto_attach).and_return(true)
-
-          expect(provider.register_command).not_to match("--auto-attach")
-        end
-      end
-    end
-
-    context "when username and password exist" do
-      before do
-        allow(resource).to receive(:username).and_return("myuser")
-        allow(resource).to receive(:password).and_return("mypass")
-        allow(resource).to receive(:environment)
-        allow(resource).to receive(:using_satellite_host?)
-        allow(resource).to receive(:activation_key).and_return([])
-      end
-
-      context "when auto_attach is true" do
-        it "returns a command containing --auto-attach" do
-          allow(resource).to receive(:auto_attach).and_return(true)
-
-          expect(provider.register_command).to match("--auto-attach")
-        end
-      end
-
-      context "when auto_attach is false" do
-        it "returns a command that does not contain --auto-attach" do
-          allow(resource).to receive(:auto_attach).and_return(false)
-
-          expect(provider.register_command).not_to match("--auto-attach")
-        end
-      end
-
-      context "when a system_name is provided" do
-        it "returns a command containing the system name" do
-          allow(resource).to receive(:system_name).and_return("myname")
-          expect(provider.register_command).to match("--name=myname")
-        end
-      end
-
-      context "when a server_url is provided" do
-        it "returns a command containing the server url" do
-          allow(resource).to receive(:server_url).and_return("https://fqdn.example")
-          expect(provider.register_command).to match("--serverurl=https://fqdn.example")
-        end
-      end
-
-      context "when a base_url is provided" do
-        it "returns a command containing the base url" do
-          allow(resource).to receive(:base_url).and_return("https://fqdn.example")
-          expect(provider.register_command).to match("--baseurl=https://fqdn.example")
-        end
-      end
-
-      context "when a service_level is provided" do
-        it "returns a command containing the service level" do
-          allow(resource).to receive(:service_level).and_return("None")
-          allow(resource).to receive(:auto_attach).and_return(true)
-          expect(provider.register_command).to match("--servicelevel=None")
-        end
-
-        it "raises an exception if auto_attach is not set" do
-          allow(resource).to receive(:service_level).and_return("None")
-          allow(resource).to receive(:auto_attach).and_return(nil)
-          expect { provider.register_command }.to raise_error(RuntimeError)
-        end
-      end
-
-      context "when a release is provided" do
-        it "returns a command containing the release" do
-          allow(resource).to receive(:release).and_return("8.4")
-          allow(resource).to receive(:auto_attach).and_return(true)
-          expect(provider.register_command).to match("--release=8.4")
-        end
-
-        it "raises an exception if auto_attach is not set" do
-          allow(resource).to receive(:release).and_return("8.4")
-          allow(resource).to receive(:auto_attach).and_return(nil)
-          expect { provider.register_command }.to raise_error(RuntimeError)
-        end
-      end
-
-      context "when a system_name is not provided" do
-        it "returns a command containing the system name" do
-          allow(resource).to receive(:system_name).and_return(nil)
-          expect(provider.register_command).not_to match("--name")
-        end
-      end
-
-      context "when auto_attach is nil" do
-        it "returns a command that does not contain --auto-attach" do
-          allow(resource).to receive(:auto_attach).and_return(nil)
-
-          expect(provider.register_command).not_to match("--auto-attach")
-        end
-      end
-
-      context "when environment does not exist" do
-        context "when registering to a satellite server" do
-          it "raises an exception" do
-            allow(provider).to receive(:using_satellite_host?).and_return(true)
-            allow(resource).to receive(:environment).and_return(nil)
-            expect { provider.register_command }.to raise_error(RuntimeError)
-          end
-        end
-
-        context "when registering to RHSM proper" do
-          before do
-            allow(provider).to receive(:using_satellite_host?).and_return(false)
-            allow(resource).to receive(:environment).and_return(nil)
-          end
-
-          it "does not raise an exception" do
-            expect { provider.register_command }.not_to raise_error
-          end
-
-          it "returns a command containing the username and password and no environment" do
-            allow(resource).to receive(:environment).and_return("myenv")
-            expect(provider.register_command).to match("--username=myuser --password=mypass")
-            expect(provider.register_command).not_to match("--environment")
-          end
-        end
-      end
-
-      context "when an environment exists" do
-        it "returns a command containing the username, password, and environment" do
-          allow(provider).to receive(:using_satellite_host?).and_return(true)
-          allow(resource).to receive(:environment).and_return("myenv")
-          expect(provider.register_command).to match("--username=myuser --password=mypass --environment=myenv")
-        end
-      end
-    end
-
-    context "when no activation keys, username, or password exist" do
-      it "raises an exception" do
-        allow(resource).to receive(:activation_key).and_return([])
-        allow(resource).to receive(:username).and_return(nil)
-        allow(resource).to receive(:password).and_return(nil)
-
-        expect { provider.register_command }.to raise_error(RuntimeError)
-      end
-    end
-  end
-
-  describe "#ca_consumer_package_source" do
-    let(:satellite_host) { "sat-host" }
-
-    before do
-      resource.satellite_host = satellite_host
-    end
-
-    context "when https_for_ca_consumer is true" do
-      before { resource.https_for_ca_consumer true }
-
-      it "returns url with https" do
-        expect(provider.ca_consumer_package_source).to eq("https://#{satellite_host}/pub/katello-ca-consumer-latest.noarch.rpm")
-      end
-    end
-
-    context "when https_for_ca_consumer is false" do
-      before { resource.https_for_ca_consumer false }
-
-      it "returns url with http" do
-        expect(provider.ca_consumer_package_source).to eq("http://#{satellite_host}/pub/katello-ca-consumer-latest.noarch.rpm")
-      end
-    end
-  end
-
-  describe "#registered_with_rhsm?" do
-    context "when the status is Unknown" do
-      let(:unknown_status) { double("shell_out", stdout: "Overall Status: Unknown") }
-
-      it "returns false" do
-        allow(provider).to receive(:shell_out).and_return(unknown_status)
-        expect(provider.registered_with_rhsm?).to eq(false)
-      end
-    end
-
-    context "when the status is anything else" do
-      let(:known_status) { double("shell_out", stdout: "Overall Status: Insufficient") }
-
-      it "returns true" do
-        allow(provider).to receive(:shell_out).and_return(known_status)
-        expect(provider.registered_with_rhsm?).to eq(true)
-      end
-    end
-  end
-end

data/spec/unit/resource/rhsm_repo_spec.rb

@@ -1,70 +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::RhsmRepo do
-
-  let(:resource) { Chef::Resource::RhsmRepo.new("fakey_fakerton") }
-  let(:provider) { resource.provider_for_action(:enable) }
-
-  it "has a resource name of :rhsm_repo" do
-    expect(resource.resource_name).to eql(:rhsm_repo)
-  end
-
-  it "the repo_name property is the name_property" do
-    expect(resource.repo_name).to eql("fakey_fakerton")
-  end
-
-  it "sets the default action as :enable" do
-    expect(resource.action).to eql([:enable])
-  end
-
-  it "supports :disable, :enable actions" do
-    expect { resource.action :disable }.not_to raise_error
-    expect { resource.action :enable }.not_to raise_error
-  end
-
-  describe "#repo_enabled?" do
-    let(:cmd)    { double("cmd") }
-    let(:output) { "Repo ID:    repo123" }
-
-    before do
-      allow(Mixlib::ShellOut).to receive(:new).and_return(cmd)
-      allow(cmd).to receive(:run_command)
-      allow(cmd).to receive(:stdout).and_return(output)
-    end
-
-    context "when the repo provided matches the output" do
-      it "returns true" do
-        expect(provider.repo_enabled?("repo123")).to eq(true)
-      end
-    end
-
-    context "when the repo provided does not match the output" do
-      it "returns false" do
-        expect(provider.repo_enabled?("differentrepo")).to eq(false)
-      end
-    end
-
-    context "when user pass wildcard" do
-      it "returns true" do
-        expect(provider.repo_enabled?("*")).to eq(true)
-      end
-    end
-  end
-end

data/spec/unit/resource/rhsm_subscription_spec.rb

@@ -1,145 +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::RhsmSubscription do
-  let(:event_dispatch) { Chef::EventDispatch::Dispatcher.new }
-  let(:node) { Chef::Node.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, event_dispatch) }
-
-  let(:pool_id) { "8a8dd78c766232550226b46e59404aba" }
-  let(:resource) { Chef::Resource::RhsmSubscription.new(pool_id, run_context) }
-  let(:provider) { resource.provider_for_action(Array(resource.action).first) }
-
-  before do
-    allow(resource).to receive(:provider_for_action).with(:attach).and_return(provider)
-  end
-
-  it "has a resource name of :rhsm_subscription" do
-    expect(resource.resource_name).to eql(:rhsm_subscription)
-  end
-
-  it "the pool_id property is the name_property" do
-    expect(resource.pool_id).to eql(pool_id)
-  end
-
-  it "sets the default action as :attach" do
-    expect(resource.action).to eql([:attach])
-  end
-
-  it "supports :attach, :remove actions" do
-    expect { resource.action :attach }.not_to raise_error
-    expect { resource.action :remove }.not_to raise_error
-  end
-
-  describe "#action_attach" do
-    let(:yum_package_double) { instance_double("Chef::Resource::YumPackage") }
-    let(:so_double) { instance_double("Mixlib::ShellOut", stdout: "Successfully attached a subscription for: My Subscription", exitstatus: 0, error?: false) }
-
-    before do
-      allow(provider).to receive(:shell_out!).with("subscription-manager attach --pool=#{resource.pool_id}").and_return(so_double)
-      allow(provider).to receive(:build_resource).with(:package, "rhsm_subscription-#{pool_id}-flush_cache").and_return(yum_package_double)
-      allow(yum_package_double).to receive(:run_action).with(:flush_cache)
-    end
-
-    context "when already attached to pool" do
-      before do
-        allow(provider).to receive(:subscription_attached?).with(resource.pool_id).and_return(true)
-      end
-
-      it "does not attach to pool" do
-        expect(provider).not_to receive(:shell_out!)
-        resource.run_action(:attach)
-      end
-    end
-
-    context "when not attached to pool" do
-      before do
-        allow(provider).to receive(:subscription_attached?).with(resource.pool_id).and_return(false)
-      end
-
-      it "attaches to pool" do
-        expect(provider).to receive(:shell_out!).with("subscription-manager attach --pool=#{resource.pool_id}")
-        resource.run_action(:attach)
-      end
-
-      it "flushes package provider cache" do
-        expect(yum_package_double).to receive(:run_action).with(:flush_cache)
-        resource.run_action(:attach)
-      end
-    end
-  end
-
-  describe "#subscription_attached?" do
-    let(:cmd)    { double("cmd") }
-    let(:output) { "Pool ID:    pool123" }
-
-    before do
-      allow(Mixlib::ShellOut).to receive(:new).and_return(cmd)
-      allow(cmd).to receive(:run_command)
-      allow(cmd).to receive(:stdout).and_return(output)
-    end
-
-    context "when the pool provided matches the output" do
-      it "returns true" do
-        expect(provider.subscription_attached?("pool123")).to eq(true)
-      end
-    end
-
-    context "when the pool provided does not match the output" do
-      it "returns false" do
-        expect(provider.subscription_attached?("differentpool")).to eq(false)
-      end
-    end
-  end
-
-  describe "#serials_by_pool" do
-    let(:cmd) { double("cmd") }
-    let(:output) do
-      <<~EOL
-        Key1:       value1
-        Pool ID:    pool1
-        Serial:     serial1
-        Key2:       value2
-
-        Key1:       value1
-        Pool ID:    pool2
-        Serial:     serial2
-        Key2:       value2
-      EOL
-    end
-
-    it "parses the output correctly" do
-      allow(Mixlib::ShellOut).to receive(:new).and_return(cmd)
-      allow(cmd).to receive(:run_command)
-      allow(cmd).to receive(:stdout).and_return(output)
-
-      expect(provider.serials_by_pool["pool1"]).to eq("serial1")
-      expect(provider.serials_by_pool["pool2"]).to eq("serial2")
-    end
-  end
-
-  describe "#pool_serial" do
-    let(:serials) { { "pool1" => "serial1", "pool2" => "serial2" } }
-
-    it "returns the serial for a given pool" do
-      allow(provider).to receive(:serials_by_pool).and_return(serials)
-      expect(provider.pool_serial("pool1")).to eq("serial1")
-    end
-  end
-end

data/spec/unit/resource/route_spec.rb

@@ -1,100 +0,0 @@
-#
-# Author:: Bryan McLellan (btm@loftninjas.org)
-# Author:: Tyler Cloke (<tyler@chef.io>)
-# Copyright:: Copyright 2008-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::Route do
-
-  let(:resource) { Chef::Resource::Route.new("10.0.0.10") }
-
-  it "the target property is the name_property" do
-    expect(resource.target).to eql("10.0.0.10")
-  end
-
-  it "sets the default action as :add" do
-    expect(resource.action).to eql([:add])
-  end
-
-  it "supports :add, :delete actions" do
-    expect { resource.action :add }.not_to raise_error
-    expect { resource.action :delete }.not_to raise_error
-  end
-
-  it "allows you to specify the netmask" do
-    resource.netmask "255.255.255.0"
-    expect(resource.netmask).to eql("255.255.255.0")
-  end
-
-  it "allows you to specify the gateway" do
-    resource.gateway "10.0.0.1"
-    expect(resource.gateway).to eql("10.0.0.1")
-  end
-
-  it "allows you to specify the metric" do
-    resource.metric 10
-    expect(resource.metric).to eql(10)
-  end
-
-  it "allows you to specify the device" do
-    resource.device "eth0"
-    expect(resource.device).to eql("eth0")
-  end
-
-  it "allows you to specify the route type as a symbol" do
-    resource.route_type :host
-    expect(resource.route_type).to eql(:host)
-  end
-
-  it "allows you to specify the route type as a string" do
-    resource.route_type :host
-    expect(resource.route_type).to eql(:host)
-  end
-
-  it "defaults to a host route type" do
-    expect(resource.route_type).to eql(:host)
-  end
-
-  it "accepts a net route type" do
-    resource.route_type :net
-    expect(resource.route_type).to eql(:net)
-  end
-
-  it "rejects any other route_type but :host and :net" do
-    expect { resource.route_type "lolcat" }.to raise_error(ArgumentError)
-  end
-
-  describe "when it has netmask, gateway, and device" do
-    before do
-      resource.target("charmander")
-      resource.netmask("lemask")
-      resource.gateway("111.111.111")
-      resource.device("forcefield")
-    end
-
-    it "describes its state" do
-      state = resource.state_for_resource_reporter
-      expect(state[:netmask]).to eq("lemask")
-      expect(state[:gateway]).to eq("111.111.111")
-    end
-
-    it "returns the target  as its identity" do
-      expect(resource.identity).to eq("charmander")
-    end
-  end
-end

data/spec/unit/resource/rpm_package_spec.rb

@@ -1,62 +0,0 @@
-#
-# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
-# Copyright:: Copyright 2010-2016, Thomas Bishop
-# 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::RpmPackage, "initialize" do
-
-  %w{linux aix}.each do |os|
-    static_provider_resolution(
-      resource: Chef::Resource::RpmPackage,
-      provider: Chef::Provider::Package::Rpm,
-      name: :rpm_package,
-      action: :install,
-      os: os
-    )
-  end
-
-end
-
-describe Chef::Resource::RpmPackage, "allow_downgrade" do
-  let(:resource) { Chef::Resource::RpmPackage.new("foo") }
-
-  it "is a subclass of Chef::Resource::Package" do
-    expect(resource).to be_a_kind_of(Chef::Resource::Package)
-  end
-
-  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
-
-  it "allows you to specify whether allow_downgrade is true or false" do
-    expect { resource.allow_downgrade true }.not_to raise_error
-    expect { resource.allow_downgrade false }.not_to raise_error
-    expect { resource.allow_downgrade "monkey" }.to raise_error(ArgumentError)
-  end
-end