shelly 0.0.57 → 0.0.58

data/lib/shelly/cli/user.rb

@@ -7,69 +7,56 @@ module Shelly
       include Helpers
 
       before_hook :logged_in?, :only => [:list, :add, :delete]
-      before_hook :cloudfile_present?, :only => [:list, :add, :delete]
+      class_option :cloud, :type => :string, :aliases => "-c", :desc => "Specify cloud"
 
       desc "list", "List users with access to clouds defined in Cloudfile"
       def list
-        @cloudfile = Cloudfile.new
-        @cloudfile.clouds.each do |cloud|
-          begin
-            @app = App.new(cloud)
-            say "Cloud #{cloud}:"
-            @app.active_collaborations.each { |c| say "  #{c["email"]}" }
-            @app.inactive_collaborations.each { |c|
-              say "  #{c["email"]} (invited)" }
-          rescue Client::NotFoundException => e
-            raise unless e.resource == :cloud
-            say_error "You have no access to '#{cloud}' cloud defined in Cloudfile"
-          end
-        end
+        app = multiple_clouds(options[:cloud], "list")
+        say "Cloud #{app}:"
+        app.active_collaborations.each { |c| say "  #{c["email"]}" }
+        app.inactive_collaborations.each { |c|
+          say "  #{c["email"]} (invited)" }
+      rescue Client::NotFoundException => e
+        raise unless e.resource == :cloud
+        say_error "You have no access to '#{app}' cloud defined in Cloudfile"
       end
 
       desc "add [EMAIL]", "Add new developer to clouds defined in Cloudfile"
       def add(email = nil)
-        @cloudfile = Cloudfile.new
-        @user = Shelly::User.new
+        user = Shelly::User.new
+        app = multiple_clouds(options[:cloud], "add")
         user_email = email || ask_for_email({:guess_email => false})
-        @cloudfile.clouds.each do |cloud|
-          begin
-            @user.send_invitation(cloud, user_email)
-            say "Sending invitation to #{user_email} to work on #{cloud}", :green
-          rescue Client::ValidationException => e
-            if e.errors.include?(["email", "#{email} has already been taken"])
-              say_error "User #{email} is already in the cloud #{cloud}", :with_exit => false
-            else
-              e.each_error { |error| say_error error, :with_exit => false }
-              exit 1
-            end
-          rescue Client::NotFoundException => e
-            raise unless e.resource == :cloud
-            say_error "You have no access to '#{cloud}' cloud defined in Cloudfile"
-          end
+        user.send_invitation(app.to_s, user_email)
+        say "Sending invitation to #{user_email} to work on #{app}", :green
+      rescue Client::ValidationException => e
+        if e.errors.include?(["email", "#{email} has already been taken"])
+          say_error "User #{email} is already in the cloud #{app}", :with_exit => false
+        else
+          e.each_error { |error| say_error error, :with_exit => false }
+          exit 1
         end
+      rescue Client::NotFoundException => e
+        raise unless e.resource == :cloud
+        say_error "You have no access to '#{app}' cloud defined in Cloudfile"
       end
 
       desc "delete [EMAIL]", "Remove developer from clouds defined in Cloudfile"
       def delete(email = nil)
-        @cloudfile = Cloudfile.new
-        @user = Shelly::User.new
+        user = Shelly::User.new
+        app = multiple_clouds(options[:cloud], "delete")
         user_email = email || ask_for_email({:guess_email => false})
