kontena-cli 1.2.2 → 1.3.0.pre1

data/lib/kontena/plugin_manager.rb

@@ -167,8 +167,23 @@ module Kontena
           if File.exist?(plugin) && !plugins.find{ |p| p.name == spec.name }
             begin
               if spec_has_valid_dependency?(spec)
+                loaded_features_before = $LOADED_FEATURES.dup
+                load_path_before = $LOAD_PATH.dup
+
+                ENV["DEBUG"] && $stderr.puts("Activating plugin #{spec.name}")
+                spec.activate
+                spec.activate_dependencies
+
                 ENV["DEBUG"] && $stderr.puts("Loading plugin #{spec.name}")
-                load(plugin)
+                require(plugin)
+
+                if ENV['DEBUG'] == 'plugin'
+                  added_features = ($LOADED_FEATURES - loaded_features_before).map {|feat| "- #{feat}"}
+                  added_paths = ($LOAD_PATH - load_path_before).map {|feat| "- #{feat}"}
+                  $stderr.puts "Plugin manager loaded features for #{spec.name}: \n#{added_features.join("\n")}" unless added_features.empty?
+                  $stderr.puts "Plugin manager load paths added for #{spec.name}: \n#{added_paths.join("\n")}" unless added_paths.empty?
+                end
+
                 plugins << spec
               else
                 plugin_name = spec.name.sub('kontena-plugin-', '')

data/lib/kontena_cli.rb

@@ -1,12 +1,10 @@
 module Kontena
-  # Run a kontena command like it was launched from the command line.
-  #
-  # @example
-  #   Kontena.run("grid list --help")
+  # Run a kontena command like it was launched from the command line. Re-raises any exceptions,
+  # except a SystemExit with status 0, which is considered a success.
   #
   # @param [String,Array<String>] command_line
-  # @return [Fixnum] exit_code
-  def self.run(*cmdline, returning: :status)
+  # @return command result or nil
+  def self.run!(*cmdline)
     if cmdline.first.kind_of?(Array)
       command = cmdline.first
     elsif cmdline.size == 1 && cmdline.first.include?(' ')
@@ -14,19 +12,30 @@ module Kontena
     else
       command = cmdline
     end
-    ENV["DEBUG"] && puts("Running Kontena.run(#{command.inspect}, returning: #{returning}")
+    ENV["DEBUG"] && puts("Running Kontena.run(#{command.inspect}")
     result = Kontena::MainCommand.new(File.basename(__FILE__)).run(command)
     ENV["DEBUG"] && puts("Command completed, result: #{result.inspect} status: 0")
-    return 0 if returning == :status
-    return result if returning == :result
+    result
   rescue SystemExit => ex
-    ENV["DEBUG"] && $stderr.puts("Command completed with failure, result: #{result.inspect} status: #{ex.status}")
-    returning == :status ? $!.status : nil
+    ENV["DEBUG"] && $stderr.puts("Command caused SystemExit, result: #{result.inspect} status: #{ex.status}")
+    return true if ex.status.zero?
+    raise ex
   rescue => ex
-    ENV["DEBUG"] && $stderr.puts("Command raised #{ex} with message: #{ex.message}\n#{ex.backtrace.join("\n  ")}")
-    returning == :status ? 1 : nil
+    ENV["DEBUG"] && $stderr.puts("Command raised #{ex.class.name} with message: #{ex.message}\n#{ex.backtrace.join("\n  ")}")
+    raise ex
   end
 
+  # Run a kontena command and return true if the command did not raise or exit with a non-zero exit code. Raises nothing.
+  # @param [String,Array<String>] command_line
+  # @return [TrueClass,FalseClass] success
+  def self.run(*cmdline)
+    result = run!(*cmdline)
+    result.nil? ? true : result
+  rescue SystemExit => ex
+    ex.status.zero?
+  rescue
+    false
+  end
 
   # @return [String] x.y
   def self.minor_version
