cf 1.1.3.rc1 → 1.1.4

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

@@ -1,68 +1,67 @@
-require 'spec_helper'
-require 'stringio'
+require "spec_helper"
 
-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")] }
+module CF
+  module App
+    describe 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
+      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
+          }
+        end
+      end
 
-  subject do
-    capture_output { Mothership.new.invoke(:stats, inputs, given, global) }
-  end
+      subject do
+        capture_output { Mothership.new.invoke(:stats, inputs, given, global) }
+      end
 
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:stats] }
+      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
+        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'
+        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])
+        describe 'arguments' do
+          subject { command.arguments }
+          it 'has no arguments' do
+            should eq([:name => :app, :type => :optional, :value => nil])
+          end
+        end
       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.*/
+      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/map_spec.rb

@@ -1,134 +1,137 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe CF::Domain::Map do
-  before do
-    stub_client_and_precondition
-  end
+module CF
+  module Domain
+    describe Map do
+      before do
+        stub_client_and_precondition
+      end
 
-  let(:client) do
-    fake_client(
-      :current_organization => organization,
-      :current_space => space,
-      :spaces => [space],
-      :organizations => [organization],
-      :domains => domains)
-  end
+      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
+      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] }
 
-    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 a space" do
+        it "adds the domain to the space's organization" do
+          space.organization.should_receive(:add_domain).with(domain)
+          space.stub(:add_domain)
+          subject
+        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)
+        it "adds the domain to the space" do
+          space.organization.stub(:add_domain)
+          space.should_receive(:add_domain).with(domain)
+          subject
+        end
       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) { [] }
+      shared_examples_for "binding a domain to an organization" do
+        it "does NOT add the domain to a space" do
+          space.class.any_instance.should_not_receive(:add_domain).with(domain)
+        end
 
-      before do
-        stub(client).domain { domain }
-        stub(domain).create!
-        stub(space.organization).add_domain(domain)
-        stub(space).add_domain(domain)
+        it "adds the domain to the organization" do
+          organization.should_receive(:add_domain).with(domain)
+          subject
+        end
       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
+      shared_examples_for "mapping a domain to a space" do
+        context "when the domain does NOT exist" do
+          let(:domains) { [] }
 
-      include_examples "binding a domain to a space"
-    end
+          before do
+            client.stub(:domain) { domain }
+            domain.stub(:create!)
+          end
 
-    context "when the domain already exists" do
-      include_examples "binding a domain to a space"
-    end
-  end
+          it "creates the domain" do
+            space.organization.stub(:add_domain)
+            space.should_receive(:add_domain).with(domain)
 
