chef-apply 0.1.17 → 0.1.18

data/spec/unit/config_spec.rb

@@ -0,0 +1,70 @@
+#
+# 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/config"
+
+RSpec.describe ChefApply::Config do
+  subject(:config) do
+    ChefApply::Config
+  end
+
+  before(:each) do
+    ChefApply::Config.reset
+  end
+
+  it "raises an error when trying to specify non-existing config location" do
+    expect { config.custom_location("/does/not/exist") }.to raise_error(RuntimeError, /No config file/)
+  end
+
+  it "should use default location by default" do
+    expect(config.using_default_location?).to eq(true)
+  end
+
+  context "when there is a custom config" do
+    let(:custom_config) { File.expand_path("../../fixtures/custom_config.toml", __FILE__) }
+
+    it "successfully loads the config" do
+      config.custom_location(custom_config)
+      expect(config.using_default_location?).to eq(false)
+      expect(config.exist?).to eq(true)
+      config.load
+      expect(config.telemetry.dev).to eq(true)
+    end
+  end
+  describe "#load" do
+    before do
+      expect(subject).to receive(:exist?).and_return(exists)
+    end
+
+    context "when the config file exists" do
+      let(:exists) { true }
+      it "loads the file" do
+        expect(subject).to receive(:from_file)
+        subject.load
+      end
+    end
+
+    context "when the config file does not exist" do
+      let(:exists) { false }
+      it "does not try to load the file" do
+        expect(subject).to_not receive(:from_file)
+        subject.load
+      end
+    end
+  end
+end

data/spec/unit/errors/ccr_failure_mapper_spec.rb

@@ -0,0 +1,103 @@
+#
+# 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/errors/ccr_failure_mapper"
+
+RSpec.describe ChefApply::Errors::CCRFailureMapper do
+  let(:cause_line) { nil }
+  let(:resource) { "apt_package" }
+  let(:params) do
+    { resource: resource, resource_name: "a-test-thing",
+      stderr: "an error", stdout: "other output" }
+  end
+  subject { ChefApply::Errors::CCRFailureMapper.new(cause_line, params) }
+
+  describe "#exception_args_from_cause" do
+    context "when resource properties have valid names but invalid values" do
+      context "and the property is 'action'" do
+        let(:cause_line) { "Chef::Exceptions::ValidationFailed: Option action must be equal to one of: nothing, install, upgrade, remove, purge, reconfig, lock, unlock!  You passed :marve." }
+        it "returns a correct CHEFCCR003" do
+          expect(subject.exception_args_from_cause).to eq(
+            ["CHEFCCR003", "marve",
+             "nothing, install, upgrade, remove, purge, reconfig, lock, unlock"]
+          )
+        end
+      end
+
+      context "and the property is something else" do
+        context "and details are available" do
+          let(:cause_line) { "Chef::Exceptions::ValidationFailed: Option force must be a kind of [TrueClass, FalseClass]!  You passed \"purle\"." }
+          it "returns a correct CHEFCCR004 when details are available" do
+            expect(subject.exception_args_from_cause).to eq(
+              ["CHEFCCR004",
+               "Option force must be a kind of [TrueClass, FalseClass]!  You passed \"purle\"."])
+          end
+        end
+        context "And less detail is available" do
+          let(:cause_line) { "Chef::Exceptions::User: linux_user[marc] ((chef-client cookbook)::(chef-client recipe) line 1) had an error: Chef::Exceptions::User: Couldn't lookup integer GID for group name blah" }
+          it "returns a correct CHEFCCR002" do
+            expect(subject.exception_args_from_cause).to eq(
+              ["CHEFCCR002", "Couldn't lookup integer GID for group name blah"])
+          end
+        end
+      end
+    end
+
+    context "when resource is not a known Chef resource" do
+      let(:cause_line) { "NoMethodError: undefined method `useraaa' for cookbook: (chef-client cookbook), recipe: (chef-client recipe) :Chef::Recipe" }
+      let(:resource) { "useraaa" }
+      it "returns a correct CHEFCCR005" do
+        expect(subject.exception_args_from_cause).to eq(["CHEFCCR005", resource])
+      end
+    end
+
+    context "when a resource property does not exist for the given resource" do
+      let(:cause_line) { "NoMethodError: undefined method `badresourceprop' for Chef::Resource::User::LinuxUser" }
+      it "returns a correct CHEFCCR006 " do
+        expect(subject.exception_args_from_cause).to eq(
+          ["CHEFCCR006", "badresourceprop", "Chef::Resource::User::LinuxUser"])
+      end
+    end
+  end
+
+  describe "#raise_mapped_exception!" do
+    context "when no cause is provided" do
+      let(:cause_line) { nil }
+      it "raises a RemoteChefRunFailedToResolveError" do
+        expect { subject.raise_mapped_exception! }.to raise_error(ChefApply::Errors::CCRFailureMapper::RemoteChefRunFailedToResolveError)
+
+      end
+    end
+
+    context "when a cause is provided" do
+      context "but can't resolve it" do
+        let(:cause_line) { "unparseable mess" }
+        it "raises a RemoteChefClientRunFailedUnknownReason" do
+          expect { subject.raise_mapped_exception! }.to raise_error(ChefApply::Errors::CCRFailureMapper::RemoteChefClientRunFailedUnknownReason)
+        end
+      end
+
+      context "and can resolve the cause" do
+        let(:cause_line) { "NoMethodError: undefined method `badresourceprop' for Chef::Resource::User::LinuxUser" }
+        it "raises a RemoteChefClientRunFailed" do
+          expect { subject.raise_mapped_exception! }.to raise_error(ChefApply::Errors::CCRFailureMapper::RemoteChefClientRunFailed)
+        end
+      end
+    end
+  end
+end

