Implement PATCH /v3/service_instances for managed services

api/handlers/job.go

@@ -32,6 +32,7 @@ const (
 	ServiceBrokerDeleteJobType          = "service_broker.delete"
 	ManagedServiceInstanceDeleteJobType = "managed_service_instance.delete"
 	ManagedServiceInstanceCreateJobType = "managed_service_instance.create"
+	ManagedServiceInstanceUpdateJobType = "managed_service_instance.update"
 	ManagedServiceBindingCreateJobType  = "managed_service_binding.create"
 	ManagedServiceBindingDeleteJobType  = "managed_service_binding.delete"
 	JobTimeoutDuration                  = 120.0

api/handlers/service_instance.go

@@ -30,7 +30,8 @@ const (
 type CFServiceInstanceRepository interface {
 	CreateUserProvidedServiceInstance(context.Context, authorization.Info, repositories.CreateUPSIMessage) (repositories.ServiceInstanceRecord, error)
 	CreateManagedServiceInstance(context.Context, authorization.Info, repositories.CreateManagedSIMessage) (repositories.ServiceInstanceRecord, error)
-	PatchServiceInstance(context.Context, authorization.Info, repositories.PatchServiceInstanceMessage) (repositories.ServiceInstanceRecord, error)
+	PatchUserProvidedServiceInstance(context.Context, authorization.Info, repositories.PatchUPSIMessage) (repositories.ServiceInstanceRecord, error)
+	PatchManagedServiceInstance(context.Context, authorization.Info, repositories.PatchManagedSIMessage) (repositories.ServiceInstanceRecord, error)
 	ListServiceInstances(context.Context, authorization.Info, repositories.ListServiceInstanceMessage) (repositories.ListResult[repositories.ServiceInstanceRecord], error)
 	GetServiceInstance(context.Context, authorization.Info, string) (repositories.ServiceInstanceRecord, error)
 	GetServiceInstanceCredentials(context.Context, authorization.Info, string) (map[string]any, error)
@@ -185,10 +186,21 @@ func (h *ServiceInstance) patch(r *http.Request) (*routing.Response, error) {
 		return nil, apierrors.LogAndReturn(logger, apierrors.ForbiddenAsNotFound(err), "failed to get service instance")
 	}
 
-	patchMessage := payload.ToServiceInstancePatchMessage(serviceInstance.SpaceGUID, serviceInstance.GUID)
-	serviceInstance, err = h.serviceInstanceRepo.PatchServiceInstance(r.Context(), authInfo, patchMessage)
+	if serviceInstance.Type == korifiv1alpha1.ManagedType {
+		patchMessage := payload.ToManagedSIPatchMessage(serviceInstance.SpaceGUID, serviceInstance.GUID)
+		serviceInstance, err = h.serviceInstanceRepo.PatchManagedServiceInstance(r.Context(), authInfo, patchMessage)
+		if err != nil {
+			return nil, apierrors.LogAndReturn(logger, err, "failed to patch managed service instance")
+		}
+
+		return routing.NewResponse(http.StatusAccepted).
+			WithHeader("Location", presenter.JobURLForRedirects(serviceInstance.GUID, presenter.ManagedServiceInstanceUpdateOperation, h.serverURL)), nil
+	}
+
+	patchMessage := payload.ToUPSIPatchMessage(serviceInstance.SpaceGUID, serviceInstance.GUID)
+	serviceInstance, err = h.serviceInstanceRepo.PatchUserProvidedServiceInstance(r.Context(), authInfo, patchMessage)
 	if err != nil {
-		return nil, apierrors.LogAndReturn(logger, err, "failed to patch service instance")
+		return nil, apierrors.LogAndReturn(logger, err, "failed to patch user provided service instance")
 	}
 
 	return routing.NewResponse(http.StatusOK).WithBody(presenter.ForServiceInstance(serviceInstance, h.serverURL)), nil

api/handlers/service_instance_test.go

@@ -846,7 +846,7 @@ var _ = Describe("ServiceInstance", func() {
 				},
 			})
 
-			serviceInstanceRepo.PatchServiceInstanceReturns(repositories.ServiceInstanceRecord{
+			serviceInstanceRepo.PatchUserProvidedServiceInstanceReturns(repositories.ServiceInstanceRecord{
 				Name: "new-name",
 				GUID: "service-instance-guid",
 			}, nil)
@@ -865,10 +865,10 @@ var _ = Describe("ServiceInstance", func() {
 			Expect(actualAuthInfo).To(Equal(authInfo))
 			Expect(actualGUID).To(Equal("service-instance-guid"))
 
-			Expect(serviceInstanceRepo.PatchServiceInstanceCallCount()).To(Equal(1))
-			_, actualAuthInfo, patchMessage := serviceInstanceRepo.PatchServiceInstanceArgsForCall(0)
+			Expect(serviceInstanceRepo.PatchUserProvidedServiceInstanceCallCount()).To(Equal(1))
+			_, actualAuthInfo, patchMessage := serviceInstanceRepo.PatchUserProvidedServiceInstanceArgsForCall(0)
 			Expect(actualAuthInfo).To(Equal(authInfo))
-			Expect(patchMessage).To(Equal(repositories.PatchServiceInstanceMessage{
+			Expect(patchMessage).To(Equal(repositories.PatchUPSIMessage{
 				GUID:        "service-instance-guid",
 				SpaceGUID:   "space-guid",
 				Name:        tools.PtrTo("new-name"),
@@ -927,13 +927,78 @@ var _ = Describe("ServiceInstance", func() {
 
 		When("patching the service instances fails", func() {
 			BeforeEach(func() {
-				serviceInstanceRepo.PatchServiceInstanceReturns(repositories.ServiceInstanceRecord{}, errors.New("oops"))
+				serviceInstanceRepo.PatchUserProvidedServiceInstanceReturns(repositories.ServiceInstanceRecord{}, errors.New("oops"))
 			})
 
 			It("returns the error", func() {
 				expectUnknownError()
 			})
 		})
+		When("updating a managed service instance", func() {
+			BeforeEach(func() {
+				requestValidator.DecodeAndValidateJSONPayloadStub = decodeAndValidatePayloadStub(&payloads.ServiceInstancePatch{
+					Name:        tools.PtrTo("new-name"),
+					Tags:        &[]string{"alice", "bob"},
+					Credentials: &map[string]any{"foo": "bar"},
+					Relationships: &payloads.ServiceInstanceRelationships{
+						ServicePlan: &payloads.Relationship{
+							Data: &payloads.RelationshipData{
+								GUID: "plan-guid",
+							},
+						},
+					},
+					Metadata: payloads.MetadataPatch{
+						Annotations: map[string]*string{"ann2": tools.PtrTo("ann_val2")},
+						Labels:      map[string]*string{"lab2": tools.PtrTo("lab_val2")},
+					},
+				})
+
+				serviceInstanceRepo.GetServiceInstanceReturns(repositories.ServiceInstanceRecord{
+					GUID:      "service-instance-guid",
+					SpaceGUID: "space-guid",
+					Type:      korifiv1alpha1.ManagedType,
+				}, nil)
+				serviceInstanceRepo.PatchManagedServiceInstanceReturns(repositories.ServiceInstanceRecord{
+					Name: "new-name",
+					GUID: "service-instance-guid",
+				}, nil)
+			})
+
+			It("patches the managed service instance", func() {
+				Expect(requestValidator.DecodeAndValidateJSONPayloadCallCount()).To(Equal(1))
+				actualReq, _ := requestValidator.DecodeAndValidateJSONPayloadArgsForCall(0)
+				Expect(bodyString(actualReq)).To(Equal("the-json-body"))
+
+				Expect(serviceInstanceRepo.PatchManagedServiceInstanceCallCount()).To(Equal(1))
+				_, actualAuthInfo, patchMessage := serviceInstanceRepo.PatchManagedServiceInstanceArgsForCall(0)
+				Expect(actualAuthInfo).To(Equal(authInfo))
+				Expect(patchMessage).To(Equal(repositories.PatchManagedSIMessage{
+					GUID:      "service-instance-guid",
+					SpaceGUID: "space-guid",
+					PlanGUID:  tools.PtrTo("plan-guid"),
+					Name:      tools.PtrTo("new-name"),
+					Tags:      &[]string{"alice", "bob"},
+					MetadataPatch: repositories.MetadataPatch{
+						Annotations: map[string]*string{"ann2": tools.PtrTo("ann_val2")},
+						Labels:      map[string]*string{"lab2": tools.PtrTo("lab_val2")},
+					},
+				}))
+			})
+			It("returns HTTP 202 Accepted response", func() {
+				Expect(rr).To(HaveHTTPStatus(http.StatusAccepted))
+				Expect(rr).To(HaveHTTPHeaderWithValue("Location",
+					ContainSubstring("/v3/jobs/managed_service_instance.update~service-instance-guid")))
+			})
+			When("patching the managed service instances fails", func() {
+				BeforeEach(func() {
+					serviceInstanceRepo.PatchManagedServiceInstanceReturns(repositories.ServiceInstanceRecord{}, errors.New("oops"))
+				})
+
+				It("returns the error", func() {
+					expectUnknownError()
+				})
+			})
+		})
 	})
 
 	Describe("DELETE /v3/service_instances/:guid", func() {

api/main.go

@@ -421,6 +421,7 @@ func main() {
 				handlers.ServiceBrokerCreateJobType:          serviceBrokerRepo,
 				handlers.ServiceBrokerUpdateJobType:          serviceBrokerRepo,
 				handlers.ManagedServiceInstanceCreateJobType: serviceInstanceRepo,
+				handlers.ManagedServiceInstanceUpdateJobType: serviceInstanceRepo,
 				handlers.ManagedServiceBindingCreateJobType:  serviceBindingRepo,
 			},
 			routeRepo,