shelly 0.0.33 → 0.0.34

data/lib/shelly/app.rb

@@ -8,6 +8,8 @@ module Shelly
     attr_accessor :code_name, :databases, :ruby_version, :environment,
       :git_url, :domains
 
+    autoload :Backup, "shelly/backup"
+
     def initialize(code_name = nil)
       self.code_name = code_name
     end
@@ -59,15 +61,22 @@ module Shelly
     end
 
     def application_logs
-      shelly.application_logs(self.code_name)
+      shelly.application_logs(code_name)
     end
 
     def database_backups
-      shelly.database_backups(code_name)
+      shelly.database_backups(code_name).map do |attributes|
+        Shelly::Backup.new(attributes.merge("code_name" => code_name))
+      end
+    end
+
+    def database_backup(handler)
+      attributes = shelly.database_backup(code_name, handler)
+      Shelly::Backup.new(attributes.merge("code_name" => code_name))
     end
 
     def logs
-      shelly.cloud_logs(self.code_name)
+      shelly.cloud_logs(code_name)
     end
 
     def start
@@ -132,4 +141,3 @@ module Shelly
     end
   end
 end
-

data/lib/shelly/backup.rb

@@ -0,0 +1,16 @@
+module Shelly
+  class Backup < Model
+    attr_reader :filename, :size, :human_size, :code_name
+
+    def initialize(attributes = {})
+      @filename   = attributes["filename"]
+      @size       = attributes["size"]
+      @human_size = attributes["human_size"]
+      @code_name  = attributes["code_name"]
+    end
+
+    def download(callback)
+      shelly.download_backup(code_name, filename, callback)
+    end
+  end
+end

data/lib/shelly/cli/backup.rb

@@ -1,4 +1,6 @@
 require "shelly/cli/command"
+require "shelly/backup"
+require "shelly/download_progress_bar"
 
 module Shelly
   module CLI
@@ -15,13 +17,15 @@ module Shelly
         say_error "No Cloudfile found" unless Cloudfile.present?
         multiple_clouds(options[:cloud], "backup list", "Select cloud to view database backups for using:")
         backups = @app.database_backups
-        unless backups.empty?
-          backups.unshift({"filename" => "Filename", "size" => "Size"})
+        if backups.present?
+          to_display = [["Filename", "|  Size"]]
+          backups.each do |backup|
+            to_display << [backup.filename, "|  #{backup.human_size}"]
+          end
+
           say "Available backups:", :green
           say_new_line
-          print_table(backups.map do |backup|
-            [backup['filename'], "|  #{backup['size']}"]
-          end, :ident => 2)
+          print_table(to_display, :ident => 2)
         else
           say "No database backups available"
         end
@@ -32,6 +36,26 @@ module Shelly
           say_error e.message
         end
       end
+
+      method_option :cloud, :type => :string, :aliases => "-c", :desc => "Specify which cloud list backups for"
+      desc "get [FILENAME]", "Downloads specified or last backup to current directory"
+      def get(handler = "last")
+        multiple_clouds(options[:cloud], "backup get [FILENAME]", "Select cloud for which you want download backup")
+
+        backup = @app.database_backup(handler)
+        bar = Shelly::DownloadProgressBar.new(backup.size)
+        backup.download(bar.progress_callback)
+
+        say_new_line
+        say "Backup file saved to #{backup.filename}", :green
+      rescue Client::APIError => e
+        if e.not_found?
+          say_error "Backup not found", :with_exit => false
+          say "You can list available backups with 'shelly backup list' command"
+        else
+          raise e
+        end
+      end
     end
   end
 end

data/lib/shelly/client.rb

@@ -4,8 +4,11 @@ require "json"
 module Shelly
   class Client
     class APIError < Exception
-      def initialize(response_body)
+      attr_reader :status_code
+      
+      def initialize(response_body, status_code)
         @response = JSON.parse(response_body)
+        @status_code = status_code
       end
 
       def message
@@ -23,10 +26,14 @@ module Shelly
       def validation?
         message == "Validation Failed"
       end
+      
+      def not_found?
+        status_code == 404
+      end
 
       def unauthorized?
-        # FIXME: Return unauthorized if user has no access to cloud
-        #        Return 404 if cloud doesn't exist, should be fixed in API
+        # 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/
       end
 
@@ -37,6 +44,8 @@ module Shelly
       end
     end
 
+    attr_reader :email, :password
+
     def initialize(email = nil, password = nil)
       @email = email
       @password = password
