shelly 0.0.28 → 0.0.29

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.0.28"
+  VERSION = "0.0.29"
 end

data/lib/thor/basic.rb

@@ -0,0 +1,9 @@
+class Thor
+  module Shell
+
+    def print_wrapped(*args)
+      shell.print_wrapped(*args)
+    end
+
+  end
+end

data/lib/thor/options.rb

@@ -9,4 +9,3 @@ class Thor
 
   end
 end
-

data/spec/helpers.rb

@@ -3,5 +3,13 @@ module RSpec
     def fake_stdin(strings)
       InputFaker.with_fake_input(strings) { yield }
     end
+
+    def green(string)
+      "\e[32m#{string}\e[0m"
+    end
+
+    def red(string)
+      "\e[31m#{string}\e[0m"
+    end
   end
 end

data/spec/shelly/app_spec.rb

@@ -18,9 +18,16 @@ describe Shelly::App do
   end
 
   describe "#users" do
-    it "should " do
-      @client.should_receive(:app_users).with(["staging-foo", "production-foo"])
-      @app.users(["staging-foo", "production-foo"])
+    it "should fetch app's users" do
+      @client.should_receive(:app_users).with("foo-staging")
+      @app.users
+    end
+  end
+
+  describe "#ips" do
+    it "should get app's ips" do
+      @client.should_receive(:app_ips).with("foo-staging")
+      @app.ips
     end
   end
 
@@ -110,6 +117,25 @@ config
     end
   end
 
+  describe "#start & #stop" do
+    it "should start cloud" do
+      @client.should_receive(:start_cloud).with("foo-staging")
+      @app.start
+    end
+
+    it "should stop cloud" do
+      @client.should_receive(:stop_cloud).with("foo-staging")
+      @app.stop
+    end
+  end
+
+  describe "#logs" do
+    it "should list logs" do
+      @client.should_receive(:cloud_logs).with("foo-staging")
+      @app.logs
+    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/cli/deploys_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+require "shelly/cli/deploys"
+
+describe Shelly::CLI::Deploys do
+  before do
+    FileUtils.stub(:chmod)
+    @deploys = Shelly::CLI::Deploys.new
+    @client = mock
+    Shelly::Client.stub(:new).and_return(@client)
+    $stdout.stub(:puts)
+    $stdout.stub(:print)
+  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")
+      lambda {
+        @deploys.list
+      }.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)
+      @client.stub(:cloud_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)
+    end
+
+    context "multiple clouds" do
+      before do
+        File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
+      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 deploy list foo-production")
+        $stdout.should_receive(:puts).with("Available clouds:")
+        $stdout.should_receive(:puts).with(" * foo-production")
+        $stdout.should_receive(:puts).with(" * foo-staging")
+        lambda { @deploys.list }.should raise_error(SystemExit)
+      end
+
+      it "should take cloud from command line for which to show logs" do
+        @client.should_receive(:cloud_logs).with("foo-staging").and_return([{"failed" => false, "created_at" => "2011-12-12-14-14-59"}])
+        $stdout.should_receive(:puts).with(green "Available deploy logs")
+        $stdout.should_receive(:puts).with(" * 2011-12-12-14-14-59")
+        @deploys.list("foo-staging")
+      end
+    end
+
+    context "single cloud" do
+      it "should display available logs" do
+        @client.should_receive(:cloud_logs).with("foo-staging").and_return([{"failed" => false, "created_at" => "2011-12-12-14-14-59"}, {"failed" => true, "created_at" => "2011-12-12-15-14-59"}])
+        $stdout.should_receive(:puts).with(green "Available deploy logs")
+        $stdout.should_receive(:puts).with(" * 2011-12-12-14-14-59")
+        $stdout.should_receive(:puts).with(" * 2011-12-12-15-14-59 (failed)")
+        @deploys.list
+      end
+
+    end
+
+  end
+
+end

data/spec/shelly/cli/main_spec.rb

@@ -23,14 +23,18 @@ describe Shelly::CLI::Main do
     it "should display available commands" do
       expected = <<-OUT
 Tasks:
