shelly 0.0.40 → 0.0.41.pre

data/lib/shelly/app.rb

@@ -1,14 +1,13 @@
 require 'erb'
 require 'launchy'
+require "shelly/backup"
 
 module Shelly
   class App < Model
     DATABASE_KINDS = %w(postgresql mongodb redis none)
 
     attr_accessor :code_name, :databases, :ruby_version, :environment,
-      :git_url, :domains
-
-    autoload :Backup, "shelly/backup"
+      :git_url, :domains, :web_server_ip, :mail_server_ip
 
     def initialize(code_name = nil)
       self.code_name = code_name
@@ -99,10 +98,6 @@ module Shelly
       File.basename(Dir.pwd)
     end
 
-    def ips
-      shelly.app_ips(code_name)
-    end
-
     def users
       shelly.app_users(code_name)
     end
@@ -135,6 +130,18 @@ module Shelly
       shelly.app_delete_config(code_name, path)
     end
 
+    def attributes
+      @attributes ||= shelly.app(code_name)
+    end
+
+    def web_server_ip
+      attributes["web_server_ip"]
+    end
+
+    def mail_server_ip
+      attributes["mail_server_ip"]
+    end
+
     def open_billing_page
       url = "#{shelly.shellyapp_url}/login?api_key=#{current_user.token}&return_to=/apps/#{code_name}/edit_billing"
       Launchy.open(url)
@@ -143,5 +150,9 @@ module Shelly
     def self.inside_git_repository?
       system("git status > /dev/null 2>&1")
     end
+
+    def to_s
+      code_name
+    end
   end
 end

data/lib/shelly/cli/backup.rb

@@ -30,10 +30,10 @@ module Shelly
           say "No database backups available"
         end
       rescue Client::APIError => e
-        if e.unauthorized?
+        if e.not_found?
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
         else
-          say_error e.message
+          raise e
         end
       end
 
@@ -49,11 +49,13 @@ module Shelly
         say_new_line
         say "Backup file saved to #{backup.filename}", :green
       rescue Client::APIError => e
-        if e.not_found?
+        case e.resource_not_found
+        when :cloud
+          say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
+        when :backup
           say_error "Backup not found", :with_exit => false
           say "You can list available backups with 'shelly backup list' command"
-        else
-          raise e
+        else; raise e
         end
       end
 
@@ -66,7 +68,7 @@ module Shelly
         say "Backup requested. It can take up to several minutes for" +
           "the backup process to finish and the backup to show up in backups list.", :green
       rescue Client::APIError => e
-        if e.unauthorized?
+        if e.not_found?
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
         else
           say_error e.message

data/lib/shelly/cli/config.rb

@@ -34,10 +34,10 @@ module Shelly
               say "Cloud #{cloud} has no configuration files"
             end
           rescue Client::APIError => e
-            if e.unauthorized?
-              say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
+            if e.resource_not_found == :cloud
+              say_error "You have no access to '#{@app}' cloud defined in Cloudfile"
             else
-              say_error e.message
+              raise e
             end
           end
         end
@@ -53,8 +53,13 @@ module Shelly
         say "Content of #{config["path"]}:", :green
         say config["content"]
       rescue Client::APIError => e
-        if e.unauthorized?
+        case e.resource_not_found
+        when :cloud
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
+        when :config
+          say_error "Config '#{path}' not found", :with_exit => false
+          say_error "You can list available config files with `shelly config list --cloud #{@app}`"
+        else; raise e
         end
       end
 
@@ -69,7 +74,7 @@ module Shelly
         @app.create_config(path, output)
         say "File '#{path}' created, it will be used after next code deploy", :green
       rescue Client::APIError => e
-        if e.unauthorized?
+        if e.resource_not_found == :cloud
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
         elsif e.validation?
           e.each_error { |error| say_error error, :with_exit => false }
@@ -91,8 +96,11 @@ module Shelly
         @app.update_config(path, content)
         say "File '#{config["path"]}' updated, it will be used after next code deploy", :green
       rescue Client::APIError => e
-        if e.unauthorized?
+        if e.resource_not_found == :cloud
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
+        elsif e.resource_not_found == :config
+          say_error "Config '#{path}' not found", :with_exit => false
+          say_error "You can list available config files with `shelly config list --cloud #{@app}`"
         elsif e.validation?
           e.each_error { |error| say_error error, :with_exit => false }
           exit 1
@@ -115,8 +123,11 @@ module Shelly
           say "File not deleted"
         end
       rescue Client::APIError => e
