cf 4.2.9.rc5 → 4.2.10.rc1

data/lib/cf/cli/user/passwd.rb

@@ -3,7 +3,7 @@ require "cf/cli/user/base"
 module CF::User
   class Passwd < Base
     desc "Update the current user's password"
-    group :admin, :user, :hidden => true
+    group :admin, :user
     input :password, :desc => "Current password"
     input :new_password, :desc => "New password"
     input :verify, :desc => "Repeat new password"

data/lib/cf/cli/user/register.rb

@@ -5,7 +5,7 @@ module CF::User
     def precondition; end
 
     desc "Create a user and log in"
-    group :admin, :user, :hidden => true
+    group :admin, :user
     input :email, :desc => "Desired email", :argument => :optional
     input :password, :desc => "Desired password"
     input :verify, :desc => "Repeat password"

data/lib/cf/cli/user/users.rb

@@ -3,7 +3,7 @@ require "cf/cli/user/base"
 module CF::User
   class Users < Base
     desc "List all users"
-    group :admin, :hidden => true
+    group :admin
     def users
       users =
         with_progress("Getting users") do

data/lib/cf/version.rb

@@ -1,3 +1,3 @@
 module CF
-  VERSION = "4.2.9.rc5".freeze
+  VERSION = "4.2.10.rc1".freeze
 end

data/lib/manifests/manifests.rb

@@ -1,6 +1,5 @@
 require "yaml"
 require "set"
-require "cf/cli/service/create"
 
 require "manifests/loader"
 
@@ -183,23 +182,16 @@ module CFManifests
     unless services.empty?
       meta["services"] = {}
 
-      services.each do |service_instance|
-        if service_instance.is_a?(CFoundry::V2::UserProvidedServiceInstance)
-          meta["services"][service_instance.name] = {
-            "label" => "user-provided",
-            "credentials" => service_instance.credentials.stringify_keys,
-          }
-        else
-          service_plan = service_instance.service_plan
-          service = service_plan.service
-
-          meta["services"][service_instance.name] = {
-            "label" => service.label,
-            "provider" => service.provider,
-            "version" => service.version,
-            "plan" => service_plan.name
-          }
-        end
+      services.each do |i|
+        p = i.service_plan
+        s = p.service
+
+        meta["services"][i.name] = {
+          "label" => s.label,
+          "provider" => s.provider,
+          "version" => s.version,
+          "plan" => p.name
+        }
       end
     end
 
@@ -300,33 +292,25 @@ module CFManifests
       if instance = client.service_instance_by_name(name)
         to_bind << instance
       else
-        if svc[:label] == "user-provided"
-          invoke :create_service,
-            name: name,
-            offering: CF::Service::UPDummy.new,
-            app: app,
-            credentials: svc[:credentials]
-        else
-          offering = offerings.find { |o|
-            o.label == (svc[:label] || svc[:type] || svc[:vendor]) &&
-              (!svc[:version] || o.version == svc[:version]) &&
-              (o.provider == (svc[:provider] || "core"))
-          }
+        offering = offerings.find { |o|
+          o.label == (svc[:label] || svc[:type] || svc[:vendor]) &&
+            (!svc[:version] || o.version == svc[:version]) &&
+            (o.provider == (svc[:provider] || "core"))
+        }
 
-          fail "Unknown service offering: #{svc.inspect}." unless offering
+        fail "Unknown service offering: #{svc.inspect}." unless offering
 
-          plan = offering.service_plans.find { |p|
-            p.name == (svc[:plan] || "D100")
-          }
+        plan = offering.service_plans.find { |p|
+          p.name == (svc[:plan] || "D100")
+        }
 
-          fail "Unknown service plan: #{svc[:plan]}." unless plan
+        fail "Unknown service plan: #{svc[:plan]}." unless plan
 
-          invoke :create_service,
-            :name => name,
-            :offering => offering,
-            :plan => plan,
-            :app => app
-        end
+        invoke :create_service,
+          :name => name,
+          :offering => offering,
+          :plan => plan,
+          :app => app
       end
     end
 

data/lib/tasks/gem_release.rake

@@ -20,8 +20,8 @@ namespace :gem do
   def generate_release_notes(old_version)
     print_with_purpose "Generating release notes..."
     file_name = "release_#{gem_version}"
