test/usecases/oruclosedlooprecovery/goversion/internal/ves/message_test.go

   1 // -
   2 //   ========================LICENSE_START=================================
   3 //   O-RAN-SC
   4 //   %%
   5 //   Copyright (C) 2021: Nordix Foundation
   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 ves
  22
  23 import "testing"
  24
  25 func TestMessage_isFault(t *testing.T) {
  26         type fields struct {
  27                 Event Event
  28         }
  29         tests := []struct {
  30                 name   string
  31                 fields fields
  32                 want   bool
  33         }{
  34                 {
  35                         name: "is Fault",
  36                         fields: fields{
  37                                 Event: Event{
  38                                         CommonEventHeader: CommonEventHeader{
  39                                                 Domain: "fault",
  40                                         },
  41                                 },
  42                         },
  43                         want: true,
  44                 },
  45                 {
  46                         name: "is not Fault",
  47                         fields: fields{
  48                                 Event: Event{},
  49                         },
  50                         want: false,
  51                 },
  52         }
  53         for _, tt := range tests {
  54                 t.Run(tt.name, func(t *testing.T) {
  55                         message := FaultMessage{
  56                                 Event: tt.fields.Event,
  57                         }
  58                         if got := message.isFault(); got != tt.want {
  59                                 t.Errorf("Message.isFault() = %v, want %v", got, tt.want)
  60                         }
  61                 })
  62         }
  63 }
  64
  65 func TestMessage_isLinkAlarm(t *testing.T) {
  66         type fields struct {
  67                 Event Event
  68         }
  69         tests := []struct {
  70                 name   string
  71                 fields fields
  72                 want   bool
  73         }{
  74                 {
  75                         name: "is Link alarm",
  76                         fields: fields{
  77                                 Event: Event{
  78                                         FaultFields: FaultFields{
  79                                                 AlarmCondition: "28",
  80                                         },
  81                                 },
  82                         },
  83                         want: true,
  84                 },
  85                 {
  86                         name: "is not Link alarm",
  87                         fields: fields{
  88                                 Event: Event{
  89                                         FaultFields: FaultFields{
  90                                                 AlarmCondition: "2",
  91                                         },
  92                                 },
  93                         },
  94                         want: false,
  95                 },
  96         }
  97         for _, tt := range tests {
  98                 t.Run(tt.name, func(t *testing.T) {
  99                         message := FaultMessage{
 100                                 Event: tt.fields.Event,
 101                         }
 102                         if got := message.isLinkAlarm(); got != tt.want {
 103                                 t.Errorf("Message.isLinkAlarm() = %v, want %v", got, tt.want)
 104                         }
 105                 })
 106         }
 107 }
 108
 109 func TestMessage_isSeverityNormal(t *testing.T) {
 110         type fields struct {
 111                 Event Event
 112         }
 113         tests := []struct {
 114                 name   string
 115                 fields fields
 116                 want   bool
 117         }{
 118                 {
 119                         name: "is severity NORMAL",
 120                         fields: fields{
 121                                 Event: Event{
 122                                         FaultFields: FaultFields{
 123                                                 EventSeverity: "NORMAL",
 124                                         },
 125                                 },
 126                         },
 127                         want: true,
 128                 },
 129                 {
 130                         name: "is not severity NORMAL",
 131                         fields: fields{
 132                                 Event: Event{
 133                                         FaultFields: FaultFields{
 134                                                 AlarmCondition: "ERROR",
 135                                         },
 136                                 },
 137                         },
 138                         want: false,
 139                 },
 140         }
 141         for _, tt := range tests {
 142                 t.Run(tt.name, func(t *testing.T) {
 143                         message := FaultMessage{
 144                                 Event: tt.fields.Event,
 145                         }
 146                         if got := message.isSeverityNormal(); got != tt.want {
 147                                 t.Errorf("Message.isSeverityNormal() = %v, want %v", got, tt.want)
 148                         }
 149                 })
 150         }
 151 }
 152
 153 func TestMessage_IsLinkFailure(t *testing.T) {
 154         type fields struct {
 155                 Event Event
 156         }
 157         tests := []struct {
 158                 name   string
 159                 fields fields
 160                 want   bool
 161         }{
 162                 {
 163                         name: "is Link Failure",
 164                         fields: fields{
 165                                 Event: Event{
 166                                         CommonEventHeader: CommonEventHeader{
 167                                                 Domain: "fault",
 168                                         },
 169                                         FaultFields: FaultFields{
 170                                                 AlarmCondition: "28",
 171                                                 EventSeverity:  "ERROR",
 172                                         },
 173                                 },
 174                         },
 175                         want: true,
 176                 },
 177         }
 178         for _, tt := range tests {
 179                 t.Run(tt.name, func(t *testing.T) {
 180                         message := FaultMessage{
 181                                 Event: tt.fields.Event,
 182                         }
 183                         if got := message.IsLinkFailure(); got != tt.want {
 184                                 t.Errorf("Message.IsLinkFailure() = %v, want %v", got, tt.want)
 185                         }
 186                 })
 187         }
 188 }
 189
 190 func TestMessage_IsClearLinkFailure(t *testing.T) {
 191         type fields struct {
 192                 Event Event
 193         }
 194         tests := []struct {
 195                 name   string
 196                 fields fields
 197                 want   bool
 198         }{
 199                 {
 200                         name: "is not Link Failure",
 201                         fields: fields{
 202                                 Event: Event{
 203                                         CommonEventHeader: CommonEventHeader{
 204                                                 Domain: "fault",
 205                                         },
 206                                         FaultFields: FaultFields{
 207                                                 AlarmCondition: "28",
 208                                                 EventSeverity:  "NORMAL",
 209                                         },
 210                                 },
 211                         },
 212                         want: true,
 213                 },
 214         }
 215         for _, tt := range tests {
 216                 t.Run(tt.name, func(t *testing.T) {
 217                         message := FaultMessage{
 218                                 Event: tt.fields.Event,
 219                         }
 220                         if got := message.IsClearLinkFailure(); got != tt.want {
 221                                 t.Errorf("Message.IsClearLinkFailure() = %v, want %v", got, tt.want)
 222                         }
 223                 })
 224         }
 225 }
 226
 227 func TestMessage_GetORuId(t *testing.T) {
 228         type fields struct {
 229                 Event Event
 230         }
 231         tests := []struct {
 232                 name   string
 233                 fields fields
 234                 want   string
 235         }{
 236                 {
 237                         name: "is not Link Failure",
 238                         fields: fields{
 239                                 Event: Event{
 240                                         CommonEventHeader: CommonEventHeader{
 241                                                 SourceName: "O-RU-ID",
 242                                         },
 243                                         FaultFields: FaultFields{
 244                                                 AlarmCondition: "28",
 245                                                 EventSeverity:  "NORMAL",
 246                                         },
 247                                 },
 248                         },
 249                         want: "O-RU-ID",
 250                 },
 251         }
 252         for _, tt := range tests {
 253                 t.Run(tt.name, func(t *testing.T) {
 254                         message := FaultMessage{
 255                                 Event: tt.fields.Event,
 256                         }
 257                         if got := message.GetORuId(); got != tt.want {
 258                                 t.Errorf("Message.GetORuId() = %v, want %v", got, tt.want)
 259                         }
 260                 })
 261         }
 262 }