Skip to content

Commit f1c42a4

Browse files
lukaszcllukaszcl
committed
Fix other tests
1 parent 6b98721 commit f1c42a4

File tree

7 files changed

+18040
-18040
lines changed

7 files changed

+18040
-18040
lines changed

‎tools/flakeguard/reports/data_test.go‎

Lines changed: 87 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -379,8 +379,24 @@ func TestAggregate(t *testing.T) {
379379
},
380380
}
381381

382-
aggregateOptions := &reportOptions{reportID: "123"}
383-
aggregatedReport, err := aggregateReports(aggregateOptions, report1, report2)
382+
// Create channels for test results and errors.
383+
resultsChan := make(chan []TestResult)
384+
errChan := make(chan error)
385+
386+
// Launch a goroutine to send the test results into the results channel.
387+
go func() {
388+
resultsChan <- report1.Results
389+
resultsChan <- report2.Results
390+
close(resultsChan)
391+
}()
392+
393+
// No errors to send; close the error channel.
394+
go func() {
395+
close(errChan)
396+
}()
397+
398+
// Call the updated aggregate function.
399+
aggregatedResults, err := aggregate(resultsChan, errChan)
384400
if err != nil {
385401
t.Fatalf("Error aggregating reports: %v", err)
386402
}
@@ -412,15 +428,16 @@ func TestAggregate(t *testing.T) {
412428
},
413429
}
414430