-        @cloudfile.clouds.each do |cloud|
-          begin
-            @user.delete_collaboration(cloud, user_email)
-            say "User #{user_email} deleted from cloud #{cloud}"
-          rescue Client::ConflictException => e
-            say_error e[:message]
-          rescue Client::NotFoundException => e
-            case e.resource
-            when :cloud
-              say_error "You have no access to '#{cloud}' cloud defined in Cloudfile"
-            when :user
-              say_error "User '#{user_email}' not found", :with_exit => false
-              say_error "You can list users with `shelly user list`"
-            else raise
-            end
-          end
+        user.delete_collaboration(app.to_s, user_email)
+        say "User #{user_email} deleted from cloud #{app}"
+      rescue Client::ConflictException => e
+        say_error e[:message]
+      rescue Client::NotFoundException => e
+        case e.resource
+        when :cloud
+          say_error "You have no access to '#{app}' cloud defined in Cloudfile"
+        when :user
+          say_error "User '#{user_email}' not found", :with_exit => false
+          say_error "You can list users with `shelly user list`"
+        else raise
         end
       end
 

data/lib/shelly/cloudfile.rb

@@ -27,9 +27,8 @@ module Shelly
       end
     end
 
-    # FIXME: this should return instances of App
     def clouds
-      @content.keys.sort
+      @content.keys.sort if @content
     end
 
     def yaml(hash)

data/lib/shelly/helpers.rb

@@ -83,7 +83,7 @@ module Shelly
 
     def multiple_clouds(cloud, action)
       clouds = Cloudfile.new.clouds
-      if clouds.count > 1 && cloud.nil?
+      if clouds && clouds.count > 1 && cloud.nil?
         say_error "You have multiple clouds in Cloudfile.", :with_exit => false
         say "Select cloud using `shelly #{action} --cloud #{clouds.first}`"
         say "Available clouds:"
@@ -92,8 +92,16 @@ module Shelly
         end
         exit 1
       end
-      @app = Shelly::App.new
-      @app.code_name = cloud || clouds.first
+      unless Cloudfile.present? || cloud
+        say_error "You have to specify cloud.", :with_exit => false
+        say "Select cloud using `shelly #{action} --cloud CLOUD_NAME`"
+        invoke :list
+        exit 1
+      end
+
+      app = Shelly::App.new
+      app.code_name = cloud || clouds.first
+      app
     end
   end
 end

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.0.57"
+  VERSION = "0.0.58"
 end

data/spec/shelly/cli/backup_spec.rb

@@ -12,6 +12,8 @@ describe Shelly::CLI::Backup do
     FileUtils.mkdir_p("/projects/foo")
     Dir.chdir("/projects/foo")
     File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
+    @app = Shelly::App.new("foo-staging")
+    Shelly::App.stub(:new).and_return(@app)
   end
 
   describe "#list" do
@@ -25,8 +27,11 @@ describe Shelly::CLI::Backup do
       hooks(@backup, :list).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@backup, :list).should include(:cloudfile_present?)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.should_receive(:database_backups).with("foo-staging").and_return([{"filename" => "backup.postgre.tar.gz", "human_size" => "10kb", "size" => 12345}])
