cf 0.1.5 → 0.6.0.rc1

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

@@ -0,0 +1,75 @@
+require "spec_helper"
+require "webmock/rspec"
+
+command CF::App::Scale do
+  let(:client) { fake_client :apps => [app] }
+
+  context "when the --disk flag is given" do
+    let(:before_value) { 512 }
+    let(:app) { fake :app, :disk_quota => before_value }
+
+    subject { cf %W[scale #{app.name} --disk 1G] }
+
+    it "changes the application's disk quota" do
+      mock(app).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) { fake :app, :memory => before_value }
+
+    subject { cf %W[scale #{app.name} --memory 1G] }
+
+    it "changes the application's memory" do
+      mock(app).update!
+      expect { subject }.to change(app, :memory).from(before_value).to(1024)
+    end
+
+    context "if --restart is true" do
+      it "restarts the application" do
+        stub(app).update!
+        stub(app).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) { fake :app, :total_instances => before_value }
+
+    subject { cf %W[scale #{app.name} --instances 5] }
+
+    it "changes the application's number of instances" do
+      mock(app).update!
+      expect { subject }.to change(app, :total_instances).from(before_value).to(5)
+    end
+  end
+
+  context "when the --plan flag is given" do
+    context "when the plan name begins with a 'p'" do
+      let(:app) { fake :app, :production => false }
+
+      subject { cf %W[scale #{app.name} --plan P100] }
+
+      it "changes the application's 'production' flag to true" do
+        mock(app).update!
+        expect { subject }.to change(app, :production).from(false).to(true)
+      end
+    end
+
+    context "when the plan name does not begin with a 'p'" do
+      let(:app) { fake :app, :production => true }
+
+      subject { cf %W[scale #{app.name} --plan D100] }
+
+      it "changes the application's 'production' flag to false" do
+        mock(app).update!
+        expect { subject }.to change(app, :production).from(true).to(false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+require "spec_helper"
+require "webmock/rspec"
+
+command CF::App::Start do
+  let(:client) { fake_client :apps => [app] }
+  let(:app) { fake :app }
+
+  subject { cf %W[start #{app.name}] }
+
+  context "with an app that's already started" do
+    let(:app) { fake :app, :state => "STARTED" }
+
+    it "skips starting the application" do
+      dont_allow(app).start!
+      subject
+    end
+
+    it "says the app is already started" do
+      subject
+      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
+        subject
+        expect(output).to say("Starting #{app.name}... OK")
+      end
+    end
+
+    def self.it_prints_log_progress
+      it "prints out the log progress" do
+        subject
+        expect(output).to say(log_text)
+      end
+    end
+
+    def self.it_does_not_print_log_progress
+      it "does not print the log progress" do
+        subject
+        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) { fake :app, :total_instances => 2 }
+
+        def after_sleep
+          any_instance_of described_class do |cli|
+            stub(cli).sleep { yield }
+          end
+        end
+
+        before do
+          stub(app).instances do
+            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN"),
+              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
+            ]
+          end
+
+          after_sleep do
+            stub(app).instances { final_instances }
+          end
+        end
+
+        context "when all instances become 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 => "RUNNING")
+            ]
+          end
+
+          it "says app is started" do
+            subject
+            expect(output).to say("Checking #{app.name}...")
+            expect(output).to say("1 running, 1 down")
+            expect(output).to say("2 running")
+          end
+        end
+
+        context "when any instance becomes flapping" do
+          let(:final_instances) do
+            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "FLAPPING"),
+              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "STARTING")
+            ]
+          end
+
+          it "says app failed to start" do
+            subject
+            expect(output).to say("Checking #{app.name}...")
+            expect(output).to say("1 running, 1 down")
+            expect(output).to say("1 starting, 1 flapping")
+            expect(error_output).to say("Application failed to start")
+          end
+        end
+      end
+    end
+
+    let(:log_url) { nil }
+
+    before do
+      stub(app).invalidate!
+      stub(app).instances do
+        [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING") ]
+      end
+
+      stub(app).start!(true) 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) { "foo" }
+
+      subject { cf %W[start #{app.name} -d #{mode}] }
+
+      context "and the debug mode is different from the one already set" do
+        it "starts the app with the given debug mode" do
+          expect { subject }.to change { app.debug }.from(nil).to("foo")
+        end
+      end
+
+      context "and the debug mode is the same as the one already set" do
+        let(:app) { fake :app, :debug => "foo" }
+
+        it "does not set the debug mode to anything different" do
+          dont_allow(app).debug = anything
+          subject
+        end
+      end
+
+      context "and the mode is given as 'none'" do
+        let(:app) { fake :app, :debug => "foo" }
+        let(:mode) { "none" }
+
+        it "removes the debug mode" do
+          expect { subject }.to change { app.debug }.from("foo").to(nil)
+        end
+      end
+
+      context "and an empty mode is given" do
+        let(:mode) { "" }
+
+        it "sets debug to 'run'" do
+          expect { subject }.to change { app.debug }.from(nil).to("run")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'stringio'
+
+describe CF::App::Stats do
+  let(:global) { { :color => false } }
+  let(:inputs) { { :app => apps[0] } }
+  let(:given) { {} }
+  let(:client) { fake_client(:apps => apps) }
+  let(:apps) { [fake(:app, :name => "basic_app")] }
+
+  before do
+    any_instance_of(CF::CLI) do |cli|
+      stub(cli).client { client }
+      stub(cli).precondition { nil }
+    end
+    stub(inputs[:app]).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=>:normal, :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

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

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+command CF::Domain::Map do
+  let(:client) do
+    fake_client(
+      :current_organization => organization,
+      :current_space => space,
+      :spaces => [space],
+      :organizations => [organization],
+      :domains => domains)
+  end
+
+  let(:organization) { fake(:organization) }
+  let(:space) { fake(:space, :organization => organization) }
+  let(:domain) { fake(:domain, :name => domain_name) }
+  let(:domain_name) { "some.domain.com" }
+  let(:domains) { [domain] }
+
+  shared_examples_for "binding a domain to a space" do
+    it "adds the domain to the space's organization" do
+      mock(space.organization).add_domain(domain)
+      stub(space).add_domain(domain)
+      subject
+    end
+
+    it 'adds the domain to the space' do
+      stub(space.organization).add_domain(domain)
+      mock(space).add_domain(domain)
+      subject
+    end
+  end
+
+  shared_examples_for "binding a domain to an organization" do
+    it 'does NOT add the domain to a space' do
+      any_instance_of(space.class) do |space|
+        dont_allow(space).add_domain(domain)
+      end
+    end
+
+    it 'adds the domain to the organization' do
+      mock(organization).add_domain(domain)
+      subject
+    end
+  end
+
+  shared_examples_for "mapping a domain to a space" do
+    context "when the domain does NOT exist" do
+      let(:domains) { [] }
+
+      before do
+        stub(client).domain { domain }
+        stub(domain).create!
+        stub(space.organization).add_domain(domain)
+        stub(space).add_domain(domain)
+      end
+
+      it 'creates the domain' do
+        mock(domain).create!
+        subject
+        expect(domain.name).to eq domain_name
+        expect(domain.owning_organization).to eq organization
+      end
+
+      include_examples "binding a domain to a space"
+    end
+
+    context "when the domain already exists" do
+      include_examples "binding a domain to a space"
+    end
+  end
+
+  context 'when a domain and a space are passed' do
+    subject { cf %W[map-domain #{domain.name} --space #{space.name}] }
+
+    include_examples "mapping a domain to a space"
+  end
+
+  context 'when a domain and an organization are passed' do
+    subject { cf %W[map-domain #{domain.name} --organization #{organization.name}] }
+
+    context "and the domain does NOT exist" do
+      let(:domains) { [] }
+
+      before do
+        stub(client).domain { domain }
+        stub(domain).create!
+        stub(organization).add_domain(domain)
+      end
+
+      include_examples "binding a domain to an organization"
+
+      it 'creates the domain' do
+        mock(domain).create!
+        subject
+        expect(domain.name).to eq domain_name
+      end
+
+      context "and the --shared option is passed" do
+        subject { cf %W[map-domain #{domain.name} --organization #{organization.name} --shared] }
+
+        it 'adds the domain to the organization' do
+          mock(organization).add_domain(domain)
+          subject
+        end
+
+        it "does not add the domain to a specific organization" do
+          stub(domain).create!
+          subject
+          expect(domain.owning_organization).to be_nil
+        end
+      end
+    end
+
+    context "and the domain already exists" do
+      include_examples "binding a domain to an organization"
+    end
+  end
+
+  context 'when a domain, organization, and space is passed' do
+    subject { cf %W[map-domain #{domain.name} --space #{space.name} --organization #{organization.name}] }
+
+    include_examples "mapping a domain to a space"
+  end
+
+  context 'when only a domain is passed' do
+    subject { cf %W[map-domain #{domain.name}] }
+
+    include_examples "mapping a domain to a space"
+  end
+end