data/spec/unit/file_fetcher_spec.rb

@@ -0,0 +1,40 @@
+#
+# 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/file_fetcher"
+require "spec_helper"
+
+RSpec.describe ChefApply::FileFetcher do
+  let(:expected_local_location) { File.join(ChefApply::Config.cache.path, "example.txt") }
+  subject { ChefApply::FileFetcher }
+  describe ".fetch" do
+    it "returns the local path when the file is cached" do
+      allow(FileUtils).to receive(:mkdir)
+      expect(File).to receive(:exist?).with(expected_local_location).and_return(true)
+      result = subject.fetch("https://example.com/example.txt")
+      expect(result).to eq expected_local_location
+    end
+
+    it "returns the local path when the file is fetched" do
+      allow(FileUtils).to receive(:mkdir)
+      expect(File).to receive(:exist?).with(expected_local_location).and_return(false)
+      expect(subject).to receive(:download_file)
+      result = subject.fetch("https://example.com/example.txt")
+      expect(result).to eq expected_local_location
+    end
+  end
+end

data/spec/unit/fixtures/multi-error.out

@@ -0,0 +1,2 @@
+Host: host1 Error: CHEFUPL005: Uploading policy bundle to target failed.
+Host: host2 : An unexpected error has occurred: Hello World

data/spec/unit/log_spec.rb

@@ -0,0 +1,37 @@
+#
+# 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/log"
+
+RSpec.describe ChefApply::Log do
+  Log = ChefApply::Log
+  let(:output) { StringIO.new }
+
+  before do
+    Log.setup output, :debug
+  end
+
+  after do
+    Log.setup "/dev/null", :error
+  end
+
+  it "correctly logs to stdout" do
+    Log.debug("test")
+    expect(output.string).to match(/DEBUG: test$/)
+  end
+end

data/spec/unit/recipe_lookup_spec.rb

