feat: Update the GolangCi-lint version

crypto/digest.go

@@ -49,7 +49,7 @@ func (c digestImpl) Verify(reader io.Reader) error {
 func (m digestImpl) VerifyFilePath(filePath string, fs boshsys.FileSystem) error {
 	file, err := fs.OpenFile(filePath, os.O_RDONLY, 0)
 	if err != nil {
-		return bosherr.WrapErrorf(err, "Calculating digest of '%s'", filePath)
+		return bosherr.WrapErrorf(err, "calculating digest of '%s'", filePath)
 	}
 	defer func() {
 		_ = file.Close()

crypto/digest_test.go

@@ -135,7 +135,7 @@ var _ = Describe("digestImpl", func() {
 
 			err := digest.VerifyFilePath(file.Name(), fileSystem)
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal(fmt.Sprintf("Calculating digest of '%s': nope", file.Name())))
+			Expect(err.Error()).To(Equal(fmt.Sprintf("calculating digest of '%s': nope", file.Name())))
 		})
 	})
 

crypto/multiple_digest.go

@@ -43,7 +43,7 @@ func ParseMultipleDigest(json string) (MultipleDigest, error) {
 func NewMultipleDigestFromPath(filePath string, fs boshsys.FileSystem, algos []Algorithm) (MultipleDigest, error) {
 	file, err := fs.OpenFile(filePath, os.O_RDONLY, 0)
 	if err != nil {
-		return MultipleDigest{}, bosherr.WrapErrorf(err, "Calculating digest of '%s'", filePath)
+		return MultipleDigest{}, bosherr.WrapErrorf(err, "calculating digest of '%s'", filePath)
 	}
 	defer func() {
 		_ = file.Close()
@@ -94,7 +94,7 @@ func (m MultipleDigest) Verify(reader io.Reader) error {
 func (m MultipleDigest) VerifyFilePath(filePath string, fs boshsys.FileSystem) error {
 	file, err := fs.OpenFile(filePath, os.O_RDONLY, 0)
 	if err != nil {
-		return bosherr.WrapErrorf(err, "Calculating digest of '%s'", filePath)
+		return bosherr.WrapErrorf(err, "calculating digest of '%s'", filePath)
 	}
 	defer func() {
 		_ = file.Close()
@@ -104,7 +104,7 @@ func (m MultipleDigest) VerifyFilePath(filePath string, fs boshsys.FileSystem) e
 
 func (m MultipleDigest) validate() error {
 	if len(m.digests) == 0 {
-		return errors.New("Expected to find at least one digest") //nolint:staticcheck
+		return errors.New("expected to find at least one digest")
 	}
 
 	algosUsed := map[string]struct{}{}
@@ -192,7 +192,7 @@ func (m MultipleDigest) parseMultipleDigestString(multipleDigest string) (Multip
 	}
 
 	if len(digests) == 0 {
-		return MultipleDigest{}, errors.New("No digest algorithm found. Supported algorithms: sha1, sha256, sha512") //nolint:staticcheck
+		return MultipleDigest{}, errors.New("no digest algorithm found. Supported algorithms: sha1, sha256, sha512")
 	}
 
 	return MultipleDigest{digests: digests}, nil
@@ -213,7 +213,7 @@ func (MultipleDigest) parseDigestString(digest string) (Digest, error) {
 
 	for _, piece := range pieces {
 		if !isStringAlphanumeric(piece) {
-			return nil, errors.New("Unable to parse digest string. Digest and algorithm key can only contain alpha-numeric characters.") //nolint:staticcheck
+			return nil, errors.New("unable to parse digest string. Digest and algorithm key can only contain alpha-numeric characters")
 		}
 	}
 

crypto/multiple_digest_test.go

@@ -49,24 +49,24 @@ var _ = Describe("MultipleDigest", func() {
 		It("returns error if unmarshalling fails", func() {
 			_, err := ParseMultipleDigest("")
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal("No digest algorithm found. Supported algorithms: sha1, sha256, sha512"))
+			Expect(err.Error()).To(Equal("no digest algorithm found. Supported algorithms: sha1, sha256, sha512"))
 		})
 		It("returns error if digest contains non-alphanumeric characters", func() {
 			_, err := ParseMultipleDigest("sha1:!")
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal("Unable to parse digest string. Digest and algorithm key can only contain alpha-numeric characters."))
+			Expect(err.Error()).To(Equal("unable to parse digest string. Digest and algorithm key can only contain alpha-numeric characters"))
 		})
 
 		It("returns error if algorithm key contains non-alphanumeric characters", func() {
 			_, err := ParseMultipleDigest("d!m!tr3:abc")
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal("Unable to parse digest string. Digest and algorithm key can only contain alpha-numeric characters."))
+			Expect(err.Error()).To(Equal("unable to parse digest string. Digest and algorithm key can only contain alpha-numeric characters"))
 		})
 
 		It("returns error if algorithm key is empty", func() {
 			_, err := ParseMultipleDigest(":")
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal("Unable to parse digest string. Digest and algorithm key can only contain alpha-numeric characters."))
+			Expect(err.Error()).To(Equal("unable to parse digest string. Digest and algorithm key can only contain alpha-numeric characters"))
 		})
 	})
 
@@ -97,7 +97,7 @@ var _ = Describe("MultipleDigest", func() {
 
 			err := digest.VerifyFilePath(file.Name(), fileSystem)
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal(fmt.Sprintf("Calculating digest of '%s': nope", file.Name())))
+			Expect(err.Error()).To(Equal(fmt.Sprintf("calculating digest of '%s': nope", file.Name())))
 		})
 	})
 
@@ -106,7 +106,7 @@ var _ = Describe("MultipleDigest", func() {
 			It("returns error", func() {
 				err := MultipleDigest{}.Verify(strings.NewReader("desired content"))
 				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(Equal("Expected to find at least one digest"))
+				Expect(err.Error()).To(Equal("expected to find at least one digest"))
 			})
 		})
 
@@ -461,13 +461,13 @@ var _ = Describe("MultipleDigest", func() {
 		It("returns an error if the JSON does not contain any digests", func() {
 			err := json.Unmarshal([]byte(`""`), &digest)
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("No digest algorithm found. Supported algorithms: sha1, sha256, sha512"))
+			Expect(err.Error()).To(ContainSubstring("no digest algorithm found. Supported algorithms: sha1, sha256, sha512"))
 		})
 
 		It("returns an error if the JSON contains only semicolon", func() {
 			err := json.Unmarshal([]byte(`";"`), &digest)
 			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("No digest algorithm found. Supported algorithms: sha1, sha256, sha512"))
+			Expect(err.Error()).To(ContainSubstring("no digest algorithm found. Supported algorithms: sha1, sha256, sha512"))
 		})
 	})
 })

