shelly 0.0.43 → 0.0.44.pre

data/spec/shelly/cli/main_spec.rb

@@ -24,21 +24,23 @@ describe Shelly::CLI::Main do
     it "should display available commands" do
       expected = <<-OUT
 Tasks:
-  shelly add                # Adds new cloud to Shelly Cloud
-  shelly backup <command>   # Manages database backups from this cloud
-  shelly config <command>   # Manages cloud configuration files
-  shelly delete             # Delete cloud from Shelly Cloud
-  shelly deploys <command>  # View cloud deploy logs
+  shelly add                # Add a new cloud
+  shelly backup <command>   # Manage database backups
+  shelly config <command>   # Manage application configuration files
+  shelly delete             # Delete the cloud
+  shelly deploys <command>  # View deploy logs
   shelly help [TASK]        # Describe available tasks or one specific task
-  shelly ip                 # Lists clouds IP's
-  shelly list               # Lists all your clouds
-  shelly login [EMAIL]      # Logs user in to Shelly Cloud
-  shelly logs               # Show latest application logs from each instance
-  shelly register [EMAIL]   # Registers new user account on Shelly Cloud
-  shelly start              # Starts the cloud
-  shelly stop               # Stops the cloud
-  shelly user <command>     # Manages users using this cloud
-  shelly version            # Displays shelly version
+  shelly ip                 # List cloud's IP addresses
+  shelly list               # List available clouds
+  shelly login [EMAIL]      # Log into Shelly Cloud
+  shelly logout             # Logout from Shelly Cloud
+  shelly logs               # Show latest application logs
+  shelly redeploy           # Redeploy application
+  shelly register [EMAIL]   # Register new account
+  shelly start              # Start the cloud
+  shelly stop               # Stop the cloud
+  shelly user <command>     # Manage collaborators
+  shelly version            # Display shelly version
 
 Options:
   [--debug]  # Show debug information
@@ -53,10 +55,10 @@ Usage:
   shelly logs
 
 Options:
-  -c, [--cloud=CLOUD]  # Specify which cloud to show logs for
+  -c, [--cloud=CLOUD]  # Specify cloud
       [--debug]        # Show debug information
 
-Show latest application logs from each instance
+Show latest application logs
 OUT
       out = IO.popen("bin/shelly help logs").read.strip
       out.should == expected.strip
@@ -85,7 +87,7 @@ OUT
     end
 
     it "should check ssh key in database" do
