chef-dk 0.13.21 → 0.14.25

data/spec/unit/command/generator_commands/template_spec.rb

@@ -1,32 +1,32 @@
-#
-# Copyright:: Copyright (c) 2014 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 'shared/a_file_generator'
-require 'chef-dk/command/generator_commands/template'
-
-describe ChefDK::Command::GeneratorCommands::Template do
-
-  include_examples "a file generator" do
-
-    let(:generator_name) { "template" }
-    let(:generated_files) { [ "templates/default/new_template.txt.erb" ] }
-    let(:new_file_name) { "new_template.txt" }
-
-  end
-end
-
+#
+# Copyright:: Copyright (c) 2014 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 'shared/a_file_generator'
+require 'chef-dk/command/generator_commands/template'
+
+describe ChefDK::Command::GeneratorCommands::Template do
+
+  include_examples "a file generator" do
+
+    let(:generator_name) { "template" }
+    let(:generated_files) { [ "templates/default/new_template.txt.erb" ] }
+    let(:new_file_name) { "new_template.txt" }
+
+  end
+end
+

data/spec/unit/command/install_spec.rb

@@ -1,179 +1,179 @@
-#
-# Copyright:: Copyright (c) 2014 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 'shared/command_with_ui_object'
-require 'chef-dk/command/install'
-
-describe ChefDK::Command::Install do
-
-  it_behaves_like "a command with a UI object"
-
-  let(:params) { [] }
-
-  let(:command) do
-    c = described_class.new
-    c.apply_params!(params)
-    c
-  end
-
-  let(:install_service) { instance_double(ChefDK::PolicyfileServices::Install) }
-
-  it "disables debug by default" do
-    expect(command.debug?).to be(false)
-  end
-
-  it "doesn't set a config path by default" do
-    expect(command.config_path).to be_nil
-  end
-
-  context "when debug mode is set" do
-
-    let(:params) { [ "-D" ] }
-
-    it "enables debug" do
-      expect(command.debug?).to be(true)
-    end
-  end
-
-  context "when an explicit config file path is given" do
-
-    let(:params) { %w[ -c ~/.chef/alternate_config.rb ] }
-
-    let(:chef_config_loader) { instance_double("Chef::WorkstationConfigLoader") }
-
-    it "sets the config file path to the given value" do
-      expect(command.config_path).to eq("~/.chef/alternate_config.rb")
-    end
-
-    it "loads the config from the given path" do
-      expect(Chef::WorkstationConfigLoader).to receive(:new).
-        with("~/.chef/alternate_config.rb").
-        and_return(chef_config_loader)
-      expect(chef_config_loader).to receive(:load)
-      expect(command.chef_config).to eq(Chef::Config)
-    end
-
-  end
-
-  context "with no arguments" do
-
-    it "does not specify a policyfile relative path" do
-      expect(command.policyfile_relative_path).to be(nil)
-    end
-
-    it "creates the installer service with a `nil` policyfile path" do
-      expect(ChefDK::PolicyfileServices::Install).to receive(:new).
-        with(policyfile: nil, ui: command.ui, root_dir: Dir.pwd).
-        and_return(install_service)
-      expect(command.installer).to eq(install_service)
-    end
-
-  end
-
-  context "with an explicit policyfile relative path" do
-
-    let(:params) { [ "MyPolicy.rb" ] }
-
-    it "respects the user-supplied path" do
-      expect(command.policyfile_relative_path).to eq("MyPolicy.rb")
-    end
-
-    it "creates the installer service with the specified policyfile path" do
-      expect(ChefDK::PolicyfileServices::Install).to receive(:new).
-        with(policyfile: "MyPolicy.rb", ui: command.ui, root_dir: Dir.pwd).
-        and_return(install_service)
-      expect(command.installer).to eq(install_service)
-    end
-
-  end
-
-  describe "running the install" do
-
-    let(:ui) { TestHelpers::TestUI.new }
-
-    before do
-      command.ui = ui
-      allow(command).to receive(:installer).and_return(install_service)
-    end
-
-    context "when the command is successful" do
-      before do
-        expect(install_service).to receive(:run)
-      end
-
-      it "returns 0" do
-        expect(command.run).to eq(0)
-      end
-    end
-
-    context "when the command is unsuccessful" do
-
-      let(:backtrace) { caller[0...3] }
-
-      let(:cause) do
-        e = StandardError.new("some operation failed")
-        e.set_backtrace(backtrace)
-        e
-      end
-
-      let(:exception) do
-        ChefDK::PolicyfileInstallError.new("install failed", cause)
-      end
-
-      before do
-        expect(install_service).to receive(:run).and_raise(exception)
-      end
-
-      it "returns 1" do
-        expect(command.run).to eq(1)
-      end
-
-      it "displays the exception and cause" do
-        expected_error_text=<<-E
-Error: install failed
-Reason: (StandardError) some operation failed
-
-E
-
-        command.run
-        expect(ui.output).to eq(expected_error_text)
-      end
-
-      context "and debug is enabled" do
-
-        let(:params) { ["-D"] }
-
-        it "displays the exception and cause with backtrace" do
-          expected_error_text=<<-E
-Error: install failed
-Reason: (StandardError) some operation failed
-
-
-E
-
-          expected_error_text << backtrace.join("\n") << "\n"
-
-          command.run
-          expect(ui.output).to eq(expected_error_text)
-        end
-      end
-
-    end
-
-  end
-end
+#
+# Copyright:: Copyright (c) 2014 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 'shared/command_with_ui_object'
+require 'chef-dk/command/install'
+
+describe ChefDK::Command::Install do
+
+  it_behaves_like "a command with a UI object"
+
+  let(:params) { [] }
+
+  let(:command) do
+    c = described_class.new
+    c.apply_params!(params)
+    c
+  end
+
+  let(:install_service) { instance_double(ChefDK::PolicyfileServices::Install) }
+
+  it "disables debug by default" do
+    expect(command.debug?).to be(false)
+  end
+
+  it "doesn't set a config path by default" do
+    expect(command.config_path).to be_nil
+  end
+
+  context "when debug mode is set" do
+
+    let(:params) { [ "-D" ] }
+
+    it "enables debug" do
+      expect(command.debug?).to be(true)
+    end
+  end
+
+  context "when an explicit config file path is given" do
+
+    let(:params) { %w[ -c ~/.chef/alternate_config.rb ] }
+
+    let(:chef_config_loader) { instance_double("Chef::WorkstationConfigLoader") }
+
+    it "sets the config file path to the given value" do
+      expect(command.config_path).to eq("~/.chef/alternate_config.rb")
+    end
+
+    it "loads the config from the given path" do
+      expect(Chef::WorkstationConfigLoader).to receive(:new).
+        with("~/.chef/alternate_config.rb").
+        and_return(chef_config_loader)
+      expect(chef_config_loader).to receive(:load)
+      expect(command.chef_config).to eq(Chef::Config)
+    end
+
+  end
+
+  context "with no arguments" do
+
+    it "does not specify a policyfile relative path" do
+      expect(command.policyfile_relative_path).to be(nil)
+    end
+
+    it "creates the installer service with a `nil` policyfile path" do
+      expect(ChefDK::PolicyfileServices::Install).to receive(:new).
+        with(policyfile: nil, ui: command.ui, root_dir: Dir.pwd).
+        and_return(install_service)
+      expect(command.installer).to eq(install_service)
+    end
+
+  end
+
+  context "with an explicit policyfile relative path" do
+
+    let(:params) { [ "MyPolicy.rb" ] }
+
+    it "respects the user-supplied path" do
+      expect(command.policyfile_relative_path).to eq("MyPolicy.rb")
+    end
+
+    it "creates the installer service with the specified policyfile path" do
+      expect(ChefDK::PolicyfileServices::Install).to receive(:new).
+        with(policyfile: "MyPolicy.rb", ui: command.ui, root_dir: Dir.pwd).
+        and_return(install_service)
+      expect(command.installer).to eq(install_service)
+    end
+
+  end
+
+  describe "running the install" do
+
+    let(:ui) { TestHelpers::TestUI.new }
+
+    before do
+      command.ui = ui
+      allow(command).to receive(:installer).and_return(install_service)
+    end
+
+    context "when the command is successful" do
+      before do
+        expect(install_service).to receive(:run)
+      end
+
+      it "returns 0" do
+        expect(command.run).to eq(0)
+      end
+    end
+
+    context "when the command is unsuccessful" do
+
+      let(:backtrace) { caller[0...3] }
+
+      let(:cause) do
+        e = StandardError.new("some operation failed")
+        e.set_backtrace(backtrace)
+        e
+      end
+
+      let(:exception) do
+        ChefDK::PolicyfileInstallError.new("install failed", cause)
+      end
+
+      before do
+        expect(install_service).to receive(:run).and_raise(exception)
+      end
+
+      it "returns 1" do
+        expect(command.run).to eq(1)
+      end
+
+      it "displays the exception and cause" do
+        expected_error_text=<<-E
+Error: install failed
+Reason: (StandardError) some operation failed
+
+E
+
+        command.run
+        expect(ui.output).to eq(expected_error_text)
+      end
+
+      context "and debug is enabled" do
+
+        let(:params) { ["-D"] }
+
+        it "displays the exception and cause with backtrace" do
+          expected_error_text=<<-E
+Error: install failed
+Reason: (StandardError) some operation failed
+
+
+E
+
+          expected_error_text << backtrace.join("\n") << "\n"
+
+          command.run
+          expect(ui.output).to eq(expected_error_text)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/unit/command/provision_spec.rb

