chef-cli 1.0.3

data/spec/unit/command/shell_init_spec.rb

@@ -0,0 +1,339 @@
+#
+# Copyright:: Copyright (c) 2014-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-cli/command/shell_init"
+
+describe ChefCLI::Command::ShellInit do
+
+  let(:expected_path) { [omnibus_bin_dir, user_bin_dir, omnibus_embedded_bin_dir, ENV["PATH"], git_bin_dir].join(File::PATH_SEPARATOR) }
+  let(:stdout_io) { StringIO.new }
+  let(:stderr_io) { StringIO.new }
+
+  let(:command_instance) do
+    ChefCLI::Command::ShellInit.new.tap do |c|
+      allow(c).to receive(:stdout).and_return(stdout_io)
+      allow(c).to receive(:stderr).and_return(stderr_io)
+    end
+  end
+
+  shared_context "shell init script" do |shell|
+    let(:user_bin_dir) { File.expand_path(File.join(Gem.user_dir, "bin")) }
+    let(:expected_gem_root) { Gem.default_dir.to_s }
+    let(:expected_gem_home) { Gem.user_dir }
+    let(:expected_gem_path) { Gem.path.join(File::PATH_SEPARATOR) }
+
+    before do
+      allow(::Dir).to receive(:exist?).and_call_original
+    end
+
+    context "with no explicit omnibus directory" do
+
+      let(:omnibus_bin_dir) { "/foo/bin" }
+      let(:omnibus_embedded_bin_dir) { "/foo/embedded/bin" }
+      let(:git_bin_dir) { "/foo/gitbin" }
+      let(:argv) { [shell] }
+
+      before do
+        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)
+        allow(command_instance).to receive(:git_bin_dir).and_return(git_bin_dir)
+        allow(::Dir).to receive(:exist?).with(git_bin_dir).and_return(true)
+      end
+
+      it "emits a script to add ChefCLI's ruby to the shell environment" do
+        command_instance.run(argv)
+        expect(stdout_io.string).to include(expected_environment_commands)
+      end
+
+      it "does not emit any empty lines", if: %w{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
+
+    context "with an explicit omnibus directory as an argument" do
+
+      let(:omnibus_root) { File.join(fixtures_path, "eg_omnibus_dir/valid/") }
+      let(:omnibus_bin_dir) { File.join(omnibus_root, "bin") }
+      let(:omnibus_embedded_bin_dir) { File.join(omnibus_root, "embedded/bin") }
+      let(:git_bin_dir) { File.join(omnibus_root, "gitbin") }
+
+      let(:argv) { [shell, "--omnibus-dir", omnibus_root] }
+
+      before do
+        allow(::Dir).to receive(:exist?).with(git_bin_dir).and_return(true)
+      end
+
+      it "emits a script to add the package's ruby to the shell environment" do
+        command_instance.run(argv)
+        expect(stdout_io.string).to include(expected_environment_commands)
+      end
+
+      it "does not emit any empty lines", if: %w{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
+
+  shared_examples "a posix shell script" do |shell|
+    before do
+      stub_const("File::PATH_SEPARATOR", ":")
+    end
+
+    let(:expected_environment_commands) do
+      <<~EOH
+        export PATH="#{expected_path}"
+        export GEM_ROOT="#{expected_gem_root}"
+        export GEM_HOME="#{expected_gem_home}"
+        export GEM_PATH="#{expected_gem_path}"
+      EOH
+    end
+    include_context "shell init script", shell
+  end
+
+  shared_examples "a powershell script" do |shell|
+    before do
+      stub_const("File::PATH_SEPARATOR", ";")
+    end
+
+    let(:expected_environment_commands) do
+      <<~EOH
+        $env:PATH="#{expected_path}"
+        $env:GEM_ROOT="#{expected_gem_root}"
+        $env:GEM_HOME="#{expected_gem_home}"
+        $env:GEM_PATH="#{expected_gem_path}"
+      EOH
+    end
+    include_context "shell init script", shell
+  end
+
+  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 #{ChefCLI::Dist::PRODUCT}",
+          "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 #{ChefCLI::Dist::PRODUCT}",
+          "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 #{ChefCLI::Dist::PRODUCT}'
+                '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
+
+  context "for fish" do
+    before do
+      stub_const("File::PATH_SEPARATOR", ":")
+    end
+    let(:expected_path) { [omnibus_bin_dir, user_bin_dir, omnibus_embedded_bin_dir, ENV["PATH"], git_bin_dir].join(":").split(":").join('" "') }
+    let(:expected_environment_commands) do
+      <<~EOH
+        set -gx PATH "#{expected_path}" 2>/dev/null;
+        set -gx GEM_ROOT "#{expected_gem_root}";
+        set -gx GEM_HOME "#{expected_gem_home}";
+        set -gx GEM_PATH "#{expected_gem_path}";
+      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 #{ChefCLI::Dist::PRODUCT}",
+          "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 #{ChefCLI::Dist::PRODUCT}
+
+          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 Chef Workstation"
+          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
+
+  %w{powershell posh}.each do |shell|
+    context "for #{shell}" do
+      it_behaves_like "a powershell script", shell
+    end
+  end
+
+  context "when no shell is specified" do
+
+    let(:argv) { [] }
+
+    it "exits with an error message" do
+      expect(command_instance.run(argv)).to eq(1)
+      expect(stderr_io.string).to include("Please specify what shell you are using")
+    end
+
+  end
+
+  context "when an unsupported shell is specified" do
+
+    let(:argv) { ["nosuchsh"] }
+
+    it "exits with an error message" do
+      expect(command_instance.run(argv)).to eq(1)
+      expect(stderr_io.string).to include("Shell `nosuchsh' is not currently supported")
+      expect(stderr_io.string).to include("Supported shells are: bash fish zsh sh powershell posh")
+    end
+
+  end
+
+end

data/spec/unit/command/show_policy_spec.rb

@@ -0,0 +1,234 @@
+#
+# 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-cli/command/show_policy"
+
+describe ChefCLI::Command::ShowPolicy do
+
+  it_behaves_like "a command with a UI object"
+
+  subject(:command) do
+    described_class.new
+  end
+
+  let(:show_policy_service) { command.show_policy_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) { [] }
+
+    before do
+      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(show_policy_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 "is configured to show all policies across all groups" do
+          expect(show_policy_service.show_all_policies?).to be(true)
+        end
+
+        it "disables displaying orphans" do
+          expect(command.show_orphans?).to be(false)
+          expect(show_policy_service.show_orphans?).to be(false)
+        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 --show-orphans is given" do
+
+        let(:params) { %w{ -o } }
+
+        it "enables displaying orphans" do
+          expect(command.show_orphans?).to be(true)
+          expect(show_policy_service.show_orphans?).to be(true)
+        end
+
+      end
+
+      context "when given a policy name" do
+
+        let(:params) { %w{ appserver } }
+
+        it "is not configured to show all policies" do
+          expect(show_policy_service.show_all_policies?).to be(false)
+        end
+
+        it "is configured to show the given policy" do
+          expect(command.policy_name).to eq("appserver")
+          expect(show_policy_service.policy_name).to eq("appserver")
+        end
+
+      end
+
+      context "when given a policy name and a policy group name" do
+
+        let(:params) { %w{ appserver production } }
+
+        it "is not configured to show all policies" do
+          expect(show_policy_service.show_all_policies?).to be(false)
+        end
+
+        it "is configured to show the given policy" do
+          expect(command.policy_name).to eq("appserver")
+          expect(show_policy_service.policy_name).to eq("appserver")
+        end
+
+        it "is configured to display the exact revision for the given policy+group" do
+          expect(command.policy_group).to eq("production")
+          expect(show_policy_service.policy_group).to eq("production")
+        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{ appserver policygroup wut-is-this } }
+
+      it "shows usage and exits" do
+        expect(command.run(params)).to eq(1)
+      end
+
+    end
+
+    context "when the list service raises an exception" do
+
+      let(:backtrace) { caller[0...3] }
+
+      let(:cause) do
+        e = StandardError.new("some operation failed")
+        e.set_backtrace(backtrace)
+        e
+      end
+
+      let(:exception) do
+        ChefCLI::PolicyfileListError.new("Failed to list policies", cause)
+      end
+
+      before do
+        allow(command.show_policy_service).to receive(:run).and_raise(exception)
+      end
+
+      it "prints a debugging message and exits non-zero" do
+        expect(command.run([])).to eq(1)
+
+        expected_output = <<~E
+          Error: Failed to list policies
+          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(%w{ -D })
+
+          expected_output = <<~E
+            Error: Failed to list policies
+            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 list service executes successfully" do
+
+      before do
+        expect(command.show_policy_service).to receive(:run)
+      end
+
+      it "exits 0" do
+        expect(command.run([])).to eq(0)
+      end
+
+    end
+
+  end
+end