@@ -121,6 +130,10 @@ module Shelly
     def database_backups(code_name)
       get("/apps/#{code_name}/database_backups")
     end
+    
+    def database_backup(code_name, handler)
+      get("/apps/#{code_name}/database_backups/#{handler}")
+    end
 
     def ssh_key_available?(ssh_key)
     	get("/users/new", :ssh_key => ssh_key)
@@ -149,6 +162,23 @@ module Shelly
     def delete(path, params = {})
       request(path, :delete, params)
     end
+    
+    def download_backup(cloud, filename, progress_callback = nil)
+      File.open(filename, "w") do |out|
+        process_response = lambda do |response|
+          response.read_body do |chunk|
+            out.write(chunk)
+            progress_callback.call(chunk.size) if progress_callback
+          end
+        end
+
+        options = request_parameters("/apps/#{cloud}/database_backups/#{filename}", :get)
+        options = options.merge(:block_response => process_response, 
+          :headers => {:accept => "application/x-gzip"})
+      
+        RestClient::Request.execute(options)
+      end
+    end
 
     def request(path, method, params = {})
       options = request_parameters(path, method, params)
@@ -177,7 +207,7 @@ module Shelly
 
     def process_response(response)
       if [401, 404, 422, 500].include?(response.code)
-        raise APIError.new(response.body)
+        raise APIError.new(response.body, response.code)
       end
 
       response.return!

data/lib/shelly/download_progress_bar.rb

@@ -0,0 +1,14 @@
+require "progressbar"
+
+module Shelly
+  class DownloadProgressBar < ProgressBar
+    def initialize(total)
+      super("Progress", total)
+      self.format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+    end
+  
+    def progress_callback
+      lambda { |size| inc(size) }
+    end
+  end
+end

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.0.33"
+  VERSION = "0.0.34"
 end

data/shelly.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "rest-client"
   s.add_runtime_dependency "json"
   s.add_runtime_dependency "wijet-launchy"
+  s.add_runtime_dependency "progressbar"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/shelly/app_spec.rb

@@ -167,6 +167,30 @@ config
     end
   end
 
+  describe "#database_backup" do
+    before do
+      @description = {
+        "filename" => "backup.tar.gz",
+        "size" => 1234,
+        "human_size" => "2KB"
+      }
+      @client.stub(:database_backup).and_return(@description)
+    end
+
+    it "should fetch backup from API" do
+      @client.should_receive(:database_backup).with("foo-staging", "backup.tar.gz")
+      @app.database_backup("backup.tar.gz")
+    end
+
+    it "should initialize backup object" do
+      backup = @app.database_backup("backup.tar.gz")
+      backup.code_name.should == "foo-staging"
+      backup.size.should == 1234
+      backup.human_size.should == "2KB"
+      backup.filename.should == "backup.tar.gz"
+    end
+  end
+
   describe "#create" do
     context "without providing domain" do
       it "should create the app on shelly cloud via API client" do

data/spec/shelly/backup_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "shelly/backup"
+
+describe Shelly::Backup do
+  before do
+    @client = mock
+    Shelly::Client.stub(:new).and_return(@client)
+  end
+
+  it "should assign attributes" do
+    backup = Shelly::Backup.new(attributes)
+
+    backup.code_name.should == "foo"
+    backup.filename.should == "backup.tar.gz"
+    backup.human_size.should == "2KB"
+    backup.size.should == 2048
+  end
+
+  describe "#download" do
+    it "should download given backup via API file with filename to which backup will be downloaded" do
+      callback = lambda {}
+      @client.should_receive(:download_backup).with("foo", "backup.tar.gz", callback)
+      backup = Shelly::Backup.new(attributes)
+      backup.download(callback)
+    end
+  end
+
+  def attributes
+    {"code_name" => "foo",
+    "filename"   => "backup.tar.gz",
+    "human_size" => "2KB",
+    "size"       => 2048}
+  end
+end

data/spec/shelly/cli/backup_spec.rb

@@ -1,21 +1,19 @@
 require "spec_helper"
 require "shelly/cli/backup"
+require "shelly/download_progress_bar"
 
 describe Shelly::CLI::Backup do
   before do
     @backup = Shelly::CLI::Backup.new
     @client = mock
+    @client.stub(:token).and_return("abc")
     Shelly::Client.stub(:new).and_return(@client)
+    FileUtils.mkdir_p("/projects/foo")
+    Dir.chdir("/projects/foo")
+    File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
   end
 
   describe "#list" do
