cf 5.0.0.rc1 → 5.0.0.rc3

data/lib/tasks/gem_release.rake

@@ -10,7 +10,7 @@ namespace :gem do
     sh! "git add lib/cf/version.rb"
 
     print_with_purpose "Bumping to version #{gem_version}"
-    #generate_release_notes(old_version)
+    generate_release_notes(old_version)
     sh!("git commit -m 'Bumping to version #{gem_version}.'")
     sh!("git push")
     sh!("gem release --tag")

data/spec/admin/service_broker/add_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe CFAdmin::ServiceBroker::Add do
+  let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_admin_dir" }
+
+  stub_home_dir_with { fake_home_dir }
+
+  let(:client) { build(:client) }
+
+  let(:service_broker) { CFoundry::V2::ServiceBroker.new(nil, client) }
+
+  before do
+    CFAdmin::ServiceBroker::Add.client = client
+    client.stub(:service_broker).and_return(service_broker)
+  end
+
+  it "creates a service broker when arguments are provided on the command line" do
+    service_broker.stub(:create!)
+
+    cf %W[add-service-broker --name cf-mysql --url http://cf-mysql.cfapp.io --token cfmysqlsecret]
+
+    service_broker.name.should == 'cf-mysql'
+    service_broker.broker_url.should == 'http://cf-mysql.cfapp.io'
+    service_broker.token.should == 'cfmysqlsecret'
+
+    service_broker.should have_received(:create!)
+  end
+
+  it "creates a service broker when only the name is provided" do
+    service_broker.stub(:create!)
+
+    stub_ask("url").and_return("http://example.com")
+    stub_ask("token").and_return("token")
+
+    cf %W[add-service-broker cf-mysql]
+
+    service_broker.name.should == 'cf-mysql'
+    service_broker.broker_url.should == 'http://example.com'
+    service_broker.token.should == 'token'
+
+    service_broker.should have_received(:create!)
+  end
+
+  it "creates a service broker when no arguments are provided" do
+    service_broker.stub(:create!)
+
+    stub_ask("name").and_return("cf-mysql")
+    stub_ask("url").and_return("http://example.com")
+    stub_ask("token").and_return("token")
+
+    cf %W[add-service-broker]
+
+    service_broker.name.should == 'cf-mysql'
+    service_broker.broker_url.should == 'http://example.com'
+    service_broker.token.should == 'token'
+
+    service_broker.should have_received(:create!)
+  end
+end

data/spec/assets/env/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+gem 'bundler'
+gem 'sinatra'
+gem 'json'

data/spec/assets/env/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    json (1.8.0)
+    rack (1.5.2)
+    rack-protection (1.5.0)
+      rack
+    sinatra (1.4.3)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    tilt (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  json
+  sinatra

data/spec/assets/env/env_test.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'sinatra'
+require 'json'
+
+$stdout.sync = true
+
+def dump_env(fmt)
+  if fmt == 'html' || fmt == nil
+    res = ''
+    ENV.each do |k, v|
+      res << "#{k}: #{v}<br/>"
+    end
+    res
+  elsif fmt == 'json'
+    res = {}
+    ENV.each do |k, v|
+      res[k] = v
+    end
+    puts res
+    res.to_json
+  end
+end
+
+get '/' do
+  dump_env('html')
+end
+
+get '/healthcheck' do
+  "OK"
+end
+
+get '/env' do
+  dump_env('json')
+end
+
+
+get '/services' do
+  app_instance = JSON.parse(ENV['VCAP_APPLICATION'])
+  services = JSON.parse(ENV['VCAP_SERVICES'])
+
+  valid_services = false
+  service_list = []
+  services.each do |k, v|
+    v.each do |i|
+      s = {}
+      s['vendor'] = k.split('-')[0]
+      s['name'] = i['name']
+      service_list << s
+      valid_services = true
+    end
+  end
+  response = "{\"status\":\"ok\", \"services\": #{service_list.to_json}}" if valid_services
+  response = "{\"status\":\"fail\", \"services\": []}" if !valid_services
+
+  puts "my response: #{response}"
+  response
+end

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

@@ -52,8 +52,8 @@ module CF
       end
 
       context "when there are apps" do
-        let(:service_1) { build(:service_instance, :name => "service-instance-name-1") }
-        let(:service_2) { build(:service_instance, :name => "service-instance-name-2") }
+        let(:service_1) { build(:managed_service_instance, :name => "service-instance-name-1") }
+        let(:service_2) { build(:managed_service_instance, :name => "service-instance-name-2") }
 
         let(:service_binding_1) { build(:service_binding, :service_instance => service_1) }
         let(:service_binding_2) { build(:service_binding, :service_instance => service_2) }

data/spec/cf/cli/app/push/create_spec.rb

@@ -7,7 +7,7 @@ module CF
       let(:given) { {} }
       let(:global) { {:color => false, :quiet => true} }
 
-      let(:service_instances) { Array.new(5) { build(:service_instance) } }
+      let(:service_instances) { Array.new(5) { build(:managed_service_instance) } }
       let(:lucid64) { build(:stack, :name => "lucid64") }
       let(:client) { build(:client) }
 

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

@@ -73,8 +73,8 @@ module CF
           } }
 
           it "creates the specified service" do
