Mastering DRY Tests in Go - For everyone!
Mastering Golang DRY Testing: From Fundamentals to Advanced Strategies and tips!
Greetings, Gophers!
In the vast landscape of Golang testing, we often find repeat writing a separate test function for each case; resulting in duplication and calling the tested function multiple times within a single test function can lead to ambiguity in case of failure.
The solution lies in the art of Table-Driven Tests.
Code listing for all demo can be downloaded here, free of charge!
The Elegance of Table-Driven Tests
Let's dissect an example using Great Common Divisor algorithm:
The magic begins by defining the table's columns, representing the test inputs and expected outputs. Each row becomes a test case, and the execution loop ensures every case is examined separately.
This approach offers two pivotal advantages:
1. Reusable Assertion Logic: The same assertion logic is employed for all tests, maintaining the Dryness of your tests.
2. Transparent Test Coverage: Easily discern what's covered by observing the inputs in the table. Each row, uniquely named, becomes a subtest expressing the test's intent.
The Testing Package
In the realm of Go testing, the testing package is your guiding star. The testing.T offers a suite of methods to control the testing flow. From running tests in parallel with Parallel() to skipping tests with Skip() and executing teardown functions with Cleanup(), it's a toolkit every Gopher should wield.
You can read the exhaustive list here.
1. Indicating Errors and Logs
The testing.T type equips you with practical tools. Utilize t.Errorf() to print error messages and flag tests as failed.
Remember, `t.Error*` won't halt test execution, but `t.Fatal*` will.
The `Log*()` functions come in handy for printing information during test execution, ensuring you stay informed.
2. Parallelizing Your Tests
Parallelizing tests in Go is a breeze with the `Parallel()` method. By default, tests run sequentially, but marking a test with `t.Parallel()` signals Go to run it concurrently.
3. Skipping Tests
Separating unit tests from integration tests is accomplished with `Skip()`. Use this method strategically to optimize test execution.
Combine it with `testing.Short()` to distinguish between short and long tests, refining your testing suite for maximum effectiveness.
4. Test Teardown and Cleanup Made Simple
The `Cleanup()` method is for test teardown. Forget the clutter of `defer` statements; the cleanup function ensures your intentions are clear. Additionally, leverage `t.Helper()` to enhance logs, focusing on the failing test's line number.
Code listing for all the above code can be downloaded here, free of charge!
In your testing endeavors, let simplicity be your guide, verbosity your ally. Happy testing, Gophers!
Cheers,
Birnadin E,
A Gopher.