moira

1
package controller
2

3
import (
4
	"fmt"
5
	"testing"
6

7
	"github.com/golang/mock/gomock"
8
	"github.com/satori/go.uuid"
9
	. "github.com/smartystreets/goconvey/convey"
10

11
	"go.avito.ru/DO/moira"
12
	"go.avito.ru/DO/moira/api"
13
	"go.avito.ru/DO/moira/api/dto"
14
	"go.avito.ru/DO/moira/database"
15
	"go.avito.ru/DO/moira/mock/moira-alert"
16
)
17

18
func TestGetUserSubscriptions(t *testing.T) {
19
	mockCtrl := gomock.NewController(t)
20
	defer mockCtrl.Finish()
21
	database := mock_moira_alert.NewMockDatabase(mockCtrl)
22
	login := "user"
23

24
	Convey("Two subscriptions", t, func() {
25
		subscriptionIDs := []string{uuid.NewV4().String(), uuid.NewV4().String()}
26
		subscriptions := []*moira.SubscriptionData{{ID: subscriptionIDs[0]}, {ID: subscriptionIDs[1]}}
27
		database.EXPECT().GetUserSubscriptionIDs(login).Return(subscriptionIDs, nil)
28
		database.EXPECT().GetSubscriptions(subscriptionIDs).Return(subscriptions, nil)
29
		list, err := GetUserSubscriptions(database, login)
30
		So(err, ShouldBeNil)
31
		So(list, ShouldResemble, &dto.SubscriptionList{List: []moira.SubscriptionData{*subscriptions[0], *subscriptions[1]}})
32
	})
33

34
	Convey("Two ids, one subscription", t, func() {
35
		subscriptionIDs := []string{uuid.NewV4().String(), uuid.NewV4().String()}
36
		subscriptions := []*moira.SubscriptionData{{ID: subscriptionIDs[1]}}
37
		database.EXPECT().GetUserSubscriptionIDs(login).Return(subscriptionIDs, nil)
38
		database.EXPECT().GetSubscriptions(subscriptionIDs).Return(subscriptions, nil)
39
		list, err := GetUserSubscriptions(database, login)
40
		So(err, ShouldBeNil)
41
		So(list, ShouldResemble, &dto.SubscriptionList{List: []moira.SubscriptionData{*subscriptions[0]}})
42
	})
43

44
	Convey("Errors", t, func() {
45
		Convey("GetUserSubscriptionIDs", func() {
46
			expected := fmt.Errorf("Oh no!!!11 Cant get subscription ids")
47
			database.EXPECT().GetUserSubscriptionIDs(login).Return(nil, expected)
48
			list, err := GetUserSubscriptions(database, login)
49
			So(err, ShouldResemble, api.ErrorInternalServer(expected))
50
			So(list, ShouldBeNil)
51
		})
52

53
		Convey("GetSubscriptions", func() {
54
			expected := fmt.Errorf("Oh no!!!11 Cant get subscriptions")
55
			subscriptionIDs := []string{uuid.NewV4().String(), uuid.NewV4().String()}
56
			database.EXPECT().GetUserSubscriptionIDs(login).Return(subscriptionIDs, nil)
57
			database.EXPECT().GetSubscriptions(subscriptionIDs).Return(nil, expected)
58
			list, err := GetUserSubscriptions(database, login)
59
			So(err, ShouldResemble, api.ErrorInternalServer(expected))
60
			So(list, ShouldBeNil)
61
		})
62
	})
63
}
64

65
func TestUpdateSubscription(t *testing.T) {
66
	mockCtrl := gomock.NewController(t)
67
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
68
	defer mockCtrl.Finish()
69
	userLogin := "user"
70

71
	Convey("Success update", t, func() {
72
		subscriptionDTO := &dto.Subscription{}
73
		subscriptionID := uuid.NewV4().String()
74
		subscription := moira.SubscriptionData{
75
			ID:   subscriptionID,
76
			User: userLogin,
77
		}
78
		dataBase.EXPECT().SaveSubscription(&subscription).Return(nil)
79
		err := UpdateSubscription(dataBase, subscriptionID, userLogin, subscriptionDTO)
80
		So(err, ShouldBeNil)
81
		So(subscriptionDTO.User, ShouldResemble, userLogin)
82
		So(subscriptionDTO.ID, ShouldResemble, subscriptionID)
83
	})
84

85
	Convey("Error save", t, func() {
86
		subscriptionDTO := &dto.Subscription{}
87
		subscriptionID := uuid.NewV4().String()
88
		subscription := moira.SubscriptionData{
89
			ID:   subscriptionID,
90
			User: userLogin,
91
		}
92
		err := fmt.Errorf("Oooops")
93
		dataBase.EXPECT().SaveSubscription(&subscription).Return(err)
94
		actual := UpdateSubscription(dataBase, subscriptionID, userLogin, subscriptionDTO)
95
		So(actual, ShouldResemble, api.ErrorInternalServer(err))
96
		So(subscriptionDTO.User, ShouldResemble, userLogin)
97
		So(subscriptionDTO.ID, ShouldResemble, subscriptionID)
98
	})
99
}
100

101
func TestRemoveSubscription(t *testing.T) {
102
	mockCtrl := gomock.NewController(t)
103
	defer mockCtrl.Finish()
104
	database := mock_moira_alert.NewMockDatabase(mockCtrl)
105
	id := uuid.NewV4().String()
106

107
	Convey("Success", t, func() {
108
		database.EXPECT().RemoveSubscription(id).Return(nil)
109
		err := RemoveSubscription(database, id)
110
		So(err, ShouldBeNil)
111
	})
112

113
	Convey("Error", t, func() {
114
		expected := fmt.Errorf("Oooops! Can not remove subscription")
115
		database.EXPECT().RemoveSubscription(id).Return(expected)
116
		err := RemoveSubscription(database, id)
117
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
118
	})
119
}
120