-  shelly add               # Adds new cloud to Shelly Cloud
-  shelly help [TASK]       # Describe available tasks or one specific task
-  shelly ip                # Lists clouds IP's
-  shelly list              # Lists all your clouds
-  shelly login [EMAIL]     # Logs user in to Shelly Cloud
-  shelly register [EMAIL]  # Registers new user account on Shelly Cloud
-  shelly user <command>    # Manages users using this cloud
-  shelly version           # Displays shelly version
+  shelly add                # Adds new cloud to Shelly Cloud
+  shelly delete CODE-NAME   # Delete cloud from Shelly Cloud
+  shelly deploys <command>  # View cloud deploy logs
+  shelly help [TASK]        # Describe available tasks or one specific task
+  shelly ip                 # Lists clouds IP's
+  shelly list               # Lists all your clouds
+  shelly login [EMAIL]      # Logs user in to Shelly Cloud
+  shelly register [EMAIL]   # Registers new user account on Shelly Cloud
+  shelly start [CODE-NAME]  # Starts specific cloud
+  shelly stop [CODE-NAME]   # Stops specific cloud
+  shelly user <command>     # Manages users using this cloud
+  shelly version            # Displays shelly version
 
 Options:
   [--debug]  # Show debug information
@@ -165,6 +169,9 @@ OUT
   describe "#login" do
     before do
       @user = Shelly::User.new