@@ -115,4 +124,4 @@ require 'kontena/client'
 require 'kontena/stacks_cache'
 require 'kontena/plugin_manager'
 require 'kontena/main_command'
-require 'kontena/cli/spinner'
+require 'kontena/cli/spinner'

data/spec/kontena/cli/cloud/master/add_command_spec.rb

@@ -95,8 +95,8 @@ describe Kontena::Cli::Cloud::Master::AddCommand do
       subject.provider = 'provider'
       subject.version  = '10.10.10'
 
-      expect(Kontena).to receive(:run).with('master config import --force --preset kontena_auth_provider')
-      expect(Kontena).to receive(:run).with('master config set oauth2.client_id=123 oauth2.client_secret=345 server.root_url=foofoofoo server.name=foofoo cloud.provider_is_kontena=true')
+      expect(Kontena).to receive(:run!).with(%w(master config import --force --preset kontena_auth_provider))
+      expect(Kontena).to receive(:run!).with(%w(master config set oauth2.client_id=123 oauth2.client_secret=345 server.root_url=foofoofoo server.name=foofoo cloud.provider_is_kontena=true))
 
       subject.register_current
     end
@@ -108,9 +108,9 @@ describe Kontena::Cli::Cloud::Master::AddCommand do
       subject.version  = '10.10.10'
       subject.cloud_master_id = 'abcd'
 
-      expect(Kontena).to receive(:run).with('cloud master update --provider provider --version 10.10.10 abcd').and_return(true)
-      expect(Kontena).to receive(:run).with('master config import --force --preset kontena_auth_provider').and_return(true)
-      expect(Kontena).to receive(:run).with('master config set oauth2.client_id=123 oauth2.client_secret=345 server.root_url=foofoofoo server.name=foofoo cloud.provider_is_kontena=true').and_return(true)
+      expect(Kontena).to receive(:run!).with(%w(cloud master update --provider provider --version 10.10.10 abcd)).and_return(true)
+      expect(Kontena).to receive(:run!).with(%w(master config import --force --preset kontena_auth_provider)).and_return(true)
+      expect(Kontena).to receive(:run!).with(%w(master config set oauth2.client_id=123 oauth2.client_secret=345 server.root_url=foofoofoo server.name=foofoo cloud.provider_is_kontena=true)).and_return(true)
 
       subject.register_current
     end

data/spec/kontena/cli/grids/trusted_subnets/add_command_spec.rb

@@ -4,24 +4,40 @@ require "kontena/cli/grids/trusted_subnets/add_command"
 describe Kontena::Cli::Grids::TrustedSubnets::AddCommand do
 
   include ClientHelpers
+  include RequirementsHelper
+
+  expect_to_require_current_master
 
   describe '#execute' do
-    it 'requires grid as param' do
+    it 'requires subnet as param' do
       expect {
         subject.run([])
       }.to raise_error(Clamp::UsageError)
     end
 
     it 'adds subnet to grid' do
