chef-dk 0.7.0 → 0.8.0

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

@@ -99,7 +99,7 @@ describe ChefDK::Command::GeneratorCommands::Cookbook do
 
     it "prints usage when args are empty" do
       with_argv([]).run
-      expect(stdout_io.string).to eq(expected_help_message)
+      expect(stderr_io.string).to include(expected_help_message)
     end
 
   end

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

@@ -115,7 +115,7 @@ describe ChefDK::Command::GeneratorCommands::Policyfile do
       expected_stdout = "Usage: chef generate policyfile [NAME] [options]"
 
       expect(generator.run).to eq(1)
-      expect(stdout).to include(expected_stdout)
+      expect(stderr).to include(expected_stdout)
     end
 
   end

data/spec/unit/command/install_spec.rb

@@ -37,6 +37,10 @@ describe ChefDK::Command::Install 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" ] }
@@ -46,6 +50,26 @@ describe ChefDK::Command::Install do
     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

data/spec/unit/command/shell_init_spec.rb

@@ -50,7 +50,14 @@ describe ChefDK::Command::ShellInit do
 
       it "emits a script to add ChefDK's ruby to the shell environment" do
         command_instance.run(argv)
-        expect(stdout_io.string).to eq(expected_environment_commands)
+        expect(stdout_io.string).to include(expected_environment_commands)
+      end
+
+      it "does not emit any empty lines", :if => ["powershell", "posh"].include?(shell) do
+        command_instance.run(argv)
+        stdout_io.string.each_line do |s|
+          expect(s.strip).not_to be_empty
+        end
       end
     end
 
@@ -64,7 +71,14 @@ describe ChefDK::Command::ShellInit do
 
       it "emits a script to add ChefDK's ruby to the shell environment" do
         command_instance.run(argv)
-        expect(stdout_io.string).to eq(expected_environment_commands)
+        expect(stdout_io.string).to include(expected_environment_commands)
+      end
+
+      it "does not emit any empty lines", :if => ["powershell", "posh"].include?(shell) do
+        command_instance.run(argv)
+        stdout_io.string.each_line do |s|
+          expect(s.strip).not_to be_empty
+        end
       end
     end
   end
@@ -101,9 +115,118 @@ EOH
     include_context "shell init script", shell
   end
 
-  ['bash', 'sh', 'zsh'].each do |shell|
-    context "for #{shell}" do
-      it_behaves_like "a posix shell script", shell
+  context "for sh" do
+    it_behaves_like "a posix shell script", "sh"
+  end
+
+  context "for bash" do
+    it_behaves_like "a posix shell script", "bash"
+
+    describe "generating auto-complete" do
+
+      let(:command_descriptions) do
+        {
+          "exec" => "Runs the command in context of the embedded ruby",
+          "env" => "Prints environment variables used by ChefDK",
+          "gem" => "Runs the `gem` command in context of the embedded ruby",
+          "generate" => "Generate a new app, cookbook, or component"
+        }
+      end
+
+      let(:omnibus_bin_dir) { "/foo/bin" }
+      let(:omnibus_embedded_bin_dir) { "/foo/embedded/bin" }
+
+      let(:argv) { [ "bash" ] }
+
+      let(:expected_completion_function) do
+        <<-END_COMPLETION
+_chef_comp() {
+    local COMMANDS="exec env gem generate"
+    COMPREPLY=($(compgen -W "$COMMANDS" -- ${COMP_WORDS[COMP_CWORD]} ))
+}
+complete -F _chef_comp chef
+END_COMPLETION
+      end
+
+      before do
+        # Stub this or else we'd have to update the test every time a new command
+        # is added.
+        allow(command_instance.shell_completion_template_context).to receive(:commands).
+          and_return(command_descriptions)
+
+        allow(command_instance).to receive(:omnibus_embedded_bin_dir).and_return(omnibus_embedded_bin_dir)
+        allow(command_instance).to receive(:omnibus_bin_dir).and_return(omnibus_bin_dir)
+      end
+
+      it "generates a completion function for the chef command" do
+        command_instance.run(argv)
+        expect(stdout_io.string).to include(expected_completion_function)
+      end
+
+    end
+  end
+
+  context "for zsh" do
+
+    it_behaves_like "a posix shell script", "zsh"
+
+    describe "generating auto-complete" do
+
+      let(:command_descriptions) do
+        {
+          "exec" => "Runs the command in context of the embedded ruby",
+          "env" => "Prints environment variables used by ChefDK",
+          "gem" => "Runs the `gem` command in context of the embedded ruby",
+          "generate" => "Generate a new app, cookbook, or component"
+        }
+      end
+
+      let(:omnibus_bin_dir) { "/foo/bin" }
+      let(:omnibus_embedded_bin_dir) { "/foo/embedded/bin" }
+
+      let(:argv) { [ "zsh" ] }
+
+      let(:expected_completion_function) do
+        <<-END_COMPLETION
+function _chef() {
+
+  local -a _1st_arguments
+  _1st_arguments=(
+      'exec:Runs the command in context of the embedded ruby'
+      'env:Prints environment variables used by ChefDK'
+      'gem:Runs the `gem` command in context of the embedded ruby'
+      'generate:Generate a new app, cookbook, or component'
+    )
+
+  _arguments \\
+    '(-v --version)'{-v,--version}'[version information]' \\
+    '*:: :->subcmds' && return 0
+
+  if (( CURRENT == 1 )); then
+    _describe -t commands "chef subcommand" _1st_arguments
+    return
+  fi
+}
+
+compdef _chef chef
+
+        END_COMPLETION
+      end
+
+      before do
+        # Stub this or else we'd have to update the test every time a new command
+        # is added.
+        allow(command_instance.shell_completion_template_context).to receive(:commands).
+          and_return(command_descriptions)
+
+        allow(command_instance).to receive(:omnibus_embedded_bin_dir).and_return(omnibus_embedded_bin_dir)
+        allow(command_instance).to receive(:omnibus_bin_dir).and_return(omnibus_bin_dir)
+      end
+
+      it "generates a completion function for the chef command" do
+        command_instance.run(argv)
+        expect(stdout_io.string).to include(expected_completion_function)
+      end
     end
   end
 
