Go Development Tools

rtk go test [packages] [flags]

// Force JSON output
cmd.arg("test");
if !args.iter().any(|a| a == "-json") {
    cmd.arg("-json");
}

// Parse NDJSON line-by-line
#[derive(Deserialize)]
struct GoTestEvent {
    #[serde(rename = "Time")]
    time: Option<String>,
    #[serde(rename = "Action")]
    action: String,  // "run", "pass", "fail", "output"
    #[serde(rename = "Package")]
    package: Option<String>,
    #[serde(rename = "Test")]
    test: Option<String>,
    #[serde(rename = "Output")]
    output: Option<String>,
}

// Track per-package results
let mut packages: HashMap<String, PackageResult> = HashMap::new();

for line in stdout.lines() {
    let event: GoTestEvent = serde_json::from_str(line)?;
    match event.action.as_str() {
        "fail" => {
            packages.entry(event.package)
                .or_default()
                .failed_tests.push((event.test, event.output));
        }
        "pass" => {
            packages.entry(event.package)
                .or_default()
                .pass += 1;
        }
        _ => {}
    }
}

{"Time":"2024-01-23T10:00:00Z","Action":"run","Package":"github.com/user/project/pkg/api","Test":"TestFetchUser"}
{"Time":"2024-01-23T10:00:00Z","Action":"output","Package":"github.com/user/project/pkg/api","Test":"TestFetchUser","Output":"    api_test.go:42: Expected status 200, got 404\n"}
{"Time":"2024-01-23T10:00:00Z","Action":"fail","Package":"github.com/user/project/pkg/api","Test":"TestFetchUser","Elapsed":0.02}

rtk go test github.com/user/project/pkg/api
# Tests only the api package

rtk go test -v -race -timeout 30s ./...
# Verbose, race detection, 30s timeout

rtk go build [flags] [packages]

fn filter_go_build(output: &str) -> String {
    let lines: Vec<&str> = output.lines()
        .filter(|line| {
            // Keep error lines (file:line:col format)
            line.contains(".go:") && (line.contains("error") || line.contains(":"))
        })
        .collect();
    
    if lines.is_empty() {
        return "✓ Build successful".to_string();
    }
    
    format!("✗ Build failed ({} errors)\n\n{}", lines.len(), lines.join("\n"))
}

rtk go vet [packages]

rtk golangci-lint run [options]

// Force JSON output
cmd.arg("run").arg("--out-format=json");

// Parse JSON output
#[derive(Deserialize)]
struct GolangciIssue {
    #[serde(rename = "FromLinter")]
    from_linter: String,
    #[serde(rename = "Text")]
    text: String,
    #[serde(rename = "Pos")]
    pos: Position,
}

#[derive(Deserialize)]
struct Position {
    #[serde(rename = "Filename")]
    filename: String,
    #[serde(rename = "Line")]
    line: usize,
}

let result: GolangciOutput = serde_json::from_str(&stdout)?;

// Group by linter
let mut by_linter: HashMap<String, Vec<GolangciIssue>> = HashMap::new();
for issue in result.issues {
    by_linter.entry(issue.from_linter)
        .or_default()
        .push(issue);
}

rtk go test ./...                    # All packages recursively
rtk go test ./pkg/api ./pkg/utils    # Specific packages
rtk go test github.com/user/project/pkg/api  # Full import path

rtk go test -tags=integration ./...
rtk go build -tags=release .

# .github/workflows/ci.yml
name: Go CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-go@v4
        with:
          go-version: '1.21'
      - name: Vet
        run: rtk go vet ./...
      - name: Lint
        run: rtk golangci-lint run
      - name: Test
        run: rtk go test -race -cover ./...
      - name: Build
        run: rtk go build .

let mut packages: HashMap<String, PackageResult> = HashMap::new();

// Events arrive interleaved:
// {"Package":"pkg/api","Action":"run"}
// {"Package":"pkg/utils","Action":"run"}
// {"Package":"pkg/api","Action":"fail"}
// {"Package":"pkg/utils","Action":"pass"}

// RTK groups by package:
packages["pkg/api"] = { failed: 1 }
packages["pkg/utils"] = { passed: 5 }