1 package services
2
3 import (
4 "context"
5 "database/sql"
6 "testing"
7
8 "github.com/DATA-DOG/go-sqlmock"
9 "github.com/stretchr/testify/assert"
10
11 "edge-infra.dev/pkg/edge/api/bsl/types"
12 "edge-infra.dev/pkg/edge/api/graph/model"
13 sqlquery "edge-infra.dev/pkg/edge/api/sql"
14 "edge-infra.dev/pkg/edge/bsl"
15 )
16
17 func TestTenantService_List(t *testing.T) {
18 db, sqlMock := setup(t)
19 defer db.Close()
20
21 mockTentant := &model.Tenant{
22 TenantBSLId: "5dcabc872e4f4c37975fa3ff16022910",
23 TenantEdgeID: "8a3f8a89-b5c9-4ba3-1d3a-be90de5e24e1",
24 OrgName: "test-bsl-org-1",
25 }
26
27 type test struct {
28 testName string
29 mockSQLQuery func() *sqlmock.ExpectedQuery
30 expectedLen int
31 expectedTenantID string
32 }
33
34 bspCfg := types.BSPConfig{}
35
36 bslClient := bsl.NewBSLClient(bspCfg)
37
38 service := NewTenantService(db, bslClient, nil)
39
40 tests := []test{
41 {
42 testName: "listTenants",
43 expectedLen: 1,
44 expectedTenantID: mockTentant.TenantEdgeID,
45 mockSQLQuery: func() *sqlmock.ExpectedQuery {
46 return sqlMock.ExpectQuery(sqlquery.TenantListQuery).
47 WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
48 AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
49 },
50 },
51 }
52
53 for _, tc := range tests {
54 tc.mockSQLQuery()
55 t.Run(tc.testName, func(t *testing.T) {
56 tenants, err := service.List(context.Background())
57 assert.Equal(t, len(tenants), tc.expectedLen)
58 assert.Equal(t, tenants[0].TenantEdgeID, tc.expectedTenantID)
59
60 assert.NoError(t, err)
61 })
62 }
63 }
64
65 func TestTenantService_GetByTenantID(t *testing.T) {
66 db, sqlMock := setup(t)
67 defer db.Close()
68
69 mockTentant := &model.Tenant{
70 TenantBSLId: "5dcabc872e4f4c37975fa3ff16022910",
71 TenantEdgeID: "8a3f8a89-b5c9-4ba3-1d3a-be90de5e24e1",
72 OrgName: "test-bsl-org-1",
73 }
74
75 type test struct {
76 testName string
77 mockSQLQuery func() *sqlmock.ExpectedQuery
78 expectedLen int
79 expectedTenantID string
80 }
81
82 bspCfg := types.BSPConfig{}
83
84 bslClient := bsl.NewBSLClient(bspCfg)
85
86 service := NewTenantService(db, bslClient, nil)
87
88 tests := []test{
89 {
90 testName: "getTenantByID",
91 expectedLen: 1,
92 expectedTenantID: mockTentant.TenantEdgeID,
93 mockSQLQuery: func() *sqlmock.ExpectedQuery {
94 return sqlMock.ExpectQuery(sqlquery.TenantGetQuery).
95 WithArgs(mockTentant.TenantEdgeID).
96 WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
97 AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
98 },
99 },
100 }
101
102 for _, tc := range tests {
103 tc.mockSQLQuery()
104 t.Run(tc.testName, func(t *testing.T) {
105 tenant, err := service.Get(context.Background(), mockTentant.TenantEdgeID)
106
107 assert.Equal(t, tc.expectedTenantID, tenant.TenantEdgeID)
108 assert.NoError(t, err)
109 })
110 }
111 }
112
113 func TestTenantService_GetTenantByBannerIDOrByClusterEdgeID(t *testing.T) {
114 db, sqlMock := setup(t)
115 defer db.Close()
116
117 mockTentant := &model.Tenant{
118 TenantBSLId: "5dcabc872e4f4c37975fa3ff16022910",
119 TenantEdgeID: "8a3f8a89-b5c9-4ba3-1d3a-be90de5e24e1",
120 OrgName: "test-bsl-org-1",
121 }
122
123 type test struct {
124 testName string
125 mockSQLQuery func() *sqlmock.ExpectedQuery
126 service func() (*model.Tenant, error)
127 expectedTenantID string
128 }
129
130 bspCfg := types.BSPConfig{}
131
132 bslClient := bsl.NewBSLClient(bspCfg)
133
134 service := NewTenantService(db, bslClient, nil)
135
136 tests := []test{
137
138 {
139 testName: "getTenantByBannerID",
140 expectedTenantID: mockTentant.TenantEdgeID,
141 service: func() (*model.Tenant, error) {
142 return service.GetTenantByBannerID(context.Background(), testBannerID)
143 },
144 mockSQLQuery: func() *sqlmock.ExpectedQuery {
145 return sqlMock.ExpectQuery(sqlquery.GetTenantByBannerEdgeID).
146 WithArgs(testBannerID).
147 WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
148 AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
149 },
150 },
151 {
152 testName: "getTenantByClusterEdgeID",
153 expectedTenantID: mockTentant.TenantEdgeID,
154 service: func() (*model.Tenant, error) {
155 return service.GetTenantByClusterEdgeID(context.Background(), testClusterEdgeID)
156 },
157 mockSQLQuery: func() *sqlmock.ExpectedQuery {
158 return sqlMock.ExpectQuery(sqlquery.GetTenantByClusterEdgeID).
159 WithArgs(testClusterEdgeID).
160 WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
161 AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
162 },
163 },
164 }
165
166 for _, tc := range tests {
167 tc.mockSQLQuery()
168 t.Run(tc.testName, func(t *testing.T) {
169 tenant, err := tc.service()
170 assert.Equal(t, tc.expectedTenantID, tenant.TenantEdgeID)
171 assert.NoError(t, err)
172 })
173 }
174 }
175
176 func TestTenantService_Create(t *testing.T) {
177 db, sqlMock := setup(t)
178 sqlMock.MatchExpectationsInOrder(false)
179
180 defer db.Close()
181
182 mockTentant := &model.Tenant{
183 TenantBSLId: "5dcabc872e4f4c37975fa3ff16022910",
184 TenantEdgeID: "8a3f8a89-b5c9-4ba3-1d3a-be90de5e24e1",
185 OrgName: "test-bsl-org-1",
186 }
187
188 type test struct {
189 testName string
190 mockSQLQuery func() *sqlmock.ExpectedQuery
191 mockSQLInsert func() *sqlmock.ExpectedExec
192 expectedTenantID string
193 }
194
195 bspCfg := types.BSPConfig{}
196
197 bslClient := bsl.NewBSLClient(bspCfg)
198
199 service := NewTenantService(db, bslClient, nil)
200
201 tests := []test{
202 {
203 testName: "createTenant",
204 expectedTenantID: mockTentant.TenantEdgeID,
205 mockSQLInsert: func() *sqlmock.ExpectedExec {
206 return sqlMock.ExpectExec(sqlquery.TenantInsertQuery).
207 WithArgs(mockTentant.TenantBSLId, mockTentant.OrgName).
208 WillReturnResult(sqlmock.NewResult(1, 1))
209 },
210 mockSQLQuery: func() *sqlmock.ExpectedQuery {
211 return sqlMock.ExpectQuery(sqlquery.TenantGetNoIDQuery).
212 WithArgs(mockTentant.TenantBSLId, mockTentant.OrgName).
213 WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
214 AddRow(mockTentant.TenantEdgeID, mockTentant.TenantBSLId, mockTentant.OrgName))
215 },
216 },
217 }
218
219 for _, tc := range tests {
220 tc.mockSQLInsert()
221 tc.mockSQLQuery()
222
223 t.Run(tc.testName, func(t *testing.T) {
224 tenant, err := service.Create(context.Background(), &model.TenantInput{
225 OrgName: mockTentant.OrgName,
226 TenantBSLId: mockTentant.TenantBSLId,
227 })
228
229 assert.Equal(t, tc.expectedTenantID, tenant.TenantEdgeID)
230 assert.NoError(t, err)
231 })
232 }
233 }
234
235 func TestTenantService_GetOktaTenants(t *testing.T) {
236 testOktaToken := "test-okta-token"
237
238 db, sqlMock := setup(t)
239 sqlMock.MatchExpectationsInOrder(false)
240
241 defer db.Close()
242
243 mockTenants := []*model.Tenant{
244 {
245 TenantBSLId: "5dcabc872e4f4c37975fa3ff16022910",
246 TenantEdgeID: "578fbb65-3ae7-466e-9241-fb5e2aee306d",
247 OrgName: "test-bsl-org-1",
248 },
249 {
250 TenantBSLId: "5dcabc874e4f4c37975fa3ff16022911",
251 TenantEdgeID: "773083cd-476e-40fb-a174-7a761c33acdd",
252 OrgName: "test-bsl-org-2",
253 },
254 {
255 TenantBSLId: "7dcabc872e4f4c37975fa3ff16022912",
256 TenantEdgeID: "569e1a86-bb52-4b9d-95d5-9fb3892a2496",
257 OrgName: "test-bsl-org-3",
258 },
259 }
260
261 svr := GetMockBspServer(testOrg, testOrgID, testUser, "", "", "")
262
263 bspCfg := types.BSPConfig{
264 Endpoint: svr.URL,
265 Root: "/customers/",
266 }
267
268 for _, mockTenant := range mockTenants {
269 sqlMock.ExpectQuery(sqlquery.TenantGetByName).
270 WithArgs(mockTenant.OrgName).
271 WillReturnRows(sqlmock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
272 AddRow(mockTenant.TenantEdgeID, mockTenant.TenantBSLId, mockTenant.OrgName))
273 }
274
275 bslClient := bsl.NewBSLClient(bspCfg)
276
277 service := NewTenantService(db, bslClient, &bspCfg)
278
279 tenants, err := service.GetOktaTenants(context.Background(), testOktaToken)
280 assert.NoError(t, err)
281 assert.Len(t, tenants, 3)
282 }
283
284 func setup(t *testing.T) (*sql.DB, sqlmock.Sqlmock) {
285 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
286 if err != nil {
287 t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
288 }
289
290 return db, mock
291 }
292
View as plain text