-        if e.unauthorized?
+        if e.resource_not_found == :cloud
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
+        elsif e.resource_not_found == :config
+          say_error "Config '#{path}' not found", :with_exit => false
+          say_error "You can list available config files with `shelly config list --cloud #{@app}`"
         elsif e.validation?
           e.each_error { |error| say_error error, :with_exit => false }
           exit 1

data/lib/shelly/cli/deploys.rb

@@ -25,10 +25,10 @@ module Shelly
           say "No deploy logs available"
         end
       rescue Client::APIError => e
-        if e.unauthorized?
+        if e.not_found?
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
         else
-          say_error e.message
+          raise e
         end
       end
 
@@ -56,12 +56,15 @@ module Shelly
           say("Starting thin", :green); say(content["thin_restart"])
         end
       rescue Client::APIError => e
-        if e.unauthorized?
-          say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
-        elsif e.message == "Log not found"
-          say_error "Log not found, list all deploy logs using:", :with_exit => false
-          say "  shelly deploys list #{cloud}"
-          exit 1
+        if e.not_found?
+          case e.resource_not_found
+          when :cloud
+            say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
+          when :log
+            say_error "Log not found, list all deploy logs using  `shelly deploys list --cloud=#{@app.code_name}`"
+          end
+        else
+          raise e
         end
       end
 

data/lib/shelly/cli/main.rb

@@ -143,16 +143,16 @@ module Shelly
 
       desc "ip", "Lists clouds IP's"
       def ip
+        say_error "No Cloudfile found" unless Cloudfile.present?
         @cloudfile = Cloudfile.new
         @cloudfile.clouds.each do |cloud|
           begin
             @app = App.new(cloud)
             say "Cloud #{cloud}:", :green
-            ips = @app.ips
-            print_wrapped "Web server IP: #{ips['web_server_ip']}", :ident => 2
-            print_wrapped "Mail server IP: #{ips['mail_server_ip']}", :ident => 2
+            print_wrapped "Web server IP: #{@app.web_server_ip}", :ident => 2
+            print_wrapped "Mail server IP: #{@app.mail_server_ip}", :ident => 2
           rescue Client::APIError => e
-            if e.unauthorized?
+            if e.not_found?
               say_error "You have no access to '#{cloud}' cloud defined in Cloudfile", :with_exit => false
             else
               say_error e.message, :with_exit => false
@@ -190,7 +190,7 @@ module Shelly
         end
         exit 1
       rescue Client::APIError => e
-        if e.unauthorized?
+        if e.not_found?
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
         end
       end
@@ -203,7 +203,7 @@ module Shelly
         @app.stop
         say "Cloud '#{@app.code_name}' stopped"
       rescue Client::APIError => e
-        if e.unauthorized?
+        if e.not_found?
           say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
         end
       end
@@ -230,7 +230,9 @@ module Shelly
           say "Missing git remote"
         end
       rescue Client::APIError => e
-        say_error e.message
+        if e.not_found?
+          say_error "You have no access to '#{@app.code_name}' cloud defined in Cloudfile"
+        end
       end
 
       desc "logs", "Show latest application logs from each instance"
@@ -247,7 +249,7 @@ module Shelly
             say log
           end
         rescue Client::APIError => e
-          if e.unauthorized?
+          if e.not_found?
             say_error "You have no access to cloud '#{cloud || @app.code_name}'"
           end
         end

data/lib/shelly/cli/user.rb

@@ -19,7 +19,7 @@ module Shelly
             say "Cloud #{cloud}:"
             @app.users.each { |user| say "  #{user["email"]}" }
           rescue Client::APIError => e
-            if e.unauthorized?
+            if e.not_found?
               say_error "You have no access to '#{cloud}' cloud defined in Cloudfile", :with_exit => false
             else
               say_error e.message, :with_exit => false
@@ -39,7 +39,7 @@ module Shelly
           rescue Client::APIError => e
             if e.validation? && e.errors.include?(["email", "#{email} has already been taken"])
               say_error "User #{email} is already in the cloud #{cloud}", :with_exit => false
-            elsif e.unauthorized?
+            elsif e.not_found?
               say_error "You have no access to '#{cloud}' cloud defined in Cloudfile", :with_exit => false
             elsif e.validation?
               e.each_error { |error| say_error error, :with_exit => false }
@@ -51,12 +51,7 @@ module Shelly
             say "Sending invitation to #{user_email} to work on #{cloud}", :green
           end
         end
-      rescue Client::APIError => e
-        if e.unauthorized?
-          e.errors.each { |error| say_error error, :with_exit => false}
-          exit 1
-        end
       end
     end
   end
