shelly 0.0.43 → 0.0.44.pre

data/spec/shelly/cli/backup_spec.rb

@@ -18,19 +18,19 @@ describe Shelly::CLI::Backup do
     before do
       FileUtils.mkdir_p("/projects/foo")
       Dir.chdir("/projects/foo")
-      File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
+      File.open("Cloudfile", 'w') { |f| f.write("foo-staging:\n") }
     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(@backup, :list)
-      }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@backup, :list).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@backup, :list).should include(:cloudfile_present?)
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
-      exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Cloud with"})
+      exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
       @client.stub(:database_backups).and_raise(exception)
       $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
       lambda { invoke(@backup, :list) }.should raise_error(SystemExit)
@@ -42,8 +42,8 @@ describe Shelly::CLI::Backup do
       end
 
       it "should show information to select specific cloud and exit" do
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Select cloud to view database backups for using:")
-        $stdout.should_receive(:puts).with("  shelly backup list --cloud foo-production")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly backup list --cloud foo-production`")
         $stdout.should_receive(:puts).with("Available clouds:")
         $stdout.should_receive(:puts).with(" * foo-production")
         $stdout.should_receive(:puts).with(" * foo-staging")
@@ -71,6 +71,10 @@ describe Shelly::CLI::Backup do
         $stdout.stub(:puts)
       end
 
+      it "should ensure user has logged in" do
+        hooks(@backup, :get).should include(:logged_in?)
+      end
+
       it "should make sure that cloud is choosen" do
         @client.should_receive(:database_backup).with("foo-staging", "last")
         invoke(@backup, :get)
@@ -103,23 +107,23 @@ describe Shelly::CLI::Backup do
 
       context "on backup not found" do
         it "it should display error message" do
-          exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Backup with"})
+          exception = Shelly::Client::NotFoundException.new({"resource" => "database_backup"})
           @client.stub(:database_backup).and_raise(exception)
           $stdout.should_receive(:puts).with(red "Backup not found")
-          $stdout.should_receive(:puts).with("You can list available backups with 'shelly backup list' command")
+          $stdout.should_receive(:puts).with("You can list available backups with `shelly backup list` command")
           invoke(@backup, :get, "better.tar.gz")
         end
       end
 
       context "on unsupported exception" do
         it "should re-raise it" do
-          exception = Shelly::Client::APIError.new(500)
+          exception = Shelly::Client::APIException.new
           @client.stub(:database_backup).and_raise(exception)
           $stdout.should_not_receive(:puts).with(red "Backup not found")
-          $stdout.should_not_receive(:puts).with("You can list available backups with 'shelly backup list' command")
+          $stdout.should_not_receive(:puts).with("You can list available backups with `shelly backup list` command")
           lambda {
             invoke(@backup, :get, "better.tar.gz")
-          }.should raise_error(Shelly::Client::APIError)
+          }.should raise_error(Shelly::Client::APIException)
         end
       end
     end
@@ -132,8 +136,12 @@ describe Shelly::CLI::Backup do
       File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
     end
 
+    it "should ensure user has logged in" do
+      hooks(@backup, :create).should include(:logged_in?)
+    end
+
     it "should exit if user doesn't have access to cloud in Cloudfile" do
-      exception = Shelly::Client::APIError.new(404, {"message" => "Cloud foo-staging not found"})
+      exception = Shelly::Client::NotFoundException.new({"resource" => "cloud"})
       @client.stub(:request_backup).and_raise(exception)
       $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
       lambda { invoke(@backup, :create) }.should raise_error(SystemExit)
@@ -141,7 +149,7 @@ describe Shelly::CLI::Backup do
 
     it "should display errors and exit 1 when kind is not valid" do
       response = {"message" => "Wrong KIND argument. User one of following: postgresql, mongodb, redis"}
-      exception = Shelly::Client::APIError.new(422, response)
+      exception = Shelly::Client::ValidationException.new(response)
       @client.should_receive(:request_backup).and_raise(exception)
       $stdout.should_receive(:puts).with(red response["message"])
       lambda { invoke(@backup, :create) }.should raise_error(SystemExit)
@@ -162,16 +170,20 @@ describe Shelly::CLI::Backup do
       $stdout.stub(:puts)
     end
 
+    it "should ensure user has logged in" do
+      hooks(@backup, :restore).should include(:logged_in?)
+    end
+
     it "should restore database" do
       $stdout.should_receive(:puts).with("You are about restore database postgre for cloud foo-staging to state from better.tar.gz")
       $stdout.should_receive(:print).with("I want to restore the database (yes/no): ")
       $stdout.should_receive(:puts).with("\n")
       @client.stub(:restore_backup).with("todo-list-test","better.tar.gz")
       $stdout.should_receive(:puts).with("\n")
-      $stdout.should_receive(:puts).with("Restore has been scheduled. Wait few minutes till database is restored.")
+      $stdout.should_receive(:puts).with("Restore has been scheduled. Wait a few minutes till database is restored.")
 
       fake_stdin(["yes"]) do
-        @backup.restore("better.tar.gz")
+        invoke(@backup, :restore, "better.tar.gz")
       end
     end
 
@@ -184,27 +196,20 @@ describe Shelly::CLI::Backup do
 
         lambda {
           fake_stdin(["no"]) do
-            @backup.restore("better.tar.gz")
+            invoke(@backup, :restore, "better.tar.gz")
           end
         }.should raise_error(SystemExit)
       end
     end
 
-    it "should exit with 1 when filename is not specified" do
-      $stdout.should_receive(:puts).with(red "Filename is required")
-      lambda {
-        @backup.restore
-      }.should raise_error(SystemExit)
-    end
-
     context "on backup not found" do
       it "should display error message" do
-        response = {"message" => "Backup restore not found"}
-        exception = Shelly::Client::APIError.new(404, response)
+        response = {"resource" => "database_backup"}
+        exception = Shelly::Client::NotFoundException.new(response)
         @client.stub(:database_backup).and_raise(exception)
         $stdout.should_receive(:puts).with(red "Backup not found")
-        $stdout.should_receive(:puts).with("You can list available backups with 'shelly backup list' command")
-        @backup.restore("better.tar.gz")
+        $stdout.should_receive(:puts).with("You can list available backups with `shelly backup list` command")
+        invoke(@backup, :restore, "better.tar.gz")
       end
     end
   end

data/spec/shelly/cli/config_spec.rb

@@ -25,17 +25,16 @@ describe Shelly::CLI::Config do
       File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
     end
 
-    it "should exit with message if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with(red "No Cloudfile found")
-      lambda {
-        invoke(@config, :list)
-      }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@config, :list).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@config, :list).should include(:cloudfile_present?)
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
-      response = {"message" => "Couldn't find Cloud with code_name = foo-staging"}
-      exception = Shelly::Client::APIError.new(404, response)
+      exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
       @client.stub(:app_configs).and_raise(exception)
       $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
       lambda { invoke(@config, :list) }.should raise_error(SystemExit)
@@ -58,10 +57,13 @@ describe Shelly::CLI::Config do
   end
 
   describe "#show" do
-    it "should exit with message if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with(red "No Cloudfile found")
-      lambda { invoke(@config, :show) }.should raise_error(SystemExit)
+
+    it "should ensure user has logged in" do
+      hooks(@config, :show).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@config, :show).should include(:cloudfile_present?)
     end
 
     it "should exit if no path was specified" do
@@ -79,7 +81,7 @@ describe Shelly::CLI::Config do
     describe "on failure" do
       context "when config doesn't exist" do
         it "should display error message and exit with 1" do
-          exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Config with"})
+          exception = Shelly::Client::NotFoundException.new("resource" => "config")
           @client.should_receive(:app_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "Config 'config/app.yml' not found")
           $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-staging`")
