V3 delete recursively user provided services (cloudfoundry#1996)

* WIP

Co-authored-by: Felisia Martini <fmartini@pivotal.io>

* v3(services) Recursively delete user provided service instances

Co-Authored-By: George Blue <blgm@users.noreply.github.com>

Co-authored-by: George Blue <gblue@pivotal.io>
Co-authored-by: George Blue <blgm@users.noreply.github.com>

Author: FelisiaM

app/actions/v3/service_instance_delete.rb

@@ -1,5 +1,6 @@
 require 'jobs/v3/delete_service_instance_job'
-require 'actions/services/locks/deleter_lock'
+require 'actions/service_route_binding_delete'
+require 'actions/service_credential_binding_delete'
 require 'cloud_controller/errors/api_error'
 
 module VCAP::CloudController
@@ -30,6 +31,11 @@ def initialize(service_instance, event_repo)
       def delete
         operation_in_progress! if service_instance.operation_in_progress? && service_instance.last_operation.type != 'create'
 
+        if service_instance.is_a?(UserProvidedServiceInstance)
+          errors = remove_bindings
+          raise errors.first if errors.any?
+        end
+
         result = send_deprovison_to_broker
         if result[:finished]
           destroy
@@ -117,6 +123,25 @@ def destroy
         end
       end
 
+      def remove_bindings
+        errors = []
+        route_bindings_action = ServiceRouteBindingDelete.new(service_event_repository.user_audit_info)
+        RouteBinding.where(service_instance: service_instance).each do |route_binding|
+          route_bindings_action.delete(route_binding)
+        rescue => e
+          errors << e
+        end
+
+        service_bindings_action = ServiceCredentialBindingDelete.new(:credential, service_event_repository.user_audit_info)
+        service_instance.service_bindings.each do |service_binding|
+          service_bindings_action.delete(service_binding)
+        rescue => e
+          errors << e
+        end
+
+        return errors
+      end
+
       def update_last_operation_with_operation_id(operation_id)
         service_instance.save_with_new_operation(
           {},

app/controllers/v3/service_instances_controller.rb

@@ -113,10 +113,10 @@ def destroy
     end
 
     delete_action = V3::ServiceInstanceDelete.new(service_instance, service_event_repository)
-    delete_action.delete_checks
 
     case service_instance
     when VCAP::CloudController::ManagedServiceInstance
+      delete_action.delete_checks
       job_guid = enqueue_delete_job(service_instance)
       head :accepted, 'Location' => url_builder.build_url(path: "/v3/jobs/#{job_guid}")
     when VCAP::CloudController::UserProvidedServiceInstance

spec/request/service_instances_spec.rb

@@ -2588,10 +2588,16 @@ def check_filtered_instances(*instances)
         expect(VCAP::CloudController::ServiceInstanceAnnotationModel.where(service_instance: instance).all).to be_empty
       end
 
-      it 'fails to delete when there are bindings' do
+      it 'deletes any related bindings' do
+        VCAP::CloudController::RouteBinding.make(service_instance: instance)
         VCAP::CloudController::ServiceBinding.make(service_instance: instance)
+
         api_call.call(admin_headers)
-        expect(last_response).to have_status_code(422)
+        expect(last_response).to have_status_code(204)
+
+        expect(VCAP::CloudController::ServiceInstance.all).to be_empty
+        expect(VCAP::CloudController::RouteBinding.all).to be_empty
+        expect(VCAP::CloudController::ServiceBinding.all).to be_empty
       end
 
       context 'with purge' do

spec/unit/actions/v3/service_instance_delete_spec.rb

@@ -79,6 +79,77 @@ module V3
             result = action.delete
             expect(result[:finished]).to be_truthy
           end
+
+          context 'when there are bindings' do
+            let(:delete_route_binding_action) do
+              double(ServiceRouteBindingDelete).tap do |d|
+                allow(d).to receive(:delete), &:destroy
+              end
+            end
+            let(:delete_service_binding_action) do
+              double(ServiceCredentialBindingDelete).tap do |d|
+                allow(d).to receive(:delete), &:destroy
+              end
+            end
+
+            let!(:route_binding_1) { RouteBinding.make(service_instance: service_instance) }
+            let!(:route_binding_2) { RouteBinding.make(service_instance: service_instance) }
+            let!(:route_binding_3) { RouteBinding.make(service_instance: service_instance) }
+            let!(:service_binding_1) { ServiceBinding.make(service_instance: service_instance) }
+            let!(:service_binding_2) { ServiceBinding.make(service_instance: service_instance) }
+            let!(:service_binding_3) { ServiceBinding.make(service_instance: service_instance) }
+
+            before do
+              allow(ServiceRouteBindingDelete).to receive(:new).and_return(delete_route_binding_action)
+              allow(ServiceCredentialBindingDelete).to receive(:new).and_return(delete_service_binding_action)
+            end
+
+            it 'unbinds all the bindings' do
+              action.delete
+
+              expect(ServiceRouteBindingDelete).to have_received(:new).with(event_repository.user_audit_info)
+              expect(delete_route_binding_action).to have_received(:delete).with(route_binding_1)
+              expect(delete_route_binding_action).to have_received(:delete).with(route_binding_2)
+              expect(delete_route_binding_action).to have_received(:delete).with(route_binding_3)
+
+              expect(ServiceCredentialBindingDelete).to have_received(:new).with(:credential, event_repository.user_audit_info)
+              expect(delete_service_binding_action).to have_received(:delete).with(service_binding_1)
+              expect(delete_service_binding_action).to have_received(:delete).with(service_binding_2)
+              expect(delete_service_binding_action).to have_received(:delete).with(service_binding_3)
+            end
+
+            context 'when deleting bindings raises' do
+              let(:delete_route_binding_action) do
+                double(ServiceRouteBindingDelete).tap do |d|
+                  allow(d).to receive(:delete) do |binding|
+                    raise StandardError.new('boom-route') if binding == route_binding_2
+
+                    binding.destroy
+                  end
+                end
+              end
+
+              let(:delete_service_binding_action) do
+                double(ServiceCredentialBindingDelete).tap do |d|
+                  allow(d).to receive(:delete) do |binding|
+                    raise StandardError.new('boom-credential') if binding == service_binding_2
+
+                    binding.destroy
+                  end
+                end
+              end
+
+              it 'attempts to remove other route bindings' do
+                expect {
+                  action.delete
+                }.to raise_error(StandardError, 'boom-route')
+
+                expect(ServiceInstance.all).to contain_exactly(service_instance)
+                expect(RouteBinding.all).to contain_exactly(route_binding_2)
+                expect(ServiceBinding.all).to contain_exactly(service_binding_2)
+              end
+            end
+          end
         end
 
         context 'managed service instances' do