trucker-cli 0.0.1

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

@@ -0,0 +1,261 @@
+require "spec_helper"
+require "cf/cli/app/env"
+
+module CF
+  module App
+    describe Env do
+      before do
+        stub_client
+      end
+
+      describe '#set_env' do
+        let(:mock_restart_command) { MockRestartCommand.new }
+        let(:mock_start_command) { MockStartCommand.new }
+        let(:client) { build(:client) }
+        let(:app) { build(:app, client: client, name: 'puppies-r-us-website') }
+        let(:env) { Env.new(Mothership.commands[:set_env]) }
+
+        before do
+          client.stub(:app_by_name).and_return(app)
+          env.input = Mothership::Inputs.new(Mothership.commands[:set_env], env, inputs, {}, {})
+        end
+
+        context 'when name and value are specified' do
+          let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING', value: 'oh_what_a_value'} }
+
+          it 'updates the app with the new environment variable' do
+            expect(app.env['MY_LOVELY_SETTING']).to eq(nil)
+            expect(app).to receive(:update!) do
+              expect(app.env['MY_LOVELY_SETTING']).to eq('oh_what_a_value')
+            end
+
+            capture_output { env.set_env }
+          end
+        end
+
+        context "when the environment variable is specified with the 'VAR=VALUE' format" do
+          let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING=oh_what_a_value'} }
+
+          it 'updates the app with the new environment variable' do
+            expect(app.env['MY_LOVELY_SETTING']).to eq(nil)
+            expect(app).to receive(:update!) do
+              expect(app.env['MY_LOVELY_SETTING']).to eq('oh_what_a_value')
+            end
+
+            capture_output { env.set_env }
+          end
+        end
+
+        describe "environment variable format" do
+          context "when the name has only letters, numbers, and underscores" do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING123', value: "oh_what_a_value"} }
+            it "gets the value from the input[:value]" do
+              expect(app.env['MY_LOVELY_SETTING123']).to eq(nil)
+              app.stub(:update!)
+
+              capture_output { env.set_env }
+              expect(app.env['MY_LOVELY_SETTING123']).to eq("oh_what_a_value")
+            end
+          end
+
+          context "when the name has one equal sign, and is otherwise valid" do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING123=oh_what_a_value'} }
+            it "gets the value by parsing the name" do
+              expect(app.env['MY_LOVELY_SETTING123']).to eq(nil)
+              app.stub(:update!)
+
+              capture_output { env.set_env }
+              expect(app.env['MY_LOVELY_SETTING123']).to eq("oh_what_a_value")
+            end
+
+            context "but provides a value anyway" do
+              let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING123=oh_what_a_value', value: 'my_other_value'} }
+
+              it "gives the user an error" do
+                capture_exceptional_output { env.set_env }
+                expect(error_output).to say "You attempted to specify the value of MY_LOVELY_SETTING123 twice."
+              end
+            end
+          end
+
+          context "when the name has more than one equal sign" do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING123=oh_what_a_value=badbadbad'} }
+            it "gives the user an error" do
+              capture_exceptional_output { env.set_env }
+              expect(error_output).to say "Invalid format: environment variable definition contains too many occurences of '='"
+            end
+          end
+
+          context "when there are characters that are not letters, numbers, or underscores" do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING1?#$=value'} }
+            it "raises an error" do
+              capture_exceptional_output { env.set_env }
+              expect(error_output).to say "Invalid format: environment variable names can only contain alphanumeric characters and underscores"
+            end
+          end
+
+          context "when the name starts with a number" do
+            let(:inputs) { {app: app, name: '1MY_LOVELY_SETTING', value: 'oh_what_a_value'} }
+            it "raises an error" do
+              capture_exceptional_output { env.set_env }
+              expect(error_output).to say "Invalid format: environment variable names cannot start with a number"
+            end
+          end
+        end
+
+        context 'when the app is not started' do
+          context 'with the --restart flag' do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING', value: 'oh_what_a_value', restart: true} }
+            before { Start.stub(:new).and_return(mock_start_command) }
+
+            it 'starts the app' do
+              expect(app).to receive(:update!) do
+                expect(mock_start_command.started_apps).to be_empty
+              end
+
+              capture_output { env.set_env }
+              expect(output).to say "Your app was unstarted. Starting now."
+
+              expect(mock_start_command.started_apps).to eq [app]
+            end
+          end
+
+          context 'without the --restart flag' do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING', value: 'oh_what_a_value', restart: false} }
+
+            before do
+              app.stub(:update!)
+            end
+
+            it "suggests a 'truck push' to the user" do
+              capture_output { env.set_env }
+              expect(output).to say "TIP: Use 'truck push' to ensure your env variable changes take effect."
+            end
+          end
+        end
+
+        context 'when the app is already started' do
+          before do
+            app.stub(:started?) { true }
+            Restart.stub(:new).and_return(mock_restart_command)
+          end
+
+          context 'with the --restart flag' do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING', value: 'oh_what_a_value', restart: true} }
+
+            it 'restarts the app' do
+              expect(app).to receive(:update!) do
+                expect(mock_restart_command.restarted_apps).to be_empty
+              end
+
+              capture_output { env.set_env }
+
+              expect(mock_restart_command.restarted_apps).to eq([app])
+            end
+          end
+
+          context 'without the --restart flag' do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING', value: 'oh_what_a_value', restart: false} }
+            before do
+              app.stub(:update!)
+            end
+
+            it 'does not restart the app but suggests a cf push' do
+              capture_output { env.set_env }
+              expect(mock_restart_command.restarted_apps).to be_empty
+              expect(output).to say "TIP: Use 'truck push' to ensure your env variable changes take effect."
+            end
+          end
+        end
+      end
+
+      describe '#unset_env' do
+        let(:app) { build(:app, client: client, name: 'puppies-r-us-website', environment_json: {'MY_LOVELY_SETTING' => 'oh_so_lovely'}) }
+        let(:client) { build(:client) }
+        let(:env) { Env.new(Mothership.commands[:unset_env]) }
+        let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING'} }
+        let(:mock_start_command) { MockStartCommand.new }
+        let(:mock_restart_command) { MockRestartCommand.new }
+
+        before do
+          env.input = Mothership::Inputs.new(Mothership.commands[:unset_env], env, inputs, {}, {})
+        end
+
+        it 'unsets the environment variable and updates the app' do
+          expect(app.env['MY_LOVELY_SETTING']).to eq('oh_so_lovely')
+          expect(app).to receive(:update!) do
+            expect(app.env['MY_LOVELY_SETTING']).to be_nil
+          end
+
+          capture_output { env.unset_env }
+        end
+
+        context 'when the app is not started' do
+          context 'with the --restart flag' do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING', restart: true} }
+            before { Start.stub(:new).and_return(mock_start_command) }
+
+            it 'starts the app' do
+              expect(app).to receive(:update!) do
+                expect(mock_start_command.started_apps).to be_empty
+              end
+
+              capture_output { env.unset_env }
+              expect(output).to say "Your app was unstarted. Starting now."
+
+              expect(mock_start_command.started_apps).to eq [app]
+            end
+          end
+
+          context 'without the --restart flag' do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING'} }
+
+            before do
+              app.stub(:update!)
+            end
+
+            it "suggests a 'truck push' to the user" do
+              capture_output { env.unset_env }
+              expect(output).to say "TIP: Use 'truck push' to ensure your env variable changes take effect."
+            end
+          end
+        end
+
+        context 'when the app is already started' do
+          before do
+            app.stub(:started?) { true }
+            Restart.stub(:new).and_return(mock_restart_command)
+          end
+
+          context 'with the --restart flag' do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING', restart: true} }
+
+            it 'restarts the app' do
+              expect(app).to receive(:update!) do
+                expect(mock_restart_command.restarted_apps).to be_empty
+              end
+
+              capture_output { env.unset_env }
+
+              expect(mock_restart_command.restarted_apps).to eq([app])
+            end
+          end
+
+          context 'without the --restart flag' do
+            let(:inputs) { {app: app, name: 'MY_LOVELY_SETTING', restart: false} }
+            before do
+              app.stub(:update!)
+            end
+
+            it 'does not restart the app but suggests a cf push' do
+              capture_output { env.unset_env }
+              expect(mock_restart_command.restarted_apps).to be_empty
+              expect(output).to say "TIP: Use 'truck push' to ensure your env variable changes take effect."
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+module CF
+  module App
+    describe Events do
+      let(:global) { {} }
+      let(:given) { {} }
+      let(:inputs) { {:app => apps[0]} }
+      let(:apps) { [build(:app)] }
+
+      before do
+        inputs[:app].stub(:events) do
+          [double("AppEvent", {
+            :instance_guid => "some_guid",
+            :instance_index => 1,
+            :exit_status => -1,
+            :exit_description => "Something very interesting",
+            :timestamp => "2013-05-15 18:52:17 +0000" }),
+          double("AppEvent", {
+            :instance_guid => "some_other_guid",
+            :instance_index => 0,
+            :exit_status => 0,
+            :exit_description => "Something less interesting",
+            :timestamp => "2013-05-15 18:52:15 +0000" })]
+        end
+      end
+
+      subject do
+        capture_output { Mothership.new.invoke(:events, inputs, given, global) }
+      end
+
+      describe "metadata" do
+        let(:command) { Mothership.commands[:events] }
+
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Display application events" }
+          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 arguments that are not needed with a manifest" do
+            should eq([:name => :app, :type => :optional, :value => nil])
+          end
+        end
+      end
+
+      it "prints out progress" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.first).to match /Getting events for #{apps.first.name}/
+      end
+
+      it "prints out headers" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines[2]).to match /time\s+instance\s+index\s+description\s+exit\s+status/
+      end
+
+      it "prints out the events in order" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines[3]).to match /.*2013-05-15 18:52:15 \+0000\s+0\s+Something less interesting\s+Success \(0\).*/
+        stdout.rewind
+        expect(stdout.readlines[4]).to match /.*2013-05-15 18:52:17 \+0000\s+1\s+Something very interesting\s+Failure \(-1\).*/
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+module CF
+  module App
+    describe "Help"  do
+      let(:global) { {} }
+      let(:given) { {} }
+
+      subject do
+        capture_output { Mothership.new.invoke(:help, :command => "app") }
+      end
+
+      it "describes the command" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.first).to match /Show app information/
+      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

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