-      @user.stub(:ssh_key_registered?).and_raise(RestClient::Conflict)
+      @user.stub(:ssh_key_registered?).and_raise(Shelly::Client::ConflictException.new)
       $stdout.should_receive(:puts).with("\e[31mUser with your ssh key already exists.\e[0m")
       $stdout.should_receive(:puts).with("\e[31mYou can login using: shelly login [EMAIL]\e[0m")
       lambda {
@@ -172,8 +174,8 @@ OUT
 
     context "on unsuccessful registration" do
       it "should display errors and exit with 1" do
-        response = {"message" => "Validation Failed", "errors" => [["email", "has been already taken"]]}
-        exception = Shelly::Client::APIError.new(422, response)
+        body = {"message" => "Validation Failed", "errors" => [["email", "has been already taken"]]}
+        exception = Shelly::Client::ValidationException.new(body)
         @client.stub(:register_user).and_raise(exception)
         $stdout.should_receive(:puts).with("\e[31mEmail has been already taken\e[0m")
         lambda {
@@ -252,7 +254,7 @@ OUT
     context "on unauthorized user" do
       it "should exit with 1 and display error message" do
         response = {"message" => "Unauthorized", "url" => "https://admin.winniecloud.com/users/password/new"}
-        exception = Shelly::Client::APIError.new(401, response)
+        exception = Shelly::Client::UnauthorizedException.new(response)
         @client.stub(:token).and_raise(exception)
         $stdout.should_receive(:puts).with("\e[31mWrong email or password\e[0m")
         $stdout.should_receive(:puts).with("\e[31mYou can reset password by using link:\e[0m")
@@ -281,6 +283,7 @@ OUT
       @client.stub(:token).and_return("abc")
     end
 
+    # This spec tests inside_git_repository? hook
     it "should exit with message if command run outside git repository" do
       Shelly::App.stub(:inside_git_repository?).and_return(false)
       $stdout.should_receive(:puts).with("\e[31mMust be run inside your project git repository\e[0m")
@@ -291,8 +294,19 @@ OUT
       }.should raise_error(SystemExit)
     end
 
-    context "command line options" do
+    # This spec tests logged_in? hook
+    it "should exit with message if user is not logged in" do
+      exception = Shelly::Client::UnauthorizedException.new
+      @client.stub(:token).and_raise(exception)
+      $stdout.should_receive(:puts).with(red "You are not logged in. To log in use: `shelly login`")
+      lambda {
+        fake_stdin(["", ""]) do
+          invoke(@main, :add)
+        end
+      }.should raise_error(SystemExit)
+    end
 
+    context "command line options" do
       context "invalid params" do
         it "should show help and exit if not all options are passed" do
           $stdout.should_receive(:puts).with("\e[31mTry 'shelly help add' for more information\e[0m")
@@ -363,6 +377,15 @@ OUT
       end
     end
 
+    context "when user provided 'none' database" do
+      it "shouldn't take it into account" do
+        @app.should_receive(:databases=).with(["postgresql"])
+        fake_stdin(["", "postgresql, none"]) do
+          invoke(@main, :add)
+        end
+      end
+    end
+
     it "should create the app on shelly cloud" do
       @app.should_receive(:create)
       fake_stdin(["", ""]) do
@@ -371,8 +394,8 @@ OUT
     end
 
     it "should display validation errors if they are any" do
-      response = {"message" => "Validation Failed", "errors" => [["code_name", "has been already taken"]]}
-      exception = Shelly::Client::APIError.new(422, response)
+      body = {"message" => "Validation Failed", "errors" => [["code_name", "has been already taken"]]}
+      exception = Shelly::Client::ValidationException.new(body)
       @app.should_receive(:create).and_raise(exception)
       $stdout.should_receive(:puts).with("\e[31mCode name has been already taken\e[0m")
       $stdout.should_receive(:puts).with("\e[31mFix erros in the below command and type it again to create your cloud\e[0m")
@@ -439,6 +462,10 @@ OUT
       Shelly::User.stub(:new).and_return(@user)
     end
 
+    it "should ensure user has logged in" do
+      hooks(@main, :list).should include(:logged_in?)
+    end
+
     it "should display user's clouds" do
       $stdout.should_receive(:puts).with("\e[32mYou have following clouds available:\e[0m")
       $stdout.should_receive(:puts).with(/abc\s+\|  running/)
@@ -457,18 +484,6 @@ OUT
       $stdout.should_receive(:puts).with("\e[32mYou have no clouds yet\e[0m")
       invoke(@main, :status)
     end
-
-    context "on failure" do
-      it "should display info that user is not logged in" do
-        error = Shelly::Client::APIError.new(401)
-        @client.stub(:token).and_raise(error)
-        $stdout.should_receive(:puts).with(red "You are not logged in. To log in use:")
-        $stdout.should_receive(:puts).with("  shelly login")
-        lambda {
-          invoke(@main, :list)
-        }.should raise_error(SystemExit)
-      end
-    end
   end
 
   describe "#start" do
@@ -484,6 +499,7 @@ OUT
       Shelly::App.stub(:new).and_return(@app)
     end
 
+    # This spec tests cloudfile_present? hook
     it "should exit if there is no Cloudfile" do
       File.delete("Cloudfile")
       $stdout.should_receive(:puts).with("\e[31mNo Cloudfile found\e[0m")
@@ -492,22 +508,17 @@ OUT
       }.should raise_error(SystemExit)
     end
 
+    it "should ensure user has logged in" do
+      hooks(@main, :start).should include(:logged_in?)
+    end
+
     it "should exit if user doesn't have access to clouds in Cloudfile" do