-    before do
-      FileUtils.mkdir_p("/projects/foo")
-      Dir.chdir("/projects/foo")
-      File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
-      @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")
@@ -26,7 +24,7 @@ describe Shelly::CLI::Backup do
 
     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)
+      exception = Shelly::Client::APIError.new(response.to_json, 401)
       @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 { @backup.list }.should raise_error(SystemExit)
@@ -47,7 +45,7 @@ describe Shelly::CLI::Backup do
       end
 
       it "should take cloud from command line for which to show backups" do
-        @client.should_receive(:database_backups).with("foo-staging").and_return([{"filename" => "backup.postgre.tar.gz", "size" => "10kb"},{"filename" => "backup.mongo.tar.gz", "size" => "22kb"}])
+        @client.should_receive(:database_backups).with("foo-staging").and_return([{"filename" => "backup.postgre.tar.gz", "human_size" => "10kb", "size" => 12345},{"filename" => "backup.mongo.tar.gz", "human_size" => "22kb", "size" => 333}])
         $stdout.should_receive(:puts).with(green "Available backups:")
         $stdout.should_receive(:puts).with("\n")
         $stdout.should_receive(:puts).with("  Filename               |  Size")
@@ -57,5 +55,65 @@ describe Shelly::CLI::Backup do
         @backup.list
       end
     end
+    
+    describe "#get" do
+      before do
+        @client.stub(:download_backup)
+        @bar = mock(:progress_callback => @callback)
+        Shelly::DownloadProgressBar.stub(:new).and_return(@bar)
+        @client.stub(:database_backup).and_return({"filename" => "better.tar.gz", "size" => 12345})
+        $stdout.stub(:puts)
+      end
+      
+      it "should make sure that cloud is choosen" do
+        @client.should_receive(:database_backup).with("foo-staging", "last")
+        @backup.get
+              
+        @backup.options = {:cloud => "other"}
+        @client.should_receive(:database_backup).with("other", "last")
+        @backup.get
+      end
+      
+      it "should fetch backup size and initialize download progress bar" do
+        @client.stub(:database_backup).and_return({"filename" => "backup.postgres.tar.gz", "size" => 333})
+        Shelly::DownloadProgressBar.should_receive(:new).with(333).and_return(@bar)
+        
+        @backup.get
+      end
+      
+      it "should fetch given backup file itself" do
+        @client.should_receive(:download_backup).with("foo-staging", "better.tar.gz", @bar.progress_callback)
+        @backup.get("better.tar.gz")
+      end
+      
+      it "should show info where file has been saved" do
+        $stdout.should_receive(:puts)
+        $stdout.should_receive(:puts).with(green "Backup file saved to better.tar.gz")
+        @client.should_receive(:download_backup).with("foo-staging", "better.tar.gz", @bar.progress_callback)
+        @backup.get("last")
+      end
+      
+      context "on backup not found" do
+        it "it should display error message" do
+          exception = Shelly::Client::APIError.new({}.to_json, 404)
+          @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.get("better.tar.gz")
+        end
+      end
+      
+      context "on unsupported exception" do
+        it "should re-raise it" do
+          exception = Shelly::Client::APIError.new({}.to_json, 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")
+          lambda { 
+            @backup.get("better.tar.gz") 
+          }.should raise_error(Shelly::Client::APIError)
+        end
+      end
+    end
   end
 end

data/spec/shelly/cli/config_spec.rb

@@ -34,7 +34,7 @@ describe Shelly::CLI::Config do
 
     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)
+      exception = Shelly::Client::APIError.new(response.to_json, 404)
       @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 { @config.list }.should raise_error(SystemExit)

data/spec/shelly/cli/deploys_spec.rb

@@ -29,7 +29,7 @@ describe Shelly::CLI::Deploys do
 
     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)
+      exception = Shelly::Client::APIError.new(response.to_json, 404)
       @client.stub(:deploy_logs).and_raise(exception)
       $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
       lambda { @deploys.list }.should raise_error(SystemExit)
@@ -87,7 +87,7 @@ describe Shelly::CLI::Deploys do
 
     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)
+      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 { @deploys.show("last") }.should raise_error(SystemExit)

data/spec/shelly/cli/main_spec.rb

@@ -172,7 +172,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)
+        exception = Shelly::Client::APIError.new(response.to_json, 422)
         @client.stub(:register_user).and_raise(exception)
         $stdout.should_receive(:puts).with("\e[31mEmail has been already taken\e[0m")
         lambda {
@@ -259,7 +259,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)
+        exception = Shelly::Client::APIError.new(response.to_json, 401)
         @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")