-end
+end

data/lib/shelly/client.rb

@@ -5,42 +5,45 @@ require "cgi"
 module Shelly
   class Client
     class APIError < Exception
-      attr_reader :status_code
+      attr_reader :status_code, :body
       
-      def initialize(response_body, status_code)
-        @response = JSON.parse(response_body)
+      def initialize(status_code, body = {})
         @status_code = status_code
+        @body = body
       end
 
       def message
-        @response["message"]
+        body["message"]
       end
 
       def errors
-        @response["errors"]
+        body["errors"]
       end
 
       def url
-        @response["url"]
+        body["url"]
       end
 
       def validation?
         message == "Validation Failed"
       end
-      
+
       def not_found?
         status_code == 404
       end
 
+      def resource_not_found
+        return unless not_found?
+        message =~ /Couldn't find (.*) with/ && $1.downcase.to_sym
+      end
+
       def unauthorized?
-        # FIXME: Return unauthorized if user has no access to cloud, checked by 401 status code
-        #        Return 404 if child of app doesn't exist, should be fixed in API
-        message == "Unauthorized" || message =~ /Cloud .+ not found/
+        status_code == 401
       end
 
       def each_error
-        @response["errors"].each do |index,message|
-          yield index.gsub('_',' ').capitalize + " " + message
+        errors.each do |field, message|
+          yield [field.gsub('_',' ').capitalize, message].join(" ")
         end
       end
     end
@@ -115,6 +118,10 @@ module Shelly
     def apps
       get("/apps")
     end
+    
+    def app(code_name)
+      get("/apps/#{code_name}")
+    end
 
     def deploy_logs(cloud)
       get("/apps/#{cloud}/deploys")
@@ -148,10 +155,6 @@ module Shelly
       get("/apps/#{cloud}/users")
     end
 
-    def app_ips(cloud)
-      get("/apps/#{cloud}/ips")
-    end
-
     def post(path, params = {})
       request(path, :post, params)
     end
@@ -211,12 +214,11 @@ module Shelly
     end
 
     def process_response(response)
-      if [401, 404, 422, 500].include?(response.code)
-        raise APIError.new(response.body, response.code)
-      end
-
+      body = JSON.parse(response.body) rescue JSON::ParserError && {}
+      code = response.code
+      raise APIError.new(code, body) if (400..599).include?(code)
       response.return!
-      JSON.parse(response.body)
+      body
     end
   end
 end

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.0.40"
+  VERSION = "0.0.41.pre"
 end

data/spec/shelly/app_spec.rb

@@ -24,13 +24,6 @@ describe Shelly::App do
     end
   end
 
-  describe "#ips" do
-    it "should get app's ips" do
-      @client.should_receive(:app_ips).with("foo-staging")
-      @app.ips
-    end
-  end
-
   describe "#add_git_remote" do
     before do
       @app.stub(:git_url).and_return("git@git.shellycloud.com:foo-staging.git")
@@ -50,18 +43,67 @@ describe Shelly::App do
 
   describe "#configs" do
     it "should get configs from client" do
-      @client.should_receive(:app_configs).with("foo-staging")
-      @app.configs
+      @client.should_receive(:app_configs).with("foo-staging").and_return(config_response)
+      @app.configs.should == config_response
     end
 
     it "should return only user config files" do
-      @client.should_receive(:app_configs).with("foo-staging").and_return([])
-      @app.user_configs
+      @client.should_receive(:app_configs).with("foo-staging").and_return(config_response)
+      @app.user_configs.should == [{"path" => "user_created", "created_by_user" => true}]
     end
 
     it "should return only shelly genereted config files" do
