trucker-cli 0.0.1

data/spec/cf/cli/app/restart_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+module CF
+  module App
+    describe Restart do
+      let(:restart_command) { CF::App::Restart.new(Mothership.commands[:restart]) }
+      let(:inputs) { {:apps => [app]} }
+      let(:app) { build(:app, :command => "rails s") }
+
+      before do
+        restart_command.input = Mothership::Inputs.new(nil, restart_command, inputs, {}, {})
+        app.stub(:update!)
+      end
+
+      it "restarts the application" do
+        restart_command.should_receive(:invoke).with(:stop, anything) do
+          restart_command.should_receive(:invoke).with(:start, anything)
+        end
+        restart_command.restart
+      end
+
+      it "does not change the command if we do not pass the command argument" do
+        restart_command.stub(:invoke).with(:start, anything)
+        restart_command.stub(:invoke).with(:stop, anything)
+        restart_command.restart
+        app.command.should == "rails s"
+      end
+
+      context "when passing in a new start command" do
+        let(:inputs) { {:apps => [app], :command => 'rake db:migrate'} }
+
+        before do
+          restart_command.stub(:invoke).with(:stop, anything)
+          restart_command.input = Mothership::Inputs.new(nil, restart_command, inputs, {}, {})
+        end
+
+        it "updates the start command" do
+          app.should_receive(:update!) do
+            restart_command.should_receive(:invoke).with(:start, anything)
+          end
+          restart_command.restart
+          app.command.should == "rake db:migrate"
+        end
+      end
+    end
+  end
+end

