shelly 0.0.57 → 0.0.58

data/spec/shelly/cli/deploys_spec.rb

@@ -10,6 +10,7 @@ describe Shelly::CLI::Deploys do
     Shelly::Client.stub(:new).and_return(@client)
     $stdout.stub(:puts)
     $stdout.stub(:print)
+    @app = Shelly::App.new("foo-staging")
   end
 
   describe "#list" do
@@ -24,8 +25,12 @@ describe Shelly::CLI::Deploys do
       hooks(@deploys, :list).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@deploys, :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(:deploy_logs).with("foo-staging").and_return([
+        {"failed" => false, "created_at" => "2011-12-12-14-14-59"}])
+      @deploys.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@deploys, :list)
     end
 
     it "should exit if user doesn't have access to cloud in Cloudfile" do
@@ -34,39 +39,14 @@ describe Shelly::CLI::Deploys do
       lambda { invoke(@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(red "You have multiple clouds in Cloudfile.")
-        $stdout.should_receive(:puts).with("Select cloud using `shelly deploys list --cloud foo-production`")
-        $stdout.should_receive(:puts).with("Available clouds:")
-        $stdout.should_receive(:puts).with(" * foo-production")
-        $stdout.should_receive(:puts).with(" * foo-staging")
-        lambda { invoke(@deploys, :list) }.should raise_error(SystemExit)
-      end
-
-      it "should take cloud from command line for which to show logs" do
-        @client.should_receive(:deploy_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.options = {:cloud => "foo-staging"}
-        invoke(@deploys, :list)
-      end
-    end
-
-    context "single cloud" do
-      it "should display available logs" do
-        @client.should_receive(:deploy_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)")
-        invoke(@deploys, :list)
-      end
+    it "should display available logs" do
+      @client.should_receive(:deploy_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)")
+      invoke(@deploys, :list)
     end
   end
 
@@ -82,8 +62,11 @@ describe Shelly::CLI::Deploys do
       hooks(@deploys, :show).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@deploys, :show).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(:deploy_log).with("foo-staging", "last").and_return(response)
+      @deploys.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@deploys, :show, "last")
     end
 
     context "user doesn't have access to cloud" do
@@ -104,28 +87,6 @@ describe Shelly::CLI::Deploys 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 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 deploys show last --cloud foo-production`")
-        $stdout.should_receive(:puts).with("Available clouds:")
-        $stdout.should_receive(:puts).with(" * foo-production")
-        $stdout.should_receive(:puts).with(" * foo-staging")
-        lambda { invoke(@deploys, :show, "last") }.should raise_error(SystemExit)
-      end
-
-      it "should render the logs" do
-        @client.should_receive(:deploy_log).with("foo-staging", "last").and_return(response)
-        expected_output
-        @deploys.options = {:cloud => "foo-staging"}
-        invoke(@deploys, :show, "last")
-      end
-    end
-
     context "single cloud" do
       it "should render logs without passing cloud" do
         @client.should_receive(:deploy_log).with("foo-staging", "last").and_return(response)

data/spec/shelly/cli/main_spec.rb

@@ -553,20 +553,12 @@ OUT
       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"}])
+      @client.stub(:apps).and_return([{"code_name" => "foo-production", "state" => "running"},
+         {"code_name" => "foo-staging", "state" => "no_code"}])
       @app = Shelly::App.new
       Shelly::App.stub(:new).and_return(@app)
     end
 
-    # This spec tests cloudfile_present? hook
-    it "should exit if there is no Cloudfile" do
-      File.delete("Cloudfile")
-      $stdout.should_receive(:puts).with("\e[31mNo Cloudfile found\e[0m")
-      lambda {
-        invoke(@main, :start)
-      }.should raise_error(SystemExit)
-    end
-
     it "should ensure user has logged in" do
       hooks(@main, :start).should include(:logged_in?)
     end
@@ -588,6 +580,29 @@ OUT
       end
     end
 
+    # this tests multiple_clouds method used in majority of tasks
+    context "without Cloudfile" do
+      it "should use cloud from params" do
+        Dir.chdir("/projects")
+        @client.stub(:start_cloud)
+        $stdout.should_receive(:puts).with(green "Starting cloud foo-production.")
+        @main.options = {:cloud => "foo-production"}
+        invoke(@main, :start)
+      end
+
+      it "should ask user to specify cloud, list all clouds and exit" do
+        Dir.chdir("/projects")
+        @client.stub(:start_cloud)
+        $stdout.should_receive(:puts).with(red "You have to specify cloud.")
+        $stdout.should_receive(:puts).with("Select cloud using `shelly start --cloud CLOUD_NAME`")
+        $stdout.should_receive(:puts).with(green "You have following clouds available:")
+        $stdout.should_receive(:puts).with("  foo-production  |  running")
+        $stdout.should_receive(:puts).with("  foo-staging     |  no code")
+        lambda { invoke(@main, :start) }.should raise_error(SystemExit)
+      end
+    end
+
+    # this tests multiple_clouds method used in majority of tasks
     context "multiple clouds in Cloudfile" do
       before do
         File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
@@ -692,8 +707,13 @@ We have been notified about it. We will be adding new resources shortly")
       hooks(@main, :stop).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@main, :stop).should include(:cloudfile_present?)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.stub(:stop_cloud)
+      @main.should_receive(:multiple_clouds).and_return(@app)
+      fake_stdin(["yes"]) do
+        invoke(@main, :stop)
+      end
     end
 
     it "should exit if user doesn't have access to clouds in Cloudfile" do
@@ -706,48 +726,21 @@ We have been notified about it. We will be adding new resources shortly")
       }.should raise_error(SystemExit)
     end
 
-    context "single cloud in Cloudfile" do
-      it "should stop the cloud" do
-        @client.stub(:stop_cloud)
-        $stdout.should_receive(:print).with("Are you sure you want to shut down your application (yes/no): ")
-        $stdout.should_receive(:puts).with("\n")
-        $stdout.should_receive(:puts).with("Cloud 'foo-production' stopped")
-        fake_stdin(["yes"]) do
-          invoke(@main, :stop)
-        end
+    it "should stop the cloud" do
+      @client.stub(:stop_cloud)
+      $stdout.should_receive(:print).with("Are you sure you want to shut down your application (yes/no): ")
+      $stdout.should_receive(:puts).with("\n")
+      $stdout.should_receive(:puts).with("Cloud 'foo-production' stopped")
+      fake_stdin(["yes"]) do
+        invoke(@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 stop 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 stop --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(@main, :stop) }.should raise_error(SystemExit)
-      end
-
-      it "should fetch from command line which cloud to stop" do
-        @client.should_receive(:stop_cloud).with("foo-staging")
-        $stdout.should_receive(:print).with("Are you sure you want to shut down your application (yes/no): ")
-        $stdout.should_receive(:puts).with("\n")
-        $stdout.should_receive(:puts).with("Cloud 'foo-staging' stopped")
-        @main.options = {:cloud => "foo-staging"}
-        fake_stdin(["yes"]) do
-          invoke(@main, :stop)
-        end
-      end
-    end
   end
 
   describe "#ip" do
     before do
-      File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
+      File.open("Cloudfile", 'w') {|f| f.write("foo-production:\n") }
       @main.stub(:logged_in?).and_return(true)
     end
 
@@ -755,8 +748,12 @@ We have been notified about it. We will be adding new resources shortly")
       hooks(@main, :ip).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@main, :ip).should include(:cloudfile_present?)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @app.should_receive(:web_server_ip).and_return("11.11")
+      @app.should_receive(:mail_server_ip).and_return("22.22")
+      @main.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@main, :ip)
     end
 
     context "on success" do
@@ -777,8 +774,8 @@ We have been notified about it. We will be adding new resources shortly")
       it "should raise an error if user does not have access to cloud" do
         exception = Shelly::Client::NotFoundException.new("resource" => "cloud")
         @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)
+        $stdout.should_receive(:puts).with(red "You have no access to 'foo-production' cloud defined in Cloudfile")
+        lambda { invoke(@main, :ip) }.should raise_error(SystemExit)
       end
     end
   end
@@ -803,13 +800,14 @@ We have been notified about it. We will be adding new resources shortly")
       hooks(@main, :setup).should include(:inside_git_repository?)
     end
 
-    it "should ensure that cloudfile is present" do
-      hooks(@main, :setup).should include(:cloudfile_present?)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @main.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@main, :setup)
     end
 
     it "should show info about adding remote and branch" do
-      $stdout.should_receive(:puts).with("Investigating Cloudfile")
-      $stdout.should_receive(:puts).with(green "Adding foo-staging cloud")
+      $stdout.should_receive(:puts).with(green "Setting up foo-staging cloud")
       $stdout.should_receive(:puts).with("git remote add foo-staging git_url")
       $stdout.should_receive(:puts).with("git fetch production")
       $stdout.should_receive(:puts).with("git checkout -b foo-staging --track foo-staging/master")
@@ -849,7 +847,7 @@ We have been notified about it. We will be adding new resources shortly")
       end
 
       context "and user answers no" do
-        it "should display commands to perform manually " do
+        it "should display commands to perform manually" do
           @app.should_not_receive(:add_git_remote)
           @app.should_not_receive(:git_fetch_remote)
           @app.should_not_receive(:git_add_tracking_branch)
@@ -877,6 +875,15 @@ We have been notified about it. We will be adding new resources shortly")
       hooks(@main, :delete).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(:delete)
+      @main.should_receive(:multiple_clouds).and_return(@app)
+      fake_stdin(["yes", "yes", "yes"]) do
+        invoke(@main, :delete)
+      end
+    end
+
     context "when cloud is given" do
       before do
         File.open("Cloudfile", 'w') {|f|
@@ -1021,8 +1028,11 @@ We have been notified about it. We will be adding new resources shortly")
       hooks(@main, :logs).should include(:logged_in?)
     end
 
-    it "should ensure that Cloudfile is present" do
-      hooks(@main, :logs).should include(:cloudfile_present?)
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.stub(:application_logs).and_return(["log1"])
+      @main.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@main, :logs)
     end
 
     it "should exit if user doesn't have access to clouds in Cloudfile" do
@@ -1033,40 +1043,12 @@ We have been notified about it. We will be adding new resources shortly")
       lambda { invoke(@main, :logs) }.should raise_error(SystemExit)
     end
 
-    context "single cloud in Cloudfile" do
-      it "should show logs for the cloud" do
-        @client.stub(:application_logs).and_return(["log1"])
-        $stdout.should_receive(:puts).with(green "Cloud foo-production:")
-        $stdout.should_receive(:puts).with(green "Instance 1:")
-        $stdout.should_receive(:puts).with("log1")
-        invoke(@main, :logs)
-      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 print logs for 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 logs --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(@main, :logs) }.should raise_error(SystemExit)
-      end
-
-      it "should fetch from command line which cloud to start" do
-        @client.should_receive(:application_logs).with("foo-staging").
-          and_return(["log1"])
-        $stdout.should_receive(:puts).with(green "Cloud foo-staging:")
-        $stdout.should_receive(:puts).with(green "Instance 1:")
-        $stdout.should_receive(:puts).with("log1")
-        @main.options = {:cloud => "foo-staging"}
-        invoke(@main, :logs)
-      end
+    it "should show logs for the cloud" do
+      @client.stub(:application_logs).and_return(["log1"])
+      $stdout.should_receive(:puts).with(green "Cloud foo-production:")
+      $stdout.should_receive(:puts).with(green "Instance 1:")
+      $stdout.should_receive(:puts).with("log1")
+      invoke(@main, :logs)
     end
 
     context "multiple instances" do
@@ -1092,7 +1074,7 @@ We have been notified about it. We will be adding new resources shortly")
       Shelly::User.stub(:new).and_return(@user)
       @client.stub(:apps).and_return([{"code_name" => "foo-production"},
                                      {"code_name" => "foo-staging"}])
-      @app = Shelly::App.new
+      @app = Shelly::App.new("foo-production")
       Shelly::App.stub(:new).and_return(@app)
       File.open("to_execute.rb", 'w') {|f| f.write("User.count") }
     end
@@ -1101,51 +1083,26 @@ We have been notified about it. We will be adding new resources shortly")
       hooks(@main, :execute).should include(:logged_in?)
     end
 
-    it "should ensure cloudfile present" do
-      hooks(@main, :execute).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(:command).with("foo-production", "User.count", :ruby).
+        and_return({"result" => "3"})
+      @main.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@main, :execute, "to_execute.rb")
     end
 
-    context "single cloud in Cloudfile" do
-      it "should execute code for the cloud" do
-        @client.should_receive(:command).with("foo-production", "User.count", :ruby).
-          and_return({"result" => "3"})
-        $stdout.should_receive(:puts).with("3")
-        invoke(@main, :execute, "to_execute.rb")
-      end
+    it "should execute code for the cloud" do
+      @client.should_receive(:command).with("foo-production", "User.count", :ruby).
+        and_return({"result" => "3"})
+      $stdout.should_receive(:puts).with("3")
+      invoke(@main, :execute, "to_execute.rb")
     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 print logs for 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 execute --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(@main, :execute, "to_execute.rb") }.should raise_error(SystemExit)
-      end
-
-      it "should fetch from command line which cloud to start" do
-        @client.should_receive(:command).with("foo-staging", "User.count", :ruby).
-          and_return({"result" => "3"})
-        $stdout.should_receive(:puts).with("3")
-        @main.options = {:cloud => "foo-staging"}
-        invoke(@main, :execute, "to_execute.rb")
-      end
-
-      it "should run code when no file from parameter is found" do
-        @client.should_receive(:command).with("foo-staging", "2 + 2", :ruby).
-          and_return({"result" => "4"})
-        $stdout.should_receive(:puts).with("4")
-        @main.options = {:cloud => "foo-staging"}
-        invoke(@main, :execute, "2 + 2")
-      end
+    it "should run code when no file from parameter is found" do
+      @client.should_receive(:command).with("foo-production", "2 + 2", :ruby).
+        and_return({"result" => "4"})
+      $stdout.should_receive(:puts).with("4")
+      invoke(@main, :execute, "2 + 2")
     end
 
     context "cloud is not in running state" do
@@ -1176,7 +1133,7 @@ We have been notified about it. We will be adding new resources shortly")
       @user = Shelly::User.new
       @user.stub(:token)
       Shelly::User.stub(:new).and_return(@user)
-      @app = Shelly::App.new
+      @app = Shelly::App.new("foo-production")
       Shelly::App.stub(:new).and_return(@app)
       @main.stub(:rake_args).and_return(%w(db:migrate))
     end
@@ -1185,8 +1142,12 @@ We have been notified about it. We will be adding new resources shortly")
       hooks(@main, :rake).should include(:logged_in?)
     end
 
-    it "should ensure cloudfile present" do
-      hooks(@main, :execute).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(:command).with("foo-production", "db:migrate", :rake).
+        and_return({"result" => "OK"})
+      @main.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@main, :rake, "db:migrate")
     end
 
     it "should invoke :command on app with rake task" do
@@ -1227,45 +1188,26 @@ We have been notified about it. We will be adding new resources shortly")
         lambda { invoke(@main, :rake, "db:migrate") }.should raise_error(SystemExit)
       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 run rake task for 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 rake db:migrate --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(@main, :rake, "db:migrate") }.should raise_error(SystemExit)
-      end
-
-      it "should fetch from command line for which cloud run rake task" do
-        @client.should_receive(:command).with("foo-staging", "db:migrate", :rake).
-          and_return({"result" => "3"})
-        $stdout.should_receive(:puts).with("3")
-        @main.options = {:cloud => "foo-staging"}
-        invoke(@main, :rake, "db:migrate")
-      end
-    end
   end
 
   describe "#redeploy" do
     before do
       @user = Shelly::User.new
       @client.stub(:token).and_return("abc")
-      @app = Shelly::App.new
+      @app = Shelly::App.new("foo-production")
       Shelly::App.stub(:new).and_return(@app)
       FileUtils.mkdir_p("/projects/foo")
       Dir.chdir("/projects/foo")
       File.open("Cloudfile", 'w') { |f| f.write("foo-production:\n") }
     end
 
+    # multiple_clouds is tested in main_spec.rb in describe "#start" block
+    it "should ensure multiple_clouds check" do
+      @client.stub(:redeploy)
+      @main.should_receive(:multiple_clouds).and_return(@app)
+      invoke(@main, :redeploy)
+    end
+
     it "should redeploy the application" do
       $stdout.should_receive(:puts).with(green "Redeploying your application for cloud 'foo-production'")
       @app.should_receive(:redeploy)
@@ -1308,27 +1250,5 @@ We have been notified about it. We will be adding new resources shortly")
         }.should raise_error(Shelly::Client::ConflictException)
       end
     end
-
-    context "on 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 redeploy application for 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 redeploy --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(@main, :redeploy) }.should raise_error(SystemExit)
-      end
-
-      it "should fetch from command line which cloud to redeploy application for" do
-        @client.should_receive(:redeploy).with("foo-staging")
-        $stdout.should_receive(:puts).with(green "Redeploying your application for cloud 'foo-staging'")
-        @main.options = {:cloud => "foo-staging"}
-        invoke(@main, :redeploy)
-      end
-    end
   end
 end