@@ -0,0 +1,122 @@
+#
+# 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/recipe_lookup"
+require "chef/exceptions"
+require "chef/cookbook/cookbook_version_loader"
+require "chef/cookbook_version"
+require "chef/cookbook_loader"
+
+RSpec.describe ChefApply::RecipeLookup do
+  let(:repo_path) { "repo_path" }
+  subject(:rp) { ChefApply::RecipeLookup.new([repo_path]) }
+  VL = Chef::Cookbook::CookbookVersionLoader
+  let(:version_loader) { instance_double(VL) }
+  let(:cookbook_version) { instance_double(Chef::CookbookVersion, root_dir: "dir", name: "name") }
+  let(:cookbook_loader) { instance_double(Chef::CookbookLoader, load_cookbooks_without_shadow_warning: nil) }
+
+  describe "#split" do
+    it "splits a customer provided specifier into a cookbook part and possible recipe part" do
+      expect(rp.split("/some/path")).to eq(%w{/some/path})
+      expect(rp.split("cookbook::recipe")).to eq(%w{cookbook recipe})
+    end
+  end
+
+  describe "#load_cookbook" do
+    context "when a directory is provided" do
+      let(:recipe_specifier) { "/some/directory" }
+      let(:default_recipe) { File.join(recipe_specifier, "default.rb") }
+      let(:recipes_by_name) { { "default" => default_recipe } }
+      before do
+        expect(File).to receive(:directory?).with(recipe_specifier).and_return(true)
+        expect(VL).to receive(:new).with(recipe_specifier).and_return(version_loader)
+      end
+
+      it "loads the cookbook and returns the path to the default recipe" do
+        expect(version_loader).to receive(:load!)
+        expect(version_loader).to receive(:cookbook_version).and_return(cookbook_version)
+        expect(rp.load_cookbook(recipe_specifier)).to eq(cookbook_version)
+      end
+
+      context "the directory is not a cookbook" do
+        it "raise an InvalidCookbook error" do
+          expect(version_loader).to receive(:load!).and_raise(Chef::Exceptions::CookbookNotFoundInRepo.new)
+          expect { rp.load_cookbook(recipe_specifier) }.to raise_error(ChefApply::RecipeLookup::InvalidCookbook)
+        end
+      end
+    end
+
+    context "when a cookbook name is provided" do
+      let(:recipe_specifier) { "cb" }
+      before do
+        expect(File).to receive(:directory?).with(recipe_specifier).and_return(false)
+        expect(Chef::CookbookLoader).to receive(:new).and_return(cookbook_loader)
+      end
+
+      context "and a cookbook in the cookbook repository exists with that name" do
+        it "returns the default cookbook" do
+          expect(cookbook_loader).to receive(:[]).with(recipe_specifier).and_return(cookbook_version)
+          expect(rp.load_cookbook(recipe_specifier)).to eq(cookbook_version)
+        end
+      end
+
+      context "and a cookbook exists but it is invalid" do
+        it "raises an InvalidCookbook error" do
+          expect(cookbook_loader).to receive(:[]).with(recipe_specifier).and_raise(Chef::Exceptions::CookbookNotFoundInRepo.new())
+          expect(File).to receive(:directory?).with(File.join(repo_path, recipe_specifier)).and_return(true)
+          expect { rp.load_cookbook(recipe_specifier) }.to raise_error(ChefApply::RecipeLookup::InvalidCookbook)
+        end
+      end
+
+      context "and a cookbook does not exist" do
+        it "raises an CookbookNotFound error" do
+          expect(cookbook_loader).to receive(:[]).with(recipe_specifier).and_raise(Chef::Exceptions::CookbookNotFoundInRepo.new())
+          expect(File).to receive(:directory?).with(File.join(repo_path, recipe_specifier)).and_return(false)
+          expect { rp.load_cookbook(recipe_specifier) }.to raise_error(ChefApply::RecipeLookup::CookbookNotFound)
+        end
+      end
+    end
+  end
+
+  describe "#find_recipe" do
+    let(:recipe) { double("recipe") }
+
+    context "no recipe is specified" do
+      it "finds a default recipe" do
+        expect(cookbook_version).to receive(:recipe_filenames_by_name).and_return({ "default" => recipe })
+        expect(rp.find_recipe(cookbook_version)).to eq(recipe)
+      end
+      it "when there is no default recipe it raises a NoDefaultRecipe error" do
+        expect(cookbook_version).to receive(:recipe_filenames_by_name).and_return({})
+        expect { rp.find_recipe(cookbook_version) }.to raise_error(ChefApply::RecipeLookup::NoDefaultRecipe)
+      end
+    end
+
+    context "a recipe is specified" do
+      let(:desired_recipe) { "a_recipe" }
+      it "finds the specified recipe" do
+        expect(cookbook_version).to receive(:recipe_filenames_by_name).and_return({ desired_recipe => recipe })
+        expect(rp.find_recipe(cookbook_version, desired_recipe)).to eq(recipe)
+      end
+      it "when there is no recipe with that name it raises a RecipeNotFound error" do
+        expect(cookbook_version).to receive(:recipe_filenames_by_name).and_return({})
+        expect { rp.find_recipe(cookbook_version, desired_recipe) }.to raise_error(ChefApply::RecipeLookup::RecipeNotFound)
+      end
+    end
+  end
+end

data/spec/unit/startup_spec.rb

