Forem: Guiyomh

Tame Testing Chaos with Gotestsum

Guiyomh — Tue, 31 Oct 2023 14:59:02 +0000

Testing is now a crucial part of the software development process. However, managing results can rapidly become chaotic when you have a lot of tests. This is where the potent open-source utility Gotestsum comes in, which is made to make managing test results in Go easier and better. By combining the outcomes of several tests into a single, understandable report, this developer companion helps you to improve the readability and comprehension of the status of your tests.

Gotestsum is a useful tool that can help developers of all experience levels manage their tests more efficiently and identify possible problems more rapidly. Let's take a look!

Ready in a Blink

To install Gotestsum, you can use the following command:

go install gotest.tools/gotestsum@latest

Gotestsum is designed to be user-friendly and work without additional configuration.

Gotestsum's Super Powers

Gotestsum offers a set of powerful features to improve the management of your Go test results.

Personalize Your Tests

It allows you to customize the output format of test results
with the option --format. You can choose from different formats, such as:

dots prints one character for each test
dots-v2 experimental dots format, one packet per line
pkgname prints one line for each packet
pkgname-and-test-fails prints one line for each packet and failed test results
testname prints one line for each test and each packet
testdox prints a sentence for each test using gotestdox
github-actions test name format with github actions log grouping
standard-quiet standard format go test
standard-verbose standard format go test -v

Technicolor tests

The reports generated by Gotestsum are colored for better readability. Passed tests are displayed in green, failed tests in red, and unexecuted tests in yellow. This coloring makes the status of your tests immediately visible, which is particularly useful when running large tests.

The Ideal Companion for your CI/CD

An important feature is the ability to produce results in Junit or Json format, which makes it a valuable tool for CIs such as Gitlab, Circle CI, Github-action,...

When the --junitfile option specifies a file path, gotestsum will write a test report, in JUnit XML format, to the file. This file can be used to integrate CI systems.

gotestsum --junitfile unit-tests.xml

Your Local Test Assistant

When working on your local development project, Gotestsum offers features that simplify the testing process. The --watch option allows you to automatically run tests of the package that has changed every time a .go file is saved. This ensures that your tests are always up to date and helps you quickly spot any issues introduced during your changes.

gotestsum --watch

Additionally, you can use the --post-run-command option to run a command after running the tests. This can be particularly useful for displaying notifications on your desktop about test results. This way, you can stay informed in real time about the status of your tests during your development process.

gotestsum --post-run-command notify

A Powerful Ally

These capabilities transform Gotestsum into a powerful tool for Go developers, streamlining the administration of test results, improving visibility of test status and accelerating the debugging process.

Gotestsum adapts to your needs, whether you're working on a large team project or a small personal one. It can be tailored to your needs, including interaction with your favorite CI/CD systems, desktop notifications at the end of tests and customized output formats.

I hope I've convinced you that Gotestsum is an effective tool that can help you move forward with your Go development projects.

golangci-lint: a powerful and complete Go linter

Guiyomh — Tue, 31 Oct 2023 10:48:59 +0000

golangci-lint is a Go linter tool that helps detect and fix style errors, convention errors, and potential vulnerabilities. It is based on a set of predefined rules, but you can also create your own rules.

Installation and configuration

go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

Use

To run golangci-lint on your project, use the following command:

golangci-lint run

golangci-lint will display the list of errors and warnings found. You can also use the --format option to display the results in a custom format.

Here are some examples of issues that golangci-lint can detect:

Style errors: golangci-lint can detect the most common Go style errors, such as using uninitialized variables, missing comments, and bad indentation.
Convention errors: golangci-lint can detect violations of Go coding conventions, such as using non-compliant variable names or missing unit tests.
Vulnerabilities: golangci-lint can detect known vulnerabilities in Go code, such as the use of outdated encryption primitives or lack of input validation.

Configuration

golangci-lint is a very configurable tool. It supports several formats YAML, JSON, TOML. You can customize linter rules to meet your specific needs.

Enable or disable linters

linters:
  enable-all: true
  disable:
    - deadcode
    - exhaustivestruct
    - golint
    - ifshort
    - interfacer
    - maligned

This configuration activates all linters except those listed.

Apply specific rules

For example, you can add custom rules to detect issues specific to your project.

rules:
      # Name of a rule.
      main:
        deny:
          - pkg: "github.com/sirupsen/logrus"
            desc: not allowed
          - pkg: "github.com/pkg/errors"
            desc: Should be replaced by standard lib errors package

This configuration prohibits the use of certain packages (this is an example)

Linter included

Golangci-lint includes over 30 linters, which cover a wide range of code quality issues. These linters are divided into several categories:

Style linters check code for compliance with Go style conventions.
- A variable declared without initialization.
- A function declared with an inappropriate name.
- A function that does not return a value.
Security linters detect potential security issues in code.
- A function that uses an inappropriate data type for a parameter.
- A function that does not properly isolate errors.
- A function that uses an uninitialized variable.
Performance linters detect potential performance issues in code.
- A loop that could be replaced by an arithmetic expression.
- A function that could be simplified to improve performance.
- A function that uses an inefficient Go structure.
Quality linters check the overall quality of code, including consistency, readability, and maintainability.
- A variable that is used only once.
- A function that is too long.
- A function that is not well documented.

To get a list of supported linters and enabled/disabled linters, you can do the following command:

golangci-lint help linters

Integration with IDEs

Golangci-lint offers integrations with major Go IDEs, allowing you to run the linter directly from your IDE.

To install the IDE extension for Visual Studio Code, open the VS Code Marketplace and search for "golangci-lint". Click on the extension to install it and add it to your configuration:

{
    "go.lintTool": "golangci-lint",
    "go.lintOnSave": "workspace",
}

Conclusion

You can adjust golangci-lint's behavior to suit your needs by configuring it. You can make sure your code is of the highest caliber by taking the effort to configure golangci-lint.

The following advice will help you configure golangci-lint:

Start with a simple setup and add options as you need them.
Learn more about the various configuration choices by reading the golangci-lint manual.
Take inspiration from the golangci-lint configuration samples.

I hope this piece clarifies the golangci-lint settings for you.