Add UT for REST interface & code refactor
[ric-plt/alarm-go.git] / adapter / cmd / adapter_test.go
1 /*
2  *  Copyright (c) 2020 AT&T Intellectual Property.
3  *  Copyright (c) 2020 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
21 package main
22
23 import (
24         "encoding/json"
25         "fmt"
26         "github.com/stretchr/testify/assert"
27         "io"
28         "io/ioutil"
29         "net"
30         "net/http"
31         "net/http/httptest"
32         "os"
33         "strings"
34         "testing"
35         "time"
36
37         "gerrit.o-ran-sc.org/r/ric-plt/alarm-go/alarm"
38         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
39         "github.com/prometheus/alertmanager/api/v2/models"
40 )
41
42 var alarmAdapter *AlarmAdapter
43 var alarmer *alarm.RICAlarm
44 var eventChan chan string
45
46 // Test cases
47 func TestMain(M *testing.M) {
48         alarmAdapter = NewAlarmAdapter("localhost:9093", 500)
49         go alarmAdapter.Run(false)
50         time.Sleep(time.Duration(2) * time.Second)
51
52         // Wait until RMR is up-and-running
53         for !xapp.Rmr.IsReady() {
54                 time.Sleep(time.Duration(1) * time.Second)
55         }
56
57         alarmer, _ = alarm.InitAlarm("my-pod", "my-app")
58         eventChan = make(chan string)
59
60         os.Exit(M.Run())
61 }
62
63 func TestNewAlarmStoredAndPostedSucess(t *testing.T) {
64         ts := CreatePromAlertSimulator(t, "POST", "/api/v2/alerts", http.StatusOK, models.LabelSet{})
65         defer ts.Close()
66
67         a := alarmer.NewAlarm(alarm.RIC_RT_DISTRIBUTION_FAILED, alarm.SeverityMajor, "Some App data", "eth 0 1")
68         assert.Nil(t, alarmer.Raise(a), "raise failed")
69
70         VerifyAlarm(t, a, 1, 0)
71 }
72
73 func TestAlarmClearedSucess(t *testing.T) {
74         ts := CreatePromAlertSimulator(t, "POST", "/api/v2/alerts", http.StatusOK, models.LabelSet{})
75         defer ts.Close()
76
77         // Raise the alarm
78         a := alarmer.NewAlarm(alarm.RIC_RT_DISTRIBUTION_FAILED, alarm.SeverityMajor, "Some App data", "eth 0 1")
79         assert.Nil(t, alarmer.Raise(a), "raise failed")
80
81         VerifyAlarm(t, a, 1, 0)
82
83         // Now Clear the alarm and check alarm is removed
84         a = alarmer.NewAlarm(alarm.RIC_RT_DISTRIBUTION_FAILED, alarm.SeverityCleared, "Some App data", "eth 0 1")
85         assert.Nil(t, alarmer.Clear(a), "clear failed")
86
87         time.Sleep(time.Duration(2) * time.Second)
88         assert.Equal(t, len(alarmAdapter.activeAlarms), 0)
89 }
90
91 func TestMultipleAlarmsRaisedSucess(t *testing.T) {
92         ts := CreatePromAlertSimulator(t, "POST", "/api/v2/alerts", http.StatusOK, models.LabelSet{})
93         defer ts.Close()
94
95         // Raise two alarms
96         a := alarmer.NewAlarm(alarm.RIC_RT_DISTRIBUTION_FAILED, alarm.SeverityMajor, "Some App data", "eth 0 1")
97         assert.Nil(t, alarmer.Raise(a), "raise failed")
98
99         b := alarmer.NewAlarm(alarm.TCP_CONNECTIVITY_LOST_TO_DBAAS, alarm.SeverityMinor, "Hello", "abcd 11")
100         assert.Nil(t, alarmer.Raise(b), "raise failed")
101
102         VerifyAlarm(t, a, 2, 0)
103         VerifyAlarm(t, b, 2, 1)
104 }
105
106 func TestMultipleAlarmsClearedSucess(t *testing.T) {
107         ts := CreatePromAlertSimulator(t, "POST", "/api/v2/alerts", http.StatusOK, models.LabelSet{})
108         defer ts.Close()
109
110         // Raise two alarms
111         a := alarmer.NewAlarm(alarm.RIC_RT_DISTRIBUTION_FAILED, alarm.SeverityMajor, "Some App data", "eth 0 1")
112         assert.Nil(t, alarmer.Clear(a), "clear failed")
113
114         b := alarmer.NewAlarm(alarm.TCP_CONNECTIVITY_LOST_TO_DBAAS, alarm.SeverityMinor, "Hello", "abcd 11")
115         assert.Nil(t, alarmer.Clear(b), "clear failed")
116
117         time.Sleep(time.Duration(2) * time.Second)
118         assert.Equal(t, len(alarmAdapter.activeAlarms), 0)
119 }
120
121 func TestAlarmsSuppresedSucess(t *testing.T) {
122         ts := CreatePromAlertSimulator(t, "POST", "/api/v2/alerts", http.StatusOK, models.LabelSet{})
123         defer ts.Close()
124
125         // Raise two similar/matching alarms ... the second one suppresed
126         a := alarmer.NewAlarm(alarm.RIC_RT_DISTRIBUTION_FAILED, alarm.SeverityMajor, "Some App data", "eth 0 1")
127         assert.Nil(t, alarmer.Raise(a), "raise failed")
128         assert.Nil(t, alarmer.Raise(a), "raise failed")
129
130         VerifyAlarm(t, a, 1, 0)
131 }
132
133 func TestInvalidAlarms(t *testing.T) {
134         a := alarmer.NewAlarm(1111, alarm.SeverityMajor, "Some App data", "eth 0 1")
135         assert.Nil(t, alarmer.Raise(a), "raise failed")
136         time.Sleep(time.Duration(2) * time.Second)
137 }
138
139 func TestAlarmHandlingErrorCases(t *testing.T) {
140         ok, err := alarmAdapter.HandleAlarms(&xapp.RMRParams{})
141         assert.Equal(t, err.Error(), "unexpected end of JSON input")
142         assert.Nil(t, ok, "raise failed")
143 }
144
145 func TestConsumeUnknownMessage(t *testing.T) {
146         err := alarmAdapter.Consume(&xapp.RMRParams{})
147         assert.Nil(t, err, "raise failed")
148 }
149
150 func TestStatusCallback(t *testing.T) {
151         assert.Equal(t, true, alarmAdapter.StatusCB())
152 }
153
154 func VerifyAlarm(t *testing.T, a alarm.Alarm, count, idx int) string {
155         receivedAlert := waitForEvent()
156
157         assert.Equal(t, len(alarmAdapter.activeAlarms), count)
158
159         b := alarmAdapter.activeAlarms[idx]
160         assert.Equal(t, b.ManagedObjectId, a.ManagedObjectId)
161         assert.Equal(t, b.ApplicationId, a.ApplicationId)
162         assert.Equal(t, b.SpecificProblem, a.SpecificProblem)
163         assert.Equal(t, b.PerceivedSeverity, a.PerceivedSeverity)
164         assert.Equal(t, b.AdditionalInfo, a.AdditionalInfo)
165         assert.Equal(t, b.IdentifyingInfo, a.IdentifyingInfo)
166
167         return receivedAlert
168 }
169
170 func VerifyAlert(t *testing.T, receivedAlert, expectedAlert string) {
171         receivedAlert = strings.Replace(fmt.Sprintf("%v", receivedAlert), "\r\n", " ", -1)
172         //assert.Equal(t, receivedAlert, e)
173 }
174
175 func CreatePromAlertSimulator(t *testing.T, method, url string, status int, respData interface{}) *httptest.Server {
176         l, err := net.Listen("tcp", "localhost:9093")
177         if err != nil {
178                 t.Error("Failed to create listener: " + err.Error())
179         }
180         ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
181                 assert.Equal(t, r.Method, method)
182                 assert.Equal(t, r.URL.String(), url)
183
184                 fireEvent(t, r.Body)
185
186                 w.Header().Add("Content-Type", "application/json")
187                 w.WriteHeader(status)
188                 b, _ := json.Marshal(respData)
189                 w.Write(b)
190         }))
191         ts.Listener.Close()
192         ts.Listener = l
193
194         ts.Start()
195
196         return ts
197 }
198
199 func waitForEvent() string {
200         receivedAlert := <-eventChan
201         return receivedAlert
202 }
203
204 func fireEvent(t *testing.T, body io.ReadCloser) {
205         reqBody, err := ioutil.ReadAll(body)
206         assert.Nil(t, err, "ioutil.ReadAll failed")
207         assert.NotNil(t, reqBody, "ioutil.ReadAll failed")
208
209         eventChan <- fmt.Sprintf("%s", reqBody)
210 }