-      allow(client).to receive(:get).with("grids/my-grid").and_return(
+      allow(client).to receive(:get).with("grids/test-grid").and_return(
+        'trusted_subnets' => ['192.168.12.0/24']
+      )
+      expect(client).to receive(:put).with(
+        'grids/test-grid', hash_including({trusted_subnets: [
+          '192.168.12.0/24', '10.12.0.0/19'
+        ]})
+      )
+      subject.run(['10.12.0.0/19'])
+    end
+
+    it 'supports the --grid option' do
+      allow(subject).to receive(:current_grid).and_call_original
+      allow(client).to receive(:get).with("grids/ingrid").and_return(
         'trusted_subnets' => ['192.168.12.0/24']
       )
       expect(client).to receive(:put).with(
-        'grids/my-grid', hash_including({trusted_subnets: [
+        'grids/ingrid', hash_including({trusted_subnets: [
           '192.168.12.0/24', '10.12.0.0/19'
         ]})
       )
-      subject.run(['my-grid', '10.12.0.0/19'])
+      subject.run(['--grid', 'ingrid', '10.12.0.0/19'])
     end
   end
 end

data/spec/kontena/cli/grids/trusted_subnets/list_command_spec.rb

@@ -4,19 +4,24 @@ require "kontena/cli/grids/trusted_subnets/list_command"
 describe Kontena::Cli::Grids::TrustedSubnets::ListCommand do
 
   include ClientHelpers
+  include RequirementsHelper
 
-  describe '#execute' do
-    it 'requires grid as param' do
-      expect {
-        subject.run([])
-      }.to raise_error(Clamp::UsageError)
-    end
+  expect_to_require_current_master
 
+  describe '#execute' do
     it 'requests grid details from master' do
       expect(client).to receive(:get).with("grids/test-grid").and_return('trusted_subnets' => [
           '192.168.0.1/24',
       ])
-      expect{subject.run(['test-grid'])}.to output("192.168.0.1/24\n").to_stdout
+      expect{subject.run([])}.to output("192.168.0.1/24\n").to_stdout
+    end
+
+    it 'supports the --grid option' do
+      allow(subject).to receive(:current_grid).and_call_original
+      expect(client).to receive(:get).with("grids/ingrid").and_return('trusted_subnets' => [
+          '192.168.0.1/24',
+      ])
+      expect{subject.run(['--grid', 'ingrid'])}.to output("192.168.0.1/24\n").to_stdout
     end
   end
 end

data/spec/kontena/cli/grids/trusted_subnets/remove_command_spec.rb

@@ -4,24 +4,40 @@ require "kontena/cli/grids/trusted_subnets/remove_command"
 describe Kontena::Cli::Grids::TrustedSubnets::RemoveCommand do
 
   include ClientHelpers
+  include RequirementsHelper
+
+  expect_to_require_current_master
 
   describe '#execute' do
-    it 'requires grid as param' do
+    it 'requires subnet as param' do
       expect {
         subject.run([])
       }.to raise_error(Clamp::UsageError)
     end
 
     it 'removes subnet from grid' do
-      allow(client).to receive(:get).with("grids/my-grid").and_return(
+      allow(client).to receive(:get).with("grids/test-grid").and_return(
+        'trusted_subnets' => ['192.168.12.0/24', '192.168.50.0/24']
+      )
+      expect(client).to receive(:put).with(
+        'grids/test-grid', hash_including({trusted_subnets: [
+          '192.168.12.0/24'
+        ]})
+      )
+      subject.run(['--force', '192.168.50.0/24'])
+    end
+
+    it 'supports the --grid option' do
+      allow(subject).to receive(:current_grid).and_call_original
+      allow(client).to receive(:get).with("grids/ingrid").and_return(
         'trusted_subnets' => ['192.168.12.0/24', '192.168.50.0/24']
       )
       expect(client).to receive(:put).with(
-        'grids/my-grid', hash_including({trusted_subnets: [
+        'grids/ingrid', hash_including({trusted_subnets: [
           '192.168.12.0/24'
         ]})
       )
-      subject.run(['--force', 'my-grid', '192.168.50.0/24'])
+      subject.run(['--force', '--grid', 'ingrid', '192.168.50.0/24'])
     end
   end
 end

data/spec/kontena/cli/master/init_cloud_command_spec.rb

@@ -20,7 +20,7 @@ describe Kontena::Cli::Master::InitCloudCommand do
   end
 
   it 'runs the invite self after deploy callback' do
-    expect(Kontena).to receive(:run).with('cloud master add --current --force').and_return(true)
+    expect(Kontena).to receive(:run!).with(%w(cloud master add --current --force)).and_return(true)
     expect_any_instance_of(Kontena::Callbacks::InviteSelfAfterDeploy).to receive(:after).and_return(true)
     subject.run(['--force'])
   end

data/spec/kontena/cli/master/user/invite_command_spec.rb

@@ -7,8 +7,8 @@ describe Kontena::Cli::Master::User::InviteCommand do
 
   describe "#invite" do
     it 'makes invitation request for all given users' do
-      expect(client).to receive(:post).with("/oauth2/authorize", {email: 'john@example.org', external_id: nil, response_type: "invite"}).once
-      expect(client).to receive(:post).with("/oauth2/authorize", {email: 'jane@example.org', external_id: nil, response_type: "invite"}).once
+      expect(client).to receive(:post).with("/oauth2/authorize", {email: 'john@example.org', external_id: nil, response_type: "invite"}).once.and_return(Hash.new { "foo" })
+      expect(client).to receive(:post).with("/oauth2/authorize", {email: 'jane@example.org', external_id: nil, response_type: "invite"}).once.and_return(Hash.new { "bar" })
 
       subject.run(['john@example.org', 'jane@example.org'])
     end

data/spec/kontena/cli/nodes/ssh_command_spec.rb

@@ -0,0 +1,43 @@
+require 'kontena/cli/nodes/ssh_command'
+
+describe Kontena::Cli::Nodes::SshCommand do
+  include ClientHelpers
+
+  let :node do
+    {
+      'labels' => [],
+      'public_ip' => '192.0.2.10',
+      'private_ip' => '10.0.8.10',
+      'overlay_ip' => '10.81.0.1',
+    }
+  end
+
+  before do
+    allow(client).to receive(:get).with('nodes/test-grid/test-node').and_return(node)
+  end
+
+  it "uses the public IP by default" do
+    expect(subject).to receive(:exec).with('ssh', 'core@192.0.2.10')
+    subject.run ['test-node']
+  end
+
+  it "uses the private IP" do
+    expect(subject).to receive(:exec).with('ssh', 'core@10.0.8.10')
+    subject.run ['--private-ip', 'test-node']
+  end
+
+  it "uses the overlay IP" do
+    expect(subject).to receive(:exec).with('ssh', 'core@10.81.0.1')
+    subject.run ['--internal-ip', 'test-node']
+  end
+
+  it "passes through the command to SSH" do
+    expect(subject).to receive(:exec).with('ssh', 'core@192.0.2.10', 'ls', '-l')
+    subject.run ['test-node', 'ls', '-l']
+  end
+
+  it "passes through arguments to SSH" do
+    expect(subject).to receive(:exec).with('ssh', 'core@192.0.2.10', '-F', 'ssh/config' 'ls', '-l')
+    subject.run ['test-node', '-F', 'ssh/config' 'ls', '-l']
+  end
+end

data/spec/kontena/cli/stacks/restart_command_spec.rb

@@ -0,0 +1,16 @@
+require "kontena/cli/stacks/restart_command"
+
+describe Kontena::Cli::Stacks::RestartCommand do
+  include ClientHelpers
+  include RequirementsHelper
+
+  expect_to_require_current_master
+  expect_to_require_current_master_token
+
+  describe '#execute' do
+    it 'sends stop request to server' do
+      expect(client).to receive(:post).with('stacks/test-grid/foo/restart', {})
+      subject.run(['foo'])
+    end
+  end
+end

data/spec/kontena/cli/stacks/stop_command_spec.rb

@@ -0,0 +1,16 @@
+require "kontena/cli/stacks/stop_command"
+
+describe Kontena::Cli::Stacks::StopCommand do
+  include ClientHelpers
+  include RequirementsHelper
+
+  expect_to_require_current_master
+  expect_to_require_current_master_token
+
+  describe '#execute' do
+    it 'sends stop request to server' do
+      expect(client).to receive(:post).with('stacks/test-grid/foo/stop', {})
+      subject.run(['foo'])
+    end
+  end
+end

data/spec/kontena/cli/stacks/upgrade_command_spec.rb

@@ -89,7 +89,7 @@ describe Kontena::Cli::Stacks::UpgradeCommand do
       allow(client).to receive(:put).with(
         'stacks/test-grid/stack-a', anything
       ).and_return({})
-      expect(Kontena).to receive(:run).with(['stack', 'deploy', 'stack-a']).once
+      expect(Kontena).to receive(:run!).with(['stack', 'deploy', 'stack-a']).once
       subject.run(['stack-a', './path/to/kontena.yml'])
     end
 
@@ -101,7 +101,7 @@ describe Kontena::Cli::Stacks::UpgradeCommand do
         allow(client).to receive(:put).with(
           'stacks/test-grid/stack-a', anything
         ).and_return({})
-        expect(Kontena).not_to receive(:run).with(['stack', 'deploy', 'stack-a'])
+        expect(Kontena).not_to receive(:run!).with(['stack', 'deploy', 'stack-a'])
         subject.run(['--no-deploy', 'stack-a', './path/to/kontena.yml'])
       end
     end

data/spec/kontena/cli/stacks/yaml/validator_v3_spec.rb

@@ -108,20 +108,40 @@ describe Kontena::Cli::Stacks::YAML::ValidatorV3 do
       expect(result.errors.key?('environment')).to be_falsey
       result = subject.validate_options('environment' => { 'KEY' => 'VALUE' })
       expect(result.errors.key?('environment')).to be_falsey
+      result = subject.validate_options('environment' => ['KEY=VALUE', 'KEY2=VALUE2', 'KEY3='])
+      expect(result.errors.key?('environment')).to be_falsey
     end
 
     it 'fails validation if environment array includes items without equals sign' do
-      result = subject.validate_options('environment' => ['KEY=VALUE', 'KEY2=VALUE2'])
-      expect(result.errors.key?('environment')).to be_falsey
       result = subject.validate_options('environment' => ['KEY=VALUE', 'KEY2 VALUE'])
       expect(result.errors.key?('environment')).to be_truthy
     end
 
+    it "fails validation if environment has invalid key prefix" do
+      result = subject.validate_options('environment' => ['=VALUE'])
+      expect(result.errors.key?('environment')).to be_truthy
+    end
+
+    it "fails validation if environemnt has invalid key prefix with valud key prefix in value" do
+      result = subject.validate_options('environment' => ['=VALUE=VALUE2'])
+      expect(result.errors.key?('environment')).to be_truthy
+    end
+
+    it "fails validation if environment contains invalid key prefix with valid key prefix in multi-line value" do
+      result = subject.validate_options('environment' => ['=ASDF\nKEY=VALUE'])
+      expect(result.errors.key?('environment')).to be_truthy
+    end
+
     it 'passes validation if environment array includes items with booleans or nils' do
       result = subject.validate_options('environment' => { 'KEY' => true, 'KEY2' => false, 'KEY3' => nil })
       expect(result.errors.key?('environment')).to be_falsey
     end
 
+    it 'passes validation if environment array includes items with multi-line values' do
+      result = subject.validate_options('environment' => [ "KEY=foo\nbar" ])
+      expect(result.errors.key?('environment')).to be_falsey
+    end
+
     context 'validates secrets' do
       it 'must be array' do
         result = subject.validate_options('secrets' => {})

data/spec/kontena/cli/vault/export_spec.rb

@@ -15,16 +15,16 @@ describe Kontena::Cli::Vault::ExportCommand do
   end
 
   it 'goes through the list of vault keys and outputs a yaml' do
-    expect(Kontena).to receive(:run).with(/^vault ls/, returning: :result).and_return(['foo', 'bar'])
-    expect(Kontena).to receive(:run).with(/^vault read.*bar/, returning: :result).and_return('barbar')
-    expect(Kontena).to receive(:run).with(/^vault read.*foo/, returning: :result).and_return('foofoo')
+    expect(Kontena).to receive(:run!).with(['vault', 'ls', '--return']).and_return(['foo', 'bar'])
+    expect(Kontena).to receive(:run!).with(['vault', 'read', '--return', 'bar']).and_return('barbar')
+    expect(Kontena).to receive(:run!).with(['vault', 'read', '--return', 'foo']).and_return('foofoo')
     expect{subject.run([])}.to output(/bar: barbar\nfoo: foofoo/).to_stdout
   end
 
   it 'goes through the list of vault keys and outputs a json' do
-    expect(Kontena).to receive(:run).with(/^vault ls/, returning: :result).and_return(['foo', 'bar'])
-    expect(Kontena).to receive(:run).with(/^vault read.*bar/, returning: :result).and_return('barbar')
-    expect(Kontena).to receive(:run).with(/^vault read.*foo/, returning: :result).and_return('foofoo')
+    expect(Kontena).to receive(:run!).with(['vault', 'ls', '--return']).and_return(['foo', 'bar'])
+    expect(Kontena).to receive(:run!).with(['vault', 'read', '--return', 'bar']).and_return('barbar')
+    expect(Kontena).to receive(:run!).with(['vault', 'read', '--return', 'foo']).and_return('foofoo')
     expect{subject.run(['--json'])}.to output(/\"bar\":\"barbar\",\"foo\":\"foofoo\"/).to_stdout
   end
 

data/spec/kontena/cli/vault/import_spec.rb

@@ -30,39 +30,38 @@ describe Kontena::Cli::Vault::ImportCommand do
 
   it 'runs vault write for kv-pairs in yaml' do
     expect(File).to receive(:read).with('foo.yml').and_return("foo: bar\nbar: foo\n")
-    expect(Kontena).to receive(:run).with(/vault update.*foo bar/).and_return(0)
-    expect(Kontena).to receive(:run).with(/vault update.*bar foo/).and_return(0)
+    expect(Kontena).to receive(:run).with(['vault', 'update', '--upsert', '--silent', 'foo', 'bar']).and_return(true)
+    expect(Kontena).to receive(:run).with(['vault', 'update', '--upsert', '--silent', 'bar', 'foo']).and_return(true)
     subject.run(['--force', 'foo.yml'])
   end
 
   it 'runs vault rm for kv-pairs with null value in yaml' do
     expect(File).to receive(:read).with('foo.yml').and_return("foo: bar\nbar: null\n")
-    expect(Kontena).to receive(:run).with(/vault update.*foo bar/).and_return(0)
-    expect(Kontena).to receive(:run).with(/vault rm.*bar/).and_return(0)
+    expect(Kontena).to receive(:run).with(['vault', 'update', '--upsert', '--silent', 'foo', 'bar']).and_return(true)
+    expect(Kontena).to receive(:run).with(['vault', 'rm', '--silent', '--force', 'bar']).and_return(true)
     subject.run(['--force', 'foo.yml'])
   end
 
   it 'runs vault rm for kv-pairs with empty value in yaml when --empty-is-null' do
     expect(File).to receive(:read).with('foo.yml').and_return("foo: bar\nbar:\n")
-    expect(Kontena).to receive(:run).with(/vault update.*foo bar/).and_return(0)
-    expect(Kontena).to receive(:run).with(/vault rm.*bar/).and_return(0)
+    expect(Kontena).to receive(:run).with(['vault', 'update', '--upsert', '--silent', 'foo', 'bar']).and_return(true)
+    expect(Kontena).to receive(:run).with(['vault', 'rm', '--silent', '--force', 'bar']).and_return(true)
     subject.run(['--force', '--empty-is-null', 'foo.yml'])
   end
 
   it 'does not run vault rm for kv-pairs with empty value in yaml when no --empty-is-null' do
     expect(File).to receive(:read).with('foo.yml').and_return("foo: bar\nbar: \"\"\n")
-    expect(Kontena).to receive(:run).with(/vault update.*foo bar/).and_return(0)
-    expect(Kontena).to receive(:run).with(/vault update.*bar ''/).and_return(0)
-    expect(Kontena).not_to receive(:run).with(/vault rm.*bar/)
+    expect(Kontena).to receive(:run).with(['vault', 'update', '--upsert', '--silent', 'foo', 'bar']).and_return(true)
+    expect(Kontena).to receive(:run).with(['vault', 'update', '--upsert', '--silent', 'bar', '']).and_return(true)
+    expect(Kontena).not_to receive(:run).with(['vault', 'rm', '--silent', '--force', 'bar'])
     subject.run(['--force', 'foo.yml'])
   end
 
   it 'doesnt vault rm for kv-pairs with null value in yaml when --skip-null used' do
     expect(File).to receive(:read).with('foo.yml').and_return("foo: bar\nbar: null\n")
-    expect(Kontena).to receive(:run).with(/vault update.*foo bar/).and_return(0)
-    expect(Kontena).not_to receive(:run).with(/vault rm.*bar/)
+    expect(Kontena).to receive(:run).with(['vault', 'update', '--upsert', '--silent', 'foo', 'bar']).and_return(true)
+    expect(Kontena).not_to receive(:run).with(['vault', 'rm', '--silent', '--force', 'bar'])
     subject.run(['--force', '--skip-null', 'foo.yml'])
   end
-
 end
 

data/spec/kontena/kontena_cli_spec.rb

@@ -30,24 +30,59 @@ describe Kontena do
     end
   end
 
-  describe '#run' do
+  describe '#run!' do
     let(:whoami) { double(:whoami) }
 
     before(:each) do
       expect(Kontena::Cli::WhoamiCommand).to receive(:new).and_return(whoami)
-      expect(whoami).to receive(:run).with(['--bash-completion-path']).and_return(true)
     end
 
     it 'accepts a command line as string' do
-      Kontena.run('whoami --bash-completion-path')
+      expect(whoami).to receive(:run).with(['--bash-completion-path']).and_return(true)
+      Kontena.run!('whoami --bash-completion-path')
     end
 
     it 'accepts a command line as a list of parameters' do
-      Kontena.run('whoami', '--bash-completion-path')
+      expect(whoami).to receive(:run).with(['--bash-completion-path']).and_return(true)
+      Kontena.run!('whoami', '--bash-completion-path')
     end
 
     it 'accepts a command line as an array' do
-      Kontena.run(['whoami', '--bash-completion-path'])
+      expect(whoami).to receive(:run).with(['--bash-completion-path']).and_return(true)
+      Kontena.run!(['whoami', '--bash-completion-path'])
+    end
+
+    it 'Returns true if the command exits with SystemExit status 0' do
+      expect(whoami).to receive(:run) { exit 0 }
+      expect(Kontena.run!(['whoami'])).to be_truthy
+    end
+
+    it 'Re-raises the SystemExit when command exits with non-zero status' do
+      expect(whoami).to receive(:run) { exit 1 }
+      expect{Kontena.run!(['whoami'])}.to exit_with_error.status(1)
+    end
+  end
+
+  describe '#run' do
+    let(:whoami) { double(:whoami) }
+
+    before(:each) do
+      expect(Kontena::Cli::WhoamiCommand).to receive(:new).and_return(whoami)
+    end
+
+    it 'Returns false when status is 1' do
+      expect(whoami).to receive(:run) { exit 1 }
+      expect(Kontena.run(['whoami'])).to be_falsey
+    end
+
+    it 'Returns true when status is 0' do
+      expect(whoami).to receive(:run) { exit 0 }
+      expect(Kontena.run(['whoami'])).to be_truthy
+    end
+
+    it 'Returns true when nothing was raised' do
+      expect(whoami).to receive(:run).and_return(nil)
+      expect(Kontena.run(['whoami'])).to be_truthy
     end
   end
 end

data/spec/spec_helper.rb

@@ -49,14 +49,16 @@ RSpec.configure do |config|
     end
   end
 
-  config.before(:each) do
-    $stdout = StringIO.new
-    $stderr = StringIO.new
-  end
+  unless ENV["DEBUG"]
+    config.before(:each) do
+      $stdout = StringIO.new
+      $stderr = StringIO.new
+    end
 
-  config.after(:each) do
-    $stdout = STDOUT
-    $stderr = STDERR
+    config.after(:each) do
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
   end
 end