chef-apply 0.4.6 → 0.4.9

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

@@ -1,90 +0,0 @@
-#
-# 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/install_chef/minimum_chef_version"
-require "chef_apply/target_host"
-require "spec_helper"
-
-RSpec.describe ChefApply::Action::InstallChef::MinimumChefVersion do
-  let(:base_os) { :linux }
-  let(:version) { 14 }
-  let(:target) { instance_double(ChefApply::TargetHost, base_os: base_os, installed_chef_version: version) }
-  subject(:klass) { ChefApply::Action::InstallChef::MinimumChefVersion }
-
-  context "#check!" do
-    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 = klass.check!(target, false)
-        expect(:client_not_installed).to eq(actual)
-      end
-
-      context "when config is set to check_only" do
-        it "raises ClientNotInstalled" do
-          expect do
-            klass.check!(target, true)
-          end.to raise_error(ChefApply::Action::InstallChef::MinimumChefVersion::ClientNotInstalled)
-        end
-      end
-    end
-
-    %i{windows linux}.each do |os|
-      context "on #{os}" do
-        let(:base_os) { os }
-        [13, 14].each do |major_version|
-          context "when chef is already installed at the correct minimum Chef #{major_version} version" do
-            let(:version) { ChefApply::Action::InstallChef::MinimumChefVersion::CONSTRAINTS[os][major_version] }
-            it "should return :minimum_version_met" do
-              actual = klass.check!(target, false)
-              expect(:minimum_version_met).to eq(actual)
-            end
-          end
-        end
-      end
-    end
-
-    installed_expected = {
-      windows: {
-        Gem::Version.new("12.1.1") => ChefApply::Action::InstallChef::MinimumChefVersion::Client13Outdated,
-        Gem::Version.new("13.9.0") => ChefApply::Action::InstallChef::MinimumChefVersion::Client13Outdated,
-        Gem::Version.new("14.3.37") => ChefApply::Action::InstallChef::MinimumChefVersion::Client14Outdated,
-      },
-      linux: {
-        Gem::Version.new("12.1.1") => ChefApply::Action::InstallChef::MinimumChefVersion::Client13Outdated,
-        Gem::Version.new("13.9.0") => ChefApply::Action::InstallChef::MinimumChefVersion::Client13Outdated,
-        Gem::Version.new("14.1.0") => ChefApply::Action::InstallChef::MinimumChefVersion::Client14Outdated,
-      },
-    }
-    %i{windows linux}.each do |os|
-      context "on #{os}" do
-        let(:base_os) { os }
-        installed_expected[os].each do |installed, expected|
-          context "when chef is already installed on target at version #{installed}" do
-            let(:version) { installed }
-            it "notifies of failure and takes no further action" do
-              expect { klass.check!(target, false) }.to raise_error(expected)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/action/install_chef_spec.rb

@@ -1,164 +0,0 @@
-#
-# 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) { "linux" }
-  let(:mock_os_family) { "linux" }
-  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.mock_instance("mock://user1:password1@localhost", mock_opts)
-  end
-
-  let(:reporter) do
-    ChefApply::MockReporter.new
-  end
-
-  subject(:install) do
-    ChefApply::Action::InstallChef.new(target_host: target_host,
-                                       reporter: reporter,
-                                       check_only: false)
-  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(ChefApply::Action::InstallChef::MinimumChefVersion).to receive(:check!).with(install.target_host, false)
-          .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(ChefApply::Action::InstallChef::MinimumChefVersion).to receive(:check!).with(install.target_host, false)
-          .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(target_host).to receive(:install_package).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
-end

data/spec/unit/cli/options_spec.rb

