chef-dk 0.2.0

data/spec/unit/cli_spec.rb

@@ -0,0 +1,151 @@
+#
+# 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 'stringio'
+require 'chef-dk/cli'
+require 'unit/fixtures/command/cli_test_command'
+
+describe ChefDK::CLI do
+
+  let(:argv) { [] }
+
+  # Setup a new commands map so we control what subcommands exist. Otherwise
+  # we'd have to update this test for every new subcommand we add or code the
+  # tests defensively.
+  let(:commands_map) { ChefDK::CommandsMap.new }
+
+  let(:stdout_io) { StringIO.new }
+  let(:stderr_io) { StringIO.new }
+
+  def stdout
+    stdout_io.string
+  end
+
+  def stderr
+    stderr_io.string
+  end
+
+  let(:base_help_message) do
+    <<-E
+Usage:
+    chef -h/--help
+    chef -v/--version
+    chef command [arguments...] [options...]
+
+
+Available Commands:
+    verify   Test the embedded ChefDK applications
+    gem      Runs the `gem` command in context of the embedded ruby
+    example  Example subcommand for testing
+E
+  end
+
+  let(:version_message) { "Chef Development Kit Version: #{ChefDK::VERSION}\n" }
+
+  def run_cli(expected_exit_code)
+    cli.should_receive(:exit).with(expected_exit_code)
+    cli.run
+  end
+
+  subject(:cli) do
+    ChefDK::CLI.new(argv).tap do |c|
+      c.stub(:commands_map).and_return(commands_map)
+      c.stub(:stdout).and_return(stdout_io)
+      c.stub(:stderr).and_return(stderr_io)
+    end
+  end
+
+  before do
+    commands_map.builtin "verify", :Verify, desc: "Test the embedded ChefDK applications"
+
+    commands_map.builtin "gem", :GemForwarder, require_path: "chef-dk/command/gem",
+      desc: "Runs the `gem` command in context of the embedded ruby"
+
+    commands_map.builtin "example", :TestCommand, require_path: "unit/fixtures/command/cli_test_command",
+      desc: "Example subcommand for testing"
+  end
+
+  context "given no arguments or options" do
+
+    it "prints the help output" do
+      run_cli(0)
+      expect(stdout).to eq(base_help_message)
+    end
+
+  end
+
+  context "given -h" do
+    let(:argv) { %w[-h] }
+
+    it "prints the help output" do
+      run_cli(0)
+      expect(stdout).to eq(base_help_message)
+    end
+  end
+
+  context "given -v" do
+    let(:argv) { %w[-v] }
+
+    it "prints the version" do
+      run_cli(0)
+      expect(stdout).to eq(version_message)
+    end
+  end
+
+  context "given an invalid/unknown subcommand" do
+    let(:argv) { %w[ancient-aliens] }
+
+    it "prints an 'unknown command' message and the help output" do
+      expected_err = "Unknown command `ancient-aliens'.\n"
+
+      run_cli(1)
+
+      expect(stderr).to eq(expected_err)
+      expect(stdout).to eq(base_help_message)
+    end
+
+  end
+
+  context "given a valid subcommand" do
+    let(:argv) { %w[example with some args --and-an-option] }
+
+    def test_result
+      ChefDK::Command::TestCommand.test_result
+    end
+
+    before do
+      ChefDK::Command::TestCommand.reset!
+    end
+
+    it "runs the subcommand" do
+      run_cli(23)
+      expect(test_result[:status]).to eq(:success)
+    end
+
+    it "exits with the return code given by the subcommand" do
+      run_cli(23)
+    end
+
+    it "passes arguments and options to the subcommand" do
+      params = %w[with some args --and-an-option]
+      run_cli(23)
+      expect(test_result[:params]).to eq(params)
+    end
+  end
+
+end

data/spec/unit/command/base_spec.rb

@@ -0,0 +1,88 @@
+#
+# 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'
+
+describe ChefDK::Command::Base do
+  class TestCommand < ChefDK::Command::Base
+    banner "use me please"
+
+    option :user,
+      :short        => "-u",
+      :long         => "--user",
+      :description  => "If the user exists",
+      :boolean      => true
+
+    def run(params)
+      parse_options(params)
+      msg("thanks for passing me #{config[:user]}")
+    end
+  end
+
+  let(:stdout_io) { StringIO.new }
+  let(:command_instance) { TestCommand.new() }
+
+  def stdout
+    stdout_io.string
+  end
+
+  before do
+    command_instance.stub(:stdout).and_return(stdout_io)
+  end
+
+
+  def run_command(options)
+    command_instance.run_with_default_options(options)
+  end
+
+  it "should print the banner for -h" do
+    run_command(["-h"])
+    expect(stdout).to include("use me please\n")
+  end
+
+  it "should print the banner for --help" do
+    run_command(["--help"])
+    expect(stdout).to include("use me please\n")
+  end
+
+  it "prints the options along with the banner when displaying the help message" do
+    run_command(["--help"])
+    expect(stdout).to include("-u, --user                       If the user exists")
+  end
+
+  it "should print the version for -v" do
+    run_command(["-v"])
+    expect(stdout).to eq("Chef Development Kit Version: #{ChefDK::VERSION}\n")
+  end
+
+  it "should print the version for --version" do
+    run_command(["--version"])
+    expect(stdout).to eq("Chef Development Kit Version: #{ChefDK::VERSION}\n")
+  end
+
+  it "should run the command passing in the custom options for long custom options" do
+    run_command(["--user"])
+    expect(stdout).to eq("thanks for passing me true\n")
+  end
+
+  it "should run the command passing in the custom options for short custom options" do
+    run_command(["-u"])
+    expect(stdout).to eq("thanks for passing me true\n")
+  end
+
+end

