Implement API PATCH /v3/service_offerings/:guid (#4053)

Author: ybykov-a9s

api/handlers/fake/cfservice_offering_repository.go

@@ -24,6 +24,7 @@ const (
 //counterfeiter:generate -o fake -fake-name CFServiceOfferingRepository . CFServiceOfferingRepository
 type CFServiceOfferingRepository interface {
 	GetServiceOffering(context.Context, authorization.Info, string) (repositories.ServiceOfferingRecord, error)
+	UpdateServiceOffering(context.Context, authorization.Info, repositories.UpdateServiceOfferingMessage) (repositories.ServiceOfferingRecord, error)
 	ListOfferings(context.Context, authorization.Info, repositories.ListServiceOfferingMessage) ([]repositories.ServiceOfferingRecord, error)
 	DeleteOffering(context.Context, authorization.Info, repositories.DeleteServiceOfferingMessage) error
 }
@@ -79,6 +80,30 @@ func (h *ServiceOffering) get(r *http.Request) (*routing.Response, error) {
 	return routing.NewResponse(http.StatusOK).WithBody(presenter.ForServiceOffering(serviceOffering, h.serverURL, includedResources...)), nil
 }
 
+func (h *ServiceOffering) update(r *http.Request) (*routing.Response, error) {
+	authInfo, _ := authorization.InfoFromContext(r.Context())
+	logger := logr.FromContextOrDiscard(r.Context()).WithName("handlers.service-offering.update")
+
+	serviceOfferingGUID := routing.URLParam(r, "guid")
+
+	var payload payloads.ServiceOfferingUpdate
+	if err := h.requestValidator.DecodeAndValidateJSONPayload(r, &payload); err != nil {
+		return nil, apierrors.LogAndReturn(logger, err, "failed to decode payload")
+	}
+
+	_, err := h.serviceOfferingRepo.GetServiceOffering(r.Context(), authInfo, serviceOfferingGUID)
+	if err != nil {
+		return nil, apierrors.LogAndReturn(logger, apierrors.ForbiddenAsNotFound(err), "Error getting service offering in repository")
+	}
+
+	serviceOffering, err := h.serviceOfferingRepo.UpdateServiceOffering(r.Context(), authInfo, payload.ToMessage(serviceOfferingGUID))
+	if err != nil {
+		return nil, apierrors.LogAndReturn(logger, err, "Error updating service offering in repository")
+	}
+
+	return routing.NewResponse(http.StatusOK).WithBody(presenter.ForServiceOffering(serviceOffering, h.serverURL)), nil
+}
+
 func (h *ServiceOffering) list(r *http.Request) (*routing.Response, error) {
 	authInfo, _ := authorization.InfoFromContext(r.Context())
 	logger := logr.FromContextOrDiscard(r.Context()).WithName("handlers.service-offering.list")
@@ -125,6 +150,7 @@ func (h *ServiceOffering) UnauthenticatedRoutes() []routing.Route {
 func (h *ServiceOffering) AuthenticatedRoutes() []routing.Route {
 	return []routing.Route{
 		{Method: "GET", Pattern: ServiceOfferingPath, Handler: h.get},
+		{Method: "PATCH", Pattern: ServiceOfferingPath, Handler: h.update},
 		{Method: "GET", Pattern: ServiceOfferingsPath, Handler: h.list},
 		{Method: "DELETE", Pattern: ServiceOfferingPath, Handler: h.delete},
 	}

api/handlers/service_offering.go

@@ -13,6 +13,7 @@ import (
 	"code.cloudfoundry.org/korifi/api/repositories/k8sklient/descriptors"
 	"code.cloudfoundry.org/korifi/api/repositories/relationships"
 	. "code.cloudfoundry.org/korifi/tests/matchers"
+	"code.cloudfoundry.org/korifi/tools"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -325,4 +326,78 @@ var _ = Describe("ServiceOffering", func() {
 			})
 		})
 	})
+
+	Describe("PATCH /v3/service_offering/:guid", func() {
+		BeforeEach(func() {
+			serviceOfferingRepo.UpdateServiceOfferingReturns(repositories.ServiceOfferingRecord{
+				GUID: "offering-guid",
+			}, nil)
+
+			payload := payloads.ServiceOfferingUpdate{
+				Metadata: payloads.MetadataPatch{
+					Labels:      map[string]*string{"foo": tools.PtrTo("bar")},
+					Annotations: map[string]*string{"bar": tools.PtrTo("baz")},
+				},
+			}
+
+			requestValidator.DecodeAndValidateJSONPayloadStub = decodeAndValidatePayloadStub(&payload)
+		})
+
+		JustBeforeEach(func() {
+			req, err := http.NewRequestWithContext(ctx, "PATCH", "/v3/service_offerings/offering-guid", nil)
+			Expect(err).NotTo(HaveOccurred())
+
+			routerBuilder.Build().ServeHTTP(rr, req)
+		})
+
+		It("updates the service offering", func() {
+			Expect(rr).Should(HaveHTTPStatus(http.StatusOK))
+			Expect(rr).To(HaveHTTPHeaderWithValue("Content-Type", "application/json"))
+			Expect(rr).To(HaveHTTPBody(SatisfyAll(
+				MatchJSONPath("$.guid", "offering-guid"),
+				MatchJSONPath("$.links.self.href", "https://api.example.org/v3/service_offerings/offering-guid"),
+			)))
+
+			Expect(serviceOfferingRepo.UpdateServiceOfferingCallCount()).To(Equal(1))
+			_, actualAuthInfo, updateMessage := serviceOfferingRepo.UpdateServiceOfferingArgsForCall(0)
+			Expect(actualAuthInfo).To(Equal(authInfo))
+			Expect(updateMessage).To(Equal(repositories.UpdateServiceOfferingMessage{
+				GUID: "offering-guid",
+				MetadataPatch: repositories.MetadataPatch{
+					Labels:      map[string]*string{"foo": tools.PtrTo("bar")},
+					Annotations: map[string]*string{"bar": tools.PtrTo("baz")},
+				},
+			}))
+		})
+
+		When("the request is invalid", func() {
+			BeforeEach(func() {
+				requestValidator.DecodeAndValidateJSONPayloadReturns(errors.New("invalid-request"))
+			})
+
+			It("returns an error", func() {
+				expectUnknownError()
+			})
+		})
+
+		When("user is not allowed to get a process", func() {
+			BeforeEach(func() {
+				serviceOfferingRepo.GetServiceOfferingReturns(repositories.ServiceOfferingRecord{}, apierrors.NewForbiddenError(errors.New("Forbidden"), repositories.ServiceOfferingResourceType))
+			})
+
+			It("returns a not found error", func() {
+				expectNotFoundError(repositories.ServiceOfferingResourceType)
+			})
+		})
+
+		When("the service offering repo returns an error", func() {
+			BeforeEach(func() {
+				serviceOfferingRepo.UpdateServiceOfferingReturns(repositories.ServiceOfferingRecord{}, errors.New("update-so-error"))
+			})
+
+			It("returns an error", func() {
+				expectUnknownError()
+			})
+		})
+	})
 })

