Skip to content

Commit ce625c9

Browse files
oschwaldoschwald
committed
Improve error checks in tests
1 parent f45db06 commit ce625c9

File tree

2 files changed

+50
-49
lines changed

2 files changed

+50
-49
lines changed

‎decoder_test.go

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@ import (
99
"testing"
1010

1111
"github.com/stretchr/testify/assert"
12+
"github.com/stretchr/testify/require"
1213
)
1314

1415
func TestBool(t *testing.T) {
@@ -205,7 +206,7 @@ func validateDecoding(t *testing.T, tests map[string]interface{}) {
205206

206207
var result interface{}
207208
_, err := d.decode(0, reflect.ValueOf(&result), 0)
208-
assert.Nil(t, err)
209+
assert.NoError(t, err)
209210

210211
if !reflect.DeepEqual(result, expected) {
211212
// A big case statement would produce nicer errors
@@ -216,7 +217,7 @@ func validateDecoding(t *testing.T, tests map[string]interface{}) {
216217

217218
func TestPointers(t *testing.T) {
218219
bytes, err := ioutil.ReadFile("test-data/test-data/maps-with-pointers.raw")
219-
assert.Nil(t, err)
220+
require.NoError(t, err)
220221
d := decoder{bytes}
221222

222223
expected := map[uint]map[string]string{
@@ -231,7 +232,7 @@ func TestPointers(t *testing.T) {
231232
for offset, expectedValue := range expected {
232233
var actual map[string]string
233234
_, err := d.decode(offset, reflect.ValueOf(&actual), 0)
234-
assert.Nil(t, err)
235+
assert.NoError(t, err)
235236
if !reflect.DeepEqual(actual, expectedValue) {
236237
t.Errorf("Decode for pointer at %d failed", offset)
237238
}

‎reader_test.go

Lines changed: 46 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ func TestReader(t *testing.T) {
1919
for _, ipVersion := range []uint{4, 6} {
2020
fileName := fmt.Sprintf("test-data/test-data/MaxMind-DB-test-ipv%d-%d.mmdb", ipVersion, recordSize)
2121
reader, err := Open(fileName)
22-
require.Nil(t, err, "unexpected error while opening database: %v", err)
22+
require.NoError(t, err, "unexpected error while opening database: %v", err)
2323
checkMetadata(t, reader, ipVersion, recordSize)
2424

2525
if ipVersion == 4 {
@@ -37,7 +37,7 @@ func TestReaderBytes(t *testing.T) {
3737
fileName := fmt.Sprintf("test-data/test-data/MaxMind-DB-test-ipv%d-%d.mmdb", ipVersion, recordSize)
3838
bytes, _ := ioutil.ReadFile(fileName)
3939
reader, err := FromBytes(bytes)
40-
require.Nil(t, err, "unexpected error while opening bytes: %v", err)
40+
require.NoError(t, err, "unexpected error while opening bytes: %v", err)
4141

4242
checkMetadata(t, reader, ipVersion, recordSize)
4343

@@ -52,11 +52,11 @@ func TestReaderBytes(t *testing.T) {
5252

5353
func TestDecodingToInterface(t *testing.T) {
5454
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
55-
assert.Nil(t, err, "unexpected error while opening database: %v", err)
55+
require.NoError(t, err, "unexpected error while opening database: %v", err)
5656

5757
var recordInterface interface{}
5858
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &recordInterface)
59-
require.Nil(t, err, "unexpected error while doing lookup: %v", err)
59+
require.NoError(t, err, "unexpected error while doing lookup: %v", err)
6060

6161
record := recordInterface.(map[string]interface{})
6262
assert.Equal(t, record["array"], []interface{}{uint64(1), uint64(2), uint64(3)})
@@ -99,7 +99,7 @@ type TestType struct {
9999

100100
func TestDecoder(t *testing.T) {
101101
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
102-
require.Nil(t, err)
102+
require.NoError(t, err)
103103

104104
verify := func(result TestType) {
105105
assert.Equal(t, result.Array, []uint{uint(1), uint(2), uint(3)})
@@ -128,21 +128,21 @@ func TestDecoder(t *testing.T) {
128128
{
129129
// Directly lookup and decode.
130130
var result TestType
131-
assert.Nil(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
131+
require.NoError(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
132132
verify(result)
133133
}
134134
{
135135
// Lookup record offset, then Decode.
136136
var result TestType
137137
offset, err := reader.LookupOffset(net.ParseIP("::1.1.1.0"))
138-
assert.Nil(t, err)
138+
require.NoError(t, err)
139139
assert.NotEqual(t, offset, NotFound)
140140

141-
assert.Nil(t, reader.Decode(offset, &result))
141+
assert.NoError(t, reader.Decode(offset, &result))
142142
verify(result)
143143
}
144144

145-
assert.Nil(t, reader.Close())
145+
assert.NoError(t, reader.Close())
146146
}
147147

148148
type TestInterface interface {
@@ -157,9 +157,9 @@ func TestStructInterface(t *testing.T) {
157157
var result TestInterface = &TestType{}
158158

159159
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
160-
require.Nil(t, err)
160+
require.NoError(t, err)
161161

162-
require.Nil(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
162+
require.NoError(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
163163

164164
assert.Equal(t, result.method(), true)
165165
}
@@ -168,7 +168,7 @@ func TestNonEmptyNilInterface(t *testing.T) {
168168
var result TestInterface
169169

170170
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
171-
require.Nil(t, err)
171+
require.NoError(t, err)
172172

173173
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
174174
assert.Equal(t, err.Error(), "maxminddb: cannot unmarshal map into type maxminddb.TestInterface")
@@ -187,9 +187,9 @@ func TestEmbeddedStructAsInterface(t *testing.T) {
187187
var result interface{} = city.Traits
188188

189189
db, err := Open("test-data/test-data/GeoIP2-ISP-Test.mmdb")
190-
require.Nil(t, err)
190+
require.NoError(t, err)
191191

192-
assert.Nil(t, db.Lookup(net.ParseIP("1.128.0.0"), &result))
192+
assert.NoError(t, db.Lookup(net.ParseIP("1.128.0.0"), &result))
193193
}
194194

195195
type BoolInterface interface {
@@ -211,8 +211,8 @@ func TesValueTypeInterface(t *testing.T) {
211211
result.Boolean = Bool(false)
212212

213213
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
214-
require.Nil(t, err)
215-
require.Nil(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
214+
require.NoError(t, err)
215+
require.NoError(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
216216

217217
assert.Equal(t, result.Boolean.true(), true)
218218
}
@@ -252,12 +252,12 @@ type TestPointerType struct {
252252

253253
func TestComplexStructWithNestingAndPointer(t *testing.T) {
254254
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
255-
assert.Nil(t, err)
255+
assert.NoError(t, err)
256256

257257
var result TestPointerType
258258

259259
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
260-
require.Nil(t, err)
260+
require.NoError(t, err)
261261

262262
assert.Equal(t, *result.Array, []uint{uint(1), uint(2), uint(3)})
263263
assert.Equal(t, *result.Boolean, true)
@@ -278,16 +278,16 @@ func TestComplexStructWithNestingAndPointer(t *testing.T) {
278278
bigInt.SetString("1329227995784915872903807060280344576", 10)
279279
assert.Equal(t, result.Uint128, bigInt)
280280

281-
assert.Nil(t, reader.Close())
281+
assert.NoError(t, reader.Close())
282282
}
283283

284284
func TestNestedOffsetDecode(t *testing.T) {
285285
db, err := Open("test-data/test-data/GeoIP2-City-Test.mmdb")
286-
require.Nil(t, err)
286+
require.NoError(t, err)
287287

288288
off, err := db.LookupOffset(net.ParseIP("81.2.69.142"))
289289
assert.NotEqual(t, off, NotFound)
290-
require.Nil(t, err)
290+
require.NoError(t, err)
291291

292292
var root struct {
293293
CountryOffset uintptr `maxminddb:"country"`
@@ -300,42 +300,42 @@ func TestNestedOffsetDecode(t *testing.T) {
300300
TimeZoneOffset uintptr `maxminddb:"time_zone"`
301301
} `maxminddb:"location"`
302302
}
303-
assert.Nil(t, db.Decode(off, &root))
303+
assert.NoError(t, db.Decode(off, &root))
304304
assert.Equal(t, root.Location.Latitude, 51.5142)
305305

306306
var longitude float64
307-
assert.Nil(t, db.Decode(root.Location.LongitudeOffset, &longitude))
307+
assert.NoError(t, db.Decode(root.Location.LongitudeOffset, &longitude))
308308
assert.Equal(t, longitude, -0.0931)
309309

310310
var timeZone string
311-
assert.Nil(t, db.Decode(root.Location.TimeZoneOffset, &timeZone))
311+
assert.NoError(t, db.Decode(root.Location.TimeZoneOffset, &timeZone))
312312
assert.Equal(t, timeZone, "Europe/London")
313313

314314
var country struct {
315315
IsoCode string `maxminddb:"iso_code"`
316316
}
317-
assert.Nil(t, db.Decode(root.CountryOffset, &country))
317+
assert.NoError(t, db.Decode(root.CountryOffset, &country))
318318
assert.Equal(t, country.IsoCode, "GB")
319319

320-
assert.Nil(t, db.Close())
320+
assert.NoError(t, db.Close())
321321
}
322322

323323
func TestDecodingUint16IntoInt(t *testing.T) {
324324
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
325-
require.Nil(t, err, "unexpected error while opening database: %v", err)
325+
require.NoError(t, err, "unexpected error while opening database: %v", err)
326326

327327
var result struct {
328328
Uint16 int `maxminddb:"uint16"`
329329
}
330330
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
331-
require.Nil(t, err)
331+
require.NoError(t, err)
332332

333333
assert.Equal(t, result.Uint16, 100)
334334
}
335335

336336
func TestIpv6inIpv4(t *testing.T) {
337337
reader, err := Open("test-data/test-data/MaxMind-DB-test-ipv4-24.mmdb")
338-
require.Nil(t, err, "unexpected error while opening database: %v", err)
338+
require.NoError(t, err, "unexpected error while opening database: %v", err)
339339

340340
var result TestType
341341
err = reader.Lookup(net.ParseIP("2001::"), &result)
@@ -345,19 +345,19 @@ func TestIpv6inIpv4(t *testing.T) {
345345

346346
expected := errors.New("error looking up '2001::': you attempted to look up an IPv6 address in an IPv4-only database")
347347
assert.Equal(t, err, expected)
348-
assert.Nil(t, reader.Close(), "error on close")
348+
assert.NoError(t, reader.Close(), "error on close")
349349
}
350350

351351
func TestBrokenDoubleDatabase(t *testing.T) {
352352
reader, err := Open("test-data/test-data/GeoIP2-City-Test-Broken-Double-Format.mmdb")
353-
require.Nil(t, err, "unexpected error while opening database: %v", err)
353+
require.NoError(t, err, "unexpected error while opening database: %v", err)
354354

355355
var result interface{}
356356
err = reader.Lookup(net.ParseIP("2001:220::"), &result)
357357

358358
expected := newInvalidDatabaseError("the MaxMind DB file's data section contains bad data (float 64 size of 2)")
359359
assert.Equal(t, err, expected)
360-
assert.Nil(t, reader.Close(), "error on close")
360+
assert.NoError(t, reader.Close(), "error on close")
361361
}
362362

363363
func TestInvalidNodeCountDatabase(t *testing.T) {
@@ -385,7 +385,7 @@ func TestDecodingToNonPointer(t *testing.T) {
385385
var recordInterface interface{}
386386
err := reader.Lookup(net.ParseIP("::1.1.1.0"), recordInterface)
387387
assert.Equal(t, err.Error(), "result param must be a pointer")
388-
assert.Nil(t, reader.Close(), "error on close")
388+
assert.NoError(t, reader.Close(), "error on close")
389389
}
390390

391391
func TestNilLookup(t *testing.T) {
@@ -394,7 +394,7 @@ func TestNilLookup(t *testing.T) {
394394
var recordInterface interface{}
395395
err := reader.Lookup(nil, recordInterface)
396396
assert.Equal(t, err.Error(), "ipAddress passed to Lookup cannot be nil")
397-
assert.Nil(t, reader.Close(), "error on close")
397+
assert.NoError(t, reader.Close(), "error on close")
398398
}
399399

400400
func TestUsingClosedDatabase(t *testing.T) {
@@ -447,7 +447,7 @@ func checkIpv4(t *testing.T, reader *Reader) {
447447

448448
var result map[string]string
449449
err := reader.Lookup(ip, &result)
450-
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
450+
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
451451
assert.Equal(t, result, map[string]string{"ip": address})
452452
}
453453
pairs := map[string]string{
@@ -467,7 +467,7 @@ func checkIpv4(t *testing.T, reader *Reader) {
467467

468468
var result map[string]string
469469
err := reader.Lookup(ip, &result)
470-
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
470+
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
471471
assert.Equal(t, result, data)
472472
}
473473

@@ -476,7 +476,7 @@ func checkIpv4(t *testing.T, reader *Reader) {
476476

477477
var result map[string]string
478478
err := reader.Lookup(ip, &result)
479-
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
479+
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
480480
assert.Nil(t, result)
481481
}
482482
}
@@ -489,7 +489,7 @@ func checkIpv6(t *testing.T, reader *Reader) {
489489
for _, address := range subnets {
490490
var result map[string]string
491491
err := reader.Lookup(net.ParseIP(address), &result)
492-
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
492+
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
493493
assert.Equal(t, result, map[string]string{"ip": address})
494494
}
495495

@@ -508,21 +508,21 @@ func checkIpv6(t *testing.T, reader *Reader) {
508508
data := map[string]string{"ip": valueAddress}
509509
var result map[string]string
510510
err := reader.Lookup(net.ParseIP(keyAddress), &result)
511-
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
511+
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
512512
assert.Equal(t, result, data)
513513
}
514514

515515
for _, address := range []string{"1.1.1.33", "255.254.253.123", "89fa::"} {
516516
var result map[string]string
517517
err := reader.Lookup(net.ParseIP(address), &result)
518-
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
518+
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
519519
assert.Nil(t, result)
520520
}
521521
}
522522

523523
func BenchmarkMaxMindDB(b *testing.B) {
524524
db, err := Open("GeoLite2-City.mmdb")
525-
assert.Nil(b, err)
525+
require.NoError(b, err)
526526

527527
r := rand.New(rand.NewSource(time.Now().UnixNano()))
528528
var result interface{}
@@ -531,14 +531,14 @@ func BenchmarkMaxMindDB(b *testing.B) {
531531
for i := 0; i < b.N; i++ {
532532
randomIPv4Address(r, ip)
533533
err = db.Lookup(ip, &result)
534-
assert.Nil(b, err)
534+
assert.NoError(b, err)
535535
}
536-
assert.Nil(b, db.Close(), "error on close")
536+
assert.NoError(b, db.Close(), "error on close")
537537
}
538538

539539
func BenchmarkCountryCode(b *testing.B) {
540540
db, err := Open("GeoLite2-City.mmdb")
541-
assert.Nil(b, err)
541+
require.NoError(b, err)
542542

543543
type MinCountry struct {
544544
Country struct {
@@ -553,9 +553,9 @@ func BenchmarkCountryCode(b *testing.B) {
553553
for i := 0; i < b.N; i++ {
554554
randomIPv4Address(r, ip)
555555
err = db.Lookup(ip, &result)
556-
assert.Nil(b, err)
556+
assert.NoError(b, err)
557557
}
558-
assert.Nil(b, db.Close(), "error on close")
558+
assert.NoError(b, db.Close(), "error on close")
559559
}
560560

561561
func randomIPv4Address(r *rand.Rand, ip []byte) {

0 commit comments

Comments
 (0)