-      response = {"message" => "Couldn't find Cloud with"}
-      exception = Shelly::Client::APIError.new(404, response)
+      exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
       @client.stub(:start_cloud).and_raise(exception)
       $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
       lambda { invoke(@main, :start) }.should raise_error(SystemExit)
     end
 
-    it "should exit if user is not logged in" do
-      exception = Shelly::Client::APIError.new(401)
-      @client.stub(:token).and_raise(exception)
-      $stdout.should_receive(:puts).with(red "You are not logged in. To log in use:")
-      $stdout.should_receive(:puts).with("  shelly login")
-      lambda { invoke(@main, :start) }.should raise_error(SystemExit)
-    end
-
     context "single cloud in Cloudfile" do
       it "should start the cloud" do
         @client.stub(:start_cloud)
@@ -523,8 +534,8 @@ OUT
       end
 
       it "should show information to start specific cloud and exit" do
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Select cloud to start using:")
-        $stdout.should_receive(:puts).with("  shelly start --cloud foo-production")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly start --cloud foo-production`")
         $stdout.should_receive(:puts).with("Available clouds:")
         $stdout.should_receive(:puts).with(" * foo-production")
         $stdout.should_receive(:puts).with(" * foo-staging")
@@ -542,21 +553,21 @@ OUT
 
     context "on failure" do
       it "should show information that cloud is running" do
-        raise_conflict(:state => "running")
+        raise_conflict("state" => "running")
         $stdout.should_receive(:puts).with(red "Not starting: cloud 'foo-production' is already running")
         lambda { invoke(@main, :start)  }.should raise_error(SystemExit)
       end
 
       %w{deploying configuring}.each do |state|
         it "should show information that cloud is #{state}" do
-          raise_conflict(:state => state)
+          raise_conflict("state" => state)
           $stdout.should_receive(:puts).with(red "Not starting: cloud 'foo-production' is currently deploying")
           lambda { invoke(@main, :start) }.should raise_error(SystemExit)
         end
       end
 
       it "should show information that cloud has no code" do
-        raise_conflict(:state => "no_code")
+        raise_conflict("state" => "no_code")
         $stdout.should_receive(:puts).with(red "Not starting: no source code provided")
         $stdout.should_receive(:puts).with(red "Push source code using:")
         $stdout.should_receive(:puts).with("  git push production master")
@@ -565,24 +576,25 @@ OUT
 
       %w{deploy_failed configuration_failed}.each do |state|
         it "should show information that cloud #{state}" do
-          raise_conflict(:state => state, :link => "http://example.com/logs")
+          raise_conflict("state" => state)
           $stdout.should_receive(:puts).with(red "Not starting: deployment failed")
           $stdout.should_receive(:puts).with(red "Support has been notified")
-          $stdout.should_receive(:puts).with(red "See http://example.com/logs for reasons of failure")
+          $stdout.should_receive(:puts).
+            with(red "Check `shelly deploys show last --cloud foo-production` for reasons of failure")
           lambda { invoke(@main, :start) }.should raise_error(SystemExit)
         end
       end
+
       it "should open billing page" do
-        raise_conflict(:state => "no_billing")
+        raise_conflict("state" => "no_billing")
         $stdout.should_receive(:puts).with(red "Please fill in billing details to start foo-production. Opening browser.")
         @app.should_receive(:open_billing_page)
         lambda { invoke(@main, :start) }.should raise_error(SystemExit)
       end
 
       def raise_conflict(options = {})
-        options = {:state => "no_code"}.merge(options)
-        exception = RestClient::Conflict.new
-        exception.stub(:response).and_return(options.to_json)
+        body = {"state" => "no_code"}.merge(options)
+        exception = Shelly::Client::ConflictException.new(body)
         @client.stub(:start_cloud).and_raise(exception)
       end
     end
@@ -601,24 +613,17 @@ OUT
       Shelly::App.stub(:new).and_return(@app)
     end
 
-    it "should exit if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with("\e[31mNo Cloudfile found\e[0m")
-      lambda {
-        invoke(@main, :stop)
-      }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@main, :stop).should include(:logged_in?)
     end
 
-    it "should exit if user doesn't have access to clouds in Cloudfile" do
-      @client.stub(:stop_cloud).and_raise(Shelly::Client::APIError.new(404))
-      $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
-      lambda { invoke(@main, :stop) }.should raise_error(SystemExit)
+    it "should ensure that Cloudfile is present" do
+      hooks(@main, :stop).should include(:cloudfile_present?)
     end
 
-    it "should exit if user is not logged in" do
-      @client.stub(:token).and_raise(Shelly::Client::APIError.new(401))
-      $stdout.should_receive(:puts).with(red "You are not logged in. To log in use:")
-      $stdout.should_receive(:puts).with("  shelly login")
+    it "should exit if user doesn't have access to clouds in Cloudfile" do
+      @client.stub(:stop_cloud).and_raise(Shelly::Client::NotFoundException.new("resource" => "cloud"))
+      $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
       lambda { invoke(@main, :stop) }.should raise_error(SystemExit)
     end
 
@@ -636,8 +641,8 @@ OUT
       end
 
       it "should show information to start specific cloud and exit" do
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Select cloud to stop using:")
-        $stdout.should_receive(:puts).with("  shelly stop --cloud foo-production")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly stop --cloud foo-production`")
         $stdout.should_receive(:puts).with("Available clouds:")
         $stdout.should_receive(:puts).with(" * foo-production")
         $stdout.should_receive(:puts).with(" * foo-staging")