@@ -91,7 +93,7 @@ describe Shelly::CLI::Config do
 
       context "when user doesn't have access to cloud" do
         it "should display error message and exit with 1" do
-          exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Cloud with"})
+          exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
           @client.should_receive(:app_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
           lambda {
@@ -107,7 +109,8 @@ describe Shelly::CLI::Config do
       end
 
       it "should show info to select cloud and exit" do
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Specify cloud using:")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly show path --cloud foo-production`")
         lambda { invoke(@config, :show, "path") }.should raise_error(SystemExit)
       end
 
@@ -120,10 +123,12 @@ describe Shelly::CLI::Config do
   end
 
   describe "#create" do
-    it "should exit with message if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with(red "No Cloudfile found")
-      lambda { invoke(@config, :create, "path") }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@config, :create).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@config, :create).should include(:cloudfile_present?)
     end
 
     it "should exit if no path was specified" do
@@ -144,6 +149,18 @@ describe Shelly::CLI::Config do
       invoke(@config, :create, "path")
     end
 
+    context "on validation errors" do
+      it "should display validation errors" do
+        exception = Shelly::Client::ValidationException.new({"errors" => [["path", "is already taken"]]})
+        @config.should_receive(:system).with(/vim \/tmp\/shelly-edit/).and_return(true)
+        @client.stub(:app_create_config).and_raise(exception)
+        $stdout.should_receive(:puts).with(red "Path is already taken")
+        lambda {
+          invoke(@config, :create, "config/app.yml")
+        }.should raise_error(SystemExit)
+      end
+    end
+
     context "multiple clouds" do
       before do
         File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