@@ -1,592 +1,592 @@
-#
-# Copyright:: Copyright (c) 2015 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 'shared/command_with_ui_object'
-require 'chef-dk/command/provision'
-
-describe ChefDK::Command::Provision do
-
-  it_behaves_like "a command with a UI object"
-
-  let(:command) do
-    described_class.new
-  end
-
-  let(:push_service) { instance_double(ChefDK::PolicyfileServices::Push) }
-
-  let(:chef_config_loader) { instance_double("Chef::WorkstationConfigLoader") }
-
-  let(:chef_config) { double("Chef::Config") }
-
-  let(:config_arg) { nil }
-
-  before do
-    ChefDK::ProvisioningData.reset
-
-    stub_const("Chef::Config", chef_config)
-    allow(Chef::WorkstationConfigLoader).to receive(:new).with(config_arg).and_return(chef_config_loader)
-  end
-
-  describe "evaluating CLI options and arguments" do
-
-    let(:ui) { TestHelpers::TestUI.new }
-
-    before do
-      command.ui = ui
-    end
-
-    describe "when input is invalid" do
-
-      context "when not enough arguments are given" do
-
-        let(:params) { [] }
-
-        it "prints usage and exits non-zero" do
-          expect(command.run(params)).to eq(1)
-          expect(ui.output).to include("You must specify a POLICY_GROUP or disable policyfiles with --no-policy")
-        end
-
-      end
-
-      context "when --no-policy is combined with policy arguments" do
-
-        let(:params) { %w[ --no-policy some-policy-group ] }
-
-        it "prints usage and exits non-zero" do
-          expect(command.run(params)).to eq(1)
-          expect(ui.output).to include("The --no-policy flag cannot be combined with policyfile arguments")
-        end
-
-      end
-
-      context "when a POLICY_GROUP is given but neither of --sync or --policy-name are given" do
-
-        let(:params) { %w[ some-policy-group ] }
-
-        it "prints usage and exits non-zero" do
-          expect(command.run(params)).to eq(1)
-          expect(ui.output).to include("You must pass either --sync or --policy-name to provision machines in policyfile mode")
-        end
-
-      end
-
-      context "when both --sync and --policy-name are given" do
-
-        let(:params) { %w[ some-policy-group --policy-name foo --sync] }
-
-        it "prints usage and exits non-zero" do
-          expect(command.run(params)).to eq(1)
-          expect(ui.output).to include("The --policy-name and --sync arguments cannot be combined")
-        end
-
-      end
-
-      context "when too many arguments are given" do
-
-        let(:params) { %w[ policygroup extraneous-argument --sync ] }
-
-        it "prints usage and exits non-zero" do
-          expect(command.run(params)).to eq(1)
-          expect(ui.output).to include("Too many arguments")
-        end
-
-      end
-    end
-
-    describe "when input is valid" do
-
-      let(:context) { ChefDK::ProvisioningData.context }
-
-      shared_examples  "common_optional_options" do
-
-        context "with default option values" do
-
-          it "node name is not specified" do
-            expect(command.node_name).to eq(nil)
-            expect(context.node_name).to eq(nil)
-          end
-
-          it "sets the cookbook path to CWD" do
-            # this is cookbook_path in the chef sense, a directory with cookbooks in it.
-            expect(command.provisioning_cookbook_path).to eq(Dir.pwd)
-          end
-
-          it "sets the cookbook name to 'provision'" do
-            expect(command.provisioning_cookbook_name).to eq('provision')
-          end
-
-          it "sets the recipe to 'default'" do
-            expect(command.recipe).to eq("default")
-            expect(command.chef_runner.run_list).to eq(["recipe[provision::default]"])
-          end
-
-          it "sets the default action to converge" do
-            expect(command.default_action).to eq(:converge)
-            expect(context.action).to eq(:converge)
-          end
-
-        end
-
-        context "with -n NODE_NAME" do
-
-          let(:extra_params) { %w[ -n example-node ] }
-
-          it "sets the default requested node name" do
-            expect(command.node_name).to eq("example-node")
-            expect(context.node_name).to eq("example-node")
-          end
-
-        end
-
-        context "with --cookbook COOKBOOK_PATH" do
-
-          let(:extra_params) { %w[ --cookbook ~/mystuff/my-provision-cookbook ] }
-
-          let(:expected_cookbook_path) { File.expand_path("~/mystuff") }
-          let(:expected_cookbook_name) { "my-provision-cookbook" }
-
-          it "sets the cookbook path" do
-            # this is cookbook_path in the chef sense, a directory with cookbooks in it.
-            expect(command.provisioning_cookbook_path).to eq(expected_cookbook_path)
-          end
-
-          it "sets the cookbook name" do
-            expect(command.provisioning_cookbook_name).to eq(expected_cookbook_name)
-          end
-
-        end
-
-        context "with -c CONFIG_FILE" do
-
-          let(:config_arg) { "~/somewhere_else/knife.rb" }
-
-          let(:extra_params) { [ "-c", config_arg ] }
-
-          it "loads config from the specified location" do
-            # The configurable module uses config[:config_file]
-            expect(command.config[:config_file]).to eq("~/somewhere_else/knife.rb")
-          end
-
-        end
-
-        context "with -r MACHINE_RECIPE" do
-
-          let(:extra_params) { %w[ -r ec2cluster ] }
-
-          it "sets the recipe to run as specified" do
-            expect(command.recipe).to eq("ec2cluster")
-            expect(command.chef_runner.run_list).to eq(["recipe[provision::ec2cluster]"])
-          end
-
-        end
-
-        context "with --target" do
-
-          let(:extra_params) { %w[ -t 192.168.255.123 ] }
-
-          it "sets the target host to the given value" do
-            expect(context.target).to eq("192.168.255.123")
-          end
-
-        end
-
-        context "with --opt" do
-          context "with one user-specified option" do
-            let(:extra_params) { %w[ --opt color=ebfg ] }
-
-            it "sets the given option name to the given value" do
-              expect(context.opts.color).to eq("ebfg")
-            end
-          end
-
-          context "with an option given as a quoted arg with spaces" do
-
-            let(:extra_params) { [ '--opt', 'color = ebfg' ] }
-
-            it "sets the given option name to the given value" do
-              expect(context.opts.color).to eq("ebfg")
-            end
-          end
-
-          context "with an option with an '=' in it" do
-
-            let(:extra_params) { [ '--opt', 'api_key=abcdef==' ] }
-
-            it "sets the given option name to the given value" do
-              expect(context.opts.api_key).to eq("abcdef==")
-            end
-          end
-
-          context "with an option with a space in it" do
-
-            let(:extra_params) { [ '--opt', 'full_name=Bobo T. Clown' ] }
-
-            it "sets the given option name to the given value" do
-              expect(context.opts.full_name).to eq("Bobo T. Clown")
-            end
-          end
-
-          context "with multiple options given" do
-            let(:extra_params) { %w[ --opt color=ebfg --opt nope=seppb ] }
-
-            it "sets the given option name to the given value" do
-              expect(context.opts.color).to eq("ebfg")
-              expect(context.opts.nope).to eq("seppb")
-            end
-          end
-        end
-
-        context "with -d" do
-
-          let(:extra_params) { %w[ -d ] }
-
-          it "sets the default action to destroy" do
-            expect(command.default_action).to eq(:destroy)
-            expect(context.action).to eq(:destroy)
-          end
-
-        end
-
-      end # shared examples
-
-      context "when --no-policy is given" do
-
-        before do
-          allow(chef_config_loader).to receive(:load)
-          allow(command).to receive(:push).and_return(push_service)
-
-          allow(chef_config).to receive(:ssl_verify_mode).and_return(:verify_peer)
-
-          command.apply_params!(params)
-          command.setup_context
-        end
-
-        let(:extra_params) { [] }
-        let(:params) { %w[ --no-policy ] + extra_params }
-
-        it "disables policyfile integration" do
-          expect(command.enable_policyfile?).to be(false)
-        end
-
-        it "generates chef config with no policyfile options" do
-          expected_config = <<-CONFIG
-# SSL Settings:
-ssl_verify_mode :verify_peer
-
-CONFIG
-          expect(context.chef_config).to eq(expected_config)
-        end
-
-        include_examples "common_optional_options"
-
-      end # when --no-policy is given
-
-      context "when --sync POLICYFILE argument is given" do
-
-        let(:policy_data) { { "name" => "myapp" } }
-
-        before do
-          allow(chef_config_loader).to receive(:load)
-
-          allow(ChefDK::PolicyfileServices::Push).to receive(:new).
-            with(policyfile: given_policyfile_path, ui: ui, policy_group: given_policy_group, config: chef_config, root_dir: Dir.pwd).
-            and_return(push_service)
-
-          allow(push_service).to receive(:policy_data).and_return(policy_data)
-
-          command.apply_params!(params)
-          command.setup_context
-        end
-
-        context "with explicit policyfile relative path" do
-
-          let(:given_policyfile_path) { "policies/OtherPolicy.rb" }
-
-          let(:given_policy_group) { "some-policy-group" }
-
-          let(:params) { [ given_policy_group, '--sync', given_policyfile_path ] }
-
-          it "sets policy group" do
-            expect(command.policy_group).to eq(given_policy_group)
-            expect(context.policy_group).to eq(given_policy_group)
-          end
-
-          it "sets policy name" do
-            expect(command.policy_name).to eq("myapp")
-            expect(context.policy_name).to eq("myapp")
-          end
-
-        end
-
-        context "with implicit policyfile relative path" do
-
-          let(:given_policyfile_path) { nil }
-
-          let(:given_policy_group) { "some-policy-group" }
-
-          let(:extra_params) { [] }
-
-          let(:params) { [ given_policy_group, '--sync' ] + extra_params }
-
-          before do
-            allow(chef_config).to receive(:ssl_verify_mode).and_return(:verify_peer)
-          end
-
-          it "sets policy group" do
-            expect(command.policy_group).to eq(given_policy_group)
-            expect(context.policy_group).to eq(given_policy_group)
-          end
-
-          it "sets policy name" do
-            expect(command.policy_name).to eq("myapp")
-            expect(context.policy_name).to eq("myapp")
-          end
-
-          it "generates chef config with policyfile options" do
-            expected_config = <<-CONFIG
-# SSL Settings:
-ssl_verify_mode :verify_peer
-
-# Policyfile Settings:
-use_policyfile true
-policy_document_native_api true
-
-policy_group "some-policy-group"
-policy_name "myapp"
-
-CONFIG
-            expect(context.chef_config).to eq(expected_config)
-          end
-
-
-          include_examples "common_optional_options"
-
-        end
-
-      end # when --sync POLICYFILE argument is given
-
-      context "when a --policy-name is given" do
-
-        let(:given_policy_group) { "some-policy-group" }
-
-        let(:extra_params) { [] }
-
-        let(:params) { [ given_policy_group, '--policy-name', "myapp" ] + extra_params }
-
-
-        before do
-          command.apply_params!(params)
-          command.setup_context
-
-          allow(chef_config).to receive(:ssl_verify_mode).and_return(:verify_peer)
-        end
-
-        it "sets policy group" do
-          expect(command.policy_group).to eq(given_policy_group)
-          expect(context.policy_group).to eq(given_policy_group)
-        end
-
-        it "sets policy name" do
-          expect(command.policy_name).to eq("myapp")
-          expect(context.policy_name).to eq("myapp")
-        end
-
-        it "generates chef config with policyfile options" do
-          expected_config = <<-CONFIG
-# SSL Settings:
-ssl_verify_mode :verify_peer
-
-# Policyfile Settings:
-use_policyfile true
-policy_document_native_api true
-
-policy_group "some-policy-group"
-policy_name "myapp"
-
-CONFIG
-          expect(context.chef_config).to eq(expected_config)
-        end
-
-        include_examples "common_optional_options"
-
-      end
-    end
-
-  end
-
-  describe "running the provision cookbook" do
-
-    let(:ui) { TestHelpers::TestUI.new }
-
-    before do
-      allow(chef_config_loader).to receive(:load)
-      allow(command).to receive(:push).and_return(push_service)
-      command.ui = ui
-    end
-
-    let(:provision_cookbook_path) { File.expand_path("provision", Dir.pwd) }
-    let(:provision_recipe_path) { File.join(provision_cookbook_path, "recipes", "default.rb") }
-
-    let(:chef_runner) { instance_double("ChefDK::ChefRunner") }
-
-    let(:params) { %w[ policygroup --sync ] }
-
-    context "when the provision cookbook doesn't exist" do
-
-      before do
-        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(false)
-      end
-
-      it "prints an error and exits non-zero" do
-        expect(command.run(params)).to eq(1)
-        expect(ui.output).to include("Provisioning cookbook not found at path #{provision_cookbook_path}")
-      end
-
-    end
-
-    context "when the provision cookbook doesn't have the requested recipe" do
-
-      before do
-        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(true)
-        allow(File).to receive(:exist?).with(provision_recipe_path).and_return(false)
-      end
-
-      it "prints an error and exits non-zero" do
-        expect(command.run(params)).to eq(1)
-        expect(ui.output).to include("Provisioning recipe not found at path #{provision_recipe_path}")
-      end
-
-    end
-
-    context "when the policyfile upload fails" do
-
-      let(:backtrace) { caller[0...3] }
-
-      let(:cause) do
-        e = StandardError.new("some operation failed")
-        e.set_backtrace(backtrace)
-        e
-      end
-
-      let(:exception) do
-        ChefDK::PolicyfilePushError.new("push failed", cause)
-      end
-
-      before do
-        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(true)
-        allow(File).to receive(:exist?).with(provision_recipe_path).and_return(true)
-
-        expect(push_service).to receive(:run).and_raise(exception)
-      end
-
-      it "prints an error and exits non-zero" do
-          expected_output=<<-E
-Error: push failed
-Reason: (StandardError) some operation failed
-
-E
-        expect(command.run(params)).to eq(1)
-        expect(ui.output).to include(expected_output)
-      end
-
-    end
-
-    context "when the chef run fails" do
-
-      let(:base_exception) { StandardError.new("Something went wrong") }
-      let(:exception) { ChefDK::ChefConvergeError.new("Chef failed to converge: #{base_exception}", base_exception) }
-
-      let(:policy_data) { { "name" => "myapp" } }
-
-      before do
-        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(true)
-        allow(File).to receive(:exist?).with(provision_recipe_path).and_return(true)
-
-        allow(push_service).to receive(:policy_data).and_return(policy_data)
-
-        expect(push_service).to receive(:run)
-
-        allow(command).to receive(:chef_runner).and_return(chef_runner)
-        allow(chef_runner).to receive(:cookbook_path).and_return(Dir.pwd)
-        expect(chef_runner).to receive(:converge).and_raise(exception)
-      end
-
-      it "prints an error and exits non-zero" do
-        expect(command.run(params)).to eq(1)
-        expect(ui.output).to include("Error: Chef failed to converge")
-        expect(ui.output).to include("Reason: (StandardError) Something went wrong")
-      end
-
-    end
-
-    context "when the chef run is successful" do
-
-      before do
-        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(true)
-        allow(File).to receive(:exist?).with(provision_recipe_path).and_return(true)
-        allow(command).to receive(:chef_runner).and_return(chef_runner)
-        allow(chef_runner).to receive(:cookbook_path).and_return(Dir.pwd)
-
-        expect(chef_runner).to receive(:converge)
-      end
-
-      context "when using --no-policy" do
-
-        let(:params) { %w[ --no-policy ] }
-
-        it "exits 0" do
-          return_value = command.run(params)
-          expect(ui.output).to eq("")
-          expect(return_value).to eq(0)
-        end
-
-      end
-
-      context "with --policy-name" do
-
-        let(:params) { %w[ policygroup --policy-name otherapp ] }
-
-        it "exits 0" do
-          return_value = command.run(params)
-          expect(ui.output).to eq("")
-          expect(return_value).to eq(0)
-        end
-      end
-
-      context "with --sync" do
-
-        let(:policy_data) { { "name" => "myapp" } }
-
-        before do
-          allow(push_service).to receive(:policy_data).and_return(policy_data)
-          expect(push_service).to receive(:run)
-        end
-
-        it "exits 0" do
-          return_value = command.run(params)
-          expect(ui.output).to eq("")
-          expect(return_value).to eq(0)
-        end
-
-      end
-
-    end
-
-  end
-end
-
+#
+# Copyright:: Copyright (c) 2015 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 'shared/command_with_ui_object'
+require 'chef-dk/command/provision'
+
+describe ChefDK::Command::Provision do
+
+  it_behaves_like "a command with a UI object"
+
+  let(:command) do
+    described_class.new
+  end
+
+  let(:push_service) { instance_double(ChefDK::PolicyfileServices::Push) }
+
+  let(:chef_config_loader) { instance_double("Chef::WorkstationConfigLoader") }
+
+  let(:chef_config) { double("Chef::Config") }
+
+  let(:config_arg) { nil }
+
+  before do
+    ChefDK::ProvisioningData.reset
+
+    stub_const("Chef::Config", chef_config)
+    allow(Chef::WorkstationConfigLoader).to receive(:new).with(config_arg).and_return(chef_config_loader)
+  end
+
+  describe "evaluating CLI options and arguments" do
+
+    let(:ui) { TestHelpers::TestUI.new }
+
+    before do
+      command.ui = ui
+    end
+
+    describe "when input is invalid" do
+
+      context "when not enough arguments are given" do
+
+        let(:params) { [] }
+
+        it "prints usage and exits non-zero" do
+          expect(command.run(params)).to eq(1)
+          expect(ui.output).to include("You must specify a POLICY_GROUP or disable policyfiles with --no-policy")
+        end
+
+      end
+
+      context "when --no-policy is combined with policy arguments" do
+
+        let(:params) { %w[ --no-policy some-policy-group ] }
+
+        it "prints usage and exits non-zero" do
+          expect(command.run(params)).to eq(1)
+          expect(ui.output).to include("The --no-policy flag cannot be combined with policyfile arguments")
+        end
+
+      end
+
+      context "when a POLICY_GROUP is given but neither of --sync or --policy-name are given" do
+
+        let(:params) { %w[ some-policy-group ] }
+
+        it "prints usage and exits non-zero" do
+          expect(command.run(params)).to eq(1)
+          expect(ui.output).to include("You must pass either --sync or --policy-name to provision machines in policyfile mode")
+        end
+
+      end
+
+      context "when both --sync and --policy-name are given" do
+
+        let(:params) { %w[ some-policy-group --policy-name foo --sync] }
+
+        it "prints usage and exits non-zero" do
+          expect(command.run(params)).to eq(1)
+          expect(ui.output).to include("The --policy-name and --sync arguments cannot be combined")
+        end
+
+      end
+
+      context "when too many arguments are given" do
+
+        let(:params) { %w[ policygroup extraneous-argument --sync ] }
+
+        it "prints usage and exits non-zero" do
+          expect(command.run(params)).to eq(1)
+          expect(ui.output).to include("Too many arguments")
+        end
+
+      end
+    end
+
+    describe "when input is valid" do
+
+      let(:context) { ChefDK::ProvisioningData.context }
+
+      shared_examples  "common_optional_options" do
+
+        context "with default option values" do
+
+          it "node name is not specified" do
+            expect(command.node_name).to eq(nil)
+            expect(context.node_name).to eq(nil)
+          end
+
+          it "sets the cookbook path to CWD" do
+            # this is cookbook_path in the chef sense, a directory with cookbooks in it.
+            expect(command.provisioning_cookbook_path).to eq(Dir.pwd)
+          end
+
+          it "sets the cookbook name to 'provision'" do
+            expect(command.provisioning_cookbook_name).to eq('provision')
+          end
+
+          it "sets the recipe to 'default'" do
+            expect(command.recipe).to eq("default")
+            expect(command.chef_runner.run_list).to eq(["recipe[provision::default]"])
+          end
+
+          it "sets the default action to converge" do
+            expect(command.default_action).to eq(:converge)
+            expect(context.action).to eq(:converge)
+          end
+
+        end
+
+        context "with -n NODE_NAME" do
+
+          let(:extra_params) { %w[ -n example-node ] }
+
+          it "sets the default requested node name" do
+            expect(command.node_name).to eq("example-node")
+            expect(context.node_name).to eq("example-node")
+          end
+
+        end
+
+        context "with --cookbook COOKBOOK_PATH" do
+
+          let(:extra_params) { %w[ --cookbook ~/mystuff/my-provision-cookbook ] }
+
+          let(:expected_cookbook_path) { File.expand_path("~/mystuff") }
+          let(:expected_cookbook_name) { "my-provision-cookbook" }
+
+          it "sets the cookbook path" do
+            # this is cookbook_path in the chef sense, a directory with cookbooks in it.
+            expect(command.provisioning_cookbook_path).to eq(expected_cookbook_path)
+          end
+
+          it "sets the cookbook name" do
+            expect(command.provisioning_cookbook_name).to eq(expected_cookbook_name)
+          end
+
+        end
+
+        context "with -c CONFIG_FILE" do
+
+          let(:config_arg) { "~/somewhere_else/knife.rb" }
+
+          let(:extra_params) { [ "-c", config_arg ] }
+
+          it "loads config from the specified location" do
+            # The configurable module uses config[:config_file]
+            expect(command.config[:config_file]).to eq("~/somewhere_else/knife.rb")
+          end
+
+        end
+
+        context "with -r MACHINE_RECIPE" do
+
+          let(:extra_params) { %w[ -r ec2cluster ] }
+
+          it "sets the recipe to run as specified" do
+            expect(command.recipe).to eq("ec2cluster")
+            expect(command.chef_runner.run_list).to eq(["recipe[provision::ec2cluster]"])
+          end
+
+        end
+
+        context "with --target" do
+
+          let(:extra_params) { %w[ -t 192.168.255.123 ] }
+
+          it "sets the target host to the given value" do
+            expect(context.target).to eq("192.168.255.123")
+          end
+
+        end
+
+        context "with --opt" do
+          context "with one user-specified option" do
+            let(:extra_params) { %w[ --opt color=ebfg ] }
+
+            it "sets the given option name to the given value" do
+              expect(context.opts.color).to eq("ebfg")
+            end
+          end
+
+          context "with an option given as a quoted arg with spaces" do
+
+            let(:extra_params) { [ '--opt', 'color = ebfg' ] }
+
+            it "sets the given option name to the given value" do
+              expect(context.opts.color).to eq("ebfg")
+            end
+          end
+
+          context "with an option with an '=' in it" do
+
+            let(:extra_params) { [ '--opt', 'api_key=abcdef==' ] }
+
+            it "sets the given option name to the given value" do
+              expect(context.opts.api_key).to eq("abcdef==")
+            end
+          end
+
+          context "with an option with a space in it" do
+
+            let(:extra_params) { [ '--opt', 'full_name=Bobo T. Clown' ] }
+
+            it "sets the given option name to the given value" do
+              expect(context.opts.full_name).to eq("Bobo T. Clown")
+            end
+          end
+
+          context "with multiple options given" do
+            let(:extra_params) { %w[ --opt color=ebfg --opt nope=seppb ] }
+
+            it "sets the given option name to the given value" do
+              expect(context.opts.color).to eq("ebfg")
+              expect(context.opts.nope).to eq("seppb")
+            end
+          end
+        end
+
+        context "with -d" do
+
+          let(:extra_params) { %w[ -d ] }
+
+          it "sets the default action to destroy" do
+            expect(command.default_action).to eq(:destroy)
+            expect(context.action).to eq(:destroy)
+          end
+
+        end
+
+      end # shared examples
+
+      context "when --no-policy is given" do
+
+        before do
+          allow(chef_config_loader).to receive(:load)
+          allow(command).to receive(:push).and_return(push_service)
+
+          allow(chef_config).to receive(:ssl_verify_mode).and_return(:verify_peer)
+
+          command.apply_params!(params)
+          command.setup_context
+        end
+
+        let(:extra_params) { [] }
+        let(:params) { %w[ --no-policy ] + extra_params }
+
+        it "disables policyfile integration" do
+          expect(command.enable_policyfile?).to be(false)
+        end
+
+        it "generates chef config with no policyfile options" do
+          expected_config = <<-CONFIG
+# SSL Settings:
+ssl_verify_mode :verify_peer
+
+CONFIG
+          expect(context.chef_config).to eq(expected_config)
+        end
+
+        include_examples "common_optional_options"
+
+      end # when --no-policy is given
+
+      context "when --sync POLICYFILE argument is given" do
+
+        let(:policy_data) { { "name" => "myapp" } }
+
+        before do
+          allow(chef_config_loader).to receive(:load)
+
+          allow(ChefDK::PolicyfileServices::Push).to receive(:new).
+            with(policyfile: given_policyfile_path, ui: ui, policy_group: given_policy_group, config: chef_config, root_dir: Dir.pwd).
+            and_return(push_service)
+
+          allow(push_service).to receive(:policy_data).and_return(policy_data)
+
+          command.apply_params!(params)
+          command.setup_context
+        end
+
+        context "with explicit policyfile relative path" do
+
+          let(:given_policyfile_path) { "policies/OtherPolicy.rb" }
+
+          let(:given_policy_group) { "some-policy-group" }
+
+          let(:params) { [ given_policy_group, '--sync', given_policyfile_path ] }
+
+          it "sets policy group" do
+            expect(command.policy_group).to eq(given_policy_group)
+            expect(context.policy_group).to eq(given_policy_group)
+          end
+
+          it "sets policy name" do
+            expect(command.policy_name).to eq("myapp")
+            expect(context.policy_name).to eq("myapp")
+          end
+
+        end
+
+        context "with implicit policyfile relative path" do
+
+          let(:given_policyfile_path) { nil }
+
+          let(:given_policy_group) { "some-policy-group" }
+
+          let(:extra_params) { [] }
+
+          let(:params) { [ given_policy_group, '--sync' ] + extra_params }
+
+          before do
+            allow(chef_config).to receive(:ssl_verify_mode).and_return(:verify_peer)
+          end
+
+          it "sets policy group" do
+            expect(command.policy_group).to eq(given_policy_group)
+            expect(context.policy_group).to eq(given_policy_group)
+          end
+
+          it "sets policy name" do
+            expect(command.policy_name).to eq("myapp")
+            expect(context.policy_name).to eq("myapp")
+          end
+
+          it "generates chef config with policyfile options" do
+            expected_config = <<-CONFIG
+# SSL Settings:
+ssl_verify_mode :verify_peer
+
+# Policyfile Settings:
+use_policyfile true
+policy_document_native_api true
+
+policy_group "some-policy-group"
+policy_name "myapp"
+
+CONFIG
+            expect(context.chef_config).to eq(expected_config)
+          end
+
+
+          include_examples "common_optional_options"
+
+        end
+
+      end # when --sync POLICYFILE argument is given
+
+      context "when a --policy-name is given" do
+
+        let(:given_policy_group) { "some-policy-group" }
+
+        let(:extra_params) { [] }
+
+        let(:params) { [ given_policy_group, '--policy-name', "myapp" ] + extra_params }
+
+
+        before do
+          command.apply_params!(params)
+          command.setup_context
+
+          allow(chef_config).to receive(:ssl_verify_mode).and_return(:verify_peer)
+        end
+
+        it "sets policy group" do
+          expect(command.policy_group).to eq(given_policy_group)
+          expect(context.policy_group).to eq(given_policy_group)
+        end
+
+        it "sets policy name" do
+          expect(command.policy_name).to eq("myapp")
+          expect(context.policy_name).to eq("myapp")
+        end
+
+        it "generates chef config with policyfile options" do
+          expected_config = <<-CONFIG
+# SSL Settings:
+ssl_verify_mode :verify_peer
+
+# Policyfile Settings:
+use_policyfile true
+policy_document_native_api true
+
+policy_group "some-policy-group"
+policy_name "myapp"
+
+CONFIG
+          expect(context.chef_config).to eq(expected_config)
+        end
+
+        include_examples "common_optional_options"
+
+      end
+    end
+
+  end
+
+  describe "running the provision cookbook" do
+
+    let(:ui) { TestHelpers::TestUI.new }
+
+    before do
+      allow(chef_config_loader).to receive(:load)
+      allow(command).to receive(:push).and_return(push_service)
+      command.ui = ui
+    end
+
+    let(:provision_cookbook_path) { File.expand_path("provision", Dir.pwd) }
+    let(:provision_recipe_path) { File.join(provision_cookbook_path, "recipes", "default.rb") }
+
+    let(:chef_runner) { instance_double("ChefDK::ChefRunner") }
+
+    let(:params) { %w[ policygroup --sync ] }
+
+    context "when the provision cookbook doesn't exist" do
+
+      before do
+        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(false)
+      end
+
+      it "prints an error and exits non-zero" do
+        expect(command.run(params)).to eq(1)
+        expect(ui.output).to include("Provisioning cookbook not found at path #{provision_cookbook_path}")
+      end
+
+    end
+
+    context "when the provision cookbook doesn't have the requested recipe" do
+
+      before do
+        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(true)
+        allow(File).to receive(:exist?).with(provision_recipe_path).and_return(false)
+      end
+
+      it "prints an error and exits non-zero" do
+        expect(command.run(params)).to eq(1)
+        expect(ui.output).to include("Provisioning recipe not found at path #{provision_recipe_path}")
+      end
+
+    end
+
+    context "when the policyfile upload fails" do
+
+      let(:backtrace) { caller[0...3] }
+
+      let(:cause) do
+        e = StandardError.new("some operation failed")
+        e.set_backtrace(backtrace)
+        e
+      end
+
+      let(:exception) do
+        ChefDK::PolicyfilePushError.new("push failed", cause)
+      end
+
+      before do
+        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(true)
+        allow(File).to receive(:exist?).with(provision_recipe_path).and_return(true)
+
+        expect(push_service).to receive(:run).and_raise(exception)
+      end
+
+      it "prints an error and exits non-zero" do
+          expected_output=<<-E
+Error: push failed
+Reason: (StandardError) some operation failed
+
+E
+        expect(command.run(params)).to eq(1)
+        expect(ui.output).to include(expected_output)
+      end
+
+    end
+
+    context "when the chef run fails" do
+
+      let(:base_exception) { StandardError.new("Something went wrong") }
+      let(:exception) { ChefDK::ChefConvergeError.new("Chef failed to converge: #{base_exception}", base_exception) }
+
+      let(:policy_data) { { "name" => "myapp" } }
+
+      before do
+        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(true)
+        allow(File).to receive(:exist?).with(provision_recipe_path).and_return(true)
+
+        allow(push_service).to receive(:policy_data).and_return(policy_data)
+
+        expect(push_service).to receive(:run)
+
+        allow(command).to receive(:chef_runner).and_return(chef_runner)
+        allow(chef_runner).to receive(:cookbook_path).and_return(Dir.pwd)
+        expect(chef_runner).to receive(:converge).and_raise(exception)
+      end
+
+      it "prints an error and exits non-zero" do
+        expect(command.run(params)).to eq(1)
+        expect(ui.output).to include("Error: Chef failed to converge")
+        expect(ui.output).to include("Reason: (StandardError) Something went wrong")
+      end
+
+    end
+
+    context "when the chef run is successful" do
+
+      before do
+        allow(File).to receive(:exist?).with(provision_cookbook_path).and_return(true)
+        allow(File).to receive(:exist?).with(provision_recipe_path).and_return(true)
+        allow(command).to receive(:chef_runner).and_return(chef_runner)
+        allow(chef_runner).to receive(:cookbook_path).and_return(Dir.pwd)
+
+        expect(chef_runner).to receive(:converge)
+      end
+
+      context "when using --no-policy" do
+
+        let(:params) { %w[ --no-policy ] }
+
+        it "exits 0" do
+          return_value = command.run(params)
+          expect(ui.output).to eq("")
+          expect(return_value).to eq(0)
+        end
+
+      end
+
+      context "with --policy-name" do
+
+        let(:params) { %w[ policygroup --policy-name otherapp ] }
+
+        it "exits 0" do
+          return_value = command.run(params)
+          expect(ui.output).to eq("")
+          expect(return_value).to eq(0)
+        end
+      end
+
+      context "with --sync" do
+
+        let(:policy_data) { { "name" => "myapp" } }
+
+        before do
+          allow(push_service).to receive(:policy_data).and_return(policy_data)
+          expect(push_service).to receive(:run)
+        end
+
+        it "exits 0" do
+          return_value = command.run(params)
+          expect(ui.output).to eq("")
+          expect(return_value).to eq(0)
+        end
+
+      end
+
+    end
+
+  end
+end
+