-      @client.should_receive(:app_configs).with("foo-staging").and_return([])
-      @app.shelly_generated_configs
+      @client.should_receive(:app_configs).with("foo-staging").and_return(config_response)
+      @app.shelly_generated_configs.should == [{"path" => "shelly_created", "created_by_user" => false}]
+    end
+
+    def config_response
+      [{"path" => "user_created", "created_by_user" => true},
+       {"path" => "shelly_created", "created_by_user" => false}]
+    end
+
+    it "should get config from client" do
+      @client.should_receive(:app_config).with("foo-staging", "path")
+      @app.config("path")
+    end
+
+    it "should create config using client" do
+      @client.should_receive(:app_create_config).with("foo-staging", "path", "content")
+      @app.create_config("path", "content")
+    end
+
+    it "should update config using client" do
+      @client.should_receive(:app_update_config).with("foo-staging", "path", "content")
+      @app.update_config("path", "content")
+    end
+
+    it "should delete config using client" do
+      @client.should_receive(:app_delete_config).with("foo-staging", "path")
+      @app.delete_config("path")
+    end
+  end
+  
+  describe "#attributes" do
+    before do
+      @response = {"web_server_ip" => "192.0.2.1", "mail_server_ip" => "192.0.2.3"}
+      @client.stub(:app).and_return(@response)
+    end
+    
+    it "should fetch app attributes from API and cache them" do
+      @client.should_receive(:app).with("foo-staging").exactly(:once).and_return(@response)
+      2.times { @app.attributes }
+    end
+    
+    describe "#web_server_ip" do
+      it "should return web server ip address" do
+        @app.web_server_ip.should == "192.0.2.1"
+      end
+    end
+    
+    describe "#mail_server_ip" do
+      it "should return mail server ip address" do
+        @app.mail_server_ip.should == "192.0.2.3"
+      end
     end
   end
 
@@ -238,5 +280,11 @@ config
       end
     end
   end
+
+  describe "#to_s" do
+    it "should return code_name" do
+      @app.to_s.should == "foo-staging"
+    end
+  end
 end
 

data/spec/shelly/cli/backup_spec.rb

@@ -30,8 +30,7 @@ describe Shelly::CLI::Backup do
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
-      response = {"message" => "Cloud foo-staging not found"}
-      exception = Shelly::Client::APIError.new(response.to_json, 401)
+      exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Cloud with"})
       @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)
@@ -104,7 +103,7 @@ describe Shelly::CLI::Backup do
 
       context "on backup not found" do
         it "it should display error message" do
-          exception = Shelly::Client::APIError.new({}.to_json, 404)
+          exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Backup with"})
           @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")
@@ -114,7 +113,7 @@ describe Shelly::CLI::Backup do
 
       context "on unsupported exception" do
         it "should re-raise it" do
-          exception = Shelly::Client::APIError.new({}.to_json, 500)
+          exception = Shelly::Client::APIError.new(500)
           @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")
@@ -134,8 +133,7 @@ describe Shelly::CLI::Backup do
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
-      response = {"message" => "Cloud foo-staging not found"}
-      exception = Shelly::Client::APIError.new(response.to_json, 404)
+      exception = Shelly::Client::APIError.new(404, {"message" => "Cloud foo-staging not found"})
       @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)
@@ -143,7 +141,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(response.to_json, 422)
+      exception = Shelly::Client::APIError.new(422, 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)

data/spec/shelly/cli/config_spec.rb

@@ -34,8 +34,8 @@ describe Shelly::CLI::Config do
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
-      response = {"message" => "Cloud foo-staging not found"}
-      exception = Shelly::Client::APIError.new(response.to_json, 404)
+      response = {"message" => "Couldn't find Cloud with code_name = foo-staging"}
+      exception = Shelly::Client::APIError.new(404, response)
       @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)
@@ -76,6 +76,31 @@ describe Shelly::CLI::Config do
       invoke(@config, :show, "path")
     end
 
+    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"})
+          @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`")
+          lambda {
+            invoke(@config, :show, "config/app.yml")
+          }.should raise_error(SystemExit)
+        end
+      end
+
+      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"})
+          @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 {
+            invoke(@config, :show, "config/app.yml")
+          }.should raise_error(SystemExit)
+        end
+      end
+    end
+
     context "multiple clouds" do
       before do
         File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
@@ -167,6 +192,31 @@ describe Shelly::CLI::Config do
       invoke(@config, :edit, "path")
     end
 
+    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"})
+          @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`")
+          lambda {
+            invoke(@config, :edit, "config/app.yml")
+          }.should raise_error(SystemExit)
+        end
+      end
+
+      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"})
+          @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 {
+            invoke(@config, :edit, "config/app.yml")
+          }.should raise_error(SystemExit)
+        end
+      end
+    end
+
     context "multiple clouds" do
       before do
         File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
@@ -235,5 +285,35 @@ describe Shelly::CLI::Config do
         end
       end
     end