@@ -151,7 +168,8 @@ describe Shelly::CLI::Config do
 
       it "should show info to select cloud and exit" do
         @config.stub(:system) {true}
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Specify cloud using:")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly create path --cloud foo-production`")
         lambda { @config.create("path") }.should raise_error(SystemExit)
       end
 
@@ -166,10 +184,12 @@ describe Shelly::CLI::Config do
 
 
   describe "#edit" do
-    it "should exit with message if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with(red "No Cloudfile found")
-      lambda { invoke(@config, :edit, "path") }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@config, :edit).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@config, :edit).should include(:cloudfile_present?)
     end
 
     it "should exit if no path was specified" do
@@ -195,7 +215,7 @@ describe Shelly::CLI::Config do
     describe "on failure" do
       context "when config doesn't exist" do
         it "should display error message and exit with 1" do
-          exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Config with"})
+          exception = Shelly::Client::NotFoundException.new("resource" => "config")
           @client.should_receive(:app_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "Config 'config/app.yml' not found")
           $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-staging`")
@@ -207,7 +227,7 @@ describe Shelly::CLI::Config do
 
       context "when user doesn't have access to cloud" do
         it "should display error message and exit with 1" do
-          exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Cloud with"})
+          exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
           @client.should_receive(:app_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
           lambda {
@@ -215,6 +235,17 @@ describe Shelly::CLI::Config do
           }.should raise_error(SystemExit)
         end
       end
+
+      context "on validation errors" do
+        it "should display validation errors" do
+          exception = Shelly::Client::ValidationException.new({"errors" => [["path", "is already taken"]]})
+          @client.should_receive(:app_config).and_raise(exception)
+          $stdout.should_receive(:puts).with(red "Path is already taken")
+          lambda {
+            invoke(@config, :edit, "config/app.yml")
+          }.should raise_error(SystemExit)
+        end
+      end
     end
 
     context "multiple clouds" do
@@ -224,7 +255,8 @@ describe Shelly::CLI::Config do
 
       it "should show info to select cloud and exit" do
         @config.stub(:system) {true}
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Specify cloud using:")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly edit path --cloud foo-production`")
         lambda { invoke(@config, :edit, "path") }.should raise_error(SystemExit)
       end
 
@@ -239,10 +271,12 @@ describe Shelly::CLI::Config do
   end
 
   describe "#delete" do
-    it "should exit with message if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with(red "No Cloudfile found")
-      lambda { invoke(@config, :delete) }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@config, :delete).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@config, :delete).should include(:cloudfile_present?)
     end
 
     it "should exit if no path was specified" do
