chef-cli 1.0.3

data/spec/unit/command/verify_spec.rb

@@ -0,0 +1,341 @@
+#
+# 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/verify"
+
+module Gem
+
+  # We stub Gem.ruby because `verify` uses it to locate the omnibus directory,
+  # but we also use it in some of the "test commands" in these tests.
+  class << self
+    alias :real_ruby :ruby
+  end
+end
+
+describe ChefCLI::Command::Verify do
+
+  let(:command_instance) { ChefCLI::Command::Verify.new() }
+
+  let(:command_options) { [] }
+
+  let(:components) { {} }
+
+  let(:default_components) do
+    [
+      "berkshelf",
+      "test-kitchen",
+      "tk-policyfile-provisioner",
+      "chef-client",
+      "chef-cli",
+      "chef-apply",
+      "chefspec",
+      "generated-cookbooks-pass-chefspec",
+      "fauxhai",
+      "knife-spork",
+      "kitchen-vagrant",
+      "package installation",
+      "openssl",
+      "inspec",
+      "chef-sugar",
+      "opscode-pushy-client",
+      "git",
+      "delivery-cli",
+    ]
+  end
+
+  def run_command(expected_exit_code)
+    expect(command_instance.run(command_options)).to eq(expected_exit_code)
+  end
+
+  it "defines berks, tk, chef and chef-cli components by default" do
+    expected_components = default_components
+    expect(command_instance.components).not_to be_empty
+    expect(command_instance.components.map(&:name)).to match_array(expected_components)
+  end
+
+  it "has a usage banner" do
+    expect(command_instance.banner).to eq("Usage: chef verify [component, ...] [options]")
+  end
+
+  describe "when locating omnibus directory from the ruby path" do
+    it "should find omnibus root 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_root).to end_with("eg_omnibus_dir/valid")
+    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 "raises OmnibusInstallNotFound if omnibus directory doesn't exist" do
+      allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, "eg_omnibus_dir/invalid/embedded/bin/ruby"))
+      expect { command_instance.omnibus_bin_dir }.to raise_error(ChefCLI::OmnibusInstallNotFound)
+    end
+
+    context "and a component's gem is not installed" do
+      before do
+        component_map = ChefCLI::Command::Verify.component_map.dup
+        component_map["cucumber"] = ChefCLI::ComponentTest.new("cucumber")
+        component_map["cucumber"].gem_base_dir = "cucumber"
+        allow(ChefCLI::Command::Verify).to receive(:component_map).and_return(component_map)
+      end
+
+      it "raises MissingComponentError when a component doesn't exist" do
+        allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, "eg_omnibus_dir/missing_component/embedded/bin/ruby"))
+        expect { command_instance.validate_components! }.to raise_error(ChefCLI::MissingComponentError)
+      end
+    end
+  end
+
+  describe "when running verify command" do
+    let(:stdout_io) { StringIO.new }
+    let(:stderr_io) { StringIO.new }
+    let(:ruby_path) { File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin/ruby") }
+
+    def run_unit_test
+      # Set rubyopt to empty to prevent bundler from infecting the ruby
+      # subcommands (and loading a bunch of extra gems).
+      lambda { |_self| sh("#{Gem.real_ruby} verify_me", env: { "RUBYOPT" => "" }) }
+    end
+
+    def run_integration_test
+      lambda { |_self| sh("#{Gem.real_ruby} integration_test", env: { "RUBYOPT" => "" }) }
+    end
+
+    let(:all_tests_ok) do
+      ChefCLI::ComponentTest.new("successful_comp").tap do |c|
+        c.base_dir = "embedded/apps/berkshelf"
+        c.unit_test(&run_unit_test)
+        c.integration_test(&run_integration_test)
+        c.smoke_test { sh("exit 0") }
+      end
+    end
+
+    let(:all_tests_ok_2) do
+      ChefCLI::ComponentTest.new("successful_comp_2").tap do |c|
+        c.base_dir = "embedded/apps/test-kitchen"
+        c.unit_test(&run_unit_test)
+        c.smoke_test { sh("exit 0") }
+      end
+    end
+
+    let(:failing_unit_test) do
+      ChefCLI::ComponentTest.new("failing_comp").tap do |c|
+        c.base_dir = "embedded/apps/chef"
+        c.unit_test(&run_unit_test)
+        c.smoke_test { sh("exit 0") }
+      end
+    end
+
+    let(:passing_smoke_test_only) do
+      component = failing_unit_test.dup
+      component.smoke_test { sh("exit 0") }
+      component
+    end
+
+    let(:failing_smoke_test_only) do
+      component = all_tests_ok.dup
+      component.smoke_test { sh("exit 1") }
+      component
+    end
+
+    let(:component_without_integration_tests) do
+      ChefCLI::ComponentTest.new("successful_comp").tap do |c|
+        c.base_dir = "embedded/apps/berkshelf"
+        c.unit_test { sh("./verify_me") }
+        c.smoke_test { sh("exit 0") }
+      end
+    end
+
+    def stdout
+      stdout_io.string
+    end
+
+    before do
+      allow(Gem).to receive(:ruby).and_return(ruby_path)
+      allow(command_instance).to receive(:stdout).and_return(stdout_io)
+      allow(command_instance).to receive(:stderr).and_return(stderr_io)
+      allow(command_instance).to receive(:components).and_return(components)
+    end
+
+    context "when running smoke tests only" do
+      describe "with single command with success" do
+        let(:components) do
+          [ passing_smoke_test_only ]
+        end
+
+        before do
+          run_command(0)
+        end
+
+        it "should report the success of the command" do
+          expect(stdout).to include("Verification of component 'failing_comp' succeeded.")
+        end
+
+      end
+
+      describe "with single command with failure" do
+        let(:components) do
+          [ failing_smoke_test_only ]
+        end
+
+        before do
+          run_command(1)
+        end
+
+        it "should report the failure of the command" do
+          expect(stdout).to include("Verification of component 'successful_comp' failed.")
+        end
+
+      end
+    end
+
+    context "when running unit tests" do
+
+      let(:command_options) { %w{--unit --verbose} }
+
+      let(:components) do
+        [ all_tests_ok ]
+      end
+
+      describe "with single command with success" do
+        before do
+          run_command(0)
+        end
+
+        it "should have embedded/bin on the PATH" do
+          expect(stdout).to include(File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin"))
+        end
+
+        it "should report the success of the command" do
+          expect(stdout).to include("Verification of component 'successful_comp' succeeded.")
+        end
+
+        it "reports the component test output" do
+          expect(stdout).to include("you are good to go...")
+        end
+
+        context "and --verbose is not enabled" do
+
+          let(:command_options) { %w{--unit} }
+
+          it "omits the component test output" do
+            expect(stdout).to_not include("you are good to go...")
+          end
+        end
+
+        context "and --integration flag is given" do
+
+          let(:command_options) { %w{--integration --verbose} }
+
+          it "should run the integration command also" do
+            expect(stdout).to include("integration tests OK")
+          end
+
+          context "and no integration test command is specifed for the component" do
+
+            let(:components) do
+              [ component_without_integration_tests ]
+            end
+
+            it "skips the integration test and succeeds" do
+              expect(stdout).to include("Verification of component 'successful_comp' succeeded.")
+            end
+
+          end
+
+        end
+
+      end
+
+      describe "with single command with failure" do
+        let(:components) do
+          [ failing_unit_test ]
+        end
+
+        before do
+          run_command(1)
+        end
+
+        it "should report the failure of the command" do
+          expect(stdout).to include("Verification of component 'failing_comp' failed.")
+        end
+
+        it "reports the component test output" do
+          expect(stdout).to include("i'm not feeling good today...")
+        end
+      end
+
+      describe "with multiple commands with success" do
+        let(:components) do
+          [ all_tests_ok, all_tests_ok_2 ]
+        end
+
+        before do
+          run_command(0)
+        end
+
+        it "should report the success of the command" do
+          expect(stdout).to include("Verification of component 'successful_comp' succeeded.")
+          expect(stdout).to include("Verification of component 'successful_comp_2' succeeded.")
+        end
+
+        it "reports the component test outputs" do
+          expect(stdout).to include("you are good to go...")
+          expect(stdout).to include("my friend everything is good...")
+        end
+
+        context "and components are filtered by CLI args" do
+
+          let(:command_options) { [ "successful_comp_2" ] }
+
+          it "verifies only the desired component" do
+            expect(stdout).to_not include("Verification of component 'successful_comp_1' succeeded.")
+            expect(stdout).to include("Verification of component 'successful_comp_2' succeeded.")
+          end
+
+        end
+      end
+
+      describe "with multiple commands with failures" do
+        let(:components) do
+          [ all_tests_ok, all_tests_ok_2, failing_unit_test ]
+        end
+
+        before do
+          run_command(1)
+        end
+
+        it "should report the success and failure of the commands" do
+          expect(stdout).to include("Verification of component 'successful_comp' succeeded.")
+          expect(stdout).to include("Verification of component 'successful_comp_2' succeeded.")
+          expect(stdout).to include("Verification of component 'failing_comp' failed.")
+        end
+
+        it "reports the component test outputs" do
+          expect(stdout).to include("you are good to go...")
+          expect(stdout).to include("my friend everything is good...")
+          expect(stdout).to include("i'm not feeling good today...")
+        end
+      end
+
+    end
+  end
+
+end

data/spec/unit/commands_map_spec.rb

@@ -0,0 +1,57 @@
+#
+# 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/commands_map"
+require "stringio"
+
+describe ChefCLI::CommandsMap do
+
+  subject(:mapping) { ChefCLI::CommandsMap.new }
+
+  before do
+    mapping.builtin("example", :Example)
+    mapping.builtin("hypenated-example", :HyphenatedExample)
+    mapping.builtin("explicit-path-example", :ExplicitPathExample, require_path: "unit/fixtures/command/explicit_path_example")
+    mapping.builtin("documented-example", :DocumentedExample, desc: "I have documentation")
+  end
+
+  it "defines a subcommand mapping" do
+    expect(mapping.have_command?("example")).to be true
+  end
+
+  it "infers a non-hypenated command's require path" do
+    expect(mapping.spec_for("example").require_path).to eq("chef-cli/command/example")
+  end
+
+  it "infers a hyphenated command's require path" do
+    expect(mapping.spec_for("hypenated-example").require_path).to eq("chef-cli/command/hypenated_example")
+  end
+
+  it "lists the available commands" do
+    expect(mapping.command_names).to match_array(%w{example hypenated-example explicit-path-example documented-example})
+  end
+
+  it "keeps the docstring of a command" do
+    expect(mapping.spec_for("documented-example").description).to eq("I have documentation")
+  end
+
+  it "creates an instance of a command" do
+    expect(mapping.instantiate("explicit-path-example")).to be_an_instance_of(ChefCLI::Command::ExplicitPathExample)
+  end
+
+end

data/spec/unit/component_test_spec.rb

@@ -0,0 +1,128 @@
+#
+# 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/component_test"
+require "pathname"
+
+describe ChefCLI::ComponentTest do
+
+  let(:component) do
+    ChefCLI::ComponentTest.new("berkshelf").tap do |c|
+      c.base_dir = "berkshelf"
+    end
+  end
+
+  it "defines the component" do
+    expect(component.name).to eq("berkshelf")
+  end
+
+  it "sets the component base directory" do
+    expect(component.base_dir).to eq("berkshelf")
+  end
+
+  it "defines a default unit test" do
+    expect(component.run_unit_test.exitstatus).to eq(0)
+    expect(component.run_unit_test.stdout).to eq("")
+    expect(component.run_unit_test.stderr).to eq("")
+  end
+
+  it "defines a default integration test" do
+    expect(component.run_integration_test.exitstatus).to eq(0)
+    expect(component.run_integration_test.stdout).to eq("")
+    expect(component.run_integration_test.stderr).to eq("")
+  end
+
+  it "defines a default smoke test" do
+    expect(component.run_smoke_test.exitstatus).to eq(0)
+    expect(component.run_smoke_test.stdout).to eq("")
+    expect(component.run_smoke_test.stderr).to eq("")
+  end
+
+  context "with basic tests defined" do
+
+    let(:result) { {} }
+
+    before do
+      # capture a reference to results hash so we can use it in tests.
+      result_hash = result
+      component.tap do |c|
+        c.unit_test { result_hash[:unit_test] = true }
+        c.integration_test { result_hash[:integration_test] = true }
+        c.smoke_test { result_hash[:smoke_test] = true }
+      end
+    end
+
+    it "defines a unit test block" do
+      component.run_unit_test
+      expect(result[:unit_test]).to be true
+    end
+
+    it "defines an integration test block" do
+      component.run_integration_test
+      expect(result[:integration_test]).to be true
+    end
+
+    it "defines a smoke test block" do
+      component.run_smoke_test
+      expect(result[:smoke_test]).to be true
+    end
+
+  end
+
+  context "with tests that shell out to commands" do
+
+    let(:omnibus_root) { File.join(fixtures_path, "eg_omnibus_dir/valid/") }
+
+    before do
+      component.tap do |c|
+        # Have to set omnibus dir so command can run with correct cwd
+        c.omnibus_root = omnibus_root
+
+        c.base_dir = "embedded/apps/berkshelf"
+
+        c.unit_test { sh("true") }
+
+        c.integration_test { sh("ruby -e 'puts Dir.pwd'", env: { "RUBYOPT" => "" }) }
+
+        c.smoke_test { run_in_tmpdir("ruby -e 'puts Dir.pwd'", env: { "RUBYOPT" => "" }) }
+      end
+    end
+
+    it "shells out and returns the shell out object" do
+      expect(component.run_unit_test.exitstatus).to eq(0)
+      expect(component.run_unit_test.stdout).to eq("")
+      expect(component.run_unit_test.stderr).to eq("")
+    end
+
+    it "runs the command in the app's root" do
+      result = component.run_integration_test
+      expected_path = Pathname.new(File.join(omnibus_root, "embedded/apps/berkshelf")).realpath
+      expect(Pathname.new(result.stdout.strip).realpath).to eq(expected_path)
+    end
+
+    it "runs commands in a temporary directory when specified" do
+      result = component.run_smoke_test
+
+      parent_of_cwd = Pathname.new(result.stdout.strip).parent.realpath
+      tempdir = Pathname.new(Dir.tmpdir).realpath
+      expect(parent_of_cwd).to eq(tempdir)
+    end
+
+  end
+
+end