-            CFoundry::V2::ServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
-            CFoundry::V2::ServiceInstance.any_instance.should_receive(:create!)
+            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
@@ -89,11 +89,58 @@ module CF
           let(:services) { [selected_service] }
 
           it "uses case insensitive match" do
-            CFoundry::V2::ServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
-            CFoundry::V2::ServiceInstance.any_instance.should_receive(:create!)
+            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

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

@@ -51,7 +51,7 @@ describe CF::Service::Rename do
   end
 
   context "when there are services" do
-    let(:services) { Array.new(2) { build(:service_instance) } }
+    let(:services) { Array.new(2) { build(:managed_service_instance) } }
     let(:renamed_service) { services.first }
 
     context "when the defaults are used" do

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 ManagedSerivceInstanceHelper 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/services_spec.rb

@@ -42,29 +42,34 @@ module CF
 
         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(:service_instance, :service_plan => service_plan, :service_bindings => [service_binding]) }
+        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 { Mothership.new.invoke(:services, inputs, given, global) }
+          capture_output { CF::CLI.new.invoke(:services, inputs, given, global) }
         end
 
         before do
-          stub_client_and_precondition
+          stub_client
           client.stub(:service_bindings).and_return([service_binding])
         end
 
-        it "produces a table of services" do
-          subject
-          stdout.rewind
-          output = stdout.read
+        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 /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
+            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
@@ -72,45 +77,69 @@ module CF
         app-name-\d+\s+                                         # bound apps
         /x
 
-        end
+          end
 
-        context "when one of the services does not have a service plan" do
-          let(:service_instances) { [service1, service2]}
-          let(:service2) { build(:service_instance, :service_plan => nil, :service_bindings => [service_binding]) }
-          it 'still produces a table of service' do
-            subject
-            stdout.rewind
-            output = stdout.read
+          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]) }
 
-            expect(output).to match /Getting services in the space.*OK/
+            it 'still produces a table of service' do
+              subject
+              stdout.rewind
+              output = stdout.read
 
-            expect(output).to match /name\s+service\s+provider\s+version\s+plan\s+bound apps/
+              expect(output).to match /Getting services in the space.*OK/
 
-            expect(output).to match /service-instance-.+?\s+  # name
+              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
+        app-name-\d+\s+                                 # bound apps
         /x
 
-            expect(output).to match /service-instance-.+?\s+  # name
-        none\s+                                  # service
-        none\s+                                  # provider
-        none\s+                              # version
-        none\s+                             # plan
-        app-name-\d+\s+                                         # bound apps
+              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
           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
 
-        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/)
+            expect(output.to_s).to match "Please select a space with 'cf target --space SPACE_NAME'"
           end
         end
       end