@@ -122,6 +245,54 @@ EOH
     end
 
     include_context 'shell init script', 'fish'
+
+    describe "generating auto-complete" do
+
+      let(:command_descriptions) do
+        {
+          "exec" => "Runs the command in context of the embedded ruby",
+          "env" => "Prints environment variables used by ChefDK",
+          "gem" => "Runs the `gem` command in context of the embedded ruby",
+          "generate" => "Generate a new app, cookbook, or component"
+        }
+      end
+
+      let(:omnibus_bin_dir) { "/foo/bin" }
+      let(:omnibus_embedded_bin_dir) { "/foo/embedded/bin" }
+
+      let(:argv) { [ "fish" ] }
+
+      let(:expected_completion_function) do
+        <<-END_COMPLETION
+# Fish Shell command-line completions for ChefDK
+
+function __fish_chef_no_command --description 'Test if chef has yet to be given the main command'
+  set -l cmd (commandline -opc)
+  test (count $cmd) -eq 1
+end
+
+complete -c chef -f -n '__fish_chef_no_command' -a exec -d "Runs the command in context of the embedded ruby"
+complete -c chef -f -n '__fish_chef_no_command' -a env -d "Prints environment variables used by ChefDK"
+complete -c chef -f -n '__fish_chef_no_command' -a gem -d "Runs the `gem` command in context of the embedded ruby"
+complete -c chef -f -n '__fish_chef_no_command' -a generate -d "Generate a new app, cookbook, or component"
+END_COMPLETION
+      end
+
+      before do
+        # Stub this or else we'd have to update the test every time a new command
+        # is added.
+        allow(command_instance.shell_completion_template_context).to receive(:commands).
+          and_return(command_descriptions)
+
+        allow(command_instance).to receive(:omnibus_embedded_bin_dir).and_return(omnibus_embedded_bin_dir)
+        allow(command_instance).to receive(:omnibus_bin_dir).and_return(omnibus_bin_dir)
+      end
+
+      it "generates a completion function for the chef command" do
+        command_instance.run(argv)
+        expect(stdout_io.string).to include(expected_completion_function)
+      end
+    end
   end
 
   ['powershell', 'posh'].each do |shell|

data/spec/unit/command/undelete_spec.rb

