servicemanager/main_test.go

   1 // -
   2 //   ========================LICENSE_START=================================
   3 //   O-RAN-SC
   4 //   %%
   5 //   Copyright (C) 2023-2024: OpenInfra Foundation Europe
   6 //   %%
   7 //   Licensed under the Apache License, Version 2.0 (the "License");
   8 //   you may not use this file except in compliance with the License.
   9 //   You may obtain a copy of the License at
  10 //
  11 //        http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 //   Unless required by applicable law or agreed to in writing, software
  14 //   distributed under the License is distributed on an "AS IS" BASIS,
  15 //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 //   See the License for the specific language governing permissions and
  17 //   limitations under the License.
  18 //   ========================LICENSE_END===================================
  19 //
  20
  21 package main
  22
  23 import (
  24         "net/http"
  25         "net/http/httptest"
  26         "net/url"
  27         "os"
  28         "testing"
  29
  30         "github.com/deepmap/oapi-codegen/pkg/testutil"
  31         "github.com/getkin/kin-openapi/openapi3"
  32         "github.com/labstack/echo/v4"
  33         "github.com/stretchr/testify/assert"
  34         log "github.com/sirupsen/logrus"
  35
  36         "oransc.org/nonrtric/servicemanager/internal/common29122"
  37         "oransc.org/nonrtric/servicemanager/internal/envreader"
  38         "oransc.org/nonrtric/servicemanager/internal/kongclear"
  39
  40         "oransc.org/nonrtric/capifcore"
  41         "oransc.org/nonrtric/servicemanager/mockkong"
  42 )
  43
  44 var (
  45         eServiceManager          *echo.Echo
  46         eCapifWeb                *echo.Echo
  47         eKong                    *echo.Echo
  48         mockConfigReader         *envreader.MockConfigReader
  49         serviceManagerServer *httptest.Server
  50         capifServer              *httptest.Server
  51         mockKongServer           *httptest.Server
  52 )
  53
  54 // Init code to run before tests
  55 func TestMain(m *testing.M) {
  56         err := setupTest()
  57         if err != nil {
  58                 return
  59         }
  60
  61         ret := m.Run()
  62         if ret == 0 {
  63                 teardown()
  64         }
  65         os.Exit(ret)
  66 }
  67
  68 func setupTest() error {
  69         // Start the mock Kong server
  70         eKong = echo.New()
  71         mockKong.RegisterHandlers(eKong)
  72         mockKongServer = httptest.NewServer(eKong)
  73
  74         // Parse the server URL
  75         parsedMockKongURL, err := url.Parse(mockKongServer.URL)
  76         if err != nil {
  77                 log.Fatalf("error parsing mock Kong URL: %v", err)
  78                 return err
  79         }
  80
  81         // Extract the host and port
  82         mockKongHost := parsedMockKongURL.Hostname()
  83         mockKongControlPlanePort := parsedMockKongURL.Port()
  84
  85         eCapifWeb = echo.New()
  86         capifcore.RegisterHandlers(eCapifWeb, nil, nil)
  87         capifServer = httptest.NewServer(eCapifWeb)
  88
  89         // Parse the server URL
  90         parsedCapifURL, err := url.Parse(capifServer.URL)
  91         if err != nil {
  92                 log.Fatalf("error parsing mock Kong URL: %v", err)
  93                 return err
  94         }
  95
  96         // Extract the host and port
  97         capifHost := parsedCapifURL.Hostname()
  98         capifPort := parsedCapifURL.Port()
  99
 100         // Set up the mock config reader with the desired configuration for testing
 101         mockConfigReader = &envreader.MockConfigReader{
 102                 MockedConfig: map[string]string{
 103                         "KONG_DOMAIN":             "kong",
 104                         "KONG_PROTOCOL":           "http",
 105                         "KONG_IPV4":               mockKongHost,
 106                         "KONG_DATA_PLANE_PORT":    "32080",
 107                         "KONG_CONTROL_PLANE_PORT": mockKongControlPlanePort,
 108                         "CAPIF_PROTOCOL":          "http",
 109                         "CAPIF_IPV4":              capifHost,
 110                         "CAPIF_PORT":              capifPort,
 111                         "LOG_LEVEL":               "Info",
 112                         "SERVICE_MANAGER_PORT":    "8095",
 113                         "TEST_SERVICE_IPV4":       "10.101.1.101",
 114                         "TEST_SERVICE_PORT":       "30951",
 115                 },
 116         }
 117
 118         myEnv, myPorts, err := mockConfigReader.ReadDotEnv()
 119         if err != nil {
 120                 log.Fatal("error loading environment file on setupTest")
 121                 return err
 122         }
 123
 124         eServiceManager = echo.New()
 125         err = registerHandlers(eServiceManager, myEnv, myPorts)
 126         if err != nil {
 127                 log.Fatal("registerHandlers fatal error on setupTest")
 128                 return err
 129         }
 130         serviceManagerServer = httptest.NewServer(eServiceManager)
 131
 132         return err
 133 }
 134
 135
 136 func teardown() error {
 137         log.Trace("entering teardown")
 138
 139         myEnv, myPorts, err := mockConfigReader.ReadDotEnv()
 140         if err != nil {
 141                 log.Fatal("error loading environment file")
 142                 return err
 143         }
 144
 145         err = kongclear.KongClear(myEnv, myPorts)
 146         if err != nil {
 147                 log.Fatal("error clearing Kong on teardown")
 148         }
 149
 150         mockKongServer.Close()
 151         capifServer.Close()
 152         serviceManagerServer.Close()
 153
 154         return err
 155 }
 156
 157
 158 func Test_routing(t *testing.T) {
 159         type args struct {
 160                 url          string
 161                 returnStatus int
 162                 method       string
 163         }
 164         tests := []struct {
 165                 name string
 166                 args args
 167         }{
 168                 {
 169                         name: "Default path",
 170                         args: args{
 171                                 url:          "/",
 172                                 returnStatus: http.StatusOK,
 173                                 method:       "GET",
 174                         },
 175                 },
 176                 {
 177                         name: "Provider path",
 178                         args: args{
 179                                 url:          "/api-provider-management/v1/registrations/provider",
 180                                 returnStatus: http.StatusNoContent,
 181                                 method:       "DELETE",
 182                         },
 183                 },
 184                 {
 185                         name: "Publish path",
 186                         args: args{
 187                                 url:          "/published-apis/v1/apfId/service-apis/serviceId",
 188                                 returnStatus: http.StatusNotFound,
 189                                 method:       "GET",
 190                         },
 191                 },
 192                 {
 193                         name: "Discover path",
 194                         args: args{
 195                                 url:          "/service-apis/v1/allServiceAPIs?api-invoker-id=api_invoker_id",
 196                                 returnStatus: http.StatusNotFound,
 197                                 method:       "GET",
 198                         },
 199                 },
 200                 {
 201                         name: "Invoker path",
 202                         args: args{
 203                                 url:          "/api-invoker-management/v1/onboardedInvokers/invoker",
 204                                 returnStatus: http.StatusNoContent,
 205                                 method:       "DELETE",
 206                         },
 207                 },
 208         }
 209         for _, tt := range tests {
 210                 t.Run(tt.name, func(t *testing.T) {
 211                         var result *testutil.CompletedRequest
 212                         if tt.args.method == "GET" {
 213                                 result = testutil.NewRequest().Get(tt.args.url).Go(t, eServiceManager)
 214                         } else if tt.args.method == "DELETE" {
 215                                 result = testutil.NewRequest().Delete(tt.args.url).Go(t, eServiceManager)
 216                         }
 217
 218                         assert.Equal(t, tt.args.returnStatus, result.Code(), tt.name)
 219                 })
 220         }
 221 }
 222
 223 func TestGetSwagger(t *testing.T) {
 224         type args struct {
 225                 apiPath string
 226                 apiName string
 227         }
 228         tests := []struct {
 229                 name string
 230                 args args
 231         }{
 232                 {
 233                         name: "Provider api",
 234                         args: args{
 235                                 apiPath: "provider",
 236                                 apiName: "Provider",
 237                         },
 238                 },
 239                 {
 240                         name: "Publish api",
 241                         args: args{
 242                                 apiPath: "publish",
 243                                 apiName: "Publish",
 244                         },
 245                 },
 246                 {
 247                         name: "Invoker api",
 248                         args: args{
 249                                 apiPath: "invoker",
 250                                 apiName: "Invoker",
 251                         },
 252                 },
 253                 {
 254                         name: "Discover api",
 255                         args: args{
 256                                 apiPath: "discover",
 257                                 apiName: "Discover",
 258                         },
 259                 },
 260         }
 261         for _, tt := range tests {
 262                 t.Run(tt.name, func(t *testing.T) {
 263                         result := testutil.NewRequest().Get("/swagger/"+tt.args.apiPath).Go(t, eServiceManager)
 264                         assert.Equal(t, http.StatusOK, result.Code())
 265                         var swaggerResponse openapi3.T
 266                         err := result.UnmarshalJsonToObject(&swaggerResponse)
 267                         assert.Nil(t, err)
 268                         assert.Contains(t, swaggerResponse.Info.Title, tt.args.apiName)
 269                 })
 270         }
 271         invalidApi := "foobar"
 272         result := testutil.NewRequest().Get("/swagger/"+invalidApi).Go(t, eServiceManager)
 273         assert.Equal(t, http.StatusBadRequest, result.Code())
 274         var errorResponse common29122.ProblemDetails
 275         err := result.UnmarshalJsonToObject(&errorResponse)
 276         assert.Nil(t, err)
 277         assert.Contains(t, *errorResponse.Cause, "Invalid API")
 278         assert.Contains(t, *errorResponse.Cause, invalidApi)
 279 }