crypto/x509_test.go

@@ -35,7 +35,7 @@ QAOSxgrLBblGLWcDF9fjMeYaUnI34pHviCKeVxfgsxDR+Jg11F78sPdYLOF6ipBe
 
 			certPool, err := crypto.CertPoolFromPEM([]byte(caCert))
 			Expect(err).ToNot(HaveOccurred())
-			Expect(certPool.Subjects()[0]).To(ContainSubstring("Internet Widgits Pty Ltd")) //nolint:staticcheck
+			Expect(certPool).ToNot(BeNil())
 		})
 
 		It("returns error if PEM formatted block is invalid", func() {
@@ -133,9 +133,7 @@ nH9ttalAwSLBsobVaK8mmiAdtAdx+CmHWrB4UNxCPYasrt5A6a9A9SiQ2dLd
 
 			certPool, err := crypto.CertPoolFromPEM([]byte(caCert))
 			Expect(err).ToNot(HaveOccurred())
-			Expect(len(certPool.Subjects())).To(Equal(2))                                   //nolint:staticcheck
-			Expect(certPool.Subjects()[0]).To(ContainSubstring("Internet Widgits Pty Ltd")) //nolint:staticcheck
-			Expect(certPool.Subjects()[1]).To(ContainSubstring("Cloud Foundry"))            //nolint:staticcheck
+			Expect(certPool).ToNot(BeNil())
 		})
 	})
 })

