moira

1
package notifier
2

3
import (
4
	"fmt"
5
	"sync"
6
	"testing"
7
	"time"
8

9
	"github.com/golang/mock/gomock"
10
	. "github.com/smartystreets/goconvey/convey"
11

12
	"go.avito.ru/DO/moira"
13
	"go.avito.ru/DO/moira/metrics"
14
	"go.avito.ru/DO/moira/mock/moira-alert"
15
	"go.avito.ru/DO/moira/mock/scheduler"
16
	"go.avito.ru/DO/moira/test-helpers"
17
)
18

19
var (
20
	mockCtrl  *gomock.Controller
21
	sender    *mock_moira_alert.MockSender
22
	notif     *StandardNotifier
23
	scheduler *mock_scheduler.MockScheduler
24
	dataBase  *mock_moira_alert.MockDatabase
25
)
26

27
func TestUnknownContactType(t *testing.T) {
28
	configureNotifier(t)
29
	defer afterTest()
30

31
	eventsData := []moira.NotificationEvent{event}
32
	pkg := NotificationPackage{
33
		Events: eventsData,
34
		Contact: moira.ContactData{
35
			Type: "unknown contact",
36
		},
37
	}
38
	notification := moira.ScheduledNotification{}
39

40
	scheduler.EXPECT().CalculateBackoff(pkg.FailCount + 1).Return(1 * time.Minute)
41
	scheduler.EXPECT().GetDeliveryInfo(gomock.Any(), event, pkg.Throttled, pkg.FailCount+1).Return(time.Now(), false)
42
	scheduler.EXPECT().ScheduleNotification(gomock.Any(), pkg.Throttled, event, pkg.Trigger, pkg.Contact, pkg.FailCount+1, pkg.NeedAck).Return(&notification)
43
	dataBase.EXPECT().AddNotification(&notification).Return(nil)
44

45
	wg := sync.WaitGroup{}
46
	notif.Send(&pkg, &wg)
47
	wg.Wait()
48
}
49

50
func TestFailSendEvent(t *testing.T) {
51
	configureNotifier(t)
52
	defer afterTest()
53

54
	var eventsData moira.NotificationEvents = []moira.NotificationEvent{event}
55

56
	pkg := NotificationPackage{
57
		Events: eventsData,
58
		Contact: moira.ContactData{
59
			Type: "test",
60
		},
61
	}
62
	notification := moira.ScheduledNotification{}
63

64
	sender.EXPECT().SendEvents(eventsData, pkg.Contact, pkg.Trigger, pkg.Throttled, pkg.NeedAck).Return(fmt.Errorf("Can't send"))
65
	scheduler.EXPECT().CalculateBackoff(pkg.FailCount + 1).Return(1 * time.Minute)
66
	scheduler.EXPECT().GetDeliveryInfo(gomock.Any(), event, pkg.Throttled, pkg.FailCount+1).Return(time.Now(), false)
67
	scheduler.EXPECT().ScheduleNotification(gomock.Any(), pkg.Throttled, event, pkg.Trigger, pkg.Contact, pkg.FailCount+1, pkg.NeedAck).Return(&notification)
68
	dataBase.EXPECT().AddNotification(&notification).Return(nil)
69

70
	var wg sync.WaitGroup
71
	notif.Send(&pkg, &wg)
72
	wg.Wait()
73
	time.Sleep(time.Second * 2)
74
}
75

76
func configureNotifier(t *testing.T) {
77
	test_helpers.InitTestLogging()
78
	notifierMetrics := metrics.NewNotifierMetrics()
79

80
	var location, _ = time.LoadLocation("UTC")
81
	config := Config{
82
		SendingTimeout:   time.Millisecond * 10,
83
		ResendingTimeout: time.Hour * 24,
84
		Location:         location,
85
	}
86
	mockCtrl = gomock.NewController(t)
87

88
	dataBase = mock_moira_alert.NewMockDatabase(mockCtrl)
89
	test_helpers.InitTestLogging()
90

91
	scheduler = mock_scheduler.NewMockScheduler(mockCtrl)
92
	sender = mock_moira_alert.NewMockSender(mockCtrl)
93

94
	notif = NewNotifier(dataBase, config, notifierMetrics)
95
	notif.scheduler = scheduler
96
	senderSettings := map[string]string{
97
		"type": "test",
98
	}
99

100
	sender.EXPECT().Init(senderSettings, location).Return(nil)
101

102
	notif.RegisterSender(senderSettings, sender)
103

104
	Convey("Should return one sender", t, func() {
105
		So(notif.GetSenders(), ShouldResemble, map[string]bool{"test": true})
106
	})
107
}
108

109
func afterTest() {
110
	mockCtrl.Finish()
111
	notif.StopSenders()
112
}
113

114
var subID = "SubscriptionID-000000000000001"
115

116
var event = moira.NotificationEvent{
117
	Metric:         "generate.event.1",
118
	State:          moira.OK,
119
	OldState:       moira.WARN,
120
	TriggerID:      "triggerID-0000000000001",
121
	SubscriptionID: &subID,
122
}
123