+
+    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"})
+          @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`")
+          fake_stdin(["y"]) do
+            lambda {
+              invoke(@config, :delete, "config/app.yml")
+            }.should raise_error(SystemExit)
+          end
+        end
+      end
+
+      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"})
+          @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
+            lambda {
+              invoke(@config, :delete, "config/app.yml")
+            }.should raise_error(SystemExit)
+          end
+        end
+      end
+    end
+
   end
 end

data/spec/shelly/cli/deploys_spec.rb

@@ -29,9 +29,7 @@ describe Shelly::CLI::Deploys do
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
-      response = {"message" => "Cloud foo-staging not found"}
-      exception = Shelly::Client::APIError.new(response.to_json, 404)
-      @client.stub(:deploy_logs).and_raise(exception)
+      @client.stub(:deploy_logs).and_raise(Shelly::Client::APIError.new(404))
       $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
@@ -88,12 +86,22 @@ describe Shelly::CLI::Deploys do
       }.should raise_error(SystemExit)
     end
 
-    it "should exit if user doesn't have access to cloud in Cloudfile" do
-      response = {"message" => "Cloud foo-staging not found"}
-      exception = Shelly::Client::APIError.new(response.to_json, 404)
-      @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 { invoke(@deploys, :show, "last") }.should raise_error(SystemExit)
+    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"})
+        @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)
+      end
+    end
+
+    context "log not found" do
+      it "should exit 1 with message" do
+        exception = Shelly::Client::APIError.new(404, {"message" => "Couldn't find Log with"})
+        @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)
+      end
     end
 
     context "multiple clouds" do

data/spec/shelly/cli/main_spec.rb

@@ -173,7 +173,7 @@ 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(response.to_json, 422)
+        exception = Shelly::Client::APIError.new(422, response)
         @client.stub(:register_user).and_raise(exception)
         $stdout.should_receive(:puts).with("\e[31mEmail has been already taken\e[0m")
         lambda {
@@ -260,7 +260,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(response.to_json, 401)
+        exception = Shelly::Client::APIError.new(401, 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")
@@ -380,7 +380,7 @@ OUT
 
     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(response.to_json, 422)
+      exception = Shelly::Client::APIError.new(422, response)
       @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")
@@ -468,8 +468,7 @@ OUT
 
     context "on failure" do
       it "should display info that user is not logged in" do
-        body = {"message" => "Unauthorized"}
-        error = Shelly::Client::APIError.new(body.to_json, 401)
+        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")
@@ -502,16 +501,15 @@ OUT
     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(response.to_json, 404)
+      response = {"message" => "Couldn't find Cloud with"}
+      exception = Shelly::Client::APIError.new(404, response)
       @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
-      response = {"message" => "Unauthorized"}
-      exception = Shelly::Client::APIError.new(response.to_json, 401)
+      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")
@@ -620,17 +618,13 @@ OUT
     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(response.to_json, 404)
-      @client.stub(:stop_cloud).and_raise(exception)
+      @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)
     end
 
     it "should exit if user is not logged in" do
-      response = {"message" => "Unauthorized"}
-      exception = Shelly::Client::APIError.new(response.to_json, 401)
-      @client.stub(:token).and_raise(exception)
+      @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")
       lambda { invoke(@main, :stop) }.should raise_error(SystemExit)
@@ -673,14 +667,6 @@ OUT
       Shelly::App.stub(:inside_git_repository?).and_return(true)
     end
 
-    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")
-      lambda {
-        invoke(@main, :ip)
-      }.should raise_error(SystemExit)
-    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")
@@ -691,7 +677,7 @@ OUT
 
     context "on success" do
       it "should display mail and web server ip's" do
-        @client.stub(:app_ips).and_return(response)
+        @client.stub(:app).and_return(response)
         $stdout.should_receive(:puts).with("\e[32mCloud foo-production:\e[0m")
         $stdout.should_receive(:puts).with("  Web server IP: 22.22.22.22")
         $stdout.should_receive(:puts).with("  Mail server IP: 11.11.11.11")
@@ -704,16 +690,9 @@ OUT
     end
 
     context "on failure" do
-      it "should raise an error if user is not in 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")
-        lambda { invoke(@main, :ip) }.should raise_error(SystemExit)
-      end
-
       it "should raise an error if user does not have access to cloud" do
-        response = {"message" => "Cloud foo-staging not found"}
-        exception = Shelly::Client::APIError.new(response.to_json, 404)
-        @client.stub(:app_ips).and_raise(exception)
+        exception = Shelly::Client::APIError.new(404, {"message" => "Cloud foo-staging not found"})
+        @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)
       end
@@ -758,7 +737,8 @@ OUT
         @app.should_not_receive(:delete)
         lambda{
           fake_stdin(["yes", "yes", "no"]) do
-            invoke(@main, :delete, "--cloud", "foo-staging")
+            @main.options = {:cloud => "foo-staging"}
+            invoke(@main, :delete)
           end
         }.should raise_error(SystemExit)
       end
@@ -774,7 +754,8 @@ OUT
         Shelly::App.stub(:inside_git_repository?).and_return(false)
         $stdout.should_receive(:puts).with("Missing git remote")
         fake_stdin(["yes", "yes", "yes"]) do
-          invoke(@main, :delete, "--cloud", "foo-staging")
+          @main.options = {:cloud => "foo-staging"}
+          invoke(@main, :delete)
         end
       end
     end
@@ -786,13 +767,13 @@ OUT
       end
 
       it "should raise Client::APIError" do
-        response = {:message => "Application not found"}
-        exception = Shelly::Client::APIError.new(response.to_json, 404)
+        exception = Shelly::Client::APIError.new(404)
         @app.stub(:delete).and_raise(exception)
-        $stdout.should_receive(:puts).with("\e[31mApplication not found\e[0m")
+        $stdout.should_receive(:puts).with(red "You have no access to 'foo-bar' cloud defined in Cloudfile")
         lambda{
           fake_stdin(["yes", "yes", "yes"]) do
-            invoke(@main, :delete, "--cloud", "foo-bar")
+            @main.options = {:cloud => "foo-bar"}
+            invoke(@main, :delete)
           end
         }.should raise_error(SystemExit)
       end
@@ -846,7 +827,7 @@ OUT
 
     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(response.to_json, 404)
+      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'")
@@ -854,8 +835,7 @@ OUT
     end
 
     it "should exit if user is not logged in" do
-      response = {"message" => "Unauthorized"}
-      exception = Shelly::Client::APIError.new(response.to_json, 401)
+      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:")

data/spec/shelly/cli/user_spec.rb

@@ -51,7 +51,7 @@ describe Shelly::CLI::User do
 
     it "should exit if user is not logged in" do
       response = {"message" => "Unauthorized", "url" => "https://admin.winniecloud.com/users/password/new"}
-      exception = Shelly::Client::APIError.new(response.to_json, 404)
+      exception = Shelly::Client::APIError.new(401, response)
       @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")
@@ -81,8 +81,8 @@ describe Shelly::CLI::User do
 
     context "on failure" do
       it "should raise an error if user does not have access to cloud" do
-        response = {"message" => "Cloud foo-staging not found"}
-        exception = Shelly::Client::APIError.new(response.to_json, 404)
+        response = {"message" => "Couldn't find Cloud with code_name = foo-staging"}
+        exception = Shelly::Client::APIError.new(404, response)
         @client.stub(:app_users).and_raise(exception)
         $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
         invoke(@cli_user, :list)
@@ -143,7 +143,7 @@ describe Shelly::CLI::User do
     context "on failure" do
       it "should raise error if user doesnt have access to cloud" do
         response = {"message" => "Cloud foo-staging not found"}
-        exception = Shelly::Client::APIError.new(response.to_json, 404)
+        exception = Shelly::Client::APIError.new(404, response)
         @client.stub(:send_invitation).and_raise(exception)
         $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
         invoke(@cli_user, :add, "megan@example.com")

data/spec/shelly/client_spec.rb

@@ -2,12 +2,13 @@ require "spec_helper"
 
 describe Shelly::Client::APIError do
   before do
-    body = {"message" => "something went wrong", "errors" => [["first", "foo"]], "url" => "https://foo.bar"}
-    @error = Shelly::Client::APIError.new(body.to_json, 404)
+    body = {"message" => "Couldn't find Cloud with code_name = fooo",
+      "errors" => [["first", "foo"]], "url" => "https://foo.bar"}
+    @error = Shelly::Client::APIError.new(404, body)
   end
 
   it "should return error message" do
-    @error.message.should == "something went wrong"
+    @error.message.should == "Couldn't find Cloud with code_name = fooo"
   end
 
   it "should return array of errors" do
@@ -19,16 +20,31 @@ describe Shelly::Client::APIError do
   end
 
   it "should return user friendly string" do
-    @error.each_error{|error| error.should == "First foo"}
+    @error.each_error { |error| error.should == "First foo" }
   end
-  
+
+  describe "#resource_not_found?" do
+    context "on 404 response" do
+      it "should return which resource was not found" do
+        @error.resource_not_found.should == :cloud
+      end
+    end
+
+    context "on non 404 response" do
+      it "should return nil" do
+        error = Shelly::Client::APIError.new(401)
+        error.resource_not_found.should be_nil
+      end
+    end
+  end
+
   describe "#not_found?" do
     it "should return true if response status code is 404" do
       @error.should be_not_found
     end
-    
+
     it "should return false if response status code is not 404" do
-      error = Shelly::Client::APIError.new({}.to_json, 500)
+      error = Shelly::Client::APIError.new(500)
       error.should_not be_not_found
     end
   end
@@ -37,7 +53,7 @@ describe Shelly::Client::APIError do
     context "when error is caused by validation errors" do
       it "should return true" do
         body = {"message" => "Validation Failed"}
-        error = Shelly::Client::APIError.new(body.to_json, 422)
+        error = Shelly::Client::APIError.new(422, body)
         error.should be_validation
       end
     end
@@ -52,8 +68,7 @@ describe Shelly::Client::APIError do
   describe "#unauthorized?" do
     context "when error is caused by unauthorized error" do
       it "should return true" do
-        body = {"message" => "Unauthorized"}
-        error = Shelly::Client::APIError.new(body.to_json, 401)
+        error = Shelly::Client::APIError.new(401)
         error.should be_unauthorized
       end
     end
@@ -71,7 +86,7 @@ describe Shelly::Client do
     ENV['SHELLY_URL'] = nil
     @client = Shelly::Client.new("bob@example.com", "secret")
   end
-  
+
   def api_url(resource = "")
     auth = "#{CGI.escape(@client.email)}:#{@client.password}@"
     "https://#{auth}admin.winniecloud.com/apiv2/#{resource}"
@@ -142,6 +157,38 @@ describe Shelly::Client do
     end
   end
 
+  describe "#app_config" do
+    it "should send get request" do
+      FakeWeb.register_uri(:get, api_url("apps/staging-foo/configs/path"), :body => [{:content => "content", :path => "path"}].to_json)
+      response = @client.app_config("staging-foo", "path")
+      response.should == [{"content" => "content", "path" => "path"}]
+    end
+  end
+
+  describe "#app_create_config" do
+    it "should send post request" do
+      FakeWeb.register_uri(:post, api_url("apps/staging-foo/configs"), :body => {}.to_json, :status => 201)
+      response = @client.app_create_config("staging-foo", "path", "content")
+      response.should == {}
+    end
+  end
+
+  describe "#app_update_config" do
+    it "should send put request" do
+      FakeWeb.register_uri(:put, api_url("apps/staging-foo/configs/path"), :body => {}.to_json)
+      response = @client.app_update_config("staging-foo", "path", "content")
+      response.should == {}
+    end
+  end
+
+  describe "#app_delete_config" do
+    it "should send delete request" do
+      FakeWeb.register_uri(:delete, api_url("apps/staging-foo/configs/path"), :body => {}.to_json)
+      response = @client.app_delete_config("staging-foo", "path")
+      response.should == {}
+    end
+  end
+
   describe "#application_logs" do
     it "should send get request" do
       time = Time.now
@@ -167,12 +214,13 @@ describe Shelly::Client do
       response.should == [{"email" => "test@example.com"}, {"email" => "test2@example.com"}]
     end
   end
-
-  describe "#app_ips" do
-    it "should send get request with app code_name" do
-      FakeWeb.register_uri(:get, api_url("apps/staging-foo/ips"), :body => {:mail_server_ip => "10.0.1.1", :web_server_ip => "88.198.21.187"}.to_json)
-      response = @client.app_ips("staging-foo")
-      response.should == {"mail_server_ip" => "10.0.1.1", "web_server_ip" => "88.198.21.187"}
+  
+  describe "#app" do
+    it "should fetch app from API" do
+      FakeWeb.register_uri(:get, api_url("apps/staging-foo"), 
+        :body => {:web_server_ip => "192.0.2.1", :mail_server_ip => "192.0.2.3"}.to_json)
+      response = @client.app("staging-foo")
+      response.should == {"web_server_ip" => "192.0.2.1", "mail_server_ip" => "192.0.2.3"}
     end
   end
 
@@ -221,7 +269,7 @@ describe Shelly::Client do
       @client.ssh_key_available?("ssh-key Abb")
     end
   end
-  
+
   describe "#database_backup" do
     it "should fetch backup description from API" do
       expected = {
@@ -232,11 +280,11 @@ describe Shelly::Client do
       filename = "2011.11.26.04.00.10.foo.postgres.tar.gz"
       url = api_url("apps/foo/database_backups/#{filename}")
       FakeWeb.register_uri(:get, url, :body => expected.to_json)
-      
+
       @client.database_backup("foo", filename).should == expected
     end
   end
-  
+
   describe "#download_backup" do
     before do
       @filename = "2011.11.26.04.00.10.foo.postgres.tar.gz"
@@ -246,18 +294,18 @@ describe Shelly::Client do
       response.stub(:read_body).and_yield("aaa").and_yield("bbbbb").and_yield("dddf")
       FakeWeb.register_uri(:get, url, :response => response)
     end
-    
+
     it "should write streamed database backup to file" do
       @client.download_backup("foo", @filename)
       File.read(@filename).should == %w(aaa bbbbb dddf).join
     end
-    
+
     it "should execute progress_callback with size of every chunk" do
       progress = mock(:update => true)
       progress.should_receive(:update).with(3)
       progress.should_receive(:update).with(5)
       progress.should_receive(:update).with(4)
-      
+
       callback = lambda { |size| progress.update(size) }
 
       @client.download_backup("foo", @filename, callback)
@@ -331,6 +379,13 @@ describe Shelly::Client do
         end
       end
     end
+    
+    it "should return empty hash if response is not a valid JSON" do
+      JSON.should_receive(:parse).with("").and_raise(JSON::ParserError)
+      @response.stub(:code).and_return("204")
+      @response.stub(:body).and_return("")
+      @client.post("/api/apps/flower").should == {}
+    end
   end
 
   describe "#headers" do

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: shelly
 version: !ruby/object:Gem::Version
-  version: 0.0.40
-  prerelease: 
+  version: 0.0.41.pre
+  prerelease: 7
 platform: ruby
 authors:
 - Shelly Cloud team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-30 00:00:00.000000000 Z
+date: 2012-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70136906680620 !ruby/object:Gem::Requirement
+  requirement: &70129852876100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70136906680620
+  version_requirements: *70129852876100
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70136906696580 !ruby/object:Gem::Requirement
+  requirement: &70129852875680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70136906696580
+  version_requirements: *70129852875680
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &70136906696160 !ruby/object:Gem::Requirement
+  requirement: &70129852875260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70136906696160
+  version_requirements: *70129852875260
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70136906695740 !ruby/object:Gem::Requirement
+  requirement: &70129852874840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70136906695740
+  version_requirements: *70129852874840
 - !ruby/object:Gem::Dependency
   name: growl_notify
-  requirement: &70136906695280 !ruby/object:Gem::Requirement
+  requirement: &70129852890740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70136906695280
+  version_requirements: *70129852890740
 - !ruby/object:Gem::Dependency
   name: rb-fsevent
-  requirement: &70136906694860 !ruby/object:Gem::Requirement
+  requirement: &70129852890320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70136906694860
+  version_requirements: *70129852890320
 - !ruby/object:Gem::Dependency
   name: fakefs
-  requirement: &70136906694440 !ruby/object:Gem::Requirement
+  requirement: &70129852889900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70136906694440
+  version_requirements: *70129852889900
 - !ruby/object:Gem::Dependency
   name: fakeweb
-  requirement: &70136906694020 !ruby/object:Gem::Requirement
+  requirement: &70129852889480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70136906694020
+  version_requirements: *70129852889480
 - !ruby/object:Gem::Dependency
   name: wijet-thor
-  requirement: &70136906693520 !ruby/object:Gem::Requirement
+  requirement: &70129852888980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -109,10 +109,10 @@ dependencies:
         version: 0.14.7
   type: :runtime
   prerelease: false
-  version_requirements: *70136906693520
+  version_requirements: *70129852888980
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &70136906693100 !ruby/object:Gem::Requirement
+  requirement: &70129852888560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,10 +120,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70136906693100
+  version_requirements: *70129852888560
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &70136906692640 !ruby/object:Gem::Requirement
+  requirement: &70129852888100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -131,10 +131,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70136906692640
+  version_requirements: *70129852888100
 - !ruby/object:Gem::Dependency
   name: wijet-launchy
-  requirement: &70136906692220 !ruby/object:Gem::Requirement
+  requirement: &70129852887680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -142,10 +142,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70136906692220
+  version_requirements: *70129852887680
 - !ruby/object:Gem::Dependency
   name: progressbar
-  requirement: &70136906691800 !ruby/object:Gem::Requirement
+  requirement: &70129852887260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -153,7 +153,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70136906691800
+  version_requirements: *70129852887260
 description: Tool for managing applications and clouds at shellycloud.com
 email:
 - support@shellycloud.com
@@ -223,21 +223,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2595737964624093032
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 2595737964624093032
+      version: 1.3.1
 requirements: []
 rubyforge_project: shelly
-rubygems_version: 1.8.11
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Shelly Cloud command line tool