Skip to content

Commit 036359c

Browse files
oschwaldoschwald
committed
Put test assertion params in correct order
1 parent 71772a2 commit 036359c

File tree

2 files changed

+78
-74
lines changed

2 files changed

+78
-74
lines changed

‎reader_test.go

Lines changed: 77 additions & 73 deletions
Original file line numberDiff line numberDiff line change
@@ -200,26 +200,28 @@ func TestDecodingToInterface(t *testing.T) {
200200
require.NoError(t, err, "unexpected error while doing lookup: %v", err)
201201

202202
record := recordInterface.(map[string]interface{})
203-
assert.Equal(t, record["array"], []interface{}{uint64(1), uint64(2), uint64(3)})
204-
assert.Equal(t, record["boolean"], true)
205-
assert.Equal(t, record["bytes"], []byte{0x00, 0x00, 0x00, 0x2a})
206-
assert.Equal(t, record["double"], 42.123456)
207-
assert.Equal(t, record["float"], float32(1.1))
208-
assert.Equal(t, record["int32"], -268435456)
209-
assert.Equal(t, record["map"],
203+
assert.Equal(t, []interface{}{uint64(1), uint64(2), uint64(3)}, record["array"])
204+
assert.Equal(t, true, record["boolean"])
205+
assert.Equal(t, []byte{0x00, 0x00, 0x00, 0x2a}, record["bytes"])
206+
assert.Equal(t, 42.123456, record["double"])
207+
assert.Equal(t, float32(1.1), record["float"])
208+
assert.Equal(t, -268435456, record["int32"])
209+
assert.Equal(t,
210210
map[string]interface{}{
211211
"mapX": map[string]interface{}{
212212
"arrayX": []interface{}{uint64(7), uint64(8), uint64(9)},
213213
"utf8_stringX": "hello",
214-
}})
215-
216-
assert.Equal(t, record["uint16"], uint64(100))
217-
assert.Equal(t, record["uint32"], uint64(268435456))
218-
assert.Equal(t, record["uint64"], uint64(1152921504606846976))
219-
assert.Equal(t, record["utf8_string"], "unicode! ☯ - ♫")
214+
}},
215+
record["map"],
216+
)
217+
218+
assert.Equal(t, uint64(100), record["uint16"])
219+
assert.Equal(t, uint64(268435456), record["uint32"])
220+
assert.Equal(t, uint64(1152921504606846976), record["uint64"])
221+
assert.Equal(t, "unicode! ☯ - ♫", record["utf8_string"])
220222
bigInt := new(big.Int)
221223
bigInt.SetString("1329227995784915872903807060280344576", 10)
222-
assert.Equal(t, record["uint128"], bigInt)
224+
assert.Equal(t, bigInt, record["uint128"])
223225
}
224226

225227
// nolint: maligned
@@ -243,27 +245,29 @@ func TestDecoder(t *testing.T) {
243245
require.NoError(t, err)
244246

245247
verify := func(result TestType) {
246-
assert.Equal(t, result.Array, []uint{uint(1), uint(2), uint(3)})
247-
assert.Equal(t, result.Boolean, true)
248-
assert.Equal(t, result.Bytes, []byte{0x00, 0x00, 0x00, 0x2a})
249-
assert.Equal(t, result.Double, 42.123456)
250-
assert.Equal(t, result.Float, float32(1.1))
251-
assert.Equal(t, result.Int32, int32(-268435456))
252-
253-
assert.Equal(t, result.Map,
248+
assert.Equal(t, []uint{uint(1), uint(2), uint(3)}, result.Array)
249+
assert.Equal(t, true, result.Boolean)
250+
assert.Equal(t, []byte{0x00, 0x00, 0x00, 0x2a}, result.Bytes)
251+
assert.Equal(t, 42.123456, result.Double)
252+
assert.Equal(t, float32(1.1), result.Float)
253+
assert.Equal(t, int32(-268435456), result.Int32)
254+
255+
assert.Equal(t,
254256
map[string]interface{}{
255257
"mapX": map[string]interface{}{
256258
"arrayX": []interface{}{uint64(7), uint64(8), uint64(9)},
257259
"utf8_stringX": "hello",
258-
}})
259-
260-
assert.Equal(t, result.Uint16, uint16(100))
261-
assert.Equal(t, result.Uint32, uint32(268435456))
262-
assert.Equal(t, result.Uint64, uint64(1152921504606846976))
263-
assert.Equal(t, result.Utf8String, "unicode! ☯ - ♫")
260+
}},
261+
result.Map,
262+
)
263+
264+
assert.Equal(t, uint16(100), result.Uint16)
265+
assert.Equal(t, uint32(268435456), result.Uint32)
266+
assert.Equal(t, uint64(1152921504606846976), result.Uint64)
267+
assert.Equal(t, "unicode! ☯ - ♫", result.Utf8String)
264268
bigInt := new(big.Int)
265269
bigInt.SetString("1329227995784915872903807060280344576", 10)
266-
assert.Equal(t, &result.Uint128, bigInt)
270+
assert.Equal(t, bigInt, &result.Uint128)
267271
}
268272