data/spec/unit/command/exec_spec.rb

@@ -0,0 +1,123 @@
+#
+# 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/exec'
+
+describe ChefDK::Command::Exec do
+  let(:command_instance) { ChefDK::Command::Exec.new() }
+
+  let(:command_options) { [] }
+
+  def run_command
+    command_instance.run(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
+      Gem.stub(: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
+      Gem.stub(: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
+      Gem.stub(:ruby).and_return(File.join(fixtures_path,".rbenv/versions/2.1.1/bin/ruby"))
+      expect{command_instance.omnibus_bin_dir}.to raise_error(ChefDK::OmnibusInstallNotFound)
+    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_embedded_bin_dir}.to raise_error(ChefDK::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
+      Gem.stub(:ruby).and_return(ruby_path)
+    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_env) do
+        {
+          'PATH' => "#{omnibus_bin_dir}:#{user_bin_dir}:#{omnibus_embedded_bin_dir}:#{ENV['PATH']}",
+          'GEM_ROOT' => Gem.default_dir.inspect,
+          'GEM_HOME' => ENV['GEM_HOME'],
+          'GEM_PATH' => Gem.path.join(':'),
+        }
+      end
+
+      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 "should call exec to fire off the command with the correct environment" do
+        expect(command_instance).to receive(:exec).with(expected_env, *command_options)
+        expect{ run_command }.to raise_error # XXX: this isn't a test we just need to swallow the exception
+      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_env) do
+        {
+          'PATH' => "#{omnibus_bin_dir}:#{user_bin_dir}:#{omnibus_embedded_bin_dir}:#{ENV['PATH']}",
+          'GEM_ROOT' => Gem.default_dir.inspect,
+          'GEM_HOME' => Gem.paths.home,
+          'GEM_PATH' => Gem.path.join(':'),
+        }
+      end
+
+      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 "should raise Errno::ENOENT" do
+        # XXX: this doesn't really test much, but really calling exec will never return to rspec
+        expect(command_instance).to receive(:exec).with(expected_env, *command_options).and_raise(Errno::ENOENT)
+        expect{ run_command }.to raise_error(Errno::ENOENT)
+      end
+    end
+  end
+
+end

data/spec/unit/command/generate_spec.rb

@@ -0,0 +1,102 @@
+#
+# 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 "stringio"
+require 'chef-dk/command/generate'
+
+class ChefDK::Command::GeneratorCommands::Example
+
+  def initialize(argv)
+    @argv = argv
+  end
+
+  def run
+    {:argv => @argv, :ran_cmd => "example"}
+  end
+end
+
+describe ChefDK::Command::Generate do
+
+  # Use a subclass so we have a clean slate of defined generators
+  let(:generator_class) { Class.new(ChefDK::Command::Generate) }
+
+  let(:stdout_io) { StringIO.new }
+  let(:stderr_io) { StringIO.new }
+
+  def stdout
+    stdout_io.string
+  end
+
+  subject(:generate) do
+    g = generator_class.new
+    g.stub(:stdout).and_return(stdout_io)
+    g.stub(:stderr).and_return(stderr_io)
+    g
+  end
+
+  it "has a list of generators" do
+    expect(generator_class.generators).to eq([])
+  end
+
+  context "with a generator defined" do
+    let(:expected_help_message) do
+      <<-E
+Usage: chef generate GENERATOR [options]
+
+Available generators:
+  example  this is a test
+E
+    end
+
+    before do
+      generator_class.generator(:example, :Example, "this is a test")
+    end
+
+    it "includes the generator in the list" do
+      expect(generator_class).to have(1).generators
+      generator_spec = generator_class.generators.first
+      expect(generator_spec.name).to eq(:example)
+      expect(generator_spec.class_name).to eq(:Example)
+      expect(generator_spec.description).to eq("this is a test")
+    end
+
+    it "includes the generator in the help output" do
+      expect(generator_class.banner).to eq(expected_help_message)
+    end
+
+    it "prints usage when running an unknown generator" do
+      generate.run(%w[ancient-aliens])
+      expect(stdout).to include(expected_help_message)
+    end
+
+    it "runs the generator sub-command" do
+      result = generate.run(%w[example])
+      expect(result[:ran_cmd]).to eq("example")
+    end
+
+    it "removes the subcommand name from argv" do
+      result = generate.run(%w[example])
+      expect(result[:argv]).to eq([])
+    end
+
+    it "passes extra arguments and options to the subcommand" do
+      result = generate.run(%w[example argument_one argument_two --option-one --option-two])
+      expect(result[:argv]).to eq(%w[argument_one argument_two --option-one --option-two])
+    end
+  end
+end