@@ -386,7 +386,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)
+      exception = Shelly::Client::APIError.new(response.to_json, 422)
       @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")
@@ -475,7 +475,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)
+        error = Shelly::Client::APIError.new(body.to_json, 401)
         @client.stub(:token).and_raise(error)
         $stdout.should_receive(:puts).with("\e[31mYou are not logged in, use `shelly login`\e[0m")
         lambda {
@@ -508,7 +508,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)
+      exception = Shelly::Client::APIError.new(response.to_json, 404)
       @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 { @main.start }.should raise_error(SystemExit)
@@ -516,7 +516,7 @@ OUT
 
     it "should exit if user is not logged in" do
       response = {"message" => "Unauthorized"}
-      exception = Shelly::Client::APIError.new(response.to_json)
+      exception = Shelly::Client::APIError.new(response.to_json, 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")
@@ -626,7 +626,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)
+      exception = Shelly::Client::APIError.new(response.to_json, 404)
       @client.stub(:stop_cloud).and_raise(exception)
       $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
       lambda { @main.stop }.should raise_error(SystemExit)
@@ -634,7 +634,7 @@ OUT
 
     it "should exit if user is not logged in" do
       response = {"message" => "Unauthorized"}
-      exception = Shelly::Client::APIError.new(response.to_json)
+      exception = Shelly::Client::APIError.new(response.to_json, 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")
@@ -717,7 +717,7 @@ OUT
 
       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)
+        exception = Shelly::Client::APIError.new(response.to_json, 404)
         @client.stub(:app_ips).and_raise(exception)
         $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
         @main.ip
@@ -794,7 +794,7 @@ OUT
 
       it "should raise Client::APIError" do
         response = {:message => "Application not found"}
-        exception = Shelly::Client::APIError.new(response.to_json)
+        exception = Shelly::Client::APIError.new(response.to_json, 404)
         @app.stub(:delete).and_raise(exception)
         $stdout.should_receive(:puts).with("\e[31mApplication not found\e[0m")
         lambda{
@@ -854,7 +854,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)
+      exception = Shelly::Client::APIError.new(response.to_json, 404)
       @client.stub(:application_logs).and_raise(exception)
       $stdout.should_receive(:puts).
         with(red "You have no access to cloud 'foo-production'")
@@ -863,7 +863,7 @@ OUT
 
     it "should exit if user is not logged in" do
       response = {"message" => "Unauthorized"}
-      exception = Shelly::Client::APIError.new(response.to_json)
+      exception = Shelly::Client::APIError.new(response.to_json, 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

@@ -69,7 +69,7 @@ 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)
+        exception = Shelly::Client::APIError.new(response.to_json, 404)
         @client.stub(:app_users).and_raise(exception)
         $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
         @cli_user.list
@@ -130,7 +130,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)
+        exception = Shelly::Client::APIError.new(response.to_json, 404)
         @client.stub(:send_invitation).and_raise(exception)
         $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
         @cli_user.add("megan@example.com")

data/spec/shelly/client_spec.rb

@@ -3,7 +3,7 @@ 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)
+    @error = Shelly::Client::APIError.new(body.to_json, 404)
   end
 
   it "should return error message" do
@@ -21,12 +21,23 @@ describe Shelly::Client::APIError do
   it "should return user friendly string" do
     @error.each_error{|error| error.should == "First foo"}
   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.should_not be_not_found
+    end
+  end
 
   describe "#validation?" 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)
+        error = Shelly::Client::APIError.new(body.to_json, 422)
         error.should be_validation
       end
     end
@@ -42,7 +53,7 @@ describe Shelly::Client::APIError 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)
+        error = Shelly::Client::APIError.new(body.to_json, 401)
         error.should be_unauthorized
       end
     end
@@ -59,7 +70,11 @@ describe Shelly::Client do
   before do
     ENV['SHELLY_URL'] = nil
     @client = Shelly::Client.new("bob@example.com", "secret")
-    @url = "https://#{CGI.escape("bob@example.com")}:secret@admin.winniecloud.com/apiv2"
+  end
+  
+  def api_url(resource = "")
+    auth = "#{CGI.escape(@client.email)}:#{@client.password}@"
+    "https://#{auth}admin.winniecloud.com/apiv2/#{resource}"
   end
 
   describe "#api_url" do
