pkg/resthooks/resthooks_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 package resthooks
  21
  22 import (
  23         "encoding/json"
  24         "errors"
  25         "fmt"
  26         "github.com/stretchr/testify/assert"
  27         "github.com/stretchr/testify/mock"
  28         "net"
  29         "net/http"
  30         "net/http/httptest"
  31         "os"
  32         "strconv"
  33         "testing"
  34         "time"
  35
  36         "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/appmgr"
  37         "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/models"
  38 )
  39
  40 var rh *Resthook
  41 var resp models.SubscriptionResponse
  42 var mockedSdl *SdlMock
  43
  44 // Test cases
  45 func TestMain(m *testing.M) {
  46         appmgr.Init()
  47         appmgr.Logger.SetLevel(0)
  48
  49         mockedSdl = new(SdlMock)
  50         NewResthook(false)
  51         rh = createResthook(false, mockedSdl)
  52         code := m.Run()
  53         os.Exit(code)
  54 }
  55
  56 func TestAddSubscriptionSuccess(t *testing.T) {
  57         var mockSdlRetOk error
  58         subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
  59
  60         mockedSdl.expectDbSet(t, subsReq, mockSdlRetOk)
  61         resp := rh.AddSubscription(subsReq)
  62         assert.Equal(t, resp.Version, int64(0))
  63         assert.Equal(t, resp.EventType, models.EventTypeCreated)
  64 }
  65
  66 func TestAddSubscriptionExists(t *testing.T) {
  67         resp := rh.AddSubscription(createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook"))
  68         assert.Equal(t, resp.Version, int64(0))
  69         assert.Equal(t, resp.EventType, models.EventTypeCreated)
  70 }
  71
  72 func TestDeletesubscriptionSuccess(t *testing.T) {
  73         var mockSdlRetOk error
  74
  75         mockedSdl.On("Set", appmgrSdlNs, mock.Anything).Return(mockSdlRetOk)
  76         resp := rh.AddSubscription(createSubscription(models.EventTypeDeleted, int64(5), int64(10), "http://localhost:8087/xapps_hook2"))
  77         assert.Equal(t, resp.Version, int64(0))
  78         assert.Equal(t, resp.EventType, models.EventTypeDeleted)
  79
  80         resp, ok := rh.DeleteSubscription(resp.ID)
  81         assert.Equal(t, ok, true)
  82         assert.Equal(t, resp.Version, int64(0))
  83         assert.Equal(t, resp.EventType, models.EventTypeDeleted)
  84 }
  85
  86 func TestDeletesubscriptionInvalid(t *testing.T) {
  87         resp, ok := rh.DeleteSubscription("Non-existent-ID")
  88         assert.Equal(t, ok, false)
  89         assert.Equal(t, resp.Version, int64(0))
  90         assert.Equal(t, resp.EventType, models.EventType(""))
  91 }
  92
  93 func TestModifySubscriptionSuccess(t *testing.T) {
  94         resp := rh.AddSubscription(createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook2"))
  95         assert.Equal(t, resp.Version, int64(0))
  96         assert.Equal(t, resp.EventType, models.EventTypeCreated)
  97
  98         resp, ok := rh.ModifySubscription(resp.ID, createSubscription(models.EventTypeModified, int64(5), int64(10), "http://localhost:8087/xapps_hook2"))
  99         assert.Equal(t, ok, true)
 100         assert.Equal(t, resp.Version, int64(0))
 101         assert.Equal(t, resp.EventType, models.EventTypeModified)
 102 }
 103
 104 func TestModifySubscriptionForNonExistingSubscription(t *testing.T) {
 105         resp, ok := rh.ModifySubscription("Non-existent-ID", createSubscription(models.EventTypeModified, int64(5), int64(10), "http://localhost:8087/xapps_hook2"))
 106         assert.Equal(t, ok, false)
 107         assert.Equal(t, *resp, models.SubscriptionResponse{})
 108 }
 109
 110 func TestDeleteSubscriptionForNonExistingSubscription(t *testing.T) {
 111         resp, ok := rh.DeleteSubscription("Non-existent-ID")
 112         assert.Equal(t, ok, false)
 113         assert.Equal(t, resp.Version, int64(0))
 114         assert.Equal(t, resp.EventType, models.EventType(""))
 115 }
 116
 117 func TestGetAllSubscriptionSuccess(t *testing.T) {
 118         flushExistingSubscriptions()
 119         subscriptions := rh.GetAllSubscriptions()
 120         assert.Equal(t, len(subscriptions), 0)
 121
 122         rh.AddSubscription(createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook"))
 123         rh.AddSubscription(createSubscription(models.EventTypeModified, int64(5), int64(10), "http://localhost:8087/xapps_hook2"))
 124
 125         subscriptions = rh.GetAllSubscriptions()
 126         assert.Equal(t, len(subscriptions), 2)
 127 }
 128
 129 func TestGetSubscriptionByIdSuccess(t *testing.T) {
 130         flushExistingSubscriptions()
 131
 132         sub1 := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 133         sub2 := createSubscription(models.EventTypeModified, int64(5), int64(10), "http://localhost:8087/xapps_hook2")
 134         r1 := rh.AddSubscription(sub1)
 135         r2 := rh.AddSubscription(sub2)
 136
 137         resp1, ok := rh.GetSubscriptionById(r1.ID)
 138         assert.Equal(t, ok, true)
 139         assert.Equal(t, resp1.Data, sub1.Data)
 140
 141         resp2, ok := rh.GetSubscriptionById(r2.ID)
 142         assert.Equal(t, ok, true)
 143         assert.Equal(t, resp2.Data, sub2.Data)
 144 }
 145
 146 func TestGetSubscriptionByIdForNonExistingSubscription(t *testing.T) {
 147         resp, ok := rh.GetSubscriptionById("Non-existent-ID")
 148         assert.Equal(t, ok, false)
 149         assert.Equal(t, resp, models.Subscription{})
 150 }
 151
 152 func TestNotifyClientsNoXapp(t *testing.T) {
 153         rh.NotifyClients(models.AllDeployedXapps{}, models.EventTypeUndeployed)
 154 }
 155
 156 func TestNotifySuccess(t *testing.T) {
 157         flushExistingSubscriptions()
 158
 159         sub := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 160         resp := rh.AddSubscription(sub)
 161
 162         xapp := getDummyXapp()
 163         ts := createHTTPServer(t, "POST", "/xapps_hook", 8087, http.StatusOK, nil)
 164         defer ts.Close()
 165
 166         v, ok := rh.subscriptions.Get(resp.ID)
 167         assert.True(t, ok)
 168         err := rh.notify(models.AllDeployedXapps{&xapp}, models.EventTypeUndeployed, v.(SubscriptionInfo), 1)
 169         assert.Nil(t, err)
 170 }
 171
 172 func TestNotifySuccessIfHttpErrorResponse(t *testing.T) {
 173         flushExistingSubscriptions()
 174
 175         sub := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 176         resp := rh.AddSubscription(sub)
 177
 178         xapp := getDummyXapp()
 179         ts := createHTTPServer(t, "POST", "/xapps_hook", 8087, http.StatusInternalServerError, nil)
 180         defer ts.Close()
 181
 182         v, ok := rh.subscriptions.Get(resp.ID)
 183         assert.True(t, ok)
 184         err := rh.notify(models.AllDeployedXapps{&xapp}, models.EventTypeUndeployed, v.(SubscriptionInfo), 1)
 185         assert.Nil(t, err)
 186 }
 187
 188 func TestNotifyReturnsErrorAfterRetriesIfNoHttpServer(t *testing.T) {
 189         flushExistingSubscriptions()
 190
 191         sub := createSubscription(models.EventTypeCreated, int64(2), int64(1), "http://localhost:8087/xapps_hook")
 192         resp := rh.AddSubscription(sub)
 193
 194         xapp := getDummyXapp()
 195
 196         v, ok := rh.subscriptions.Get(resp.ID)
 197         assert.True(t, ok)
 198         err := rh.notify(models.AllDeployedXapps{&xapp}, models.EventTypeUndeployed, v.(SubscriptionInfo), 1)
 199         assert.NotNil(t, err)
 200         assert.Equal(t, 0, len(rh.subscriptions.Items()))
 201 }
 202
 203 func TestRestoreSubscriptionsSuccess(t *testing.T) {
 204         var mockSdlRetOk error
 205         mSdl := new(SdlMock)
 206         key := "key-1"
 207
 208         subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 209         serializedSubsReq, err := json.Marshal(subsReq)
 210         assert.Nil(t, err)
 211
 212         mockSdlGetRetVal := make(map[string]interface{})
 213         //Cast data to string to act like a real SDL/Redis client
 214         mockSdlGetRetVal[key] = string(serializedSubsReq)
 215         mSdl.On("GetAll", appmgrSdlNs).Return([]string{key}, mockSdlRetOk).Twice()
 216         mSdl.On("Get", appmgrSdlNs, []string{key}).Return(mockSdlGetRetVal, mockSdlRetOk).Once()
 217         restHook := createResthook(true, mSdl)
 218
 219         val, found := restHook.subscriptions.Get(key)
 220         assert.True(t, found)
 221         assert.Equal(t, subsReq, val.(SubscriptionInfo).req)
 222 }
 223
 224 func TestRestoreSubscriptionsFailsIfSdlGetAllFails(t *testing.T) {
 225         var mockSdlRetStatus error
 226         mSdl := new(SdlMock)
 227         getCalled := 0
 228         mGetAllCall := mSdl.On("GetAll", appmgrSdlNs)
 229         mGetAllCall.RunFn = func(args mock.Arguments) {
 230                 if getCalled > 0 {
 231                         mockSdlRetStatus = errors.New("some SDL error")
 232                 }
 233                 getCalled++
 234                 mGetAllCall.ReturnArguments = mock.Arguments{[]string{}, mockSdlRetStatus}
 235         }
 236
 237         restHook := createResthook(true, mSdl)
 238         assert.Equal(t, 0, len(restHook.subscriptions.Items()))
 239 }
 240
 241 func TestRestoreSubscriptionsFailsIfSdlGetFails(t *testing.T) {
 242         var mockSdlRetOk error
 243         mSdl := new(SdlMock)
 244         mockSdlRetNok := errors.New("some SDL error")
 245         key := "key-1"
 246         subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 247         serializedSubsReq, err := json.Marshal(subsReq)
 248         assert.Nil(t, err)
 249
 250         mockSdlGetRetVal := make(map[string]interface{})
 251         mockSdlGetRetVal[key] = serializedSubsReq
 252
 253         mSdl.On("GetAll", appmgrSdlNs).Return([]string{key}, mockSdlRetOk).Twice()
 254         mSdl.On("Get", appmgrSdlNs, []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
 255
 256         restHook := createResthook(true, mSdl)
 257         assert.Equal(t, 0, len(restHook.subscriptions.Items()))
 258 }
 259
 260 func TestTeardown(t *testing.T) {
 261         var mockSdlRetOk error
 262         mockedSdl.On("RemoveAll", appmgrSdlNs).Return(mockSdlRetOk).Once()
 263
 264         rh.FlushSubscriptions()
 265 }
 266
 267 func TestUpdateAppDataFail1(t *testing.T) {
 268         var reg models.RegisterRequest
 269         var tEndpoint string = "10.104.237.59"
 270         reg.HTTPEndpoint = &tEndpoint
 271         rh.UpdateAppData(reg, false)
 272 }
 273
 274 func TestUpdateAppDataFail2(t *testing.T) {
 275         var mockSdlRetOk error
 276         var params models.RegisterRequest
 277
 278         mSdl := new(SdlMock)
 279         mockSdlRetNok := errors.New("some SDL error")
 280         var tEndpoint1 string = "10.104.237.59:8087"
 281         params.HTTPEndpoint = &tEndpoint1
 282         serializedSubsReq2, err := json.Marshal(params)
 283         if err != nil {
 284                 t.Logf("error in marshal .. %v", err)
 285         }
 286
 287         subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 288         serializedSubsReq, err := json.Marshal(subsReq)
 289         assert.Nil(t, err)
 290
 291         key := "key-1"
 292         value := "endpoints"
 293         mockSdlGetRetVal := make(map[string]interface{})
 294         mockSdlGetRetVal[key] = serializedSubsReq
 295
 296         mockSdlGetRetVal2 := make(map[string]interface{})
 297         mockSdlGetRetVal2[value] = serializedSubsReq2
 298         mSdl.On("GetAll", appmgrSdlNs).Return([]string{key}, mockSdlRetOk).Twice()
 299         mSdl.On("Get", appmgrSdlNs, []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
 300         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal2, mockSdlRetOk).Once()
 301
 302         restHook := createResthook(false, mSdl)
 303
 304         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal2, mockSdlRetOk).Once()
 305
 306         ret := restHook.GetAppsInSDL()
 307         if ret == nil {
 308                 assert.Nil(t, ret)
 309         }
 310 }
 311
 312 func TestGetAppsInSDLFail3(t *testing.T) {
 313         var mockSdlRetOk error
 314         var params models.RegisterRequest
 315
 316         mSdl := new(SdlMock)
 317         mockSdlRetNok := errors.New("some SDL error")
 318
 319         serializedSubsReq1, err := json.Marshal(params)
 320         if err != nil {
 321                 t.Logf("error in marshal .. %v", err)
 322         }
 323
 324         subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 325         serializedSubsReq, err := json.Marshal(subsReq)
 326         assert.Nil(t, err)
 327
 328         key := "key-1"
 329         value := "endpoints"
 330         mockSdlGetRetVal := make(map[string]interface{})
 331         mockSdlGetRetVal[key] = serializedSubsReq
 332
 333         mockSdlGetRetVal1 := make(map[string]interface{})
 334         mockSdlGetRetVal1[key] = serializedSubsReq1
 335
 336         mSdl.On("GetAll", appmgrSdlNs).Return([]string{key}, mockSdlRetOk).Twice()
 337         mSdl.On("Get", appmgrSdlNs, []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
 338         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
 339
 340         restHook := createResthook(false, mSdl)
 341
 342         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
 343         ret2 := restHook.GetAppsInSDL()
 344         if ret2 != nil {
 345                 t.Logf("SDL Returning: %s \n", *ret2)
 346         } else {
 347                 assert.Nil(t, ret2)
 348         }
 349 }
 350
 351 func TestUpdateAppDataSucc(t *testing.T) {
 352         var mockSdlRetOk error
 353         var params models.RegisterRequest
 354
 355         mSdl := new(SdlMock)
 356         mockSdlRetNok := errors.New("some SDL error")
 357
 358         var tEndpoint1 string = "10.104.237.59:8087"
 359         params.HTTPEndpoint = &tEndpoint1
 360         serializedSubsReq1, err := json.Marshal(params)
 361         if err != nil {
 362                 t.Logf("error in marshal .. %v", err)
 363         }
 364         subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 365         serializedSubsReq, err := json.Marshal(subsReq)
 366         assert.Nil(t, err)
 367
 368         key := "key-1"
 369         value := "endpoints"
 370         mockSdlGetRetVal := make(map[string]interface{})
 371         mockSdlGetRetVal[key] = serializedSubsReq
 372
 373         mockSdlGetRetVal1 := make(map[string]interface{})
 374         mockSdlGetRetVal1[key] = serializedSubsReq1
 375
 376         mSdl.On("GetAll", appmgrSdlNs).Return([]string{key}, mockSdlRetOk).Twice()
 377         mSdl.On("Get", appmgrSdlNs, []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
 378         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
 379
 380         restHook := createResthook(false, mSdl)
 381
 382         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
 383         mSdl.On("Set", appDbSdlNs, mock.Anything).Return(mockSdlRetOk)
 384         restHook.UpdateAppData(params, true)
 385 }
 386
 387 func TestUpdateAppDataSucc1(t *testing.T) {
 388         var mockSdlRetOk error
 389         var params models.RegisterRequest
 390
 391         mSdl := new(SdlMock)
 392         mockSdlRetNok := errors.New("some SDL error")
 393
 394         var tEndpoint1 string = "10.104.237.59:8087"
 395         params.HTTPEndpoint = &tEndpoint1
 396         appsindb := []string{"10.104.237.59:8088 ", " ", " ", " 10.104.237.59:8087"}
 397         serializedSubsReq1, err := json.Marshal(appsindb)
 398         if err != nil {
 399                 t.Logf("error in marshal .. %v", err)
 400         }
 401         subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 402         serializedSubsReq, err := json.Marshal(subsReq)
 403         assert.Nil(t, err)
 404
 405         key := "key-1"
 406         value := "endpoints"
 407         mockSdlGetRetVal := make(map[string]interface{})
 408         mockSdlGetRetVal[key] = serializedSubsReq
 409
 410         mockSdlGetRetVal1 := make(map[string]interface{})
 411         mockSdlGetRetVal1[value] = serializedSubsReq1
 412
 413         mSdl.On("GetAll", appmgrSdlNs).Return([]string{key}, mockSdlRetOk).Twice()
 414         mSdl.On("Get", appmgrSdlNs, []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
 415         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
 416
 417         restHook := createResthook(false, mSdl)
 418
 419         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
 420         mSdl.On("Set", appDbSdlNs, []string{value}).Return(mockSdlRetOk).Twice()
 421
 422         mSdl.On("Remove", appDbSdlNs, mock.Anything).Return(mockSdlRetOk)
 423         mSdl.On("Set", appDbSdlNs, mock.Anything).Return(mockSdlRetOk)
 424         restHook.UpdateAppData(params, true)
 425 }
 426
 427 func TestUpdateAppDataSucc2(t *testing.T) {
 428         var mockSdlRetOk error
 429         var params models.RegisterRequest
 430
 431         mSdl := new(SdlMock)
 432         mockSdlRetNok := errors.New("some SDL error")
 433
 434         var tEndpoint1 string = "10.104.237.59:8087"
 435         params.Config = "/temp/config.yaml"
 436         params.HTTPEndpoint = &tEndpoint1
 437         serializedSubsReq1, err := json.Marshal(tEndpoint1)
 438         if err != nil {
 439                 t.Logf("error in marshal .. %v", err)
 440         }
 441         subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
 442         serializedSubsReq, err := json.Marshal(subsReq)
 443         assert.Nil(t, err)
 444
 445         key := "key-1"
 446         value := "endpoints"
 447         mockSdlGetRetVal := make(map[string]interface{})
 448         mockSdlGetRetVal[key] = serializedSubsReq
 449
 450         mockSdlGetRetVal1 := make(map[string]interface{})
 451         mockSdlGetRetVal1[value] = serializedSubsReq1
 452
 453         mSdl.On("GetAll", appmgrSdlNs).Return([]string{key}, mockSdlRetOk).Twice()
 454         mSdl.On("Get", appmgrSdlNs, []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
 455         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
 456
 457         restHook := createResthook(false, mSdl)
 458
 459         mSdl.On("Get", appDbSdlNs, []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
 460         mSdl.On("Set", appDbSdlNs, []string{value}).Return(mockSdlRetOk).Twice()
 461
 462         mSdl.On("Remove", appDbSdlNs, mock.Anything).Return(mockSdlRetOk)
 463         mSdl.On("Set", appDbSdlNs, mock.Anything).Return(mockSdlRetOk)
 464         restHook.UpdateAppData(params, true)
 465 }
 466 func createSubscription(et models.EventType, maxRetries, retryTimer int64, targetUrl string) models.SubscriptionRequest {
 467         return models.SubscriptionRequest{&models.SubscriptionData{et, &maxRetries, &retryTimer, &targetUrl}}
 468 }
 469
 470 func getDummyXapp() models.Xapp {
 471         return generateXapp("dummy-xapp", "deployed", "1.0", "dummy-xapp-8984fc9fd-bkcbp", "running", "service-ricxapp-dummy-xapp-rmr.ricxapp", "4560")
 472 }
 473
 474 func generateXapp(name, status, ver, iname, istatus, ip, port string) (x models.Xapp) {
 475         x.Name = &name
 476         x.Status = status
 477         x.Version = ver
 478         p, _ := strconv.Atoi(port)
 479         var msgs appmgr.RtmData
 480
 481         instance := &models.XappInstance{
 482                 Name:       &iname,
 483                 Status:     istatus,
 484                 IP:         ip,
 485                 Port:       int64(p),
 486                 TxMessages: msgs.TxMessages,
 487                 RxMessages: msgs.RxMessages,
 488         }
 489         x.Instances = append(x.Instances, instance)
 490         return
 491 }
 492
 493 func flushExistingSubscriptions() {
 494         var mockSdlRetOk error
 495         mockedSdl.On("RemoveAll", appmgrSdlNs).Return(mockSdlRetOk).Once()
 496         rh.FlushSubscriptions()
 497 }
 498
 499 func createHTTPServer(t *testing.T, method, url string, port, status int, respData interface{}) *httptest.Server {
 500         l, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", port))
 501         if err != nil {
 502                 t.Error("Failed to create listener: " + err.Error())
 503         }
 504         ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 505                 assert.Equal(t, r.Method, method)
 506                 assert.Equal(t, r.URL.String(), url)
 507                 w.Header().Add("Content-Type", "application/json")
 508                 w.WriteHeader(status)
 509                 b, _ := json.Marshal(respData)
 510                 w.Write(b)
 511         }))
 512         ts.Listener.Close()
 513         ts.Listener = l
 514
 515         ts.Start()
 516         time.Sleep(time.Duration(1 * time.Second))
 517         return ts
 518 }
 519
 520 func (m *SdlMock) expectDbSet(t *testing.T, subsReq models.SubscriptionRequest, mockRet error) {
 521         serializedSubReq, _ := json.Marshal(subsReq)
 522         m.On("Set", appmgrSdlNs, mock.Anything).Run(
 523                 func(args mock.Arguments) {
 524                         sdlKVs := args.Get(1).([]interface{})
 525                         assert.Equal(t, 2, len(sdlKVs))
 526                         //Validate that subscription request is set to SDL
 527                         assert.Equal(t, serializedSubReq, sdlKVs[1])
 528                 }).Return(mockRet).Once()
 529 }
 530
 531 func TestPublishSubscription(t *testing.T) {
 532         sub := createSubscription(models.EventTypeCreated, int64(2), int64(1), "http://localhost:8087/xapps_hook")
 533         resp := rh.AddSubscription(sub)
 534
 535         xapp := getDummyXapp()
 536
 537         v, ok := rh.subscriptions.Get(resp.ID)
 538         assert.True(t, ok)
 539         if v == nil {
 540                 t.Logf("value : %+v", v)
 541         }
 542         rh.PublishSubscription(xapp, models.EventTypeUndeployed)
 543 }
 544
 545 type SdlMock struct {
 546         mock.Mock
 547 }
 548
 549 func (m *SdlMock) Set(ns string, pairs ...interface{}) error {
 550         a := m.Called(ns, pairs)
 551         return a.Error(0)
 552 }
 553
 554 func (m *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
 555         a := m.Called(ns, keys)
 556         return a.Get(0).(map[string]interface{}), a.Error(1)
 557 }
 558
 559 func (m *SdlMock) GetAll(ns string) ([]string, error) {
 560         a := m.Called(ns)
 561         return a.Get(0).([]string), a.Error(1)
 562 }
 563
 564 func (m *SdlMock) RemoveAll(ns string) error {
 565         a := m.Called(ns)
 566         return a.Error(0)
 567 }
 568
 569 func (m *SdlMock) Remove(ns string, keys []string) error {
 570         a := m.Called(ns)
 571         return a.Error(0)
 572 }