@@ -653,18 +658,18 @@ OUT
     end
   end
 
-  describe "#ips" do
+  describe "#ip" do
     before do
       File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
-      Shelly::App.stub(:inside_git_repository?).and_return(true)
+      @main.stub(:logged_in?).and_return(true)
     end
 
-    it "should exit with message if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with("\e[31mNo Cloudfile found\e[0m")
-      lambda {
-        invoke(@main, :ip)
-      }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@main, :ip).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@main, :ip).should include(:cloudfile_present?)
     end
 
     context "on success" do
@@ -683,7 +688,7 @@ OUT
 
     context "on failure" do
       it "should raise an error if user does not have access to cloud" do
-        exception = Shelly::Client::APIError.new(404, {"message" => "Cloud foo-staging not found"})
+        exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
         @client.stub(:app).and_raise(exception)
         $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
         invoke(@main, :ip)
@@ -702,6 +707,10 @@ OUT
       Shelly::App.stub(:new).and_return(@app)
     end
 
+    it "should ensure user has logged in" do
+      hooks(@main, :delete).should include(:logged_in?)
+    end
+
     context "when cloud is given" do
       before do
         File.open("Cloudfile", 'w') {|f|
@@ -758,8 +767,8 @@ OUT
           f.write("foo-staging:\n") }
       end
 
