Make code more lint-proof

Author: tstromberg

.github/dependabot.yml

@@ -1,8 +1,8 @@
 version: 2
 updates:
-- package-ecosystem: gomod
-  directory: "/"
-  schedule:
-    interval: daily
-    time: "04:00"
-  open-pull-requests-limit: 10
+  - package-ecosystem: gomod
+    directory: "/"
+    schedule:
+      interval: daily
+      time: "04:00"
+    open-pull-requests-limit: 10

.github/workflows/workflow.yaml

@@ -23,7 +23,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go-version: ['1.20', '1.21', '1.22', '1.23', '1.24']
+        go-version: ["1.20", "1.21", "1.22", "1.23", "1.24"]
         os: [ubuntu-latest, macos-latest, windows-latest]
     env:
       OS: ${{ matrix.os }}

.gitignore

@@ -19,3 +19,6 @@ Gopkg.lock
 
 # cover
 coverage.txt
+
+# added by lint-install
+out/

Makefile

@@ -1,55 +1,75 @@
-SOURCE_FILES?=$$(go list ./... | grep -v /vendor/)
-TEST_PATTERN?=.
-TEST_OPTIONS?=
-VERSION?=$$(cat VERSION)
-LINTER?=$$(which golangci-lint)
-LINTER_VERSION=1.50.0
-
-ifeq ($(OS),Windows_NT)
-	LINTER_FILE=golangci-lint-$(LINTER_VERSION)-windows-amd64.zip
-	LINTER_UNPACK= >| app.zip; unzip -j app.zip -d $$GOPATH/bin; rm app.zip
-else ifeq ($(OS), Darwin)
-	LINTER_FILE=golangci-lint-$(LINTER_VERSION)-darwin-amd64.tar.gz
-	LINTER_UNPACK= | tar xzf - -C $$GOPATH/bin --wildcards --strip 1 "**/golangci-lint"
-else
-	LINTER_FILE=golangci-lint-$(LINTER_VERSION)-linux-amd64.tar.gz
-	LINTER_UNPACK= | tar xzf - -C $$GOPATH/bin --wildcards --strip 1 "**/golangci-lint"
-endif
-
-setup:
-	go install github.com/pierrre/gotestcover@latest
-	go install golang.org/x/tools/cmd/cover@latest
-	go mod download
-
-test: test_and_cover_report lint
-
-test_and_cover_report:
-	gotestcover $(TEST_OPTIONS) -covermode=atomic -coverprofile=coverage.txt $(SOURCE_FILES) -run $(TEST_PATTERN) -timeout=2m
-
 cover: test ## Run all the tests and opens the coverage report
 	go tool cover -html=coverage.txt
 
+test:
+	go test ./...
+
 fmt: ## gofmt and goimports all go files
 	find . -name '*.go' -not -wholename './vendor/*' | while read -r file; do gofmt -w -s "$$file"; goimports -w "$$file"; done
 
-lint: ## Run all the linters
-	@if [ "$(LINTER)" = "" ]; then\
-		curl -L https://github.com/golangci/golangci-lint/releases/download/v$(LINTER_VERSION)/$(LINTER_FILE) $(LINTER_UNPACK) ;\
-		chmod +x $$GOPATH/bin/golangci-lint;\
-	fi
-
-	golangci-lint run
-
-ci: test_and_cover_report ## Run all the tests but no linters - use https://golangci.com integration instead
-
 build:
 	go build
 
-release: ## Release new version
-	git tag | grep -q $(VERSION) && echo This version was released! Increase VERSION! || git tag $(VERSION) && git push origin $(VERSION) && git tag v$(VERSION) && git push origin v$(VERSION)
-
-# Absolutely awesome: http://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
 help:
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
 
 .DEFAULT_GOAL := build