-  context 'when a domain and a space are passed' do
-    subject { cf %W[map-domain #{domain.name} --space #{space.name}] }
+            domain.should_receive(:create!)
+            subject
+            expect(domain.name).to eq domain_name
+            expect(domain.owning_organization).to eq organization
+          end
 
-    include_examples "mapping a domain to a space"
-  end
+          include_examples "binding 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 "when the domain already exists" do
+          include_examples "binding a domain to a space"
+        end
+      end
 
-    context "and the domain does NOT exist" do
-      let(:domains) { [] }
+      context "when a domain and a space are passed" do
+        subject { cf %W[map-domain #{domain.name} --space #{space.name}] }
 
-      before do
-        stub(client).domain { domain }
-        stub(domain).create!
-        stub(organization).add_domain(domain)
+        include_examples "mapping a domain to a space"
       end
 
-      include_examples "binding a domain to an organization"
+      context "when a domain and an organization are passed" do
+        subject { cf %W[map-domain #{domain.name} --organization #{organization.name}] }
 
-      it 'creates the domain' do
-        mock(domain).create!
-        subject
-        expect(domain.name).to eq domain_name
-      end
+        context "and the domain does NOT exist" do
+          let(:domains) { [] }
 
-      context "and the --shared option is passed" do
-        subject { cf %W[map-domain #{domain.name} --organization #{organization.name} --shared] }
+          before do
+            client.stub(:domain) { domain }
+            domain.stub(:create!)
+            organization.stub(:add_domain)
+          end
 
-        it 'adds the domain to the organization' do
-          mock(organization).add_domain(domain)
-          subject
+          include_examples "binding a domain to an organization"
+
+          it "creates the domain" do
+            domain.should_receive(: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
+              organization.should_receive(:add_domain).with(domain)
+              subject
+            end
+
+            it "does not add the domain to a specific organization" do
+              domain.stub(:create!)
+              subject
+              expect(domain.owning_organization).to be_nil
+            end
+          end
         end
 
-        it "does not add the domain to a specific organization" do
-          stub(domain).create!
-          subject
-          expect(domain.owning_organization).to be_nil
+        context "and the domain already exists" do
+          include_examples "binding a domain to an organization"
         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}] }
 
-  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
+        include_examples "mapping a domain to a space"
+      end
 
-  context 'when only a domain is passed' do
-    subject { cf %W[map-domain #{domain.name}] }
+      context "when only a domain is passed" do
+        subject { cf %W[map-domain #{domain.name}] }
 
-    include_examples "mapping a domain to a space"
+        include_examples "mapping a domain to a space"
+      end
+    end
   end
 end

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

@@ -1,73 +1,77 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe CF::Domain::Unmap do
-  before do
-    stub_client_and_precondition
-  end
+module CF
+  module Domain
+    describe Unmap do
+      before do
+        stub_client_and_precondition
+      end
 
-  let(:client) do
-    fake_client(
-      :current_organization => organization,
-      :current_space => space,
-      :spaces => [space],
-      :organizations => [organization],
-      :domains => [domain])
-  end
+      let(:client) do
+        fake_client(
+          :current_organization => organization,
+          :current_space => space,
+          :spaces => [space],
+          :organizations => [organization],
+          :domains => [domain])
+      end
 
-  let(:organization) { fake(:organization, :spaces => [space]) }
-  let(:space) { fake(:space) }
-  let(:domain) { fake(:domain, :name => "some.domain.com") }
+      let(:organization) { fake(:organization, :spaces => [space]) }
+      let(:space) { fake(:space) }
+      let(:domain) { fake(:domain, :name => "some.domain.com") }
 
-  context "when the --delete flag is given" do
-    subject { cf %W[unmap-domain #{domain.name} --delete] }
+      context "when the --delete flag is given" do
+        subject { cf %W[unmap-domain #{domain.name} --delete] }
 
-    it "asks for a confirmation" do
-      mock_ask("Really delete #{domain.name}?", :default => false) { false }
-      stub(domain).delete!
-      subject
-    end
+        it "asks for a confirmation" do
+          mock_ask("Really delete #{domain.name}?", :default => false) { false }
+          domain.stub(:delete!)
+          subject
+        end
 
-    context "and the user answers 'no' to the confirmation" do
-      it "does NOT delete the domain" do
-        stub_ask("Really delete #{domain.name}?", anything) { false }
-        dont_allow(domain).delete!
-        subject
-      end
-    end
+        context "and the user answers 'no' to the confirmation" do
+          it "does NOT delete the domain" do
+            stub_ask("Really delete #{domain.name}?", anything) { false }
+            domain.should_not_receive(:delete!)
+            subject
+          end
+        end
 
-    context "and the user answers 'yes' to the confirmation" do
-      it "deletes the domain" do
-        stub_ask("Really delete #{domain.name}?", anything) { true }
-        mock(domain).delete!
-        subject
+        context "and the user answers 'yes' to the confirmation" do
+          it "deletes the domain" do
+            stub_ask("Really delete #{domain.name}?", anything) { true }
+            domain.should_receive(:delete!)
+            subject
+          end
+        end
       end
-    end
-  end
 
-  context "when a space is given" do
-    subject { cf %W[unmap-domain #{domain.name} --space #{space.name}] }
+      context "when a space is given" do
+        subject { cf %W[unmap-domain #{domain.name} --space #{space.name}] }
 
-    it "unmaps the domain from the space" do
-      mock(space).remove_domain(domain)
-      subject
-    end
-  end
+        it "unmaps the domain from the space" do
+          space.should_receive(:remove_domain).with(domain)
+          subject
+        end
+      end
 
-  context "when an organization is given" do
-    subject { cf %W[unmap-domain #{domain.name} --organization #{organization.name}] }
+      context "when an organization is given" do
+        subject { cf %W[unmap-domain #{domain.name} --organization #{organization.name}] }
 
-    it "unmaps the domain from the organization" do
-      mock(organization).remove_domain(domain)
-      subject
-    end
-  end
+        it "unmaps the domain from the organization" do
+          organization.should_receive(:remove_domain).with(domain)
+          subject
+        end
+      end
 
-  context "when only the domain is given" do
-    subject { cf %W[unmap-domain #{domain.name}] }
+      context "when only the domain is given" do
+        subject { cf %W[unmap-domain #{domain.name}] }
 
-    it "unmaps the domain from the current space" do
-      mock(client.current_space).remove_domain(domain)
-      subject
+        it "unmaps the domain from the current space" do
+          client.current_space.should_receive(:remove_domain).with(domain)
+          subject
+        end
+      end
     end
   end
 end