+      @backup.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@backup, :list)
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
@@ -36,30 +41,15 @@ describe Shelly::CLI::Backup do
       lambda { invoke(@backup, :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(red "You have multiple clouds in Cloudfile.")
-        $stdout.should_receive(:puts).with("Select cloud using `shelly backup list --cloud foo-production`")
-        $stdout.should_receive(:puts).with("Available clouds:")
-        $stdout.should_receive(:puts).with(" * foo-production")
-        $stdout.should_receive(:puts).with(" * foo-staging")
-        lambda { invoke(@backup, :list) }.should raise_error(SystemExit)
-      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", "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")
-        $stdout.should_receive(:puts).with("  backup.postgre.tar.gz  |  10kb")
-        $stdout.should_receive(:puts).with("  backup.mongo.tar.gz    |  22kb")
-        @backup.options = {:cloud => "foo-staging"}
-        invoke(@backup, :list)
-      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", "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")
+      $stdout.should_receive(:puts).with("  backup.postgre.tar.gz  |  10kb")
+      $stdout.should_receive(:puts).with("  backup.mongo.tar.gz    |  22kb")
+      @backup.options = {:cloud => "foo-staging"}
+      invoke(@backup, :list)
     end
 
     describe "#get" do
@@ -75,14 +65,10 @@ describe Shelly::CLI::Backup do
         hooks(@backup, :get).should include(:logged_in?)
       end
 
-      it "should make sure that cloud is choosen" do
+      # multiple_clouds is tested in main_spec.rb in describe "#start" block
+      it "should ensure multiple_clouds check" do
         @client.should_receive(:database_backup).with("foo-staging", "last")
-        invoke(@backup, :get)
-      end
-
-      it "should make sure that cloud is choosen" do
-        @client.should_receive(:database_backup).with("other", "last")
-        @backup.options = {:cloud => "other"}
+        @backup.should_receive(:multiple_clouds).and_return(@app)
         invoke(@backup, :get)
       end
 
@@ -140,6 +126,13 @@ describe Shelly::CLI::Backup do
       hooks(@backup, :create).should include(:logged_in?)
     end
 
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.stub(:request_backup)
+      @backup.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@backup, :create)
+    end
+
     it "should exit if user doesn't have access to cloud in Cloudfile" do
       exception = Shelly::Client::NotFoundException.new({"resource" => "cloud"})
       @client.stub(:request_backup).and_raise(exception)
@@ -174,6 +167,15 @@ describe Shelly::CLI::Backup do
       hooks(@backup, :restore).should include(:logged_in?)
     end
 
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.stub(:restore_backup)
+      @backup.should_receive(:multiple_clouds).and_return(@app)
+      fake_stdin(["yes"]) do
+        invoke(@backup, :restore, "better.tar.gz")
+      end
+    end
+
     it "should restore database" do
       $stdout.should_receive(:puts).with("You are about restore database postgre for cloud foo-staging to state from better.tar.gz")
       $stdout.should_receive(:print).with("I want to restore the database (yes/no): ")

data/spec/shelly/cli/config_spec.rb

@@ -14,23 +14,23 @@ describe Shelly::CLI::Config do
     FileUtils.mkdir_p("/projects/foo")
     Dir.chdir("/projects/foo")
     @client.stub(:token).and_return("abc")
-    File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
+    File.open("Cloudfile", 'w') {|f| f.write("foo-production:\n") }
     FileUtils.mkdir_p("/tmp")
     Dir.stub(:tmpdir).and_return("/tmp")
     ENV["EDITOR"] = "vim"
+    @app = Shelly::App.new("foo-production")
   end
 
   describe "#list" do
-    before do
-      File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
-    end
-
     it "should ensure user has logged in" do
       hooks(@config, :list).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@config, :list).should include(:cloudfile_present?)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.should_receive(:app_configs).with("foo-production").and_return([{"created_by_user" => false, "path" => "config/app.yml"}])
+      @config.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@config, :list)
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
@@ -41,38 +41,30 @@ describe Shelly::CLI::Config do
     end
 
     it "should list available configuration files for clouds" do
-      @client.should_receive(:app_configs).with("foo-staging").and_return([{"created_by_user" => true, "path" => "config/settings.yml"}])
       @client.should_receive(:app_configs).with("foo-production").and_return([{"created_by_user" => false, "path" => "config/app.yml"}])
       $stdout.should_receive(:puts).with(green "Configuration files for foo-production")
       $stdout.should_receive(:puts).with("You have no custom configuration files.")
       $stdout.should_receive(:puts).with("Following files are created by Shelly Cloud:")
       $stdout.should_receive(:puts).with(/ * \s+config\/app.yml/)
-      $stdout.should_receive(:puts).with(green "Configuration files for foo-staging")
-      $stdout.should_receive(:puts).with("Custom configuration files:")
-      $stdout.should_receive(:puts).with(/ * \s+config\/settings.yml/)
 
       invoke(@config, :list)
     end
-
   end
 
   describe "#show" do
-
     it "should ensure user has logged in" do
       hooks(@config, :show).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@config, :show).should include(:cloudfile_present?)