-    #sh!("anchorman notes --name=#{file_name} --from=v#{old_version}")
-    #sh!("git add release_notes")
+    sh!("anchorman notes --name=#{file_name} --from=v#{old_version}")
+    sh!("git add release_notes")
   end
 
   def sh!(cmd)

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(:managed_service_instance, :name => "service-instance-name-1") }
-        let(:service_2) { build(:managed_service_instance, :name => "service-instance-name-2") }
+        let(:service_1) { build(:service_instance, :name => "service-instance-name-1") }
+        let(:service_2) { build(: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(:managed_service_instance) } }
+      let(:service_instances) { Array.new(5) { build(: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::ManagedServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
-            CFoundry::V2::ManagedServiceInstance.any_instance.should_receive(:create!)
+            CFoundry::V2::ServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
+            CFoundry::V2::ServiceInstance.any_instance.should_receive(:create!)
             capture_output { command }
           end
         end
@@ -89,59 +89,11 @@ module CF
           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!)
+            CFoundry::V2::ServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
+            CFoundry::V2::ServiceInstance.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_print("What credential parameters should applications use to connect to this service instance? (e.g. hostname, port, password)")
-            should_ask("Keys") { "host, port, user name" }
-            should_print("'user name' is not a valid key")
-            should_ask("Keys") { "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(:managed_service_instance) } }
+    let(:services) { Array.new(2) { build(:service_instance) } }
     let(:renamed_service) { services.first }
 
     context "when the defaults are used" do

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

@@ -42,34 +42,29 @@ 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(:managed_service_instance, :service_plan => service_plan, :service_bindings => [service_binding]) }
+        let(:service1) { build(: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) }
+          capture_output { Mothership.new.invoke(:services, inputs, given, global) }
         end
 
         before do
-          stub_client
+          stub_client_and_precondition
           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
+        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
@@ -77,69 +72,45 @@ module CF
         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]) }
+        end
 
