chef-apply 0.1.17 → 0.1.18

data/spec/unit/action/generate_local_policy_spec.rb

@@ -0,0 +1,114 @@
+#
+# Copyright:: Copyright (c) 2017 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_apply/action/generate_local_policy"
+require "chef-dk/policyfile_services/install"
+require "chef-dk/ui"
+require "chef-dk/policyfile_services/export_repo"
+
+RSpec.describe ChefApply::Action::GenerateLocalPolicy do
+  subject { ChefApply::Action::GenerateLocalPolicy.new(cookbook: cookbook) }
+  let(:cookbook) do
+    double("TempCookbook",
+           path: "/my/temp/cookbook",
+           export_path: "/my/temp/cookbook/export",
+           policyfile_lock_path: "/my/temp/cookbook/policyfile.lock")
+  end
+
+  let(:installer_double) do
+    instance_double(ChefDK::PolicyfileServices::Install, run: :ok)
+  end
+
+  let(:exporter_double) do
+    instance_double(ChefDK::PolicyfileServices::ExportRepo,
+                    archive_file_location: "/path/to/export",
+                    run: :ok)
+  end
+
+  before do
+    allow(subject).to receive(:notify)
+  end
+
+  describe "#perform_action" do
+    context "in the normal case" do
+      it "exports the policy notifying caller of progress, setting archive_file_location" do
+        expect(subject).to receive(:notify).ordered.with(:generating)
+        expect(subject).to receive(:installer).ordered.and_return installer_double
+        expect(installer_double).to receive(:run).ordered
+        expect(subject).to receive(:notify).ordered.with(:exporting)
+        expect(subject).to receive(:exporter).ordered.and_return exporter_double
+        expect(exporter_double).to receive(:run).ordered
+        expect(subject).to receive(:exporter).ordered.and_return exporter_double
+        expect(subject).to receive(:notify).ordered.with(:success)
+        subject.perform_action
+        expect(subject.archive_file_location).to eq("/path/to/export")
+      end
+    end
+
+    context "when PolicyfileServices raises an error" do
+      it "reraises as PolicyfileInstallError" do
+        expect(subject).to receive(:installer).and_return installer_double
+        expect(installer_double).to receive(:run).and_raise(ChefDK::PolicyfileInstallError.new("", nil))
+        expect { subject.perform_action }.to raise_error(ChefApply::Action::PolicyfileInstallError)
+      end
+    end
+
+    context "when the path name is too long" do
+      let(:name) { "THIS_IS_A_REALLY_LONG_STRING111111111111111111111111111111111111111111111111111111" }
+
+      # There is an issue with policyfile generation where, if we have a cookbook with too long
+      # of a name or directory name the policyfile will not generate. This is because the tar
+      # library that ChefDK uses comes from the Rubygems package and is meant for packaging
+      # gems up, so it can impose a 100 character limit. We attempt to solve this by ensuring
+      # that the paths/names we generate with `TempCookbook` are short.
+      #
+      # This is here for documentation
+      # 2018-05-18 mp addendum: this cna take upwards of 15s to run on ci nodes, pending
+      # for now since it's not testing any Chef Apply functionality.
+      xit "fails to create when there is a long path name" do
+        err = ChefDK::PolicyfileExportRepoError
+        expect { subject.perform_action }.to raise_error(err) do |e|
+          expect(e.cause.class).to eq(Gem::Package::TooLongFileName)
+          expect(e.cause.message).to match(/should be 100 or less/)
+        end
+      end
+    end
+  end
+
+  describe "#exporter" do
+
+    it "returns a correctly constructed ExportRepo" do
+      expect(ChefDK::PolicyfileServices::ExportRepo).to receive(:new)
+        .with(policyfile: cookbook.policyfile_lock_path,
+              root_dir: cookbook.path,
+              export_dir:  cookbook.export_path,
+              archive: true, force: true)
+        .and_return exporter_double
+      expect(subject.exporter).to eq exporter_double
+    end
+  end
+
+  describe "#installer" do
+    it "returns a correctly constructed Install service" do
+      expect(ChefDK::PolicyfileServices::Install).to receive(:new)
+        .with(ui: ChefDK::UI, root_dir: cookbook.path)
+        .and_return(installer_double)
+      expect(subject.installer).to eq installer_double
+    end
+  end
+
+end

data/spec/unit/action/generate_temp_cookbook_spec.rb

