trucker-cli 0.0.1

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe ServiceHelper do
+  describe "#label" do
+    it "returns the label for the service" do
+      service = build(:service, label: 'mysql')
+      helper = ServiceHelper.new(service)
+
+      expect(helper.label).to eq('mysql')
+    end
+  end
+
+  describe "#provider" do
+    it "returns the provider for the service if it has one" do
+      service = build(:service, provider: 'aws')
+      helper = ServiceHelper.new(service)
+
+      expect(helper.provider).to eq('aws')
+    end
+
+    it "returns n/a if it does not have a provider" do
+      service = build(:service, provider: nil)
+      helper = ServiceHelper.new(service)
+
+      expect(helper.provider).to eq('n/a')
+    end
+  end
+
+  describe "#version" do
+    it "returns the version for the service if it has one" do
+      service = build(:service, version: '3.11')
+      helper = ServiceHelper.new(service)
+
+      expect(helper.version).to eq('3.11')
+    end
+
+    it "returns n/a if it does not have a version" do
+      service = build(:service, version: nil)
+      helper = ServiceHelper.new(service)
+
+      expect(helper.version).to eq('n/a')
+    end
+  end
+
+  describe "#service_plans" do
+    it "returns the plans for the service if it has one" do
+      plans = [
+        build(:service_plan, name: 'small'),
+        build(:service_plan, name: 'large')
+      ]
+      service = build(:service, :service_plans => plans)
+      helper = ServiceHelper.new(service)
+
+      expect(helper.service_plans).to eq('small, large')
+    end
+  end
+
+  describe "#description" do
+    it "returns the plans for the service if it has one" do
+      service = build(:service, :description => 'super awesome NoSQL NO DOWNTIME')
+      helper = ServiceHelper.new(service)
+
+      expect(helper.description).to eq('super awesome NoSQL NO DOWNTIME')
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+require "spec_helper"
+
+describe ServiceInstanceHelper do
+  describe ".new" do
+    let(:provided_instance) { build(:user_provided_service_instance) }
+    let(:managed_instance) { build(:managed_service_instance) }
+
+    it "returns a ManagedServiceInstanceHelper when the argument is a ManagedServiceInstance" do
+      expect(ServiceInstanceHelper.new(managed_instance)).to be_a ManagedServiceInstanceHelper
+    end
+
+    it "returns a ManagedSerivceInstanceHelper when the argument is a ManagedServiceInstance" do
+      expect(ServiceInstanceHelper.new(provided_instance)).to be_a UserProvidedServiceInstanceHelper
+    end
+  end
+end
+
+describe UserProvidedServiceInstanceHelper do
+  let(:bindings) { [] }
+  let(:instance) { build(:user_provided_service_instance, service_bindings: bindings) }
+  subject(:helper) { UserProvidedServiceInstanceHelper.new(instance) }
+  describe "matches" do
+    it "returns true when 'user-provided' is the given label" do
+      expect(helper.matches(service: "user-provided")).to eq true
+    end
+
+    it "returns false when 'user-provided' is not the given label" do
+      expect(helper.matches(service: "a-different-label")).to eq false
+    end
+
+    it "returns true when a label is not given" do
+      expect(helper.matches).to eq true
+    end
+  end
+
+  its(:service_label) { should eq("user-provided") }
+  its(:service_provider) { should eq("n/a") }
+  its(:version) { should eq("n/a") }
+  its(:plan_name) { should eq("n/a") }
+  its(:name) { should eq instance.name }
+  its(:service_bindings) { should eq instance.service_bindings }
+end
+
+describe ManagedServiceInstanceHelper do
+  let(:label) { "some-label" }
+  let(:provider) { "some-provider" }
+  let(:version) { "some-version" }
+  let(:plan_name) { "some-plan-name" }
+
+  let(:service) { build(:service, label: label, provider: provider, version: version) }
+  let(:plan) { build(:service_plan, service: service, name: plan_name) }
+  let(:bindings) { [] }
+  let(:instance) { build(:managed_service_instance, service_plan: plan, service_bindings: bindings) }
+  subject(:helper) { ManagedServiceInstanceHelper.new(instance) }
+
+  describe "matches" do
+    it "returns true when no condition is specified" do
+      expect(helper.matches).to eq(true)
+    end
+
+    context "filtering based on service" do
+      it "returns true if the service label matches given service" do
+        expect(helper.matches(service: label)).to eq(true)
+      end
+
+      it "returns false if the service label does not match given service" do
+        expect(helper.matches(service: "a-different-label")).to eq(false)
+      end
+    end
+
+    context "filtering based on service plan" do
+      it "returns true if the plan name matches given plan" do
+        expect(helper.matches(plan: plan_name)).to eq(true)
+      end
+
+      it "returns true if the plan name does not match given plan" do
+        expect(helper.matches(plan: "some-other-plan-name")).to eq(false)
+      end
+
+      it "is case insensitive" do
+        expect(helper.matches(plan: plan_name.upcase)).to eq(true)
+      end
+    end
+
+    context "filtering based on provider" do
+      it "returns true if the provider name matches given provider" do
+        expect(helper.matches(provider: provider)).to eq(true)
+      end
+
+      it "returns true if the provider does not match given provider" do
+        expect(helper.matches(provider: "a-different-provider")).to eq(false)
+      end
+    end
+
+    context "filtering based on version" do
+      it "returns true if the version matches given version" do
+        expect(helper.matches(version: version)).to eq(true)
+      end
+
+      it "returns true if the version does not match given version" do
+        expect(helper.matches(version: "a-different-version")).to eq(false)
+      end
+    end
+
+    context "multiple filters" do
+      it "returns true if the service instance matches all four parameters" do
+        expect(helper.matches(service: label, plan: plan_name,
+                              provider: provider, version: version)).to eq true
+      end
+
+      it "return false if any of the parameters does not match the attribute of the service instance" do
+        expect(helper.matches(service: label, plan: plan_name,
+                              provider: provider, version: "a-different-version")).to eq false
+      end
+    end
+
+    context "with patterns for args" do
+      it "returns true when service label matches the given glob" do
+        expect(helper.matches(service: label.gsub(/.$/, "*"))).to eq(true)
+      end
+
+      it "returns false when the service label doesn not match the given glob" do
+        expect(helper.matches(service: label + "_*")).to eq(false)
+      end
+    end
+  end
+
+  describe "service_label" do
+
+    it "returns the label of instance's service offering" do
+      expect(helper.service_label).to eq label
+    end
+  end
+
+  describe "service_provider" do
+    it "returns the provider of the instance's service offering" do
+      expect(helper.service_provider).to eq provider
+    end
+  end
+
+  describe "version" do
+    it "returns the version of the instance's service offering" do
+      expect(helper.version).to eq version
+    end
+  end
+
+  describe "plan_name" do
+    it "returns the name of the instance's service plan" do
+      expect(helper.plan_name).to eq plan_name
+    end
+  end
+
+  its(:name) { should eq instance.name }
+  its(:service_bindings) { should eq instance.service_bindings }
+end

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

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

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

