control/duplicate_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2021 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 */
  18
  19 package control
  20
  21 import (
  22         "fmt"
  23         "testing"
  24
  25         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
  26         "github.com/stretchr/testify/assert"
  27 )
  28
  29 type testData struct {
  30         Name    *string
  31         Data    []byte
  32         SomeVal *int64
  33 }
  34
  35 func TestDefaultUseCase(t *testing.T) {
  36
  37         fmt.Println("#####################  TestRetransmissionChecker  #####################")
  38
  39         var retransCtrl DuplicateCtrl
  40         restSubdId := "898dfkjashntgkjasgho4"
  41         var name string = "yolo"
  42         var someVal int64 = 98765
  43         data := testData{Name: &name, Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, SomeVal: &someVal}
  44
  45         retransCtrl.Init()
  46
  47         md5sum, err := CalculateRequestMd5sum(data)
  48         assert.Empty(t, err)
  49
  50         duplicate := retransCtrl.IsDuplicateToOngoingTransaction(restSubdId, md5sum)
  51
  52         assert.Equal(t, 1, len(retransCtrl.ongoingRequestMap))
  53         assert.Equal(t, false, duplicate)
  54
  55         retransCtrl.TransactionComplete(md5sum)
  56
  57         assert.Equal(t, 0, len(retransCtrl.ongoingRequestMap))
  58 }
  59
  60 func TestDuplicate(t *testing.T) {
  61
  62         fmt.Println("#####################  TestDuplicate  #####################")
  63
  64         var retransCtrl DuplicateCtrl
  65         restSubdId := "898dfkjashntgkjasgho4"
  66         var name string = "yolo"
  67         var someVal int64 = 98765
  68         data := testData{Name: &name, Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, SomeVal: &someVal}
  69
  70         var name2 string = "yolo"
  71         var someVal2 int64 = 98765
  72
  73         data2 := new(testData)
  74         data2.Name = &name2
  75         data2.SomeVal = &someVal2
  76         datax := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
  77         data2.Data = datax
  78
  79         retransCtrl.Init()
  80
  81         md5sum, err := CalculateRequestMd5sum(data)
  82         assert.Empty(t, err)
  83
  84         duplicate := retransCtrl.IsDuplicateToOngoingTransaction(restSubdId, md5sum)
  85         assert.Equal(t, 1, len(retransCtrl.ongoingRequestMap))
  86         assert.Equal(t, false, duplicate)
  87
  88         md5sum, err = CalculateRequestMd5sum(data2)
  89         assert.Empty(t, err)
  90
  91         duplicate = retransCtrl.IsDuplicateToOngoingTransaction(restSubdId, md5sum)
  92         assert.Equal(t, 1, len(retransCtrl.ongoingRequestMap))
  93         assert.Equal(t, true, duplicate)
  94
  95         retransCtrl.TransactionComplete(md5sum)
  96
  97         assert.Equal(t, 0, len(retransCtrl.ongoingRequestMap))
  98 }
  99
 100 func TestNoneDuplicate(t *testing.T) {
 101
 102         fmt.Println("#####################  TestNoneDuplicate  #####################")
 103
 104         var retransCtrl DuplicateCtrl
 105         restSubdId := "898dfkjashntgkjasgho4"
 106         var name string = "yolo"
 107         var someVal int64 = 98765
 108         data := testData{Name: &name, Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, SomeVal: &someVal}
 109
 110         var name2 string = "yolo"
 111         var someVal2 int64 = 98765
 112
 113         data2 := new(testData)
 114         data2.Name = &name2
 115         data2.SomeVal = &someVal2
 116         datax := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 1} // One byte changed
 117         data2.Data = datax
 118
 119         retransCtrl.Init()
 120
 121         md5sum, err := CalculateRequestMd5sum(data)
 122         assert.Empty(t, err)
 123
 124         duplicate := retransCtrl.IsDuplicateToOngoingTransaction(restSubdId, md5sum)
 125         assert.Equal(t, 1, len(retransCtrl.ongoingRequestMap))
 126         assert.Equal(t, false, duplicate)
 127
 128         md5sum2, err := CalculateRequestMd5sum(data2)
 129         assert.Empty(t, err)
 130
 131         duplicate2 := retransCtrl.IsDuplicateToOngoingTransaction(restSubdId, md5sum2)
 132         assert.Equal(t, 2, len(retransCtrl.ongoingRequestMap))
 133         assert.Equal(t, false, duplicate2)
 134
 135         retransCtrl.TransactionComplete(md5sum)
 136         retransCtrl.TransactionComplete(md5sum2)
 137
 138         assert.Equal(t, 0, len(retransCtrl.ongoingRequestMap))
 139 }
 140
 141 func TestEncodingError(t *testing.T) {
 142
 143         fmt.Println("#####################  TestEncodingError  #####################")
 144
 145         var retransCtrl DuplicateCtrl
 146         var data interface{}
 147
 148         retransCtrl.Init()
 149
 150         _, err := CalculateRequestMd5sum(data)
 151         assert.NotEqual(t, err, nil)
 152 }
 153
 154 func TestRemovalError(t *testing.T) {
 155
 156         fmt.Println("#####################  TestRemovalError  #####################")
 157
 158         var retransCtrl DuplicateCtrl
 159         restSubdId := "898dfkjashntgkjasgho4"
 160         var data testData
 161
 162         retransCtrl.Init()
 163
 164         md5sum, err := CalculateRequestMd5sum(data)
 165         assert.Empty(t, err)
 166
 167         duplicate := retransCtrl.IsDuplicateToOngoingTransaction(restSubdId, md5sum)
 168         assert.Equal(t, 1, len(retransCtrl.ongoingRequestMap))
 169         assert.Equal(t, false, duplicate)
 170
 171         err = retransCtrl.TransactionComplete(md5sum)
 172         assert.Empty(t, err)
 173
 174         err = retransCtrl.TransactionComplete(md5sum)
 175         assert.NotEmpty(t, err)
 176 }
 177
 178 func TestXappRestReqDuplicate(t *testing.T) {
 179
 180         fmt.Println("#####################  TestXappRestReqDuplicate  #####################")
 181
 182         var retransCtrl DuplicateCtrl
 183
 184         msg1 := new(models.SubscriptionParams)
 185         msg2 := new(models.SubscriptionParams)
 186
 187         retransCtrl.Init()
 188
 189         md5sum, err := CalculateRequestMd5sum(msg1)
 190         assert.Empty(t, err)
 191
 192         duplicate := retransCtrl.IsDuplicateToOngoingTransaction("foobar", md5sum)
 193         assert.Equal(t, 1, len(retransCtrl.ongoingRequestMap))
 194         assert.Equal(t, false, duplicate)
 195
 196         md5sum2, err := CalculateRequestMd5sum(msg2)
 197         assert.Empty(t, err)
 198
 199         duplicate = retransCtrl.IsDuplicateToOngoingTransaction("foobar", md5sum2)
 200         assert.Equal(t, 1, len(retransCtrl.ongoingRequestMap))
 201         assert.Equal(t, true, duplicate)
 202
 203         retransCtrl.TransactionComplete(md5sum)
 204
 205         assert.Equal(t, 0, len(retransCtrl.ongoingRequestMap))
 206 }