@@ -0,0 +1,69 @@
+require "spec_helper"
+require "stringio"
+
+module CF
+  module App
+    describe Stats do
+      let(:global) { {:color => false} }
+      let(:inputs) { {:app => apps[0]} }
+      let(:given) { {} }
+      let(:client) { build(:client) }
+      let(:apps) { [build(:app, :client => client, :name => "basic-app-name")] }
+      let(:time) { Time.local(2012, 11, 1, 2, 30) }
+
+      before do
+        client.stub(:apps).and_return(apps)
+        CF::CLI.any_instance.stub(:client).and_return(client)
+        CF::CLI.any_instance.stub(:precondition).and_return(nil)
+
+        client.base.stub(:instances).with(anything) do
+          {
+            "12" => {:state => "STOPPED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"},
+            "1" => {:state => "STOPPED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"},
+            "2" => {:state => "STARTED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"}
+          }
+        end
+      end
+
+      subject do
+        capture_output do
+          Mothership.new.invoke(:instances, inputs, given, global)
+        end
+      end
+
+      describe "metadata" do
+        let(:command) { Mothership.commands[:instances] }
+
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "List an app's instances" }
+          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([{:type => :splat, :value => nil, :name => :apps}])
+          end
+        end
+      end
+
+      it "prints out the instances in the correct order" do
+        subject
+        expect(output).to say("instance #1")
+        expect(output).to say("instance #2")
+        expect(output).to say("instance #12")
+      end
+
+      it "prints out one of the instances correctly" do
+        subject
+        expect(output).to say("instance #2: started")
+        expect(output).to say("  started: #{time.strftime("%F %r")}")
+        expect(output).to say("  debugger: port bar at foo")
+        expect(output).to say("  console: port qux at baz")
+      end
+    end
+  end
+end

