chef-cli 1.0.3

data/spec/unit/command/env_spec.rb

@@ -0,0 +1,86 @@
+#
+# 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 "yaml"
+require "chef-cli/command/env"
+
+describe ChefCLI::Command::Env do
+  let(:ui) { TestHelpers::TestUI.new }
+  let(:command_instance) { ChefCLI::Command::Env.new() }
+
+  let(:command_options) { [] }
+
+  let(:user_bin_dir) { File.expand_path(File.join(Gem.user_dir, "bin")) }
+  let(:omnibus_embedded_bin_dir) { "/foo/embedded/bin" }
+  let(:omnibus_bin_dir) { "/foo/bin" }
+
+  it "has a usage banner" do
+    expect(command_instance.banner).to eq("Usage: chef env")
+  end
+
+  describe "when running from within an omnibus install" do
+    before do
+      allow(command_instance).to receive(:omnibus_install?).and_return true
+      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)
+      command_instance.ui = ui
+    end
+
+    describe "and the env command is run" do
+      let(:yaml) { YAML.load(ui.output) }
+      before :each do
+        run_command
+      end
+      it "output should be valid yaml" do
+        expect { yaml }.not_to raise_error
+      end
+      it "should include correct Workstation version info" do
+        expect(yaml).to have_key ChefCLI::Dist::PRODUCT
+        expect(yaml[ChefCLI::Dist::PRODUCT]["Version"]).to eql ChefCLI::VERSION
+      end
+    end
+  end
+  describe "when running locally" do
+    before do
+      allow(command_instance).to receive(:omnibus_install?).and_return false
+      command_instance.ui = ui
+    end
+
+    describe "and the env command is run" do
+      let(:yaml) { YAML.load(ui.output) }
+      before :each do
+        run_command
+      end
+      it "output should be valid yaml" do
+        expect { yaml }.not_to raise_error
+      end
+      it "Workstation version should indicate that that we're not runnign from a WS install" do
+        expect(yaml).to have_key ChefCLI::Dist::PRODUCT
+        expect(yaml[ChefCLI::Dist::PRODUCT]["Version"]).to eql "Not running from within Workstation"
+      end
+      it "should return valid yaml" do
+        run_command
+        expect { YAML.load(ui.output) }.not_to raise_error
+      end
+    end
+  end
+  def run_command
+    command_instance.run_with_default_options(false, command_options)
+  end
+
+end

data/spec/unit/command/exec_spec.rb