-      it "should raise Client::APIError" do
-        exception = Shelly::Client::APIError.new(404)
+      it "should raise Client::NotFoundException" do
+        exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
         @app.stub(:delete).and_raise(exception)
         $stdout.should_receive(:puts).with(red "You have no access to 'foo-bar' cloud defined in Cloudfile")
         lambda{
@@ -795,13 +804,46 @@ OUT
     end
   end
 
+  describe "#logout" do
+    before do
+      @user = Shelly::User.new
+      @client.stub(:token).and_return("abc")
+      Shelly::User.stub(:new).and_return(@user)
+      FileUtils.mkdir_p("~/.ssh")
+      FileUtils.mkdir_p("~/.shelly")
+      File.open("Cloudfile", 'w') { |f| f.write("foo-production:\n") }
+      File.open("~/.ssh/id_rsa.pub", "w") { |f| f << "ssh-key AAbbcc" }
+      @key_path = File.expand_path("~/.ssh/id_rsa.pub")
+      File.open("~/.shelly/credentials", "w") { |f| f << "megan@fox.pl\nsecret" }
+      @client.stub(:logout).and_return(true)
+    end
+
+    it "should ensure user has logged in" do
+      hooks(@main, :logout).should include(:logged_in?)
+    end
+
+    it "should logout from shelly cloud and show message" do
+      $stdout.should_receive(:puts).with("Your public SSH key has been removed from Shelly Cloud")
+      $stdout.should_receive(:puts).with("You have been successfully logged out")
+      invoke(@main, :logout)
+      File.exists?("~/.shelly/credentials").should be_false
+    end
+
+    it "should remove only credentiales when local ssh key doesn't exist" do
+      FileUtils.rm_rf(@key_path)
+      $stdout.should_receive(:puts).with("You have been successfully logged out")
+      invoke(@main, :logout)
+      File.exists?("~/.shelly/credentials").should be_false
+    end
+  end
+
   describe "#logs" do
     before do
       @user = Shelly::User.new
       @client.stub(:token).and_return("abc")
       FileUtils.mkdir_p("/projects/foo")
       Dir.chdir("/projects/foo")
-      File.open("Cloudfile", 'w') {|f| f.write("foo-production:\n") }
+      File.open("Cloudfile", 'w') { |f| f.write("foo-production:\n") }
       Shelly::User.stub(:new).and_return(@user)
       @client.stub(:apps).and_return([{"code_name" => "foo-production"},
                                      {"code_name" => "foo-staging"}])
@@ -809,29 +851,19 @@ OUT
       Shelly::App.stub(:new).and_return(@app)
     end
 
-    it "should exit if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with("\e[31mNo Cloudfile found\e[0m")
-      lambda {
-        invoke(@main, :logs)
-      }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@main, :logs).should include(:logged_in?)
     end
 
-    it "should exit if user doesn't have access to clouds in Cloudfile" do
-      response = {"message" => "Cloud foo-production not found"}
-      exception = Shelly::Client::APIError.new(404, response)
-      @client.stub(:application_logs).and_raise(exception)
-      $stdout.should_receive(:puts).
-        with(red "You have no access to cloud 'foo-production'")
-      lambda { invoke(@main, :logs) }.should raise_error(SystemExit)
+    it "should ensure that Cloudfile is present" do
+      hooks(@main, :logs).should include(:cloudfile_present?)
     end
 
-    it "should exit if user is not logged in" do
-      exception = Shelly::Client::APIError.new(401)
-      @client.stub(:token).and_raise(exception)
+    it "should exit if user doesn't have access to clouds in Cloudfile" do
+      exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
+      @client.stub(:application_logs).and_raise(exception)
       $stdout.should_receive(:puts).
-        with(red "You are not logged in. To log in use:")
-      $stdout.should_receive(:puts).with("  shelly login")
+        with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
       lambda { invoke(@main, :logs) }.should raise_error(SystemExit)
     end
 
@@ -852,9 +884,8 @@ OUT
       end
 
       it "should show information to print logs for specific cloud and exit" do
-        $stdout.should_receive(:puts).
-          with("You have multiple clouds in Cloudfile. Select which to show logs for using:")
-        $stdout.should_receive(:puts).with("  shelly logs --cloud foo-production")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly logs --cloud foo-production`")
         $stdout.should_receive(:puts).with("Available clouds:")
         $stdout.should_receive(:puts).with(" * foo-production")
         $stdout.should_receive(:puts).with(" * foo-staging")
@@ -884,4 +915,81 @@ OUT
       end
     end
   end
+
+  describe "#redeploy" do
+    before do
+      @user = Shelly::User.new
+      @client.stub(:token).and_return("abc")
+      @app = Shelly::App.new
+      Shelly::App.stub(:new).and_return(@app)
+      FileUtils.mkdir_p("/projects/foo")
+      Dir.chdir("/projects/foo")
+      File.open("Cloudfile", 'w') { |f| f.write("foo-production:\n") }
+    end
+
+    it "should redeploy the application" do
+      $stdout.should_receive(:puts).with(green "Redeploying your application for cloud 'foo-production'")
+      @app.should_receive(:redeploy)
+      invoke(@main, :redeploy)
+    end
+
+    context "on redeploy failure" do
+      %w(deploying configuring).each do |state|
+        context "when application is in #{state} state" do
+          it "should display error that deploy is in progress" do
+            exception = Shelly::Client::ConflictException.new("state" => state)
+            @client.should_receive(:redeploy).with("foo-production").and_raise(exception)
+            $stdout.should_receive(:puts).with(red "Your application is being redeployed at the moment")
+            lambda {
+              invoke(@main, :redeploy)
+            }.should raise_error(SystemExit)
+          end
+        end
+      end
+
+      %w(no_code no_billing turned_off).each do |state|
+        context "when application is in #{state} state" do
+          it "should display error that cloud is not running" do
+            exception = Shelly::Client::ConflictException.new("state" => state)
+            @client.should_receive(:redeploy).with("foo-production").and_raise(exception)
+            $stdout.should_receive(:puts).with(red "Cloud foo-production is not running")
+            $stdout.should_receive(:puts).with("Start your cloud with `shelly start --cloud foo-production`")
+            lambda {
+              invoke(@main, :redeploy)
+            }.should raise_error(SystemExit)
+          end
+        end
+      end
+
+      it "should re-raise exception on unknown state" do
+        exception = Shelly::Client::ConflictException.new("state" => "doing_something")
+        @client.should_receive(:redeploy).with("foo-production").and_raise(exception)
+        lambda {
+          invoke(@main, :redeploy)
+        }.should raise_error(Shelly::Client::ConflictException)
+      end
+    end
+
+    context "on multiple clouds in Cloudfile" do
+      before do
+        File.open("Cloudfile", 'w') { |f| f.write("foo-staging:\nfoo-production:\n") }
+      end
+
+      it "should show information to redeploy application for specific cloud and exit" do
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly redeploy --cloud foo-production`")
+        $stdout.should_receive(:puts).with("Available clouds:")
+        $stdout.should_receive(:puts).with(" * foo-production")
+        $stdout.should_receive(:puts).with(" * foo-staging")
+        lambda { invoke(@main, :redeploy) }.should raise_error(SystemExit)
+      end
+
+      it "should fetch from command line which cloud to redeploy application for" do
+        @client.should_receive(:redeploy).with("foo-staging")
+        $stdout.should_receive(:puts).with(green "Redeploying your application for cloud 'foo-staging'")
+        @main.options = {:cloud => "foo-staging"}
+        invoke(@main, :redeploy)
+      end
+    end
+  end
 end

data/spec/shelly/cli/runner_spec.rb

@@ -22,7 +22,7 @@ describe Shelly::CLI::Runner do
     it "should be true if args include --debug option" do
       @runner.should be_debug
     end
-    
+
     it "should be true if SHELLY_DEBUG is set to true" do
       runner = Shelly::CLI::Runner.new
       runner.should_not be_debug
@@ -42,6 +42,16 @@ describe Shelly::CLI::Runner do
       @runner.start
     end
 
+    it "should rescue interrupt exception and display message" do
+      Shelly::CLI::Main.stub(:start).and_raise(Interrupt.new)
+      runner = Shelly::CLI::Runner.new(%w(login))
+      $stdout.should_receive(:puts).with("\n")
+      $stdout.should_receive(:puts).with("[canceled]")
+      lambda {
+        runner.start
+      }.should raise_error(SystemExit)
+    end
+
     context "with --debug option (debug mode)" do
       it "should re-raise caught exception to the console" do
         Shelly::CLI::Main.stub(:start).and_raise(RuntimeError.new)
@@ -60,6 +70,24 @@ describe Shelly::CLI::Runner do
           runner.start
         }.should raise_error(SystemExit)
       end
+
+      it "should caught exception thrown by API Client" do
+        Shelly::CLI::Main.stub(:start).and_raise(Shelly::Client::APIException.new)
+        runner = Shelly::CLI::Runner.new(%w(version))
+        $stdout.should_receive(:puts).with("Unknown error, to see debug information run command with --debug")
+        lambda {
+          runner.start
+        }.should raise_error(SystemExit)
+      end
+
+      it "should re-reise SystemExit exceptions" do
+        Shelly::CLI::Main.stub(:start).and_raise(SystemExit.new)
+        $stdout.should_not_receive(:puts).with("Unknown error, to see debug information run command with --debug")
+        runner = Shelly::CLI::Runner.new(%w(version))
+        lambda {
+          runner.start
+        }.should raise_error(SystemExit)
+      end
     end
   end
 end