-            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(:service_instance, :service_plan => nil, :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 /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 /name\s+service\s+provider\s+version\s+plan\s+bound apps/
 
-              expect(output).to match /service-instance-.+?\s+  # name
+            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
-        user-provided\s+                                # service
-        n\/a\s+                                         # provider
-        n\/a\s+                                         # version
-        n\/a\s+                                         # plan
-        app-name-\d+\s+                                 # bound apps
+            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
         /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
 
-            expect(output.to_s).to match "Please select a space with 'cf target --space SPACE_NAME'"
+        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

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

@@ -29,7 +29,7 @@ module CF
 
         let(:apps) { Array.new(2) { build(:app) } }
         let(:domains) { Array.new(2) { build(:domain) } }
-        let(:services) { Array.new(2) { build(:managed_service_instance) } }
+        let(:services) { Array.new(2) { build(:service_instance) } }
         let(:space) { build(:space, :name => "some_space_name", :apps => apps, :service_instances => services, :domains => domains, :organization => organization ) }
         let(:spaces) { [space] }
         let(:organization) { build(:organization, :name => "Spacey Org") }

data/spec/cf/cli/space/spaces_spec.rb

@@ -5,9 +5,9 @@ module CF
     describe Spaces do
       let(:full) { false }
       let(:app) { build(:app) }
-      let!(:space_1) { build(:space, :name => "bb_second", :apps => [app], :service_instances => [build(:managed_service_instance)]) }
-      let!(:space_2) { build(:space, :name => "aa_first", :apps => [app], :service_instances => [build(:managed_service_instance)], :domains => [build(:domain)]) }
-      let!(:space_3) { build(:space, :name => "cc_last", :apps => [app], :service_instances => [build(:managed_service_instance)], :domains => [build(:domain)]) }
+      let!(:space_1) { build(:space, :name => "bb_second", :apps => [app], :service_instances => [build(:service_instance)]) }
+      let!(:space_2) { build(:space, :name => "aa_first", :apps => [app], :service_instances => [build(:service_instance)], :domains => [build(:domain)]) }
+      let!(:space_3) { build(:space, :name => "cc_last", :apps => [app], :service_instances => [build(:service_instance)], :domains => [build(:domain)]) }
       let(:spaces) { [space_1, space_2, space_3] }
       let(:organization) { build(:organization, :spaces => spaces, :name => "foo") }
       let(:client) do

data/spec/factories/cfoundry/v2/{managed_service_instances_factory.rb → service_instances_factory.rb}

@@ -1,5 +1,5 @@
 FactoryGirl.define do
-  factory :managed_service_instance, :class => CFoundry::V2::ManagedServiceInstance do
+  factory :service_instance, :class => CFoundry::V2::ServiceInstance do
     sequence(:guid) { |n| "service-instance-guid-#{n}" }
     sequence(:name) { |n| "service-instance-name-#{n}" }
 
@@ -9,4 +9,4 @@ FactoryGirl.define do
 
     initialize_with { new(guid, client) }
   end
-end
+end

data/spec/features/services_spec.rb

@@ -6,25 +6,6 @@ if ENV['CF_V2_RUN_INTEGRATION']
       login
     end
 
-    describe "listing services" do
-      let(:service1) { "some-provided-instance-#{Time.now.to_i}" }
-      let(:service2) { "cf-managed-instance-#{Time.now.to_i}" }
-
-      it "shows all service instances in the space" do
-        create_service_instance("user-provided", service1, credentials: { hostname: "myservice.com"} )
-        create_service_instance("dummy-dev", service2, plan: "small")
-
-        BlueShell::Runner.run("#{cf_bin} services") do |runner|
-          expect(runner).to say /#{service1}\s+user-provided\s+n\/a\s+n\/a\s+n\/a\s+.*/
-        end
-      end
-
-      after do
-        delete_service(service1)
-        delete_service(service2)
-      end
-    end
-
     describe "creating a service" do
       describe "when the user leaves the line blank for a plan" do
         it "re-prompts for the plan" do
@@ -39,83 +20,6 @@ if ENV['CF_V2_RUN_INTEGRATION']
           end
         end
       end
-
-      describe "when the service is a user-provided instance" do
-        let(:service_name) { "my-private-db-#{Random.rand(1000) + 1000}"}
-
-        it "can create a service instance" do
-          BlueShell::Runner.run("#{cf_bin} create-service") do |runner|
-            expect(runner).to say "What kind?"
-            runner.send_keys "user-provided"
-
-            expect(runner).to say "Name?"
-            runner.send_keys service_name
-
-            expect(runner).to say "What credential parameters should applications use to connect to this service instance? (e.g. hostname, port, password)\nKeys"
-            runner.send_keys "hostname"
-            expect(runner).to say "hostname"
-            runner.send_keys "myserviceinstance.com"
-
-            expect(runner).to say /Creating service #{service_name}.+ OK/
-          end
-        end
-
-        after do
-          delete_service(service_name)
-        end
-      end
-    end
-
-    describe "binding to a service" do
-      let(:app_folder) { "env" }
-      let(:app_name) { "services_env_test_app-#{Time.now.to_i}" }
-
-      let(:service_name) { "some-provided-instance-#{Time.now.to_i}" }
-
-      it "can bind and unbind user-provided services to apps" do
-        push_app(app_folder, app_name, start_command: "'bundle exec ruby env_test.rb -p $PORT'", timeout: 90)
-        create_service_instance("user-provided", service_name, credentials: { hostname: "myservice.com"} )
-
-        BlueShell::Runner.run("#{cf_bin} bind-service") do |runner|
-          expect(runner).to say "Which application?>"
-          runner.send_keys app_name
-
-          expect(runner).to say "Which service?>"
-          runner.send_keys service_name
-
-          expect(runner).to say "Binding #{service_name} to #{app_name}... OK"
-        end
-
-        BlueShell::Runner.run("#{cf_bin} unbind-service") do |runner|
-          expect(runner).to say "Which application?"
-          runner.send_keys app_name
-
-          expect(runner).to say "Which service?>"
-          runner.send_keys service_name
-
-          expect(runner).to say "Unbinding #{service_name} from #{app_name}... OK"
-        end
-      end
-
-      after do
-        delete_app(app_name)
-      end
-    end
-
-    def delete_service(service_name)
-      BlueShell::Runner.run("#{cf_bin} delete-service --service #{service_name} --force") do |runner|
-        expect(runner).to say "Deleting #{service_name}... OK"
-      end
-    end
-
-    def delete_app(app_name, routes=true)
-      delete_cmd = "#{cf_bin} delete #{app_name}"
-      delete_cmd + " --routes" if routes
-      BlueShell::Runner.run(delete_cmd) do |runner|
-        expect(runner).to say "Really delete #{app_name}?"
-        runner.send_keys "y"
-        expect(runner).to say "Deleting #{app_name}... OK"
-      end
     end
   end
 end