api/handlers/service_offering_test.go

@@ -47,6 +47,26 @@ func (l *ServiceOfferingGet) DecodeFromURLValues(values url.Values) error {
 	return nil
 }
 
+type ServiceOfferingUpdate struct {
+	Metadata MetadataPatch `json:"metadata"`
+}
+
+func (g ServiceOfferingUpdate) Validate() error {
+	return jellidation.ValidateStruct(&g,
+		jellidation.Field(&g.Metadata),
+	)
+}
+
+func (c *ServiceOfferingUpdate) ToMessage(serviceOfferingGUID string) repositories.UpdateServiceOfferingMessage {
+	return repositories.UpdateServiceOfferingMessage{
+		GUID: serviceOfferingGUID,
+		MetadataPatch: repositories.MetadataPatch{
+			Labels:      c.Metadata.Labels,
+			Annotations: c.Metadata.Annotations,
+		},
+	}
+}
+
 type ServiceOfferingList struct {
 	Names                string
 	BrokerNames          string

api/payloads/service_offering.go

@@ -65,11 +65,20 @@ type ListServiceOfferingMessage struct {
 	BrokerNames []string
 }
 
+type UpdateServiceOfferingMessage struct {
+	GUID          string
+	MetadataPatch MetadataPatch
+}
+
 type DeleteServiceOfferingMessage struct {
 	GUID  string
 	Purge bool
 }
 
+func (m UpdateServiceOfferingMessage) apply(offering *korifiv1alpha1.CFServiceOffering) {
+	m.MetadataPatch.Apply(offering)
+}
+
 func (m *ListServiceOfferingMessage) toListOptions() []ListOption {
 	return []ListOption{
 		WithLabelIn(korifiv1alpha1.CFServiceOfferingNameKey, tools.EncodeValuesToSha224(m.Names...)),
@@ -258,3 +267,20 @@ func (r *ServiceOfferingRepo) fetchServiceBindings(ctx context.Context, serviceI
 
 	return bindings.Items, nil
 }
+
+func (r *ServiceOfferingRepo) UpdateServiceOffering(ctx context.Context, authInfo authorization.Info, message UpdateServiceOfferingMessage) (ServiceOfferingRecord, error) {
+	offering := &korifiv1alpha1.CFServiceOffering{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: r.rootNamespace,
+			Name:      message.GUID,
+		},
+	}
+	if err := GetAndPatch(ctx, r.rootNSKlient, offering, func() error {
+		message.apply(offering)
+		return nil
+	}); err != nil {
+		return ServiceOfferingRecord{}, fmt.Errorf("failed to patch service offering metadata: %w", apierrors.FromK8sError(err, ServiceOfferingResourceType))
+	}
+
+	return offeringToRecord(*offering)
+}