chef-dk 0.2.0

data/spec/unit/command/shell_init_spec.rb

@@ -0,0 +1,109 @@
+#
+# 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 'chef-dk/command/shell_init'
+
+describe ChefDK::Command::ShellInit do
+
+  let(:stdout_io) { StringIO.new }
+  let(:stderr_io) { StringIO.new }
+
+  let(:command_instance) do
+    ChefDK::Command::ShellInit.new.tap do |c|
+      c.stub(:stdout).and_return(stdout_io)
+      c.stub(:stderr).and_return(stderr_io)
+    end
+  end
+
+  let(:argv) { ['bash'] }
+
+  let(:user_bin_dir) { File.expand_path(File.join(Gem.user_dir, 'bin')) }
+
+  let(:expected_path) { "#{omnibus_bin_dir}:#{user_bin_dir}:#{omnibus_embedded_bin_dir}:#{ENV['PATH']}" }
+
+  let(:expected_gem_root) { Gem.default_dir.to_s }
+
+  let(:expected_gem_home) { ENV['GEM_HOME'] }
+
+  let(:expected_gem_path) { Gem.path.join(':') }
+
+  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
+
+  context "with no explicit omnibus directory" do
+
+    let(:omnibus_bin_dir) { "/foo/bin" }
+    let(:omnibus_embedded_bin_dir) { "/foo/embedded/bin" }
+
+    before do
+      command_instance.stub(:omnibus_embedded_bin_dir).and_return(omnibus_embedded_bin_dir)
+      command_instance.stub(:omnibus_bin_dir).and_return(omnibus_bin_dir)
+    end
+
+    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)
+    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 zsh sh")
+      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(:argv) { ["bash", "--omnibus-dir", omnibus_root] }
+
+    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)
+    end
+  end
+
+end
+

data/spec/unit/command/verify_spec.rb

@@ -0,0 +1,311 @@
+#
+# 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 'chef-dk/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 ChefDK::Command::Verify do
+  let(:command_instance) { ChefDK::Command::Verify.new() }
+
+  let(:command_options) { [] }
+
+  let(:components) { {} }
+
+  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-dk components by default" do
+    expect(command_instance.components).not_to be_empty
+    expect(command_instance.components.map(&:name)).to match_array(%w{berkshelf test-kitchen chef-client chef-dk})
+  end
+
+  it "has a usage banner" do
+    expect(command_instance.banner).to eq("Usage: chef verify [component, ...] [options]")
+  end
+
+  describe "when locating omnibus directory" do
+    it "should find omnibus app directory from ruby path" do
+      Gem.stub(:ruby).and_return(File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin/ruby"))
+      expect(command_instance.omnibus_apps_dir).to include("eg_omnibus_dir/valid/embedded")
+    end
+
+    it "should raise OmnibusInstallNotFound if directory is not looking like omnibus" do
+      Gem.stub(:ruby).and_return(File.join(fixtures_path,".rbenv/versions/2.1.1/bin/ruby"))
+      expect{command_instance.omnibus_apps_dir}.to raise_error(ChefDK::OmnibusInstallNotFound)
+    end
+
+    it "raises OmnibusInstallNotFound if omnibus directory doesn't exist" do
+      Gem.stub(:ruby).and_return(File.join(fixtures_path,"eg_omnibus_dir/missing_apps/embedded/bin/ruby"))
+      expect{command_instance.omnibus_apps_dir}.to raise_error(ChefDK::OmnibusInstallNotFound)
+    end
+
+    it "raises MissingComponentError when a component doesn't exist" do
+      Gem.stub(:ruby).and_return(File.join(fixtures_path,"eg_omnibus_dir/missing_component/embedded/bin/ruby"))
+      expect{command_instance.validate_components!}.to raise_error(ChefDK::MissingComponentError)
+    end
+  end
+
+  describe "when running verify command" do
+    let(:stdout_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
+      ChefDK::ComponentTest.new("successful_comp").tap do |c|
+        c.base_dir = "berkshelf"
+        c.unit_test(&run_unit_test)
+        c.integration_test(&run_integration_test)
+        c.smoke_test { sh("true") }
+      end
+    end
+
+    let(:all_tests_ok_2) do
+      ChefDK::ComponentTest.new("successful_comp_2").tap do |c|
+        c.base_dir = "test-kitchen"
+        c.unit_test(&run_unit_test)
+        c.smoke_test { sh("true") }
+      end
+    end
+
+    let(:failing_unit_test) do
+      ChefDK::ComponentTest.new("failing_comp").tap do |c|
+        c.base_dir = "chef"
+        c.unit_test(&run_unit_test)
+        c.smoke_test { sh("true") }
+      end
+    end
+
+    let(:passing_smoke_test_only) do
+      component = failing_unit_test.dup
+      component.smoke_test { sh("true") }
+      component
+    end
+
+    let(:failing_smoke_test_only) do
+      component = all_tests_ok.dup
+      component.smoke_test { sh("false") }
+      component
+    end
+
+    let(:component_without_integration_tests) do
+      ChefDK::ComponentTest.new("successful_comp").tap do |c|
+        c.base_dir = "berkshelf"
+        c.unit_test { sh("./verify_me") }
+        c.smoke_test { sh("true") }
+      end
+    end
+
+    def stdout
+      stdout_io.string
+    end
+
+    before do
+      Gem.stub(:ruby).and_return(ruby_path)
+      command_instance.stub(:stdout).and_return(stdout_io)
+      command_instance.stub(: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
+
+        it "should report the output of the first verification first" do
+          index_first = stdout.index("you are good to go...")
+          index_second = stdout.index("my friend everything is good...")
+          expect(index_second > index_first).to be_true
+        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 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-dk/commands_map'
+require 'stringio'
+
+describe ChefDK::CommandsMap do
+
+  subject(:mapping) { ChefDK::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-dk/command/example")
+  end
+
+  it "infers a hyphenated command's require path" do
+    expect(mapping.spec_for("hypenated-example").require_path).to eq("chef-dk/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(ChefDK::Command::ExplicitPathExample)
+  end
+
+end