data/spec/cf/cli/app/push/create_spec.rb

@@ -0,0 +1,444 @@
+require "spec_helper"
+
+module CF
+  module App
+    describe Create do
+      let(:inputs) { {} }
+      let(:given) { {} }
+      let(:global) { {:color => false, :quiet => true} }
+
+      let(:service_instances) { Array.new(5) { build(:managed_service_instance) } }
+      let(:lucid64) { build(:stack, :name => "lucid64") }
+      let(:client) { build(:client) }
+
+      before do
+        CF::CLI.any_instance.stub(:client).and_return(client)
+        client.stub(:service_instances).and_return(service_instances)
+        client.stub(:stacks).and_return([lucid64])
+      end
+
+      let(:path) { "some-path" }
+
+
+      def setup_create
+        command = Mothership.commands[:push]
+        push_command = CF::App::Push.new(command)
+        push_command.path = path
+        push_command.input = Mothership::Inputs.new(command, push_command, inputs, given, global)
+        push_command.extend CF::App::PushInteractions
+        push_command
+      end
+
+      let(:push_command) { setup_create }
+
+      describe "#get_inputs" do
+        subject { push_command.get_inputs }
+
+        let(:given) do
+          {:name => "some-name",
+            :instances => "1",
+            :plan => "100",
+            :memory => "1G",
+            :command => "ruby main.rb",
+            :buildpack => "git://example.com",
+            :stack => "lucid64"
+          }
+        end
+
+        context "when all the inputs are given" do
+          its([:name]) { should eq "some-name" }
+          its([:total_instances]) { should eq 1 }
+          its([:space]) { should eq client.current_space }
+          its([:command]) { should eq "ruby main.rb" }
+          its([:memory]) { should eq 1024 }
+          its([:stack]) { should eq lucid64 }
+        end
+
+        context "when the command is given" do
+          context "and there is a Procfile in the application's root" do
+            before do
+              FakeFS.activate!
+              Dir.mkdir(path)
+
+              File.open("#{path}/Procfile", "w") do |file|
+                file.write("this is a procfile")
+              end
+            end
+
+            after do
+              FakeFS.deactivate!
+              FakeFS::FileSystem.clear
+            end
+
+            its([:command]) { should eq "ruby main.rb" }
+          end
+        end
+
+        context "when certain inputs are not given" do
+          it "asks for the name" do
+            given.delete(:name)
+            should_ask("Name") { "some-name" }
+            subject
+          end
+
+          it "asks for the total instances" do
+            given.delete(:instances)
+            should_ask("Instances", anything) { 1 }
+            subject
+          end
+
+          context "when the command is not given" do
+            before { given.delete(:command) }
+
+            it "defaults to nil" do
+              expect(subject[:command]).to be_nil
+            end
+
+            describe "getting the start command" do
+              before do
+                FakeFS.activate!
+                Dir.mkdir(path)
+              end
+
+              after do
+                FakeFS.deactivate!
+                FakeFS::FileSystem.clear
+              end
+
+              context "when there is a Procfile in the app's root" do
+                before do
+                  File.open("#{path}/Procfile", "w") do |file|
+                    file.write("this is a procfile")
+                  end
+                end
+
+                it "does not ask for a start command" do
+                  dont_allow_ask("Startup command")
+                  subject
+                end
+              end
+
+              context "when there is no Procfile in the app's root" do
+                it "is nil" do
+                  expect(subject[:command]).to be_nil
+                end
+              end
+            end
+          end
+
+          it "asks for the memory" do
+            given.delete(:memory)
+
+            memory_choices = %w(64M 128M 256M 512M 1G)
+            push_command.stub(:memory_choices).and_return(memory_choices)
+
+            should_ask("Memory Limit", anything) do |_, options|
+              expect(options[:choices]).to eq memory_choices
+              expect(options[:default]).to eq "256M"
+              "1G"
+            end
+
+            subject
+          end
+        end
+      end
+
+      describe "#create_app" do
+        before { dont_allow_ask }
+
+        let(:app) { double(:app, :name => "some-app").as_null_object }
+        let(:space) { double(:space, :name => "some-space") }
+
+        let(:attributes) do
+          {:name => "some-app",
+            :total_instances => 2,
+            :memory => 1024,
+            :buildpack => "git://example.com"
+          }
+        end
+
+        before do
+          client.stub(:app).and_return(app)
+          client.stub(:current_space).and_return(space)
+        end
+
+        subject { push_command.create_app(attributes) }
+
+        context "when the user does not have permission to create apps" do
+          it "fails with a friendly message" do
+            app.stub(:create!).and_raise(CFoundry::NotAuthorized, "foo")
+
+            expect { subject }.to raise_error(
+              CF::UserError,
+              "You need the Project Developer role in some-space to push.")
+          end
+        end
+
+        context "with an invalid buildpack" do
+          before do
+            app.stub(:create!) do
+              raise CFoundry::MessageParseError.new(
+                "Request invalid due to parse error: Field: buildpack, Error: Value git@github.com:cloudfoundry/heroku-buildpack-ruby.git doesn't match regexp String /GIT_URL_REGEX/",
+                1001)
+            end
+          end
+
+          it "fails and prints a pretty message" do
+            push_command.stub(:line).with(anything)
+            expect { subject }.to raise_error(
+              CF::UserError, "Buildpack must be a public git repository URI.")
+          end
+        end
+      end
+
+      describe "#map_url" do
+        let(:app) { double(:app, :space => space, name: "app-name").as_null_object }
+        let(:space) { double(:space, :domains => domains) }
+        let(:domains) { [double(:domain, :name => "foo.com")] }
+        let(:hosts) { [app.name] }
+
+        subject { push_command.map_route(app) }
+
+        it "asks for a subdomain with 'none' as an option" do
+          should_ask("Subdomain", anything) do |_, options|
+            expect(options[:choices]).to eq(hosts + %w(none))
+            expect(options[:default]).to eq hosts.first
+            hosts.first
+          end
+
+          stub_ask("Domain", anything) { domains.first }
+
+          push_command.stub(:invoke)
+
+          subject
+        end
+
+        it "asks for a domain with 'none' as an option" do
+          stub_ask("Subdomain", anything) { hosts.first }
+
+          should_ask("Domain", anything) do |_, options|
+            expect(options[:choices]).to eq(domains + %w(none))
+            expect(options[:default]).to eq domains.first
+            domains.first
+          end
+
+          push_command.stub(:invoke)
+
+          subject
+        end
+
+        it "maps the host and domain after both are given" do
+          stub_ask("Subdomain", anything) { hosts.first }
+          stub_ask("Domain", anything) { domains.first }
+
+          push_command.should_receive(:invoke).with(:map,
+            :app => app, :host => hosts.first,
+            :domain => domains.first)
+
+          subject
+        end
+
+        context "when 'none' is given as the host" do
+          context "and a domain is provided afterwards" do
+            it "invokes 'map' with an empty host" do
+              should_ask("Subdomain", anything) { "none" }
+              stub_ask("Domain", anything) { domains.first }
+
+              push_command.should_receive(:invoke).with(:map,
+                :host => "", :domain => domains.first, :app => app)
+
+              subject
+            end
+          end
+        end
+
+        context "when 'none' is given as the domain" do
+          it "does not perform any mapping" do
+            stub_ask("Subdomain", anything) { "foo" }
+            should_ask("Domain", anything) { "none" }
+
+            push_command.should_not_receive(:invoke).with(:map, anything)
+
+            subject
+          end
+        end
+
+        context "when mapping fails" do
+          before do
+            should_ask("Subdomain", anything) { "foo" }
+            should_ask("Domain", anything) { domains.first }
+
+            push_command.should_receive(:invoke).with(:map,
+              :host => "foo", :domain => domains.first, :app => app) do
+              raise CFoundry::RouteHostTaken.new("foo", 1234)
+            end
+          end
+
+          it "asks again" do
+            push_command.stub(:line)
+
+            should_ask("Subdomain", anything) { hosts.first }
+            should_ask("Domain", anything) { domains.first }
+
+            push_command.stub(:invoke)
+
+            subject
+          end
+
+          it "reports the failure message" do
+            push_command.should_receive(:line).with("foo")
+            push_command.should_receive(:line)
+
+            stub_ask("Subdomain", anything) { hosts.first }
+            stub_ask("Domain", anything) { domains.first }
+
+            push_command.stub(:invoke)
+
+            subject
+          end
+        end
+      end
+
+      describe "#create_services" do
+        let(:app) { build(:app, :client => client) }
+        subject { push_command.create_services(app) }
+
+        context "when forcing" do
+          let(:inputs) { {:force => true} }
+
+          it "does not ask to create any services" do
+            dont_allow_ask("Create services for application?", anything)
+            subject
+          end
+
+          it "does not create any services" do
+            push_command.should_not_receive(:invoke).with(:create_service, anything)
+            subject
+          end
+        end
+
+        context "when not forcing" do
+          let(:inputs) { {:force => false} }
+
+          it "does not create the service if asked not to" do
+            should_ask("Create services for application?", anything) { false }
+            push_command.should_not_receive(:invoke).with(:create_service, anything)
+
+            subject
+          end
+
+          it "asks again to create a service" do
+            should_ask("Create services for application?", anything) { true }
+            push_command.should_receive(:invoke).with(:create_service, {:app => app}, :plan => :interact).ordered
+
+            should_ask("Create another service?", :default => false) { true }
+            push_command.should_receive(:invoke).with(:create_service, {:app => app}, :plan => :interact).ordered
+
+            should_ask("Create another service?", :default => false) { true }
+            push_command.should_receive(:invoke).with(:create_service, {:app => app}, :plan => :interact).ordered
+
+            should_ask("Create another service?", :default => false) { false }
+            push_command.should_not_receive(:invoke).with(:create_service, anything).ordered
+
+            subject
+          end
+        end
+      end
+
+      describe "#bind_services" do
+        let(:app) { double(:app).as_null_object }
+
+        subject { push_command.bind_services(app) }
+
+        context "when forcing" do
+          let(:global) { {:force => true, :color => false, :quiet => true} }
+
+          it "does not ask to bind any services" do
+            dont_allow_ask("Bind other services to application?", anything)
+            subject
+          end
+
+          it "does not bind any services" do
+            push_command.should_not_receive(:invoke).with(:bind_service, anything)
+            subject
+          end
+        end
+
+        context "when not forcing" do
+          it "does not bind the service if asked not to" do
+            should_ask("Bind other services to application?", anything) { false }
+            push_command.should_not_receive(:invoke).with(:bind_service, anything)
+
+            subject
+          end
+
+          it "asks again to bind a service" do
+            bind_times = 3
+            call_count = 0
+
+            should_ask("Bind other services to application?", anything) { true }
+
+            push_command.should_receive(:invoke).with(:bind_service, :app => app).exactly(bind_times).times do
+              call_count += 1
+              app.stub(:services).and_return(service_instances.first(call_count))
+            end
+
+            should_ask("Bind another service?", anything).exactly(bind_times).times do
+              call_count < bind_times
+            end
+
+            subject
+          end
+
+          it "stops asking if there are no more services to bind" do
+            bind_times = service_instances.size
+            call_count = 0
+
+            should_ask("Bind other services to application?", anything) { true }
+
+            push_command.should_receive(:invoke).with(:bind_service, :app => app).exactly(bind_times).times do
+              call_count += 1
+              app.stub(:services).and_return(service_instances.first(call_count))
+            end
+
+            should_ask("Bind another service?", anything).exactly(bind_times-1).times { true }
+
+            subject
+          end
+
+          context "when there are no services" do
+            let(:service_instances) { [] }
+
+            it "does not ask to bind anything" do
+              dont_allow_ask
+              subject
+            end
+          end
+        end
+      end
+
+      describe "#start_app" do
+        let(:app) { build(:app, :client => client) }
+        subject { push_command.start_app(app) }
+
+        context "when the start flag is provided" do
+          let(:inputs) { {:start => true} }
+
+          it "invokes the start command" do
+            push_command.should_receive(:invoke).with(:start, :app => app)
+            subject
+          end
+        end
+
+        context "when the start flag is not provided" do
+          let(:inputs) { {:start => false} }
+
+          it "invokes the start command" do
+            push_command.should_not_receive(:invoke).with(:start, anything)
+            subject
+          end
+        end
+      end
+    end
+  end
+end