+      @key_path = File.expand_path("~/.ssh/id_rsa.pub")
+      FileUtils.mkdir_p("~/.ssh")
+      File.open("~/.ssh/id_rsa.pub", "w") { |f| f << "ssh-key AAbbcc" }
       @user.stub(:upload_ssh_key)
       @client.stub(:token).and_return("abc")
       @client.stub(:apps).and_return([{"code_name" => "abc", "state" => "running"},
@@ -186,6 +193,13 @@ OUT
         end
       end
 
+      it "should accept email as parameter" do
+        $stdout.should_receive(:puts).with("Login successful")
+        fake_stdin(["secret"]) do
+          @main.login("megan@example.com")
+        end
+      end
+
       it "should upload user's public SSH key" do
         @user.should_receive(:upload_ssh_key)
         $stdout.should_receive(:puts).with("Uploading your public SSH key")
@@ -212,6 +226,18 @@ OUT
       end
     end
 
+    context "when local ssh key doesn't exists" do
+      it "should display error message and return exit with 1" do
+        FileUtils.rm_rf(@key_path)
+        File.exists?(@key_path).should be_false
+        $stdout.should_receive(:puts).with("\e[31mNo such file or directory - " + @key_path + "\e[0m")
+        $stdout.should_receive(:puts).with("\e[31mUse ssh-keygen to generate ssh key pair\e[0m")
+        lambda {
+          @main.login
+        }.should raise_error(SystemExit)
+      end
+    end
+
     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"}
@@ -439,7 +465,191 @@ OUT
         }.should raise_error(SystemExit)
       end
     end
+  end
 
+  describe "#start" do
+    before do
+      @user = Shelly::User.new
+      @client.stub(:token).and_return("abc")
+      FileUtils.mkdir_p("/projects/foo")
+      Dir.chdir("/projects/foo")
+      File.open("Cloudfile", 'w') {|f| f.write("foo-production:\n") }
+      Shelly::User.stub(:new).and_return(@user)
+      @client.stub(:apps).and_return([{"code_name" => "foo-production"}, {"code_name" => "foo-staging"}])
+      @app = Shelly::App.new
+      Shelly::App.stub(:new).and_return(@app)
+    end
+
+    it "should exit if there is no Cloudfile" do
+      File.delete("Cloudfile")
+      $stdout.should_receive(:puts).with("\e[31mNo Cloudfile found\e[0m")
+      lambda {
+        @main.start
+      }.should raise_error(SystemExit)
+    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)
+      @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)
+    end
+
+    it "should exit if user is not logged in" do
+      response = {"message" => "Unauthorized"}
+      exception = Shelly::Client::APIError.new(response.to_json)
+      @client.stub(:token).and_raise(exception)
+      $stdout.should_receive(:puts).with(red "You are not logged in. To log in use:")
+      $stdout.should_receive(:puts).with("  shelly login")
+      lambda { @main.start }.should raise_error(SystemExit)
+    end
+
+    context "single cloud in Cloudfile" do
+      it "should start the cloud" do
+        @client.stub(:start_cloud)
+        $stdout.should_receive(:puts).with(green "Starting cloud foo-production. Check status with:")
+        $stdout.should_receive(:puts).with("  shelly list")
+        @main.start
+      end
+    end
+
+    context "multiple clouds in Cloudfile" do
+      before do
+        File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
+      end
+
+      it "should show information to start specific cloud and exit" do
+        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Select which to start using:")
+        $stdout.should_receive(:puts).with("  shelly start foo-production")
+        $stdout.should_receive(:puts).with("Available clouds:")
+        $stdout.should_receive(:puts).with(" * foo-production")
+        $stdout.should_receive(:puts).with(" * foo-staging")
+        lambda { @main.start }.should raise_error(SystemExit)
+      end
+
+      it "should fetch from command line which cloud to start" do
+        @client.should_receive(:start_cloud).with("foo-staging")
+        $stdout.should_receive(:puts).with(green "Starting cloud foo-staging. Check status with:")
+        $stdout.should_receive(:puts).with("  shelly list")
+        @main.start("foo-staging")
+      end
+    end
+
+    context "on failure" do
+      it "should show information that cloud is running" do
+        raise_conflict(:state => "running")
+        $stdout.should_receive(:puts).with(red "Not starting: cloud 'foo-production' is already running")
+        lambda { @main.start }.should raise_error(SystemExit)
+      end
+
+      %w{deploying configuring}.each do |state|
+        it "should show information that cloud is #{state}" do
+          raise_conflict(:state => state)
+          $stdout.should_receive(:puts).with(red "Not starting: cloud 'foo-production' is currently deploying")
+          lambda { @main.start }.should raise_error(SystemExit)
+        end
+      end
+
+      it "should show information that cloud has no code" do
+        raise_conflict(:state => "no_code")
+        $stdout.should_receive(:puts).with(red "Not starting: no source code provided")
+        $stdout.should_receive(:puts).with(red "Push source code using:")
+        $stdout.should_receive(:puts).with("  git push production master")
+        lambda { @main.start }.should raise_error(SystemExit)
+      end
+
+      %w{deploy_failed configuration_failed}.each do |state|
+        it "should show information that cloud #{state}" do
+          raise_conflict(:state => state, :link => "http://example.com/logs")
+          $stdout.should_receive(:puts).with(red "Not starting: deployment failed")
+          $stdout.should_receive(:puts).with(red "Support has been notified")
+          $stdout.should_receive(:puts).with(red "See http://example.com/logs for reasons of failure")
+          lambda { @main.start }.should raise_error(SystemExit)
+        end
+      end
+      it "should open billing page" do
+        raise_conflict(:state => "no_billing")
+        $stdout.should_receive(:puts).with(red "Please fill in billing details to start foo-production. Opening browser.")
+        @app.should_receive(:open_billing_page)
+        lambda { @main.start }.should raise_error(SystemExit)
+      end
+
+      def raise_conflict(options = {})
+        options = {:state => "no_code"}.merge(options)
+        exception = RestClient::Conflict.new
+        exception.stub(:response).and_return(options.to_json)
+        @client.stub(:start_cloud).and_raise(exception)
+      end
+    end
+  end
+
+  describe "#stop" do
+    before do
+      @user = Shelly::User.new
+      @client.stub(:token).and_return("abc")
+      FileUtils.mkdir_p("/projects/foo")
+      Dir.chdir("/projects/foo")
+      File.open("Cloudfile", 'w') {|f| f.write("foo-production:\n") }
+      Shelly::User.stub(:new).and_return(@user)
+      @client.stub(:apps).and_return([{"code_name" => "foo-production"}, {"code_name" => "foo-staging"}])
+      @app = Shelly::App.new
+      Shelly::App.stub(:new).and_return(@app)
+    end
+
+    it "should exit if there is no Cloudfile" do
+      File.delete("Cloudfile")
+      $stdout.should_receive(:puts).with("\e[31mNo Cloudfile found\e[0m")
+      lambda {
+        @main.stop
+      }.should raise_error(SystemExit)
+    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)
+      @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)
+    end
+
+    it "should exit if user is not logged in" do
+      response = {"message" => "Unauthorized"}
+      exception = Shelly::Client::APIError.new(response.to_json)
+      @client.stub(:token).and_raise(exception)
+      $stdout.should_receive(:puts).with(red "You are not logged in. To log in use:")
+      $stdout.should_receive(:puts).with("  shelly login")
+      lambda { @main.stop }.should raise_error(SystemExit)
+    end
+
+    context "single cloud in Cloudfile" do
+      it "should start the cloud" do
+        @client.stub(:stop_cloud)
+        $stdout.should_receive(:puts).with("Cloud 'foo-production' stopped")
+        @main.stop
+      end
+    end
+
+    context "multiple clouds in Cloudfile" do
+      before do
+        File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
+      end
+
+      it "should show information to start specific cloud and exit" do
+        $stdout.should_receive(:puts).with("You have multiple clouds in Cloudfile. Select which to stop using:")
+        $stdout.should_receive(:puts).with("  shelly stop foo-production")
+        $stdout.should_receive(:puts).with("Available clouds:")
+        $stdout.should_receive(:puts).with(" * foo-production")
+        $stdout.should_receive(:puts).with(" * foo-staging")
+        lambda { @main.stop }.should raise_error(SystemExit)
+      end
+
+      it "should fetch from command line which cloud to start" do
+        @client.should_receive(:stop_cloud).with("foo-staging")
+        $stdout.should_receive(:puts).with("Cloud 'foo-staging' stopped")
+        @main.stop("foo-staging")
+      end
+    end
   end
 
   describe "#ips" do