+
+# BEGIN: lint-install .
+# http://github.com/codeGROOVE-dev/lint-install
+
+.PHONY: lint
+lint: _lint
+
+LINT_ARCH := $(shell uname -m)
+LINT_OS := $(shell uname)
+LINT_OS_LOWER := $(shell echo $(LINT_OS) | tr '[:upper:]' '[:lower:]')
+LINT_ROOT := $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
+
+# shellcheck and hadolint lack arm64 native binaries: rely on x86-64 emulation
+ifeq ($(LINT_OS),Darwin)
+	ifeq ($(LINT_ARCH),arm64)
+		LINT_ARCH=x86_64
+	endif
+endif
+
+LINTERS :=
+FIXERS :=
+
+GOLANGCI_LINT_CONFIG := $(LINT_ROOT)/.golangci.yml
+GOLANGCI_LINT_VERSION ?= v2.3.0
+GOLANGCI_LINT_BIN := $(LINT_ROOT)/out/linters/golangci-lint-$(GOLANGCI_LINT_VERSION)-$(LINT_ARCH)
+$(GOLANGCI_LINT_BIN):
+	mkdir -p $(LINT_ROOT)/out/linters
+	rm -rf $(LINT_ROOT)/out/linters/golangci-lint-*
+	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(LINT_ROOT)/out/linters $(GOLANGCI_LINT_VERSION)
+	mv $(LINT_ROOT)/out/linters/golangci-lint $@
+
+LINTERS += golangci-lint-lint
+golangci-lint-lint: $(GOLANGCI_LINT_BIN)
+	find . -name go.mod -execdir "$(GOLANGCI_LINT_BIN)" run -c "$(GOLANGCI_LINT_CONFIG)" \;
+
+FIXERS += golangci-lint-fix
+golangci-lint-fix: $(GOLANGCI_LINT_BIN)
+	find . -name go.mod -execdir "$(GOLANGCI_LINT_BIN)" run -c "$(GOLANGCI_LINT_CONFIG)" --fix \;
+
+YAMLLINT_VERSION ?= 1.37.1
+YAMLLINT_ROOT := $(LINT_ROOT)/out/linters/yamllint-$(YAMLLINT_VERSION)
+YAMLLINT_BIN := $(YAMLLINT_ROOT)/dist/bin/yamllint
+$(YAMLLINT_BIN):
+	mkdir -p $(LINT_ROOT)/out/linters
+	rm -rf $(LINT_ROOT)/out/linters/yamllint-*
+	curl -sSfL https://github.com/adrienverge/yamllint/archive/refs/tags/v$(YAMLLINT_VERSION).tar.gz | tar -C $(LINT_ROOT)/out/linters -zxf -
+	cd $(YAMLLINT_ROOT) && pip3 install --target dist . || pip install --target dist .
+
+LINTERS += yamllint-lint
+yamllint-lint: $(YAMLLINT_BIN)
+	PYTHONPATH=$(YAMLLINT_ROOT)/dist $(YAMLLINT_ROOT)/dist/bin/yamllint .
+
+.PHONY: _lint $(LINTERS)
+_lint: $(LINTERS)
+
+.PHONY: fix $(FIXERS)
+fix: $(FIXERS)
+
+# END: lint-install .

examples/custom_retry_function_test.go

@@ -1,8 +1,9 @@
 package retry_test
 
 import (
+	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"strconv"
@@ -34,12 +35,12 @@ func TestCustomRetryFunction(t *testing.T) {
 			// HTTP 429 status code with Retry-After header in seconds
 			w.Header().Add("Retry-After", "1")
 			w.WriteHeader(http.StatusTooManyRequests)
-			w.Write([]byte("Server limit reached"))
+			_, _ = w.Write([]byte("Server limit reached"))
 			attempts--
 			return
 		}
 		w.WriteHeader(http.StatusOK)
-		w.Write([]byte("hello"))
+		_, _ = w.Write([]byte("hello"))
 	}))
 	defer ts.Close()
 
@@ -55,8 +56,8 @@ func TestCustomRetryFunction(t *testing.T) {
 						panic(err)
 					}
 				}()
