trucker-cli 0.0.1

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+
+module CF::App
+  class PushInteractionClass
+    include PushInteractions
+    def ask(question, options); end
+  end
+
+  describe PushInteractionClass do
+    let(:domains) { [build(:domain), build(:domain)]}
+    let(:app){ build(:app, :space => build(:space, :domains => domains)) }
+
+    describe "#ask_domain" do
+      it "uses all space domains as choices with optional none" do
+        subject.should_receive(:ask).with("Domain", anything) do |_, options|
+          expect(options[:choices]).to eq(domains + ["none"])
+        end
+
+        subject.ask_domain(app)
+      end
+
+      it "has always a default value" do
+        subject.should_receive(:ask).with("Domain", anything) do |_, options|
+          expect(options[:default]).to eq domains.first
+        end
+
+        subject.ask_domain(app)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,332 @@
+require "spec_helper"
+
+module CF
+  module App
+    describe Push do
+      let(:global) { {:color => false, :quiet => true} }
+      let(:inputs) { {} }
+      let(:given) { {} }
+      let(:path) { "/somepath" }
+      let(:client) { build(:client) }
+      let(:push) { CF::App::Push.new(Mothership.commands[:push]) }
+
+      before do
+        CF::CLI.any_instance.stub(:client) { client }
+        CF::CLI.any_instance.stub(:precondition) { nil }
+      end
+
+      describe "metadata" do
+        let(:command) { Mothership.commands[:push] }
+
+        describe "has the correct information" do
+          subject { command }
+          its(:description) { should eq "Push an application, syncing changes if it exists" }
+          it { expect(Mothership::Help.group(:apps, :manage)).to include(subject) }
+        end
+
+        it_behaves_like "inputs must have descriptions"
+      end
+
+      describe "#push" do
+        let(:app) { build(:app, :client => client, :name => "app-name-1") }
+
+        before do
+          app.stub(:upload)
+          app.changes = {}
+          push.stub(:warn)
+          client.stub(:app_by_name).and_return(app)
+        end
+
+        let(:inputs) { {} }
+
+        shared_examples_for "an input" do |*args|
+          context "when the new input is the same as the old" do
+            type, input = args
+            input ||= type
+
+            let(:inputs) { {input => old} }
+
+            it "does not update the app's #{type}" do
+              push.should_not_receive(:line)
+              app.should_not_receive(:update!)
+              expect do
+                push.input = Mothership::Inputs.new(Mothership.commands[:push], push, inputs, {}, global)
+                push.push
+              end.not_to change { app.send(type) }
+            end
+          end
+        end
+
+        it "triggers the :push_app filter" do
+          push.should_receive(:filter).with(:push_app, app) { app }
+          push.input = Mothership::Inputs.new(Mothership.commands[:push], push, inputs, {}, global)
+          push.push
+        end
+
+        describe 'uploading the app from the correct path' do
+          context 'when the user does not specify a path' do
+            it 'uploads the app' do
+              app.should_receive(:upload).with(File.expand_path('.'))
+              push.input = Mothership::Inputs.new(Mothership.commands[:push], push, {}, {}, global)
+              push.push
+            end
+          end
+
+          context 'when the user specifies a path' do
+            it 'uploads the app' do
+              app.should_receive(:upload).with(path)
+              push.input = Mothership::Inputs.new(Mothership.commands[:push], push, {:path => path}, {}, global)
+              push.push
+            end
+          end
+        end
+
+        context "when the app is stopped" do
+          before do
+            app.stub(:started?).and_return(false)
+          end
+
+          it "warns the user" do
+            push.should_receive(:warn).with("\n#{app.name} is currently stopped, start it with 'truck start'")
+            push.input = Mothership::Inputs.new(nil, push, {:path => path}, {}, global)
+            push.push
+          end
+        end
+
+        context "when no inputs other than path are given" do
+          let(:inputs) { {:path => ""} }
+
+          it "should not update the app" do
+            app.should_not_receive(:update!)
+            push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+            push.push
+          end
+
+          it "should not set memory on the app" do
+            app.should_not_receive(:memory=)
+            push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+            push.push
+          end
+        end
+
+        context "when memory is given" do
+          let(:old) { 1024 }
+          let(:new) { "2G" }
+          let(:app) { build(:app, :memory => old) }
+          let(:inputs) { {:path => path, :memory => new} }
+
+          it "updates the app memory, converting to megabytes" do
+            push.stub(:line)
+            app.should_receive(:update!)
+            expect { push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+            push.push }.to change { app.memory }.from(old).to(2048)
+          end
+
+          it "outputs the changed memory in human readable sizes" do
+            push.should_receive(:line).with("Changes:")
+            push.should_receive(:line).with("memory: 1G -> 2G")
+            app.stub(:update!)
+            push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+            push.push
+          end
+
+          it_behaves_like "an input", :memory
+        end
+
+        context "when instances is given" do
+          let(:old) { 1 }
+          let(:new) { 2 }
+          let(:app) { build(:app, :total_instances => old) }
+          let(:inputs) { {:path => path, :instances => new} }
+
+          it "updates the app instances" do
+            push.stub(:line)
+            app.stub(:update!)
+            expect do
+              push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+              push.push
+            end.to change { app.total_instances }.from(old).to(new)
+          end
+
+          it "outputs the changed instances" do
+            push.should_receive(:line).with("Changes:")
+            push.should_receive(:line).with("total_instances: 1 -> 2")
+            app.stub(:update!)
+            push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+            push.push
+          end
+
+          it_behaves_like "an input", :total_instances, :instances
+        end
+
+        context "when command is given" do
+          let(:old) { "./start" }
+          let(:new) { "./start foo " }
+          let(:app) { build(:app, :command => old) }
+          let(:inputs) { {:path => path, :command => new} }
+
+          it "updates the app command" do
+            push.stub(:line)
+            app.should_receive(:update!)
+            expect do
+              push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+              push.push
+            end.to change { app.command }.from("./start").to("./start foo ")
+          end
+
+          it "outputs the changed command in single quotes" do
+            push.should_receive(:line).with("Changes:")
+            push.should_receive(:line).with("command: './start' -> './start foo '")
+            app.stub(:update!)
+            push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+            push.push
+          end
+
+          it_behaves_like "an input", :command
+        end
+
+        context "when restart is given" do
+          let(:inputs) { {:path => path, :restart => true, :memory => 4096} }
+
+          let(:mock_restart_command) do
+            MockRestartCommand.new
+          end
+
+          before do
+            CF::App::Base.any_instance.stub(:human_mb).and_return(0)
+            Restart.stub(:new).and_return(mock_restart_command)
+          end
+
+          context "when the app is already started" do
+            let(:app) { build(:app, :state => "STARTED") }
+
+            it "restarts the app after updating" do
+              push.stub(:line)
+              app.should_receive(:update!) do
+                expect(mock_restart_command.restarted_apps).to be_empty
+              end
+
+              push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+              push.push
+
+              expect(mock_restart_command.restarted_apps).to eq [app]
+            end
+
+            context "but there are no changes" do
+              let(:inputs) { {:path => path, :restart => true} }
+
+              it "restarts the app without updating" do
+                push.stub(:line)
+                app.should_not_receive(:update!)
+
+                push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+                push.push
+
+                mock_restart_command.restarted_apps.should == [app]
+              end
+            end
+          end
+
+          context "when the app is not already started" do
+            let(:app) { build(:app, :state => "STOPPED") }
+
+            it "updates the app without restarting" do
+              push.stub(:line)
+              app.should_receive(:update!)
+
+              push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+              push.push
+
+              expect(mock_restart_command.restarted_apps).to be_empty
+            end
+          end
+        end
+
+        context "when buildpack is given" do
+          let(:old) { nil }
+          let(:app) { build(:app, :buildpack => old) }
+          let(:inputs) { {:path => path, :buildpack => new} }
+
+          context "and it's an invalid URL" do
+            let(:new) { "git@github.com:foo/bar.git" }
+
+            before do
+              app.stub(:update!) 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.stub(:line)
+              expect do
+                push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+                push.push
+              end.to raise_error(
+                                 CF::UserError, "Buildpack must be a public git repository URI.")
+            end
+          end
+
+          context "and it's a valid URL" do
+            let(:new) { "git://github.com/foo/bar.git" }
+
+            it "updates the app's buildpack" do
+              push.stub(:line)
+              app.should_receive(:update!)
+              expect do
+                push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+                push.push
+              end.to change { app.buildpack }.from(old).to(new)
+            end
+
+            it "outputs the changed buildpack with single quotes" do
+              push.should_receive(:line).with("Changes:")
+              push.should_receive(:line).with("buildpack: '' -> '#{new}'")
+              app.stub(:update!)
+              push.input = Mothership::Inputs.new(nil, push, inputs, {}, global)
+              push.push
+            end
+
+            it_behaves_like "an input", :buildpack
+          end
+        end
+      end
+
+      describe "#setup_new_app (integration spec!!)" do
+        let(:app) { build(:app) }
+        let(:host) { "" }
+        let(:domain) { build(:domain) }
+        let(:inputs) do
+          {:name => "some-app",
+           :instances => 2,
+           :memory => 1024,
+           :host => host,
+           :domain => domain
+          }
+        end
+        let(:global) { {:quiet => true, :color => false, :force => true} }
+
+        before do
+          client.stub(:app) { app }
+        end
+
+        subject do
+          push.input = Mothership::Inputs.new(Mothership.commands[:push], push, inputs, global, global)
+          push.setup_new_app(path)
+        end
+
+        it "creates the app" do
+          app.should_receive(:create!)
+          app.should_receive(:upload).with(path)
+
+          push.should_receive(:filter).with(:create_app, app) { app }
+          push.should_receive(:filter).with(:push_app, app) { app }
+          push.should_receive(:invoke).with(:map, :app => app, :host => host, :domain => domain)
+          push.should_receive(:invoke).with(:start, :app => app)
+          subject
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe CF::App::Rename do
+  let(:global) { { :color => false, :quiet => true } }
+  let(:inputs) { {} }
+  let(:given) { {} }
+  let(:client) { build(:client) }
+  let(:app) {}
+  let(:new_name) { "some-new-name" }
+
+  before do
+    CF::CLI.any_instance.stub(:client).and_return(client)
+    CF::CLI.any_instance.stub(:precondition).and_return(nil)
+  end
+
+  subject { Mothership.new.invoke(:rename, inputs, given, global) }
+
+  describe "metadata" do
+    let(:command) { Mothership.commands[:rename] }
+
+    describe "command" do
+      subject { command }
+      its(:description) { should eq "Rename an application" }
+      it { expect(Mothership::Help.group(:apps, :manage)).to include(subject) }
+    end
+
+    include_examples "inputs must have descriptions"
+
+    describe "arguments" do
+      subject { command.arguments }
+      it "has the correct argument order" do
+        should eq([
+          { :type => :optional, :value => nil, :name => :app },
+          { :type => :optional, :value => nil, :name => :name }
+        ])
+      end
+    end
+  end
+
+  context "when there are no apps" do
+    before do
+      client.stub(:apps).and_return([])
+    end
+
+    context "and an app is given" do
+      let(:given) { { :app => "some-app" } }
+      it { expect { subject }.to raise_error(CF::UserError, "Unknown app 'some-app'.") }
+    end
+
+    context "and an app is not given" do
+      it { expect { subject }.to raise_error(CF::UserError, "No applications.") }
+    end
+  end
+
+  context "when there are apps" do
+    let(:apps) { [build(:app, :client => client), build(:app, :client => client)] }
+    let(:renamed_app) { apps.first }
+
+    before do
+      client.stub(:apps).and_return(apps)
+    end
+
+    context "when the defaults are used" do
+      it "asks for the app and new name and renames" do
+        should_ask("Rename which application?", anything) { renamed_app }
+        should_ask("New name") { new_name }
+        renamed_app.should_receive(:name=).with(new_name)
+        renamed_app.should_receive(:update!)
+        subject
+      end
+    end
+
+    context "when no name is provided, but a app is" do
+      let(:given) { { :app => renamed_app.name } }
+
+      it "asks for the new name and renames" do
+        dont_allow_ask("Rename which application?", anything)
+        should_ask("New name") { new_name }
+        renamed_app.should_receive(:name=).with(new_name)
+        renamed_app.should_receive(:update!)
+        subject
+      end
+    end
+
+    context "when an app is provided and a name" do
+      let(:inputs) { { :app => renamed_app, :name => new_name } }
+
+      it "renames the app" do
+        renamed_app.should_receive(:update!)
+        subject
+      end
+
+      it "displays the progress" do
+        mock_with_progress("Renaming to #{new_name}")
+        renamed_app.should_receive(:update!)
+
+        subject
+      end
+
+      context "and the name already exists" do
+        it "fails" do
+          renamed_app.should_receive(:update!) { raise CFoundry::AppNameTaken.new("Bad Name", 404) }
+          expect { subject }.to raise_error(CFoundry::AppNameTaken)
+        end
+      end
+    end
+  end
+end