E2Manager/clients/routing_manager_client_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package clients
  21
  22 import (
  23         "bytes"
  24         "e2mgr/configuration"
  25         "e2mgr/e2managererrors"
  26         "e2mgr/logger"
  27         "e2mgr/mocks"
  28         "e2mgr/models"
  29         "encoding/json"
  30         "github.com/pkg/errors"
  31         "github.com/stretchr/testify/assert"
  32         "io/ioutil"
  33         "net/http"
  34         "testing"
  35 )
  36
  37 const E2TAddress = "10.0.2.15:38000"
  38 const E2TAddress2 = "10.0.2.15:38001"
  39 const RanName = "test1"
  40
  41 func initRoutingManagerClientTest(t *testing.T) (*RoutingManagerClient, *mocks.HttpClientMock, *configuration.Configuration) {
  42         logger := initLog(t)
  43         config := &configuration.Configuration{}
  44         config.RoutingManager.BaseUrl = "http://iltlv740.intl.att.com:8080/ric/v1/handles/"
  45         httpClientMock := &mocks.HttpClientMock{}
  46         rmClient := NewRoutingManagerClient(logger, config, httpClientMock)
  47         return rmClient, httpClientMock, config
  48 }
  49
  50 func TestDeleteE2TInstanceSuccess(t *testing.T) {
  51         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
  52
  53         e2tToRansAssociations := map[string][]string{
  54                 E2TAddress2: {"test1"},
  55         }
  56         e2tDataList := convertE2TToRansAssociationsMapToE2TDataList(e2tToRansAssociations)
  57         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"},e2tDataList)
  58         marshaled, _ := json.Marshal(data)
  59         body := bytes.NewBuffer(marshaled)
  60         url := config.RoutingManager.BaseUrl + "e2t"
  61         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
  62         httpClientMock.On("Delete", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusOK, Body: respBody}, nil)
  63         err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"}, e2tToRansAssociations)
  64         assert.Nil(t, err)
  65 }
  66
  67 func TestDeleteE2TInstanceFailure(t *testing.T) {
  68         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
  69
  70         e2tToRansAssociations := map[string][]string{
  71                 E2TAddress2: {"test1"},
  72         }
  73         e2tDataList := convertE2TToRansAssociationsMapToE2TDataList(e2tToRansAssociations)
  74         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"},e2tDataList)
  75         marshaled, _ := json.Marshal(data)
  76         body := bytes.NewBuffer(marshaled)
  77         url := config.RoutingManager.BaseUrl + "e2t"
  78         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
  79         httpClientMock.On("Delete", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body: respBody}, nil)
  80         err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"}, e2tToRansAssociations)
  81         assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
  82 }
  83
  84 func TestDeleteE2TInstanceDeleteFailure(t *testing.T) {
  85         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
  86
  87         e2tToRansAssociations := map[string][]string{
  88                 E2TAddress2: {"test1"},
  89         }
  90         e2tDataList := convertE2TToRansAssociationsMapToE2TDataList(e2tToRansAssociations)
  91         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"},e2tDataList)
  92         marshaled, _ := json.Marshal(data)
  93         body := bytes.NewBuffer(marshaled)
  94         url := config.RoutingManager.BaseUrl + "e2t"
  95         httpClientMock.On("Delete", url, "application/json", body).Return(&http.Response{}, errors.New("error"))
  96         err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"}, e2tToRansAssociations)
  97         assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
  98 }
  99
 100 func TestAddE2TInstanceSuccess(t *testing.T) {
 101         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 102
 103         data := models.NewRoutingManagerE2TData(E2TAddress)
 104         marshaled, _ := json.Marshal(data)
 105         body := bytes.NewBuffer(marshaled)
 106         url := config.RoutingManager.BaseUrl + "e2t"
 107         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 108         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 109         err := rmClient.AddE2TInstance(E2TAddress)
 110         assert.Nil(t, err)
 111 }
 112
 113 func TestAddE2TInstanceHttpPostFailure(t *testing.T) {
 114         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 115
 116         data := models.NewRoutingManagerE2TData(E2TAddress)
 117         marshaled, _ := json.Marshal(data)
 118         body := bytes.NewBuffer(marshaled)
 119         url := config.RoutingManager.BaseUrl + "e2t"
 120         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{}, errors.New("error"))
 121         err := rmClient.AddE2TInstance(E2TAddress)
 122         assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
 123 }
 124
 125 func TestAddE2TInstanceFailure(t *testing.T) {
 126         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 127
 128         data := models.NewRoutingManagerE2TData(E2TAddress)
 129         marshaled, _ := json.Marshal(data)
 130         body := bytes.NewBuffer(marshaled)
 131         url := config.RoutingManager.BaseUrl + "e2t"
 132         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 133         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body: respBody}, nil)
 134         err := rmClient.AddE2TInstance(E2TAddress)
 135         assert.NotNil(t, err)
 136 }
 137
 138 func TestAssociateRanToE2TInstance_Success(t *testing.T) {
 139         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 140
 141         data := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 142         marshaled, _ := json.Marshal(data)
 143         body := bytes.NewBuffer(marshaled)
 144         url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix
 145         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 146         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 147         err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName)
 148         assert.Nil(t, err)
 149 }
 150
 151 func TestAssociateRanToE2TInstance_RoutingManagerError(t *testing.T) {
 152         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 153
 154         data := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 155         marshaled, _ := json.Marshal(data)
 156         body := bytes.NewBuffer(marshaled)
 157         url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix
 158         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{}, errors.New("error"))
 159         err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName)
 160         assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
 161 }
 162
 163 func TestAssociateRanToE2TInstance_RoutingManager_400(t *testing.T) {
 164         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 165
 166         data := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 167         marshaled, _ := json.Marshal(data)
 168         body := bytes.NewBuffer(marshaled)
 169         url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix
 170         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 171         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body: respBody}, nil)
 172         err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName)
 173         assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
 174 }
 175
 176 func TestDissociateRanE2TInstance_Success(t *testing.T) {
 177         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 178
 179         data := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 180         marshaled, _ := json.Marshal(data)
 181         body := bytes.NewBuffer(marshaled)
 182         url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix
 183         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 184         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 185         err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName)
 186         assert.Nil(t, err)
 187 }
 188
 189 func TestDissociateRanE2TInstance_RoutingManagerError(t *testing.T) {
 190         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 191
 192         data := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 193         marshaled, _ := json.Marshal(data)
 194         body := bytes.NewBuffer(marshaled)
 195         url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix
 196         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{}, errors.New("error"))
 197         err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName)
 198         assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
 199 }
 200
 201 func TestDissociateRanE2TInstance_RoutingManager_400(t *testing.T) {
 202         rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
 203
 204         data := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 205         marshaled, _ := json.Marshal(data)
 206         body := bytes.NewBuffer(marshaled)
 207         url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix
 208         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 209         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body: respBody}, nil)
 210         err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName)
 211         assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
 212 }
 213
 214 // TODO: extract to test_utils
 215 func initLog(t *testing.T) *logger.Logger {
 216         log, err := logger.InitLogger(logger.InfoLevel)
 217         if err != nil {
 218                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
 219         }
 220         return log
 221 }
 222
 223 //func TestAddE2TInstanceInteg(t *testing.T) {
 224 //      logger := initLog(t)
 225 //      config := configuration.ParseConfiguration()
 226 //      httpClient := &http.Client{}
 227 //      rmClient := NewRoutingManagerClient(logger, config, httpClient)
 228 //      err := rmClient.AddE2TInstance(E2TAddress)
 229 //      assert.Nil(t, err)
 230 //}