data/spec/cf/cli/app/scale_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+module CF
+  module App
+    describe Scale do
+      before do
+        stub_client_and_precondition
+      end
+
+      let(:client) { build(:client) }
+      let(:app) { }
+
+      before do
+        client.stub(:apps).and_return([app])
+      end
+
+      context "when the --disk flag is given" do
+        let(:before_value) { 512 }
+        let(:app) { build(:app, :disk_quota => before_value) }
+
+        subject { cf %W[scale #{app.name} --disk 1G] }
+
+        it "changes the application's disk quota" do
+          app.should_receive(:update!)
+          expect { subject }.to change(app, :disk_quota).from(before_value).to(1024)
+        end
+      end
+
+      context "when the --memory flag is given" do
+        let(:before_value) { 512 }
+        let(:app) { build(:app, :memory => before_value) }
+
+        subject { cf %W[scale #{app.name} --memory 1G] }
+
+        it "changes the application's memory" do
+          app.should_receive(:update!)
+          expect { subject }.to change(app, :memory).from(before_value).to(1024)
+        end
+
+        context "if --restart is true" do
+          it "restarts the application" do
+            app.stub(:update!)
+            app.stub(:started?) { true }
+            mock_invoke :restart, :app => app
+            subject
+          end
+        end
+      end
+
+      context "when the --instances flag is given" do
+        let(:before_value) { 3 }
+        let(:app) { build(:app, :total_instances => before_value) }
+
+        subject { cf %W[scale #{app.name} --instances 5] }
+
+        it "changes the application's number of instances" do
+          app.should_receive(:update!)
+          expect { subject }.to change(app, :total_instances).from(before_value).to(5)
+        end
+      end
+    end
+  end
+end

data/spec/cf/cli/app/start_spec.rb

@@ -0,0 +1,255 @@
+require "spec_helper"
+
+module CF
+  module App
+    describe Start do
+      let(:client) { build(:client) }
+      let(:app) { build(:app, :client => client, :name => "app-name", :guid => "app-id-1") }
+
+      before do
+        stub_client_and_precondition
+        client.stub(:apps).and_return([app])
+
+        app.stub(:host).and_return("some_host")
+        app.stub(:domain).and_return("some_domain")
+        app.stub(:subdomain).and_return("some_subdomain")
+      end
+
+      def execute_start_app
+        cf %W[start #{app.name}]
+      end
+
+      context "with an app that's already started" do
+        let(:app) { build(:app, :state => "STARTED") }
+
+        it "skips starting the application" do
+          app.should_not_receive(:start!)
+          execute_start_app
+        end
+
+        it "says the app is already started" do
+          execute_start_app
+          expect(error_output).to say("Application #{app.name} is already started.")
+        end
+      end
+
+      context "with an app that's NOT already started" do
+        def self.it_says_application_is_starting
+          it "says that it's starting the application" do
+            execute_start_app
+            expect(output).to say("Preparing to start #{app.name}... OK")
+          end
+        end
+
+        def self.it_prints_log_progress
+          it "prints out the log progress" do
+            execute_start_app
+            expect(output).to say(log_text)
+          end
+        end
+
+        def self.it_does_not_print_log_progress
+          it "does not print the log progress" do
+            execute_start_app
+            expect(output).to_not say(log_text)
+          end
+        end
+
+        def self.it_waits_for_application_to_become_healthy
+          describe "waits for application to become healthy" do
+            let(:app) { build(:app, :total_instances => 2) }
+
+            def after_sleep
+              described_class.any_instance.stub(:sleep) { yield }
+            end
+
+            before do
+              app.stub(:instances) do
+                [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN"),
+                  CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN")
+                ]
+              end
+
+              after_sleep do
+                app.stub(:instances) { final_instances }
+              end
+            end
+
+            context "when one instance becomes running" do
+              let(:final_instances) do
+                [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING"),
+                  CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN")
+                ]
+              end
+
+              it "says app is started" do
+                execute_start_app
+                expect(output).to say("Checking status of app '#{app.name}'...")
+                expect(output).to say("1 running, 1 down")
+                expect(output).to say("Push successful!")
+              end
+            end
+
+            context "staging fails" do
+              before do
+                app.stub(:instances) { raise CFoundry::StagingError.new("Failed to stage", 170001, nil, nil) }
+              end
+
+              it "says the app failed to stage" do
+                execute_start_app
+                expect(output).to say("Checking status of app '#{app.name}'...")
+                expect(error_output).to say("Application failed to stage")
+                expect(output).to_not say(/\d (running|down|flapping)/)
+              end
+            end
+
+            context "staging has not completed" do
+              let(:final_instances) do
+                [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING"),
+                  CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
+                ]
+              end
+
+              before do
+                app.stub(:instances) { raise CFoundry::NotStaged.new("Staging is pending", 170002, nil, nil) }
+              end
+
+              it "keeps polling" do
+                execute_start_app
+                expect(output).to say("Checking status of app '#{app.name}'...")
+                expect(output).to say("2 running")
+              end
+            end
+
+            context "when any instance becomes flapping" do
+              before do
+                app.stub(:instances) do
+                  [
+                    CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "FLAPPING"),
+                    CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN"),
+                  ]
+                end
+              end
+
+              it "says app failed to start" do
+                execute_start_app
+                expect(output).to say("Checking status of app '#{app.name}'...")
+                expect(output).to say("1 crashing, 1 down")
+                expect(error_output).to say("Push unsuccessful.")
+              end
+            end
+          end
+        end
+
+        let(:log_url) { nil }
+
+        before do
+          app.stub(:invalidate!)
+          app.stub(:instances) do
+            [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")]
+          end
+
+          app.should_receive(:start!) do |_, &blk|
+            app.state = "STARTED"
+            blk.call(log_url)
+          end
+        end
+
+        context "when progress log url is provided" do
+          let(:log_url) { "http://example.com/my-app-log" }
+          let(:log_text) { "Staging complete!" }
+
+          context "and progress log url is not available immediately" do
+            before do
+              stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+                :status => 404, :body => "")
+            end
+
+            it_says_application_is_starting
+            it_does_not_print_log_progress
+            it_waits_for_application_to_become_healthy
+          end
+
+          context "and progress log url becomes unavailable after some time" do
+            before do
+              stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+                :status => 200, :body => log_text[0...5])
+              stub_request(:get, "#{log_url}&tail&tail_offset=5").to_return(
+                :status => 200, :body => log_text[5..-1])
+              stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
+                :status => 404, :body => "")
+            end
+
+            it_says_application_is_starting
+            it_prints_log_progress
+            it_waits_for_application_to_become_healthy
+          end
+
+          context "and a request times out" do
+            before do
+              stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+                :should_timeout => true)
+              stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+                :status => 200, :body => log_text)
+              stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
+                :status => 404, :body => "")
+            end
+
+            it_says_application_is_starting
+            it_prints_log_progress
+            it_waits_for_application_to_become_healthy
+          end
+        end
+
+        context "when progress log url is not provided" do
+          let(:log_url) { nil }
+          let(:log_text) { "Staging complete!" }
+
+          it_says_application_is_starting
+          it_does_not_print_log_progress
+          it_waits_for_application_to_become_healthy
+        end
+
+        context "when a debug mode is given" do
+          let(:mode) { "some_mode" }
+
+          def execute_start_app_with_mode
+            cf %W[start #{app.name} -d #{mode}]
+          end
+
+          context "and the debug mode is different from the one already set" do
+            it "starts the app with the given debug mode" do
+              expect { execute_start_app_with_mode }.to change { app.debug }.from(nil).to("some_mode")
+            end
+          end
+
+          context "and the debug mode is the same as the one already set" do
+            let(:app) { build(:app, :debug => "in_debug") }
+
+            it "does not set the debug mode to anything different" do
+              app.should_not_receive(:debug).with(anything)
+              execute_start_app_with_mode
+            end
+          end
+
+          context "and the mode is given as 'none'" do
+            let(:app) { build(:app, :debug => "in_debug") }
+            let(:mode) { "none" }
+
+            it "removes the debug mode" do
+              expect { execute_start_app_with_mode }.to change { app.debug }.from("in_debug").to("none")
+            end
+          end
+
+          context "and an empty mode is given" do
+            let(:mode) { "" }
+
+            it "sets debug to 'run'" do
+              expect { execute_start_app_with_mode }.to change { app.debug }.from(nil).to("run")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cf/cli/app/stats_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+module CF
+  module App
+    describe Stats do
+      let(:global) { {} }
+      let(:given) { {} }
+      let(:inputs) { {:app => apps[0]} }
+      let(:apps) { [build(:app)] }
+
+      before do
+        inputs[:app].stub(:stats) do
+          {"0" => {
+            :state => "RUNNING",
+            :stats => {
+              :name => "basic_app",
+              :uris => ["basic_app.p01.rbconsvcs.com"],
+              :host => "172.20.183.93",
+              :port => 61006,
+              :uptime => 3250,
+              :mem_quota => 301989888,
+              :disk_quota => 268435456,
+              :fds_quota => 256,
+              :usage => {
+                :time => "2013-01-04 19:53:39 +0000",
+                :cpu => 0.0019777013519415455,
+                :mem => 31395840,
+                :disk => 15638528
+              }
+            }
+          }
+          }
+        end
+      end
+
+      subject do
+        capture_output { Mothership.new.invoke(:stats, inputs, given, global) }
+      end
+
+      describe "metadata" do
+        let(:command) { Mothership.commands[:stats] }
+
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Display application instance status" }
+          it { expect(Mothership::Help.group(:apps, :info)).to include(subject) }
+        end
+
+        include_examples "inputs must have descriptions"
+
+        describe "arguments" do
+          subject { command.arguments }
+          it "has no arguments" do
+            should eq([:name => :app, :type => :optional, :value => nil])
+          end
+        end
+      end
+
+      it "prints out the stats" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.last).to match /.*0\s+0\.0%\s+29\.9M of 288M\s+14\.9M of 256M.*/
+      end
+    end
+  end
+end

data/spec/cf/cli/domain/help_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+module CF
+  module Domain
+    describe "Help"  do
+      let(:global) { {} }
+      let(:given) { {} }
+
+      subject do
+        capture_output { Mothership.new.invoke(:help, :command => "domains") }
+      end
+
+      it "describes the command" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.first).to match /List domains in a space/
+      end
+
+      it "prints the options" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.any? {|line| line =~ /Options:/ }).to be_true
+
+      end
+
+      context "when the user is not logged in" do
+        before do
+          capture_output { Mothership.new.invoke(:logout) }
+        end
+
+        it "does not require login" do
+          subject
+          stdout.rewind
+          expect(stdout.readlines.first).to_not match /Please log in first to proceed/
+        end
+      end
+    end
+  end
+end