@@ -0,0 +1,75 @@
+#
+# Copyright:: Copyright (c) 2018 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 "chef_apply/action/generate_temp_cookbook"
+
+RSpec.describe ChefApply::Action::GenerateTempCookbook do
+  let(:options) { {} }
+  subject { ChefApply::Action::GenerateTempCookbook }
+
+  describe ".from_options" do
+    context "when given options for a recipe" do
+      let(:options) { { recipe_spec: "some::recipe" } }
+      it "returns a GenerateCookbookFromRecipe action" do
+        expect(subject.from_options(options)).to be_a(ChefApply::Action::GenerateCookbookFromRecipe)
+      end
+    end
+
+    context "when given options for a resource" do
+      let(:resource_properties) { {} }
+      let(:options) do
+        { resource_name: "user1", resource_type: "user",
+          resource_properties: resource_properties } end
+
+      it "returns a GenerateCookbookFromResource action" do
+        expect(subject.from_options(options)).to be_a ChefApply::Action::GenerateCookbookFromResource
+      end
+    end
+
+    context "when not given sufficient options for either" do
+      let(:options) { {} }
+      it "raises MissingOptions" do
+        expect { subject.from_options(options) }.to raise_error ChefApply::Action::MissingOptions
+      end
+    end
+
+  end
+
+  describe "#perform_action" do
+    subject { ChefApply::Action::GenerateTempCookbook.new( {} ) }
+    it "generates a cookbook, notifies caller, and makes the cookbook available" do
+
+      expect(subject).to receive(:notify).ordered.with(:generating)
+      expect(subject).to receive(:generate)
+      expect(subject).to receive(:notify).ordered.with(:success)
+      subject.perform_action
+      expect(subject.generated_cookbook).to_not be nil
+    end
+
+  end
+
+end
+
+RSpec.describe ChefApply::Action::GenerateCookbookFromRecipe do
+  describe "#generate" do
+  end
+end
+
+RSpec.describe ChefApply::Action::GenerateCookbookFromResource do
+  describe "#generate" do
+  end
+end

data/spec/unit/action/install_chef/base_spec.rb

@@ -0,0 +1,234 @@
+#
+# Copyright:: Copyright (c) 2018 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_apply/action/install_chef"
+require "chef_apply/target_host"
+
+RSpec.describe ChefApply::Action::InstallChef::Base do
+  let(:mock_os_name) { "mock" }
+  let(:mock_os_family) { "mock" }
+  let(:mock_os_release ) { "unknown" }
+  let(:mock_opts) do
+    {
+      name: mock_os_name,
+      family: mock_os_family,
+      release: mock_os_release,
+      arch: "x86_64",
+    }
+  end
+  let(:target_host) do
+    ChefApply::TargetHost.new("mock://user1:password1@localhost")
+  end
+
+  let(:reporter) do
+    ChefApply::MockReporter.new
+  end
+
+  subject(:install) do
+    ChefApply::Action::InstallChef::Base.new(target_host: target_host,
+                                             reporter: reporter) end
+  before do
+    target_host.connect!
+    target_host.backend.mock_os(mock_opts)
+  end
+
+  context "#perform_action" do
+    context "when chef is already installed on target" do
+      it "notifies of success and takes no further action" do
+        expect(install).to receive(:check_minimum_chef_version!).with(install.target_host)
+                       .and_return(:minimum_version_met)
+        expect(install).not_to receive(:perform_local_install)
+        install.perform_action
+      end
+    end
+
+    context "when chef is not already installed on target" do
+      it "should invoke perform_local_install" do
+        expect(install).to receive(:check_minimum_chef_version!).with(install.target_host)
+                       .and_return(:client_not_installed)
+        expect(install).to receive(:perform_local_install)
+        install.perform_action
+      end
+    end
+  end
+
+  context "#perform_local_install" do
+    let(:artifact) { double("artifact") }
+    let(:package_url) { "https://chef.io/download/package/here" }
+    before do
+      allow(artifact).to receive(:url).and_return package_url
+    end
+
+    it "performs the steps necessary to perform an installation" do
+      expect(install).to receive(:lookup_artifact).and_return artifact
+      expect(install).to receive(:download_to_workstation).with(package_url) .and_return "/local/path"
+      expect(install).to receive(:upload_to_target).with("/local/path").and_return("/remote/path")
+      expect(install).to receive(:install_chef_to_target).with("/remote/path")
+
+      install.perform_local_install
+    end
+  end
+
+  context "#train_to_mixlib" do
+    let(:platform) { double }
+    before do
+      allow(platform).to receive(:release).and_return "1234"
+      allow(platform).to receive(:name).and_return "beos"
+      allow(platform).to receive(:arch).and_return "ppc"
+    end
+
+    context "when any flavor of windows" do
+      before do
+        allow(platform).to receive(:name).and_return "windows_10_pro_n"
+      end
+
+      it "sets platform name to 'windows'" do
+        mixlib_info = install.train_to_mixlib(platform)
+        expect(mixlib_info[:platform]).to eq "windows"
+      end
+    end
+
+    context "when redhat" do
+      before do
+        allow(platform).to receive(:name).and_return "redhat"
+      end
+
+      it "sets platform name to 'el'" do
+        mixlib_info = install.train_to_mixlib(platform)
+        expect(mixlib_info[:platform]).to eq "el"
+      end
+    end
+
+    context "when centos" do
+      before do
+        allow(platform).to receive(:name).and_return "centos"
+      end
+
+      it "sets platform name to 'el'" do
+        mixlib_info = install.train_to_mixlib(platform)
+        expect(mixlib_info[:platform]).to eq "el"
+      end
+    end
+
+    context "when suse" do
+      before do
+        allow(platform).to receive(:name).and_return "suse"
+      end
+
+      it "sets platform name to 'sles'" do
+        mixlib_info = install.train_to_mixlib(platform)
+        expect(mixlib_info[:platform]).to eq "sles"
+      end
+    end
+    context "when amazon" do
+      before do
+        allow(platform).to receive(:name).and_return "amazon"
+      end
+
+      context "when amazon linux 1.x" do
+        before do
+          allow(platform).to receive(:release).and_return "2017.09"
+        end
+
+        it "sets platform name to 'amazon' and plaform_version to '6'" do
+          mixlib_info = install.train_to_mixlib(platform)
+          expect(mixlib_info[:platform]).to eq "el"
+          expect(mixlib_info[:platform_version]).to eq "6"
+        end
+      end
+      context "when amazon linux 2.x" do
+        before do
+          allow(platform).to receive(:release).and_return "2"
+        end
+
+        it "sets platform name to 'amazon' and plaform_version to '7'" do
+          mixlib_info = install.train_to_mixlib(platform)
+          expect(mixlib_info[:platform]).to eq "el"
+          expect(mixlib_info[:platform_version]).to eq "7"
+        end
+      end
+    end
+  end
+
+  context "#check_minimum_chef_version!" do
+    let(:target) { install.target_host }
+    context "when chef is not already installed on target" do
+      before do
+        expect(target).to receive(:installed_chef_version).
+          and_raise ChefApply::TargetHost::ChefNotInstalled.new
+      end
+
+      it "should return :client_not_installed" do
+        actual = install.check_minimum_chef_version!(target)
+        expect(:client_not_installed).to eq(actual)
+      end
+
+      context "when config is set to check_only" do
+        after do
+          install.config.clear
+        end
+
+        it "raises ClientNotInstalled" do
+          install.config[:check_only] = true
+          expect do
+            install.check_minimum_chef_version!(target)
+          end.to raise_error(ChefApply::Action::InstallChef::ClientNotInstalled)
+        end
+      end
+    end
+
+    min_14_version = ChefApply::Action::InstallChef::Base::MIN_14_VERSION
+    min_13_version = ChefApply::Action::InstallChef::Base::MIN_13_VERSION
+    context "when chef is already installed on target at the correct minimum Chef 14 version" do
+      before do
+        expect(target).to receive(:installed_chef_version).and_return min_14_version
+      end
+      it "should return :minimum_version_met" do
+        actual = install.check_minimum_chef_version!(target)
+        expect(:minimum_version_met).to eq(actual)
+      end
+    end
+
+    context "when chef is already installed on target at the correct minimum Chef 13 version" do
+      before do
+        expect(target).to receive(:installed_chef_version).and_return min_13_version
+      end
+      it "should return :minimum_version_met" do
+        actual = install.check_minimum_chef_version!(target)
+        expect(:minimum_version_met).to eq(actual)
+      end
+    end
+
+    installed_expected = {
+      Gem::Version.new("12.1.1") => ChefApply::Action::InstallChef::Client13Outdated,
+      Gem::Version.new("13.9.0") => ChefApply::Action::InstallChef::Client13Outdated,
+      Gem::Version.new("14.1.0") => ChefApply::Action::InstallChef::Client14Outdated,
+    }
+    installed_expected.each do |installed, expected|
+      context "when chef is already installed on target at version #{installed}" do
+        before do
+          expect(target).to receive(:installed_chef_version).
+            and_return installed
+        end
+        it "notifies of failure and takes no further action" do
+          expect { install.check_minimum_chef_version!(target) }.to raise_error(expected)
+        end
+      end
+    end
+  end
+end