-    end
-
-    it "should exit if no path was specified" do
-      $stdout.should_receive(:puts).with(red "No configuration file specified")
-      lambda { invoke(@config, :show) }.should raise_error(SystemExit)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.should_receive(:app_config).with("foo-production", "path").and_return({"path" => "test.rb", "content" => "example content"})
+      @config.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@config, :show, "path")
     end
 
     it "should show config" do
-      @client.should_receive(:app_config).with("foo-staging", "path").and_return({"path" => "test.rb", "content" => "example content"})
+      @client.should_receive(:app_config).with("foo-production", "path").and_return({"path" => "test.rb", "content" => "example content"})
       $stdout.should_receive(:puts).with(green "Content of test.rb:")
       $stdout.should_receive(:puts).with("example content")
       invoke(@config, :show, "path")
@@ -84,7 +76,7 @@ describe Shelly::CLI::Config do
           exception = Shelly::Client::NotFoundException.new("resource" => "config")
           @client.should_receive(:app_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "Config 'config/app.yml' not found")
-          $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-staging`")
+          $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-production`")
           lambda {
             invoke(@config, :show, "config/app.yml")
           }.should raise_error(SystemExit)
@@ -95,31 +87,13 @@ describe Shelly::CLI::Config do
         it "should display error message and exit with 1" do
           exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
           @client.should_receive(:app_config).and_raise(exception)
-          $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
+          $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' 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") }
-      end
-
-      it "should show info to select cloud and exit" do
-        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
-        $stdout.should_receive(:puts).with("Select cloud using `shelly show path --cloud foo-production`")
-        lambda { invoke(@config, :show, "path") }.should raise_error(SystemExit)
-      end
-
-      it "should use cloud specified by parameter" do
-        @client.should_receive(:app_config).with("foo-production", "path").and_return({"path" => "test.rb", "content" => "example content"})
-        @config.options = {:cloud => "foo-production"}
-        invoke(@config, :show, "path")
-      end
-    end
   end
 
   describe "#create" do
@@ -127,13 +101,18 @@ describe Shelly::CLI::Config do
       hooks(@config, :create).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@config, :create).should include(:cloudfile_present?)
+    it "should ensure user has logged in" do
+      hooks(@config, :new).should include(:logged_in?)
     end
 
-    it "should exit if no path was specified" do
-      $stdout.should_receive(:puts).with(red "No path specified")
-      lambda { invoke(@config, :create) }.should raise_error(SystemExit)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @config.should_receive(:system).with(/vim \/tmp\/shelly-edit/).and_return(true)
+      @app = Shelly::App.new("foo-production")
+      Shelly::App.stub(:new).and_return(@app)
+      @client.should_receive(:app_create_config).with("foo-production", "path", "\n").and_return({})
+      @config.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@config, :create, "path")
     end
 
     it "should ask to set EDITOR environment variable if not set" do
@@ -144,10 +123,10 @@ describe Shelly::CLI::Config do
 
     it "should create file" do
       @config.should_receive(:system).with(/vim \/tmp\/shelly-edit/).and_return(true)
-      @client.should_receive(:app_create_config).with("foo-staging", "path", "\n").and_return({})
+      @client.should_receive(:app_create_config).with("foo-production", "path", "\n").and_return({})
       $stdout.should_receive(:puts).with(green "File 'path' created.")
       $stdout.should_receive(:puts).with("To make changes to running application redeploy it using:")
-      $stdout.should_receive(:puts).with("`shelly redeploy --cloud foo-staging`")
+      $stdout.should_receive(:puts).with("`shelly redeploy --cloud foo-production`")
       invoke(@config, :create, "path")
     end
 
@@ -162,26 +141,6 @@ describe Shelly::CLI::Config do
         }.should raise_error(SystemExit)
       end
     end
