Update more functionality to publish service

[nonrtric/plt/sme.git] / capifcore / internal / publishservice / publishservice_test.go

diff --git a/capifcore/internal/publishservice/publishservice_test.go b/capifcore/internal/publishservice/publishservice_test.go
index ab92363..2483053 100644 (file)
--- a/capifcore/internal/publishservice/publishservice_test.go
+++ b/capifcore/internal/publishservice/publishservice_test.go
@@ -25,8 +25,10 @@ import (
        "net/http"
        "os"
        "testing"
+       "time"
 
        "oransc.org/nonrtric/capifcore/internal/common29122"
+       "oransc.org/nonrtric/capifcore/internal/eventsapi"
        "oransc.org/nonrtric/capifcore/internal/providermanagement"
 
        "github.com/labstack/echo/v4"
@@ -51,7 +53,7 @@ func TestPublishUnpublishService(t *testing.T) {
        serviceRegisterMock.On("GetAefsForPublisher", apfId).Return([]string{aefId, "otherAefId"})
        helmManagerMock := helmMocks.HelmManager{}
        helmManagerMock.On("InstallHelmChart", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-       serviceUnderTest, requestHandler := getEcho(&serviceRegisterMock, &helmManagerMock)
+       serviceUnderTest, eventChannel, requestHandler := getEcho(&serviceRegisterMock, &helmManagerMock)
 
        // Check no services published for provider
        result := testutil.NewRequest().Get("/"+apfId+"/service-apis").Go(t, requestHandler)
@@ -83,6 +85,12 @@ func TestPublishUnpublishService(t *testing.T) {
        serviceRegisterMock.AssertCalled(t, "GetAefsForPublisher", apfId)
        helmManagerMock.AssertCalled(t, "InstallHelmChart", namespace, repoName, chartName, releaseName)
        assert.ElementsMatch(t, []string{aefId}, serviceUnderTest.getAllAefIds())
+       if publishEvent, ok := waitForEvent(eventChannel, 1*time.Second); ok {
+               assert.Fail(t, "No event sent")
+       } else {
+               assert.Equal(t, *resultService.ApiId, (*publishEvent.EventDetail.ApiIds)[0])
+               assert.Equal(t, eventsapi.CAPIFEventSERVICEAPIAVAILABLE, publishEvent.Events)
+       }
 
        // Check that the service is published for the provider
        result = testutil.NewRequest().Get("/"+apfId+"/service-apis/"+newApiId).Go(t, requestHandler)
@@ -103,6 +111,13 @@ func TestPublishUnpublishService(t *testing.T) {
        // Check no services published
        result = testutil.NewRequest().Get("/"+apfId+"/service-apis/"+newApiId).Go(t, requestHandler)
 
+       if publishEvent, ok := waitForEvent(eventChannel, 1*time.Second); ok {
+               assert.Fail(t, "No event sent")
+       } else {
+               assert.Equal(t, *resultService.ApiId, (*publishEvent.EventDetail.ApiIds)[0])
+               assert.Equal(t, eventsapi.CAPIFEventSERVICEAPIUNAVAILABLE, publishEvent.Events)
+       }
+
        assert.Equal(t, http.StatusNotFound, result.Code())
 }
 
@@ -111,9 +126,9 @@ func TestPostUnpublishedServiceWithUnregisteredFunction(t *testing.T) {
        aefId := "aefId"
        serviceRegisterMock := serviceMocks.ServiceRegister{}
        serviceRegisterMock.On("GetAefsForPublisher", apfId).Return([]string{"otherAefId"})
-       _, requestHandler := getEcho(&serviceRegisterMock, nil)
+       _, _, requestHandler := getEcho(&serviceRegisterMock, nil)
 
-       newServiceDescription := getServiceAPIDescription(aefId, "apiname", "description")
+       newServiceDescription := getServiceAPIDescription(aefId, "apiName", "description")
 
        // Publish a service
        result := testutil.NewRequest().Post("/"+apfId+"/service-apis").WithJsonBody(newServiceDescription).Go(t, requestHandler)
@@ -133,7 +148,7 @@ func TestGetServices(t *testing.T) {
        aefId := "aefId"
        serviceRegisterMock := serviceMocks.ServiceRegister{}
        serviceRegisterMock.On("GetAefsForPublisher", apfId).Return([]string{aefId})
-       _, requestHandler := getEcho(&serviceRegisterMock, nil)
+       _, _, requestHandler := getEcho(&serviceRegisterMock, nil)
 
        // Check no services published for provider
        result := testutil.NewRequest().Get("/"+apfId+"/service-apis").Go(t, requestHandler)
@@ -163,7 +178,7 @@ func TestGetServices(t *testing.T) {
 }
 
 func TestGetPublishedServices(t *testing.T) {
-       serviceUnderTest := NewPublishService(nil, nil)
+       serviceUnderTest := NewPublishService(nil, nil, nil)
 
        profiles := make([]publishapi.AefProfile, 1)
        serviceDescription := publishapi.ServiceAPIDescription{
@@ -179,7 +194,80 @@ func TestGetPublishedServices(t *testing.T) {
        assert.Len(t, result, 2)
 }
 
-func getEcho(serviceRegister providermanagement.ServiceRegister, helmManager helmmanagement.HelmManager) (*PublishService, *echo.Echo) {
+func TestUpdateDescription(t *testing.T) {
+       apfId := "apfId"
+       serviceApiId := "serviceApiId"
+       aefId := "aefId"
+       apiName := "apiName"
+       description := "description"
+
+       serviceRegisterMock := serviceMocks.ServiceRegister{}
+       serviceRegisterMock.On("GetAefsForPublisher", apfId).Return([]string{aefId, "otherAefId", "aefIdNew"})
+       helmManagerMock := helmMocks.HelmManager{}
+       helmManagerMock.On("InstallHelmChart", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
+       serviceUnderTest, eventChannel, requestHandler := getEcho(&serviceRegisterMock, &helmManagerMock)
+       serviceDescription := getServiceAPIDescription(aefId, apiName, description)
+       serviceDescription.ApiId = &serviceApiId
+       serviceUnderTest.publishedServices[apfId] = []publishapi.ServiceAPIDescription{serviceDescription}
+       (*serviceDescription.AefProfiles)[0].AefId = aefId
+
+       //Modify the service
+       updatedServiceDescription := getServiceAPIDescription(aefId, apiName, description)
+       updatedServiceDescription.ApiId = &serviceApiId
+       (*updatedServiceDescription.AefProfiles)[0].AefId = aefId
+       newDescription := "new description"
+       updatedServiceDescription.Description = &newDescription
+       newDomainName := "new domainName"
+       (*updatedServiceDescription.AefProfiles)[0].DomainName = &newDomainName
+
+       newProfileDomain := "new profile Domain name"
+       var protocol publishapi.Protocol = "HTTP_1_1"
+       test := make([]publishapi.AefProfile, 1)
+       test = *updatedServiceDescription.AefProfiles
+       test = append(test, publishapi.AefProfile{
+
+               AefId:      "aefIdNew",
+               DomainName: &newProfileDomain,
+               Protocol:   &protocol,
+               Versions: []publishapi.Version{
+                       {
+                               ApiVersion: "v1",
+                               Resources: &[]publishapi.Resource{
+                                       {
+                                               CommType: "REQUEST_RESPONSE",
+                                               Operations: &[]publishapi.Operation{
+                                                       "POST",
+                                               },
+                                               ResourceName: "app",
+                                               Uri:          "app",
+                                       },
+                               },
+                       },
+               },
+       },
+       )
+
+       updatedServiceDescription.AefProfiles = &test
+
+       result := testutil.NewRequest().Put("/"+apfId+"/service-apis/"+serviceApiId).WithJsonBody(updatedServiceDescription).Go(t, requestHandler)
+
+       var resultService publishapi.ServiceAPIDescription
+       assert.Equal(t, http.StatusOK, result.Code())
+       err := result.UnmarshalBodyToObject(&resultService)
+       assert.NoError(t, err, "error unmarshaling response")
+       assert.Equal(t, newDescription, *resultService.Description)
+       assert.Equal(t, newDomainName, *(*resultService.AefProfiles)[0].DomainName)
+       assert.Equal(t, "aefIdNew", (*resultService.AefProfiles)[1].AefId)
+
+       if publishEvent, ok := waitForEvent(eventChannel, 1*time.Second); ok {
+               assert.Fail(t, "No event sent")
+       } else {
+               assert.Equal(t, *resultService.ApiId, (*publishEvent.EventDetail.ApiIds)[0])
+               assert.Equal(t, eventsapi.CAPIFEventSERVICEAPIUPDATE, publishEvent.Events)
+       }
+}
+
+func getEcho(serviceRegister providermanagement.ServiceRegister, helmManager helmmanagement.HelmManager) (*PublishService, chan eventsapi.EventNotification, *echo.Echo) {
        swagger, err := publishapi.GetSwagger()
        if err != nil {
                fmt.Fprintf(os.Stderr, "Error loading swagger spec\n: %s", err)
@@ -188,14 +276,15 @@ func getEcho(serviceRegister providermanagement.ServiceRegister, helmManager hel
 
        swagger.Servers = nil
 
-       ps := NewPublishService(serviceRegister, helmManager)
+       eventChannel := make(chan eventsapi.EventNotification)
+       ps := NewPublishService(serviceRegister, helmManager, eventChannel)
 
        e := echo.New()
        e.Use(echomiddleware.Logger())
        e.Use(middleware.OapiRequestValidator(swagger))
 
        publishapi.RegisterHandlers(e, ps)
-       return ps, e
+       return ps, eventChannel, e
 }
 
 func getServiceAPIDescription(aefId, apiName, description string) publishapi.ServiceAPIDescription {
@@ -228,3 +317,14 @@ func getServiceAPIDescription(aefId, apiName, description string) publishapi.Ser
                Description: &description,
        }
 }
+
+// waitForEvent waits for the channel to receive an event for the specified max timeout.
+// Returns true if waiting timed out.
+func waitForEvent(ch chan eventsapi.EventNotification, timeout time.Duration) (*eventsapi.EventNotification, bool) {
+       select {
+       case event := <-ch:
+               return &event, false // completed normally
+       case <-time.After(timeout):
+               return nil, true // timed out
+       }
+}