@@ -0,0 +1,283 @@
+require "chef_apply/startup"
+require "chef_apply/text"
+require "chef_apply/ui/terminal"
+
+RSpec.describe ChefApply::Startup do
+  let(:argv) { [] }
+  let(:telemetry) { ChefApply::Telemeter.instance }
+  subject do
+    ChefApply::Startup.new(argv)
+  end
+  before do
+    allow(ChefApply::UI::Terminal).to receive(:init)
+  end
+
+  after do
+    ChefApply::Config.reset
+  end
+
+  describe "#initalize" do
+    it "initializes the terminal" do
+      expect_any_instance_of(ChefApply::Startup).to receive(:init_terminal)
+      ChefApply::Startup.new([])
+    end
+  end
+
+  describe "#run" do
+    it "performs ordered startup tasks and invokes the CLI" do
+      ordered_messages = [:first_run_tasks,
+                          :setup_workstation_user_directories,
+                          :setup_error_handling,
+                          :load_config,
+                          :setup_logging,
+                          :start_telemeter_upload,
+                          :start_chef_apply]
+      ordered_messages.each do |msg|
+        expect(subject).to receive(msg).ordered
+      end
+      subject.run()
+    end
+    context "when errors happen" do
+      let(:error) { nil }
+      let(:error_text) { ChefApply::Text.cli.error }
+      before do
+        # Force the error to happen in first_run_tasks, since it's always... well, first.
+        expect(subject).to receive(:first_run_tasks).and_raise(error)
+      end
+
+      context "when an UnknownConfigOptionError is raised" do
+        let(:bad_path) { "bad/path" }
+        let(:bad_option) { "bad_option" }
+
+        context "and it matches the expected text form" do
+          let(:error) { Mixlib::Config::UnknownConfigOptionError.new("unsupported config value #{bad_option}.") }
+          it "shows the correct error" do
+            expected_text = error_text.invalid_config_key(bad_option, ChefApply::Config.location)
+            expect(ChefApply::UI::Terminal).to receive(:output).with(expected_text)
+            subject.run
+          end
+        end
+
+        context "and it does not match the expeted text form" do
+          let(:msg) { "something bad happened" }
+          let(:error) { Mixlib::Config::UnknownConfigOptionError.new(msg) }
+          it "shows the correct error" do
+            expected_text = error_text.unknown_config_error(msg, ChefApply::Config.location)
+            expect(ChefApply::UI::Terminal).to receive(:output).with(expected_text)
+            subject.run
+          end
+        end
+      end
+
+      context "when a ConfigPathInvalid is raised" do
+        let(:bad_path) { "bad/path" }
+        let(:error) { ChefApply::Startup::ConfigPathInvalid.new(bad_path) }
+
+        it "shows the correct error" do
+          expected_text = error_text.bad_config_file(bad_path)
+          expect(ChefApply::UI::Terminal).to receive(:output).with(expected_text)
+          subject.run
+        end
+      end
+
+      context "when a ConfigPathNotProvided is raised" do
+        let(:error) { ChefApply::Startup::ConfigPathNotProvided.new }
+
+        it "shows the correct error" do
+          expected_text = error_text.missing_config_path
+          expect(ChefApply::UI::Terminal).to receive(:output).with(expected_text)
+          subject.run
+        end
+      end
+
+      context "when a Tomlrb::ParserError is raised" do
+        let(:msg) { "Parse failed." }
+        let(:error) { Tomlrb::ParseError.new(msg) }
+
+        it "shows the correct error" do
+          expected_text = error_text.unknown_config_error(msg, ChefApply::Config.location)
+          expect(ChefApply::UI::Terminal).to receive(:output).with(expected_text)
+          subject.run
+        end
+      end
+    end
+  end
+  describe "#init_terminal" do
+    it "initializees the terminal for stdout" do
+      expect(ChefApply::UI::Terminal).to receive(:init).with($stdout)
+      subject.init_terminal
+    end
+  end
+  describe "#first_run_tasks" do
+    let(:first_run_complete) { true }
+    before do
+      allow(Dir).to receive(:exist?).with(ChefApply::Config::WS_BASE_PATH).and_return first_run_complete
+    end
+
+    context "when first run has already occurred" do
+      let(:first_run_complete) { true }
+      it "returns without taking action" do
+        expect(subject).to_not receive(:create_default_config)
+        expect(subject).to_not receive(:setup_telemetry)
+        subject.first_run_tasks
+      end
+    end
+    context "when first run has not already occurred" do
+      let(:first_run_complete) { false }
+      it "Performs required first-run tasks" do
+        expect(subject).to receive(:create_default_config)
+        expect(subject).to receive(:setup_telemetry)
+        subject.first_run_tasks
+      end
+    end
+  end
+
+  describe "#create_default_config" do
+    it "touches the configuration file to create it and notifies that it has done so" do
+      expected_config_path = ChefApply::Config.default_location
+      expected_message = ChefApply::Text.cli.creating_config(expected_config_path)
+      expect(ChefApply::UI::Terminal).to receive(:output).
+        with(expected_message)
+      expect(ChefApply::UI::Terminal).to receive(:output).
+        with("")
+      expect(FileUtils).to receive(:touch).
+        with(expected_config_path)
+      subject.create_default_config
+
+    end
+  end
+
+  describe "#setup_telemetry" do
+    let(:mock_guid) { "1234" }
+    it "sets up a telemetry installation id and notifies the operator that telemetry is enabled" do
+      expect(SecureRandom).to receive(:uuid).and_return(mock_guid)
+      expect(File).to receive(:write).
+        with(ChefApply::Config.telemetry_installation_identifier_file, mock_guid)
+      subject.setup_telemetry
+    end
+  end
+
+  describe "#start_telemeter_upload" do
+    it "launches telemetry uploads" do
+      expect(ChefApply::Telemeter::Sender).to receive(:start_upload_thread)
+      subject.start_telemeter_upload
+    end
+  end
+
+  describe "setup_workstation_user_directories" do
+    it "creates the required chef-workstation directories in HOME" do
+      expect(FileUtils).to receive(:mkdir_p).with(ChefApply::Config::WS_BASE_PATH)
+      expect(FileUtils).to receive(:mkdir_p).with(ChefApply::Config.base_log_directory)
+      expect(FileUtils).to receive(:mkdir_p).with(ChefApply::Config.telemetry_path)
+      subject.setup_workstation_user_directories
+    end
+  end
+
+  describe "#custom_config_path" do
+    context "when a custom config path is not provided as an option" do
+      let(:args) { [] }
+      it "returns nil" do
+        expect(subject.custom_config_path).to be_nil
+      end
+    end
+
+    context "when a --config-path is provided" do
+      context "but the actual path parameter is not provided" do
+        let(:argv) { %w{--config-path} }
+        it "raises ConfigPathNotProvided" do
+          expect { subject.custom_config_path }.to raise_error(ChefApply::Startup::ConfigPathNotProvided)
+        end
+      end
+
+      context "and the path is provided" do
+        let(:path) { "/mock/file.toml" }
+        let(:argv) { ["--config-path", path] }
+
+        context "but the path is not a file" do
+          before do
+            allow(File).to receive(:file?).with(path).and_return false
+          end
+          it "raises an error ConfigPathInvalid" do
+            expect { subject.custom_config_path }.to raise_error(ChefApply::Startup::ConfigPathInvalid)
+          end
+        end
+
+        context "and the path exists and is a valid file" do
+          before do
+            allow(File).to receive(:file?).with(path).and_return true
+          end
+
+          context "but it is not readable" do
+            before do
+              allow(File).to receive(:readable?).with(path).and_return false
+            end
+            it "raises an error ConfigPathInvalid" do
+              expect { subject.custom_config_path }.to raise_error(ChefApply::Startup::ConfigPathInvalid)
+            end
+          end
+
+          context "and it is readable" do
+            before do
+              allow(File).to receive(:readable?).with(path).and_return true
+            end
+            it "returns the custom path" do
+              expect(subject.custom_config_path).to eq path
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#load_config" do
+    context "when a custom configuraton path is provided" do
+      let(:config_path) { nil }
+      it "loads the config at the custom path" do
+        expect(subject).to receive(:custom_config_path).and_return config_path
+        expect(ChefApply::Config).to receive(:custom_location).with config_path
+        expect(ChefApply::Config).to receive(:load)
+        subject.load_config
+      end
+      let(:config_path) { "/tmp/workstation-mock-config.toml" }
+    end
+
+    context "when no custom configuration path is provided" do
+      let(:config_path) { nil }
+      it "loads it at the default configuration path" do
+        expect(subject).to receive(:custom_config_path).and_return config_path
+        expect(ChefApply::Config).not_to receive(:custom_location)
+        expect(ChefApply::Config).to receive(:load)
+        subject.load_config
+      end
+    end
+
+  end
+
+  describe "#setup_logging" do
+    let(:log_path) { "/tmp/logs" }
+    let(:log_level) { :debug }
+    before do
+      ChefApply::Config.log.location = log_path
+      ChefApply::Config.log.level = log_level
+    end
+
+    it "sets up the logging for ChefApply and Chef" do
+      expect(ChefApply::Log).to receive(:setup).
+        with(log_path, log_level)
+      expect(Chef::Log).to receive(:init).
+        with(ChefApply::Log)
+      subject.setup_logging
+      expect(ChefConfig.logger).to eq(ChefApply::Log)
+    end
+  end
+
+  describe "#start_chef_apply" do
+    let(:argv) { %w{some arguments} }
+    it "runs ChefApply::CLI and passes along arguments it received" do
+      run_double = instance_double(ChefApply::CLI)
+      expect(ChefApply::CLI).to receive(:new).with(argv).and_return(run_double)
+      expect(run_double).to receive(:run)
+      subject.start_chef_apply
+    end
+  end
+end