-
-    context "multiple clouds" do
-      before do
-        File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
-      end
-
-      it "should show info to select cloud and exit" do
-        @config.stub(:system) {true}
-        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
-        $stdout.should_receive(:puts).with("Select cloud using `shelly create path --cloud foo-production`")
-        lambda { @config.create("path") }.should raise_error(SystemExit)
-      end
-
-      it "should use cloud specified by parameter" do
-        @config.should_receive(:system).with(/vim \/tmp\/shelly-edit/).and_return(true)
-        @client.should_receive(:app_create_config).with("foo-production", "path", "\n").and_return({})
-        @config.options = {:cloud => "foo-production"}
-        invoke(@config, :create, "path")
-      end
-    end
   end
 
 
@@ -190,29 +149,33 @@ describe Shelly::CLI::Config do
       hooks(@config, :edit).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@config, :edit).should include(:cloudfile_present?)
+    it "should ensure user has logged in" do
+      hooks(@config, :update).should include(:logged_in?)
     end
 
-    it "should exit if no path was specified" do
-      $stdout.should_receive(:puts).with(red "No configuration file specified")
-      lambda { invoke(@config, :edit) }.should raise_error(SystemExit)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @config.should_receive(:system).with(/vim \/tmp\/shelly-edit/).and_return(true)
+      @client.should_receive(:app_config).with("foo-production", "path").and_return({"path" => "test.rb", "content" => "example content"})
+      @client.should_receive(:app_update_config).with("foo-production", "path", "example content\n").and_return({"path" => "test.rb", "content" => "example content"})
+      @config.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@config, :edit, "path")
     end
 
     it "should ask to set EDITOR environment variable if not set" do
-      @client.should_receive(:app_config).with("foo-staging", "path").and_return({"path" => "test.rb", "content" => "example content"})
+      @client.should_receive(:app_config).with("foo-production", "path").and_return({"path" => "test.rb", "content" => "example content"})
       @config.stub(:system) {false}
       $stdout.should_receive(:puts).with(red "Please set EDITOR environment variable")
       lambda { invoke(@config, :edit, "path") }.should raise_error(SystemExit)
     end
 
     it "should create file" do
-      @client.should_receive(:app_config).with("foo-staging", "path").and_return({"path" => "test.rb", "content" => "example content"})
+      @client.should_receive(:app_config).with("foo-production", "path").and_return({"path" => "test.rb", "content" => "example content"})
       @config.should_receive(:system).with(/vim \/tmp\/shelly-edit/).and_return(true)
-      @client.should_receive(:app_update_config).with("foo-staging", "path", "example content\n").and_return({"path" => "test.rb", "content" => "example content"})
+      @client.should_receive(:app_update_config).with("foo-production", "path", "example content\n").and_return({"path" => "test.rb", "content" => "example content"})
       $stdout.should_receive(:puts).with(green "File 'test.rb' updated.")
       $stdout.should_receive(:puts).with("To make changes to running application redeploy it using:")
-      $stdout.should_receive(:puts).with("`shelly redeploy --cloud foo-staging`")
+      $stdout.should_receive(:puts).with("`shelly redeploy --cloud foo-production`")
       invoke(@config, :edit, "path")
     end
 
@@ -222,7 +185,7 @@ describe Shelly::CLI::Config do
           exception = Shelly::Client::NotFoundException.new("resource" => "config")
           @client.should_receive(:app_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "Config 'config/app.yml' not found")
-          $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-staging`")
+          $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-production`")
           lambda {
             invoke(@config, :edit, "config/app.yml")
           }.should raise_error(SystemExit)
@@ -233,7 +196,7 @@ describe Shelly::CLI::Config do
         it "should display error message and exit with 1" do
           exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
           @client.should_receive(:app_config).and_raise(exception)
-          $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
+          $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
           lambda {
             invoke(@config, :edit, "config/app.yml")
           }.should raise_error(SystemExit)
@@ -251,27 +214,6 @@ describe Shelly::CLI::Config do
         end
       end
     end
