package providermanagement
import (
- "fmt"
"net/http"
+ "net/http/httptest"
+ "net/url"
"os"
"strings"
"testing"
"oransc.org/nonrtric/servicemanager/internal/common29122"
"oransc.org/nonrtric/servicemanager/internal/envreader"
"oransc.org/nonrtric/servicemanager/internal/kongclear"
+
provapi "oransc.org/nonrtric/servicemanager/internal/providermanagementapi"
- "oransc.org/nonrtric/servicemanager/internal/publishservice"
- publishapi "oransc.org/nonrtric/servicemanager/internal/publishserviceapi"
"github.com/deepmap/oapi-codegen/pkg/middleware"
"github.com/deepmap/oapi-codegen/pkg/testutil"
echomiddleware "github.com/labstack/echo/v4/middleware"
log "github.com/sirupsen/logrus"
+
"github.com/stretchr/testify/assert"
+
+ "oransc.org/nonrtric/capifcore"
+ "oransc.org/nonrtric/servicemanager/mockkong"
)
var (
- domainID = "domain_id_Kong"
+ domainID = "domain_id_Kong"
domainInfo = "Kong"
funcInfoAPF = "rApp Kong as APF"
funcIdAPF = "APF_id_rApp_Kong_as_APF"
funcIdAEF = "AEF_id_rApp_Kong_as_AEF"
)
-var requestHandler *echo.Echo
+var (
+ eServiceManager *echo.Echo
+ eCapifWeb *echo.Echo
+ eKong *echo.Echo
+ mockConfigReader *envreader.MockConfigReader
+ serviceManagerServer *httptest.Server
+ capifServer *httptest.Server
+ mockKongServer *httptest.Server
+)
func TestMain(m *testing.M) {
err := setupTest()
}
func setupTest() error {
- myEnv, myPorts, err := envreader.ReadDotEnv()
+ // Start the mock Kong server
+ eKong = echo.New()
+ mockKong.RegisterHandlers(eKong)
+ mockKongServer = httptest.NewServer(eKong)
+
+ // Parse the server URL
+ parsedMockKongURL, err := url.Parse(mockKongServer.URL)
+ if err != nil {
+ log.Fatalf("error parsing mock Kong URL: %v", err)
+ return err
+ }
+
+ // Extract the host and port
+ mockKongHost := parsedMockKongURL.Hostname()
+ mockKongControlPlanePort := parsedMockKongURL.Port()
+
+ eCapifWeb = echo.New()
+ capifcore.RegisterHandlers(eCapifWeb, nil, nil)
+ capifServer = httptest.NewServer(eCapifWeb)
+
+ // Parse the server URL
+ parsedCapifURL, err := url.Parse(capifServer.URL)
+ if err != nil {
+ log.Fatalf("error parsing mock Kong URL: %v", err)
+ return err
+ }
+
+ // Extract the host and port
+ capifHost := parsedCapifURL.Hostname()
+ capifPort := parsedCapifURL.Port()
+
+ // Set up the mock config reader with the desired configuration for testing
+ mockConfigReader = &envreader.MockConfigReader{
+ MockedConfig: map[string]string{
+ "KONG_DOMAIN": "kong",
+ "KONG_PROTOCOL": "http",
+ "KONG_IPV4": mockKongHost,
+ "KONG_DATA_PLANE_PORT": "32080",
+ "KONG_CONTROL_PLANE_PORT": mockKongControlPlanePort,
+ "CAPIF_PROTOCOL": "http",
+ "CAPIF_IPV4": capifHost,
+ "CAPIF_PORT": capifPort,
+ "LOG_LEVEL": "Info",
+ "SERVICE_MANAGER_PORT": "8095",
+ "TEST_SERVICE_IPV4": "10.101.1.101",
+ "TEST_SERVICE_PORT": "30951",
+ },
+ }
+
+ myEnv, myPorts, err := mockConfigReader.ReadDotEnv()
if err != nil {
log.Fatal("error loading environment file on setupTest")
return err
}
- requestHandler, err = getEcho(myEnv, myPorts)
+ eServiceManager = echo.New()
+ err = registerHandlers(eServiceManager, myEnv, myPorts)
if err != nil {
- log.Fatal("getEcho fatal error on setupTest")
+ log.Fatal("registerHandlers fatal error on setupTest")
return err
}
+ serviceManagerServer = httptest.NewServer(eServiceManager)
+
return err
}
-func teardown() error {
- log.Trace("entering teardown")
- t := new(testing.T) // Create a new testing.T instance for teardown
+func capifCleanUp() {
+ t := new(testing.T) // Create a new testing.T instance for capifCleanUp
// Delete the invoker
invokerInfo := "invoker a"
invokerId := "api_invoker_id_" + strings.Replace(invokerInfo, " ", "_", 1)
- result := testutil.NewRequest().Delete("/api-invoker-management/v1/onboardedInvokers/"+invokerId).Go(t, requestHandler)
+ result := testutil.NewRequest().Delete("/api-invoker-management/v1/onboardedInvokers/"+invokerId).Go(t, eServiceManager)
assert.Equal(t, http.StatusNoContent, result.Code())
// Delete the original published service
apiName := "apiName"
apiId := "api_id_" + apiName
- result = testutil.NewRequest().Delete("/published-apis/v1/"+apfId+"/service-apis/"+apiId).Go(t, requestHandler)
+ result = testutil.NewRequest().Delete("/published-apis/v1/"+apfId+"/service-apis/"+apiId).Go(t, eServiceManager)
assert.Equal(t, http.StatusNoContent, result.Code())
// Delete the first published service
apiName = "apiName1"
apiId = "api_id_" + apiName
- result = testutil.NewRequest().Delete("/published-apis/v1/"+apfId+"/service-apis/"+apiId).Go(t, requestHandler)
+ result = testutil.NewRequest().Delete("/published-apis/v1/"+apfId+"/service-apis/"+apiId).Go(t, eServiceManager)
assert.Equal(t, http.StatusNoContent, result.Code())
// Delete the second published service
apiName = "apiName2"
apiId = "api_id_" + apiName
- result = testutil.NewRequest().Delete("/published-apis/v1/"+apfId+"/service-apis/"+apiId).Go(t, requestHandler)
+ result = testutil.NewRequest().Delete("/published-apis/v1/"+apfId+"/service-apis/"+apiId).Go(t, eServiceManager)
assert.Equal(t, http.StatusNoContent, result.Code())
// Delete the provider
- result = testutil.NewRequest().Delete("/api-provider-management/v1/registrations/"+domainID).Go(t, requestHandler)
+ result = testutil.NewRequest().Delete("/api-provider-management/v1/registrations/"+domainID).Go(t, eServiceManager)
assert.Equal(t, http.StatusNoContent, result.Code())
+}
+
+
+func teardown() error {
+ log.Trace("entering teardown")
- myEnv, myPorts, err := envreader.ReadDotEnv()
+ myEnv, myPorts, err := mockConfigReader.ReadDotEnv()
if err != nil {
log.Fatal("error loading environment file")
return err
if err != nil {
log.Fatal("error clearing Kong on teardown")
}
- return err
+
+ mockKongServer.Close()
+ capifServer.Close()
+ serviceManagerServer.Close()
+
+ return nil
}
func TestRegisterValidProvider(t *testing.T) {
- teardown()
+ capifCleanUp()
// Register a valid provider
newProvider := getProvider()
- result := testutil.NewRequest().Post("/api-provider-management/v1/registrations").WithJsonBody(newProvider).Go(t, requestHandler)
+ result := testutil.NewRequest().Post("/api-provider-management/v1/registrations").WithJsonBody(newProvider).Go(t, eServiceManager)
assert.Equal(t, http.StatusCreated, result.Code())
var resultProvider provapi.APIProviderEnrolmentDetails
assert.Equal(t, "http://example.com/api-provider-management/v1/registrations/"+*resultProvider.ApiProvDomId, result.Recorder.Header().Get(echo.HeaderLocation))
// Register same provider again should result in Forbidden
- result = testutil.NewRequest().Post("/api-provider-management/v1/registrations").WithJsonBody(newProvider).Go(t, requestHandler)
+ result = testutil.NewRequest().Post("/api-provider-management/v1/registrations").WithJsonBody(newProvider).Go(t, eServiceManager)
- var errorObj common29122.ProblemDetails
assert.Equal(t, http.StatusForbidden, result.Code())
+ var errorObj common29122.ProblemDetails
err = result.UnmarshalBodyToObject(&errorObj)
assert.NoError(t, err, "error unmarshaling response")
assert.Equal(t, http.StatusForbidden, *errorObj.Status)
})
updatedProvider.ApiProvFuncs = &testFuncs
- result := testutil.NewRequest().Put("/api-provider-management/v1/registrations/"+domainID).WithJsonBody(updatedProvider).Go(t, requestHandler)
+ result := testutil.NewRequest().Put("/api-provider-management/v1/registrations/"+domainID).WithJsonBody(updatedProvider).Go(t, eServiceManager)
var resultProvider provapi.APIProviderEnrolmentDetails
assert.Equal(t, http.StatusOK, result.Code())
provider := getProvider()
provider.ApiProvDomId = &domainID
(*provider.ApiProvFuncs)[0].ApiProvFuncId = &funcIdAPF
- result := testutil.NewRequest().Delete("/api-provider-management/v1/registrations/"+domainID).Go(t, requestHandler)
+ result := testutil.NewRequest().Delete("/api-provider-management/v1/registrations/"+domainID).Go(t, eServiceManager)
assert.Equal(t, http.StatusNoContent, result.Code())
- teardown()
+ capifCleanUp()
}
func getProvider() provapi.APIProviderEnrolmentDetails {
}
}
-func getEcho(myEnv map[string]string, myPorts map[string]int) (*echo.Echo, error) {
+func registerHandlers(e *echo.Echo, myEnv map[string]string, myPorts map[string]int) (err error) {
capifProtocol := myEnv["CAPIF_PROTOCOL"]
capifIPv4 := common29122.Ipv4Addr(myEnv["CAPIF_IPV4"])
capifPort := common29122.Port(myPorts["CAPIF_PORT"])
- kongDomain := myEnv["KONG_DOMAIN"]
- kongProtocol := myEnv["KONG_PROTOCOL"]
- kongIPv4 := common29122.Ipv4Addr(myEnv["KONG_IPV4"])
- kongDataPlanePort := common29122.Port(myPorts["KONG_DATA_PLANE_PORT"])
- kongControlPlanePort := common29122.Port(myPorts["KONG_CONTROL_PLANE_PORT"])
-
- e := echo.New()
// Register ProviderManagement
providerManagerSwagger, err := provapi.GetSwagger()
if err != nil {
log.Fatalf("Error loading ProviderManagement swagger spec\n: %s", err)
- return nil, err
+ return err
}
providerManagerSwagger.Servers = nil
providerManager := NewProviderManager(capifProtocol, capifIPv4, capifPort)
- var group *echo.Group
-
- group = e.Group("/api-provider-management/v1")
+ group := e.Group("/api-provider-management/v1")
+ group.Use(echomiddleware.Logger())
group.Use(middleware.OapiRequestValidator(providerManagerSwagger))
provapi.RegisterHandlersWithBaseURL(e, providerManager, "/api-provider-management/v1")
- publishServiceSwagger, err := publishapi.GetSwagger()
- if err != nil {
- fmt.Fprintf(os.Stderr, "Error loading PublishService swagger spec\n: %s", err)
- return nil, err
- }
-
- publishServiceSwagger.Servers = nil
-
- ps := publishservice.NewPublishService(kongDomain, kongProtocol, kongIPv4, kongDataPlanePort, kongControlPlanePort, capifProtocol, capifIPv4, capifPort)
-
- group = e.Group("/published-apis/v1")
- group.Use(echomiddleware.Logger())
- group.Use(middleware.OapiRequestValidator(publishServiceSwagger))
- publishapi.RegisterHandlersWithBaseURL(e, ps, "/published-apis/v1")
-
- // return ps, eventChannel, e
- return e, err
+ return err
}
Code Review / nonrtric / plt / sme.git / blobdiff