Skip to content

Commit 481716c

Browse files
elmacnificooschwald
elmacnifico
authored and
oschwald
committed
use require and simplify equal usage
1 parent 46abb66 commit 481716c

File tree

2 files changed

+42
-40
lines changed

2 files changed

+42
-40
lines changed

‎reader_test.go‎

Lines changed: 39 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -11,14 +11,15 @@ import (
1111
"time"
1212

1313
"github.com/stretchr/testify/assert"
14+
"github.com/stretchr/testify/require"
1415
)
1516

1617
func TestReader(t *testing.T) {
1718
for _, recordSize := range []uint{24, 28, 32} {
1819
for _, ipVersion := range []uint{4, 6} {
1920
fileName := fmt.Sprintf("test-data/test-data/MaxMind-DB-test-ipv%d-%d.mmdb", ipVersion, recordSize)
2021
reader, err := Open(fileName)
21-
assert.Nil(t, err, "unexpected error while opening database: %v", err)
22+
require.Nil(t, err, "unexpected error while opening database: %v", err)
2223
checkMetadata(t, reader, ipVersion, recordSize)
2324

2425
if ipVersion == 4 {
@@ -36,7 +37,7 @@ func TestReaderBytes(t *testing.T) {
3637
fileName := fmt.Sprintf("test-data/test-data/MaxMind-DB-test-ipv%d-%d.mmdb", ipVersion, recordSize)
3738
bytes, _ := ioutil.ReadFile(fileName)
3839
reader, err := FromBytes(bytes)
39-
assert.Nil(t, err, "unexpected error while opening bytes: %v", err)
40+
require.Nil(t, err, "unexpected error while opening bytes: %v", err)
4041

4142
checkMetadata(t, reader, ipVersion, recordSize)
4243

@@ -55,16 +56,16 @@ func TestDecodingToInterface(t *testing.T) {
5556

5657
var recordInterface interface{}
5758
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &recordInterface)
58-
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
59+
require.Nil(t, err, "unexpected error while doing lookup: %v", err)
5960

6061
record := recordInterface.(map[string]interface{})
61-
assert.True(t, assert.ObjectsAreEqual(record["array"], []interface{}{uint64(1), uint64(2), uint64(3)}))
62+
assert.Equal(t, record["array"], []interface{}{uint64(1), uint64(2), uint64(3)})
6263
assert.Equal(t, record["boolean"], true)
63-
assert.True(t, assert.ObjectsAreEqual(record["bytes"], []byte{0x00, 0x00, 0x00, 0x2a}))
64+
assert.Equal(t, record["bytes"], []byte{0x00, 0x00, 0x00, 0x2a})
6465
assert.Equal(t, record["double"], 42.123456)
6566
assert.Equal(t, record["float"], float32(1.1))
6667
assert.Equal(t, record["int32"], -268435456)
67-
assert.ObjectsAreEqual(record["map"],
68+
assert.Equal(t, record["map"],
6869
map[string]interface{}{
6970
"mapX": map[string]interface{}{
7071
"arrayX": []interface{}{uint64(7), uint64(8), uint64(9)},
@@ -77,7 +78,7 @@ func TestDecodingToInterface(t *testing.T) {
7778
assert.Equal(t, record["utf8_string"], "unicode! ☯ - ♫")
7879
bigInt := new(big.Int)
7980
bigInt.SetString("1329227995784915872903807060280344576", 10)
80-
assert.True(t, assert.ObjectsAreEqual(record["uint128"], bigInt))
81+
assert.Equal(t, record["uint128"], bigInt)
8182
}
8283

8384
type TestType struct {
@@ -97,17 +98,17 @@ type TestType struct {
9798

9899
func TestDecoder(t *testing.T) {
99100
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
100-
assert.Nil(t, err)
101+
require.Nil(t, err)
101102

102103
verify := func(result TestType) {
103-
assert.True(t, assert.ObjectsAreEqual(result.Array, []uint{uint(1), uint(2), uint(3)}))
104+
assert.Equal(t, result.Array, []uint{uint(1), uint(2), uint(3)})
104105
assert.Equal(t, result.Boolean, true)
105-
assert.True(t, assert.ObjectsAreEqual(result.Bytes, []byte{0x00, 0x00, 0x00, 0x2a}))
106+
assert.Equal(t, result.Bytes, []byte{0x00, 0x00, 0x00, 0x2a})
106107
assert.Equal(t, result.Double, 42.123456)
107108
assert.Equal(t, result.Float, float32(1.1))
108109
assert.Equal(t, result.Int32, int32(-268435456))
109110

110-
assert.ObjectsAreEqual(result.Map,
111+
assert.Equal(t, result.Map,
111112
map[string]interface{}{
112113
"mapX": map[string]interface{}{
113114
"arrayX": []interface{}{uint64(7), uint64(8), uint64(9)},
@@ -120,7 +121,7 @@ func TestDecoder(t *testing.T) {
120121
assert.Equal(t, result.Utf8String, "unicode! ☯ - ♫")
121122
bigInt := new(big.Int)
122123
bigInt.SetString("1329227995784915872903807060280344576", 10)
123-
assert.True(t, assert.ObjectsAreEqual(&result.Uint128, bigInt))
124+
assert.Equal(t, &result.Uint128, bigInt)
124125
}
125126

126127
{
@@ -155,9 +156,9 @@ func TestStructInterface(t *testing.T) {
155156
var result TestInterface = &TestType{}
156157

157158
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
158-
assert.Nil(t, err)
159+
require.Nil(t, err)
159160

160-
assert.Nil(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
161+
require.Nil(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
161162

162163
assert.Equal(t, result.method(), true)
163164
}
@@ -166,7 +167,7 @@ func TestNonEmptyNilInterface(t *testing.T) {
166167
var result TestInterface
167168

168169
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
169-
assert.Nil(t, err)
170+
require.Nil(t, err)
170171

171172
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
172173
assert.Equal(t, err.Error(), "maxminddb: cannot unmarshal map into type maxminddb.TestInterface")
@@ -191,8 +192,8 @@ func TesValueTypeInterface(t *testing.T) {
191192
result.Boolean = Bool(false)
192193

193194
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
194-
assert.Nil(t, err)
195-
assert.Nil(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
195+
require.Nil(t, err)
196+
require.Nil(t, reader.Lookup(net.ParseIP("::1.1.1.0"), &result))
196197

197198
assert.Equal(t, result.Boolean.true(), true)
198199
}
@@ -236,16 +237,16 @@ func TestComplexStructWithNestingAndPointer(t *testing.T) {
236237
var result TestPointerType
237238

238239
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
239-
assert.Nil(t, err)
240+
require.Nil(t, err)
240241

241-
assert.True(t, assert.ObjectsAreEqual(*result.Array, []uint{uint(1), uint(2), uint(3)}))
242+
assert.Equal(t, *result.Array, []uint{uint(1), uint(2), uint(3)})
242243
assert.Equal(t, *result.Boolean, true)
243-
assert.True(t, assert.ObjectsAreEqual(*result.Bytes, []byte{0x00, 0x00, 0x00, 0x2a}))
244+
assert.Equal(t, *result.Bytes, []byte{0x00, 0x00, 0x00, 0x2a})
244245
assert.Equal(t, *result.Double, 42.123456)
245246
assert.Equal(t, *result.Float, float32(1.1))
246247
assert.Equal(t, *result.Int32, int32(-268435456))
247248

248-
assert.True(t, assert.ObjectsAreEqual(result.Map.MapX.ArrayX, []int{7, 8, 9}))
249+
assert.Equal(t, result.Map.MapX.ArrayX, []int{7, 8, 9})
249250

250251
assert.Equal(t, result.Map.MapX.UTF8StringX, "hello")
251252

@@ -255,18 +256,18 @@ func TestComplexStructWithNestingAndPointer(t *testing.T) {
255256
assert.Equal(t, *result.Utf8String, "unicode! ☯ - ♫")
256257
bigInt := new(big.Int)
257258
bigInt.SetString("1329227995784915872903807060280344576", 10)
258-
assert.True(t, assert.ObjectsAreEqual(result.Uint128, bigInt))
259+
assert.Equal(t, result.Uint128, bigInt)
259260

260261
assert.Nil(t, reader.Close())
261262
}
262263

263264
func TestNestedOffsetDecode(t *testing.T) {
264265
db, err := Open("test-data/test-data/GeoIP2-City-Test.mmdb")
265-
assert.Nil(t, err)
266+
require.Nil(t, err)
266267

267268
off, err := db.LookupOffset(net.ParseIP("81.2.69.142"))
268269
assert.NotEqual(t, off, NotFound)
269-
assert.Nil(t, err)
270+
require.Nil(t, err)
270271

271272
var root struct {
272273
CountryOffset uintptr `maxminddb:"country"`
@@ -301,49 +302,49 @@ func TestNestedOffsetDecode(t *testing.T) {
301302

302303
func TestDecodingUint16IntoInt(t *testing.T) {
303304
reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
304-
assert.Nil(t, err, "unexpected error while opening database: %v", err)
305+
require.Nil(t, err, "unexpected error while opening database: %v", err)
305306

306307
var result struct {
307308
Uint16 int `maxminddb:"uint16"`
308309
}
309310
err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
310-
assert.Nil(t, err)
311+
require.Nil(t, err)
311312

312313
assert.Equal(t, result.Uint16, 100)
313314
}
314315

315316
func TestIpv6inIpv4(t *testing.T) {
316317
reader, err := Open("test-data/test-data/MaxMind-DB-test-ipv4-24.mmdb")
317-
assert.Nil(t, err, "unexpected error while opening database: %v", err)
318+
require.Nil(t, err, "unexpected error while opening database: %v", err)
318319

319320
var result TestType
320321
err = reader.Lookup(net.ParseIP("2001::"), &result)
321322

322323
var emptyResult TestType
323-
assert.True(t, assert.ObjectsAreEqual(result, emptyResult))
324+
assert.Equal(t, result, emptyResult)
324325

325326
expected := errors.New("error looking up '2001::': you attempted to look up an IPv6 address in an IPv4-only database")
326-
assert.True(t, assert.ObjectsAreEqual(err, expected))
327+
assert.Equal(t, err, expected)
327328
assert.Nil(t, reader.Close(), "error on close")
328329
}
329330

330331
func TestBrokenDoubleDatabase(t *testing.T) {
331332
reader, err := Open("test-data/test-data/GeoIP2-City-Test-Broken-Double-Format.mmdb")
332-
assert.Nil(t, err, "unexpected error while opening database: %v", err)
333+
require.Nil(t, err, "unexpected error while opening database: %v", err)
333334

334335
var result interface{}
335336
err = reader.Lookup(net.ParseIP("2001:220::"), &result)
336337

337338
expected := newInvalidDatabaseError("the MaxMind DB file's data section contains bad data (float 64 size of 2)")
338-
assert.True(t, assert.ObjectsAreEqual(err, expected))
339+
assert.Equal(t, err, expected)
339340
assert.Nil(t, reader.Close(), "error on close")
340341
}
341342

342343
func TestInvalidNodeCountDatabase(t *testing.T) {
343344
_, err := Open("test-data/test-data/GeoIP2-City-Test-Invalid-Node-Count.mmdb")
344345

345346
expected := newInvalidDatabaseError("the MaxMind DB contains invalid metadata")
346-
assert.True(t, assert.ObjectsAreEqual(err, expected))
347+
assert.Equal(t, err, expected)
347348
}
348349

349350
func TestMissingDatabase(t *testing.T) {
@@ -385,13 +386,13 @@ func checkMetadata(t *testing.T, reader *Reader, ipVersion uint, recordSize uint
385386
assert.IsType(t, uint(0), metadata.BuildEpoch)
386387
assert.Equal(t, metadata.DatabaseType, "Test")
387388

388-
assert.ObjectsAreEqual( metadata.Description,
389+
assert.Equal(t, metadata.Description,
389390
map[string]string{
390391
"en": "Test Database",
391392
"zh": "Test Database Chinese",
392393
})
393394
assert.Equal(t, metadata.IPVersion, ipVersion)
394-
assert.True(t, assert.ObjectsAreEqual(metadata.Languages, []string{"en", "zh"}))
395+
assert.Equal(t, metadata.Languages, []string{"en", "zh"})
395396

396397
if ipVersion == 4 {
397398
assert.Equal(t, metadata.NodeCount, uint(164))
@@ -411,7 +412,7 @@ func checkIpv4(t *testing.T, reader *Reader) {
411412
var result map[string]string
412413
err := reader.Lookup(ip, &result)
413414
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
414-
assert.True(t, assert.ObjectsAreEqual(result, map[string]string{"ip": address}))
415+
assert.Equal(t, result, map[string]string{"ip": address})
415416
}
416417
pairs := map[string]string{
417418
"1.1.1.3": "1.1.1.2",
@@ -431,7 +432,7 @@ func checkIpv4(t *testing.T, reader *Reader) {
431432
var result map[string]string
432433
err := reader.Lookup(ip, &result)
433434
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
434-
assert.True(t, assert.ObjectsAreEqual(result, data))
435+
assert.Equal(t, result, data)
435436
}
436437

437438
for _, address := range []string{"1.1.1.33", "255.254.253.123"} {
@@ -453,7 +454,7 @@ func checkIpv6(t *testing.T, reader *Reader) {
453454
var result map[string]string
454455
err := reader.Lookup(net.ParseIP(address), &result)
455456
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
456-
assert.True(t, assert.ObjectsAreEqual(result, map[string]string{"ip": address}))
457+
assert.Equal(t, result, map[string]string{"ip": address})
457458
}
458459

459460
pairs := map[string]string{
@@ -472,7 +473,7 @@ func checkIpv6(t *testing.T, reader *Reader) {
472473
var result map[string]string
473474
err := reader.Lookup(net.ParseIP(keyAddress), &result)
474475
assert.Nil(t, err, "unexpected error while doing lookup: %v", err)
475-
assert.True(t, assert.ObjectsAreEqual(result, data))
476+
assert.Equal(t, result, data)
476477
}
477478

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

‎traverse_test.go‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,14 +5,15 @@ import (
55
"testing"
66

77
"github.com/stretchr/testify/assert"
8+
"github.com/stretchr/testify/require"
89
)
910

1011
func TestNetworks(t *testing.T) {
1112
for _, recordSize := range []uint{24, 28, 32} {
1213
for _, ipVersion := range []uint{4, 6} {
1314
fileName := fmt.Sprintf("test-data/test-data/MaxMind-DB-test-ipv%d-%d.mmdb", ipVersion, recordSize)
1415
reader, err := Open(fileName)
15-
assert.Nil(t, err, "unexpected error while opening database: %v", err)
16+
require.Nil(t, err, "unexpected error while opening database: %v", err)
1617
defer reader.Close()
1718

1819
n := reader.Networks()
@@ -33,7 +34,7 @@ func TestNetworks(t *testing.T) {
3334

3435
func TestNetworksWithInvalidSearchTree(t *testing.T) {
3536
reader, err := Open("test-data/test-data/MaxMind-DB-test-broken-search-tree-24.mmdb")
36-
assert.Nil(t, err, "unexpected error while opening database: %v", err)
37+
require.Nil(t, err, "unexpected error while opening database: %v", err)
3738
defer reader.Close()
3839

3940
n := reader.Networks()

0 commit comments

Comments
 (0)