@@ -0,0 +1,156 @@
+require "spec_helper"
+
+module CF
+  module Service
+    describe Services do
+      let(:command) { Mothership.commands[:services] }
+
+      describe "metadata" do
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "List your services" }
+          it { expect(Mothership::Help.group(:services)).to include(subject) }
+        end
+
+        include_examples "inputs must have descriptions"
+
+        describe "arguments" do
+          subject { command.arguments }
+          it "has no required arguments" do
+            should eq([])
+          end
+        end
+
+        describe "inputs" do
+          subject { command.inputs }
+          it "has the expected inputs" do
+            subject.keys.should =~ [:name, :service, :marketplace, :plan, :provider, :version, :app, :full, :space]
+          end
+        end
+      end
+
+      describe "listing services" do
+        let(:global) { {:color => false} }
+        let(:inputs) { {} }
+        let(:given) { {} }
+        let(:client) do
+          build(:client).tap do |client|
+            client.stub(:current_space => current_space, :service_instances => service_instances)
+          end
+        end
+        let(:app) { build(:app) }
+
+        let(:service_plan) { build(:service_plan, :service => build(:service, :version => "service_version", :provider => "provider")) }
+        let(:service_binding) { build(:service_binding, :app => app) }
+        let(:service1) { build(:managed_service_instance, :service_plan => service_plan, :service_bindings => [service_binding]) }
+
+        let(:service_instances) { [service1] }
+        let(:current_space) { build(:space, :name => "the space") }
+
+        subject do
+          capture_output { CF::CLI.new.invoke(:services, inputs, given, global) }
+        end
+
+        before do
+          stub_client
+          client.stub(:service_bindings).and_return([service_binding])
+        end
+
+        context "when the user is targeted to a space" do
+          before do
+            stub_precondition
+          end
+
+          it "produces a table of services" do
+            subject
+            stdout.rewind
+            output = stdout.read
+
+            expect(output).to match /Getting services in the space.*OK/
+
+            expect(output).to match /name\s+service\s+provider\s+version\s+plan\s+bound apps/
+            expect(output).to match /service-instance-.+?\s+  # name
+        service-.*?\s+                                  # service
+        provider.*?\s+                                  # provider
+        service_version\s+                              # version
+        service-plan-.*?\s+                             # plan
+        app-name-\d+\s+                                         # bound apps
+        /x
+
+          end
+
+          context "when one of the services does not have a service plan" do
+            let(:service_instances) { [service1, service2]}
+            let(:service2) { build(:user_provided_service_instance, :service_bindings => [service_binding]) }
+
+            it 'still produces a table of service' do
+              subject
+              stdout.rewind
+              output = stdout.read
+
+              expect(output).to match /Getting services in the space.*OK/
+
+              expect(output).to match /name\s+service\s+provider\s+version\s+plan\s+bound apps/
+
+              expect(output).to match /service-instance-.+?\s+  # name
+        service-.*?\s+                                  # service
+        provider.*?\s+                                  # provider
+        service_version\s+                              # version
+        service-plan-.*?\s+                             # plan
+        app-name-\d+\s+                                 # bound apps
+        /x
+
+              expect(output).to match /service-instance-.+?\s+  # name
+        user-provided\s+                                # service
+        n\/a\s+                                         # provider
+        n\/a\s+                                         # version
+        n\/a\s+                                         # plan
+        app-name-\d+\s+                                 # bound apps
+        /x
+            end
+          end
+
+          context 'when given --marketplace argument' do
+            it 'lists services on the target' do
+              client.stub(:services => Array.new(3) { build(:service) })
+              cf %W[services --marketplace]
+              expect(output).to say("Getting services... OK")
+              expect(output).to say(/service\s+version\s+provider\s+plans\s+description/)
+            end
+
+            context "when one of the services does not have a version or provider" do
+              it 'replaces those fields with n/a' do
+                client.stub(:services => [build(:service, :version => nil, :provider => nil)])
+                cf %W[services --marketplace]
+                expect(output).to say(/n\/a\s+n\/a/)
+              end
+            end
+          end
+        end
+
+        context "when the user is not targeted to a space" do
+          before do
+            service_command.stub(:check_logged_in).and_return(true)
+            client.stub(:current_organization).and_return(true)
+          end
+          let(:service_command) { CF::Service::Services.new(nil, {}) }
+          let(:current_space) { nil }
+
+          subject do
+            capture_output { service_command.execute(:services, inputs, global) }
+
+            #capture_output { CF::CLI.new.invoke(:services, inputs, given, global) }
+          end
+
+          it "returns an error" do
+            subject
+            stdout.rewind
+            output = stderr.read
+
+            expect(output.to_s).to match "Please select a space with 'truck target --space SPACE_NAME'"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe CF::Service::Unbind do
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:unbind_service] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Unbind a service from 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/space/base_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+module CF::Space
+  class Base; def fake_method; end
+  end
+end
+
+module CF
+  module Space
+    describe Base do
+      describe "#run" do
+        subject { CF::Space::Base.new }
+
+        it "uses a populator to set organization" do
+          organization = double
+          CF::Populators::Organization.should_receive(:new) { double(:populator, :populate_and_save! => organization) }
+          subject.run(:fake_method)
+          subject.org.should == organization
+        end
+      end
+
+      describe ".space_by_name" do
+        subject { CF::Space::Base.space_by_name }
+        let(:org) { double(:organization) }
+
+        before do
+          org.should_receive(:space_by_name).with("mySpace").and_return(space)
+        end
+
+
+        context "with a space" do
+          let(:space) { double(:space) }
+          it "returns a space matching the name from the given org" do
+            CF::Space::Base.space_by_name.call("mySpace", org).should == space
+          end
+        end
+
+        context "with no matching space" do
+          let(:space) { nil }
+          it "fails when no space matches the name" do
+            expect {
+              CF::Space::Base.space_by_name.call("mySpace", org)
+            }.to raise_exception
+          end
+        end
+      end
+    end
+  end
+end