S
Home Explora + Blogs Contact

Setting Up Your Go Testing Lab!

Are you tired of uncertainty and eager to deliver robust Go applications with complete assurance? You're in the right spot. Here's where you'll start creating your own comprehensive testing environment.

Consider this as your own workspace, the area where you will carry out tests, verify the functionality of your code, and ultimately create Go programs that are solid and reliable. In this article, we will establish the necessary foundation, ensuring that you have all the necessary tools and experience the initial moment of understanding that will guide you towards mastering testing.

It's time to roll up our sleeves and get to work!

Go Installation

To get started, you'll need to have Go set up on your system. If you've already installed and configured Go, you're off to a great start! To confirm that everything is working as expected, simply run a quick check.

go version

You can expect to see a message similar to go version go1.2X.Y os/arch.

Installing or Updating Go

Visit the official Go downloads page at go.dev/dl/ to get the installer suitable for your operating system (Windows, macOS, Linux). Simply follow the provided installation guidelines, which are typically easy to understand. After installation, launch a fresh terminal window and execute go version to verify the installation process.

Once Go is installed, the foundation of your lab is set and ready for use.

Introducing the go test Tool

The go test command. This indispensable tool provided by Go is well-equipped for executing tests. You won't have to seek out additional testing frameworks for simple unit testing as Go provides everything you need from the get-go.

Understanding the Functionality of the Go Test Command

  • Finds your test files: It automatically looks for files ending with the _test.go suffix.
  • Identifies test functions: Within those files, it looks for functions that start with Test (e.g., TestMyFunction).
  • Compiles and runs your tests: It compiles your main code and your test code, runs the test functions, and reports the results.
  • Reports success or failure: You will receive a clear indication of whether your tests were successful or not.

We will utilize go test extensively as it is easy to use, effective, and seamlessly integrated into the Go environment.

Editor Setup for Go & Testing

Having the right setup can greatly simplify your life, particularly when it comes to testing, even though Go code can be written in any text editor. Here are some key aspects to consider:

Support for Go Language and Extensions

Majority of modern text editors (such as VS Code, GoLand, Vim, Emacs, etc.) offer strong support for Go programming, often through extensions developed by official sources or the community.

For VS Code Users: It is highly recommended to use the official "Go" extension created by Google. This extension typically guides you to install essential Go tools (such as gopls for language server support) when you open a Go file.

Essential Features to Activate

  • Syntax Highlighting: Enhances the readability of your Go code.
  • Autocompletion/IntelliSense: Aids in faster coding with reduced errors.
  • Go to Definition: Simplifies navigation within your codebase.
  • Linting & Formatting: Tools like go fmt and golint (often integrated) assist in maintaining clean and idiomatic code.
  • Integrated Test Running: Numerous extensions offer the ability to run and debug tests directly from the editor, eliminating the need to constantly switch to the terminal. This significantly boosts productivity!

Spend a brief moment verifying that your editor is set up for optimal performance with Go for an effective and efficient testing experience.

Creating Your First Go Program and Test

Now that we've covered the basics, it's time to put them into action. Let's create a simple Go program and pair it with a test, which will serve as our introduction to testing in Go, akin to the classic "Hello, World!" example.

Establish Your Project Folder

Create a new directory named gotester in your terminal for this experiment.

mkdir gotester
cd gotester

Set up a Go module to effectively manage your project's dependencies and maintain a structured organization.

go mod init example.com/gotester

(You can replace example.com/gotester with any module path you like, e.g., github.com/yourusername/gotester).

Creating a Basic Go Program

Make a new file called calculator.go in your gotester folder and add this code:

// calculator.go
package main // Or 'calculator' if you intend it as a library

// Add takes two integers and returns their sum.
func Add(a, b int) int {
	return a + b
}

We have created a basic Add function and our objective is to verify its functionality through testing.

Begin by Creating Your Initial Test

Create a test file for calculator.go, adhering to the standard naming convention by appending _test.go to the file name. Create calculator_test.go in the same directory as calculator.go, specifically within the gotester directory.

// calculator_test.go
package main // Must be the same package as the code being tested

import "testing" // Import the testing package

// TestAdd is our test function for the Add function.
func TestAdd(t *testing.T) {
	got := Add(2, 3)
	want := 5

	if got != want {
		t.Errorf("Add(2, 3) = %d; want %d", got, want)
	}
}

Let's break this down:

  • package main: Test files belong to the same package as the code they are testing.
  • import "testing": We need this package for its testing utilities.
  • func TestAdd(t *testing.T):
    • The function name starts with Test followed by the name of the function we're testing (capitalized Add).
    • It takes one argument: t of type testing.T. This t object is our toolkit for reporting test failures, logging, etc.
  • got := Add(2, 3): We "act" by calling the function we want to test.
  • want := 5: We define the "expected" result.
  • if got != want: We "assert" by comparing the actual result (got) with the expected result (want).
  • If the comparison fails, the t.Errorf method is used to report the error, marking the test as failed and printing a formatted error message.

Launch Your Experiment Now!

In your command-line interface, ensuring that you are still within the gotester directory, run:

go test

Expected Result When All Settings Are Properly Configured

PASS
ok  	example.com/gotester	0.005s

(The module path and time might vary slightly.)

Well done! You've now established a fundamental Go setup, crafted a straightforward function, and validated its performance with your inaugural Go test!

Examining a Test Failure

To see what a test that doesn't pass looks like, revisit calculator_test.go and modify the want variable to 6. Then rerun go test again:

go test

You will witness something similar this time:

--- FAIL: TestAdd (0.00s)
    calculator_test.go:11: Add(2, 3) = 5; want 6
FAIL
exit status 1
FAIL	example.com/gotester	0.006s

The test result explicitly identifies the failed test (TestAdd), the source of the error (calculator_test.go:11), and the error message itself. To resolve the issue, modify the expected value back to 5 to restore a passing test.

Your Lab is Now Officially Up and Running!

Congratulations are in order! You've successfully set up your Go Testing Lab. With Go installed, a grasp of the go test command, and your editor configured, you've made significant progress. The icing on the cake is that you've already created and executed your first program and test, marking a solid starting point for your journey.

Although the Add function and its accompanying test may appear straightforward, the underlying concepts you've utilized - a well-defined function, a transparent test, and automated validation - form the foundation for crafting reliable and resilient Go applications.

Next, we'll delve into advanced Go topics, with a focus on how to validate them through robust testing. Prepare to create impressive projects and verify their functionality with assurance.