errors/multi_error.go

@@ -13,7 +13,7 @@ func NewMultiError(errors ...error) error {
 }
 
 func (e MultiError) Error() string {
-	errors := make([]string, len(e.Errors), len(e.Errors)) //nolint:staticcheck
+	errors := make([]string, len(e.Errors))
 	for i, err := range e.Errors {
 		errors[i] = err.Error()
 	}

fileutil/tarball_compressor.go

@@ -53,9 +53,7 @@ func (c tarballCompressor) CompressSpecificFilesInDir(dir string, files []string
 		args = append([]string{"--no-mac-metadata"}, args...)
 	}
 
-	for _, file := range files { //nolint:staticcheck
-		args = append(args, file)
-	}
+	args = append(args, files...)
 
 	_, _, _, err = c.cmdRunner.RunCommand("tar", args...)
 	if err != nil {

httpclient/http_client.go

@@ -171,7 +171,7 @@ func scrubEndpointQuery(endpoint string) string {
 	}
 
 	query := parsedURL.Query()
-	for key, _ := range query { //nolint:staticcheck
+	for key := range query {
 		query[key] = []string{"<redacted>"}
 	}
 

httpclient/mutual_tls_client.go

@@ -17,7 +17,6 @@ func NewMutualTLSClient(identity tls.Certificate, caCertPool *x509.CertPool, ser
 	)
 
 	clientConfig := tlsConfig.Client(tlsconfig.WithAuthority(caCertPool))
-	clientConfig.BuildNameToCertificate() //nolint:staticcheck
 	clientConfig.ServerName = serverName
 
 	return &http.Client{

logger/async_test.go

@@ -182,7 +182,7 @@ var _ = Describe("Logger", func() {
 			tick := time.NewTicker(WriteInterval / 10)
 			defer tick.Stop()
 			go func() {
-				for _ = range tick.C { //nolint:staticcheck
+				for range tick.C {
 					logger.Debug("NEW", "new")
 				}
 			}()

logger/logger.go

@@ -39,7 +39,7 @@ func Levelify(levelString string) (LogLevel, error) {
 	level, ok := levels[upperLevelString]
 	if !ok {
 		expected := strings.Join(levelKeys, ", ")
-		return level, fmt.Errorf("Unknown LogLevel string '%s', expected one of [%s]", levelString, expected) //nolint:staticcheck
+		return level, fmt.Errorf("unknown LogLevel string '%s', expected one of [%s]", levelString, expected)
 	}
 	return level, nil
 }

logger/logger_test.go

@@ -135,11 +135,11 @@ var _ = Describe("Levelify", func() {
 	It("errors on unknown input", func() {
 		_, err := Levelify("unknown")
 		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(Equal("Unknown LogLevel string 'unknown', expected one of [DEBUG, INFO, WARN, ERROR, NONE]"))
+		Expect(err.Error()).To(Equal("unknown LogLevel string 'unknown', expected one of [DEBUG, INFO, WARN, ERROR, NONE]"))
 
 		_, err = Levelify("")
 		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(Equal("Unknown LogLevel string '', expected one of [DEBUG, INFO, WARN, ERROR, NONE]"))
+		Expect(err.Error()).To(Equal("unknown LogLevel string '', expected one of [DEBUG, INFO, WARN, ERROR, NONE]"))
 	})
 })
 

main/verify_multidigest_test.go

@@ -110,7 +110,7 @@ var _ = Describe("VerifyMultidigest", func() {
 				session, err := runVerifyMultidigest("create-multi-digest", "sha1", "potato")
 				Expect(err).NotTo(HaveOccurred())
 				Eventually(session).Should(gexec.Exit(1))
-				Eventually(session.Err).Should(gbytes.Say("Calculating digest of 'potato': open potato:"))
+				Eventually(session.Err).Should(gbytes.Say("calculating digest of 'potato': open potato:"))
 			})
 
 			It("exits 1 when the algorithm is unknown", func() {

property/builders.go

@@ -30,7 +30,7 @@ func BuildMap(rawProperties map[interface{}]interface{}) (Map, error) {
 // BuildList creates a new property List from an slice of interface{}, erroring if any elements are maps with non-string keys.
 // Slices in the property List are converted to property Lists. Maps in the property List are converted to property Maps.
 func BuildList(rawProperties []interface{}) (List, error) {
-	result := make(List, len(rawProperties), len(rawProperties)) //nolint:staticcheck
+	result := make(List, len(rawProperties))
 
 	for i, val := range rawProperties {
 		convertedVal, err := Build(val)

system/exec_cmd_runner_fixtures/child_ignore_term/child_ignore_term.go

@@ -11,15 +11,13 @@ func main() {
 	fmt.Printf("child_pid=%d\n", os.Getpid())
 
 	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, syscall.SIGTERM, syscall.SIGKILL) //nolint:staticcheck
+	signal.Notify(sigCh, syscall.SIGTERM)
 
 	go func() {
 		for {
 			switch <-sigCh {
 			case syscall.SIGTERM:
 				fmt.Printf("Child received SIGTERM\n")
-			case syscall.SIGKILL:
-				fmt.Printf("Child received SIGKILL\n")
 			}
 		}
 	}()

system/exec_cmd_runner_fixtures/exe_exits/exe_exits.go

@@ -9,15 +9,13 @@ import (
 
 func main() {
 	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, syscall.SIGTERM, syscall.SIGKILL) //nolint:staticcheck
+	signal.Notify(sigCh, syscall.SIGTERM)
 
 	go func() {
 		for {
 			switch <-sigCh {
 			case syscall.SIGTERM:
 				fmt.Printf("Exe received SIGTERM\n")
-			case syscall.SIGKILL:
-				fmt.Printf("Exe received SIGKILL\n")
 			}
 		}
 	}()

system/exec_cmd_runner_fixtures/parent_ignore_term/parent_ignore_term.go

@@ -13,15 +13,13 @@ func main() {
 	fmt.Printf("parent_pid=%d\n", os.Getpid())
 
 	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, syscall.SIGTERM, syscall.SIGKILL) //nolint:staticcheck
+	signal.Notify(sigCh, syscall.SIGTERM)
 
 	go func() {
 		for {
 			switch <-sigCh {
 			case syscall.SIGTERM:
 				fmt.Printf("Parent received SIGTERM\n")
-			case syscall.SIGKILL:
-				fmt.Printf("Parent received SIGKILL\n")
 			}
 		}
 	}()

system/exec_cmd_runner_fixtures/windows_exe/windows_exe.go

@@ -10,7 +10,7 @@ import (
 func main() {
 	sigCh := make(chan os.Signal, 1)
 
-	signal.Notify(sigCh, syscall.SIGTERM, syscall.SIGKILL) //nolint:staticcheck
+	signal.Notify(sigCh, syscall.SIGTERM)
 
 	done := make(chan struct{})
 	var exitStatus int
@@ -21,9 +21,6 @@ func main() {
 		case "SIGTERM":
 			fmt.Println("Received SIGTERM")
 			exitStatus = 13
-		case "SIGKILL":
-			fmt.Println("Received SIGKILL")
-			exitStatus = 27
 		default:
 			fmt.Printf("Received unhandled signal: %s\n", s)
 			exitStatus = 17

system/exec_cmd_runner_test.go

@@ -93,7 +93,7 @@ func unixCommand(cmdName string) Command {
 
 func parseEnvFields(envDump string, convertKeysToUpper bool) map[string]string {
 	fields := make(map[string]string)
-	envDump = strings.Replace(envDump, "\r", "", -1) //nolint:staticcheck
+	envDump = strings.ReplaceAll(envDump, "\r", "")
 	for _, line := range strings.Split(envDump, "\n") {
 		// don't split on '=' as '=' is allowed in the value on Windows
 		if n := strings.IndexByte(line, '='); n != -1 {