trucker-cli 0.0.1

data/spec/cf/cli/populators/space_spec.rb

@@ -0,0 +1,156 @@
+require "spec_helper"
+
+module CF
+  module Populators
+    describe Space do
+      stub_home_dir_with { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+
+      describe "#populate_and_save!" do
+        let(:spaces) do
+          [
+            build(:space, :name => "Development", :guid => "space-id-1", :developers => [user]),
+            build(:space, :name => "Staging", :guid => "space-id-2")
+          ]
+        end
+        let(:space) { spaces.first }
+        let(:user) { build(:user) }
+        let(:client) { build(:client) }
+        let(:organization) { build(:organization, :client => client, :name => "My Org", :guid => "organization-id-1", :users => [user], :spaces => spaces) }
+
+        let(:tokens_file_path) { "~/.truck/tokens.yml" }
+        let(:input_hash) { {:space => space} }
+        let(:inputs) { Mothership::Inputs.new(nil, nil, input_hash) }
+        let(:tokens_yaml) { YAML.load_file(File.expand_path(tokens_file_path)) }
+        let(:populator) { CF::Populators::Space.new(inputs, organization) }
+
+        before do
+          client.stub(:current_user).and_return(user)
+          described_class.any_instance.stub(:client).and_return(client)
+        end
+
+        def execute_populate_and_save
+          capture_output { populator.populate_and_save! }
+        end
+
+        it "updates the client with the new space" do
+          write_token_file({:space => "space-id-2"})
+          described_class.any_instance.unstub(:client)
+          populator.client.current_space.guid.should == "space-id-2"
+
+          execute_populate_and_save
+
+          populator.client.current_space.guid.should == "space-id-1"
+        end
+
+        it "returns the space" do
+          execute_populate_and_save.should == space
+        end
+
+        describe "mothership input arguments" do
+          let(:inputs) do
+            Mothership::Inputs.new(nil, nil, input_hash).tap do |input|
+              input.should_receive(:[]).with(:space, organization).and_return(space)
+              input.stub(:[]).and_return(space)
+            end
+          end
+
+          it "passes through extra arguments to the input call" do
+            execute_populate_and_save
+          end
+        end
+
+        context "with a space in the input" do
+          let(:input_hash) { {:space => space} }
+          before { write_token_file({:space => "space-id-2"}) }
+
+          it "uses that space" do
+            execute_populate_and_save.should == space
+          end
+
+          it "should not reprompt for space" do
+            dont_allow_ask("Space", anything)
+            execute_populate_and_save
+          end
+
+          it "sets the space in the token file" do
+            execute_populate_and_save
+            expect(tokens_yaml["https://api.some-domain.com"][:space]).to be == "space-id-1"
+          end
+
+          it "prints out that it is switching to that space" do
+            execute_populate_and_save
+            expect(output).to say("Switching to space #{space.name}")
+          end
+        end
+
+        context "without a space in the input" do
+          let(:input_hash) { {} }
+
+          context "with a space in the config file" do
+            before do
+              write_token_file({:space => space.guid, :organization => organization.guid})
+              client.stub(:space).and_return(space)
+            end
+
+            it "should not reprompt for space" do
+              dont_allow_ask("Space", anything)
+              execute_populate_and_save
+            end
+
+            it "sets the space in the token file" do
+              execute_populate_and_save
+              expect(tokens_yaml["https://api.some-domain.com"][:space]).to be == "space-id-1"
+            end
+
+            context "but that space doesn't exist anymore (not valid)" do
+              before do
+                space.stub(:developers).and_raise(CFoundry::APIError)
+                organization.stub(:spaces).and_return(spaces)
+              end
+
+              it "asks the user for an space" do
+                should_ask("Space", anything) { space }
+                execute_populate_and_save
+              end
+            end
+          end
+
+          context "without a space in the config file" do
+            context "when the user has spaces in that organization" do
+              before do
+                write_token_file({})
+                organization.stub(:spaces).and_return(spaces)
+              end
+
+              it "prompts for the space" do
+                should_ask("Space", anything) { space }
+                execute_populate_and_save
+
+                expect(output).to say("Switching to space #{space.name}")
+              end
+
+              it "sets the space in the token file" do
+                should_ask("Space", anything) { space }
+
+                execute_populate_and_save
+                expect(tokens_yaml["https://api.some-domain.com"][:space]).to be == "space-id-1"
+              end
+            end
+
+            context "when the user has no spaces in that organization" do
+              before do
+                write_token_file({})
+                organization.stub(:spaces).and_return([])
+              end
+
+              it "warns the user they should create one" do
+                execute_populate_and_save
+                expect(output).to say("There are no spaces. You may want to create one with create-space.")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cf/cli/populators/target_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+module CF
+    describe Populators::Target do
+      describe "#populate_and_save!" do
+        let(:input) { double(:input) }
+        let(:organization_populator) { double(Populators::Organization) }
+        let(:space_populator) { double(Populators::Space) }
+
+        def execute_populate_and_save
+          Populators::Target.new(input).populate_and_save!
+        end
+
+        context 'when there are no orgs' do
+          it 'does not try to populate the space' do
+            Populators::Organization.stub(:new).and_return(organization_populator)
+            organization_populator.stub(:populate_and_save!).and_return(nil)
+
+            Populators::Space.stub(:new).and_return(space_populator)
+            space_populator.should_not receive(:populate_and_save!)
+
+            execute_populate_and_save
+          end
+        end
+
+        it "uses a organization_populator then a space_populator populator" do
+          Populators::Organization.should_receive(:new).with(input).and_return(organization_populator)
+
+          cfoundry_organization = double(CFoundry::V2::Organization)
+          organization_populator.should_receive(:populate_and_save!).and_return(cfoundry_organization)
+
+          Populators::Space.should_receive(:new).with(input, cfoundry_organization).and_return(space_populator)
+          space_populator.should_receive(:populate_and_save!)
+
+          execute_populate_and_save
+        end
+      end
+    end
+end

data/spec/cf/cli/route/delete_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe CF::Route::Delete do
+  before do
+    stub_client_and_precondition
+    route.stub(:delete!)
+  end
+
+  let(:client) do
+    build(:client).tap { |client| client.stub(:routes => [route]) }
+  end
+  let(:route) { build(:route, :host => host_name, :domain => domain) }
+  let(:domain) { build(:domain, :name => domain_name) }
+  let(:domain_name) { "some-domain.com" }
+  let(:host_name) { "some-host" }
+  let(:url) { "#{host_name}.#{domain_name}" }
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:delete_route] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Delete a route" }
+      it { expect(Mothership::Help.group(:routes)).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 => :normal, :value => nil, :name => :route}])
+      end
+    end
+  end
+
+  context "without the force parameter" do
+    let(:command) { cf %W[delete-route #{url}] }
+
+    it "prompts the user are they sure?" do
+      should_ask("Really delete #{url}?", {:default => false}) { true }
+
+      command
+    end
+
+    context "when the user responds 'y'" do
+      before do
+        stub_ask("Really delete #{url}?", {:default => false}) { true }
+      end
+
+      it "deletes the route" do
+        route.should_receive(:delete!)
+        command
+      end
+
+      it "exits cleanly" do
+        command
+        @status.should == 0
+      end
+    end
+
+    context "when the user responds 'n'" do
+      before do
+        stub_ask("Really delete #{url}?", {:default => false}) { false }
+      end
+
+      it "does not delete the route" do
+        route.should_not_receive(:delete!)
+        command
+      end
+
+      it "exits cleanly" do
+        command
+        @status.should == 0
+      end
+    end
+  end
+
+  context "with the force parameter" do
+    let(:command) { cf %W[delete-route #{url} --force] }
+
+    it "deletes the route" do
+      route.should_receive(:delete!)
+      command
+    end
+
+    it "exits cleanly" do
+      command
+      @status.should == 0
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+module CF
+  module Route
+    describe "Help"  do
+      let(:global) { {} }
+      let(:given) { {} }
+
+      subject do
+        capture_output { Mothership.new.invoke(:help, :command => "routes") }
+      end
+
+      it "describes the command" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.first).to match /List routes in a space/
+      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/route/map_spec.rb

@@ -0,0 +1,148 @@
+require "spec_helper"
+
+module CF
+  module Route
+    describe Map do
+      before do
+        stub_client_and_precondition
+      end
+
+      let(:client) { build(:client) }
+
+      let(:app) { build(:app, :space => space, :name => "app-name") }
+      let(:space) { build(:space, :domains => space_domains) }
+      let(:domain) { build(:domain, :name => "domain-name-1") }
+
+      let(:apps) { [app] }
+      let(:routes) { [] }
+      let(:domains) { [domain] }
+
+      let(:space_domains) { domains }
+
+      let(:host_name) { "some-host" }
+
+      shared_examples "mapping the route to the app" do
+        context "and the domain is mapped to the space" do
+          let(:space_domains) { [domain] }
+
+          before do
+            space.stub(:domain_by_name).with(domain.name).and_return(domain)
+          end
+
+          context "and the route is mapped to the space" do
+            let(:routes) { [route] }
+            let(:route) { build(:route, :space => space, :host => host_name, :domain => domain) }
+
+            it "binds the route to the app" do
+              app.should_receive(:add_route).with(route)
+              subject
+            end
+          end
+
+          context "and the route is not mapped to the space" do
+            let(:new_route) { build(:route) }
+
+            before do
+              client.stub(:route).and_return(new_route)
+              app.stub(:add_route)
+              new_route.stub(:create!)
+            end
+
+            it "indicates that it is creating a route" do
+              subject
+              expect(output).to say("Creating route #{host_name}.#{domain.name}")
+            end
+
+            it "creates the route in the app's space" do
+              new_route.should_receive(:create!)
+              subject
+              expect(new_route.host).to eq host_name
+              expect(new_route.domain).to eq domain
+              expect(new_route.space).to eq space
+            end
+
+            it "indicates that it is binding the route" do
+              subject
+              expect(output).to say("Binding #{host_name}.#{domain.name} to #{app.name}")
+            end
+
+            it "binds the route to the app" do
+              app.should_receive(:add_route).with(new_route)
+              subject
+            end
+          end
+        end
+      end
+
+      context "when an app is specified" do
+        subject { cf(%W[map #{app.name} #{host_name} #{domain.name}]) }
+
+        before do
+          client.stub(:apps).and_return(apps)
+          client.stub(:routes).and_return(routes)
+        end
+
+        context "when a host is specified" do
+          context "and the domain is not already mapped to the space" do
+            before do
+              space.stub(:domain_by_name).with(domain.name).and_return(nil)
+            end
+
+            it "indicates that the domain is invalid" do
+              subject
+              expect(error_output).to say("Unknown domain")
+            end
+          end
+
+          include_examples "mapping the route to the app"
+        end
+
+        context "when a host is not specified" do
+          let(:new_route) { build(:route) }
+          let(:host_name) { "" }
+
+          before do
+            client.stub(:route).and_return(new_route)
+            client.stub(:app_by_name).with(app.name).and_return(app)
+            client.stub(:routes_by_host).with(host_name, {:depth => 0}).and_return([new_route])
+            app.stub(:add_route)
+            space.stub(:domain_by_name).with(domain.name).and_return(domain)
+            new_route.stub(:create!)
+          end
+
+          it "creates a route with an empty string as its host" do
+            new_route.should_receive(:create!)
+            subject
+            expect(new_route.host).to eq ""
+          end
+
+          include_examples "mapping the route to the app"
+        end
+      end
+
+      context "when an app is not specified" do
+        let(:space_domains) { [domain] }
+        let(:new_route) { double(:route).as_null_object }
+
+        subject { cf %W[map --host #{host_name} #{domain.name}] }
+
+        before do
+          client.stub(:apps).and_return(apps)
+          stub_ask("Which application?", anything) { app }
+          space.stub(:domain_by_name).with(domain.name).and_return(domain)
+          client.stub(:routes_by_host).with(host_name, {:depth => 0}).and_return(routes)
+        end
+
+        it "asks for an app" do
+          client.stub(:route).and_return(new_route)
+          app.stub(:add_route)
+          new_route.stub(:create!)
+          should_ask("Which application?", anything) { app }
+          subject
+        end
+
+        include_examples "mapping the route to the app"
+      end
+    end
+  end
+end