Moar tests

Signed-off-by: Danny Kopping <danny@coder.com>
coder · dannykopping · Aug 21, 2024 · Aug 7, 2024 · Aug 13, 2024 · Aug 13, 2024
commit 73bac3f4f020432f38a158ca81d9b593aa1844ad
diff --git a/...s/000244_provisioner_job_timings.down.sql → ...s/000245_provisioner_job_timings.down.sql b/...s/000244_provisioner_job_timings.down.sql → ...s/000245_provisioner_job_timings.down.sql
diff --git a/...ons/000244_provisioner_job_timings.up.sql → ...ons/000245_provisioner_job_timings.up.sql b/...ons/000244_provisioner_job_timings.up.sql → ...ons/000245_provisioner_job_timings.up.sql
diff --git a/provisioner/terraform/testdata/timings-aggregation/fake-terraform.sh b/provisioner/terraform/testdata/timings-aggregation/fake-terraform.sh
diff --git a/provisioner/terraform/testutil.go b/provisioner/terraform/testutil.go
@@ -0,0 +1,140 @@
+package terraform
+
+import (
+	"bufio"
+	"bytes"
+	"slices"
+	"testing"
+
+	"github.com/cespare/xxhash"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/encoding/protojson"
+	protobuf "google.golang.org/protobuf/proto"
+
+	"github.com/coder/coder/v2/provisionersdk/proto"
+)
+
+func ParseTimingLines(t *testing.T, input []byte) []*proto.Timing {
+	t.Helper()
+
+	// Parse the input into *proto.Timing structs.
+	var expected []*proto.Timing
+	scanner := bufio.NewScanner(bytes.NewBuffer(input))
+	for scanner.Scan() {
+		line := scanner.Bytes()
+
+		var msg proto.Timing
+		require.NoError(t, protojson.Unmarshal(line, &msg))
+
+		expected = append(expected, &msg)
+	}
+	require.NoError(t, scanner.Err())
+	StableSortTimings(t, expected) // To reduce flakiness.
+
+	return expected
+}
+
+func TimingsAreEqual(t *testing.T, expected []*proto.Timing, actual []*proto.Timing) bool {
+	t.Helper()
+
+	// Shortcut check.
+	if len(expected)+len(actual) == 0 {
+		t.Logf("both timings are empty")
+		return true
+	}
+
+	// Shortcut check.
+	if len(expected) != len(actual) {
+		t.Logf("timings lengths are not equal: %d != %d", len(expected), len(actual))
+		return false
+	}
+
+	// Compare each element; both are expected to be sorted in a stable manner.
+	for i := 0; i < len(expected); i++ {
+		ex := expected[i]
+		ac := actual[i]
+		if !protobuf.Equal(ex, ac) {
+			t.Logf("timings are not equivalent: %q != %q", ex.String(), ac.String())
+			return false
+		}
+	}
+
+	return true
+}
+
+func IngestAllSpans(t *testing.T, input []byte, aggregator *timingAggregator) {
+	t.Helper()
+
+	scanner := bufio.NewScanner(bytes.NewBuffer(input))
+	for scanner.Scan() {
+		line := scanner.Bytes()
+		log := parseTerraformLogLine(line)
+		if log == nil {
+			continue
+		}
+
+		ts, span, err := extractTimingSpan(log)
+		if err != nil {
+			// t.Logf("%s: failed span extraction on line: %q", err, line)
+			continue
+		}
+
+		require.NotZerof(t, ts, "failed on line: %q", line)
+		require.NotNilf(t, span, "failed on line: %q", line)
+
+		aggregator.ingest(ts, span)
+	}
+
+	require.NoError(t, scanner.Err())
+}
+
+func PrintTiming(t *testing.T, timing *proto.Timing) {
+	t.Helper()
+
+	marshaler := protojson.MarshalOptions{
+		Multiline: false, // Ensure it's set to false for single-line JSON
+		Indent:    "",    // No indentation
+	}
+
+	out, err := marshaler.Marshal(timing)
+	assert.NoError(t, err)
+	t.Logf("%s", out)
+}
+
+func StableSortTimings(t *testing.T, timings []*proto.Timing) {
+	t.Helper()
+
+	slices.SortStableFunc(timings, func(a, b *proto.Timing) int {
+		if a == nil || b == nil || a.Start == nil || b.Start == nil {
+			return 0
+		}
+
+		if a.Start.AsTime().Equal(b.Start.AsTime()) {
+			// Special case: when start times are equal, we need to keep the ordering stable, so we hash both entries
+			// and sort based on that (since end times could be equal too, in principle).
+			ah := xxhash.Sum64String(a.String())
+			bh := xxhash.Sum64String(b.String())
+
+			if ah == bh {
+				// WTF.
+				t.Logf("identical timings detected!")
+				PrintTiming(t, a)
+				PrintTiming(t, b)
+				return 0
+			}
+
+			if ah < bh {
+				return -1
+			}
+
+			return 1
+		}
+
+		if a.Start.AsTime().Before(b.Start.AsTime()) {
+			return -1
+		}
+
+		return 1
+	})
+}
diff --git a/provisioner/terraform/timings_internal_test.go b/provisioner/terraform/timings_internal_test.go
@@ -1,18 +1,12 @@
 package terraform
 
 import (
-	"bufio"
-	"bytes"
 	_ "embed"
-	"slices"
 	"testing"
 
-	"github.com/cespare/xxhash"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/tools/txtar"
-	"google.golang.org/protobuf/encoding/protojson"
-	protobuf "google.golang.org/protobuf/proto"
 
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/provisionersdk/proto"
@@ -79,138 +73,24 @@ func TestAggregation(t *testing.T) {
 					file.Name, database.AllProvisionerJobTimingStageValues())
 
 				agg := newTimingAggregator(stage)
-				extractAllSpans(t, file.Data, agg)
+				IngestAllSpans(t, file.Data, agg)
 				actualTimings = append(actualTimings, agg.aggregate()...)
 			}
 