@@ -272,7 +306,8 @@ describe Shelly::CLI::Config do
       end
 
       it "should show info to select cloud and exit" do
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Specify cloud using:")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly delete path --cloud foo-production`")
         lambda { invoke(@config, :delete, "path") }.should raise_error(SystemExit)
       end
 
@@ -289,7 +324,7 @@ describe Shelly::CLI::Config do
     describe "on failure" do
       context "when config doesn't exist" do
         it "should display error message and exit with 1" do
-          exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Config with"})
+          exception = Shelly::Client::NotFoundException.new("resource" => "config")
           @client.should_receive(:app_delete_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "Config 'config/app.yml' not found")
           $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-staging`")
@@ -303,7 +338,7 @@ describe Shelly::CLI::Config do
 
       context "when user doesn't have access to cloud" do
         it "should display error message and exit with 1" do
-          exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Cloud with"})
+          exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
           @client.should_receive(:app_delete_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
           fake_stdin(["y"]) do
@@ -316,4 +351,4 @@ describe Shelly::CLI::Config do
     end
 
   end
-end
+end

data/spec/shelly/cli/deploys_spec.rb

@@ -20,16 +20,16 @@ describe Shelly::CLI::Deploys do
       @client.stub(:token).and_return("abc")
     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(@deploys, :list)
-      }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@deploys, :list).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@deploys, :list).should include(:cloudfile_present?)
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
-      @client.stub(:deploy_logs).and_raise(Shelly::Client::APIError.new(404))
+      @client.stub(:deploy_logs).and_raise(Shelly::Client::NotFoundException.new("resource" => "cloud"))
       $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
       lambda { invoke(@deploys, :list) }.should raise_error(SystemExit)
     end
@@ -40,8 +40,8 @@ describe Shelly::CLI::Deploys do
       end
 
       it "should show information to select specific cloud and exit" do
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Select cloud to view deploy logs using:")
-        $stdout.should_receive(:puts).with("  shelly deploys list --cloud foo-production")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly deploys list --cloud foo-production`")
         $stdout.should_receive(:puts).with("Available clouds:")
         $stdout.should_receive(:puts).with(" * foo-production")
         $stdout.should_receive(:puts).with(" * foo-staging")
@@ -78,17 +78,17 @@ describe Shelly::CLI::Deploys do
       @client.stub(:token).and_return("abc")
     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(@deploys, :show)
-      }.should raise_error(SystemExit)
+    it "should ensure user has logged in" do
+      hooks(@deploys, :show).should include(:logged_in?)
+    end
+
+    it "should ensure that Cloudfile is present" do
+      hooks(@deploys, :show).should include(:cloudfile_present?)
     end
 
     context "user doesn't have access to cloud" do
       it "should exit 1 with message" do
-        exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Cloud with"})
+        exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
         @client.stub(:deploy_log).and_raise(exception)
         $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
         lambda { @deploys.show("last") }.should raise_error(SystemExit)
@@ -97,7 +97,7 @@ describe Shelly::CLI::Deploys do
 
     context "log not found" do
       it "should exit 1 with message" do
-        exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Log with"})
+        exception = Shelly::Client::NotFoundException.new("resource" => "log")
         @client.stub(:deploy_log).and_raise(exception)
         $stdout.should_receive(:puts).with(red "Log not found, list all deploy logs using  `shelly deploys list --cloud=foo-staging`")
         lambda { @deploys.show("last") }.should raise_error(SystemExit)
@@ -110,8 +110,8 @@ describe Shelly::CLI::Deploys do
       end
 
       it "should show information to select specific cloud and exit" do
-        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Select log and cloud to view deploy logs using:")
-        $stdout.should_receive(:puts).with("  shelly deploys show last --cloud foo-production")
+        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly deploys show last --cloud foo-production`")
         $stdout.should_receive(:puts).with("Available clouds:")
         $stdout.should_receive(:puts).with(" * foo-production")
         $stdout.should_receive(:puts).with(" * foo-staging")