Update linter config and fix minor linting issues

Author: oschwald

.golangci.toml

@@ -29,8 +29,8 @@ const (
 	_Slice
 	// We don't use the next two. They are placeholders. See the spec
 	// for more details.
-	_Container //nolint: deadcode, varcheck
-	_Marker    //nolint: deadcode, varcheck
+	_Container //nolint: deadcode, varcheck // above
+	_Marker    //nolint: deadcode, varcheck // above
 	_Bool
 	_Float32
 )

decoder.go

@@ -2,8 +2,8 @@ package maxminddb
 
 import (
 	"encoding/hex"
-	"io/ioutil"
 	"math/big"
+	"os"
 	"reflect"
 	"strings"
 	"testing"
@@ -51,7 +51,7 @@ func TestFloat(t *testing.T) {
 }
 
 func TestInt32(t *testing.T) {
-	int32 := map[string]interface{}{
+	int32s := map[string]interface{}{
 		"0001":         0,
 		"0401ffffffff": -1,
 		"0101ff":       255,
@@ -65,7 +65,7 @@ func TestInt32(t *testing.T) {
 		"04017fffffff": 2147483647,
 		"040180000001": -2147483647,
 	}
-	validateDecoding(t, int32)
+	validateDecoding(t, int32s)
 }
 
 func TestMap(t *testing.T) {
@@ -120,7 +120,8 @@ func TestString(t *testing.T) {
 func TestByte(t *testing.T) {
 	b := make(map[string]interface{})
 	for key, val := range testStrings {
-		oldCtrl, _ := hex.DecodeString(key[0:2])
+		oldCtrl, err := hex.DecodeString(key[0:2])
+		require.NoError(t, err)
 		newCtrl := []byte{oldCtrl[0] ^ 0xc0}
 		key = strings.Replace(key, hex.EncodeToString(oldCtrl), hex.EncodeToString(newCtrl), 1)
 		b[key] = []byte(val.(string))
@@ -130,18 +131,18 @@ func TestByte(t *testing.T) {
 }
 
 func TestUint16(t *testing.T) {
-	uint16 := map[string]interface{}{
+	uint16s := map[string]interface{}{
 		"a0":     uint64(0),
 		"a1ff":   uint64(255),
 		"a201f4": uint64(500),
 		"a22a78": uint64(10872),
 		"a2ffff": uint64(65535),
 	}
-	validateDecoding(t, uint16)
+	validateDecoding(t, uint16s)
 }
 
 func TestUint32(t *testing.T) {
-	uint32 := map[string]interface{}{
+	uint32s := map[string]interface{}{
 		"c0":         uint64(0),
 		"c1ff":       uint64(255),
 		"c201f4":     uint64(500),
@@ -150,7 +151,7 @@ func TestUint32(t *testing.T) {
 		"c3ffffff":   uint64(16777215),
 		"c4ffffffff": uint64(4294967295),
 	}
-	validateDecoding(t, uint32)
+	validateDecoding(t, uint32s)
 }
 
 func TestUint64(t *testing.T) {
@@ -205,11 +206,12 @@ func powBigInt(bi *big.Int, pow uint) *big.Int {
 
 func validateDecoding(t *testing.T, tests map[string]interface{}) {
 	for inputStr, expected := range tests {
-		inputBytes, _ := hex.DecodeString(inputStr)
+		inputBytes, err := hex.DecodeString(inputStr)
+		require.NoError(t, err)
 		d := decoder{inputBytes}
 
 		var result interface{}
-		_, err := d.decode(0, reflect.ValueOf(&result), 0)
+		_, err = d.decode(0, reflect.ValueOf(&result), 0)
 		assert.NoError(t, err)
 
 		if !reflect.DeepEqual(result, expected) {
@@ -220,7 +222,7 @@ func validateDecoding(t *testing.T, tests map[string]interface{}) {
 }
 
 func TestPointers(t *testing.T) {
-	bytes, err := ioutil.ReadFile(testFile("maps-with-pointers.raw"))
+	bytes, err := os.ReadFile(testFile("maps-with-pointers.raw"))
 	require.NoError(t, err)
 	d := decoder{bytes}
 

decoder_test.go

@@ -30,18 +30,19 @@ type testDeserializer struct {
 	key   *string
 }
 
-func (d *testDeserializer) ShouldSkip(offset uintptr) (bool, error) {
+func (d *testDeserializer) ShouldSkip(_ uintptr) (bool, error) {
 	return false, nil
 }
 
 func (d *testDeserializer) StartSlice(size uint) error {
 	return d.add(make([]interface{}, size))
 }
 
-func (d *testDeserializer) StartMap(size uint) error {
+func (d *testDeserializer) StartMap(_ uint) error {
 	return d.add(map[string]interface{}{})
 }
 
+//nolint:unparam // This is to meet the requirements of the interface.
 func (d *testDeserializer) End() error {
 	d.stack = d.stack[:len(d.stack)-1]
 	return nil

deserializer_test.go

@@ -241,7 +241,7 @@ func (r *Reader) decode(offset uintptr, result interface{}) error {
 
 func (r *Reader) lookupPointer(ip net.IP) (uint, int, net.IP, error) {
 	if ip == nil {
-		return 0, 0, ip, errors.New("IP passed to Lookup cannot be nil")
+		return 0, 0, nil, errors.New("IP passed to Lookup cannot be nil")
 	}
 
 	ipV4Address := ip.To4()

reader.go

@@ -34,13 +34,15 @@ func Open(file string) (*Reader, error) {
 	}
 
 	if err := mapFile.Close(); err != nil {
-		_ = munmap(mmap)
+		//nolint:errcheck // we prefer to return the original error
+		munmap(mmap)
 		return nil, err
 	}
 
 	reader, err := FromBytes(mmap)
 	if err != nil {
-		_ = munmap(mmap)
+		//nolint:errcheck // we prefer to return the original error
+		munmap(mmap)
 		return nil, err
 	}
 

reader_other.go

@@ -3,10 +3,10 @@ package maxminddb
 import (
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"math/big"
 	"math/rand"
 	"net"
+	"os"
 	"path/filepath"
 	"testing"
 	"time"
@@ -44,7 +44,8 @@ func TestReaderBytes(t *testing.T) {
 				ipVersion,
 				recordSize,
 			)
-			bytes, _ := ioutil.ReadFile(fileName)
+			bytes, err := os.ReadFile(fileName)
+			require.NoError(t, err)
 			reader, err := FromBytes(bytes)
 			require.NoError(t, err, "unexpected error while opening bytes: %v", err)
 
@@ -246,7 +247,6 @@ func checkDecodingToInterface(t *testing.T, recordInterface interface{}) {
 	assert.Equal(t, bigInt, record["uint128"])
 }
 
-//nolint: maligned
 type TestType struct {
 	Array      []uint                 `maxminddb:"array"`
 	Boolean    bool                   `maxminddb:"boolean"`
@@ -557,30 +557,33 @@ func TestNonDatabase(t *testing.T) {
 }
 
 func TestDecodingToNonPointer(t *testing.T) {
-	reader, _ := Open(testFile("MaxMind-DB-test-decoder.mmdb"))
+	reader, err := Open(testFile("MaxMind-DB-test-decoder.mmdb"))
+	require.NoError(t, err)
 
 	var recordInterface interface{}
-	err := reader.Lookup(net.ParseIP("::1.1.1.0"), recordInterface)
+	err = reader.Lookup(net.ParseIP("::1.1.1.0"), recordInterface)
 	assert.Equal(t, "result param must be a pointer", err.Error())
 	assert.NoError(t, reader.Close(), "error on close")
 }
 
 func TestNilLookup(t *testing.T) {
-	reader, _ := Open(testFile("MaxMind-DB-test-decoder.mmdb"))
+	reader, err := Open(testFile("MaxMind-DB-test-decoder.mmdb"))
+	require.NoError(t, err)
 
 	var recordInterface interface{}
-	err := reader.Lookup(nil, recordInterface)
+	err = reader.Lookup(nil, recordInterface)
 	assert.Equal(t, "IP passed to Lookup cannot be nil", err.Error())
 	assert.NoError(t, reader.Close(), "error on close")
 }
 
 func TestUsingClosedDatabase(t *testing.T) {
-	reader, _ := Open(testFile("MaxMind-DB-test-decoder.mmdb"))
+	reader, err := Open(testFile("MaxMind-DB-test-decoder.mmdb"))
+	require.NoError(t, err)
 	require.NoError(t, reader.Close())
 
 	var recordInterface interface{}
 
-	err := reader.Lookup(nil, recordInterface)
+	err = reader.Lookup(nil, recordInterface)
 	assert.Equal(t, "cannot call Lookup on a closed database", err.Error())
 
 	_, err = reader.LookupOffset(nil)
@@ -714,6 +717,7 @@ func BenchmarkInterfaceLookup(b *testing.B) {
 	db, err := Open("GeoLite2-City.mmdb")
 	require.NoError(b, err)
 
+	//nolint:gosec // this is a test
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	var result interface{}
 
@@ -732,6 +736,7 @@ func BenchmarkInterfaceLookupNetwork(b *testing.B) {
 	db, err := Open("GeoLite2-City.mmdb")
 	require.NoError(b, err)
 
+	//nolint:gosec // this is a test
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	var result interface{}
 
@@ -800,6 +805,7 @@ func BenchmarkCityLookup(b *testing.B) {
 	db, err := Open("GeoLite2-City.mmdb")
 	require.NoError(b, err)
 
+	//nolint:gosec // this is a test
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	var result fullCity
 
@@ -818,6 +824,7 @@ func BenchmarkCityLookupNetwork(b *testing.B) {
 	db, err := Open("GeoLite2-City.mmdb")
 	require.NoError(b, err)
 
+	//nolint:gosec // this is a test
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	var result fullCity
 
@@ -842,6 +849,7 @@ func BenchmarkCountryCode(b *testing.B) {
 		} `maxminddb:"country"`
 	}
 
+	//nolint:gosec // this is a test
 	r := rand.New(rand.NewSource(0))
 	var result MinCountry
 

reader_test.go

@@ -157,11 +157,14 @@ func (v *verifier) verifyDataSection(offsets map[uint]bool) error {
 
 		pointer := offset
 
-		if _, ok := offsets[pointer]; ok {
-			delete(offsets, pointer)
-		} else {
-			return newInvalidDatabaseError("found data (%v) at %v that the search tree does not point to", data, pointer)
+		if _, ok := offsets[pointer]; !ok {
+			return newInvalidDatabaseError(
+				"found data (%v) at %v that the search tree does not point to",
+				data,
+				pointer,
+			)
 		}
+		delete(offsets, pointer)
 
 		offset = newOffset
 	}