121
func TestSendTestNotification(t *testing.T) {
122
	mockCtrl := gomock.NewController(t)
123
	defer mockCtrl.Finish()
124
	database := mock_moira_alert.NewMockDatabase(mockCtrl)
125
	id := uuid.NewV4().String()
126

127
	Convey("Success", t, func() {
128
		database.EXPECT().PushNotificationEvent(gomock.Any()).Return(nil)
129
		err := SendTestNotification(database, id)
130
		So(err, ShouldBeNil)
131
	})
132

133
	Convey("Error", t, func() {
134
		expected := fmt.Errorf("Oooops! Can not push event")
135
		database.EXPECT().PushNotificationEvent(gomock.Any()).Return(expected)
136
		err := SendTestNotification(database, id)
137
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
138
	})
139
}
140

141
func TestCreateSubscription(t *testing.T) {
142
	mockCtrl := gomock.NewController(t)
143
	defer mockCtrl.Finish()
144
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
145
	login := "user"
146

147
	Convey("Success create", t, func() {
148
		subscription := dto.Subscription{ID: ""}
149
		dataBase.EXPECT().SaveSubscription(gomock.Any()).Return(nil)
150
		err := CreateSubscription(dataBase, login, &subscription)
151
		So(err, ShouldBeNil)
152
	})
153

154
	Convey("Success create subscription with id", t, func() {
155
		sub := &dto.Subscription{
156
			ID: uuid.NewV4().String(),
157
		}
158
		dataBase.EXPECT().GetSubscription(sub.ID).Return(moira.SubscriptionData{}, database.ErrNil)
159
		dataBase.EXPECT().SaveSubscription(gomock.Any()).Return(nil)
160
		err := CreateSubscription(dataBase, login, sub)
161
		So(err, ShouldBeNil)
162
		So(sub.User, ShouldResemble, login)
163
		So(sub.ID, ShouldResemble, sub.ID)
164
	})
165

166
	Convey("Subscription exists by id", t, func() {
167
		subscription := &dto.Subscription{
168
			ID: uuid.NewV4().String(),
169
		}
170
		dataBase.EXPECT().GetSubscription(subscription.ID).Return(moira.SubscriptionData{}, nil)
171
		err := CreateSubscription(dataBase, login, subscription)
172
		So(err, ShouldResemble, api.ErrorInvalidRequest(fmt.Errorf("Subscription with this ID already exists")))
173
	})
174

175
	Convey("Error get subscription", t, func() {
176
		subscription := &dto.Subscription{
177
			ID: uuid.NewV4().String(),
178
		}
179
		err := fmt.Errorf("Oooops! Can not write contact")
180
		dataBase.EXPECT().GetSubscription(subscription.ID).Return(moira.SubscriptionData{}, err)
181
		expected := CreateSubscription(dataBase, login, subscription)
182
		So(expected, ShouldResemble, api.ErrorInternalServer(err))
183
	})
184

185
	Convey("Error save subscription", t, func() {
186
		subscription := dto.Subscription{ID: ""}
187
		expected := fmt.Errorf("Oooops! Can not create subscription")
188
		dataBase.EXPECT().SaveSubscription(gomock.Any()).Return(expected)
189
		err := CreateSubscription(dataBase, login, &subscription)
190
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
191
	})
192
}
193

194
func TestCheckUserPermissionsForSubscription(t *testing.T) {
195
	mockCtrl := gomock.NewController(t)
196
	defer mockCtrl.Finish()
197
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
198
	userLogin := uuid.NewV4().String()
199
	id := uuid.NewV4().String()
200

201
	Convey("No subscription", t, func() {
202
		dataBase.EXPECT().GetSubscription(id).Return(moira.SubscriptionData{}, database.ErrNil)
203
		expectedSub, expected := CheckUserPermissionsForSubscription(dataBase, id, userLogin)
204
		So(expected, ShouldResemble, api.ErrorNotFound(fmt.Sprintf("Subscription with ID '%s' does not exists", id)))
205
		So(expectedSub, ShouldResemble, moira.SubscriptionData{})
206
	})
207

208
	Convey("Different user", t, func() {
209
		actualSub := moira.SubscriptionData{User: "diffUser"}
210
		dataBase.EXPECT().GetSubscription(id).Return(actualSub, nil)
211
		expectedSub, expected := CheckUserPermissionsForSubscription(dataBase, id, userLogin)
212
		So(expected, ShouldResemble, api.ErrorForbidden("You have not permissions"))
213
		So(expectedSub, ShouldResemble, actualSub)
214
	})
215

216
	Convey("Has subscription", t, func() {
217
		actualSub := moira.SubscriptionData{ID: id, User: userLogin}
218
		dataBase.EXPECT().GetSubscription(id).Return(actualSub, nil)
219
		expectedSub, expected := CheckUserPermissionsForSubscription(dataBase, id, userLogin)
220
		So(expected, ShouldBeNil)
221
		So(expectedSub, ShouldResemble, actualSub)
222
	})
223

224
	Convey("Error get contact", t, func() {
225
		err := fmt.Errorf("Oooops! Can not read contact")
226
		dataBase.EXPECT().GetSubscription(id).Return(moira.SubscriptionData{}, err)
227
		expectedSub, expected := CheckUserPermissionsForSubscription(dataBase, id, userLogin)
228
		So(expected, ShouldResemble, api.ErrorInternalServer(err))
229
		So(expectedSub, ShouldResemble, moira.SubscriptionData{})
230
	})
231
}
232