trucker-cli 0.0.1

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

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe CF::Route::Unmap do
+  before do
+    stub_client_and_precondition
+  end
+
+  let(:client) do
+    build(:client).tap do |client|
+      client.stub(:apps).and_return([app])
+      client.stub(:apps_by_name).and_return([app])
+    end
+  end
+
+  let(:app){ build(:app, :space => space, :name => "app-name") }
+  let(:space) { build(:space, :name => "space-name", :domains => space_domains) }
+  let(:domain) { build(:domain, :name => domain_name ) }
+  let(:domain_name) { "some-domain.com" }
+  let(:host_name) { "some-host" }
+  let(:url) { "#{host_name}.#{domain_name}" }
+  let(:space_domains) { [domain] }
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:delete_service] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Delete a service" }
+      it { expect(Mothership::Help.group(:services, :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 => :service }])
+      end
+    end
+  end
+
+  context "when an app and a url are specified" do
+    subject { cf %W[unmap #{url} #{app.name}] }
+
+    context "when the given route is mapped to the given app" do
+      let(:app) { build(:app, :space => space, :name => "app-name", :routes => [route]) }
+      let(:route) { build(:route, :space => space, :host => host_name, :domain => domain) }
+
+      it "unmaps the url from the app" do
+        app.should_receive(:remove_route).with(route)
+        subject
+      end
+    end
+
+    context "when the given route is NOT mapped to the given app" do
+      it "displays an error" do
+        app.stub(:routes).and_return([])
+        subject
+        expect(error_output).to say("Unknown route")
+      end
+    end
+  end
+
+  context "when only an app is specified" do
+    let(:other_route) { build(:route, :host => "abcd", :domain => domain) }
+    let(:route) { build(:route, :host => "efgh", :domain => domain) }
+    let(:app) { build(:app, :space => space, :routes => [route, other_route] )}
+
+    subject { cf %W[unmap --app #{app.name}] }
+
+    it "asks the user to select from the app's urls" do
+      should_ask("Which URL?", anything) do |_, opts|
+        expect(opts[:choices]).to eq [other_route, route]
+        route
+      end
+
+      app.stub(:remove_route)
+
+      subject
+    end
+
+    it "unmaps the selected url from the app" do
+      stub_ask("Which URL?", anything) { route }
+      app.should_receive(:remove_route).with(route)
+      subject
+    end
+  end
+
+  context "when an app is specified and the --all option is given" do
+    let(:other_route) { build(:route, :host => "abcd", :domain => domain) }
+    let(:route) { build(:route, :host => "efgh", :domain => domain) }
+    let(:app) { build(:app, :routes => [route, other_route]) }
+
+    subject { cf %W[unmap --all --app #{app.name}] }
+
+    it "unmaps all routes from the given app" do
+      app.should_receive(:remove_route).with(route)
+      app.should_receive(:remove_route).with(other_route)
+      subject
+    end
+  end
+
+  context "when only a url is passed" do
+    let(:route) { build(:route, :host => host_name, :domain => domain) }
+    before { client.stub(:routes).and_return([route]) }
+
+    subject { cf %W[unmap #{url}] }
+
+    it "displays an error message" do
+      subject
+      expect(error_output).to say("Missing --app.")
+    end
+  end
+end

data/spec/cf/cli/service/bind_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe CF::Service::Bind do
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:bind_service] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Bind a service to an application" }
+      it { expect(Mothership::Help.group(:services, :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 => :service },
+          { :type => :optional, :value => nil, :name => :app }
+        ])
+      end
+    end
+  end
+end

data/spec/cf/cli/service/create_spec.rb

@@ -0,0 +1,147 @@
+require "spec_helper"
+
+module CF
+  module Service
+    describe Create do
+      let(:client) { build(:client) }
+
+      before do
+        stub_client_and_precondition
+      end
+
+      describe "metadata" do
+        let(:command) { Mothership.commands[:create_service] }
+
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Create a service" }
+          it { expect(Mothership::Help.group(:services, :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 => :offering}, {:type => :optional, :value => nil, :name => :name}])
+          end
+        end
+      end
+
+      context "when there are services" do
+        let(:service_plan) { build(:service_plan, :name => "F20") }
+        let(:selected_service) { build(:service, :label => "Foo Service", :service_plans => [service_plan]) }
+        let(:command) { Mothership.new.invoke(:create_service, params, {}) }
+        let(:params) { {} }
+
+        before do
+          client.stub(:services).and_return(services)
+        end
+
+        describe "when there is at least one service" do
+          let(:services) { [selected_service] }
+
+          it "asks for the service" do
+            should_ask("What kind?", anything) { selected_service }
+            should_ask("Name?", anything) { selected_service.label }
+            should_ask("Which plan?", anything) { service_plan }
+            CFoundry::V2::ServiceInstance.any_instance.stub(:create!)
+
+            capture_output { command }
+          end
+        end
+
+        describe "when there are more than one services" do
+          let(:services) { [selected_service, build(:service), build(:service)] }
+
+          it "asks for the service" do
+            should_ask("What kind?", anything) { selected_service }
+            should_ask("Name?", anything) { selected_service.label }
+            should_ask("Which plan?", anything) { service_plan }
+            CFoundry::V2::ServiceInstance.any_instance.stub(:create!)
+
+            capture_output { command }
+          end
+        end
+
+        describe "when the service plan is specified by an object, not a string" do
+          let(:services) { [selected_service] }
+          let(:params) { {
+            :name => "my-service-name",
+            :offering => selected_service,
+            :plan => service_plan,
+          } }
+
+          it "creates the specified service" do
+            CFoundry::V2::ManagedServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
+            CFoundry::V2::ManagedServiceInstance.any_instance.should_receive(:create!)
+            capture_output { command }
+          end
+        end
+
+        describe "when entering command line options" do
+          let(:service_plan) { build(:service_plan, :name => "f20") }
+          let(:params) { {
+            :name => "my-service-name",
+            :offering => selected_service,
+            :plan => "F20",
+          } }
+          let(:services) { [selected_service] }
+
+          it "uses case insensitive match" do
+            CFoundry::V2::ManagedServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
+            CFoundry::V2::ManagedServiceInstance.any_instance.should_receive(:create!)
+            capture_output { command }
+          end
+        end
+
+        describe "when selecting the user-provided service" do
+          let(:services) { [build(:service), build(:service)] }
+          let(:user_provided_service) { build(:service, label: "user-provided")}
+
+          before do
+            client.stub(:services).and_return(services)
+          end
+
+          it "asks for an instance name and credentials" do
+            should_ask("What kind?", hash_including(choices: include(has_label("user-provided")))) { user_provided_service }
+            should_ask("Name?", anything) { "user-provided-service-name-1" }
+
+            should_ask("What credential parameters should applications use to connect to this service instance?\n(e.g. hostname, port, password)") { "host, port, user name" }
+            should_print("'user name' is not a valid key")
+            should_ask("What credential parameters should applications use to connect to this service instance?\n(e.g. hostname, port, password)") { "host, port" }
+            should_ask("host") { "example.com" }
+            should_ask("port") { "8080" }
+            mock_with_progress("Creating service user-provided-service-name-1")
+
+            instance = client.user_provided_service_instance
+            client.should_receive(:user_provided_service_instance).and_return(instance)
+            instance.should_receive(:create!)
+
+            capture_output { command }
+
+            instance.credentials['host'].should == 'example.com'
+            instance.credentials['port'].should == '8080'
+          end
+
+          # lame, i know
+          context "when invoked from another command" do
+            let(:params) { {
+              :credentials => {"k" => "v"},
+              :name => "service-name",
+              :offering => UPDummy.new,
+            } }
+
+            it "creates a user-provided service" do
+              instance = client.user_provided_service_instance
+              client.should_receive(:user_provided_service_instance).and_return(instance)
+              instance.should_receive(:create!)
+
+              Mothership.new.invoke(:create_service, params, {})
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe CF::Service::Delete do
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:delete_service] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Delete a service" }
+      it { expect(Mothership::Help.group(:services, :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 => :service }])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+module CF
+  module Service
+    describe "Help"  do
+      let(:global) { {} }
+      let(:given) { {} }
+
+      subject do
+        capture_output { Mothership.new.invoke(:help, :command => "service") }
+      end
+
+      it "describes the command" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.first).to match /Show service information/
+      end
+
+      it "prints the options" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.any? {|line| line =~ /Options:/ }).to be_true
+
+      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/service/rename_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe CF::Service::Rename do
+  let(:global) { { :color => false, :quiet => true } }
+  let(:inputs) { {} }
+  let(:given) { {} }
+  let(:client) { build(:client) }
+  let(:service) {}
+  let(:services) { [] }
+  let(:new_name) { "some-new-name" }
+
+  subject { Mothership.new.invoke(:rename_service, inputs, given, global) }
+
+  before do
+    CF::CLI.any_instance.stub(:client).and_return(client)
+    client.stub(:service_instances => services)
+    client.stub(:service_instances_by_name => services)
+  end
+
+  describe "metadata" do
+    let(:command) { Mothership.commands[:rename_service] }
+
+    describe "command" do
+      subject { command }
+      its(:description) { should eq "Rename a service" }
+      it { expect(Mothership::Help.group(:services, :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 => :service },
+          { :type => :optional, :value => nil, :name => :name }
+        ])
+      end
+    end
+  end
+
+  context "when there are no services" do
+    context "and a service is given" do
+      let(:given) { { :service => "some-service" } }
+      it { expect { subject }.to raise_error(CF::UserError, "Unknown service 'some-service'.") }
+    end
+
+    context "and a service is not given" do
+      it { expect { subject }.to raise_error(CF::UserError, "No services.") }
+    end
+  end
+
+  context "when there are services" do
+    let(:services) { Array.new(2) { build(:managed_service_instance) } }
+    let(:renamed_service) { services.first }
+
+    context "when the defaults are used" do
+      it "asks for the service and new name and renames" do
+        should_ask("Rename which service?", anything) { renamed_service }
+        should_ask("New name") { new_name }
+        renamed_service.should_receive(:name=).with(new_name)
+        renamed_service.should_receive(:update!)
+        subject
+      end
+    end
+
+    context "when no name is provided, but a service is" do
+      let(:given) { { :service => renamed_service.name } }
+
+      it "asks for the new name and renames" do
+        dont_allow_ask("Rename which service?", anything)
+        should_ask("New name") { new_name }
+        renamed_service.should_receive(:name=).with(new_name)
+        renamed_service.should_receive(:update!)
+        subject
+      end
+    end
+
+    context "when a service is provided and a name" do
+      let(:inputs) { { :service => renamed_service, :name => new_name } }
+
+      it "renames the service" do
+        renamed_service.should_receive(:update!)
+        subject
+      end
+
+      it "displays the progress" do
+        mock_with_progress("Renaming to #{new_name}")
+        renamed_service.should_receive(:update!)
+
+        subject
+      end
+
+      context "and the name already exists" do
+        it "fails" do
+          renamed_service.should_receive(:update!) { raise CFoundry::ServiceInstanceNameTaken.new("Taken", 200) }
+          expect { subject }.to raise_error(CFoundry::ServiceInstanceNameTaken)
+        end
+      end
+    end
+  end
+end
+