@@ -0,0 +1,178 @@
+#
+# 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/exec"
+
+describe ChefCLI::Command::Exec do
+  let(:command_instance) { ChefCLI::Command::Exec.new() }
+
+  let(:command_options) { [] }
+
+  def run_command
+    command_instance.run_with_default_options(false, command_options)
+  end
+
+  it "has a usage banner" do
+    expect(command_instance.banner).to eq("Usage: chef exec SYSTEM_COMMAND")
+  end
+
+  describe "when locating omnibus directory" do
+    it "should find omnibus bin directory from ruby path" do
+      allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin/ruby"))
+      expect(command_instance.omnibus_bin_dir).to include("eg_omnibus_dir/valid/bin")
+    end
+
+    it "should find omnibus embedded bin directory from ruby path" do
+      allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin/ruby"))
+      expect(command_instance.omnibus_embedded_bin_dir).to include("eg_omnibus_dir/valid/embedded/bin")
+    end
+
+    it "should raise OmnibusInstallNotFound if directory is not looking like omnibus" do
+      allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, ".rbenv/versions/2.1.1/bin/ruby"))
+      expect { command_instance.omnibus_bin_dir }.to raise_error(ChefCLI::OmnibusInstallNotFound)
+    end
+
+    it "should raise OmnibusInstallNotFound if directory is not looking like omnibus" do
+      allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, ".rbenv/versions/2.1.1/bin/ruby"))
+      expect { command_instance.omnibus_embedded_bin_dir }.to raise_error(ChefCLI::OmnibusInstallNotFound)
+    end
+  end
+
+  describe "when running exec command" do
+    let(:ruby_path) { File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin/ruby") }
+
+    before do
+      allow(Gem).to receive(:ruby).and_return(ruby_path)
+
+      # Using a fake path separator to keep to prevent people from accidently
+      # getting things correct on their system. This enforces that, in general,
+      # you should use the path separator ruby is telling you to use.
+      stub_const("File::PATH_SEPARATOR", "<>")
+    end
+
+    context "when running exec env" do
+      let(:command_options) { %w{gem list} }
+
+      let(:user_bin_dir) { File.expand_path(File.join(Gem.user_dir, "bin")) }
+
+      let(:omnibus_embedded_bin_dir) { "/foo/embedded/bin" }
+
+      let(:omnibus_bin_dir) { "/foo/bin" }
+
+      let(:expected_PATH) { [omnibus_bin_dir, user_bin_dir, omnibus_embedded_bin_dir, ENV["PATH"]].join(File::PATH_SEPARATOR) }
+
+      let(:expected_GEM_ROOT) { Gem.default_dir }
+
+      let(:expected_GEM_HOME) { Gem.user_dir }
+
+      let(:expected_GEM_PATH) { Gem.path.join(File::PATH_SEPARATOR) }
+
+      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)
+      end
+
+      it "should call exec to fire off the command with the correct environment" do
+        expect(ENV).to receive(:[]=).with("PATH", expected_PATH)
+        expect(ENV).to receive(:[]=).with("GEM_ROOT", expected_GEM_ROOT)
+        expect(ENV).to receive(:[]=).with("GEM_HOME", expected_GEM_HOME)
+        expect(ENV).to receive(:[]=).with("GEM_PATH", expected_GEM_PATH)
+
+        expect(command_instance).to receive(:exec).with(*command_options)
+        expect { run_command }.to raise_error(RuntimeError) # XXX: this isn't a test we just need to swallow the exception
+      end
+
+      ["-v", "--version", "-h", "--help"].each do |switch|
+        context "when running a command with #{switch}" do
+          let(:command_options) { %W{gem list #{switch}} }
+
+          it "should call exec to fire off the command with the correct environment" do
+            expect(ENV).to receive(:[]=).with("PATH", expected_PATH)
+            expect(ENV).to receive(:[]=).with("GEM_ROOT", expected_GEM_ROOT)
+            expect(ENV).to receive(:[]=).with("GEM_HOME", expected_GEM_HOME)
+            expect(ENV).to receive(:[]=).with("GEM_PATH", expected_GEM_PATH)
+
+            expect(command_instance).to receive(:exec).with(*command_options)
+            expect { run_command }.to raise_error(RuntimeError) # XXX: this isn't a test we just need to swallow the exception
+          end
+        end
+      end
+
+      ["-h", "--help"].each do |switch|
+        context "when running a exec with #{switch} and things after it" do
+          let(:command_options) { %W{#{switch} gem} }
+
+          it "should call not call exec, but it should print the banner" do
+            allow(command_instance).to receive(:msg)
+            expect(ENV).not_to receive(:[]=)
+            expect(command_instance).to receive(:banner)
+            expect(command_instance).not_to receive(:exec)
+            run_command
+          end
+        end
+
+        context "when running a exec with #{switch}" do
+          let(:command_options) { ["#{switch}"] }
+
+          it "should call not call exec, but it should print the banner" do
+            allow(command_instance).to receive(:msg)
+            expect(ENV).not_to receive(:[]=)
+            expect(command_instance).to receive(:banner)
+            expect(command_instance).not_to receive(:exec)
+            run_command
+          end
+        end
+      end
+    end
+
+    context "when running command that does not exist" do
+      let(:command_options) { %w{chef_rules_everything_aroundme} }
+
+      let(:user_bin_dir) { File.expand_path(File.join(Gem.user_dir, "bin")) }
+
+      let(:omnibus_bin_dir) { "/foo/bin" }
+
+      let(:omnibus_embedded_bin_dir) { "/foo/embedded/bin" }
+
+      let(:expected_PATH) { [omnibus_bin_dir, user_bin_dir, omnibus_embedded_bin_dir, ENV["PATH"]].join(File::PATH_SEPARATOR) }
+
+      let(:expected_GEM_ROOT) { Gem.default_dir }
+
+      let(:expected_GEM_HOME) { Gem.user_dir }
+
+      let(:expected_GEM_PATH) { Gem.path.join(File::PATH_SEPARATOR) }
+
+      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)
+      end
+
+      it "should raise Errno::ENOENT" do
+        expect(ENV).to receive(:[]=).with("PATH", expected_PATH)
+        expect(ENV).to receive(:[]=).with("GEM_ROOT", expected_GEM_ROOT)
+        expect(ENV).to receive(:[]=).with("GEM_HOME", expected_GEM_HOME)
+        expect(ENV).to receive(:[]=).with("GEM_PATH", expected_GEM_PATH)
+
+        # XXX: this doesn't really test much, but really calling exec will never return to rspec
+        expect(command_instance).to receive(:exec).with(*command_options).and_raise(Errno::ENOENT)
+        expect { run_command }.to raise_error(Errno::ENOENT)
+      end
+    end
+  end
+
+end

data/spec/unit/command/export_spec.rb

@@ -0,0 +1,199 @@
+#
+# 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 "shared/command_with_ui_object"
+require "chef-cli/command/export"
+
+describe ChefCLI::Command::Export do
+
+  it_behaves_like "a command with a UI object"
+
+  let(:params) { [] }
+
+  let(:command) do
+    described_class.new
+  end
+
+  let(:policyfile_lock) do
+    instance_double(ChefCLI::PolicyfileLock, name: "example-policy")
+  end
+
+  let(:export_service) do
+    instance_double(ChefCLI::PolicyfileServices::ExportRepo,
+                    policyfile_lock: policyfile_lock)
+  end
+
+  context "after evaluating params" do
+
+    let(:params) { [ "path/to/export" ] }
+
+    before do
+      command.apply_params!(params)
+    end
+
+    it "disables debug by default" do
+      expect(command.debug?).to be(false)
+    end
+
+    context "when debug mode is set" do
+
+      let(:params) { [ "path/to/export", "-D" ] }
+
+      it "enables debug" do
+        expect(command.debug?).to be(true)
+      end
+    end
+
+    context "when archive mode is set" do
+
+      let(:params) { [ "path/to/export", "-a" ] }
+
+      it "enables archiving the exported repo" do
+        expect(command.archive?).to be(true)
+      end
+
+      it "configures the export service to archive" do
+        expect(command.export_service.archive?).to be(true)
+      end
+    end
+
+    context "when the path to the exported repo is given" do
+
+      let(:params) { [ "path/to/export" ] }
+
+      it "configures the export service with the export path" do
+        expect(command.export_service.export_dir).to eq(File.expand_path("path/to/export"))
+      end
+
+      it "uses the default policyfile name" do
+        expect(command.export_service.policyfile_filename).to eq(File.expand_path("Policyfile.rb"))
+      end
+
+    end
+
+    context "when a Policyfile relative path and export path are given" do
+
+      let(:params) { [ "CustomNamedPolicy.rb", "path/to/export" ] }
+
+      it "configures the export service with the export path" do
+        expect(command.export_service.export_dir).to eq(File.expand_path("path/to/export"))
+      end
+
+      it "configures the export service with the policyfile relative path" do
+        expect(command.export_service.policyfile_filename).to eq(File.expand_path("CustomNamedPolicy.rb"))
+      end
+    end
+  end
+
+  describe "running the export" do
+
+    let(:params) { [ "/path/to/export" ] }
+
+    let(:ui) { TestHelpers::TestUI.new }
+
+    before do
+      command.ui = ui
+      allow(command).to receive(:export_service).and_return(export_service)
+    end
+
+    context "with no arguments" do
+
+      it "exits non-zero and prints a help message" do
+        expect(command.run).to eq(1)
+      end
+
+    end
+
+    context "when the command is successful" do
+
+      before do
+        expect(export_service).to receive(:run)
+      end
+
+      it "returns 0" do
+        expect(command.run(params)).to eq(0)
+      end
+
+      it "prints instructions for running chef-client in the repo" do
+        command.run(params)
+
+        expected_message = <<~MESSAGE
+          To converge this system with the exported policy, run:
+            cd /path/to/export
+            chef-client -z
+        MESSAGE
+        expect(ui.output).to include(expected_message)
+      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
+        ChefCLI::PolicyfileExportRepoError.new("export failed", cause)
+      end
+
+      before do
+        expect(export_service).to receive(:run).and_raise(exception)
+      end
+
+      it "returns 1" do
+        expect(command.run(params)).to eq(1)
+      end
+
+      it "displays the exception and cause" do
+        expected_error_text = <<~E
+          Error: export failed
+          Reason: (StandardError) some operation failed
+
+        E
+
+        command.run(params)
+        expect(ui.output).to eq(expected_error_text)
+      end
+
+      context "and debug is enabled" do
+
+        let(:params) { [ "path/to/export", "-D"] }
+
+        it "displays the exception and cause with backtrace" do
+          expected_error_text = <<~E
+            Error: export failed
+            Reason: (StandardError) some operation failed
+
+
+          E
+
+          expected_error_text << backtrace.join("\n") << "\n"
+
+          command.run(params)
+          expect(ui.output).to eq(expected_error_text)
+        end
+      end
+
+    end
+
+  end
+end