@@ -1,75 +0,0 @@
-#
-# 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 "mixlib/cli"
-require "chef_apply/cli/options"
-require "chef-config/config"
-
-ChefApply::Config.load
-
-module ChefApply
-  module CLIOptions
-    class TestClass
-      include Mixlib::CLI
-      include ChefApply::CLI::Options
-    end
-
-    def parse(argv)
-      parse_options(argv)
-    end
-  end
-end
-
-RSpec.describe ChefApply::CLIOptions do
-  let(:klass) { ChefApply::CLIOptions::TestClass.new }
-
-  it "contains the specified options" do
-    expect(klass.options.keys).to eq(%i{
-      version
-      help
-      config_path
-      identity_file
-      ssl
-      ssl_verify
-      protocol
-      user
-      password
-      cookbook_repo_paths
-      install
-      sudo
-      sudo_command
-      sudo_password
-      sudo_options
-    })
-  end
-
-  it "persists certain CLI options back to the ChefApply::Config" do
-    # First we check the default value beforehand
-    expect(ChefApply::Config.connection.winrm.ssl).to eq(false)
-    expect(ChefApply::Config.connection.winrm.ssl_verify).to eq(true)
-    expect(ChefApply::Config.connection.default_protocol).to eq("ssh")
-    expect(ChefApply::Config.chef.cookbook_repo_paths).to_not be_empty
-    # Then we set the values and check they are changed
-    klass.parse_options(["--ssl", "--no-ssl-verify", "--protocol", "winrm", "--cookbook-repo-paths", "a,b"])
-    expect(ChefApply::Config.connection.winrm.ssl).to eq(true)
-    expect(ChefApply::Config.connection.winrm.ssl_verify).to eq(false)
-    expect(ChefApply::Config.connection.default_protocol).to eq("winrm")
-    expect(ChefApply::Config.chef.cookbook_repo_paths).to eq(%w{a b})
-  end
-
-end