-
-    context "multiple clouds" do
-      before do
-        File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
-      end
-
-      it "should show info to select cloud and exit" do
-        @config.stub(:system) {true}
-        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
-        $stdout.should_receive(:puts).with("Select cloud using `shelly edit path --cloud foo-production`")
-        lambda { invoke(@config, :edit, "path") }.should raise_error(SystemExit)
-      end
-
-      it "should use cloud specified by parameter" do
-        @client.should_receive(:app_config).with("foo-production", "path").and_return({"path" => "test.rb", "content" => "example content"})
-        @config.should_receive(:system).with(/vim \/tmp\/shelly-edit/).and_return(true)
-        @client.should_receive(:app_update_config).with("foo-production", "path", "example content\n").and_return({"path" => "test.rb", "content" => "example content"})
-        @config.options = {:cloud => "foo-production"}
-        invoke(@config, :edit, "path")
-      end
-    end
   end
 
   describe "#delete" do
@@ -279,20 +221,20 @@ describe Shelly::CLI::Config do
       hooks(@config, :delete).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@config, :delete).should include(:cloudfile_present?)
-    end
-
-    it "should exit if no path was specified" do
-      $stdout.should_receive(:puts).with(red "No configuration file specified")
-      lambda { invoke(@config, :delete) }.should raise_error(SystemExit)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.should_receive(:app_delete_config).with("foo-production", "path").and_return({})
+      @config.should_receive(:multiple_clouds).and_return(@app)
+      fake_stdin(["y"]) do
+        invoke(@config, :delete, "path")
+      end
     end
 
     it "should delete configuration file" do
-      @client.should_receive(:app_delete_config).with("foo-staging", "path").and_return({})
+      @client.should_receive(:app_delete_config).with("foo-production", "path").and_return({})
       $stdout.should_receive(:puts).with(green "File 'path' deleted.")
       $stdout.should_receive(:puts).with("To make changes to running application redeploy it using:")
-      $stdout.should_receive(:puts).with("`shelly redeploy --cloud foo-staging`")
+      $stdout.should_receive(:puts).with("`shelly redeploy --cloud foo-production`")
       fake_stdin(["y"]) do
         invoke(@config, :delete, "path")
       end
@@ -306,36 +248,13 @@ describe Shelly::CLI::Config do
       end
     end
 
-    context "multiple clouds" do
-      before do
-        File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
-      end
-
-      it "should show info to select cloud and exit" do
-        $stdout.should_receive(:puts).with(red "You have multiple clouds in Cloudfile.")
-        $stdout.should_receive(:puts).with("Select cloud using `shelly delete path --cloud foo-production`")
-        lambda { invoke(@config, :delete, "path") }.should raise_error(SystemExit)
-      end
-
-      it "should use cloud specified by parameter" do
-        @client.should_receive(:app_delete_config).with("foo-production", "path").and_return({})
-        $stdout.should_receive(:puts).with(green "File 'path' deleted.")
-        $stdout.should_receive(:puts).with("To make changes to running application redeploy it using:")
-        $stdout.should_receive(:puts).with("`shelly redeploy --cloud foo-production`")
-        @config.options = {:cloud => "foo-production"}
-        fake_stdin(["y"]) do
-          invoke(@config, :delete, "path")
-        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::NotFoundException.new("resource" => "config")
           @client.should_receive(:app_delete_config).and_raise(exception)
           $stdout.should_receive(:puts).with(red "Config 'config/app.yml' not found")
-          $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-staging`")
+          $stdout.should_receive(:puts).with(red "You can list available config files with `shelly config list --cloud foo-production`")
           fake_stdin(["y"]) do
             lambda {
               invoke(@config, :delete, "config/app.yml")
@@ -348,7 +267,7 @@ describe Shelly::CLI::Config do
         it "should display error message and exit with 1" do
           exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
           @client.should_receive(:app_delete_config).and_raise(exception)
-          $stdout.should_receive(:puts).with(red "You have no access to 'foo-staging' cloud defined in Cloudfile")
+          $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
           fake_stdin(["y"]) do
             lambda {
               invoke(@config, :delete, "config/app.yml")
@@ -357,6 +276,5 @@ describe Shelly::CLI::Config do
         end
       end
     end
-
   end
 end