415-
// Sort results for comparison
431+
// Sort both slices by TestName to ensure the order matches for comparison.
416432
sort.Slice(expectedResults, func(i, j int) bool {
417433
return expectedResults[i].TestName < expectedResults[j].TestName
418434
})
419-
sort.Slice(aggregatedReport.Results, func(i, j int) bool {
420-
return aggregatedReport.Results[i].TestName < aggregatedReport.Results[j].TestName
435+
sort.Slice(aggregatedResults, func(i, j int) bool {
436+
return aggregatedResults[i].TestName < aggregatedResults[j].TestName
421437
})
422438

423-
for i, result := range aggregatedReport.Results {
439+
// Compare the aggregated results with expected results.
440+
for i, result := range aggregatedResults {
424441
expected := expectedResults[i]
425442
if result.TestName != expected.TestName ||
426443
result.TestPackage != expected.TestPackage ||
@@ -468,25 +485,37 @@ func TestAggregateOutputs(t *testing.T) {
468485
},
469486
}
470487

471-
aggregateOptions := &reportOptions{reportID: "123"}
472-
aggregatedReport, err := aggregateReports(aggregateOptions, report1, report2)
488+
// Create channels for results and errors.
489+
resultsChan := make(chan []TestResult)
490+
errChan := make(chan error)
491+
492+
// Launch a goroutine to send the results into the resultsChan.
493+
go func() {
494+
resultsChan <- report1.Results
495+
resultsChan <- report2.Results
496+
close(resultsChan)
497+
}()
498+
499+
// Launch a goroutine to close the error channel (no errors to report).
500+
go func() {
501+
close(errChan)
502+
}()
503+
504+
// Call the new aggregate function.
505+
aggregatedResults, err := aggregate(resultsChan, errChan)
473506
if err != nil {
474507
t.Fatalf("Error aggregating reports: %v", err)
475508
}
476509

477-
if len(aggregatedReport.Results) != 1 {
478-
t.Fatalf("Expected 1 result, got %d", len(aggregatedReport.Results))
510+
if len(aggregatedResults) != 1 {
511+
t.Fatalf("Expected 1 result, got %d", len(aggregatedResults))
479512
}
480513

481-
result := aggregatedReport.Results[0]
514+
result := aggregatedResults[0]
482515

483516
expectedOutputs := map[string][]string{
484-
"run1": {
485-
"Output from report1 test run",
486-
},
487-
"run2": {
488-
"Output from report2 test run",
489-
},
517+
"run1": {"Output from report1 test run"},
518+
"run2": {"Output from report2 test run"},
490519
}
491520

492521
expectedPackageOutputs := []string{
@@ -538,17 +567,32 @@ func TestAggregateIdenticalOutputs(t *testing.T) {
538567
},
539568
}
540569

541-
aggregateOptions := &reportOptions{reportID: "123"}
542-
aggregatedReport, err := aggregateReports(aggregateOptions, report1, report2)
570+
// Create channels for results and errors.
571+
resultsChan := make(chan []TestResult)
572+
errChan := make(chan error)
573+
574+
// Send the results from both reports.
575+
go func() {
576+
resultsChan <- report1.Results
577+
resultsChan <- report2.Results
578+
close(resultsChan)
579+
}()
580+
581+
// Close error channel since there are no errors.
582+
go func() {
583+
close(errChan)
584+
}()
585+
586+
aggregatedResults, err := aggregate(resultsChan, errChan)
543587
if err != nil {
544588
t.Fatalf("Error aggregating reports: %v", err)
545589
}
546590

547-
if len(aggregatedReport.Results) != 1 {
548-
t.Fatalf("Expected 1 result, got %d", len(aggregatedReport.Results))
591+
if len(aggregatedResults) != 1 {
592+
t.Fatalf("Expected 1 result, got %d", len(aggregatedResults))
549593
}
550594

551-
result := aggregatedReport.Results[0]
595+
result := aggregatedResults[0]
552596

553597
expectedOutputs := map[string][]string{
554598
"run1": {"Identical output", "Identical output"},
@@ -600,7 +644,7 @@ func TestAggregate_AllSkippedTests(t *testing.T) {
600644
Skipped: true,
601645
Runs: 0,
602646
Skips: 3,
603-
PassRatio: -1, // 1 indicate undefined
647+
PassRatio: -1, // -1 indicates undefined
604648
},
605649
},
606650
}
@@ -620,8 +664,23 @@ func TestAggregate_AllSkippedTests(t *testing.T) {
620664
},
621665
}
622666

623-
aggregateOptions := &reportOptions{reportID: "123"}
624-
aggregatedReport, err := aggregateReports(aggregateOptions, report1, report2)
667+
// Create channels for results and errors.
668+
resultsChan := make(chan []TestResult)
669+
errChan := make(chan error)
670+
671+
// Send results from both reports.
672+
go func() {
673+
resultsChan <- report1.Results
674+
resultsChan <- report2.Results
675+
close(resultsChan)
676+
}()
677+
678+
// Close error channel since there are no errors.
679+
go func() {
680+
close(errChan)
681+
}()
682+
683+
aggregatedResults, err := aggregate(resultsChan, errChan)
625684
if err != nil {
626685
t.Fatalf("Error aggregating reports: %v", err)
627686
}
@@ -635,11 +694,11 @@ func TestAggregate_AllSkippedTests(t *testing.T) {
635694
PassRatio: -1,
636695
}
637696

638-
if len(aggregatedReport.Results) != 1 {
639-
t.Fatalf("Expected 1 result, got %d", len(aggregatedReport.Results))
697+
if len(aggregatedResults) != 1 {
698+
t.Fatalf("Expected 1 result, got %d", len(aggregatedResults))
640699
}
641700

642-
result := aggregatedReport.Results[0]
701+
result := aggregatedResults[0]
643702

644703
if result.TestName != expectedResult.TestName {
645704
t.Errorf("Expected TestName %v, got %v", expectedResult.TestName, result.TestName)

‎tools/flakeguard/reports/io_test.go‎

Lines changed: 13 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -66,10 +66,13 @@ func TestAggregateResultFilesSplunk(t *testing.T) {
6666
}))
6767
t.Cleanup(srv.Close)
6868

69-
report, err := LoadAndAggregate("./testdata", WithReportID(reportID))
69+
results, err := LoadAndAggregate("./testdata")
7070
require.NoError(t, err, "LoadAndAggregate failed")
7171

72-
err = SendTestReportToSplunk(srv.URL, splunkToken, splunkEvent, *report)
72+
report, err := NewTestReport(results, WithReportID(reportID))
73+
require.NoError(t, err, "NewTestReport failed")
74+
75+
err = SendTestReportToSplunk(srv.URL, splunkToken, splunkEvent, report)
7376
require.NoError(t, err, "SendReportToSplunk failed")
7477
verifyAggregatedReport(t, report)
7578
assert.Equal(t, 1, reportRequestsReceived, "unexpected number of report requests")
@@ -79,12 +82,16 @@ func TestAggregateResultFilesSplunk(t *testing.T) {
7982
func TestAggregateResultFiles(t *testing.T) {
8083
t.Parallel()
8184

82-
report, err := LoadAndAggregate("./testdata", WithReportID(reportID))
85+
results, err := LoadAndAggregate("./testdata")
8386
require.NoError(t, err, "LoadAndAggregate failed")
87+
88+
report, err := NewTestReport(results, WithReportID(reportID))
89+
require.NoError(t, err, "NewTestReport failed")
90+
8491
verifyAggregatedReport(t, report)
8592
}
8693

87-
func verifyAggregatedReport(t *testing.T, report *TestReport) {
94+
func verifyAggregatedReport(t *testing.T, report TestReport) {
8895
require.NotNil(t, report, "report is nil")
8996
require.Equal(t, reportID, report.ID, "report ID mismatch")
9097
require.Equal(t, uniqueTests, len(report.Results), "report results count mismatch")
@@ -142,7 +149,7 @@ func verifyAggregatedReport(t *testing.T, report *TestReport) {
142149
func BenchmarkAggregateResultFiles(b *testing.B) {
143150
zerolog.SetGlobalLevel(zerolog.Disabled)
144151
for i := 0; i < b.N; i++ {
145-
_, err := LoadAndAggregate("./testdata", WithReportID(reportID))
152+
_, err := LoadAndAggregate("./testdata")
146153
require.NoError(b, err, "LoadAndAggregate failed")
147154
}
148155
}
@@ -156,7 +163,7 @@ func BenchmarkAggregateResultFilesSplunk(b *testing.B) {
156163

157164
b.ResetTimer()
158165
for i := 0; i < b.N; i++ {
159-
_, err := LoadAndAggregate("./testdata", WithReportID(reportID))
166+
_, err := LoadAndAggregate("./testdata")
160167
require.NoError(b, err, "LoadAndAggregate failed")
161168
}
162169
}

‎tools/flakeguard/reports/presentation_test.go‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ import (
1010
)
1111

1212
func TestGenerateFlakyTestsTable(t *testing.T) {
13-
report := &TestReport{
13+
report := TestReport{
1414
Results: []TestResult{
1515
{
1616
TestName: "TestFlaky",
@@ -70,7 +70,7 @@ func TestGenerateFlakyTestsTable(t *testing.T) {
7070

7171
func TestGenerateGitHubSummaryMarkdown(t *testing.T) {
7272
maxPassRatio := 0.9
73-
testReport := &TestReport{
73+
testReport := TestReport{
7474
GoProject: "ProjectX",
7575
SummaryData: &SummaryData{UniqueTestsRun: 2, FlakyTests: 1},
7676
RaceDetection: true,
@@ -116,7 +116,7 @@ func TestGenerateGitHubSummaryMarkdown(t *testing.T) {
116116
// TestGeneratePRCommentMarkdown tests the GeneratePRCommentMarkdown function.
117117
func TestGeneratePRCommentMarkdown(t *testing.T) {
118118
maxPassRatio := 0.9
119-
testReport := &TestReport{
119+
testReport := TestReport{
120120
GoProject: "ProjectX",
121121
SummaryData: &SummaryData{UniqueTestsRun: 3, FlakyTests: 1},
122122
RaceDetection: true,
@@ -194,13 +194,13 @@ func TestPrintTable(t *testing.T) {
194194
func TestRenderResults(t *testing.T) {
195195
testcases := []struct {
196196
name string
197-
testReport *TestReport
197+
testReport TestReport
198198
expectedSummary *SummaryData
199199
expectedStringsContain []string
200200
}{
201201
{
202202
name: "single flaky test",
203-
testReport: &TestReport{
203+
testReport: TestReport{
204204
Results: []TestResult{
205205
{
206206
TestName: "Test1",

‎tools/flakeguard/reports/test_report.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -280,7 +280,7 @@ func (tr *TestReport) PrintGotestsumOutput(w io.Writer, format string) error {
280280
}
281281

282282
fmt.Fprint(w, outBuf.String())
283-
fmt.Fprintln(w, "\n------------------------------------------\n")
283+
fmt.Fprint(w, "\n------------------------------------------\n\n")
284284
}
285285
return nil
286286
}

0 commit comments

Comments
 (0)