@@ -0,0 +1,246 @@
+#
+# 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/undelete'
+
+describe ChefDK::Command::Undelete do
+
+  it_behaves_like "a command with a UI object"
+
+  subject(:command) do
+    described_class.new
+  end
+
+  let(:undelete_service) { command.undelete_service }
+
+  let(:chef_config_loader) { instance_double("Chef::WorkstationConfigLoader") }
+
+  let(:chef_config) { double("Chef::Config") }
+
+  # nil means the config loader will do the default path lookup
+  let(:config_arg) { nil }
+
+  before do
+    stub_const("Chef::Config", chef_config)
+    allow(Chef::WorkstationConfigLoader).to receive(:new).with(config_arg).and_return(chef_config_loader)
+  end
+
+  describe "parsing args and options" do
+    let(:params) { [] }
+
+    let(:ui) { TestHelpers::TestUI.new }
+
+    before do
+      command.ui = ui
+      command.apply_params!(params)
+    end
+
+    context "when given a path to the config" do
+
+      let(:params) { %w[ -c ~/otherstuff/config.rb ] }
+
+      let(:config_arg) { "~/otherstuff/config.rb" }
+
+      before do
+        expect(chef_config_loader).to receive(:load)
+      end
+
+      it "reads the chef/knife config" do
+        expect(Chef::WorkstationConfigLoader).to receive(:new).with(config_arg).and_return(chef_config_loader)
+        expect(command.chef_config).to eq(chef_config)
+        expect(undelete_service.chef_config).to eq(chef_config)
+      end
+
+    end
+
+    describe "settings that require loading chef config" do
+
+      before do
+        allow(chef_config_loader).to receive(:load)
+      end
+
+      context "with no params" do
+
+        it "disables debug by default" do
+          expect(command.debug?).to be(false)
+        end
+
+        it "enables listing undo records" do
+          expect(command.list_undo_records?).to be(true)
+        end
+
+      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 --last is given" do
+
+        let(:params) { %w[ -l ] }
+
+        it "disables list mode" do
+          expect(command.list_undo_records?).to be(false)
+        end
+
+        it "has no undo id" do
+          expect(command.undo_record_id).to be_nil
+          expect(command.undelete_service.undo_record_id).to be_nil
+        end
+
+      end
+
+      context "when given a undo record id via --id" do
+
+        let(:undo_id) { "20150827180422" }
+
+        let(:params) { [ "-i", undo_id ] }
+
+        it "disables list mode" do
+          expect(command.list_undo_records?).to be(false)
+        end
+
+        it "is configured to perform undo for the given undo id" do
+          expect(command.undo_record_id).to eq(undo_id)
+          expect(command.undelete_service.undo_record_id).to eq(undo_id)
+        end
+
+      end
+
+      context "when exclusive options --last and --id are given" do
+
+        let(:params) { %w[ --last --id foo ] }
+
+        it "emits an error message saying they are exclusive and exits" do
+          expect(ui.output).to include("Error: options --last and --id cannot both be given.")
+          expect(ui.output).to include(command.opt_parser.to_s)
+        end
+
+      end
+
+    end
+  end
+
+
+  describe "running the command" do
+
+    let(:ui) { TestHelpers::TestUI.new }
+
+    before do
+      allow(chef_config_loader).to receive(:load)
+      command.ui = ui
+    end
+
+    context "when given too many arguments" do
+
+      let(:params) { %w[ extra-thing ] }
+
+      it "shows usage and exits" do
+        expect(command.run(params)).to eq(1)
+      end
+
+    end
+
+    describe "running the command in list mode" do
+
+      let(:params) { [] }
+
+      it "lists the undo operations" do
+        expect(command.undelete_service).to receive(:list)
+        expect(command.run(params)).to eq(0)
+      end
+
+    end
+
+    context "when the undelete service raises an exception" do
+
+      let(:params) { %w[ --last ] }
+
+      let(:backtrace) { caller[0...3] }
+
+      let(:cause) do
+        e = StandardError.new("some operation failed")
+        e.set_backtrace(backtrace)
+        e
+      end
+
+      let(:exception) do
+        ChefDK::UndeleteError.new("Failed to undelete.", cause)
+      end
+
+      before do
+        allow(command.undelete_service).to receive(:run).and_raise(exception)
+      end
+
+      it "prints a debugging message and exits non-zero" do
+        expect(command.run(params)).to eq(1)
+
+        expected_output=<<-E
+Error: Failed to undelete.
+Reason: (StandardError) some operation failed
+
+E
+
+        expect(ui.output).to eq(expected_output)
+      end
+
+      context "when debug is enabled" do
+
+        it "includes the backtrace in the error" do
+
+          command.run(params + %w[ -D ])
+
+        expected_output=<<-E
+Error: Failed to undelete.
+Reason: (StandardError) some operation failed
+
+
+E
+          expected_output << backtrace.join("\n") << "\n"
+
+          expect(ui.output).to eq(expected_output)
+        end
+
+      end
+
+    end
+
+    context "when the undelete service executes successfully" do
+
+      let(:params) { %w[ --last ] }
+
+      before do
+        expect(command.undelete_service).to receive(:run)
+      end
+
+      it "exits 0" do
+        expect(command.run(params)).to eq(0)
+      end
+
+    end
+
+  end
+end
+