-				body, err = ioutil.ReadAll(resp.Body)
-				if resp.StatusCode != 200 {
+				body, err = io.ReadAll(resp.Body)
+				if resp.StatusCode != http.StatusOK {
 					err = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 					if resp.StatusCode == http.StatusTooManyRequests {
 						// check Retry-After header if it contains seconds to wait for the next retry
@@ -79,17 +80,18 @@ func TestCustomRetryFunction(t *testing.T) {
 			return err
 		},
 		retry.DelayType(func(n uint, err error, config *retry.Config) time.Duration {
-			fmt.Println("Server fails with: " + err.Error())
-			if retriable, ok := err.(*RetriableError); ok {
-				fmt.Printf("Client follows server recommendation to retry after %v\n", retriable.RetryAfter)
+			// Server fails with: <error message>
+			var retriable *RetriableError
+			if errors.As(err, &retriable) {
+				// Client follows server recommendation to retry after retriable.RetryAfter
 				return retriable.RetryAfter
 			}
 			// apply a default exponential back off strategy
 			return retry.BackOffDelay(n, err, config)
 		}),
 	)
 
-	fmt.Println("Server responds with: " + string(body))
+	// Server responds with: <body content>
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

examples/delay_based_on_error_test.go

@@ -3,8 +3,9 @@
 package retry_test
 
 import (
+	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -37,7 +38,7 @@ func (err SomeOtherError) Error() string {
 
 func TestCustomRetryFunctionBasedOnKindOfError(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprintln(w, "hello")
+		_, _ = fmt.Fprintln(w, "hello")
 	}))
 	defer ts.Close()
 
@@ -53,19 +54,21 @@ func TestCustomRetryFunctionBasedOnKindOfError(t *testing.T) {
 						panic(err)
 					}
 				}()
-				body, err = ioutil.ReadAll(resp.Body)
+				body, err = io.ReadAll(resp.Body)
 			}
 
 			return err
 		},
 		retry.DelayType(func(n uint, err error, config *retry.Config) time.Duration {
-			switch e := err.(type) {
-			case RetryAfterError:
-				if t, err := parseRetryAfter(e.response.Header.Get("Retry-After")); err == nil {
+			var retryAfterErr RetryAfterError
+			if errors.As(err, &retryAfterErr) {
+				if t, err := parseRetryAfter(retryAfterErr.response.Header.Get("Retry-After")); err == nil {
 					return time.Until(t)
 				}
-			case SomeOtherError:
-				return e.retryAfter
+			}
+			var someOtherErr SomeOtherError
+			if errors.As(err, &someOtherErr) {
+				return someOtherErr.retryAfter
 			}
 
 			// default is backoffdelay
@@ -82,5 +85,5 @@ func TestCustomRetryFunctionBasedOnKindOfError(t *testing.T) {
 
 // use https://github.com/aereal/go-httpretryafter instead
 func parseRetryAfter(_ string) (time.Time, error) {
-	return time.Now().Add(1 * time.Second), nil
+	return time.Now().Add(1 * time.Second), nil //nolint:unparam // error is always nil for test simplicity
 }

examples/errors_history_test.go

@@ -29,8 +29,8 @@ func TestErrorHistory(t *testing.T) {
 			if err != nil {
 				return err
 			}
-			defer resp.Body.Close()
-			if resp.StatusCode != 200 {
+			defer func() { _ = resp.Body.Close() }()
+			if resp.StatusCode != http.StatusOK {
 				return fmt.Errorf("failed HTTP - %d", resp.StatusCode)
 			}
 			return nil

examples/http_get_test.go

@@ -2,7 +2,7 @@ package retry_test
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -12,7 +12,7 @@ import (
 
 func TestGet(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprintln(w, "hello")
+		_, _ = fmt.Fprintln(w, "hello")
 	}))
 	defer ts.Close()
 
@@ -28,7 +28,7 @@ func TestGet(t *testing.T) {
 						panic(err)
 					}
 				}()
-				body, err = ioutil.ReadAll(resp.Body)
+				body, err = io.ReadAll(resp.Body)
 			}
 
 			return err