data/spec/unit/action/install_chef_spec.rb

@@ -0,0 +1,69 @@
+#
+# Copyright:: Copyright (c) 2018 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_apply/action/install_chef"
+
+RSpec.describe ChefApply::Action::InstallChef do
+  let(:mock_os_name) { "mock" }
+  let(:mock_os_family) { "mock" }
+  let(:mock_os_release ) { "unknown" }
+  let(:mock_opts) do
+    {
+      name: mock_os_name,
+      family: mock_os_family,
+      release: mock_os_release,
+      arch: "x86_64",
+    }
+  end
+  let(:target_host) do
+    ChefApply::TargetHost.new("mock://user1:password1@localhost")
+  end
+
+  subject(:installer) do
+    ChefApply::Action::InstallChef
+  end
+
+  before do
+    target_host.connect!
+    target_host.backend.mock_os(mock_opts)
+  end
+
+  context ".instance_for_target" do
+    context "windows target" do
+      let(:mock_os_name) { "Windows_Server" }
+      let(:mock_os_family) { "windows" }
+      let(:mock_os_release) { "10.0.0" }
+
+      it "should return a InstallChef::Windows instance" do
+        inst = installer.instance_for_target(target_host)
+        expect(inst).to be_a installer::Windows
+      end
+    end
+
+    context "linux target" do
+      let(:mock_os_name) { "ubuntu" }
+      let(:mock_os_family) { "debian" }
+      let(:mock_os_release) { "16.04" }
+
+      it "should return a InstallChef::Linux instance" do
+        inst = installer.instance_for_target(target_host)
+        expect(inst).to be_a installer::Linux
+      end
+    end
+  end
+end