-			stableSortTimings(t, actualTimings) // To reduce flakiness.
-			require.True(t, timingsAreEqual(t, expectedTimings.Data, actualTimings))
+			expected := ParseTimingLines(t, expectedTimings.Data)
+			StableSortTimings(t, actualTimings) // To reduce flakiness.
+			if !assert.True(t, TimingsAreEqual(t, expected, actualTimings)) {
+				printExpectation(t, expected)
+			}
 		})
 	}
 }
 
-func timingsAreEqual(t *testing.T, input []byte, actual []*proto.Timing) bool {
-	t.Helper()
-
-	// Parse the input into *proto.Timing structs.
-	var expected []*proto.Timing
-	scanner := bufio.NewScanner(bytes.NewBuffer(input))
-	for scanner.Scan() {
-		line := scanner.Bytes()
-
-		var msg proto.Timing
-		require.NoError(t, protojson.Unmarshal(line, &msg))
-
-		expected = append(expected, &msg)
-	}
-	require.NoError(t, scanner.Err())
-
-	// Shortcut check.
-	if len(expected)+len(actual) == 0 {
-		t.Logf("both timings are empty")
-		return true
-	}
-
-	// Shortcut check.
-	if len(expected) != len(actual) {
-		t.Logf("timings lengths are not equal: %d != %d", len(expected), len(actual))
-		printExpectation(t, actual)
-		return false
-	}
-
-	// Compare each element; both are expected to be sorted in a stable manner.
-	for i := 0; i < len(expected); i++ {
-		ex := expected[i]
-		ac := actual[i]
-		if !protobuf.Equal(ex, ac) {
-			t.Logf("timings are not equivalent: %q != %q", ex.String(), ac.String())
-			printExpectation(t, actual)
-			return false
-		}
-	}
-
-	return true
-}
-
-func extractAllSpans(t *testing.T, input []byte, aggregator *timingAggregator) {
-	t.Helper()
-
-	scanner := bufio.NewScanner(bytes.NewBuffer(input))
-	for scanner.Scan() {
-		line := scanner.Bytes()
-		log := parseTerraformLogLine(line)
-		if log == nil {
-			continue
-		}
-
-		ts, span, err := extractTimingSpan(log)
-		if err != nil {
-			// t.Logf("%s: failed span extraction on line: %q", err, line)
-			continue
-		}
-
-		require.NotZerof(t, ts, "failed on line: %q", line)
-		require.NotNilf(t, span, "failed on line: %q", line)
-
-		aggregator.ingest(ts, span)
-	}
-
-	require.NoError(t, scanner.Err())
-}
-
 func printExpectation(t *testing.T, actual []*proto.Timing) {
 	t.Helper()
 
 	t.Log("expected:")
 	for _, a := range actual {
-		printTiming(t, a)
-	}
-}
-
-func printTiming(t *testing.T, timing *proto.Timing) {
-	t.Helper()
-
-	marshaler := protojson.MarshalOptions{
-		Multiline: false, // Ensure it's set to false for single-line JSON
-		Indent:    "",    // No indentation
+		PrintTiming(t, a)
 	}
-
-	out, err := marshaler.Marshal(timing)
-	assert.NoError(t, err)
-	t.Logf("%s", out)
-}
-
-func stableSortTimings(t *testing.T, timings []*proto.Timing) {
-	slices.SortStableFunc(timings, func(a, b *proto.Timing) int {
-		if a == nil || b == nil || a.Start == nil || b.Start == nil {
-			return 0
-		}
-
-		if a.Start.AsTime().Equal(b.Start.AsTime()) {
-			// Special case: when start times are equal, we need to keep the ordering stable, so we hash both entries
-			// and sort based on that (since end times could be equal too, in principle).
-			ah := xxhash.Sum64String(a.String())
-			bh := xxhash.Sum64String(b.String())
-
-			if ah == bh {
-				// WTF.
-				t.Logf("identical timings detected!")
-				printTiming(t, a)
-				printTiming(t, b)
-				return 0
-			}
-
-			if ah < bh {
-				return -1
-			}
-
-			return 1
-		}
-
-		if a.Start.AsTime().Before(b.Start.AsTime()) {
-			return -1
-		}
-
-		return 1
-	})
 }