@@ -103,7 +118,7 @@ describe Shelly::Client do
   describe "#deploy_logs" do
     it "should send get request" do
       time = Time.now
-      FakeWeb.register_uri(:get, @url + "/apps/staging-foo/deploys", :body => [{:failed => false, :created_at => time},
+      FakeWeb.register_uri(:get, api_url("apps/staging-foo/deploys"), :body => [{:failed => false, :created_at => time},
         {:failed => true, :created_at => time+1}].to_json)
       response = @client.deploy_logs("staging-foo")
       response.should == [{"failed"=>false, "created_at"=>time.to_s},
@@ -113,7 +128,7 @@ describe Shelly::Client do
 
   describe "#deploy_log" do
     it "should send get request with cloud and log" do
-      FakeWeb.register_uri(:get, @url + "/apps/staging-foo/deploys/2011-11-29-11-50-16", :body => {:content => "Log"}.to_json)
+      FakeWeb.register_uri(:get, api_url("apps/staging-foo/deploys/2011-11-29-11-50-16"), :body => {:content => "Log"}.to_json)
       response = @client.deploy_log("staging-foo", "2011-11-29-11-50-16")
       response.should == {"content" => "Log"}
     end
@@ -121,7 +136,7 @@ describe Shelly::Client do
 
   describe "#app_configs" do
     it "should send get request" do
-      FakeWeb.register_uri(:get, @url + "/apps/staging-foo/configs", :body => [{:created_by_user => true, :path => "config/app.yml"}].to_json)
+      FakeWeb.register_uri(:get, api_url("apps/staging-foo/configs"), :body => [{:created_by_user => true, :path => "config/app.yml"}].to_json)
       response = @client.app_configs("staging-foo")
       response.should == [{"created_by_user" => true, "path" => "config/app.yml"}]
     end
@@ -130,7 +145,7 @@ describe Shelly::Client do
   describe "#application_logs" do
     it "should send get request" do
       time = Time.now
-      FakeWeb.register_uri(:get, @url + "/apps/staging-foo/logs",
+      FakeWeb.register_uri(:get, api_url("apps/staging-foo/logs"),
         :body => {:logs => ["application_log_1", "application_log_2"]}.to_json)
       response = @client.application_logs("staging-foo")
       response.should == {"logs" => ["application_log_1", "application_log_2"]}
@@ -146,7 +161,7 @@ describe Shelly::Client do
 
   describe "#app_users" do
     it "should send get request with app code_names" do
-      FakeWeb.register_uri(:get, @url + "/apps/staging-foo/users", :body => [{:email => "test@example.com"},
+      FakeWeb.register_uri(:get, api_url("apps/staging-foo/users"), :body => [{:email => "test@example.com"},
         {:email => "test2@example.com"}].to_json)
       response = @client.app_users("staging-foo")
       response.should == [{"email" => "test@example.com"}, {"email" => "test2@example.com"}]
@@ -155,7 +170,7 @@ describe Shelly::Client do
 
   describe "#app_ips" do
     it "should send get request with app code_name" do
-      FakeWeb.register_uri(:get, @url + "/apps/staging-foo/ips", :body => {:mail_server_ip => "10.0.1.1", :web_server_ip => "88.198.21.187"}.to_json)
+      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"}
     end
@@ -163,8 +178,8 @@ describe Shelly::Client do
 
   describe "#send_invitation" do
     it "should send post with developer's email" do
-      FakeWeb.register_uri(:post, @url + "/apps/staging-foo/collaborations", :body => {}.to_json)
-      FakeWeb.register_uri(:post, @url + "/apps/production-foo/collaborations", :body => {}.to_json)
+      FakeWeb.register_uri(:post, api_url("apps/staging-foo/collaborations"), :body => {}.to_json)
+      FakeWeb.register_uri(:post, api_url("apps/production-foo/collaborations"), :body => {}.to_json)
       response = @client.send_invitation("staging-foo", "megan@example.com")
       response.should == {}
     end
@@ -186,7 +201,7 @@ describe Shelly::Client do
 
   describe "#start_cloud" do
     it "should sent post request with cloud's code_name" do
-      FakeWeb.register_uri(:put, @url + "/apps/staging-foo/start", :body => {}.to_json)
+      FakeWeb.register_uri(:put, api_url("apps/staging-foo/start"), :body => {}.to_json)
       response = @client.start_cloud("staging-foo")
       response.should == {}
     end
@@ -194,7 +209,7 @@ describe Shelly::Client do
 
   describe "#stop_cloud" do
     it "should sent delete request with cloud's code_name" do
-      FakeWeb.register_uri(:put, @url + "/apps/staging-foo/stop", :body => {}.to_json)
+      FakeWeb.register_uri(:put, api_url("apps/staging-foo/stop"), :body => {}.to_json)
       response = @client.stop_cloud("staging-foo")
       response.should == {}
     end
@@ -206,6 +221,48 @@ 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 = {
+        "filename" => @filename,
+        "size" => 1234,
+        "human_size" => "2KB"
+      }
+      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"
+      url = api_url("apps/foo/database_backups/#{@filename}")
+      response = Net::HTTPResponse.new('', '', '')
+      # Streaming
+      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)
+    end
+  end
 
   describe "#request_parameters" do
     it "should return hash of resquest parameters" do

data/spec/shelly/download_progress_bar_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "shelly/download_progress_bar"
+
+describe Shelly::DownloadProgressBar do
+  before do
+    $stderr.stub(:print)
+    @bar = Shelly::DownloadProgressBar.new(4444)
+  end
+  
+  it "should inherith from ProgressBar" do
+    @bar.should be_kind_of(ProgressBar)
+  end
+  
+  it "should initialize parent with header and given size" do
+    @bar.title.should == "Progress"
+    @bar.total.should == 4444
+  end
+  
+  describe "#progress_callback" do
+    it "should return callback for updating progress bar" do
+      @bar.should_receive(:inc).with(10)
+      @bar.should_receive(:inc).with(20)
+      
+      @bar.progress_callback.call(10)
+      @bar.progress_callback.call(20)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shelly
 version: !ruby/object:Gem::Version 
-  hash: 93
+  hash: 91
   prerelease: 
   segments: 
   - 0
   - 0
-  - 33
-  version: 0.0.33
+  - 34
+  version: 0.0.34
 platform: ruby
 authors: 
 - Shelly Cloud team
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-26 00:00:00 Z
+date: 2011-12-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -187,6 +187,20 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id012
+- !ruby/object:Gem::Dependency 
+  name: progressbar
+  prerelease: false
+  requirement: &id013 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id013
 description: Tool for managing applications and clouds at shellycloud.com
 email: 
 - support@shellycloud.com
@@ -208,6 +222,7 @@ files:
 - lib/core_ext/object.rb
 - lib/shelly.rb
 - lib/shelly/app.rb
+- lib/shelly/backup.rb
 - lib/shelly/cli/backup.rb
 - lib/shelly/cli/command.rb
 - lib/shelly/cli/config.rb
@@ -217,6 +232,7 @@ files:
 - lib/shelly/cli/user.rb
 - lib/shelly/client.rb
 - lib/shelly/cloudfile.rb
+- lib/shelly/download_progress_bar.rb
 - lib/shelly/helpers.rb
 - lib/shelly/model.rb
 - lib/shelly/templates/Cloudfile.erb
@@ -229,6 +245,7 @@ files:
 - spec/helpers.rb
 - spec/input_faker.rb
 - spec/shelly/app_spec.rb
+- spec/shelly/backup_spec.rb
 - spec/shelly/cli/backup_spec.rb
 - spec/shelly/cli/config_spec.rb
 - spec/shelly/cli/deploys_spec.rb
@@ -237,6 +254,7 @@ files:
 - spec/shelly/cli/user_spec.rb
 - spec/shelly/client_spec.rb
 - spec/shelly/cloudfile_spec.rb
+- spec/shelly/download_progress_bar_spec.rb
 - spec/shelly/model_spec.rb
 - spec/shelly/user_spec.rb
 - spec/spec_helper.rb
@@ -278,6 +296,7 @@ test_files:
 - spec/helpers.rb
 - spec/input_faker.rb
 - spec/shelly/app_spec.rb
+- spec/shelly/backup_spec.rb
 - spec/shelly/cli/backup_spec.rb
 - spec/shelly/cli/config_spec.rb
 - spec/shelly/cli/deploys_spec.rb
@@ -286,6 +305,7 @@ test_files:
 - spec/shelly/cli/user_spec.rb
 - spec/shelly/client_spec.rb
 - spec/shelly/cloudfile_spec.rb
+- spec/shelly/download_progress_bar_spec.rb
 - spec/shelly/model_spec.rb
 - spec/shelly/user_spec.rb
 - spec/spec_helper.rb