test: add tests for genconfig, queryplan, round; raise coverage to 50%

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ethanyzhang

.github/workflows/ci.yml

@@ -55,7 +55,7 @@ jobs:
         run: |
           COVERAGE=$(go tool cover -func=coverage.out | grep total | awk '{print $3}' | sed 's/%//')
           echo "Total coverage: ${COVERAGE}%"
-          THRESHOLD=35
+          THRESHOLD=50
           if (( $(echo "$COVERAGE < $THRESHOLD" | bc -l) )); then
             echo "Coverage ${COVERAGE}% is below threshold ${THRESHOLD}%"
             exit 1

cmd/genconfig/main_test.go

@@ -0,0 +1,155 @@
+package genconfig
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestGeneratedConfigsMatch runs genconfig with the real clusters directory
+// and verifies the output matches the checked-in golden files.
+func TestGeneratedConfigsMatch(t *testing.T) {
+	clustersDir, err := filepath.Abs("../../clusters")
+	require.NoError(t, err)
+
+	// Snapshot all non-config.json files in cluster subdirectories.
+	golden := snapshotClusters(t, clustersDir)
+	require.NotEmpty(t, golden, "no golden files found in clusters/")
+
+	// Configure and run genconfig.
+	TemplatePath = filepath.Join(clustersDir, "templates")
+	ParameterPath = filepath.Join(clustersDir, "params.json")
+	Run(nil, []string{clustersDir})
+
+	// Compare regenerated files against golden snapshots.
+	for relPath, expected := range golden {
+		actual, readErr := os.ReadFile(filepath.Join(clustersDir, relPath))
+		require.NoError(t, readErr, "failed to read regenerated file %s", relPath)
+		assert.Equal(t, string(expected), string(actual),
+			"generated output differs from checked-in golden file: %s", relPath)
+	}
+
+	// Check no unexpected extra files were produced.
+	regenerated := snapshotClusters(t, clustersDir)
+	for relPath := range regenerated {
+		assert.Contains(t, golden, relPath,
+			"regeneration produced unexpected file: %s", relPath)
+	}
+}
+
+func TestCalculate(t *testing.T) {
+	cfg := &ClusterConfig{
+		Name:                "test",
+		MemoryPerNodeGb:     62,
+		NumberOfWorkers:     4,
+		VCPUPerWorker:       8,
+		GeneratorParameters: DefaultGeneratorParameters,
+	}
+	cfg.Calculate()
+
+	assert.True(t, cfg.ContainerMemoryGb > 0, "ContainerMemoryGb should be positive")
+	assert.True(t, cfg.HeapSizeGb > 0, "HeapSizeGb should be positive")
+	assert.True(t, cfg.HeapSizeGb < cfg.ContainerMemoryGb, "HeapSizeGb should be less than ContainerMemoryGb")
+	assert.True(t, cfg.JavaQueryMaxTotalMemPerNodeGb > 0)
+	assert.True(t, cfg.JavaQueryMaxMemPerNodeGb > 0)
+	assert.True(t, cfg.NativeSystemMemGb > 0)
+	assert.True(t, cfg.NativeQueryMemGb > 0)
+	assert.True(t, cfg.JoinMaxBroadcastTableSizeMb > 0)
+}
+
+// snapshotClusters reads all generated files (non-config.json) in cluster
+// subdirectories and returns a map of relative path -> contents.
+func snapshotClusters(t *testing.T, clustersDir string) map[string][]byte {
+	t.Helper()
+	files := make(map[string][]byte)
+
+	entries, err := os.ReadDir(clustersDir)
+	require.NoError(t, err)
+
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		// Skip non-cluster directories (templates, shared, catalog).
+		subDir := filepath.Join(clustersDir, entry.Name())
+		if !hasConfigJson(subDir) {
+			continue
+		}
+
+		err := filepath.Walk(subDir, func(path string, info os.FileInfo, walkErr error) error {
+			if walkErr != nil {
+				return walkErr
+			}
+			if info.IsDir() || info.Name() == "config.json" {
+				return nil
+			}
+			rel, relErr := filepath.Rel(clustersDir, path)
+			if relErr != nil {
+				return relErr
+			}
+			data, readErr := os.ReadFile(path)
+			if readErr != nil {
+				return readErr
+			}
+			files[rel] = data
+			return nil
+		})
+		require.NoError(t, err)
+	}
+	return files
+}
+
+func hasConfigJson(dir string) bool {
+	_, err := os.Stat(filepath.Join(dir, "config.json"))
+	return err == nil
+}
+
+func TestPrintDefaultParams(t *testing.T) {
+	// Capture stdout by redirecting it to a pipe.
+	oldStdout := os.Stdout
+	r, w, err := os.Pipe()
+	require.NoError(t, err)
+	os.Stdout = w
+
+	PrintDefaultParams(nil, nil)
+
+	w.Close()
+	os.Stdout = oldStdout
+	out, err := io.ReadAll(r)
+	require.NoError(t, err)
+
+	assert.Contains(t, string(out), "sys_reserved_mem_cap_gb")
+}
+
+func TestRunWithBuiltinTemplates(t *testing.T) {
+	tmpDir := t.TempDir()
+	clusterDir := filepath.Join(tmpDir, "test-cluster")
+	require.NoError(t, os.MkdirAll(clusterDir, 0755))
+
+	// Write a minimal config.json.
+	configJSON := `{
+		"cluster_size": "test",
+		"worker_instance_type": "r6i.xlarge",
+		"number_of_workers": 2,
+		"memory_per_node_gb": 30,
+		"vcpu_per_worker": 4,
+		"fragment_result_cache_enabled": false,
+		"data_cache_enabled": false
+	}`
+	require.NoError(t, os.WriteFile(filepath.Join(clusterDir, "config.json"), []byte(configJSON), 0644))
+
+	// Run with builtin templates (no -t flag).
+	TemplatePath = ""
+	ParameterPath = ""
+	Run(nil, []string{tmpDir})
+
+	// Verify some output was generated.
+	entries, err := os.ReadDir(clusterDir)
+	require.NoError(t, err)
+	// Should have config.json + generated files.
+	assert.Greater(t, len(entries), 1, "expected generated files in output directory")
+}