data/spec/unit/cli/validation_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-require "chef_apply/error"
-require "chef_apply/cli/validation"
-
-RSpec.describe ChefApply::CLI::Validation do
-  class Validator
-    include ChefApply::CLI::Validation
-  end
-  subject { Validator.new }
-
-  context "#validate_params" do
-    OptionValidationError = ChefApply::CLI::OptionValidationError
-    it "raises an error if not enough params are specified" do
-      params = [
-        [],
-        %w{one},
-      ]
-      params.each do |p|
-        expect { subject.validate_params(p) }.to raise_error(OptionValidationError) do |e|
-          e.id == "CHEFVAL002"
-        end
-      end
-    end
-
-    it "succeeds if the second command is a valid file path" do
-      params = %w{target /some/path}
-      expect(File).to receive(:exist?).with("/some/path").and_return true
-      expect { subject.validate_params(params) }.to_not raise_error
-    end
-
-    it "succeeds if the second argument looks like a cookbook name" do
-      params = [
-        %w{target cb},
-        %w{target cb::recipe},
-      ]
-      params.each do |p|
-        expect { subject.validate_params(p) }.to_not raise_error
-      end
-    end
-
-    it "raises an error if the second argument is neither a valid path or a valid cookbook name" do
-      params = %w{target weird%name}
-      expect { subject.validate_params(params) }.to raise_error(OptionValidationError) do |e|
-        e.id == "CHEFVAL004"
-      end
-    end
-
-    it "raises an error if properties are not specified as key value pairs" do
-      params = [
-        %w{one two three four},
-        %w{one two three four=value five six=value},
-        %w{one two three non.word=value},
-      ]
-      params.each do |p|
-        expect { subject.validate_params(p) }.to raise_error(OptionValidationError) do |e|
-          e.id == "CHEFVAL003"
-        end
-      end
-    end
-  end
-  describe "#properties_from_string" do
-    it "parses properties into a hash" do
-      provided = %w{key1=value key2=1 key3=true key4=FaLsE key5=0777 key6=https://some.website key7=num1and2digit key_8=underscore key9=127.0.0.1 key10=1. key11=1.1}
-      expected = {
-        "key1" => "value",
-        "key2" => 1,
-        "key3" => true,
-        "key4" => false,
-        "key5" => "0777",
-        "key6" => "https://some.website",
-        "key7" => "num1and2digit",
-        "key_8" => "underscore",
-        "key9" => "127.0.0.1",
-        "key10" => 1.0,
-        "key11" => 1.1,
-      }
-      expect(subject.properties_from_string(provided)).to eq(expected)
-    end
-  end
-
-end

data/spec/unit/cli_spec.rb

@@ -1,475 +0,0 @@
-#
-# 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/cli"
-require "chef_apply/error"
-require "chef_apply/telemeter"
-require "chef_apply/telemeter/sender"
-require "chef_apply/ui/terminal"
-require "chef_apply/action/generate_temp_cookbook"
-require "chef_apply/action/generate_temp_cookbook/temp_cookbook"
-
-require "chef-cli/ui"
-
-RSpec.describe ChefApply::CLI do
-  subject { ChefApply::CLI.new(argv) }
-  let(:argv) { [] }
-  # TODO why isn't this mocked?
-  let(:telemetry) { ChefApply::Telemeter.instance }
-
-  before do
-    # Avoid messy object dumps in failures because subject is an object instance
-    allow(subject).to receive(:inspect).and_return("The subject instance")
-  end
-
-  describe "run" do
-    before do
-      # Catch all of the calls by default, to prevent the various
-      # startup actions from actually occuring on the workstatoin.
-      allow(telemetry).to receive(:timed_run_capture).and_yield
-      allow(subject).to receive(:perform_run)
-      allow(telemetry).to receive(:commit)
-    end
-
-    it "captures and commits the run to telemetry" do
-      expect(telemetry).to receive(:timed_run_capture)
-      expect(telemetry).to receive(:commit)
-      expect { subject.run }.to exit_with_code(0)
-    end
-
-    it "calls perform_run" do
-      expect(subject).to receive(:perform_run)
-      expect { subject.run }.to exit_with_code(0)
-    end
-
-    context "perform_run raises WrappedError" do
-      let(:e) { ChefApply::WrappedError.new(RuntimeError.new("Test"), "host") }
-
-      it "prints the error and exits" do
-        expect(subject).to receive(:perform_run).and_raise(e)
-        expect(ChefApply::UI::ErrorPrinter).to receive(:show_error).with(e)
-        expect { subject.run }.to exit_with_code(1)
-      end
-    end
-
-    context "perform_run raises SystemExit" do
-      it "exits with same exit code" do
-        expect(subject).to receive(:perform_run).and_raise(SystemExit.new(99))
-        expect { subject.run }.to exit_with_code(99)
-      end
-    end
-
-    context "perform_run raises any other exception" do
-      let(:e) { Exception.new("test") }
-
-      it "exits with code 64" do
-        expect(subject).to receive(:perform_run).and_raise(e)
-        expect(ChefApply::UI::ErrorPrinter).to receive(:dump_unexpected_error).with(e)
-        expect { subject.run }.to exit_with_code(64)
-      end
-    end
-  end
-
-  describe "#perform_run" do
-    it "parses options" do
-      expect(subject).to receive(:parse_options).with(argv)
-      subject.perform_run
-    end
-
-    context "when any error is raised" do
-      let(:e) { RuntimeError.new("Test") }
-      before do
-        allow(subject).to receive(:parse_options).and_raise(e)
-      end
-
-      it "calls handle_perform_error" do
-        expect(subject).to receive(:handle_perform_error).with(e)
-        subject.perform_run
-      end
-    end
-
-    context "when argv is empty" do
-      let(:argv) { [] }
-      it "shows the help text" do
-        expect(subject).to receive(:show_help)
-        subject.perform_run
-      end
-    end
-
-    context "when help flags are passed" do
-      %w{-h --help}.each do |flag|
-        context flag do
-          let(:argv) { [flag] }
-          it "shows the help text" do
-            expect(subject).to receive(:show_help)
-            subject.perform_run
-          end
-        end
-      end
-
-      %w{-v --version}.each do |flag|
-        context flag do
-          let(:argv) { [flag] }
-          it "shows the help text" do
-            expect(subject).to receive(:show_version)
-            subject.perform_run
-          end
-        end
-      end
-    end
-
-    context "when arguments are provided" do
-      let(:argv) { ["hostname", "resourcetype", "resourcename", "someproperty=true"] }
-      let(:target_hosts) { [double("TargetHost")] }
-      before do
-        # parse_options sets `cli_argument` - because we stub out parse_options,
-        # later calls that rely on cli_arguments will fail without this.
-        allow(subject).to receive(:cli_arguments).and_return argv
-      end
-
-      context "and they are valid" do
-        it "creates the cookbook locally and converges it" do
-          expect(subject).to receive(:parse_options)
-          expect(subject).to receive(:check_license_acceptance)
-          expect(subject).to receive(:validate_params)
-          expect(subject).to receive(:resolve_targets).and_return target_hosts
-          expect(subject).to receive(:render_cookbook_setup)
-          expect(subject).to receive(:render_converge).with(target_hosts)
-          subject.perform_run
-        end
-      end
-    end
-  end
-
-  describe "#check_license_acceptance" do
-    let(:acceptance_value) { "accept-no-persist" }
-    let(:acceptor) { instance_double(LicenseAcceptance::Acceptor) }
-
-    before do
-      ChefApply::Config.reset
-      expect(LicenseAcceptance::Acceptor).to receive(:new).with(provided: ChefApply::Config.chef.chef_license).and_return(acceptor)
-    end
-
-    it "sets the config value to the acceptance value" do
-      expect(ChefApply::Config.chef.chef_license).to eq(nil)
-      expect(acceptor).to receive(:check_and_persist).with("infra-client", "latest")
-      expect(acceptor).to receive(:acceptance_value).and_return(acceptance_value)
-      subject.check_license_acceptance
-      expect(ChefApply::Config.chef.chef_license).to eq(acceptance_value)
-    end
-
-    describe "when the user does not accept the license" do
-      it "raises a LicenseCheckFailed error" do
-        expect(ChefApply::Config.chef.chef_license).to eq(nil)
-        expect(acceptor).to receive(:check_and_persist).with("infra-client", "latest").and_raise(LicenseAcceptance::LicenseNotAcceptedError.new(nil, []))
-        expect { subject.check_license_acceptance }.to raise_error(ChefApply::LicenseCheckFailed)
-        expect(ChefApply::Config.chef.chef_license).to eq(nil)
-      end
-    end
-  end
-
-  describe "#connect_target" do
-    let(:host) { double("TargetHost", config: {}, user: "root" ) }
-    let(:reporter) { double("reporter", update: :ok, success: :ok) }
-    it "invokes do_connect with correct options" do
-      expect(subject).to receive(:do_connect)
-        .with(host, reporter)
-      subject.connect_target(host, reporter)
-    end
-  end
-
-  describe "#generate_temp_cookbook" do
-    before do
-      allow(subject).to receive(:parsed_options).and_return({ cookbook_repo_paths: "/tmp" })
-    end
-    let(:temp_cookbook) { double("TempCookbook") }
-    let(:action) { double("generator", generated_cookbook: temp_cookbook) }
-
-    context "when a resource is provided" do
-      it "gets an action via GenerateTempCookbook.from_options and executes it " do
-        expect(ChefApply::Action::GenerateTempCookbook)
-          .to receive(:from_options)
-          .with(resource_type: "user",
-                resource_name: "test", resource_properties: {})
-          .and_return(action)
-        expect(action).to receive(:run)
-        expect(subject.generate_temp_cookbook(%w{user test}, nil)).to eq temp_cookbook
-      end
-    end
-
-    context "when a recipe specifier is provided" do
-
-      it "gets an action via GenerateTempCookbook.from_options and executes it" do
-        expect(ChefApply::Action::GenerateTempCookbook)
-          .to receive(:from_options)
-          .with(recipe_spec: "mycookbook::default", cookbook_repo_paths: "/tmp")
-          .and_return(action)
-        expect(action).to receive(:run)
-        subject.generate_temp_cookbook(["mycookbook::default"], nil)
-      end
-    end
-
-    context "when generator posts event:" do
-      let(:reporter) { double("reporter") }
-      before do
-        expect(ChefApply::Action::GenerateTempCookbook)
-          .to receive(:from_options)
-          .and_return(action)
-        allow(action).to receive(:run) { |&block| block.call(event, event_args) }
-      end
-
-      context ":generating" do
-        let(:event) { :generating }
-        let(:event_args) { nil }
-        it "updates message text via reporter" do
-          expected_text = ChefApply::CLI::TS.generate_temp_cookbook.generating
-          expect(reporter).to receive(:update).with(expected_text)
-          subject.generate_temp_cookbook(%w{user jimbo}, reporter)
-        end
-      end
-
-      context ":success" do
-        let(:event) { :success }
-        let(:event_args) { [ temp_cookbook ] }
-        it "indicates success via reporter and returns the cookbook" do
-          expected_text = ChefApply::CLI::TS.generate_temp_cookbook.success
-          expect(reporter).to receive(:success).with(expected_text)
-          expect(subject.generate_temp_cookbook(%w{user jimbo}, reporter))
-            .to eq temp_cookbook
-        end
-      end
-    end
-  end
-
-  describe "#generate_local_policy" do
-    let(:reporter) { double("reporter") }
-    let(:action) { double("GenerateLocalPolicy") }
-    let(:temp_cookbook) { instance_double("TempCookbook") }
-    let(:archive_file_location) { "/temp/archive.gz" }
-
-    before do
-      allow(subject).to receive(:temp_cookbook).and_return temp_cookbook
-      allow(action).to receive(:archive_file_location).and_return archive_file_location
-    end
-    it "creates a GenerateLocalPolicy action and executes it" do
-      expect(ChefApply::Action::GenerateLocalPolicy).to receive(:new)
-        .with(cookbook: temp_cookbook)
-        .and_return(action)
-      expect(action).to receive(:run)
-      subject.generate_local_policy(reporter)
-    end
-
-    context "when generator posts an event:" do
-      before do
-        expect(ChefApply::Action::GenerateLocalPolicy).to receive(:new)
-          .with(cookbook: temp_cookbook)
-          .and_return(action)
-        allow(action).to receive(:run) { |&block| block.call(event, event_args) }
-      end
-
-      context ":generating" do
-        let(:event) { :generating }
-        let(:event_args) { nil }
-        let(:expected_msg) { ChefApply::CLI::TS.generate_local_policy.generating }
-        it "updates message text correctly via reporter" do
-          expect(reporter).to receive(:update).with(expected_msg)
-          subject.generate_local_policy(reporter)
-        end
-
-      end
-
-      context ":exporting" do
-        let(:event) { :exporting }
-        let(:event_args) { nil }
-        let(:expected_msg) { ChefApply::CLI::TS.generate_local_policy.exporting }
-        it "updates message text correctly via reporter" do
-          expect(reporter).to receive(:update).with(expected_msg)
-          subject.generate_local_policy(reporter)
-        end
-      end
-
-      context ":success" do
-        let(:event) { :success }
-        let(:expected_msg) { ChefApply::CLI::TS.generate_local_policy.success }
-        let(:event_args) { [archive_file_location] }
-        it "indicates success via reporter and returns the archive file location" do
-          expect(reporter).to receive(:success).with(expected_msg)
-          expect(subject.generate_local_policy(reporter)).to eq archive_file_location
-        end
-      end
-    end
-  end
-
-  describe "#render_cookbook_setup" do
-    let(:reporter) { instance_double(ChefApply::StatusReporter) }
-    let(:temp_cookbook) { double(ChefApply::Action::GenerateTempCookbook::TempCookbook) }
-    let(:archive_file_location) { "/path/to/archive" }
-    let(:args) { [] }
-    # before do
-    #   allow(ChefApply::UI::Terminal).to receive(:render_job).and_yield(reporter)
-    # end
-
-    it "generates the cookbook and local policy" do
-      expect(ChefApply::UI::Terminal).to receive(:render_job) do |initial_msg, job|
-        job.run(reporter)
-      end
-      expect(subject).to receive(:generate_temp_cookbook)
-        .with(args, reporter).and_return temp_cookbook
-      expect(ChefApply::UI::Terminal).to receive(:render_job) do |initial_msg, job|
-        job.run(reporter)
-      end
-      expect(subject).to receive(:generate_local_policy)
-        .with(reporter).and_return archive_file_location
-      subject.render_cookbook_setup(args)
-    end
-  end
-
-  describe "#render_converge" do
-
-    let(:reporter) { instance_double(ChefApply::StatusReporter) }
-    let(:host1) { ChefApply::TargetHost.new("ssh://host1") }
-    let(:host2) { ChefApply::TargetHost.new("ssh://host2") }
-    let(:cookbook_type) { :resource } # || :recipe
-    let(:temp_cookbook) do
-      instance_double(ChefApply::Action::GenerateTempCookbook::TempCookbook,
-        descriptor: "resource[name]",
-        from: "resource")
-    end
-    let(:archive_file_location) { "/path/to/archive" }
-
-    before do
-      allow(subject).to receive(:temp_cookbook).and_return temp_cookbook
-      allow(subject).to receive(:archive_file_location).and_return archive_file_location
-      expected_header = ChefApply::CLI::TS.converge.header(2, temp_cookbook.descriptor, temp_cookbook.from)
-      allow(ChefApply::UI::Terminal).to receive(:render_parallel_jobs) do |header, jobs|
-        expect(header).to eq expected_header
-        jobs.each { |j| j.run(reporter) }
-      end
-    end
-
-    let(:target_hosts) { [host1, host2] }
-    it "connects, installs chef, and converges for each target" do
-      target_hosts.each do |host|
-        expect(subject).to receive(:connect_target).with(host, reporter)
-        expect(subject).to receive(:install).with(host, reporter)
-        expect(subject).to receive(:converge).with(reporter, archive_file_location, host)
-      end
-      subject.render_converge(target_hosts)
-    end
-  end
-
-  describe "#install" do
-    let(:upgrading) { false }
-    let(:target_host) { double("targethost", installed_chef_version: "14.0") }
-    let(:reporter) { double("reporter") }
-    let(:action) do
-      double("ChefApply::Actions::InstallChef",
-        upgrading?: upgrading,
-        version_to_install: "14.0")
-    end
-
-    it "updates status, creates an InstallChef action and executes it" do
-      expect(reporter)
-        .to receive(:update)
-        .with(ChefApply::CLI::TS.install_chef.verifying)
-      expect(ChefApply::Action::InstallChef).to receive(:new)
-        .with(target_host: target_host, check_only: false)
-        .and_return action
-      expect(action).to receive(:run)
-      subject.install(target_host, reporter)
-    end
-
-    context "when generator posts event:" do
-      let(:event_args) { nil }
-      let(:text_context) { ChefApply::Text.status.install_chef }
-
-      before do
-        allow(ChefApply::Action::InstallChef)
-          .to receive(:new).and_return action
-        allow(action)
-          .to receive(:run) { |&block| block.call(event, event_args) }
-        allow(reporter)
-          .to receive(:update).with(ChefApply::CLI::TS.install_chef.verifying)
-      end
-
-      context ":installing" do
-        let(:event) { :installing }
-
-        context "when installer is upgrading" do
-          let(:upgrading) { true }
-          it "reports the update correctly" do
-            expect(reporter).to receive(:update).with(text_context.upgrading(target_host.installed_chef_version, action.version_to_install))
-            subject.install(target_host, reporter)
-          end
-        end
-
-        context "when installer is installing clean" do
-          let(:upgrading) { false }
-          it "reports the update correctly" do
-            expect(reporter).to receive(:update).with(text_context.installing(action.version_to_install))
-            subject.install(target_host, reporter)
-          end
-        end
-      end
-
-      context ":uploading" do
-        let(:event) { :uploading }
-        it "reports the update correctly" do
-          expect(reporter).to receive(:update).with(text_context.uploading)
-          subject.install(target_host, reporter)
-        end
-      end
-
-      context ":downloading"  do
-        let(:event) { :downloading }
-        it "reports the update correctly" do
-          expect(reporter).to receive(:update).with(text_context.downloading)
-          subject.install(target_host, reporter)
-        end
-      end
-
-      context ":already_installed" do
-        let(:event) { :already_installed }
-        it "reports the update correctly" do
-          expect(reporter).to receive(:update).with(text_context.already_present(target_host.installed_chef_version))
-          subject.install(target_host, reporter)
-        end
-      end
-
-      context ":install_complete" do
-        let(:event) { :install_complete }
-        context "when installer is upgrading" do
-          let(:upgrading) { true }
-          it "reports the update correctly" do
-            expect(reporter).to receive(:update).with(text_context.upgrade_success(target_host.installed_chef_version,
-              action.version_to_install))
-            subject.install(target_host, reporter)
-          end
-        end
-
-        context "when installer installing clean" do
-          let(:upgrading) { false }
-          it "reports the update correctly" do
-            expect(reporter).to receive(:update).with(text_context.install_success(target_host.installed_chef_version))
-            subject.install(target_host, reporter)
-          end
-        end
-      end
-    end
-  end
-end