1 package services
2
3 import (
4 "context"
5 "database/sql/driver"
6 "testing"
7
8 "github.com/DATA-DOG/go-sqlmock"
9 "github.com/stretchr/testify/assert"
10
11 "edge-infra.dev/pkg/edge/api/graph/model"
12 sqlquery "edge-infra.dev/pkg/edge/api/sql"
13 )
14
15 var (
16 namespaces = []model.Namespace{
17 {
18 NamespaceEdgeID: "b83ba6a5-5954-4d0b-85b3-fd5d51388bc1",
19 BannerEdgeID: "d8ce5b2b-17a9-442a-a326-92479dd9475c",
20 Name: "test-namespace-1",
21 Workload: model.WorkloadTypeTenant,
22 },
23 {
24 NamespaceEdgeID: "938593f4-68ca-4a89-8ded-94505ee7e740",
25 BannerEdgeID: "d8ce5b2b-17a9-442a-a326-92479dd9475c",
26 Name: "test-namespace-2",
27 Workload: model.WorkloadTypeTenant,
28 },
29 {
30 NamespaceEdgeID: "678d2136-c366-441f-a463-4bbbddec4f74",
31 BannerEdgeID: "752136c0-66a8-49f3-9217-2a7ecb851c68",
32 Name: "test-namespace-3",
33 Workload: model.WorkloadTypeTenant,
34 },
35 }
36 namespaceColumns = []string{"namespace_edge_id", "banner_edge_id", "name", "workload"}
37 )
38
39 func TestCreateNamespace(t *testing.T) {
40 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
41 if err != nil {
42 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
43 }
44 defer db.Close()
45
46 mockNamespace := namespaces[0]
47
48 mock.ExpectBegin()
49 mockDBNamespaceCreate(mock, mockNamespace, sqlmock.NewResult(1, 1))
50 mock.ExpectCommit()
51
52 service := NewNamespaceService(db)
53
54 createNamespace := getNamespaceCreateInput(mockNamespace)
55 _, createErr := service.CreateNamespaceEntry(context.Background(), createNamespace)
56 mockErr := mock.ExpectationsWereMet()
57
58 assert.NoError(t, createErr)
59 assert.NoError(t, mockErr)
60 }
61
62 func TestDeleteNamespace(t *testing.T) {
63 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
64 if err != nil {
65 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
66 }
67 defer db.Close()
68
69 bannerEdgeID := namespaces[0].BannerEdgeID
70 name := namespaces[0].Name
71
72 mockDBNamespaceDelete(mock, bannerEdgeID, name, sqlmock.NewResult(1, 1))
73 service := NewNamespaceService(db)
74
75 if err := service.DeleteNamespaceEntry(context.Background(), bannerEdgeID, name); err != nil {
76 t.Errorf("error was not expected while deleting namespace: %s", err)
77 }
78
79 assert.NoError(t, mock.ExpectationsWereMet())
80 }
81
82 func TestGetBannerNamespaces(t *testing.T) {
83 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
84 if err != nil {
85 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
86 }
87 defer db.Close()
88
89 mockNamespace := namespaces[0]
90
91 mockDBGetBannerNamespaces(mock, mockNamespace.BannerEdgeID, mockNamespace.Name, []model.Namespace{mockNamespace})
92
93 service := NewNamespaceService(db)
94
95 returnNamespaces, err := service.GetBannerNamespaces(context.Background(), mockNamespace.BannerEdgeID, &mockNamespace.Name)
96
97 assert.NoError(t, err)
98 assert.NoError(t, mock.ExpectationsWereMet())
99 assert.NotNil(t, returnNamespaces)
100 assert.Equal(t, 1, len(returnNamespaces))
101 assert.Equal(t, mockNamespace, *returnNamespaces[0])
102 }
103
104 func TestGetAllBannerNamespaces(t *testing.T) {
105 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
106 if err != nil {
107 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
108 }
109 defer db.Close()
110
111 mockNamespaces := namespaces[0:2]
112 bannerEdgeID := mockNamespaces[0].BannerEdgeID
113
114 mockDBGetAllBannerNamespaces(mock, bannerEdgeID, mockNamespaces)
115
116 service := NewNamespaceService(db)
117
118 returnNamespaces, err := service.GetBannerNamespaces(context.Background(), bannerEdgeID, nil)
119
120 assert.NoError(t, err)
121 assert.NoError(t, mock.ExpectationsWereMet())
122 assert.NotNil(t, returnNamespaces)
123 assert.Equal(t, len(mockNamespaces), len(returnNamespaces))
124 assert.Equal(t, mockNamespaces[0], *returnNamespaces[0])
125 assert.Equal(t, mockNamespaces[1], *returnNamespaces[1])
126 }
127
128 func TestGetClusterNamespaces(t *testing.T) {
129 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
130 if err != nil {
131 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
132 }
133 defer db.Close()
134
135 mockClusterNamespaces := namespaces[0:2]
136 clusterEdgeID := "78613f69-785b-4a37-aa9a-e9e6aa341058"
137 name := namespaces[0].Name
138
139 mockDBGetClusterNamespaces(mock, clusterEdgeID, name, mockClusterNamespaces)
140
141 service := NewNamespaceService(db)
142
143 _, err = service.GetClusterNamespaces(context.Background(), clusterEdgeID, &name)
144
145 assert.NoError(t, err)
146 assert.NoError(t, mock.ExpectationsWereMet())
147 }
148
149 func TestGetAllClusterNamespaces(t *testing.T) {
150 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
151 if err != nil {
152 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
153 }
154 defer db.Close()
155
156 mockClusterNamespaces := namespaces[0:1]
157 clusterEdgeID := "78613f69-785b-4a37-aa9a-e9e6aa341058"
158
159 mockDBGetAllClusterNamespaces(mock, clusterEdgeID, mockClusterNamespaces)
160
161 service := NewNamespaceService(db)
162
163 _, err = service.GetClusterNamespaces(context.Background(), clusterEdgeID, nil)
164
165 assert.NoError(t, err)
166 assert.NoError(t, mock.ExpectationsWereMet())
167 }
168
169 func mockDBNamespaceCreate(mock sqlmock.Sqlmock, mockNamespace model.Namespace, result driver.Result) {
170 input := []driver.Value{
171 sqlmock.AnyArg(),
172 mockNamespace.BannerEdgeID,
173 mockNamespace.Name,
174 mockNamespace.Workload,
175 }
176
177 mock.ExpectExec(sqlquery.NamespaceCreateQuery).
178 WithArgs(input...).
179 WillReturnResult(result)
180 }
181
182 func mockDBNamespaceDelete(mock sqlmock.Sqlmock, bannerEdgeID string, name string, result driver.Result) {
183 input := []driver.Value{
184 bannerEdgeID,
185 name,
186 }
187
188 mock.ExpectExec(sqlquery.NamespaceDeleteQuery).
189 WithArgs(input...).
190 WillReturnResult(result)
191 }
192
193 func mockDBGetBannerNamespaces(mock sqlmock.Sqlmock, bannerEdgeID string, name string, returnNamespaces []model.Namespace) {
194 rows := mock.NewRows(namespaceColumns)
195
196 if len(returnNamespaces) != 0 {
197 for _, returnNamespace := range returnNamespaces {
198 rows.AddRow(returnNamespace.NamespaceEdgeID, returnNamespace.BannerEdgeID, returnNamespace.Name, returnNamespace.Workload)
199 }
200 }
201
202 input := []driver.Value{
203 bannerEdgeID,
204 name,
205 }
206
207 mock.ExpectQuery(sqlquery.GetBannerNamespacesQuery).
208 WithArgs(input...).
209 WillReturnRows(rows)
210 }
211
212 func mockDBGetAllBannerNamespaces(mock sqlmock.Sqlmock, bannerEdgeID string, returnNamespaces []model.Namespace) {
213 rows := mock.NewRows(namespaceColumns)
214
215 if len(returnNamespaces) != 0 {
216 for _, returnNamespace := range returnNamespaces {
217 rows.AddRow(returnNamespace.NamespaceEdgeID, returnNamespace.BannerEdgeID, returnNamespace.Name, returnNamespace.Workload)
218 }
219 }
220
221 input := []driver.Value{
222 bannerEdgeID,
223 }
224
225 mock.ExpectQuery(sqlquery.GetAllBannerNamespacesQuery).
226 WithArgs(input...).
227 WillReturnRows(rows)
228 }
229
230 func mockDBGetClusterNamespaces(mock sqlmock.Sqlmock, clusterEdgeID string, name string, returnClusterNamespaces []model.Namespace) {
231 rows := mock.NewRows(namespaceColumns)
232
233 if len(returnClusterNamespaces) != 0 {
234 for _, returnClusterNamespace := range returnClusterNamespaces {
235 rows.AddRow(returnClusterNamespace.NamespaceEdgeID, returnClusterNamespace.BannerEdgeID, returnClusterNamespace.Name, returnClusterNamespace.Workload)
236 }
237 }
238
239 input := []driver.Value{
240 clusterEdgeID,
241 name,
242 }
243
244 mock.ExpectQuery(sqlquery.GetClusterNamespacesQuery).
245 WithArgs(input...).
246 WillReturnRows(rows)
247 }
248
249 func mockDBGetAllClusterNamespaces(mock sqlmock.Sqlmock, clusterEdgeID string, returnClusterNamespaces []model.Namespace) {
250 rows := mock.NewRows(namespaceColumns)
251
252 if len(returnClusterNamespaces) != 0 {
253 for _, returnClusterNamespace := range returnClusterNamespaces {
254 rows.AddRow(returnClusterNamespace.NamespaceEdgeID, returnClusterNamespace.BannerEdgeID, returnClusterNamespace.Name, returnClusterNamespace.Workload)
255 }
256 }
257
258 input := []driver.Value{
259 clusterEdgeID,
260 }
261
262 mock.ExpectQuery(sqlquery.GetAllClusterNamespacesQuery).
263 WithArgs(input...).
264 WillReturnRows(rows)
265 }
266
267 func getNamespaceCreateInput(createNamespace model.Namespace) *model.NamespaceCreateInput {
268 return &model.NamespaceCreateInput{
269 BannerEdgeID: createNamespace.BannerEdgeID,
270 Name: createNamespace.Name,
271 Workload: createNamespace.Workload,
272 }
273 }
274
View as plain text