cmd/genddl/main_test.go

@@ -68,3 +68,155 @@ func snapshotDir(t *testing.T, dir string) map[string][]byte {
 	require.NoError(t, err)
 	return files
 }
+
+func TestIntScaleFactor(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected int
+	}{
+		{"1", 1},
+		{"10", 10},
+		{"1000", 1000},
+		{"1k", 1000},
+		{"10k", 10000},
+		{"abc", 0},
+		{"k", 0},
+	}
+	for _, tc := range tests {
+		s := &Schema{ScaleFactor: tc.input}
+		assert.Equal(t, tc.expected, s.intScaleFactor(), "intScaleFactor(%q)", tc.input)
+	}
+}
+
+func TestLoadSchemas(t *testing.T) {
+	data := []byte(`{"scale_factor":"10","file_format":"parquet","compression_method":"uncompressed"}`)
+	schemas, err := loadSchemas(data)
+	require.NoError(t, err)
+	require.Len(t, schemas, 4, "should produce 4 schema variants")
+
+	// Verify the 4 combinations.
+	assert.True(t, schemas[0].Iceberg && !schemas[0].Partitioned)
+	assert.True(t, schemas[1].Iceberg && schemas[1].Partitioned)
+	assert.True(t, !schemas[2].Iceberg && !schemas[2].Partitioned)
+	assert.True(t, !schemas[3].Iceberg && schemas[3].Partitioned)
+
+	// Each schema should have independent maps.
+	schemas[0].Tables["foo"] = &Table{Name: "foo"}
+	assert.Empty(t, schemas[1].Tables, "schema variants should not share Tables map")
+}
+
+func TestLoadSchemasDefaults(t *testing.T) {
+	data := []byte(`{"scale_factor":"1","file_format":"orc","compression_method":"zstd"}`)
+	schemas, err := loadSchemas(data)
+	require.NoError(t, err)
+
+	// Verify defaults are applied.
+	assert.Equal(t, "tpcds", schemas[0].Workload)
+	assert.Equal(t, "tpc-ds", schemas[0].WorkloadDefinition)
+
+	// Verify zstd compression session vars.
+	assert.Equal(t, "ZSTD", schemas[0].SessionVariables["iceberg.compression_codec"])
+	assert.Equal(t, "ZSTD", schemas[3].SessionVariables["hive.compression_codec"])
+}
+
+func TestGetNamedOutput(t *testing.T) {
+	tests := []struct {
+		name     string
+		data     string
+		workload string
+		expected string
+	}{
+		{
+			"uncompressed",
+			`{"scale_factor":"10","file_format":"parquet","compression_method":"uncompressed"}`,
+			"tpcds",
+			"tpcds-sf10-parquet",
+		},
+		{
+			"zstd",
+			`{"scale_factor":"100","file_format":"orc","compression_method":"zstd"}`,
+			"tpch",
+			"tpch-sf100-orc-zstd",
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := getNamedOutput([]byte(tc.data), tc.workload)
+			require.NoError(t, err)
+			assert.Equal(t, tc.expected, result)
+		})
+	}
+}
+
+func TestCleanOutputDir(t *testing.T) {
+	dir := t.TempDir()
+
+	// Create some files.
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "a.sql"), []byte("test"), 0644))
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "b.sh"), []byte("test"), 0644))
+
+	// Create a subdirectory (should not be deleted).
+	require.NoError(t, os.MkdirAll(filepath.Join(dir, "subdir"), 0755))
+
+	err := cleanOutputDir(dir)
+	require.NoError(t, err)
+
+	entries, err := os.ReadDir(dir)
+	require.NoError(t, err)
+	assert.Len(t, entries, 1, "only subdirectory should remain")
+	assert.Equal(t, "subdir", entries[0].Name())
+}
+
+func TestCleanOutputDirNonExistent(t *testing.T) {
+	err := cleanOutputDir("/nonexistent/path")
+	assert.NoError(t, err, "should return nil for non-existent directory")
+}
+
+func TestIsPartitioned(t *testing.T) {
+	// Table with explicit PartitionedMinScale.
+	tbl := &Table{PartitionedMinScale: 100}
+	assert.False(t, tbl.isPartitioned(10))
+	assert.True(t, tbl.isPartitioned(100))
+	assert.True(t, tbl.isPartitioned(1000))
+
+	// Table without PartitionedMinScale uses Partitioned field.
+	tbl2 := &Table{Partitioned: true}
+	assert.True(t, tbl2.isPartitioned(1))
+
+	tbl3 := &Table{Partitioned: false}
+	assert.False(t, tbl3.isPartitioned(1))
+}
+
+func TestInitIsVarchar(t *testing.T) {
+	varcharType := "VARCHAR(100)"
+	intType := "INT"
+
+	tbl := &Table{
+		Columns: []*Column{
+			{Name: "a", Type: &varcharType},
+			{Name: "b", Type: &intType},
+			{Name: "c", Type: nil},
+		},
+	}
+	tbl.initIsVarchar()
+
+	assert.True(t, tbl.Columns[0].IsVarchar)
+	assert.False(t, tbl.Columns[1].IsVarchar)
+	assert.False(t, tbl.Columns[2].IsVarchar)
+}
+
+func TestSetNames(t *testing.T) {
+	s := &Schema{
+		ScaleFactor:       "100",
+		FileFormat:        "parquet",
+		CompressionMethod: "zstd",
+		Workload:          "tpcds",
+		Iceberg:           true,
+		Partitioned:       true,
+	}
+	s.setNames()
+
+	assert.Equal(t, "tpcds_sf100_parquet_partitioned_iceberg_zstd", s.SchemaName)
+	assert.Equal(t, "tpcds-sf100-parquet-partitioned-iceberg-zstd", s.LocationName)
+	assert.Equal(t, "tpcds_sf100_parquet_partitioned_iceberg", s.UncompressedName)
+}