test(librariangen): add codecov and improve main.go coverage (#3936)

Refactors the main function to be more testable by extracting the logic into a `runCLI` function.

The logging setup is also extracted into a `parseLogLevel` function to allow for easier testing.

This change increases the test coverage of main.go from 65.5% to 96.9%.

Author: meltsufin

.github/workflows/downstream.yaml

@@ -9,6 +9,7 @@ on:
       - library_generation/**
       - showcase/**
       - test/**
+      - internal/librariangen/**
 
 name: Downstream Check
 jobs:

.github/workflows/librariangen-ci.yml

@@ -27,6 +27,13 @@ jobs:
         run: go version
 
       - name: Run Go tests
-        run: go test ./...
+        run: go test -v -coverprofile=coverage.txt -covermode=atomic ./...
         working-directory: internal/librariangen
 
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.txt
+          working-directory: internal/librariangen
+          flags: librariangen

internal/librariangen/main.go

@@ -27,22 +27,32 @@ const version = "0.1.0"
 
 // main is the entrypoint for the librariangen CLI.
 func main() {
-	logLevel := slog.LevelInfo
-	switch os.Getenv("GOOGLE_SDK_JAVA_LOGGING_LEVEL") {
-	case "debug":
-		logLevel = slog.LevelDebug
-	case "quiet":
-		logLevel = slog.LevelError + 1
-	}
+	os.Exit(runCLI(os.Args))
+}
+
+func runCLI(args []string) int {
+	logLevel := parseLogLevel(os.Getenv("GOOGLE_SDK_JAVA_LOGGING_LEVEL"))
 	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
 		Level: logLevel,
 	})))
-	slog.Info("librariangen: invoked", "args", os.Args)
-	if err := run(context.Background(), os.Args[1:]); err != nil {
+	slog.Info("librariangen: invoked", "args", args)
+	if err := run(context.Background(), args[1:]); err != nil {
 		slog.Error("librariangen: failed", "error", err)
-		os.Exit(1)
+		return 1
 	}
 	slog.Info("librariangen: finished successfully")
+	return 0
+}
+
+func parseLogLevel(logLevelEnv string) slog.Level {
+	switch logLevelEnv {
+	case "debug":
+		return slog.LevelDebug
+	case "quiet":
+		return slog.LevelError + 1
+	default:
+		return slog.LevelInfo
+	}
 }
 
 // run executes the appropriate command based on the CLI's invocation arguments.

internal/librariangen/main_test.go

@@ -16,6 +16,7 @@ package main
 
 import (
 	"context"
+	"log/slog"
 	"testing"
 )
 
@@ -91,4 +92,50 @@ func TestRun(t *testing.T) {
 			}
 		})
 	}
+}
+
+func TestRunCLI(t *testing.T) {
+	tests := []struct {
+		name     string
+		args     []string
+		wantCode int
+	}{
+		{
+			name:     "success",
+			args:     []string{"librariangen", "build"},
+			wantCode: 0,
+		},
+		{
+			name:     "failure",
+			args:     []string{"librariangen", "foo"},
+			wantCode: 1,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotCode := runCLI(tt.args); gotCode != tt.wantCode {
+				t.Errorf("runCLI() = %v, want %v", gotCode, tt.wantCode)
+			}
+		})
+	}
+}
+
+func TestParseLogLevel(t *testing.T) {
+	tests := []struct {
+		name  string
+		level string
+		want  slog.Level
+	}{
+		{"default", "", slog.LevelInfo},
+		{"debug", "debug", slog.LevelDebug},
+		{"quiet", "quiet", slog.LevelError + 1},
+		{"invalid", "foo", slog.LevelInfo},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := parseLogLevel(tt.level); got != tt.want {
+				t.Errorf("parseLogLevel() = %v, want %v", got, tt.want)
+			}
+		})
+	}
 }