cf 1.1.4 → 2.0.0

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

@@ -7,30 +7,32 @@ module CF
       let(:given) { {} }
       let(:global) { {:color => false, :quiet => true} }
 
-      let(:service_instances) { fake_list(:service_instance, 5) }
-      let(:lucid64) { fake :stack, :name => "lucid64" }
-
-      let(:client) do
-        fake_client(:service_instances => service_instances, :stacks => [lucid64])
-      end
+      let(:service_instances) { Array.new(5) { build(: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" }
 
-      subject(:create) do
+
+      def setup_create
         command = Mothership.commands[:push]
-        create = CF::App::Push.new(command)
-        create.path = path
-        create.input = Mothership::Inputs.new(command, create, inputs, given, global)
-        create.extend CF::App::PushInteractions
-        create
+        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 { create.get_inputs }
+        subject { push_command.get_inputs }
 
         let(:given) do
           {:name => "some-name",
@@ -75,13 +77,13 @@ module CF
         context "when certain inputs are not given" do
           it "asks for the name" do
             given.delete(:name)
-            mock_ask("Name") { "some-name" }
+            should_ask("Name") { "some-name" }
             subject
           end
 
           it "asks for the total instances" do
             given.delete(:instances)
-            mock_ask("Instances", anything) { 1 }
+            should_ask("Instances", anything) { 1 }
             subject
           end
 
@@ -90,7 +92,7 @@ module CF
 
             shared_examples "an app that can have a custom start command" do
               it "asks for a start command with a default as 'none'" do
-                mock_ask("Custom startup command", :default => "none") do
+                should_ask("Custom startup command", :default => "none") do
                   "abcd"
                 end
 
@@ -136,7 +138,7 @@ module CF
 
               context "when there is no Procfile in the app's root" do
                 it "asks for a start command" do
-                  mock_ask("Custom startup command", :default => "none")
+                  should_ask("Custom startup command", :default => "none")
                   subject
                 end
               end
@@ -147,9 +149,9 @@ module CF
             given.delete(:memory)
 
             memory_choices = %w(64M 128M 256M 512M 1G)
-            create.stub(:memory_choices).and_return(memory_choices)
+            push_command.stub(:memory_choices).and_return(memory_choices)
 
-            mock_ask("Memory Limit", anything) do |_, options|
+            should_ask("Memory Limit", anything) do |_, options|
               expect(options[:choices]).to eq memory_choices
               expect(options[:default]).to eq "256M"
               "1G"
@@ -179,7 +181,7 @@ module CF
           client.stub(:current_space).and_return(space)
         end
 
-        subject { create.create_app(attributes) }
+        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
@@ -201,7 +203,7 @@ module CF
           end
 
           it "fails and prints a pretty message" do
-            create.stub(:line).with(anything)
+            push_command.stub(:line).with(anything)
             expect { subject }.to raise_error(
               CF::UserError, "Buildpack must be a public git repository URI.")
           end
@@ -214,10 +216,10 @@ module CF
         let(:domains) { [double(:domain, :name => "foo.com")] }
         let(:hosts) { [app.name] }
 
-        subject { create.map_route(app) }
+        subject { push_command.map_route(app) }
 
         it "asks for a subdomain with 'none' as an option" do
-          mock_ask("Subdomain", anything) do |_, options|
+          should_ask("Subdomain", anything) do |_, options|
             expect(options[:choices]).to eq(hosts + %w(none))
             expect(options[:default]).to eq hosts.first
             hosts.first
@@ -225,7 +227,7 @@ module CF
 
           stub_ask("Domain", anything) { domains.first }
 
-          create.stub(:invoke)
+          push_command.stub(:invoke)
 
           subject
         end
@@ -233,13 +235,13 @@ module CF
         it "asks for a domain with 'none' as an option" do
           stub_ask("Subdomain", anything) { hosts.first }
 
-          mock_ask("Domain", anything) do |_, options|
+          should_ask("Domain", anything) do |_, options|
             expect(options[:choices]).to eq(domains + %w(none))
             expect(options[:default]).to eq domains.first
             domains.first
           end
 
-          create.stub(:invoke)
+          push_command.stub(:invoke)
 
           subject
         end
@@ -248,7 +250,7 @@ module CF
           stub_ask("Subdomain", anything) { hosts.first }
           stub_ask("Domain", anything) { domains.first }
 
-          create.should_receive(:invoke).with(:map,
+          push_command.should_receive(:invoke).with(:map,
             :app => app, :host => hosts.first,
             :domain => domains.first)
 
@@ -258,10 +260,10 @@ module CF
         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
-              mock_ask("Subdomain", anything) { "none" }
+              should_ask("Subdomain", anything) { "none" }
               stub_ask("Domain", anything) { domains.first }
 
-              create.should_receive(:invoke).with(:map,
+              push_command.should_receive(:invoke).with(:map,
                 :host => "", :domain => domains.first, :app => app)
 
               subject
@@ -272,9 +274,9 @@ module CF
         context "when 'none' is given as the domain" do
           it "does not perform any mapping" do
             stub_ask("Subdomain", anything) { "foo" }
-            mock_ask("Domain", anything) { "none" }
+            should_ask("Domain", anything) { "none" }
 
-            create.should_not_receive(:invoke).with(:map, anything)
+            push_command.should_not_receive(:invoke).with(:map, anything)
 
             subject
           end
@@ -282,34 +284,34 @@ module CF
 
         context "when mapping fails" do
           before do
-            mock_ask("Subdomain", anything) { "foo" }
-            mock_ask("Domain", anything) { domains.first }
+            should_ask("Subdomain", anything) { "foo" }
+            should_ask("Domain", anything) { domains.first }
 
-            create.should_receive(:invoke).with(:map,
+            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
-            create.stub(:line)
+            push_command.stub(:line)
 
-            mock_ask("Subdomain", anything) { hosts.first }
-            mock_ask("Domain", anything) { domains.first }
+            should_ask("Subdomain", anything) { hosts.first }
+            should_ask("Domain", anything) { domains.first }
 
-            create.stub(:invoke)
+            push_command.stub(:invoke)
 
             subject
           end
 
           it "reports the failure message" do
-            create.should_receive(:line).with("foo")
-            create.should_receive(:line)
+            push_command.should_receive(:line).with("foo")
+            push_command.should_receive(:line)
 
             stub_ask("Subdomain", anything) { hosts.first }
             stub_ask("Domain", anything) { domains.first }
 
-            create.stub(:invoke)
+            push_command.stub(:invoke)
 
             subject
           end
@@ -317,8 +319,8 @@ module CF
       end
 
       describe "#create_services" do
-        let(:app) { fake(:app) }
-        subject { create.create_services(app) }
+        let(:app) { build(:app, :client => client) }
+        subject { push_command.create_services(app) }
 
         context "when forcing" do
           let(:inputs) { {:force => true} }
@@ -329,7 +331,7 @@ module CF
           end
 
           it "does not create any services" do
-            create.should_not_receive(:invoke).with(:create_service, anything)
+            push_command.should_not_receive(:invoke).with(:create_service, anything)
             subject
           end
         end
@@ -338,24 +340,24 @@ module CF
           let(:inputs) { {:force => false} }
 
           it "does not create the service if asked not to" do
-            mock_ask("Create services for application?", anything) { false }
-            create.should_not_receive(:invoke).with(:create_service, anything)
+            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
-            mock_ask("Create services for application?", anything) { true }
-            create.should_receive(:invoke).with(:create_service, {:app => app}, :plan => :interact).ordered
+            should_ask("Create services for application?", anything) { true }
+            push_command.should_receive(:invoke).with(:create_service, {:app => app}, :plan => :interact).ordered
 
-            mock_ask("Create another service?", :default => false) { true }
-            create.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
 
-            mock_ask("Create another service?", :default => false) { true }
-            create.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
 
-            mock_ask("Create another service?", :default => false) { false }
-            create.should_not_receive(:invoke).with(:create_service, anything).ordered
+            should_ask("Create another service?", :default => false) { false }
+            push_command.should_not_receive(:invoke).with(:create_service, anything).ordered
 
             subject
           end
@@ -365,7 +367,7 @@ module CF
       describe "#bind_services" do
         let(:app) { double(:app).as_null_object }
 
-        subject { create.bind_services(app) }
+        subject { push_command.bind_services(app) }
 
         context "when forcing" do
           let(:global) { {:force => true, :color => false, :quiet => true} }
@@ -376,15 +378,15 @@ module CF
           end
 
           it "does not bind any services" do
-            create.should_not_receive(:invoke).with(:bind_service, anything)
+            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
-            mock_ask("Bind other services to application?", anything) { false }
-            create.should_not_receive(:invoke).with(:bind_service, anything)
+            should_ask("Bind other services to application?", anything) { false }
+            push_command.should_not_receive(:invoke).with(:bind_service, anything)
 
             subject
           end
@@ -393,14 +395,14 @@ module CF
             bind_times = 3
             call_count = 0
 
-            mock_ask("Bind other services to application?", anything) { true }
+            should_ask("Bind other services to application?", anything) { true }
 
-            create.should_receive(:invoke).with(:bind_service, :app => app).exactly(bind_times).times do
+            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
 
-            mock_ask("Bind another service?", anything).exactly(bind_times).times do
+            should_ask("Bind another service?", anything).exactly(bind_times).times do
               call_count < bind_times
             end
 
@@ -411,14 +413,14 @@ module CF
             bind_times = service_instances.size
             call_count = 0
 
-            mock_ask("Bind other services to application?", anything) { true }
+            should_ask("Bind other services to application?", anything) { true }
 
-            create.should_receive(:invoke).with(:bind_service, :app => app).exactly(bind_times).times do
+            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
 
-            mock_ask("Bind another service?", anything).exactly(bind_times-1).times { true }
+            should_ask("Bind another service?", anything).exactly(bind_times-1).times { true }
 
             subject
           end
@@ -435,14 +437,14 @@ module CF
       end
 
       describe "#start_app" do
-        let(:app) { fake(:app) }
-        subject { create.start_app(app) }
+        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
-            create.should_receive(:invoke).with(:start, :app => app)
+            push_command.should_receive(:invoke).with(:start, :app => app)
             subject
           end
         end
@@ -451,7 +453,7 @@ module CF
           let(:inputs) { {:start => false} }
 
           it "invokes the start command" do
-            create.should_not_receive(:invoke).with(:start, anything)
+            push_command.should_not_receive(:invoke).with(:start, anything)
             subject
           end
         end
@@ -472,7 +474,7 @@ module CF
           end
 
           it "asks for the memory with the ceiling taking the memory usage into account" do
-            expect(subject.memory_choices).to eq(%w[64M 128M 256M 512M 1G])
+            expect(push_command.memory_choices).to eq(%w[64M 128M 256M 512M 1G])
           end
         end
 
@@ -480,7 +482,7 @@ module CF
           let(:info) { {:limits => {:memory => 2048}} }
 
           it "asks for the memory with the ceiling as their overall limit" do
-            expect(subject.memory_choices).to eq(%w[64M 128M 256M 512M 1G 2G])
+            expect(push_command.memory_choices).to eq(%w[64M 128M 256M 512M 1G 2G])
           end
         end
       end

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

@@ -7,7 +7,7 @@ module CF
       let(:inputs) { {} }
       let(:given) { {} }
       let(:path) { "somepath" }
-      let(:client) { fake_client }
+      let(:client) { build(:client) }
       let(:push) { CF::App::Push.new(Mothership.commands[:push]) }
 
       before do
@@ -15,27 +15,27 @@ module CF
         CF::CLI.any_instance.stub(:precondition) { nil }
       end
 
-      describe 'metadata' do
+      describe "metadata" do
         let(:command) { Mothership.commands[:push] }
 
-        describe 'command' do
+        describe "command" 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
 
-        include_examples 'inputs must have descriptions'
+        include_examples "inputs must have descriptions"
 
-        describe 'arguments' do
+        describe "arguments" do
           subject { command.arguments }
-          it 'has the correct argument order' do
+          it "has the correct argument order" do
             should eq([{:type => :optional, :value => nil, :name => :name}])
           end
         end
       end
 
-      describe '#sync_app' do
-        let(:app) { fake(:app) }
+      describe "#sync_app" do
+        let(:app) { build(:app, :client => client, :name => "app-name-1") }
 
         before do
           app.stub(:upload)
@@ -47,8 +47,8 @@ module CF
           push.sync_app(app, path)
         end
 
-        shared_examples 'common tests for inputs' do |*args|
-          context 'when the new input is the same as the old' do
+        shared_examples "common tests for inputs" do |*args|
+          context "when the new input is the same as the old" do
             type, input = args
             input ||= type
 
@@ -67,15 +67,15 @@ module CF
           subject
         end
 
-        it 'uploads the app' do
+        it "uploads the app" do
           app.should_receive(:upload).with(path)
           subject
         end
 
-        context 'when no inputs are given' do
+        context "when no inputs are given" do
           let(:inputs) { {} }
 
-          it 'should not update the app' do
+          it "should not update the app" do
             app.should_not_receive(:update!)
             subject
           end
@@ -86,90 +86,93 @@ module CF
           end
         end
 
-        context 'when memory is given' do
+        context "when memory is given" do
           let(:old) { 1024 }
           let(:new) { "2G" }
-          let(:app) { fake(:app, :memory => old) }
+          let(:app) { build(:app, :memory => old) }
           let(:inputs) { {:memory => new} }
 
-          it 'updates the app memory, converting to megabytes' do
+          it "updates the app memory, converting to megabytes" do
             push.stub(:line)
             app.should_receive(:update!)
             expect { subject }.to change { app.memory }.from(old).to(2048)
           end
 
-          it 'outputs the changed memory in human readable sizes' do
+          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!)
             subject
           end
 
-          include_examples 'common tests for inputs', :memory
+          include_examples "common tests for inputs", :memory
         end
 
-        context 'when instances is given' do
+        context "when instances is given" do
           let(:old) { 1 }
           let(:new) { 2 }
-          let(:app) { fake(:app, :total_instances => old) }
+          let(:app) { build(:app, :total_instances => old) }
           let(:inputs) { {:instances => new} }
 
-          it 'updates the app instances' do
+          it "updates the app instances" do
             push.stub(:line)
             app.stub(:update!)
             expect { subject }.to change { app.total_instances }.from(old).to(new)
           end
 
-          it 'outputs the changed instances' do
+          it "outputs the changed instances" do
             push.should_receive(:line).with("Changes:")
             push.should_receive(:line).with("total_instances: 1 -> 2")
             app.stub(:update!)
             subject
           end
 
-          include_examples 'common tests for inputs', :total_instances, :instances
+          include_examples "common tests for inputs", :total_instances, :instances
         end
 
-        context 'when command is given' do
+        context "when command is given" do
           let(:old) { "./start" }
           let(:new) { "./start foo " }
-          let(:app) { fake(:app, :command => old) }
+          let(:app) { build(:app, :command => old) }
           let(:inputs) { {:command => new} }
 
-          it 'updates the app command' do
+          it "updates the app command" do
             push.stub(:line)
             app.should_receive(:update!)
             expect { subject }.to change { app.command }.from("./start").to("./start foo ")
           end
 
-          it 'outputs the changed command in single quotes' do
+          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!)
             subject
           end
 
-          include_examples 'common tests for inputs', :command
+          include_examples "common tests for inputs", :command
         end
 
-        context 'when restart is given' do
+        context "when restart is given" do
           let(:inputs) { {:restart => true, :memory => 4096} }
 
+          before do
+            CF::App::Base.any_instance.stub(:human_mb).and_return(0)
+          end
 
-          context 'when the app is already started' do
-            let(:app) { fake(:app, :state => "STARTED") }
+          context "when the app is already started" do
+            let(:app) { build(:app, :state => "STARTED") }
 
-            it 'invokes the restart command' do
+            it "invokes the restart command" do
               push.stub(:line)
               app.should_receive(:update!)
               push.should_receive(:invoke).with(:restart, :app => app)
               subject
             end
 
-            context 'but there are no changes' do
+            context "but there are no changes" do
               let(:inputs) { {:restart => true} }
 
-              it 'invokes the restart command' do
+              it "invokes the restart command" do
                 push.stub(:line)
                 app.should_not_receive(:update!)
                 push.should_receive(:invoke).with(:restart, :app => app)
@@ -178,10 +181,10 @@ module CF
             end
           end
 
-          context 'when the app is not already started' do
-            let(:app) { fake(:app, :state => "STOPPED") }
+          context "when the app is not already started" do
+            let(:app) { build(:app, :state => "STOPPED") }
 
-            it 'does not invoke the restart command' do
+            it "does not invoke the restart command" do
               push.stub(:line)
               app.should_receive(:update!)
               push.should_not_receive(:invoke).with(:restart, :app => app)
@@ -192,7 +195,7 @@ module CF
 
         context "when buildpack is given" do
           let(:old) { nil }
-          let(:app) { fake(:app, :buildpack => old) }
+          let(:app) { build(:app, :buildpack => old) }
           let(:inputs) { {:buildpack => new} }
 
           context "and it's an invalid URL" do
@@ -229,15 +232,15 @@ module CF
               subject
             end
 
-            include_examples 'common tests for inputs', :buildpack
+            include_examples "common tests for inputs", :buildpack
           end
         end
       end
 
-      describe '#setup_new_app (integration spec!!)' do
-        let(:app) { fake(:app, :guid => nil) }
+      describe "#setup_new_app (integration spec!!)" do
+        let(:app) { build(:app) }
         let(:host) { "" }
-        let(:domain) { fake(:domain, :name => "example.com") }
+        let(:domain) { build(:domain) }
         let(:inputs) do
           {:name => "some-app",
             :instances => 2,
@@ -257,7 +260,7 @@ module CF
           push.setup_new_app(path)
         end
 
-        it 'creates the app' do
+        it "creates the app" do
           app.should_receive(:create!)
           app.should_receive(:upload).with(path)
           push.should_receive(:filter).with(:create_app, app) { app }