1 package sql
2
3 import (
4 "context"
5 "os"
6 "testing"
7 "time"
8
9 _ "github.com/jackc/pgx/v4/stdlib"
10 "gotest.tools/v3/assert"
11
12 "edge-infra.dev/pkg/f8n/devinfra/testinfra/model"
13 "edge-infra.dev/pkg/f8n/devinfra/testinfra/sql"
14 "edge-infra.dev/pkg/f8n/devinfra/testinfra/sql/schema"
15 "edge-infra.dev/test/f2"
16 pg "edge-infra.dev/test/f2/x/postgres"
17 )
18
19 var (
20 f f2.Framework
21 )
22
23 const (
24 selectCountJobs = `
25 SELECT Count(*) FROM edge_jobs;
26 `
27
28 selectCountMetadata = `
29 SELECT Count(*) FROM edge_job_metadatas;
30 `
31
32 selectCountTests = `
33 SELECT Count(*) FROM edge_job_tests;
34 `
35
36 deleteJob = "DELETE FROM edge_jobs WHERE number = $1 RETURNING number"
37 )
38
39 func TestMain(m *testing.M) {
40 f = f2.New(context.Background(),
41 f2.WithExtensions(
42 pg.New(),
43 ),
44 )
45 os.Exit(f.Run(m))
46 }
47
48 func TestTestInfra(t *testing.T) {
49 feat := f2.NewFeature("Test schema can be added").
50 Setup("setup schema", func(ctx f2.Context, t *testing.T) f2.Context {
51 db := pg.FromContextT(ctx, t).DB()
52 file, err := schema.SQL.ReadFile("schema.sql")
53 assert.NilError(t, err)
54
55 _, err = db.Exec(string(file))
56 assert.NilError(t, err)
57
58 return ctx
59 }).Test("db is empty", func(ctx f2.Context, t *testing.T) f2.Context {
60
61 pg := pg.FromContextT(ctx, t)
62 db := pg.DB()
63
64 rows, err := db.QueryContext(ctx, selectCountJobs)
65 assert.NilError(t, err)
66
67 var count int
68 for rows.Next() {
69 err = rows.Scan(&count)
70 assert.NilError(t, err)
71 }
72 assert.Equal(t, count, 0)
73
74 return ctx
75 }).Test("insert data from 48 hours ago", func(ctx f2.Context, t *testing.T) f2.Context {
76
77 pg := pg.FromContextT(ctx, t)
78 db := pg.DB()
79
80 dbHandle := &sql.DBHandle{DB: db}
81
82 job := model.EdgeJob{
83 Number: "4568537873",
84 Repos: "edge-test",
85 Job: "verify",
86 Workflow: "hack",
87 Started: time.Now().AddDate(0, 0, -2),
88 TestsRun: 15,
89 TestsFailed: 0,
90 }
91 pastJobID, err := dbHandle.InsertEdgeJob(ctx, job)
92 assert.NilError(t, err)
93
94 meta := model.EdgeJobMetadata{
95 EdgeJob: pastJobID,
96 Key: "a",
97 Value: "b",
98 }
99 _, err = dbHandle.InsertEdgeJobMetadata(ctx, meta)
100 assert.NilError(t, err)
101
102 testCase := model.EdgeJobTest{
103 EdgeJob: pastJobID,
104 Name: "test-1",
105 Suite: "suite 1",
106 Time: 300,
107 Failed: true,
108 FailureText: "failed because of reasons",
109 }
110 _, err = dbHandle.InsertEdgeJobTest(ctx, testCase)
111 assert.NilError(t, err)
112
113 return ctx
114 }).Test("insert present data", func(ctx f2.Context, t *testing.T) f2.Context {
115
116
117
118 pg := pg.FromContextT(ctx, t)
119 db := pg.DB()
120
121 dbHandle := &sql.DBHandle{DB: db}
122
123 job := model.EdgeJob{
124 Number: "4568537872",
125 Repos: "edge-test",
126 Workflow: "pre",
127 Job: "ci",
128 Started: time.Now(),
129 TestsRun: 14,
130 TestsFailed: 14,
131 }
132 jobID, err := dbHandle.InsertEdgeJob(ctx, job)
133 assert.NilError(t, err)
134
135 t.Logf("jobID: %s \n", jobID)
136
137 meta := model.EdgeJobMetadata{
138 EdgeJob: jobID,
139 Key: "foo",
140 Value: "bar",
141 }
142 _, err = dbHandle.InsertEdgeJobMetadata(ctx, meta)
143 assert.NilError(t, err)
144
145 meta = model.EdgeJobMetadata{
146 EdgeJob: jobID,
147 Key: "boo",
148 Value: "hoo",
149 }
150 _, err = dbHandle.InsertEdgeJobMetadata(ctx, meta)
151 assert.NilError(t, err)
152
153 meta = model.EdgeJobMetadata{
154 EdgeJob: jobID,
155 Key: "care",
156 Value: "bear",
157 }
158 _, err = dbHandle.InsertEdgeJobMetadata(ctx, meta)
159 assert.NilError(t, err)
160
161 testCase := model.EdgeJobTest{
162 EdgeJob: jobID,
163 Name: "chill test",
164 Suite: "chill suite",
165 Time: 10,
166 Failed: true,
167 FailureText: "failed to keep it chill",
168 }
169 _, err = dbHandle.InsertEdgeJobTest(ctx, testCase)
170 assert.NilError(t, err)
171
172 testCase = model.EdgeJobTest{
173 EdgeJob: jobID,
174 Name: "unchill test",
175 Suite: "unchill suite",
176 Time: 30,
177 Failed: false,
178 FailureText: "successfully kept it unchill",
179 }
180 _, err = dbHandle.InsertEdgeJobTest(ctx, testCase)
181 assert.NilError(t, err)
182
183 testCase = model.EdgeJobTest{
184 EdgeJob: jobID,
185 Name: "test-a",
186 Suite: "suite a",
187 Time: 300,
188 Failed: true,
189 FailureText: "failed because reason: a",
190 }
191 _, err = dbHandle.InsertEdgeJobTest(ctx, testCase)
192 assert.NilError(t, err)
193
194 testCase = model.EdgeJobTest{
195 EdgeJob: jobID,
196 Name: "test-b",
197 Suite: "suite b",
198 Time: 600,
199 Failed: true,
200 FailureText: "failed because reason: b",
201 }
202 _, err = dbHandle.InsertEdgeJobTest(ctx, testCase)
203 assert.NilError(t, err)
204
205 testCase = model.EdgeJobTest{
206 EdgeJob: jobID,
207 Name: "test-c",
208 Suite: "suite c",
209 Time: 900,
210 Failed: true,
211 FailureText: "failed because reason: c",
212 }
213 _, err = dbHandle.InsertEdgeJobTest(ctx, testCase)
214 assert.NilError(t, err)
215
216 run, err := dbHandle.GetEdgeJob(ctx, "4568537872")
217 assert.NilError(t, err)
218
219 assert.Equal(t, run.Job.Number, "4568537872")
220 assert.Equal(t, len(run.Metadata), 3)
221 assert.Equal(t, len(run.Tests), 5)
222
223 assert.Equal(
224 t,
225 run.Job.GCPURL,
226 "https://console.cloud.google.com/storage/browser/edge-test-jobs/actions/edge-test/pre/4568537872/ci",
227 "job has incorrect gcp bucket link",
228 )
229
230 _, err = dbHandle.GetRecentEdgeJobRuns("edge-test", "pre", "ci")
231 assert.NilError(t, err)
232
233 return ctx
234 }).Test("get todays jobs", func(ctx f2.Context, t *testing.T) f2.Context {
235 pg := pg.FromContextT(ctx, t)
236 db := pg.DB()
237
238 dbHandle := &sql.DBHandle{DB: db}
239
240 tests, err := dbHandle.GetTodaysEdgeJobs()
241 assert.NilError(t, err)
242
243 assert.Equal(t, len(tests), 1)
244
245 return ctx
246 }).Test("insert duplicate data", func(ctx f2.Context, t *testing.T) f2.Context {
247 pg := pg.FromContextT(ctx, t)
248 db := pg.DB()
249
250 dbHandle := &sql.DBHandle{DB: db}
251
252
253 job := model.EdgeJob{
254 Number: "4568537872",
255 Repos: "edge-test",
256 Workflow: "pre",
257 Job: "ci",
258 Started: time.Now(),
259 TestsRun: 14,
260 TestsFailed: 14,
261 }
262 _, err := dbHandle.InsertEdgeJob(ctx, job)
263 assert.Error(t, err, "Value already exists in table")
264
265 return ctx
266 }).Test("cascade delete", func(ctx f2.Context, t *testing.T) f2.Context {
267 pg := pg.FromContextT(ctx, t)
268 db := pg.DB()
269
270
271 rows, err := db.QueryContext(ctx, selectCountJobs)
272 assert.NilError(t, err)
273
274 var count int
275 for rows.Next() {
276 err = rows.Scan(&count)
277 assert.NilError(t, err)
278 }
279 assert.Equal(t, count, 2)
280
281
282 rows, err = db.QueryContext(ctx, selectCountMetadata)
283 assert.NilError(t, err)
284
285 for rows.Next() {
286 err = rows.Scan(&count)
287 assert.NilError(t, err)
288 }
289 assert.Equal(t, count, 4)
290
291
292 rows, err = db.QueryContext(ctx, selectCountTests)
293 assert.NilError(t, err)
294
295 for rows.Next() {
296 err = rows.Scan(&count)
297 assert.NilError(t, err)
298 }
299 assert.Equal(t, count, 6)
300
301 rows, err = db.QueryContext(ctx, deleteJob, "4568537872")
302 assert.NilError(t, err)
303
304 var number string
305 for rows.Next() {
306 err = rows.Scan(&number)
307 assert.NilError(t, err)
308 }
309 assert.Equal(t, count, 6)
310
311 assert.Equal(t, number, "4568537872")
312
313
314 rows, err = db.QueryContext(ctx, selectCountJobs)
315 assert.NilError(t, err)
316
317 for rows.Next() {
318 err = rows.Scan(&count)
319 assert.NilError(t, err)
320 }
321 assert.Equal(t, count, 1)
322
323
324 rows, err = db.QueryContext(ctx, selectCountMetadata)
325 assert.NilError(t, err)
326
327 for rows.Next() {
328 err = rows.Scan(&count)
329 assert.NilError(t, err)
330 }
331 assert.Equal(t, count, 1)
332
333
334 rows, err = db.QueryContext(ctx, selectCountTests)
335 assert.NilError(t, err)
336
337 for rows.Next() {
338 err = rows.Scan(&count)
339 assert.NilError(t, err)
340 }
341 assert.Equal(t, count, 1)
342
343 return ctx
344 }).Feature()
345
346 f.Test(t, feat)
347 }
348
View as plain text