We're now at the point where we've added all the features we want to for our counter application. To ensure the application is working as expected, we're going to write some end-to-end tests.

End-to-end (E2E) tests are one of the three primary testing types:

• Unit tests (we’ve already written these)
• Integration tests
• End-to-end tests

While integration tests validate interactions between components, end-to-end tests act more like smoke tests across the whole application—checking if everything is wired up correctly.

---

What Do We Measure?

In end-to-end testing:

• We simulate running the program like a user would.
• We validate output and side effects—primarily:
  • Standard Output (stdout)
  • Standard Error (stderr)

---

Why Not Call main()?

As mentioned earlier, we can’t call the actual main() function directly from test code.

One workaround is to wrap your logic into a Main() function that takes flags and arguments as parameters:

func Main(opts displayOptions, files []string) { ... }

But this doesn't test the CLI as a real user would experience it. Instead, we want to build and run the compiled binary as a subprocess.

---

Setting Up the End-to-End Test Environment

1. Create a new test directory:

/test/e2e/

2. Create a test entry file:

test/e2e/main_test.go

Set the package:

package e2e

---

Using TestMain for Setup

TestMain is the entry point for tests in a Go package. We'll use it to:

• Build the binary
• Run tests
• Clean up

var binName = "counter_test"

func TestMain(m *testing.M) {
    if runtime.GOOS == "windows" {
        binName += ".exe"
    }

    cmd := exec.Command("go", "build", "-o", binName, "../../cmd/counter")
    
    var buf bytes.Buffer
    cmd.Stderr = &buf

    if err := cmd.Run(); err != nil {
        fmt.Fprintln(os.Stderr, "Failed to build binary:", err)
        fmt.Fprintln(os.Stderr, buf.String())
        os.Exit(1)
    }

    code := m.Run()

    _ = os.Remove(binName)

    os.Exit(code)
}

⚠️ Note: os.Exit() will skip deferred calls, so do any cleanup (like removing the binary) before calling it.

---

Writing the First End-to-End Test

Create:

test/e2e/counter_test.go

Define a test for reading from stdin:

func TestStdin(t *testing.T) {
    dir, err := os.Getwd()
    if err != nil {
        t.Fatal("couldn't get working directory:", err)
    }

    path := filepath.Join(dir, binName)

    cmd := exec.Command(path)

    var out bytes.Buffer
    cmd.Stdout = &out

    cmd.Stdin = strings.NewReader("1\n2\n3\n")

    if err := cmd.Run(); err != nil {
        t.Fatal("Failed to run command:", err)
    }

    expected := "      6       3       3\n"

    if out.String() != expected {
        t.Logf("Failed: standard out is not correct.\nGot:    %q\nWanted: %q", out.String(), expected)
        t.Fail()
    }
}

Run the E2E Test

From the root:

go test ./test/e2e -v

Output should confirm the binary was built and that the test passed.

Try removing the final newline in expected to see the test fail and confirm the check works.

---

Summary

• We wrote a true end-to-end test by compiling and running the actual CLI binary.
• We used TestMain to handle setup and teardown.
• We captured and verified stdin and stdout using Go’s standard libraries.

Next up: we’ll write another end-to-end test for file-based input.