@@ -466,17 +676,16 @@ OUT
 
     context "on success" do
       it "should display mail and web server ip's" do
-        @client.should_receive(:apps).and_return([{"code_name" => "foo-production"},{"code_name" => "foo-staging"}])
-        @client.stub(:apps_ips).and_return(response)
-        $stdout.should_receive(:puts).with("Cloud foo-production:")
-        $stdout.should_receive(:puts).with("Web server IP : 22.22.22.22")
-        $stdout.should_receive(:puts).with("Mail server IP: 11.11.11.11")
+        @client.stub(:app_ips).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")
         @main.ip
       end
     end
 
     def response
-      [{'code_name' => 'foo-production', 'mail_server_ip' => '11.11.11.11', 'web_server_ip' => '22.22.22.22'}]
+      {'mail_server_ip' => '11.11.11.11', 'web_server_ip' => '22.22.22.22'}
     end
 
     context "on failure" do
@@ -487,12 +696,82 @@ OUT
       end
 
       it "should raise an error if user does not have access to cloud" do
-        @client.should_receive(:apps).and_return([{"code_name" => "foo-production"}])
-        @client.stub(:apps_users).and_return(response)
-        $stdout.should_receive(:puts).with("\e[31mYou have no access to 'foo-staging' cloud defined in Cloudfile\e[0m")
-        lambda { @main.ip }.should raise_error(SystemExit)
+        response = {"message" => "Cloud foo-staging not found"}
+        exception = Shelly::Client::APIError.new(response.to_json)
+        @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
       end
     end
   end
-end
 
+  describe "#delete" do
+    before  do
+      Shelly::App.stub(:inside_git_repository?).and_return(true)
+      @user = Shelly::User.new
+      @app = Shelly::App.new
+      @client.stub(:token).and_return("abc")
+      @app.stub(:delete)
+      Shelly::User.stub(:new).and_return(@user)
+      Shelly::App.stub(:new).and_return(@app)
+    end
+
+    context "when code_name is not nil" do
+      it "should ask about delete application parts" do
+        $stdout.should_receive(:puts).with("You are about to delete application: foo-bar.")
+        $stdout.should_receive(:puts).with("Press Control-C at any moment to cancel.")
+        $stdout.should_receive(:puts).with("Please confirm each question by typing yes and pressing Enter.")
+        $stdout.should_receive(:puts).with("\n")
+        $stdout.should_receive(:print).with("I want to delete all files stored on Shelly Cloud (yes/no): ")
+        $stdout.should_receive(:print).with("I want to delete all database data stored on Shelly Cloud (yes/no): ")
+        $stdout.should_receive(:print).with("I want to delete the application (yes/no): ")
+        $stdout.should_receive(:puts).with("\n")
+        $stdout.should_receive(:puts).with("Scheduling application delete - done")
+        $stdout.should_receive(:puts).with("Removing git remote - done")
+        fake_stdin(["yes", "yes", "yes"]) do
+          @main.delete("foo-bar")
+        end
+      end
+
+      it "should return exit 1 when user doesn't type 'yes'" do
+        lambda{
+          fake_stdin(["yes", "yes", "no"]) do
+            @main.delete("foo-bar")
+          end
+        }.should raise_error(SystemExit)
+      end
+    end
+
+    context "when git repository doesn't exist" do
+      it "should say that Git remote missing" do
+        Shelly::App.stub(:inside_git_repository?).and_return(false)
+        $stdout.should_receive(:puts).with("Missing git remote")
+        fake_stdin(["yes", "yes", "yes"]) do
+          @main.delete("foo-bar")
+        end
+      end
+    end
+
+    context "when application with CODE-NAME doesn't exist" do
+      it "should raise Client::APIError" do
+        response = {:message => "Application not found"}
+        exception = Shelly::Client::APIError.new(response.to_json)
+        @app.stub(:delete).and_raise(exception)
+        $stdout.should_receive(:puts).with("\e[31mApplication not found\e[0m")
+        lambda{
+          fake_stdin(["yes", "yes", "yes"]) do
+            @main.delete("foo-bar")
+          end
+        }.should raise_error(SystemExit)
+      end
+    end
+
+    context "when code_name is nil" do
+      it "should display error when no code_name" do
+        $stdout.should_receive(:puts).with("\e[31mMissing CODE-NAME\e[0m")
+        $stdout.should_receive(:puts).with("\e[31mUse: shelly delete CODE-NAME\e[0m")
+        lambda{ @main.delete }.should raise_error(SystemExit)
+      end
+    end
+  end
+end