269273
{
@@ -277,7 +281,7 @@ func TestDecoder(t *testing.T) {
277281
var result TestType
278282
offset, err := reader.LookupOffset(net.ParseIP("::1.1.1.0"))
279283
require.NoError(t, err)
280-
assert.NotEqual(t, offset, NotFound)
284+
assert.NotEqual(t, NotFound, offset)
281285

282286
assert.NoError(t, reader.Decode(offset, &result))
283287
verify(result)
@@ -302,7 +306,7 @@ func TestStructInterface(t *testing.T) {
302306

303307
require.NoError(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
304308

305-
assert.Equal(t, result.method(), true)
309+
assert.Equal(t, true, result.method())
306310
}
307311

308312
func TestNonEmptyNilInterface(t *testing.T) {
@@ -312,7 +316,7 @@ func TestNonEmptyNilInterface(t *testing.T) {
312316
require.NoError(t, err)
313317

314318
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
315-
assert.Equal(t, err.Error(), "maxminddb: cannot unmarshal map into type maxminddb.TestInterface")
319+
assert.Equal(t, "maxminddb: cannot unmarshal map into type maxminddb.TestInterface", err.Error())
316320
}
317321

318322
type CityTraits struct {
@@ -355,7 +359,7 @@ func TesValueTypeInterface(t *testing.T) {
355359
require.NoError(t, err)
356360
require.NoError(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
357361

358-
assert.Equal(t, result.Boolean.true(), true)
362+
assert.Equal(t, true, result.Boolean.true())
359363
}
360364

361365
type NestedMapX struct {
@@ -400,24 +404,24 @@ func TestComplexStructWithNestingAndPointer(t *testing.T) {
400404
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
401405
require.NoError(t, err)
402406

403-
assert.Equal(t, *result.Array, []uint{uint(1), uint(2), uint(3)})
404-
assert.Equal(t, *result.Boolean, true)
405-
assert.Equal(t, *result.Bytes, []byte{0x00, 0x00, 0x00, 0x2a})
406-
assert.Equal(t, *result.Double, 42.123456)
407-
assert.Equal(t, *result.Float, float32(1.1))
408-
assert.Equal(t, *result.Int32, int32(-268435456))
407+
assert.Equal(t, []uint{uint(1), uint(2), uint(3)}, *result.Array)
408+
assert.Equal(t, true, *result.Boolean)
409+
assert.Equal(t, []byte{0x00, 0x00, 0x00, 0x2a}, *result.Bytes)
410+
assert.Equal(t, 42.123456, *result.Double)
411+
assert.Equal(t, float32(1.1), *result.Float)
412+
assert.Equal(t, int32(-268435456), *result.Int32)
409413

410-
assert.Equal(t, result.Map.MapX.ArrayX, []int{7, 8, 9})
414+
assert.Equal(t, []int{7, 8, 9}, result.Map.MapX.ArrayX)
411415

412-
assert.Equal(t, result.Map.MapX.UTF8StringX, "hello")
416+
assert.Equal(t, "hello", result.Map.MapX.UTF8StringX)
413417

414-
assert.Equal(t, *result.Uint16, uint16(100))
415-
assert.Equal(t, *result.Uint32, uint32(268435456))
416-
assert.Equal(t, **result.Uint64, uint64(1152921504606846976))
417-
assert.Equal(t, *result.Utf8String, "unicode! ☯ - ♫")
418+
assert.Equal(t, uint16(100), *result.Uint16)
419+
assert.Equal(t, uint32(268435456), *result.Uint32)
420+
assert.Equal(t, uint64(1152921504606846976), **result.Uint64)
421+
assert.Equal(t, "unicode! ☯ - ♫", *result.Utf8String)
418422
bigInt := new(big.Int)
419423
bigInt.SetString("1329227995784915872903807060280344576", 10)
420-
assert.Equal(t, result.Uint128, bigInt)
424+
assert.Equal(t, bigInt, result.Uint128)
421425

422426
assert.NoError(t, reader.Close())
423427
}
@@ -442,21 +446,21 @@ func TestNestedOffsetDecode(t *testing.T) {
442446
} `maxminddb:"location"`
443447
}
444448
assert.NoError(t, db.Decode(off, &root))
445-
assert.Equal(t, root.Location.Latitude, 51.5142)
449+
assert.Equal(t, 51.5142, root.Location.Latitude)
446450

447451
var longitude float64
448452
assert.NoError(t, db.Decode(root.Location.LongitudeOffset, &longitude))
449-
assert.Equal(t, longitude, -0.0931)
453+
assert.Equal(t, -0.0931, longitude)
450454

451455
var timeZone string
452456
assert.NoError(t, db.Decode(root.Location.TimeZoneOffset, &timeZone))
453-
assert.Equal(t, timeZone, "Europe/London")
457+
assert.Equal(t, "Europe/London", timeZone)
454458

455459
var country struct {
456460
IsoCode string `maxminddb:"iso_code"`
457461
}
458462
assert.NoError(t, db.Decode(root.CountryOffset, &country))
459-
assert.Equal(t, country.IsoCode, "GB")
463+
assert.Equal(t, "GB", country.IsoCode)
460464

461465
assert.NoError(t, db.Close())
462466
}
@@ -471,7 +475,7 @@ func TestDecodingUint16IntoInt(t *testing.T) {
471475
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
472476
require.NoError(t, err)
473477

474-
assert.Equal(t, result.Uint16, 100)
478+
assert.Equal(t, 100, result.Uint16)
475479
}
476480

477481
func TestIpv6inIpv4(t *testing.T) {
@@ -482,10 +486,10 @@ func TestIpv6inIpv4(t *testing.T) {
482486
err = reader.Lookup(net.ParseIP("2001::"), &result)
483487

484488
var emptyResult TestType
485-
assert.Equal(t, result, emptyResult)
489+
assert.Equal(t, emptyResult, result)
486490

487491
expected := errors.New("error looking up '2001::': you attempted to look up an IPv6 address in an IPv4-only database")
488-
assert.Equal(t, err, expected)
492+
assert.Equal(t, expected, err)
489493
assert.NoError(t, reader.Close(), "error on close")
490494
}
491495

@@ -497,15 +501,15 @@ func TestBrokenDoubleDatabase(t *testing.T) {
497501
err = reader.Lookup(net.ParseIP("2001:220::"), &result)
498502

499503
expected := newInvalidDatabaseError("the MaxMind DB file's data section contains bad data (float 64 size of 2)")
500-
assert.Equal(t, err, expected)
504+
assert.Equal(t, expected, err)
501505
assert.NoError(t, reader.Close(), "error on close")
502506
}
503507

504508
func TestInvalidNodeCountDatabase(t *testing.T) {
505509
_, err := Open(testFile("GeoIP2-City-Test-Invalid-Node-Count.mmdb"))
506510

507511
expected := newInvalidDatabaseError("the MaxMind DB contains invalid metadata")
508-
assert.Equal(t, err, expected)
512+
assert.Equal(t, expected, err)
509513
}
510514

511515
func TestMissingDatabase(t *testing.T) {
@@ -517,15 +521,15 @@ func TestMissingDatabase(t *testing.T) {
517521
func TestNonDatabase(t *testing.T) {
518522
reader, err := Open("README.md")
519523
assert.Nil(t, reader, "received reader when doing lookups on DB that doesn't exist")
520-
assert.Equal(t, err.Error(), "error opening database: invalid MaxMind DB file")
524+
assert.Equal(t, "error opening database: invalid MaxMind DB file", err.Error())
521525
}
522526

523527
func TestDecodingToNonPointer(t *testing.T) {
524528
reader, _ := Open(testFile("MaxMind-DB-test-decoder.mmdb"))
525529

526530
var recordInterface interface{}
527531
err := reader.Lookup(net.ParseIP("::1.1.1.0"), recordInterface)
528-
assert.Equal(t, err.Error(), "result param must be a pointer")
532+
assert.Equal(t, "result param must be a pointer", err.Error())
529533
assert.NoError(t, reader.Close(), "error on close")
530534
}
531535

@@ -534,7 +538,7 @@ func TestNilLookup(t *testing.T) {
534538

535539
var recordInterface interface{}
536540
err := reader.Lookup(nil, recordInterface)
537-
assert.Equal(t, err.Error(), "IP passed to Lookup cannot be nil")
541+
assert.Equal(t, "IP passed to Lookup cannot be nil", err.Error())
538542
assert.NoError(t, reader.Close(), "error on close")
539543
}
540544

@@ -545,39 +549,39 @@ func TestUsingClosedDatabase(t *testing.T) {
545549
var recordInterface interface{}
546550

547551
err := reader.Lookup(nil, recordInterface)
548-
assert.Equal(t, err.Error(), "cannot call Lookup on a closed database")
552+
assert.Equal(t, "cannot call Lookup on a closed database", err.Error())
549553

550554
_, err = reader.LookupOffset(nil)
551-
assert.Equal(t, err.Error(), "cannot call LookupOffset on a closed database")
555+
assert.Equal(t, "cannot call LookupOffset on a closed database", err.Error())
552556

553557
err = reader.Decode(0, recordInterface)
554-
assert.Equal(t, err.Error(), "cannot call Decode on a closed database")
558+
assert.Equal(t, "cannot call Decode on a closed database", err.Error())
555559
}
556560

557561
func checkMetadata(t *testing.T, reader *Reader, ipVersion uint, recordSize uint) {
558562
metadata := reader.Metadata
559563

560-
assert.Equal(t, metadata.BinaryFormatMajorVersion, uint(2))
564+
assert.Equal(t, uint(2), metadata.BinaryFormatMajorVersion)
561565

562-
assert.Equal(t, metadata.BinaryFormatMinorVersion, uint(0))
566+
assert.Equal(t, uint(0), metadata.BinaryFormatMinorVersion)
563567
assert.IsType(t, uint(0), metadata.BuildEpoch)
564-
assert.Equal(t, metadata.DatabaseType, "Test")
568+
assert.Equal(t, "Test", metadata.DatabaseType)
565569

566570
assert.Equal(t, metadata.Description,
567571
map[string]string{
568572
"en": "Test Database",
569573
"zh": "Test Database Chinese",
570574
})
571-
assert.Equal(t, metadata.IPVersion, ipVersion)
572-
assert.Equal(t, metadata.Languages, []string{"en", "zh"})
575+
assert.Equal(t, ipVersion, metadata.IPVersion)
576+
assert.Equal(t, []string{"en", "zh"}, metadata.Languages)
573577

574578
if ipVersion == 4 {
575-
assert.Equal(t, metadata.NodeCount, uint(164))
579+
assert.Equal(t, uint(164), metadata.NodeCount)
576580
} else {
577-
assert.Equal(t, metadata.NodeCount, uint(416))
581+
assert.Equal(t, uint(416), metadata.NodeCount)
578582
}
579583

580-
assert.Equal(t, metadata.RecordSize, recordSize)
584+
assert.Equal(t, recordSize, metadata.RecordSize)
581585
}
582586

583587
func checkIpv4(t *testing.T, reader *Reader) {
@@ -589,7 +593,7 @@ func checkIpv4(t *testing.T, reader *Reader) {
589593
var result map[string]string
590594
err := reader.Lookup(ip, &result)
591595
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
592-
assert.Equal(t, result, map[string]string{"ip": address})
596+
assert.Equal(t, map[string]string{"ip": address}, result)
593597
}
594598
pairs := map[string]string{
595599
"1.1.1.3": "1.1.1.2",
@@ -609,7 +613,7 @@ func checkIpv4(t *testing.T, reader *Reader) {
609613
var result map[string]string
610614
err := reader.Lookup(ip, &result)
611615
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
612-
assert.Equal(t, result, data)
616+
assert.Equal(t, data, result)
613617
}
614618

615619
for _, address := range []string{"1.1.1.33", "255.254.253.123"} {
@@ -631,7 +635,7 @@ func checkIpv6(t *testing.T, reader *Reader) {
631635
var result map[string]string
632636
err := reader.Lookup(net.ParseIP(address), &result)
633637
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
634-
assert.Equal(t, result, map[string]string{"ip": address})
638+
assert.Equal(t, map[string]string{"ip": address}, result)
635639
}
636640

637641
pairs := map[string]string{
@@ -650,7 +654,7 @@ func checkIpv6(t *testing.T, reader *Reader) {
650654
var result map[string]string
651655
err := reader.Lookup(net.ParseIP(keyAddress), &result)
652656
assert.NoError(t, err, "unexpected error while doing lookup: %v", err)
653-
assert.Equal(t, result, data)
657+
assert.Equal(t, data, result)
654658
}
655659

656660
for _, address := range []string{"1.1.1.33", "255.254.253.123", "89fa::"} {

‎traverse_test.go

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,7 @@ func TestNetworksWithInvalidSearchTree(t *testing.T) {
4545
assert.Nil(t, err)
4646
}
4747
assert.NotNil(t, n.Err(), "no error received when traversing an broken search tree")
48-
assert.Equal(t, n.Err().Error(), "invalid search tree at 128.128.128.128/32")
48+
assert.Equal(t, "invalid search tree at 128.128.128.128/32", n.Err().Error())
4949
}
5050

5151
type networkTest struct {

0 commit comments

Comments
 (0)