From 06101d134b5e65cb20a642c05aee7000d990f936 Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Tue, 16 Jun 2015 16:52:01 +0100 Subject: [PATCH 1/4] Running goimports --- ipam/allocate.go | 1 + ipam/paxos/paxos.go | 1 + ipam/paxos/paxos_test.go | 3 ++- router/crypto.go | 7 ++++--- router/ethernet_decoder.go | 5 +++-- router/forwarder.go | 5 +++-- router/handshake_test.go | 3 ++- router/mocks_test.go | 3 ++- router/pcap.go | 3 ++- router/peers_test.go | 3 ++- router/udp_sender.go | 5 +++-- 11 files changed, 25 insertions(+), 14 deletions(-) diff --git a/ipam/allocate.go b/ipam/allocate.go index 130380e90a..79fe45dc31 100644 --- a/ipam/allocate.go +++ b/ipam/allocate.go @@ -2,6 +2,7 @@ package ipam import ( "fmt" + "github.com/weaveworks/weave/ipam/address" ) diff --git a/ipam/paxos/paxos.go b/ipam/paxos/paxos.go index a69b91da8a..61fda181ad 100644 --- a/ipam/paxos/paxos.go +++ b/ipam/paxos/paxos.go @@ -2,6 +2,7 @@ package paxos import ( "fmt" + "github.com/weaveworks/weave/router" ) diff --git a/ipam/paxos/paxos_test.go b/ipam/paxos/paxos_test.go index cd704c5cb2..c1d5bfe00f 100644 --- a/ipam/paxos/paxos_test.go +++ b/ipam/paxos/paxos_test.go @@ -2,10 +2,11 @@ package paxos import ( "fmt" - "github.com/weaveworks/weave/router" "math/rand" "testing" "time" + + "github.com/weaveworks/weave/router" ) type TestNode struct { diff --git a/router/crypto.go b/router/crypto.go index 19b0bcfab5..291603d1b7 100644 --- a/router/crypto.go +++ b/router/crypto.go @@ -1,15 +1,16 @@ package router import ( - "code.google.com/p/go-bit/bit" - "code.google.com/p/go.crypto/nacl/box" - "code.google.com/p/go.crypto/nacl/secretbox" "crypto/rand" "crypto/sha256" "encoding/binary" "encoding/gob" "fmt" "sync" + + "code.google.com/p/go-bit/bit" + "code.google.com/p/go.crypto/nacl/box" + "code.google.com/p/go.crypto/nacl/secretbox" ) func GenerateKeyPair() (publicKey, privateKey *[32]byte, err error) { diff --git a/router/ethernet_decoder.go b/router/ethernet_decoder.go index 6588c0adde..297a2011a3 100644 --- a/router/ethernet_decoder.go +++ b/router/ethernet_decoder.go @@ -2,10 +2,11 @@ package router import ( "bytes" - "code.google.com/p/gopacket" - "code.google.com/p/gopacket/layers" "log" "net" + + "code.google.com/p/gopacket" + "code.google.com/p/gopacket/layers" ) type EthernetDecoder struct { diff --git a/router/forwarder.go b/router/forwarder.go index a4cec4720d..802369bd24 100644 --- a/router/forwarder.go +++ b/router/forwarder.go @@ -1,10 +1,11 @@ package router import ( - "code.google.com/p/gopacket" - "code.google.com/p/gopacket/layers" "syscall" "time" + + "code.google.com/p/gopacket" + "code.google.com/p/gopacket/layers" ) type ForwardedFrame struct { diff --git a/router/handshake_test.go b/router/handshake_test.go index a72bf17c7f..1630d34379 100644 --- a/router/handshake_test.go +++ b/router/handshake_test.go @@ -1,8 +1,9 @@ package router import ( - wt "github.com/weaveworks/weave/testing" "testing" + + wt "github.com/weaveworks/weave/testing" ) func TestFieldValidator(t *testing.T) { diff --git a/router/mocks_test.go b/router/mocks_test.go index 674eaa3a71..dc0ec6c372 100644 --- a/router/mocks_test.go +++ b/router/mocks_test.go @@ -6,8 +6,9 @@ package router import ( - wt "github.com/weaveworks/weave/testing" "testing" + + wt "github.com/weaveworks/weave/testing" ) // Add to peers a connection from peers.ourself to p diff --git a/router/pcap.go b/router/pcap.go index 761d4e1df9..07d8b1d99d 100644 --- a/router/pcap.go +++ b/router/pcap.go @@ -1,8 +1,9 @@ package router import ( - "code.google.com/p/gopacket/pcap" "fmt" + + "code.google.com/p/gopacket/pcap" ) type PcapIO struct { diff --git a/router/peers_test.go b/router/peers_test.go index daf1e9444f..bf221642ce 100644 --- a/router/peers_test.go +++ b/router/peers_test.go @@ -2,9 +2,10 @@ package router import ( "fmt" - wt "github.com/weaveworks/weave/testing" "math/rand" "testing" + + wt "github.com/weaveworks/weave/testing" ) // TODO we should also test: diff --git a/router/udp_sender.go b/router/udp_sender.go index 9e91ee0b21..4c264762c6 100644 --- a/router/udp_sender.go +++ b/router/udp_sender.go @@ -1,11 +1,12 @@ package router import ( - "code.google.com/p/gopacket" - "code.google.com/p/gopacket/layers" "log" "net" "syscall" + + "code.google.com/p/gopacket" + "code.google.com/p/gopacket/layers" ) type UDPSender interface { From 21e07c0db954142cca1fa4a505d6dc2eeade15b3 Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Tue, 16 Jun 2015 16:56:22 +0100 Subject: [PATCH 2/4] Running gofmt -s --- ipam/space/space_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ipam/space/space_test.go b/ipam/space/space_test.go index 46a135c509..428349b5d2 100644 --- a/ipam/space/space_test.go +++ b/ipam/space/space_test.go @@ -188,7 +188,7 @@ func TestSpaceFree(t *testing.T) { r = space.biggestFreeRange(entireRange) wt.AssertTrue(t, r.Start == ip("10.0.3.10") && r.Size() == 4, "Wrong space") - wt.AssertEquals(t, space.OwnedRanges(), []address.Range{address.Range{Start: ip("10.0.3.4"), End: ip("10.0.3.24")}}) + wt.AssertEquals(t, space.OwnedRanges(), []address.Range{{Start: ip("10.0.3.4"), End: ip("10.0.3.24")}}) } func TestDonateSimple(t *testing.T) { From cdee7a5d6fc046911784aaa6900c049b689ebb27 Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Tue, 16 Jun 2015 17:05:20 +0100 Subject: [PATCH 3/4] Replacing custom testing helpers with testify, where possible --- common/sched_queue_test.go | 8 +- ipam/allocator_test.go | 46 +++---- ipam/http_test.go | 38 +++--- ipam/ring/ring_test.go | 211 +++++++++++++++++--------------- ipam/space/space_test.go | 151 +++++++++++------------ ipam/testutils_test.go | 35 +++--- nameserver/addrs_test.go | 18 +-- nameserver/cache_test.go | 84 ++++++------- nameserver/dns_test.go | 8 +- nameserver/http_test.go | 41 ++++--- nameserver/mdns_client_test.go | 13 +- nameserver/mdns_server_test.go | 14 +-- nameserver/mdns_test.go | 26 ++-- nameserver/mocks_test.go | 22 ++-- nameserver/server_cache_test.go | 38 +++--- nameserver/server_test.go | 70 +++++------ nameserver/zone_lookup_test.go | 28 ++--- nameserver/zone_test.go | 57 ++++----- net/route_test.go | 20 +-- router/gossip_test.go | 4 +- router/handshake_test.go | 20 +-- router/mocks_test.go | 11 +- router/peers_test.go | 10 +- testing/util.go | 143 +++------------------- 24 files changed, 509 insertions(+), 607 deletions(-) diff --git a/common/sched_queue_test.go b/common/sched_queue_test.go index 32e05f3b20..54a894300d 100644 --- a/common/sched_queue_test.go +++ b/common/sched_queue_test.go @@ -5,7 +5,7 @@ import ( "time" "github.com/benbjohnson/clock" - wt "github.com/weaveworks/weave/testing" + "github.com/stretchr/testify/require" ) // Ensure we can add new calls while forwarding the clock @@ -31,7 +31,7 @@ func TestSchedCallsBasic(t *testing.T) { } t.Logf("Now: %s - calls: %d", clk.Now(), schedQueue.Count()) - wt.AssertEqualInt(t, (int)(schedQueue.Count()), testSecs, "Number of calls") + require.Equal(t, testSecs, (int)(schedQueue.Count()), "Number of calls") } // Ensure we can create a 100 seconds gap in the middle of the time travel @@ -60,7 +60,7 @@ func TestSchedCallsGap(t *testing.T) { } t.Logf("Now: %s - calls: %d", clk.Now(), schedQueue.Count()) - wt.AssertEqualInt(t, (int)(schedQueue.Count()), testSecs-100+1, "Number of calls") + require.Equal(t, testSecs-100+1, (int)(schedQueue.Count()), "Number of calls") } func TestSchedCallsStop(t *testing.T) { @@ -88,5 +88,5 @@ func TestSchedCallsStop(t *testing.T) { } t.Logf("Now: %s - calls: %d", clk.Now(), schedQueue.Count()) - wt.AssertEqualInt(t, (int)(schedQueue.Count()), testSecs/2, "Number of calls") + require.Equal(t, testSecs/2, (int)(schedQueue.Count()), "Number of calls") } diff --git a/ipam/allocator_test.go b/ipam/allocator_test.go index d32e917433..a8b1a78272 100644 --- a/ipam/allocator_test.go +++ b/ipam/allocator_test.go @@ -7,10 +7,10 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" "github.com/weaveworks/weave/common" "github.com/weaveworks/weave/ipam/address" "github.com/weaveworks/weave/router" - wt "github.com/weaveworks/weave/testing" ) const ( @@ -39,12 +39,12 @@ func TestAllocFree(t *testing.T) { alloc.claimRingForTesting() addr1, err := alloc.Allocate(container1, cidr1.HostRange(), nil) - wt.AssertNoErr(t, err) - wt.AssertEqualString(t, addr1.String(), testAddr1, "address") + require.NoError(t, err) + require.Equal(t, testAddr1, addr1.String(), "address") addr2, err := alloc.Allocate(container1, cidr2.HostRange(), nil) - wt.AssertNoErr(t, err) - wt.AssertEqualString(t, addr2.String(), testAddr2, "address") + require.NoError(t, err) + require.Equal(t, testAddr2, addr2.String(), "address") // Ask for another address for a different container and check it's different addr1b, _ := alloc.Allocate(container2, cidr1.HostRange(), nil) @@ -54,20 +54,20 @@ func TestAllocFree(t *testing.T) { // Ask for the first container again and we should get the same addresses again addr1a, _ := alloc.Allocate(container1, cidr1.HostRange(), nil) - wt.AssertEqualString(t, addr1a.String(), testAddr1, "address") + require.Equal(t, testAddr1, addr1a.String(), "address") addr2a, _ := alloc.Allocate(container1, cidr2.HostRange(), nil) - wt.AssertEqualString(t, addr2a.String(), testAddr2, "address") + require.Equal(t, testAddr2, addr2a.String(), "address") // Now delete the first container, and we should get its addresses back - wt.AssertSuccess(t, alloc.Delete(container1)) + require.NoError(t, alloc.Delete(container1)) addr3, _ := alloc.Allocate(container3, cidr1.HostRange(), nil) - wt.AssertEqualString(t, addr3.String(), testAddr1, "address") + require.Equal(t, testAddr1, addr3.String(), "address") addr4, _ := alloc.Allocate(container3, cidr2.HostRange(), nil) - wt.AssertEqualString(t, addr4.String(), testAddr2, "address") + require.Equal(t, testAddr2, addr4.String(), "address") alloc.ContainerDied(container2) alloc.ContainerDied(container3) - wt.AssertEquals(t, alloc.NumFreeAddresses(subnet), address.Offset(spaceSize)) + require.Equal(t, address.Offset(spaceSize), alloc.NumFreeAddresses(subnet)) } func TestBootstrap(t *testing.T) { @@ -144,10 +144,10 @@ func TestAllocatorClaim(t *testing.T) { addr1, _ := address.ParseIP(testAddr1) err := alloc.Claim(container3, addr1, nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) // Check we get this address back if we try an allocate addr3, _ := alloc.Allocate(container3, subnet, nil) - wt.AssertEqualString(t, addr3.String(), testAddr1, "address") + require.Equal(t, testAddr1, addr3.String(), "address") } func (alloc *Allocator) pause() func() { @@ -190,7 +190,7 @@ func TestCancel(t *testing.T) { res2, _ := alloc2.Allocate("bar", subnet, nil) common.Debug.Printf("res2 = %s", res2.String()) if res1 == res2 { - wt.Fatalf(t, "Error: got same ips!") + require.FailNow(t, "Error: got same ips!") } // Now we're going to pause alloc2 and ask alloc1 @@ -215,7 +215,7 @@ func TestCancel(t *testing.T) { cancelChan <- true unpause() if <-doneChan { - wt.Fatalf(t, "Error: got result from Allocate") + require.FailNow(t, "Error: got result from Allocate") } } @@ -235,7 +235,7 @@ func TestGossipShutdown(t *testing.T) { alloc.Shutdown() _, err := alloc.Allocate(container2, subnet, nil) // trying to allocate after shutdown should fail - wt.AssertFalse(t, err == nil, "no address") + require.False(t, err == nil, "no address") CheckAllExpectedMessagesSent(alloc) } @@ -250,10 +250,10 @@ func TestTransfer(t *testing.T) { alloc3 := allocs[2] // This will be 'master' and get the first range _, err := alloc2.Allocate("foo", subnet, nil) - wt.AssertTrue(t, err == nil, "Failed to get address") + require.True(t, err == nil, "Failed to get address") _, err = alloc3.Allocate("bar", subnet, nil) - wt.AssertTrue(t, err == nil, "Failed to get address") + require.True(t, err == nil, "Failed to get address") router.GossipBroadcast(alloc2.Gossip()) router.GossipBroadcast(alloc3.Gossip()) @@ -261,13 +261,13 @@ func TestTransfer(t *testing.T) { router.removePeer(alloc3.ourName) alloc2.Stop() alloc3.Stop() - wt.AssertSuccess(t, alloc1.AdminTakeoverRanges(alloc2.ourName.String())) - wt.AssertSuccess(t, alloc1.AdminTakeoverRanges(alloc3.ourName.String())) + require.NoError(t, alloc1.AdminTakeoverRanges(alloc2.ourName.String())) + require.NoError(t, alloc1.AdminTakeoverRanges(alloc3.ourName.String())) - wt.AssertEquals(t, alloc1.NumFreeAddresses(subnet), address.Offset(1022)) + require.Equal(t, address.Offset(1022), alloc1.NumFreeAddresses(subnet)) _, err = alloc1.Allocate("foo", subnet, nil) - wt.AssertTrue(t, err == nil, "Failed to get address") + require.True(t, err == nil, "Failed to get address") alloc1.Stop() } @@ -388,7 +388,7 @@ func TestAllocatorFuzz(t *testing.T) { if err != nil { panic(err) } - wt.AssertSuccess(t, alloc.Free(res.name, oldAddr)) + require.NoError(t, alloc.Free(res.name, oldAddr)) } // Do a Allocate on an existing container & allocator diff --git a/ipam/http_test.go b/ipam/http_test.go index 10b1581c20..63c4dbabb5 100644 --- a/ipam/http_test.go +++ b/ipam/http_test.go @@ -11,7 +11,7 @@ import ( "time" "github.com/gorilla/mux" - + "github.com/stretchr/testify/require" "github.com/weaveworks/weave/common" "github.com/weaveworks/weave/ipam/address" wt "github.com/weaveworks/weave/testing" @@ -19,8 +19,8 @@ import ( func HTTPPost(t *testing.T, url string) string { resp, err := http.Post(url, "", nil) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusOK, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusOK, resp.StatusCode, "http response") defer resp.Body.Close() body, _ := ioutil.ReadAll(resp.Body) return string(body) @@ -28,7 +28,7 @@ func HTTPPost(t *testing.T, url string) string { func HTTPGet(t *testing.T, url string) string { resp, err := http.Get(url) - wt.AssertNoErr(t, err) + require.NoError(t, err) defer resp.Body.Close() body, _ := ioutil.ReadAll(resp.Body) return string(body) @@ -87,28 +87,28 @@ func TestHttp(t *testing.T) { // Allocate an address in each subnet, and check we got what we expected cidr1a := HTTPPost(t, allocURL(port, testCIDR1, containerID)) - wt.AssertEqualString(t, cidr1a, testAddr1, "address") + require.Equal(t, testAddr1, cidr1a, "address") cidr2a := HTTPPost(t, allocURL(port, testCIDR2, containerID)) - wt.AssertEqualString(t, cidr2a, testAddr2, "address") + require.Equal(t, testAddr2, cidr2a, "address") // Now, make the same requests again to check the operation is idempotent check := HTTPGet(t, allocURL(port, testCIDR1, containerID)) - wt.AssertEqualString(t, check, cidr1a, "address") + require.Equal(t, cidr1a, check, "address") check = HTTPGet(t, allocURL(port, testCIDR2, containerID)) - wt.AssertEqualString(t, check, cidr2a, "address") + require.Equal(t, cidr2a, check, "address") // Ask the http server for a pair of addresses for another container and check they're different cidr1b := HTTPPost(t, allocURL(port, testCIDR1, container2)) - wt.AssertFalse(t, cidr1b == testAddr1, "address") + require.False(t, cidr1b == testAddr1, "address") cidr2b := HTTPPost(t, allocURL(port, testCIDR2, container2)) - wt.AssertFalse(t, cidr2b == testAddr2, "address") + require.False(t, cidr2b == testAddr2, "address") // Now free the first container, and we should get its addresses back when we ask doHTTP("DELETE", identURL(port, containerID)) cidr1c := HTTPPost(t, allocURL(port, testCIDR1, container3)) - wt.AssertEqualString(t, cidr1c, testAddr1, "address") + require.Equal(t, testAddr1, cidr1c, "address") cidr2c := HTTPPost(t, allocURL(port, testCIDR2, container3)) - wt.AssertEqualString(t, cidr2c, testAddr2, "address") + require.Equal(t, testAddr2, cidr2c, "address") // Would like to shut down the http server at the end of this test // but it's complicated. @@ -132,16 +132,16 @@ func TestBadHttp(t *testing.T) { testAddr1 := parts[0] // Verb that's not handled resp, err := doHTTP("HEAD", fmt.Sprintf("http://localhost:%d/ip/%s/%s", port, containerID, testAddr1)) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusNotFound, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusNotFound, resp.StatusCode, "http response") // Mis-spelled URL resp, err = doHTTP("POST", fmt.Sprintf("http://localhost:%d/xip/%s/", port, containerID)) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusNotFound, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusNotFound, resp.StatusCode, "http response") // Malformed URL resp, err = doHTTP("POST", fmt.Sprintf("http://localhost:%d/ip/%s/foo/bar/baz", port, containerID)) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusNotFound, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusNotFound, resp.StatusCode, "http response") } func TestHTTPCancel(t *testing.T) { @@ -180,6 +180,6 @@ func impTestHTTPCancel(t *testing.T) { unpause() res := <-done if res != nil { - wt.Fatalf(t, "Error: Allocate returned non-nil") + require.FailNow(t, "Error: Allocate returned non-nil") } } diff --git a/ipam/ring/ring_test.go b/ipam/ring/ring_test.go index ce63a38ef6..3a4b91f69b 100644 --- a/ipam/ring/ring_test.go +++ b/ipam/ring/ring_test.go @@ -7,10 +7,10 @@ import ( "sort" "testing" + "github.com/stretchr/testify/require" "github.com/weaveworks/weave/common" "github.com/weaveworks/weave/ipam/address" "github.com/weaveworks/weave/router" - wt "github.com/weaveworks/weave/testing" ) var ( @@ -34,26 +34,26 @@ func TestInvariants(t *testing.T) { // Check ring is sorted ring.Entries = []*entry{{Token: dot245, Peer: peer1name}, {Token: dot10, Peer: peer2name}} - wt.AssertTrue(t, ring.checkInvariants() == ErrNotSorted, "Expected error") + require.True(t, ring.checkInvariants() == ErrNotSorted, "Expected error") // Check tokens don't appear twice ring.Entries = []*entry{{Token: dot245, Peer: peer1name}, {Token: dot245, Peer: peer2name}} - wt.AssertTrue(t, ring.checkInvariants() == ErrTokenRepeated, "Expected error") + require.True(t, ring.checkInvariants() == ErrTokenRepeated, "Expected error") // Check tokens are in bounds ring = New(dot10, dot245, peer1name) ring.Entries = []*entry{{Token: start, Peer: peer1name}} - wt.AssertTrue(t, ring.checkInvariants() == ErrTokenOutOfRange, "Expected error") + require.True(t, ring.checkInvariants() == ErrTokenOutOfRange, "Expected error") ring.Entries = []*entry{{Token: end, Peer: peer1name}} - wt.AssertTrue(t, ring.checkInvariants() == ErrTokenOutOfRange, "Expected error") + require.True(t, ring.checkInvariants() == ErrTokenOutOfRange, "Expected error") } func TestInsert(t *testing.T) { ring := New(start, end, peer1name) ring.Entries = []*entry{{Token: start, Peer: peer1name, Free: 255}} - wt.AssertPanic(t, func() { + require.Panics(t, func() { ring.Entries.insert(entry{Token: start, Peer: peer1name}) }) @@ -61,11 +61,11 @@ func TestInsert(t *testing.T) { ring.Entries.insert(entry{Token: dot245, Peer: peer1name}) ring2 := New(start, end, peer1name) ring2.Entries = []*entry{{Token: start, Peer: peer1name, Free: 0}, {Token: dot245, Peer: peer1name}} - wt.AssertEquals(t, ring, ring2) + require.Equal(t, ring2, ring) ring.Entries.insert(entry{Token: dot10, Peer: peer1name}) ring2.Entries = []*entry{{Token: start, Peer: peer1name, Free: 0}, {Token: dot10, Peer: peer1name}, {Token: dot245, Peer: peer1name}} - wt.AssertEquals(t, ring, ring2) + require.Equal(t, ring2, ring) } func TestBetween(t *testing.T) { @@ -76,7 +76,7 @@ func TestBetween(t *testing.T) { // between should return true for everything for i := 1; i <= 255; i++ { ip := ParseIP(fmt.Sprintf("10.0.0.%d", i)) - wt.AssertTrue(t, ring1.Entries.between(ip, 0, 1), "between should be true!") + require.True(t, ring1.Entries.between(ip, 0, 1), "between should be true!") } // Now, construct a ring with entries at +10 and -10 @@ -87,25 +87,25 @@ func TestBetween(t *testing.T) { for i := 10; i <= 244; i++ { ipStr := fmt.Sprintf("10.0.0.%d", i) ip := ParseIP(ipStr) - wt.AssertTrue(t, ring1.Entries.between(ip, 0, 1), + require.True(t, ring1.Entries.between(ip, 0, 1), fmt.Sprintf("Between should be true for %s!", ipStr)) - wt.AssertFalse(t, ring1.Entries.between(ip, 1, 2), + require.False(t, ring1.Entries.between(ip, 1, 2), fmt.Sprintf("Between should be false for %s!", ipStr)) } for i := 0; i <= 9; i++ { ipStr := fmt.Sprintf("10.0.0.%d", i) ip := ParseIP(ipStr) - wt.AssertFalse(t, ring1.Entries.between(ip, 0, 1), + require.False(t, ring1.Entries.between(ip, 0, 1), fmt.Sprintf("Between should be false for %s!", ipStr)) - wt.AssertTrue(t, ring1.Entries.between(ip, 1, 2), + require.True(t, ring1.Entries.between(ip, 1, 2), fmt.Sprintf("Between should be true for %s!", ipStr)) } for i := 245; i <= 255; i++ { ipStr := fmt.Sprintf("10.0.0.%d", i) ip := ParseIP(ipStr) - wt.AssertFalse(t, ring1.Entries.between(ip, 0, 1), + require.False(t, ring1.Entries.between(ip, 0, 1), fmt.Sprintf("Between should be false for %s!", ipStr)) - wt.AssertTrue(t, ring1.Entries.between(ip, 1, 2), + require.True(t, ring1.Entries.between(ip, 1, 2), fmt.Sprintf("Between should be true for %s!", ipStr)) } } @@ -116,32 +116,33 @@ func TestGrantSimple(t *testing.T) { // Claim everything for peer1 ring1.ClaimItAll() - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer1name, Free: 255}}) + require.Equal(t, entries{{Token: start, Peer: peer1name, Free: 255}}, ring1.Entries) // Now grant everything to peer2 ring1.GrantRangeToHost(start, end, peer2name) ring2.Entries = []*entry{{Token: start, Peer: peer2name, Free: 255, Version: 1}} - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + require.Equal(t, ring2.Entries, ring1.Entries) // Now spint back to peer 1 ring2.GrantRangeToHost(dot10, end, peer1name) ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 10, Version: 2}, {Token: dot10, Peer: peer1name, Free: 245}} - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + require.Equal(t, ring2.Entries, ring1.Entries) // And spint back to peer 2 again ring1.GrantRangeToHost(dot245, end, peer2name) - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer2name, Free: 10, Version: 2}, + require.Equal(t, entries{{Token: start, Peer: peer2name, Free: 10, Version: 2}, {Token: dot10, Peer: peer1name, Free: 235, Version: 1}, - {Token: dot245, Peer: peer2name, Free: 10}}) + {Token: dot245, Peer: peer2name, Free: 10}}, ring1.Entries) // Grant range spanning a live token ring1.Entries = []*entry{{Token: start, Peer: peer1name, Free: 10, Version: 2}, {Token: dot10, Peer: peer1name, Free: 235}, {Token: dot245, Peer: peer1name, Free: 10}} ring1.GrantRangeToHost(dot10, end, peer2name) - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer1name, Free: 10, Version: 2}, + require.Equal(t, entries{{Token: start, Peer: peer1name, Free: 10, Version: 2}, {Token: dot10, Peer: peer2name, Free: 235, Version: 1}, - {Token: dot245, Peer: peer2name, Free: 10, Version: 1}}) + {Token: dot245, Peer: peer2name, Free: 10, Version: 1}}, ring1.Entries) + } func TestGrantSplit(t *testing.T) { @@ -151,23 +152,25 @@ func TestGrantSplit(t *testing.T) { // Claim everything for peer1 ring1.Entries = []*entry{{Token: start, Peer: peer1name, Free: 255}} ring2.Merge(*ring1) - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + require.Equal(t, ring2.Entries, ring1.Entries) // Now grant a split range to peer2 ring1.GrantRangeToHost(dot10, dot245, peer2name) - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer1name, Free: 10, Version: 1}, + require.Equal(t, entries{{Token: start, Peer: peer1name, Free: 10, Version: 1}, {Token: dot10, Peer: peer2name, Free: 235}, - {Token: dot245, Peer: peer1name, Free: 10}}) + {Token: dot245, Peer: peer1name, Free: 10}}, ring1.Entries) + ring1.assertInvariants() // Grant range spanning a live token, and inserting a new token ring1.Entries = []*entry{{Token: start, Peer: peer1name, Free: 10, Version: 2}, {Token: dot10, Peer: peer1name, Free: 118}, {Token: middle, Peer: peer1name, Free: 127}} ring1.GrantRangeToHost(dot10, dot245, peer2name) - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer1name, Free: 10, Version: 2}, + require.Equal(t, entries{{Token: start, Peer: peer1name, Free: 10, Version: 2}, {Token: dot10, Peer: peer2name, Free: 118, Version: 1}, {Token: middle, Peer: peer2name, Free: 117, Version: 1}, - {Token: dot245, Peer: peer1name, Free: 10, Version: 0}}) + {Token: dot245, Peer: peer1name, Free: 10, Version: 0}}, ring1.Entries) + ring1.assertInvariants() } @@ -178,23 +181,25 @@ func TestMergeSimple(t *testing.T) { // Claim everything for peer1 ring1.ClaimItAll() ring1.GrantRangeToHost(middle, end, peer2name) - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer1name, Free: 128, Version: 1}, - {Token: middle, Peer: peer2name, Free: 127}}) - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + require.Equal(t, entries{{Token: start, Peer: peer1name, Free: 128, Version: 1}, + {Token: middle, Peer: peer2name, Free: 127}}, ring1.Entries) + + require.Equal(t, ring2.Entries, ring1.Entries) // Now to two different operations on either side, // check we can Merge again ring1.GrantRangeToHost(start, middle, peer2name) ring2.GrantRangeToHost(middle, end, peer1name) - wt.AssertSuccess(t, ring2.Merge(*ring1)) - wt.AssertSuccess(t, ring1.Merge(*ring2)) + require.NoError(t, ring2.Merge(*ring1)) + require.NoError(t, ring1.Merge(*ring2)) + + require.Equal(t, entries{{Token: start, Peer: peer2name, Free: 128, Version: 2}, + {Token: middle, Peer: peer1name, Free: 127, Version: 1}}, ring1.Entries) - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer2name, Free: 128, Version: 2}, - {Token: middle, Peer: peer1name, Free: 127, Version: 1}}) - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + require.Equal(t, ring2.Entries, ring1.Entries) } func TestMergeErrors(t *testing.T) { @@ -202,28 +207,28 @@ func TestMergeErrors(t *testing.T) { ring1 := New(start, end, peer1name) ring2 := New(start, end, peer2name) ring2.Entries = []*entry{{Token: middle, Peer: peer2name}, {Token: start, Peer: peer2name}} - wt.AssertTrue(t, ring1.Merge(*ring2) == ErrNotSorted, "Expected ErrNotSorted") + require.True(t, ring1.Merge(*ring2) == ErrNotSorted, "Expected ErrNotSorted") // Should Merge two rings for different ranges ring2 = New(start, middle, peer2name) ring2.Entries = []*entry{} - wt.AssertTrue(t, ring1.Merge(*ring2) == ErrDifferentSubnets, "Expected ErrDifferentSubnets") + require.True(t, ring1.Merge(*ring2) == ErrDifferentSubnets, "Expected ErrDifferentSubnets") // Cannot Merge newer version of entry I own ring2 = New(start, end, peer2name) ring1.Entries = []*entry{{Token: start, Peer: peer1name}} ring2.Entries = []*entry{{Token: start, Peer: peer1name, Version: 1}} - wt.AssertTrue(t, ring1.Merge(*ring2) == ErrNewerVersion, "Expected ErrNewerVersion") + require.True(t, ring1.Merge(*ring2) == ErrNewerVersion, "Expected ErrNewerVersion") // Cannot Merge two entries with same version but different hosts ring1.Entries = []*entry{{Token: start, Peer: peer1name}} ring2.Entries = []*entry{{Token: start, Peer: peer2name}} - wt.AssertTrue(t, ring1.Merge(*ring2) == ErrInvalidEntry, "Expected ErrInvalidEntry") + require.True(t, ring1.Merge(*ring2) == ErrInvalidEntry, "Expected ErrInvalidEntry") // Cannot Merge an entry into a range I own ring1.Entries = []*entry{{Token: start, Peer: peer1name}} ring2.Entries = []*entry{{Token: middle, Peer: peer2name}} - wt.AssertTrue(t, ring1.Merge(*ring2) == ErrEntryInMyRange, "Expected ErrEntryInMyRange") + require.True(t, ring1.Merge(*ring2) == ErrEntryInMyRange, "Expected ErrEntryInMyRange") } func TestMergeMore(t *testing.T) { @@ -231,7 +236,7 @@ func TestMergeMore(t *testing.T) { ring2 := New(start, end, peer2name) assertRing := func(ring *Ring, entries entries) { - wt.AssertEquals(t, ring.Entries, entries) + require.Equal(t, entries, ring.Entries) } assertRing(ring1, []*entry{}) @@ -243,7 +248,7 @@ func TestMergeMore(t *testing.T) { assertRing(ring2, []*entry{}) // Check the Merge sends it to the other ring - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) assertRing(ring1, []*entry{{Token: start, Peer: peer1name, Free: 255}}) assertRing(ring2, []*entry{{Token: start, Peer: peer1name, Free: 255}}) @@ -252,7 +257,7 @@ func TestMergeMore(t *testing.T) { assertRing(ring1, []*entry{{Token: start, Peer: peer2name, Free: 255, Version: 1}}) assertRing(ring2, []*entry{{Token: start, Peer: peer1name, Free: 255}}) - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) assertRing(ring1, []*entry{{Token: start, Peer: peer2name, Free: 255, Version: 1}}) assertRing(ring2, []*entry{{Token: start, Peer: peer2name, Free: 255, Version: 1}}) @@ -263,14 +268,14 @@ func TestMergeMore(t *testing.T) { assertRing(ring1, []*entry{{Token: start, Peer: peer2name, Free: 255, Version: 1}}) // And Merge back - wt.AssertSuccess(t, ring1.Merge(*ring2)) + require.NoError(t, ring1.Merge(*ring2)) assertRing(ring1, []*entry{{Token: start, Peer: peer2name, Free: 128, Version: 2}, {Token: middle, Peer: peer1name, Free: 127}}) assertRing(ring2, []*entry{{Token: start, Peer: peer2name, Free: 128, Version: 2}, {Token: middle, Peer: peer1name, Free: 127}}) // This should be a no-op - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) assertRing(ring1, []*entry{{Token: start, Peer: peer2name, Free: 128, Version: 2}, {Token: middle, Peer: peer1name, Free: 127}}) assertRing(ring2, []*entry{{Token: start, Peer: peer2name, Free: 128, Version: 2}, @@ -283,19 +288,21 @@ func TestMergeSplit(t *testing.T) { // Claim everything for peer2 ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 255}} - wt.AssertSuccess(t, ring2.Merge(*ring1)) - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + require.NoError(t, ring2.Merge(*ring1)) + require.Equal(t, ring2.Entries, ring1.Entries) // Now grant a split range to peer1 ring2.GrantRangeToHost(dot10, dot245, peer1name) - wt.AssertEquals(t, ring2.Entries, entries{{Token: start, Peer: peer2name, Free: 10, Version: 1}, + require.Equal(t, entries{{Token: start, Peer: peer2name, Free: 10, Version: 1}, {Token: dot10, Peer: peer1name, Free: 235}, - {Token: dot245, Peer: peer2name, Free: 10}}) - wt.AssertSuccess(t, ring1.Merge(*ring2)) - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer2name, Free: 10, Version: 1}, + {Token: dot245, Peer: peer2name, Free: 10}}, ring2.Entries) + + require.NoError(t, ring1.Merge(*ring2)) + require.Equal(t, entries{{Token: start, Peer: peer2name, Free: 10, Version: 1}, {Token: dot10, Peer: peer1name, Free: 235}, - {Token: dot245, Peer: peer2name, Free: 10}}) - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + {Token: dot245, Peer: peer2name, Free: 10}}, ring1.Entries) + + require.Equal(t, ring2.Entries, ring1.Entries) } func TestMergeSplit2(t *testing.T) { @@ -304,19 +311,21 @@ func TestMergeSplit2(t *testing.T) { // Claim everything for peer2 ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 250}, {Token: dot250, Peer: peer2name, Free: 5}} - wt.AssertSuccess(t, ring2.Merge(*ring1)) - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + require.NoError(t, ring2.Merge(*ring1)) + require.Equal(t, ring2.Entries, ring1.Entries) // Now grant a split range to peer1 ring2.GrantRangeToHost(dot10, dot245, peer1name) - wt.AssertEquals(t, ring2.Entries, entries{{Token: start, Peer: peer2name, Free: 10, Version: 1}, + require.Equal(t, entries{{Token: start, Peer: peer2name, Free: 10, Version: 1}, {Token: dot10, Peer: peer1name, Free: 235}, - {Token: dot245, Peer: peer2name, Free: 5}, {Token: dot250, Peer: peer2name, Free: 5}}) - wt.AssertSuccess(t, ring1.Merge(*ring2)) - wt.AssertEquals(t, ring1.Entries, entries{{Token: start, Peer: peer2name, Free: 10, Version: 1}, + {Token: dot245, Peer: peer2name, Free: 5}, {Token: dot250, Peer: peer2name, Free: 5}}, ring2.Entries) + + require.NoError(t, ring1.Merge(*ring2)) + require.Equal(t, entries{{Token: start, Peer: peer2name, Free: 10, Version: 1}, {Token: dot10, Peer: peer1name, Free: 235}, - {Token: dot245, Peer: peer2name, Free: 5}, {Token: dot250, Peer: peer2name, Free: 5}}) - wt.AssertEquals(t, ring1.Entries, ring2.Entries) + {Token: dot245, Peer: peer2name, Free: 5}, {Token: dot250, Peer: peer2name, Free: 5}}, ring1.Entries) + + require.Equal(t, ring2.Entries, ring1.Entries) } // A simple test, very similar to above, but using the marshalling to byte[]s @@ -325,7 +334,7 @@ func TestGossip(t *testing.T) { ring2 := New(start, end, peer2name) assertRing := func(ring *Ring, entries entries) { - wt.AssertEquals(t, ring.Entries, entries) + require.Equal(t, entries, ring.Entries) } assertRing(ring1, []*entry{}) @@ -337,7 +346,7 @@ func TestGossip(t *testing.T) { assertRing(ring2, []*entry{}) // Check the Merge sends it to the other ring - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) assertRing(ring1, []*entry{{Token: start, Peer: peer1name, Free: 255}}) assertRing(ring2, []*entry{{Token: start, Peer: peer1name, Free: 255}}) } @@ -346,38 +355,38 @@ func TestFindFree(t *testing.T) { ring1 := New(start, end, peer1name) _, err := ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertTrue(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") + require.True(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") ring1.Entries = []*entry{{Token: start, Peer: peer1name}} _, err = ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertTrue(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") + require.True(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") // We shouldn't return outselves ring1.ReportFree(map[address.Address]address.Offset{start: 10}) _, err = ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertTrue(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") + require.True(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") ring1.Entries = []*entry{{Token: start, Peer: peer1name, Free: 1}, {Token: middle, Peer: peer1name, Free: 1}} _, err = ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertTrue(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") + require.True(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") ring1.assertInvariants() // We should return others ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 1}} peer, err := ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertSuccess(t, err) - wt.AssertEquals(t, peer, peer2name) + require.NoError(t, err) + require.Equal(t, peer2name, peer) ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 1}, {Token: middle, Peer: peer3name, Free: 1}} peer, err = ring1.ChoosePeerToAskForSpace(start, middle) - wt.AssertSuccess(t, err) - wt.AssertEquals(t, peer, peer2name) + require.NoError(t, err) + require.Equal(t, peer2name, peer) peer, err = ring1.ChoosePeerToAskForSpace(middle, end) - wt.AssertSuccess(t, err) - wt.AssertEquals(t, peer, peer3name) + require.NoError(t, err) + require.Equal(t, peer3name, peer) ring1.assertInvariants() } @@ -387,7 +396,7 @@ func TestReportFree(t *testing.T) { ring1.ClaimItAll() ring1.GrantRangeToHost(middle, end, peer2name) - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) freespace := make(map[address.Address]address.Offset) for _, r := range ring2.OwnedRanges() { @@ -399,7 +408,7 @@ func TestReportFree(t *testing.T) { func TestMisc(t *testing.T) { ring := New(start, end, peer1name) - wt.AssertTrue(t, ring.Empty(), "empty") + require.True(t, ring.Empty(), "empty") ring.ClaimItAll() println(ring.String()) @@ -411,7 +420,7 @@ func TestEmptyGossip(t *testing.T) { ring1.ClaimItAll() // This used to panic, and it shouldn't - wt.AssertSuccess(t, ring1.Merge(*ring2)) + require.NoError(t, ring1.Merge(*ring2)) } func TestMergeOldMessage(t *testing.T) { @@ -419,10 +428,10 @@ func TestMergeOldMessage(t *testing.T) { ring2 := New(start, end, peer2name) ring1.ClaimItAll() - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) ring1.GrantRangeToHost(middle, end, peer1name) - wt.AssertSuccess(t, ring1.Merge(*ring2)) + require.NoError(t, ring1.Merge(*ring2)) } func TestSplitRangeAtBeginning(t *testing.T) { @@ -430,33 +439,32 @@ func TestSplitRangeAtBeginning(t *testing.T) { ring2 := New(start, end, peer2name) ring1.ClaimItAll() - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) ring1.GrantRangeToHost(start, middle, peer2name) - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) } func TestOwnedRange(t *testing.T) { ring1 := New(start, end, peer1name) ring1.ClaimItAll() - wt.AssertEquals(t, ring1.OwnedRanges(), []address.Range{{Start: start, End: end}}) + require.Equal(t, []address.Range{{Start: start, End: end}}, ring1.OwnedRanges()) ring1.GrantRangeToHost(middle, end, peer2name) - wt.AssertEquals(t, ring1.OwnedRanges(), []address.Range{{Start: start, End: middle}}) + require.Equal(t, []address.Range{{Start: start, End: middle}}, ring1.OwnedRanges()) ring2 := New(start, end, peer2name) ring2.Merge(*ring1) - wt.AssertEquals(t, ring2.OwnedRanges(), []address.Range{{Start: middle, End: end}}) + require.Equal(t, []address.Range{{Start: middle, End: end}}, ring2.OwnedRanges()) ring2.Entries = []*entry{{Token: middle, Peer: peer2name}} - wt.AssertEquals(t, ring2.OwnedRanges(), - []address.Range{{Start: start, End: middle}, {Start: middle, End: end}}) + require.Equal(t, []address.Range{{Start: start, End: middle}, {Start: middle, End: end}}, ring2.OwnedRanges()) ring2.Entries = []*entry{{Token: dot10, Peer: peer2name}, {Token: middle, Peer: peer2name}} - wt.AssertEquals(t, ring2.OwnedRanges(), - []address.Range{{Start: start, End: dot10}, {Start: dot10, End: middle}, - {Start: middle, End: end}}) + require.Equal(t, []address.Range{{Start: start, End: dot10}, {Start: dot10, End: middle}, + {Start: middle, End: end}}, ring2.OwnedRanges()) + } func TestTransfer(t *testing.T) { @@ -465,7 +473,7 @@ func TestTransfer(t *testing.T) { ring1.ClaimItAll() ring1.GrantRangeToHost(middle, end, peer2name) ring1.Transfer(peer2name, peer1name) - wt.AssertEquals(t, ring1.OwnedRanges(), []address.Range{{start, middle}, {middle, end}}) + require.Equal(t, []address.Range{{start, middle}, {middle, end}}, ring1.OwnedRanges()) // Second test is what happens when a token exists at the end of a range but is transferred // - does it get resurrected correctly? @@ -474,23 +482,24 @@ func TestTransfer(t *testing.T) { ring1.GrantRangeToHost(middle, end, peer2name) ring1.Transfer(peer2name, peer1name) ring1.GrantRangeToHost(dot10, middle, peer2name) - wt.AssertEquals(t, ring1.OwnedRanges(), []address.Range{{start, dot10}, {middle, end}}) + require.Equal(t, []address.Range{{start, dot10}, {middle, end}}, ring1.OwnedRanges()) } func TestOwner(t *testing.T) { ring1 := New(start, end, peer1name) - wt.AssertTrue(t, ring1.Contains(start), "start should be in ring") - wt.AssertFalse(t, ring1.Contains(end), "end should not be in ring") + require.True(t, ring1.Contains(start), "start should be in ring") + require.False(t, ring1.Contains(end), "end should not be in ring") - wt.AssertEquals(t, ring1.Owner(start), router.UnknownPeerName) + require.Equal(t, router.UnknownPeerName, ring1.Owner(start)) ring1.ClaimItAll() ring1.GrantRangeToHost(middle, end, peer2name) - wt.AssertEquals(t, ring1.Owner(start), peer1name) - wt.AssertEquals(t, ring1.Owner(middle), peer2name) - wt.AssertPanic(t, func() { + require.Equal(t, peer1name, ring1.Owner(start)) + require.Equal(t, peer2name, ring1.Owner(middle)) + require.Panics(t, func() { ring1.Owner(end) }) + } type addressSlice []address.Address @@ -643,7 +652,7 @@ func TestFuzzRingHard(t *testing.T) { // We need to be in a ~converged ring to rmpeer for _, ring := range rings { - wt.AssertSuccess(t, otherRing.Merge(*ring)) + require.NoError(t, otherRing.Merge(*ring)) } common.Debug.Printf("%s: transferring from peer %s", otherPeername, peername) @@ -652,7 +661,7 @@ func TestFuzzRingHard(t *testing.T) { // And now tell everyone about the transfer - rmpeer is // not partition safe for i, ring := range rings { - wt.AssertSuccess(t, ring.Merge(*otherRing)) + require.NoError(t, ring.Merge(*otherRing)) theRanges[i] = ring.OwnedRanges() } } @@ -681,7 +690,7 @@ func TestFuzzRingHard(t *testing.T) { // Now 'gossip' this to a random host (note, note could be same host as above) otherIndex, _, otherRing := randomPeer(-1) common.Debug.Printf("%s: 'Gossiping' to %s", ring.Peer, otherRing.Peer) - wt.AssertSuccess(t, otherRing.Merge(*ring)) + require.NoError(t, otherRing.Merge(*ring)) theRanges[indexWithRanges] = ring.OwnedRanges() theRanges[otherIndex] = otherRing.OwnedRanges() @@ -700,7 +709,7 @@ func TestFuzzRingHard(t *testing.T) { ring1 := ringsWithEntries[rand.Intn(len(ringsWithEntries))] ring2index, _, ring2 := randomPeer(-1) common.Debug.Printf("%s: 'Gossiping' to %s", ring1.Peer, ring2.Peer) - wt.AssertSuccess(t, ring2.Merge(*ring1)) + require.NoError(t, ring2.Merge(*ring1)) theRanges[ring2index] = ring2.OwnedRanges() } diff --git a/ipam/space/space_test.go b/ipam/space/space_test.go index 428349b5d2..1a096fe31f 100644 --- a/ipam/space/space_test.go +++ b/ipam/space/space_test.go @@ -3,6 +3,7 @@ package space import ( "testing" + "github.com/stretchr/testify/require" "github.com/weaveworks/weave/ipam/address" wt "github.com/weaveworks/weave/testing" ) @@ -31,65 +32,65 @@ func (s *Space) NumFreeAddresses() address.Offset { func TestLowlevel(t *testing.T) { a := []address.Address{} a = add(a, 100, 200) - wt.AssertEquals(t, a, []address.Address{100, 200}) - wt.AssertTrue(t, !contains(a, 99), "") - wt.AssertTrue(t, contains(a, 100), "") - wt.AssertTrue(t, contains(a, 199), "") - wt.AssertTrue(t, !contains(a, 200), "") + require.Equal(t, []address.Address{100, 200}, a) + require.True(t, !contains(a, 99), "") + require.True(t, contains(a, 100), "") + require.True(t, contains(a, 199), "") + require.True(t, !contains(a, 200), "") a = add(a, 700, 800) - wt.AssertEquals(t, a, []address.Address{100, 200, 700, 800}) + require.Equal(t, []address.Address{100, 200, 700, 800}, a) a = add(a, 300, 400) - wt.AssertEquals(t, a, []address.Address{100, 200, 300, 400, 700, 800}) + require.Equal(t, []address.Address{100, 200, 300, 400, 700, 800}, a) a = add(a, 400, 500) - wt.AssertEquals(t, a, []address.Address{100, 200, 300, 500, 700, 800}) + require.Equal(t, []address.Address{100, 200, 300, 500, 700, 800}, a) a = add(a, 600, 700) - wt.AssertEquals(t, a, []address.Address{100, 200, 300, 500, 600, 800}) + require.Equal(t, []address.Address{100, 200, 300, 500, 600, 800}, a) a = add(a, 500, 600) - wt.AssertEquals(t, a, []address.Address{100, 200, 300, 800}) + require.Equal(t, []address.Address{100, 200, 300, 800}, a) a = subtract(a, 500, 600) - wt.AssertEquals(t, a, []address.Address{100, 200, 300, 500, 600, 800}) + require.Equal(t, []address.Address{100, 200, 300, 500, 600, 800}, a) a = subtract(a, 600, 700) - wt.AssertEquals(t, a, []address.Address{100, 200, 300, 500, 700, 800}) + require.Equal(t, []address.Address{100, 200, 300, 500, 700, 800}, a) a = subtract(a, 400, 500) - wt.AssertEquals(t, a, []address.Address{100, 200, 300, 400, 700, 800}) + require.Equal(t, []address.Address{100, 200, 300, 400, 700, 800}, a) a = subtract(a, 300, 400) - wt.AssertEquals(t, a, []address.Address{100, 200, 700, 800}) + require.Equal(t, []address.Address{100, 200, 700, 800}, a) a = subtract(a, 700, 800) - wt.AssertEquals(t, a, []address.Address{100, 200}) + require.Equal(t, []address.Address{100, 200}, a) a = subtract(a, 100, 200) - wt.AssertEquals(t, a, []address.Address{}) + require.Equal(t, []address.Address{}, a) s := New() - wt.AssertEquals(t, s.NumFreeAddresses(), address.Offset(0)) + require.Equal(t, address.Offset(0), s.NumFreeAddresses()) ok, got := s.Allocate(address.NewRange(0, 1000)) - wt.AssertFalse(t, ok, "allocate in empty space should fail") + require.False(t, ok, "allocate in empty space should fail") s.Add(100, 100) - wt.AssertEquals(t, s.NumFreeAddresses(), address.Offset(100)) + require.Equal(t, address.Offset(100), s.NumFreeAddresses()) ok, got = s.Allocate(address.NewRange(0, 1000)) - wt.AssertTrue(t, ok && got == 100, "allocate") - wt.AssertEquals(t, s.NumFreeAddresses(), address.Offset(99)) - wt.AssertNoErr(t, s.Claim(150)) - wt.AssertEquals(t, s.NumFreeAddresses(), address.Offset(98)) - wt.AssertNoErr(t, s.Free(100)) - wt.AssertEquals(t, s.NumFreeAddresses(), address.Offset(99)) - wt.AssertErrorInterface(t, s.Free(0), (*error)(nil), "free not allocated") - wt.AssertErrorInterface(t, s.Free(100), (*error)(nil), "double free") + require.True(t, ok && got == 100, "allocate") + require.Equal(t, address.Offset(99), s.NumFreeAddresses()) + require.NoError(t, s.Claim(150)) + require.Equal(t, address.Offset(98), s.NumFreeAddresses()) + require.NoError(t, s.Free(100)) + require.Equal(t, address.Offset(99), s.NumFreeAddresses()) + wt.AssertErrorInterface(t, (*error)(nil), s.Free(0), "free not allocated") + wt.AssertErrorInterface(t, (*error)(nil), s.Free(100), "double free") r, ok := s.Donate(address.NewRange(0, 1000)) - wt.AssertTrue(t, ok && r.Start == 125 && r.Size() == 25, "donate") + require.True(t, ok && r.Start == 125 && r.Size() == 25, "donate") // test Donate when addresses are scarce s = New() r, ok = s.Donate(address.NewRange(0, 1000)) - wt.AssertTrue(t, !ok, "donate on empty space should fail") + require.True(t, !ok, "donate on empty space should fail") s.Add(0, 3) - wt.AssertNoErr(t, s.Claim(0)) - wt.AssertNoErr(t, s.Claim(2)) + require.NoError(t, s.Claim(0)) + require.NoError(t, s.Claim(2)) r, ok = s.Donate(address.NewRange(0, 1000)) - wt.AssertTrue(t, ok && r.Start == 1 && r.End == 2, "donate") + require.True(t, ok && r.Start == 1 && r.End == 2, "donate") r, ok = s.Donate(address.NewRange(0, 1000)) - wt.AssertTrue(t, !ok, "donate should fail") + require.True(t, !ok, "donate should fail") } func TestSpaceAllocate(t *testing.T) { @@ -106,27 +107,27 @@ func TestSpaceAllocate(t *testing.T) { ) space1 := makeSpace(start, size) - wt.AssertEquals(t, space1.NumFreeAddresses(), address.Offset(20)) + require.Equal(t, address.Offset(20), space1.NumFreeAddresses()) space1.assertInvariants() _, addr1 := space1.Allocate(address.NewRange(start, size)) - wt.AssertEqualString(t, addr1.String(), testAddr1, "address") - wt.AssertEquals(t, space1.NumFreeAddresses(), address.Offset(19)) + require.Equal(t, testAddr1, addr1.String(), "address") + require.Equal(t, address.Offset(19), space1.NumFreeAddresses()) space1.assertInvariants() _, addr2 := space1.Allocate(address.NewRange(start, size)) - wt.AssertFalse(t, addr2.String() == testAddr1, "address") - wt.AssertEquals(t, space1.NumFreeAddresses(), address.Offset(18)) - wt.AssertEquals(t, space1.NumFreeAddressesInRange(address.Range{Start: ip(testAddr1), End: ip(testAddrx)}), address.Offset(13)) - wt.AssertEquals(t, space1.NumFreeAddressesInRange(address.Range{Start: ip(testAddr1), End: ip(testAddry)}), address.Offset(18)) + require.False(t, addr2.String() == testAddr1, "address") + require.Equal(t, address.Offset(18), space1.NumFreeAddresses()) + require.Equal(t, address.Offset(13), space1.NumFreeAddressesInRange(address.Range{Start: ip(testAddr1), End: ip(testAddrx)})) + require.Equal(t, address.Offset(18), space1.NumFreeAddressesInRange(address.Range{Start: ip(testAddr1), End: ip(testAddry)})) space1.assertInvariants() space1.Free(addr2) space1.assertInvariants() - wt.AssertErrorInterface(t, space1.Free(addr2), (*error)(nil), "double free") - wt.AssertErrorInterface(t, space1.Free(ip(testAddrx)), (*error)(nil), "address not allocated") - wt.AssertErrorInterface(t, space1.Free(ip(testAddry)), (*error)(nil), "wrong out of range") + wt.AssertErrorInterface(t, (*error)(nil), space1.Free(addr2), "double free") + wt.AssertErrorInterface(t, (*error)(nil), space1.Free(ip(testAddrx)), "address not allocated") + wt.AssertErrorInterface(t, (*error)(nil), space1.Free(ip(testAddry)), "wrong out of range") space1.assertInvariants() } @@ -144,51 +145,51 @@ func TestSpaceFree(t *testing.T) { // Check we are prepared to give up the entire space r := space.biggestFreeRange(entireRange) - wt.AssertTrue(t, r.Start == ip(testAddr1) && r.Size() == 20, "Wrong space") + require.True(t, r.Start == ip(testAddr1) && r.Size() == 20, "Wrong space") for i := 0; i < 20; i++ { ok, _ := space.Allocate(entireRange) - wt.AssertTrue(t, ok, "Failed to get address") + require.True(t, ok, "Failed to get address") } // Check we are full ok, _ := space.Allocate(entireRange) - wt.AssertTrue(t, !ok, "Should have failed to get address") + require.True(t, !ok, "Should have failed to get address") r, ok = space.Donate(entireRange) - wt.AssertTrue(t, r.Size() == 0, "Wrong space") + require.True(t, r.Size() == 0, "Wrong space") // Free in the middle - wt.AssertSuccess(t, space.Free(ip("10.0.3.13"))) + require.NoError(t, space.Free(ip("10.0.3.13"))) r = space.biggestFreeRange(entireRange) - wt.AssertTrue(t, r.Start == ip("10.0.3.13") && r.Size() == 1, "Wrong space") + require.True(t, r.Start == ip("10.0.3.13") && r.Size() == 1, "Wrong space") // Free one at the end - wt.AssertSuccess(t, space.Free(ip("10.0.3.23"))) + require.NoError(t, space.Free(ip("10.0.3.23"))) r = space.biggestFreeRange(entireRange) - wt.AssertTrue(t, r.Start == ip("10.0.3.23") && r.Size() == 1, "Wrong space") + require.True(t, r.Start == ip("10.0.3.23") && r.Size() == 1, "Wrong space") // Now free a few at the end - wt.AssertSuccess(t, space.Free(ip("10.0.3.22"))) - wt.AssertSuccess(t, space.Free(ip("10.0.3.21"))) + require.NoError(t, space.Free(ip("10.0.3.22"))) + require.NoError(t, space.Free(ip("10.0.3.21"))) - wt.AssertEquals(t, space.NumFreeAddresses(), address.Offset(4)) + require.Equal(t, address.Offset(4), space.NumFreeAddresses()) // Now get the biggest free space; should be 3.21 r = space.biggestFreeRange(entireRange) - wt.AssertTrue(t, r.Start == ip("10.0.3.21") && r.Size() == 3, "Wrong space") + require.True(t, r.Start == ip("10.0.3.21") && r.Size() == 3, "Wrong space") // Now free a few in the middle - wt.AssertSuccess(t, space.Free(ip("10.0.3.12"))) - wt.AssertSuccess(t, space.Free(ip("10.0.3.11"))) - wt.AssertSuccess(t, space.Free(ip("10.0.3.10"))) + require.NoError(t, space.Free(ip("10.0.3.12"))) + require.NoError(t, space.Free(ip("10.0.3.11"))) + require.NoError(t, space.Free(ip("10.0.3.10"))) - wt.AssertEquals(t, space.NumFreeAddresses(), address.Offset(7)) + require.Equal(t, address.Offset(7), space.NumFreeAddresses()) // Now get the biggest free space; should be 3.21 r = space.biggestFreeRange(entireRange) - wt.AssertTrue(t, r.Start == ip("10.0.3.10") && r.Size() == 4, "Wrong space") + require.True(t, r.Start == ip("10.0.3.10") && r.Size() == 4, "Wrong space") - wt.AssertEquals(t, space.OwnedRanges(), []address.Range{{Start: ip("10.0.3.4"), End: ip("10.0.3.24")}}) + require.Equal(t, []address.Range{{Start: ip("10.0.3.4"), End: ip("10.0.3.24")}}, space.OwnedRanges()) } func TestDonateSimple(t *testing.T) { @@ -207,10 +208,10 @@ func TestDonateSimple(t *testing.T) { // Empty space set should split in two and give me the second half r, ok := ps1.Donate(address.NewRange(ip(testAddr1), size)) numGivenUp := r.Size() - wt.AssertTrue(t, ok, "Donate result") - wt.AssertEqualString(t, r.Start.String(), "10.0.1.24", "Invalid start") - wt.AssertEquals(t, numGivenUp, address.Offset(size/2)) - wt.AssertEquals(t, ps1.NumFreeAddresses(), address.Offset(size/2)) + require.True(t, ok, "Donate result") + require.Equal(t, "10.0.1.24", r.Start.String(), "Invalid start") + require.Equal(t, address.Offset(size/2), numGivenUp) + require.Equal(t, address.Offset(size/2), ps1.NumFreeAddresses()) // Now check we can give the rest up. count := 0 // count to avoid infinite loop @@ -221,8 +222,8 @@ func TestDonateSimple(t *testing.T) { } numGivenUp += r.Size() } - wt.AssertEquals(t, ps1.NumFreeAddresses(), address.Offset(0)) - wt.AssertEquals(t, numGivenUp, address.Offset(size)) + require.Equal(t, address.Offset(0), ps1.NumFreeAddresses()) + require.Equal(t, address.Offset(size), numGivenUp) } func TestDonateHard(t *testing.T) { @@ -236,27 +237,27 @@ func TestDonateHard(t *testing.T) { spaceset := makeSpace(start, size) for i := address.Offset(0); i < size; i++ { ok, _ := spaceset.Allocate(address.NewRange(start, size)) - wt.AssertTrue(t, ok, "Failed to get IP!") + require.True(t, ok, "Failed to get IP!") } - wt.AssertEquals(t, spaceset.NumFreeAddresses(), address.Offset(0)) + require.Equal(t, address.Offset(0), spaceset.NumFreeAddresses()) // Now free all but the last address // this will force us to split the free list for i := address.Offset(0); i < size-1; i++ { - wt.AssertSuccess(t, spaceset.Free(address.Add(start, i))) + require.NoError(t, spaceset.Free(address.Add(start, i))) } // Now split newRange, ok := spaceset.Donate(address.NewRange(start, size)) - wt.AssertTrue(t, ok, "GiveUpSpace result") - wt.AssertEquals(t, newRange.Start, ip("10.0.1.23")) - wt.AssertEquals(t, newRange.Size(), address.Offset(24)) - wt.AssertEquals(t, spaceset.NumFreeAddresses(), address.Offset(23)) + require.True(t, ok, "GiveUpSpace result") + require.Equal(t, ip("10.0.1.23"), newRange.Start) + require.Equal(t, address.Offset(24), newRange.Size()) + require.Equal(t, address.Offset(23), spaceset.NumFreeAddresses()) //Space set should now have 2 spaces expected := New() expected.Add(start, 23) expected.ours = add(nil, ip("10.0.1.47"), ip("10.0.1.48")) - wt.AssertEquals(t, spaceset, expected) + require.Equal(t, expected, spaceset) } diff --git a/ipam/testutils_test.go b/ipam/testutils_test.go index 6768a12152..b978421f7a 100644 --- a/ipam/testutils_test.go +++ b/ipam/testutils_test.go @@ -7,10 +7,10 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" "github.com/weaveworks/weave/common" "github.com/weaveworks/weave/ipam/address" "github.com/weaveworks/weave/router" - wt "github.com/weaveworks/weave/testing" ) type mockMessage struct { @@ -33,7 +33,7 @@ func toStringArray(messages []mockMessage) []string { type mockGossipComms struct { sync.RWMutex - t *testing.T + *testing.T name string messages []mockMessage } @@ -53,11 +53,11 @@ func (m *mockGossipComms) GossipBroadcast(update router.GossipData) error { defer m.Unlock() buf := []byte{} if len(m.messages) == 0 { - m.Fatalf("%s: Gossip broadcast message unexpected: \n%x", m.name, buf) + require.FailNow(m, fmt.Sprintf("%s: Gossip broadcast message unexpected: \n%x", m.name, buf)) } else if msg := m.messages[0]; msg.dst != router.UnknownPeerName { - m.Fatalf("%s: Expected Gossip message to %s but got broadcast", m.name, msg.dst) + require.FailNow(m, fmt.Sprintf("%s: Expected Gossip message to %s but got broadcast", m.name, msg.dst)) } else if msg.buf != nil && !equalByteBuffer(msg.buf, buf) { - m.Fatalf("%s: Gossip message not sent as expected: \nwant: %x\ngot : %x", m.name, msg.buf, buf) + require.FailNow(m, fmt.Sprintf("%s: Gossip message not sent as expected: \nwant: %x\ngot : %x", m.name, msg.buf, buf)) } else { // Swallow this message m.messages = m.messages[1:] @@ -77,24 +77,19 @@ func equalByteBuffer(a, b []byte) bool { return true } -func (m *mockGossipComms) Fatalf(format string, args ...interface{}) { - // this sometimes hangs: wt.Fatalf(m.t, args...) - panic(fmt.Sprintf(format, args...)) -} - func (m *mockGossipComms) GossipUnicast(dstPeerName router.PeerName, buf []byte) error { m.Lock() defer m.Unlock() if len(m.messages) == 0 { - m.Fatalf("%s: Gossip message to %s unexpected: \n%s", m.name, dstPeerName, buf) + require.FailNow(m, fmt.Sprintf("%s: Gossip message to %s unexpected: \n%s", m.name, dstPeerName, buf)) } else if msg := m.messages[0]; msg.dst == router.UnknownPeerName { - m.Fatalf("%s: Expected Gossip broadcast message but got dest %s", m.name, dstPeerName) + require.FailNow(m, fmt.Sprintf("%s: Expected Gossip broadcast message but got dest %s", m.name, dstPeerName)) } else if msg.dst != dstPeerName { - m.Fatalf("%s: Expected Gossip message to %s but got dest %s", m.name, msg.dst, dstPeerName) + require.FailNow(m, fmt.Sprintf("%s: Expected Gossip message to %s but got dest %s", m.name, msg.dst, dstPeerName)) } else if buf[0] != msg.msgType { - m.Fatalf("%s: Expected Gossip message of type %d but got type %d", m.name, msg.msgType, buf[0]) + require.FailNow(m, fmt.Sprintf("%s: Expected Gossip message of type %d but got type %d", m.name, msg.msgType, buf[0])) } else if msg.buf != nil && !equalByteBuffer(msg.buf, buf[1:]) { - m.Fatalf("%s: Gossip message not sent as expected: \nwant: %x\ngot : %x", m.name, msg.buf, buf[1:]) + require.FailNow(m, fmt.Sprintf("%s: Gossip message not sent as expected: \nwant: %x\ngot : %x", m.name, msg.buf, buf[1:])) } else { // Swallow this message m.messages = m.messages[1:] @@ -122,7 +117,7 @@ func CheckAllExpectedMessagesSent(allocs ...*Allocator) { m := alloc.gossip.(*mockGossipComms) m.RLock() if len(m.messages) > 0 { - wt.Fatalf(m.t, "%s: Gossip message(s) not sent as expected: \n%x", m.name, m.messages) + require.FailNow(m, fmt.Sprintf("%s: Gossip message(s) not sent as expected: \n%x", m.name, m.messages)) } m.RUnlock() } @@ -147,7 +142,7 @@ func makeAllocator(name string, cidrStr string, quorum uint) (*Allocator, addres func makeAllocatorWithMockGossip(t *testing.T, name string, universeCIDR string, quorum uint) (*Allocator, address.Range) { alloc, subnet := makeAllocator(name, universeCIDR, quorum) - gossip := &mockGossipComms{t: t, name: name} + gossip := &mockGossipComms{T: t, name: name} alloc.SetInterfaces(gossip) alloc.Start() return alloc, subnet @@ -177,14 +172,14 @@ func AssertSent(t *testing.T, ch <-chan bool) { case <-ch: // This case is ok case <-timeout: - wt.Fatalf(t, "Nothing sent on channel") + require.FailNow(t, "Nothing sent on channel") } } func AssertNothingSent(t *testing.T, ch <-chan bool) { select { case val := <-ch: - wt.Fatalf(t, "Unexpected value on channel: %t", val) + require.FailNow(t, fmt.Sprintf("Unexpected value on channel: %v", val)) default: // no message received } @@ -193,7 +188,7 @@ func AssertNothingSent(t *testing.T, ch <-chan bool) { func AssertNothingSentErr(t *testing.T, ch <-chan error) { select { case val := <-ch: - wt.Fatalf(t, "Unexpected value on channel: %t", val) + require.FailNow(t, fmt.Sprintf("Unexpected value on channel: %v", val)) default: // no message received } diff --git a/nameserver/addrs_test.go b/nameserver/addrs_test.go index 1c09d73a4c..81392cdca6 100644 --- a/nameserver/addrs_test.go +++ b/nameserver/addrs_test.go @@ -4,8 +4,8 @@ import ( "net" "testing" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) func TestAddrs(t *testing.T) { @@ -13,20 +13,20 @@ func TestAddrs(t *testing.T) { Info.Println("TestAddrs starting") ip, err := addrToIPv4("10.13.12.11") - wt.AssertNoErr(t, err) - wt.AssertTrue(t, net.ParseIP("10.13.12.11").Equal(ip.toNetIP()), "IP") + require.NoError(t, err) + require.True(t, net.ParseIP("10.13.12.11").Equal(ip.toNetIP()), "IP") ip, err = raddrToIPv4("11.12.13.10.in-addr.arpa.") - wt.AssertNoErr(t, err) - wt.AssertTrue(t, net.ParseIP("10.13.12.11").Equal(ip.toNetIP()), "IP") + require.NoError(t, err) + require.True(t, net.ParseIP("10.13.12.11").Equal(ip.toNetIP()), "IP") // some malformed addresses ip, err = addrToIPv4("10.13.12") - wt.AssertTrue(t, err != nil, "when parsing malformed address") + require.True(t, err != nil, "when parsing malformed address") ip, err = addrToIPv4("10.13.AA.12") - wt.AssertTrue(t, err != nil, "when parsing malformed address") + require.True(t, err != nil, "when parsing malformed address") ip, err = raddrToIPv4("11.12.13.10.in-axxx.arpa.") - wt.AssertTrue(t, err != nil, "when parsing malformed address") + require.True(t, err != nil, "when parsing malformed address") ip, err = raddrToIPv4("11.12.13.10.in-addr") - wt.AssertTrue(t, err != nil, "when parsing malformed address") + require.True(t, err != nil, "when parsing malformed address") } diff --git a/nameserver/cache_test.go b/nameserver/cache_test.go index 5182fcca6f..8f230368f4 100644 --- a/nameserver/cache_test.go +++ b/nameserver/cache_test.go @@ -8,8 +8,8 @@ import ( "github.com/benbjohnson/clock" "github.com/miekg/dns" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) // Check that the cache keeps its intended capacity constant @@ -20,7 +20,7 @@ func TestCacheLength(t *testing.T) { const cacheLen = 128 l, err := NewCache(cacheLen, nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) insTime := time.Now() @@ -42,7 +42,7 @@ func TestCacheLength(t *testing.T) { l.Put(questionMsg, reply, 0, 0) } - wt.AssertEqualInt(t, l.Len(), cacheLen, "cache length") + require.Equal(t, cacheLen, l.Len(), "cache length") minExpectedTime := insTime.Add(time.Duration(cacheLen) * time.Second) t.Logf("Checking all remaining entries expire after insert_time + %d secs='%s'", cacheLen, minExpectedTime) @@ -64,7 +64,7 @@ func TestCacheEntries(t *testing.T) { clk := clock.NewMock() l, err := NewCache(cacheLen, clk) - wt.AssertNoErr(t, err) + require.NoError(t, err) questionMsg := new(dns.Msg) questionMsg.SetQuestion("some.name", dns.TypeA) @@ -74,14 +74,14 @@ func TestCacheEntries(t *testing.T) { t.Logf("Trying to get a name") resp, err := l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) + require.NoError(t, err) if resp != nil { t.Logf("Got\n%s", resp) t.Fatalf("ERROR: Did not expect a reponse from Get() yet") } t.Logf("Trying to get it again") resp, err = l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) + require.NoError(t, err) if resp != nil { t.Logf("Got\n%s", resp) t.Fatalf("ERROR: Did not expect a reponse from Get() yet") @@ -94,26 +94,26 @@ func TestCacheEntries(t *testing.T) { t.Logf("Checking we can Get() the reply now") resp, err = l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) - wt.AssertTrue(t, resp != nil, "reponse from Get()") + require.NoError(t, err) + require.True(t, resp != nil, "reponse from Get()") t.Logf("Received '%s'", resp.Answer[0]) - wt.AssertType(t, resp.Answer[0], (*dns.A)(nil), "DNS record") + require.IsType(t, (*dns.A)(nil), resp.Answer[0], "DNS record") ttlGet1 := resp.Answer[0].Header().Ttl clk.Add(time.Duration(1) * time.Second) t.Logf("Checking that a second Get(), after 1 second, gets the same result, but with reduced TTL") resp, err = l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) - wt.AssertTrue(t, resp != nil, "reponse from a second Get()") + require.NoError(t, err) + require.True(t, resp != nil, "reponse from a second Get()") t.Logf("Received '%s'", resp.Answer[0]) - wt.AssertType(t, resp.Answer[0], (*dns.A)(nil), "DNS record") + require.IsType(t, (*dns.A)(nil), resp.Answer[0], "DNS record") ttlGet2 := resp.Answer[0].Header().Ttl - wt.AssertEqualInt(t, int(ttlGet1-ttlGet2), 1, "TTL difference") + require.Equal(t, 1, int(ttlGet1-ttlGet2), "TTL difference") clk.Add(time.Duration(DefaultLocalTTL) * time.Second) t.Logf("Checking that a third Get(), after %d second, gets no result", DefaultLocalTTL) resp, err = l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) + require.NoError(t, err) if resp != nil { t.Logf("Got\n%s", resp) t.Fatalf("ERROR: Did NOT expect a reponse from the second Get()") @@ -125,13 +125,13 @@ func TestCacheEntries(t *testing.T) { l.Put(questionMsg, replyTemp, nullTTL, 0) lenBefore := l.Len() l.Remove(question) - wt.AssertEqualInt(t, l.Len(), lenBefore-1, "cache length") + require.Equal(t, lenBefore-1, l.Len(), "cache length") l.Remove(question) // do it again: should have no effect... - wt.AssertEqualInt(t, l.Len(), lenBefore-1, "cache length") + require.Equal(t, lenBefore-1, l.Len(), "cache length") resp, err = l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) - wt.AssertTrue(t, resp == nil, "reponse from the Get() after a Remove()") + require.NoError(t, err) + require.True(t, resp == nil, "reponse from the Get() after a Remove()") t.Logf("Inserting a two replies for the same query") records = []ZoneRecord{Record{"some.name", net.ParseIP("10.0.1.2"), 0, 0, 0}} @@ -144,32 +144,32 @@ func TestCacheEntries(t *testing.T) { t.Logf("Checking we get the last one...") resp, err = l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) - wt.AssertTrue(t, resp != nil, "reponse from the Get()") + require.NoError(t, err) + require.True(t, resp != nil, "reponse from the Get()") t.Logf("Received '%s'", resp.Answer[0]) - wt.AssertType(t, resp.Answer[0], (*dns.A)(nil), "DNS record") - wt.AssertEqualString(t, resp.Answer[0].(*dns.A).A.String(), "10.0.1.3", "IP address") - wt.AssertEqualInt(t, int(resp.Answer[0].Header().Ttl), int(DefaultLocalTTL), "TTL") + require.IsType(t, (*dns.A)(nil), resp.Answer[0], "DNS record") + require.Equal(t, "10.0.1.3", resp.Answer[0].(*dns.A).A.String(), "IP address") + require.Equal(t, int(DefaultLocalTTL), int(resp.Answer[0].Header().Ttl), "TTL") clk.Add(time.Duration(DefaultLocalTTL-1) * time.Second) resp, err = l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) - wt.AssertTrue(t, resp != nil, "reponse from the Get()") + require.NoError(t, err) + require.True(t, resp != nil, "reponse from the Get()") t.Logf("Received '%s'", resp.Answer[0]) - wt.AssertType(t, resp.Answer[0], (*dns.A)(nil), "DNS record") - wt.AssertEqualString(t, resp.Answer[0].(*dns.A).A.String(), "10.0.1.3", "IP address") - wt.AssertEqualInt(t, int(resp.Answer[0].Header().Ttl), 1, "TTL") + require.IsType(t, (*dns.A)(nil), resp.Answer[0], "DNS record") + require.Equal(t, "10.0.1.3", resp.Answer[0].(*dns.A).A.String(), "IP address") + require.Equal(t, 1, int(resp.Answer[0].Header().Ttl), "TTL") t.Logf("Checking we get empty replies when they are expired...") lenBefore = l.Len() clk.Add(time.Duration(DefaultLocalTTL) * time.Second) resp, err = l.Get(questionMsg, minUDPSize) - wt.AssertNoErr(t, err) + require.NoError(t, err) if resp != nil { t.Logf("Got\n%s", resp.Answer[0]) t.Fatalf("ERROR: Did NOT expect a reponse from the Get()") } - wt.AssertEqualInt(t, l.Len(), lenBefore-1, "cache length (after getting an expired entry)") + require.Equal(t, lenBefore-1, l.Len(), "cache length (after getting an expired entry)") questionMsg2 := new(dns.Msg) questionMsg2.SetQuestion("some.other.name", dns.TypeA) @@ -178,8 +178,8 @@ func TestCacheEntries(t *testing.T) { t.Logf("Trying to Get() a name") resp, err = l.Get(questionMsg2, minUDPSize) - wt.AssertNoErr(t, err) - wt.AssertNil(t, resp, "reponse from Get() yet") + require.NoError(t, err) + require.Nil(t, resp, "reponse from Get() yet") t.Logf("Checking that an Remove() between Get() and Put() does not break things") records = []ZoneRecord{Record{"some.name", net.ParseIP("10.0.9.9"), 0, 0, 0}} @@ -187,8 +187,8 @@ func TestCacheEntries(t *testing.T) { l.Remove(question2) l.Put(questionMsg2, replyTemp2, nullTTL, 0) resp, err = l.Get(questionMsg2, minUDPSize) - wt.AssertNoErr(t, err) - wt.AssertNotNil(t, resp, "reponse from Get()") + require.NoError(t, err) + require.NotNil(t, resp, "reponse from Get()") questionMsg3 := new(dns.Msg) questionMsg3.SetQuestion("some.other.name", dns.TypeA) @@ -198,8 +198,8 @@ func TestCacheEntries(t *testing.T) { t.Logf("Checking that a entry with CacheNoLocalReplies return an error") l.Put(questionMsg3, nil, DefaultLocalTTL, CacheNoLocalReplies) resp, err = l.Get(questionMsg3, minUDPSize) - wt.AssertNil(t, resp, "Get() response with CacheNoLocalReplies") - wt.AssertTrue(t, err == errNoLocalReplies, "Get() error with CacheNoLocalReplies") + require.Nil(t, resp, "Get() response with CacheNoLocalReplies") + require.True(t, err == errNoLocalReplies, "Get() error with CacheNoLocalReplies") t.Logf("Checking that more Put's do not make the negative TTL longer") clk.Add(time.Duration(DefaultLocalTTL/2) * time.Second) @@ -209,22 +209,22 @@ func TestCacheEntries(t *testing.T) { clk.Add(time.Duration(1) * time.Second) l.Put(questionMsg3, nil, DefaultLocalTTL, CacheNoLocalReplies) resp, err = l.Get(questionMsg3, minUDPSize) - wt.AssertNil(t, resp, "Get() response with CacheNoLocalReplies") - wt.AssertTrue(t, err == errNoLocalReplies, "Get() error with CacheNoLocalReplies") + require.Nil(t, resp, "Get() response with CacheNoLocalReplies") + require.True(t, err == errNoLocalReplies, "Get() error with CacheNoLocalReplies") clk.Add(time.Duration(DefaultLocalTTL/2) * time.Second) t.Logf("Checking that we get an expired response after %f seconds", DefaultLocalTTL) clk.Add(time.Second * time.Duration(DefaultLocalTTL+1)) t.Logf("Checking that we get an expired response after %d seconds", DefaultLocalTTL) resp, err = l.Get(questionMsg3, minUDPSize) - wt.AssertNil(t, resp, "expired Get() response with CacheNoLocalReplies") - wt.AssertNil(t, err, "expired Get() error with CacheNoLocalReplies") + require.Nil(t, resp, "expired Get() response with CacheNoLocalReplies") + require.Nil(t, err, "expired Get() error with CacheNoLocalReplies") l.Remove(question3) t.Logf("Checking that Put&Get with CacheNoLocalReplies with a Remove in the middle returns nothing") l.Put(questionMsg3, nil, nullTTL, CacheNoLocalReplies) l.Remove(question3) resp, err = l.Get(questionMsg3, minUDPSize) - wt.AssertNil(t, resp, "Get() reponse with CacheNoLocalReplies") - wt.AssertNil(t, err, "Get() error with CacheNoLocalReplies") + require.Nil(t, resp, "Get() reponse with CacheNoLocalReplies") + require.Nil(t, err, "Get() error with CacheNoLocalReplies") } diff --git a/nameserver/dns_test.go b/nameserver/dns_test.go index 21fd22c5bd..3c46da41f1 100644 --- a/nameserver/dns_test.go +++ b/nameserver/dns_test.go @@ -5,8 +5,8 @@ import ( "testing" "github.com/miekg/dns" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) // Check that we can prune an answer @@ -29,11 +29,11 @@ func TestPrune(t *testing.T) { reply.Answer[0].Header().Ttl = DefaultLocalTTL pruned := pruneAnswers(reply.Answer, 1) - wt.AssertEqualInt(t, len(pruned), 1, "wrong number of answers") + require.Equal(t, 1, len(pruned), "wrong number of answers") pruned = pruneAnswers(reply.Answer, 2) - wt.AssertEqualInt(t, len(pruned), 2, "wrong number of answers") + require.Equal(t, 2, len(pruned), "wrong number of answers") pruned = pruneAnswers(reply.Answer, 0) - wt.AssertEqualInt(t, len(pruned), len(records), "wrong number of answers") + require.Equal(t, len(records), len(pruned), "wrong number of answers") } diff --git a/nameserver/http_test.go b/nameserver/http_test.go index 6e8b3ec0bd..18e26b1ba3 100644 --- a/nameserver/http_test.go +++ b/nameserver/http_test.go @@ -8,6 +8,7 @@ import ( "strings" "testing" + "github.com/stretchr/testify/require" wt "github.com/weaveworks/weave/testing" ) @@ -28,9 +29,9 @@ func TestHttp(t *testing.T) { ) zone, err := NewZoneDb(ZoneConfig{Domain: testDomain}) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = zone.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) defer zone.Stop() httpListener, err := net.Listen("tcp", ":0") @@ -49,13 +50,13 @@ func TestHttp(t *testing.T) { addrURL := fmt.Sprintf("http://localhost:%d/name/%s/%s", port, containerID, addrParts[0]) resp, err := genForm("PUT", addrURL, url.Values{"fqdn": {successTestName}, "local_ip": {dockerIP}, "routing_prefix": {addrParts[1]}}) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusOK, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusOK, resp.StatusCode, "http response") // Check that the address is now there. ip, _, _ := net.ParseCIDR(testAddr1) foundIP, err := zone.LookupName(successTestName) - wt.AssertNoErr(t, err) + require.NoError(t, err) if !foundIP[0].IP().Equal(ip) { t.Fatalf("Unexpected result for %s: received %s, expected %s", successTestName, foundIP, ip) } @@ -63,29 +64,29 @@ func TestHttp(t *testing.T) { // Adding exactly the same address should be OK resp, err = genForm("PUT", addrURL, url.Values{"fqdn": {successTestName}, "local_ip": {dockerIP}, "routing_prefix": {addrParts[1]}}) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusOK, "http success response for duplicate add") + require.NoError(t, err) + require.Equal(t, http.StatusOK, resp.StatusCode, "http success response for duplicate add") // Now try adding the same address again with a different ident -- // again should be fine otherURL := fmt.Sprintf("http://localhost:%d/name/%s/%s", port, "other", addrParts[0]) resp, err = genForm("PUT", otherURL, url.Values{"fqdn": {successTestName}, "local_ip": {dockerIP}, "routing_prefix": {addrParts[1]}}) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusOK, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusOK, resp.StatusCode, "http response") // Adding a new IP for the same name should be OK addrParts2 := strings.Split(testAddr2, "/") addrURL2 := fmt.Sprintf("http://localhost:%d/name/%s/%s", port, containerID, addrParts2[0]) resp, err = genForm("PUT", addrURL2, url.Values{"fqdn": {successTestName}, "local_ip": {dockerIP}, "routing_prefix": {addrParts2[1]}}) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusOK, "http success response for second IP") + require.NoError(t, err) + require.Equal(t, http.StatusOK, resp.StatusCode, "http success response for second IP") // Check that we can get two IPs for that name ip2, _, _ := net.ParseCIDR(testAddr2) foundIP, err = zone.LookupName(successTestName) - wt.AssertNoErr(t, err) + require.NoError(t, err) if len(foundIP) != 2 { t.Logf("IPs found: %s", foundIP) t.Fatalf("Unexpected result length: received %d responses", len(foundIP)) @@ -101,28 +102,28 @@ func TestHttp(t *testing.T) { // Delete the address resp, err = genForm("DELETE", addrURL, nil) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusOK, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusOK, resp.StatusCode, "http response") // Check that the address is still resolvable. x, err := zone.LookupName(successTestName) t.Logf("Got %s", x) - wt.AssertNoErr(t, err) + require.NoError(t, err) // Delete the address record mentioning the other container resp, err = genForm("DELETE", otherURL, nil) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusOK, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusOK, resp.StatusCode, "http response") // Delete the second IP resp, err = genForm("DELETE", addrURL2, nil) - wt.AssertNoErr(t, err) - wt.AssertStatus(t, resp.StatusCode, http.StatusOK, "http response") + require.NoError(t, err) + require.Equal(t, http.StatusOK, resp.StatusCode, "http response") // Check that the address is gone x, err = zone.LookupName(successTestName) t.Logf("Got %s", x) - wt.AssertErrorType(t, err, (*LookupError)(nil), "fully-removed address") + wt.AssertErrorType(t, (*LookupError)(nil), err, "fully-removed address") // Would like to shut down the http server at the end of this test // but it's complicated. diff --git a/nameserver/mdns_client_test.go b/nameserver/mdns_client_test.go index 89d23757e6..11f0bc2d66 100644 --- a/nameserver/mdns_client_test.go +++ b/nameserver/mdns_client_test.go @@ -7,6 +7,7 @@ import ( "time" "github.com/miekg/dns" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" wt "github.com/weaveworks/weave/testing" ) @@ -85,9 +86,9 @@ func setup(t *testing.T) (*MDNSClient, *dns.Server, error) { } mdnsClient, err := NewMDNSClient() - wt.AssertNoErr(t, err) + require.NoError(t, err) err = mdnsClient.Start(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) return mdnsClient, server, err } @@ -111,7 +112,7 @@ func (c *testContext) checkResponse(t *testing.T, channelOk bool, resp *Response c.channel = nil return } - wt.AssertNoErr(t, resp.err) + require.NoError(t, resp.err) log.Printf("Got address response %s addr %s", resp.Name(), resp.IP()) c.receivedAddr = resp.IP() c.receivedCount++ @@ -182,16 +183,16 @@ func TestAsLookup(t *testing.T) { defer server.Shutdown() ips, err := mdnsClient.LookupName(successTestName) - wt.AssertNoErr(t, err) + require.NoError(t, err) if !testAddr.Equal(ips[0].IP()) { t.Fatalf("Returned address incorrect %s", ips) } ips, err = mdnsClient.LookupName("foo.example.com.") - wt.AssertErrorType(t, err, (*LookupError)(nil), "unknown hostname") + wt.AssertErrorType(t, (*LookupError)(nil), err, "unknown hostname") names, err := mdnsClient.LookupInaddr(testInAddr) - wt.AssertNoErr(t, err) + require.NoError(t, err) if !(successTestName == names[0].Name()) { t.Fatalf("Expected name %s, got %s", successTestName, names) } diff --git a/nameserver/mdns_server_test.go b/nameserver/mdns_server_test.go index 29b72cefe4..ecfd2681a6 100644 --- a/nameserver/mdns_server_test.go +++ b/nameserver/mdns_server_test.go @@ -6,8 +6,8 @@ import ( "time" "github.com/miekg/dns" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) func TestServerSimpleQuery(t *testing.T) { @@ -22,9 +22,9 @@ func TestServerSimpleQuery(t *testing.T) { mzone := newMockedZoneWithRecords([]ZoneRecord{testRecord1, testRecord2}) mdnsServer, err := NewMDNSServer(mzone, true, DefaultLocalTTL) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = mdnsServer.Start(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) defer mdnsServer.Stop() var receivedAddrs []net.IP @@ -34,7 +34,7 @@ func TestServerSimpleQuery(t *testing.T) { // Implement a minimal listener for responses multicast, err := LinkLocalMulticastListener(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) handleMDNS := func(w dns.ResponseWriter, r *dns.Msg) { // Only handle responses here @@ -56,12 +56,12 @@ func TestServerSimpleQuery(t *testing.T) { m.SetQuestion(name, querytype) m.RecursionDesired = false buf, err := m.Pack() - wt.AssertNoErr(t, err) + require.NoError(t, err) conn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero, Port: 0}) - wt.AssertNoErr(t, err) + require.NoError(t, err) Debug.Printf("Sending UDP packet to %s", ipv4Addr) _, err = conn.WriteTo(buf, ipv4Addr) - wt.AssertNoErr(t, err) + require.NoError(t, err) Debug.Printf("Waiting for response") for { diff --git a/nameserver/mdns_test.go b/nameserver/mdns_test.go index 3127d3c4fb..4cdae43001 100644 --- a/nameserver/mdns_test.go +++ b/nameserver/mdns_test.go @@ -6,8 +6,8 @@ import ( "time" "github.com/miekg/dns" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) // Check that we can use a regular mDNS server with a regular mDNS client @@ -19,9 +19,9 @@ func TestClientServerSimpleQuery(t *testing.T) { mzone := newMockedZoneWithRecords([]ZoneRecord{testRecord1}) mdnsServer, err := NewMDNSServer(mzone, true, DefaultLocalTTL) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = mdnsServer.Start(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) defer mdnsServer.Stop() var receivedAddr net.IP @@ -29,9 +29,9 @@ func TestClientServerSimpleQuery(t *testing.T) { receivedCount := 0 mdnsCli, err := NewMDNSClient() - wt.AssertNoErr(t, err) + require.NoError(t, err) err = mdnsCli.Start(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) sendQuery := func(name string, querytype uint16) { receivedAddr = nil @@ -95,23 +95,23 @@ func TestClientServerInsistentQuery(t *testing.T) { mzone1 := newMockedZoneWithRecords([]ZoneRecord{testRecord1}) mdnsServer1, err := NewMDNSServer(mzone1, true, DefaultLocalTTL) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = mdnsServer1.Start(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) defer mdnsServer1.Stop() mzone2 := newMockedZoneWithRecords([]ZoneRecord{testRecord2}) mdnsServer2, err := NewMDNSServer(mzone2, true, DefaultLocalTTL) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = mdnsServer2.Start(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) defer mdnsServer2.Stop() // create a third server with exactly the same info as the second server (so we can test duplicates removals) mdnsServer3, err := NewMDNSServer(mzone2, true, DefaultLocalTTL) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = mdnsServer3.Start(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) defer mdnsServer3.Stop() var receivedAddrs []ZoneRecord @@ -119,9 +119,9 @@ func TestClientServerInsistentQuery(t *testing.T) { receivedCount := 0 mdnsCli, err := NewMDNSClient() - wt.AssertNoErr(t, err) + require.NoError(t, err) err = mdnsCli.Start(nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) sendQuery := func(name string, querytype uint16) { receivedAddrs = nil diff --git a/nameserver/mocks_test.go b/nameserver/mocks_test.go index c6a73f5a82..397dbc02d6 100644 --- a/nameserver/mocks_test.go +++ b/nameserver/mocks_test.go @@ -10,8 +10,8 @@ import ( "github.com/benbjohnson/clock" "github.com/miekg/dns" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) const ( @@ -451,7 +451,7 @@ func (clk *mockedClock) Forward(secs int) { // Perform a DNS query and assert the reply code, number or answers, etc func assertExchange(t *testing.T, z string, ty uint16, port int, minAnswers int, maxAnswers int, expErr int) (*dns.Msg, *dns.Msg) { - wt.AssertNotEqualInt(t, port, 0, "invalid DNS server port") + require.NotEqual(t, 0, port, "invalid DNS server port") c := &dns.Client{ UDPSize: testUDPBufSize, @@ -468,18 +468,18 @@ func assertExchange(t *testing.T, z string, ty uint16, port int, minAnswers int, if err != nil { t.Errorf("Error when querying DNS server at %s: %s", lstAddr, err) } - wt.AssertNoErr(t, err) + require.NoError(t, err) if minAnswers == 0 && maxAnswers == 0 { - wt.AssertStatus(t, r.Rcode, expErr, "DNS response code") + require.Equal(t, expErr, r.Rcode, "DNS response code") } else { - wt.AssertStatus(t, r.Rcode, dns.RcodeSuccess, "DNS response code") + require.Equal(t, dns.RcodeSuccess, r.Rcode, "DNS response code") } answers := len(r.Answer) if minAnswers >= 0 && answers < minAnswers { - wt.Fatalf(t, "Number of answers >= %d", minAnswers) + require.FailNow(t, fmt.Sprintf("Number of answers >= %d", minAnswers)) } if maxAnswers >= 0 && answers > maxAnswers { - wt.Fatalf(t, "Number of answers <= %d", maxAnswers) + require.FailNow(t, fmt.Sprintf("Number of answers <= %d", maxAnswers)) } return m, r } @@ -487,8 +487,8 @@ func assertExchange(t *testing.T, z string, ty uint16, port int, minAnswers int, // Assert that we have a response in the cache for a query `q` func assertInCache(t *testing.T, cache ZoneCache, q *dns.Msg, desc string) { r, err := cache.Get(q, maxUDPSize) - wt.AssertNoErr(t, err) - wt.AssertNotNil(t, r, fmt.Sprintf("value in the cache: %s", desc)) + require.NoError(t, err) + require.NotNil(t, r, fmt.Sprintf("value in the cache: %s", desc)) } // Assert that we have a response in the cache for a query `q` @@ -502,6 +502,6 @@ func assertNotLocalInCache(t *testing.T, cache ZoneCache, q *dns.Msg, desc strin // Assert that we do not have a response in the cache for a query `q` func assertNotInCache(t *testing.T, cache ZoneCache, q *dns.Msg, desc string) { r, err := cache.Get(q, maxUDPSize) - wt.AssertNoErr(t, err) - wt.AssertNil(t, r, fmt.Sprintf("value in the cache: %s\n%s", desc, r)) + require.NoError(t, err) + require.Nil(t, r, fmt.Sprintf("value in the cache: %s\n%s", desc, r)) } diff --git a/nameserver/server_cache_test.go b/nameserver/server_cache_test.go index 65f233df25..31200d7294 100644 --- a/nameserver/server_cache_test.go +++ b/nameserver/server_cache_test.go @@ -7,8 +7,8 @@ import ( "time" "github.com/miekg/dns" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) // Check that AddRecord/DeleteRecord/... in the Zone database lead to cache invalidations @@ -35,14 +35,14 @@ func TestServerDbCacheInvalidation(t *testing.T) { Clock: clk, } zone, err := NewZoneDb(zoneConfig) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = zone.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) defer zone.Stop() Debug.Printf("Creating a cache") cache, err := NewCache(1024, clk) - wt.AssertNoErr(t, err) + require.NoError(t, err) fallbackHandler := func(w dns.ResponseWriter, req *dns.Msg) { m := new(dns.Msg) @@ -55,7 +55,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { // Run another DNS server for fallback fallback, err := newMockedFallback(fallbackHandler, nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) fallback.Start() defer fallback.Stop() @@ -68,16 +68,16 @@ func TestServerDbCacheInvalidation(t *testing.T) { UpstreamCfg: fallback.CliConfig, MaxAnswers: 4, }) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = srv.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) go srv.ActivateAndServe() defer srv.Stop() time.Sleep(100 * time.Millisecond) // Allow server goroutine to start testPort, err := srv.GetPort() - wt.AssertNoErr(t, err) - wt.AssertNotEqualInt(t, testPort, 0, "invalid listen port") + require.NoError(t, err) + require.NotEqual(t, 0, testPort, "invalid listen port") Debug.Printf("Adding two IPs to %s", testName1) zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.1")) @@ -193,7 +193,7 @@ func TestServerCacheExpiration(t *testing.T) { Debug.Printf("Creating a cache") cache, err := NewCache(1024, clk) - wt.AssertNoErr(t, err) + require.NoError(t, err) Debug.Printf("Creating a real DNS server for the first zone database and with the cache") srv, err := NewDNSServer(DNSServerConfig{ @@ -203,16 +203,16 @@ func TestServerCacheExpiration(t *testing.T) { ListenReadTimeout: testSocketTimeout, CacheNegLocalTTL: negativeLocalTTL, }) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = srv.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) go srv.ActivateAndServe() defer srv.Stop() time.Sleep(100 * time.Millisecond) // Allow server goroutine to start testPort, err := srv.GetPort() - wt.AssertNoErr(t, err) - wt.AssertNotEqualInt(t, testPort, 0, "invalid listen port") + require.NoError(t, err) + require.NotEqual(t, 0, testPort, "invalid listen port") // Check that the DNS server knows nothing about testName1 qName1, _ := assertExchange(t, testName1, dns.TypeA, testPort, 0, 0, dns.RcodeNameError) @@ -280,7 +280,7 @@ func TestServerCacheRefresh(t *testing.T) { Debug.Printf("Creating a cache") cache, err := NewCache(1024, clk) - wt.AssertNoErr(t, err) + require.NoError(t, err) Debug.Printf("Creating a real DNS server for the first zone database and with the cache") srv, err := NewDNSServer(DNSServerConfig{ @@ -290,16 +290,16 @@ func TestServerCacheRefresh(t *testing.T) { ListenReadTimeout: testSocketTimeout, MaxAnswers: 4, }) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = srv.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) go srv.ActivateAndServe() defer srv.Stop() time.Sleep(100 * time.Millisecond) // Allow sever goroutine to start testPort, err := srv.GetPort() - wt.AssertNoErr(t, err) - wt.AssertNotEqualInt(t, testPort, 0, "listen port") + require.NoError(t, err) + require.NotEqual(t, 0, testPort, "listen port") Debug.Printf("Adding an IPs to %s", testName1) dbs[1].Zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.1")) diff --git a/nameserver/server_test.go b/nameserver/server_test.go index feba999740..ce1d4a4c5c 100644 --- a/nameserver/server_test.go +++ b/nameserver/server_test.go @@ -8,8 +8,8 @@ import ( "time" "github.com/miekg/dns" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) const ( @@ -44,9 +44,9 @@ func TestUDPDNSServer(t *testing.T) { Info.Println("TestUDPDNSServer starting") zone, err := NewZoneDb(ZoneConfig{}) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = zone.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) defer zone.Stop() ip, _, _ := net.ParseCIDR(testCIDR1) @@ -78,7 +78,7 @@ func TestUDPDNSServer(t *testing.T) { // Run another DNS server for fallback fallback, err := newMockedFallback(fallbackHandler, nil) - wt.AssertNoErr(t, err) + require.NoError(t, err) fallback.Start() defer fallback.Stop() @@ -88,9 +88,9 @@ func TestUDPDNSServer(t *testing.T) { CacheDisabled: true, ListenReadTimeout: testSocketTimeout, }) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = srv.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) go srv.ActivateAndServe() defer srv.Stop() time.Sleep(100 * time.Millisecond) // Allow sever goroutine to start @@ -98,18 +98,18 @@ func TestUDPDNSServer(t *testing.T) { var r *dns.Msg testPort, err := srv.GetPort() - wt.AssertNoErr(t, err) - wt.AssertNotEqualInt(t, testPort, 0, "invalid listen port") + require.NoError(t, err) + require.NotEqual(t, 0, testPort, "invalid listen port") _, r = assertExchange(t, successTestName, dns.TypeA, testPort, 1, 1, 0) - wt.AssertType(t, r.Answer[0], (*dns.A)(nil), "DNS record") - wt.AssertEqualString(t, r.Answer[0].(*dns.A).A.String(), testAddr1, "IP address") + require.IsType(t, (*dns.A)(nil), r.Answer[0], "DNS record") + require.Equal(t, testAddr1, r.Answer[0].(*dns.A).A.String(), "IP address") assertExchange(t, failTestName, dns.TypeA, testPort, 0, 0, dns.RcodeNameError) _, r = assertExchange(t, testRDNSsuccess, dns.TypePTR, testPort, 1, 1, 0) - wt.AssertType(t, r.Answer[0], (*dns.PTR)(nil), "DNS record") - wt.AssertEqualString(t, r.Answer[0].(*dns.PTR).Ptr, successTestName, "IP address") + require.IsType(t, (*dns.PTR)(nil), r.Answer[0], "DNS record") + require.Equal(t, successTestName, r.Answer[0].(*dns.PTR).Ptr, "IP address") assertExchange(t, testRDNSfail, dns.TypePTR, testPort, 0, 0, dns.RcodeNameError) @@ -141,9 +141,9 @@ func TestTCPDNSServer(t *testing.T) { Info.Println("TestTCPDNSServer starting") zone, err := NewZoneDb(ZoneConfig{}) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = zone.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) defer zone.Stop() // generate a list of `numAnswers` IP addresses @@ -185,7 +185,7 @@ func TestTCPDNSServer(t *testing.T) { t.Logf("Running a DNS fallback server with UDP") fallback, err := newMockedFallback(fallbackUDPHandler, fallbackTCPHandler) - wt.AssertNoErr(t, err) + require.NoError(t, err) fallback.Start() defer fallback.Stop() @@ -196,16 +196,16 @@ func TestTCPDNSServer(t *testing.T) { CacheDisabled: true, ListenReadTimeout: testSocketTimeout, }) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = srv.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) go srv.ActivateAndServe() defer srv.Stop() time.Sleep(100 * time.Millisecond) // Allow sever goroutine to start testPort, err := srv.GetPort() - wt.AssertNoErr(t, err) - wt.AssertNotEqualInt(t, testPort, 0, "listen port") + require.NoError(t, err) + require.NotEqual(t, 0, testPort, "listen port") dnsAddr := fmt.Sprintf("127.0.0.1:%d", testPort) t.Logf("Creating a UDP and a TCP client") @@ -223,36 +223,36 @@ func TestTCPDNSServer(t *testing.T) { r, _, err := uc.Exchange(m, fallback.Addr) t.Logf("Got response from fallback server (UDP) with %d answers", len(r.Answer)) t.Logf("Response:\n%+v\n", r) - wt.AssertNoErr(t, err) - wt.AssertTrue(t, r.MsgHdr.Truncated, "DNS truncated reponse flag") - wt.AssertNotEqualInt(t, len(r.Answer), numAnswers, "number of answers (UDP)") + require.NoError(t, err) + require.True(t, r.MsgHdr.Truncated, "DNS truncated reponse flag") + require.NotEqual(t, numAnswers, len(r.Answer), "number of answers (UDP)") t.Logf("Checking the WeaveDNS server at %s returns a truncated reponse with UDP", dnsAddr) r, _, err = uc.Exchange(m, dnsAddr) t.Logf("UDP Response:\n%+v\n", r) - wt.AssertNoErr(t, err) - wt.AssertNotNil(t, r, "response") + require.NoError(t, err) + require.NotNil(t, r, "response") t.Logf("%d answers", len(r.Answer)) - wt.AssertTrue(t, r.MsgHdr.Truncated, "DNS truncated reponse flag") - wt.AssertNotEqualInt(t, len(r.Answer), numAnswers, "number of answers (UDP)") + require.True(t, r.MsgHdr.Truncated, "DNS truncated reponse flag") + require.NotEqual(t, numAnswers, len(r.Answer), "number of answers (UDP)") t.Logf("Checking the WeaveDNS server at %s does not return a truncated reponse with TCP", dnsAddr) r, _, err = tc.Exchange(m, dnsAddr) t.Logf("TCP Response:\n%+v\n", r) - wt.AssertNoErr(t, err) - wt.AssertNotNil(t, r, "response") + require.NoError(t, err) + require.NotNil(t, r, "response") t.Logf("%d answers", len(r.Answer)) - wt.AssertFalse(t, r.MsgHdr.Truncated, "DNS truncated response flag") - wt.AssertEqualInt(t, len(r.Answer), numAnswers, "number of answers (TCP)") + require.False(t, r.MsgHdr.Truncated, "DNS truncated response flag") + require.Equal(t, numAnswers, len(r.Answer), "number of answers (TCP)") t.Logf("Checking the WeaveDNS server at %s does not return a truncated reponse with UDP with a bigger buffer", dnsAddr) m.SetEdns0(testUDPBufSize, false) r, _, err = uc.Exchange(m, dnsAddr) t.Logf("UDP-large Response:\n%+v\n", r) - wt.AssertNoErr(t, err) - wt.AssertNotNil(t, r, "response") + require.NoError(t, err) + require.NotNil(t, r, "response") t.Logf("%d answers", len(r.Answer)) - wt.AssertNoErr(t, err) - wt.AssertFalse(t, r.MsgHdr.Truncated, "DNS truncated response flag") - wt.AssertEqualInt(t, len(r.Answer), numAnswers, "number of answers (UDP-long)") + require.NoError(t, err) + require.False(t, r.MsgHdr.Truncated, "DNS truncated response flag") + require.Equal(t, numAnswers, len(r.Answer), "number of answers (UDP-long)") } diff --git a/nameserver/zone_lookup_test.go b/nameserver/zone_lookup_test.go index c93b7aa00e..8a7d22fdd9 100644 --- a/nameserver/zone_lookup_test.go +++ b/nameserver/zone_lookup_test.go @@ -5,8 +5,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" - wt "github.com/weaveworks/weave/testing" ) // Check that the refreshing mechanism works as expected @@ -44,23 +44,23 @@ func TestZoneRefresh(t *testing.T) { dbs[0].Zone.AddRecord("someident", name, net.ParseIP(addr1)) Debug.Printf("Checking that the name %s is relevant (as it has been locally inserted) and not remote", name) - wt.AssertTrue(t, dbs[0].Zone.IsNameRelevant(name), "name relevant") - wt.AssertTrue(t, dbs[0].Zone.HasNameLocalInfo(name), "local name info") - wt.AssertFalse(t, dbs[0].Zone.HasNameRemoteInfo(name), "remote name info") + require.True(t, dbs[0].Zone.IsNameRelevant(name), "name relevant") + require.True(t, dbs[0].Zone.HasNameLocalInfo(name), "local name info") + require.False(t, dbs[0].Zone.HasNameRemoteInfo(name), "remote name info") Debug.Printf("Asking for '%s' to Db #1: should get 1 IP from the local database...", name) res, err := dbs[0].Zone.DomainLookupName(name) - wt.AssertNoErr(t, err) + require.NoError(t, err) Debug.Printf("Got: %s", res) t.Logf("Db #1 after the lookup:\n%s", dbs[0].Zone) - wt.AssertEqualInt(t, len(res), 1, "lookup result") + require.Equal(t, 1, len(res), "lookup result") clk.Forward(refreshInterval / 2) dbs.Flush() Debug.Printf("A couple of seconds later, we should still have one IP for that name") res, err = dbs[0].Zone.DomainLookupName(name) - wt.AssertNoErr(t, err) - wt.AssertEqualInt(t, len(res), 1, "lookup result") + require.NoError(t, err) + require.Equal(t, 1, len(res), "lookup result") Debug.Printf("And then we add 2 IPs for that name at ZoneDb 2") clk.Forward(1) @@ -81,7 +81,7 @@ func TestZoneRefresh(t *testing.T) { res, err = dbs[0].Zone.DomainLookupName(name) Debug.Printf("Got: %s", res) t.Logf("Db #1 after the second lookup:\n%s", dbs[0].Zone) - wt.AssertEqualInt(t, len(res), 3, "lookup result length") + require.Equal(t, 3, len(res), "lookup result length") Debug.Printf("We will not ask for `name` for a while, so it will become irrelevant and will be removed...") clk.Forward(refreshInterval + relevantTime + 1) @@ -90,9 +90,9 @@ func TestZoneRefresh(t *testing.T) { // the name should be irrelevant now, and all remote info should have been // removed from the zone database Debug.Printf("Name '%s' should not be in the remote database in ZoneDb 1", name) - wt.AssertFalse(t, dbs[0].Zone.IsNameRelevant(name), "name still relevant after some inactivity time") - wt.AssertTrue(t, dbs[0].Zone.HasNameLocalInfo(name), "local name info") - wt.AssertFalse(t, dbs[0].Zone.HasNameRemoteInfo(name), "remote name info") + require.False(t, dbs[0].Zone.IsNameRelevant(name), "name still relevant after some inactivity time") + require.True(t, dbs[0].Zone.HasNameLocalInfo(name), "local name info") + require.False(t, dbs[0].Zone.HasNameRemoteInfo(name), "remote name info") Debug.Printf("There is no remote info about this name at zone 1: a new IP appears remotely meanwhile...") clk.Forward(1) @@ -104,7 +104,7 @@ func TestZoneRefresh(t *testing.T) { Debug.Printf("When we ask about this name again, we get 4 IPs (1 local, 3 remote)") Debug.Printf("Asking for '%s' again... the first lookup will return only the local results", name) res, err = dbs[0].Zone.DomainLookupName(name) - wt.AssertEqualInt(t, len(res), 1, "lookup result length") + require.Equal(t, 1, len(res), "lookup result length") Debug.Printf("... but a second lookup should return all the results in the network") clk.Forward(refreshInterval + 1) @@ -112,5 +112,5 @@ func TestZoneRefresh(t *testing.T) { res, err = dbs[0].Zone.DomainLookupName(name) Debug.Printf("Got: %s", res) - wt.AssertEqualInt(t, len(res), 4, "lookup result length") + require.Equal(t, 4, len(res), "lookup result length") } diff --git a/nameserver/zone_test.go b/nameserver/zone_test.go index 89dcfb2069..04a7e9d973 100644 --- a/nameserver/zone_test.go +++ b/nameserver/zone_test.go @@ -5,6 +5,7 @@ import ( "net" "testing" + "github.com/stretchr/testify/require" . "github.com/weaveworks/weave/common" wt "github.com/weaveworks/weave/testing" ) @@ -22,28 +23,28 @@ func TestZone(t *testing.T) { InitDefaultLogging(testing.Verbose()) zone, err := NewZoneDb(ZoneConfig{}) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = zone.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) defer zone.Stop() ip1, _, _ := net.ParseCIDR(name1Addr1) t.Logf("Adding '%s'/%s to '%s'", name1, ip1, container1) err = zone.AddRecord(container1, name1, ip1) - wt.AssertNoErr(t, err) + require.NoError(t, err) // Add a few more records to make the job harder t.Logf("Adding 'adummy.weave.' to 'abcdef0123'") err = zone.AddRecord("abcdef0123", "adummy.weave.", net.ParseIP("10.9.0.1")) - wt.AssertNoErr(t, err) + require.NoError(t, err) t.Logf("Adding 'zdummy.weave.' to '0123abcdef'") err = zone.AddRecord("0123abcdef", "zdummy.weave.", net.ParseIP("10.9.0.2")) - wt.AssertNoErr(t, err) + require.NoError(t, err) t.Logf("Zone database:\n%s", zone) t.Logf("Checking if we can find the name '%s'", name1) foundIPs, err := zone.LookupName(name1) - wt.AssertNoErr(t, err) + require.NoError(t, err) if !foundIPs[0].IP().Equal(ip1) { t.Fatal("Unexpected result for", name1, foundIPs) @@ -51,16 +52,16 @@ func TestZone(t *testing.T) { t.Logf("Checking if we cannot find some silly name like 'something.wrong'") foundIPs, err = zone.LookupName("something.wrong") - wt.AssertErrorType(t, err, (*LookupError)(nil), fmt.Sprintf("unknown name: %+v", foundIPs)) + wt.AssertErrorType(t, (*LookupError)(nil), err, fmt.Sprintf("unknown name: %+v", foundIPs)) ip2, _, _ := net.ParseCIDR(name1Addr2) t.Logf("Adding a second IP for '%s'/%s to '%s'", name1, ip2, container1) err = zone.AddRecord(container1, name1, ip2) - wt.AssertNoErr(t, err) + require.NoError(t, err) t.Logf("Checking if we can find both the old IP and the new IP for '%s'", name1) foundIPs, err = zone.LookupName(name1) - wt.AssertNoErr(t, err) + require.NoError(t, err) if !(foundIPs[0].IP().Equal(ip1) || foundIPs[1].IP().Equal(ip1)) { t.Fatal("Unexpected result for", name1, foundIPs) } @@ -70,7 +71,7 @@ func TestZone(t *testing.T) { t.Logf("Checking if we can find the address by IP '1.2.9.10.in-addr.arpa.'") foundNames, err := zone.LookupInaddr("1.2.9.10.in-addr.arpa.") - wt.AssertNoErr(t, err) + require.NoError(t, err) if foundNames[0].Name() != name1 { t.Fatal("Unexpected result for", ip1, foundNames) @@ -78,28 +79,28 @@ func TestZone(t *testing.T) { t.Logf("Checking we can not find an unknown address '30.20.10.1.in-addr.arpa.'") foundNames, err = zone.LookupInaddr("30.20.10.1.in-addr.arpa.") - wt.AssertErrorType(t, err, (*LookupError)(nil), fmt.Sprintf("unknown IP: %+v", foundNames)) + wt.AssertErrorType(t, (*LookupError)(nil), err, fmt.Sprintf("unknown IP: %+v", foundNames)) t.Logf("Checking if adding again '%s'/%s in %s results in an error", name1, ip1, container1) err = zone.AddRecord(container1, name1, ip1) - wt.AssertErrorType(t, err, (*DuplicateError)(nil), "duplicate add") + wt.AssertErrorType(t, (*DuplicateError)(nil), err, "duplicate add") t.Logf("Adding '%s'/%s in %s too", name1, ip1, container2) err = zone.AddRecord(container2, name1, ip1) - wt.AssertNoErr(t, err) + require.NoError(t, err) name1Removed := 0 err = zone.ObserveName(name1, func() { t.Logf("Observer #1 for '%s' notified.", name1); name1Removed++ }) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = zone.ObserveName(name1, func() { t.Logf("Observer #2 for '%s' notified.", name1); name1Removed++ }) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = zone.ObserveInaddr(revName1Addr1, func() { t.Logf("Observer #1 for '%s' notified.", revName1Addr1); name1Removed++ }) - wt.AssertNoErr(t, err) + require.NoError(t, err) t.Logf("Zone database:\n%s", zone) t.Logf("Deleting the %s in %s", ip1, container1) count := zone.DeleteRecords(container1, "", ip1) - wt.AssertEqualInt(t, count, 1, "delete failed") + require.Equal(t, 1, count, "delete failed") t.Logf("Zone database:\n%s", zone) t.Logf("Checking %s's observers have been notified on removal", name1) @@ -110,21 +111,21 @@ func TestZone(t *testing.T) { t.Logf("Checking %s can be found", name1) _, err = zone.LookupName(name1) - wt.AssertNoErr(t, err) + require.NoError(t, err) t.Logf("Checking %s is not found after removing %s it in %s and %s in %s", name1, ip1, container2, ip2, container1) count = zone.DeleteRecords(container1, "", ip2) - wt.AssertEqualInt(t, count, 1, "delete failed") + require.Equal(t, 1, count, "delete failed") count = zone.DeleteRecords(container2, "", ip1) - wt.AssertEqualInt(t, count, 1, "delete failed") + require.Equal(t, 1, count, "delete failed") t.Logf("Zone database:\n%s", zone) _, err = zone.LookupName(name1) - wt.AssertErrorType(t, err, (*LookupError)(nil), "after deleting record") + wt.AssertErrorType(t, (*LookupError)(nil), err, "after deleting record") t.Logf("Checking if removing an unknown record results in an error") count = zone.DeleteRecords(container1, "", net.ParseIP("0.0.0.0")) - wt.AssertEqualInt(t, count, 0, "delete failed") + require.Equal(t, 0, count, "delete failed") } func TestDeleteRecords(t *testing.T) { @@ -138,22 +139,22 @@ func TestDeleteRecords(t *testing.T) { InitDefaultLogging(testing.Verbose()) zone, err := NewZoneDb(ZoneConfig{}) - wt.AssertNoErr(t, err) + require.NoError(t, err) err = zone.Start() - wt.AssertNoErr(t, err) + require.NoError(t, err) defer zone.Stop() for _, addr := range []string{addr1, addr2} { ip, _, _ := net.ParseCIDR(addr) err := zone.AddRecord(id, name, ip) - wt.AssertNoErr(t, err) + require.NoError(t, err) } _, err = zone.LookupName(name) - wt.AssertNoErr(t, err) + require.NoError(t, err) count := zone.DeleteRecords(id, "", net.IP{}) - wt.AssertEqualInt(t, count, 2, "wildcard delete failed") + require.Equal(t, 2, count, "wildcard delete failed") _, err = zone.LookupName(name) - wt.AssertErrorType(t, err, (*LookupError)(nil), "after deleting records for ident") + wt.AssertErrorType(t, (*LookupError)(nil), err, "after deleting records for ident") } diff --git a/net/route_test.go b/net/route_test.go index e907fadfce..9fc35258ce 100644 --- a/net/route_test.go +++ b/net/route_test.go @@ -4,7 +4,7 @@ import ( "net" "testing" - wt "github.com/weaveworks/weave/testing" + "github.com/stretchr/testify/require" ) func TestOverlap(t *testing.T) { @@ -13,13 +13,13 @@ func TestOverlap(t *testing.T) { _, subnet3, _ := net.ParseCIDR("10.0.3.128/25") _, subnet4, _ := net.ParseCIDR("10.0.3.192/25") _, universe, _ := net.ParseCIDR("10.0.0.0/8") - wt.AssertEquals(t, overlaps(subnet1, subnet2), false) - wt.AssertEquals(t, overlaps(subnet2, subnet1), false) - wt.AssertEquals(t, overlaps(subnet1, subnet1), true) - wt.AssertEquals(t, overlaps(subnet1, subnet3), true) - wt.AssertEquals(t, overlaps(subnet1, subnet4), true) - wt.AssertEquals(t, overlaps(subnet2, subnet4), false) - wt.AssertEquals(t, overlaps(subnet4, subnet2), false) - wt.AssertEquals(t, overlaps(universe, subnet1), true) - wt.AssertEquals(t, overlaps(subnet1, universe), true) + require.False(t, overlaps(subnet1, subnet2)) + require.False(t, overlaps(subnet2, subnet1)) + require.True(t, overlaps(subnet1, subnet1)) + require.True(t, overlaps(subnet1, subnet3)) + require.True(t, overlaps(subnet1, subnet4)) + require.False(t, overlaps(subnet2, subnet4)) + require.False(t, overlaps(subnet4, subnet2)) + require.True(t, overlaps(universe, subnet1)) + require.True(t, overlaps(subnet1, universe)) } diff --git a/router/gossip_test.go b/router/gossip_test.go index 15ae81950d..c1ace33839 100644 --- a/router/gossip_test.go +++ b/router/gossip_test.go @@ -1,10 +1,12 @@ package router import ( + "fmt" "sync" "testing" "time" + "github.com/stretchr/testify/require" wt "github.com/weaveworks/weave/testing" ) @@ -255,7 +257,7 @@ func (g *testGossiper) checkHas(t *testing.T, vs ...byte) { defer g.RUnlock() for _, v := range vs { if _, found := g.state[v]; !found { - wt.Fatalf(t, "%d is missing", v) + require.FailNow(t, fmt.Sprintf("%d is missing", v)) } } } diff --git a/router/handshake_test.go b/router/handshake_test.go index 1630d34379..2139e080c4 100644 --- a/router/handshake_test.go +++ b/router/handshake_test.go @@ -3,7 +3,7 @@ package router import ( "testing" - wt "github.com/weaveworks/weave/testing" + "github.com/stretchr/testify/require" ) func TestFieldValidator(t *testing.T) { @@ -11,20 +11,20 @@ func TestFieldValidator(t *testing.T) { fv := NewFieldValidator(testMap) val, err := fv.Value("a") - wt.AssertNoErr(t, err) - wt.AssertNoErr(t, fv.Err()) - wt.AssertEqualString(t, val, "a", "") + require.NoError(t, err) + require.NoError(t, fv.Err()) + require.Equal(t, "a", val, "") _, err = fv.Value("x") - wt.AssertFalse(t, err == nil || fv.Err() == nil, "Expected error") + require.False(t, err == nil || fv.Err() == nil, "Expected error") _, err = fv.Value("a") - wt.AssertFalse(t, err == nil || fv.Err() == nil, "Previous error should be retained") + require.False(t, err == nil || fv.Err() == nil, "Previous error should be retained") fv = NewFieldValidator(testMap) err = fv.CheckEqual("a", "a") - wt.AssertNoErr(t, err) - wt.AssertNoErr(t, fv.Err()) + require.NoError(t, err) + require.NoError(t, fv.Err()) err = fv.CheckEqual("a", "b") - wt.AssertFalse(t, err == nil || fv.Err() == nil, "Expected error") + require.False(t, err == nil || fv.Err() == nil, "Expected error") err = fv.CheckEqual("a", "a") - wt.AssertFalse(t, err == nil || fv.Err() == nil, "Previous error should be retained") + require.False(t, err == nil || fv.Err() == nil, "Previous error should be retained") } diff --git a/router/mocks_test.go b/router/mocks_test.go index dc0ec6c372..7dacd9e987 100644 --- a/router/mocks_test.go +++ b/router/mocks_test.go @@ -6,9 +6,10 @@ package router import ( + "fmt" "testing" - wt "github.com/weaveworks/weave/testing" + "github.com/stretchr/testify/require" ) // Add to peers a connection from peers.ourself to p @@ -58,11 +59,11 @@ func checkEqualConns(t *testing.T, ourName PeerName, got, wanted map[PeerName]Co if _, found := checkConns[remoteName]; found { delete(checkConns, remoteName) } else { - wt.Fatalf(t, "Unexpected connection from %s to %s", ourName, remoteName) + require.FailNow(t, fmt.Sprintf("Unexpected connection from %s to %s", ourName, remoteName)) } } if len(checkConns) > 0 { - wt.Fatalf(t, "Expected connections not found: from %s to %v", ourName, checkConns) + require.FailNow(t, fmt.Sprintf("Expected connections not found: from %s to %v", ourName, checkConns)) } } @@ -105,10 +106,10 @@ func checkTopologyPeers(t *testing.T, checkConns bool, peers []*Peer, wantedPeer } delete(check, name) } else { - wt.Fatalf(t, "Unexpected peer: %s", name) + require.FailNow(t, fmt.Sprintf("Unexpected peer: %s", name)) } } if len(check) > 0 { - wt.Fatalf(t, "Expected peers not found: %v", check) + require.FailNow(t, fmt.Sprintf("Expected peers not found: %v", check)) } } diff --git a/router/peers_test.go b/router/peers_test.go index bf221642ce..2c0fbfb1cf 100644 --- a/router/peers_test.go +++ b/router/peers_test.go @@ -5,7 +5,7 @@ import ( "math/rand" "testing" - wt "github.com/weaveworks/weave/testing" + "github.com/stretchr/testify/require" ) // TODO we should also test: @@ -98,14 +98,14 @@ func TestPeersGarbageCollection(t *testing.T) { ps2.AddTestRemoteConnection(p3, p1) // Every peer is referenced, so nothing should be dropped - wt.AssertEmpty(t, ps1.GarbageCollect(), "peers removed") - wt.AssertEmpty(t, ps2.GarbageCollect(), "peers removed") - wt.AssertEmpty(t, ps3.GarbageCollect(), "peers removed") + require.Empty(t, ps1.GarbageCollect(), "peers removed") + require.Empty(t, ps2.GarbageCollect(), "peers removed") + require.Empty(t, ps3.GarbageCollect(), "peers removed") // Drop the connection from 2 to 3, and 3 isn't garbage-collected // because 1 has a connection to 3 ps2.DeleteTestConnection(p3) - wt.AssertEmpty(t, ps2.GarbageCollect(), "peers removed") + require.Empty(t, ps2.GarbageCollect(), "peers removed") // Drop the connection from 1 to 3, and 3 will get removed by // garbage-collection diff --git a/testing/util.go b/testing/util.go index 1e45685a3c..7ce98cb5b2 100644 --- a/testing/util.go +++ b/testing/util.go @@ -1,143 +1,34 @@ package testing import ( + "fmt" "reflect" "runtime" "testing" "time" -) - -func AssertTrue(t *testing.T, cond bool, desc string) { - if !cond { - Fatalf(t, "Expected %s", desc) - } -} - -func AssertFalse(t *testing.T, cond bool, desc string) { - if cond { - Fatalf(t, "Unexpected %s", desc) - } -} - -func AssertNil(t *testing.T, p interface{}, desc string) { - val := reflect.ValueOf(p) - if val.IsValid() && !val.IsNil() { - Fatalf(t, "Expected nil pointer for %s but got a \"%s\": \"%s\"", - desc, reflect.TypeOf(p), val.Interface()) - } -} - -func AssertNotNil(t *testing.T, p interface{}, desc string) { - val := reflect.ValueOf(p) - if !val.IsValid() || val.IsNil() { - Fatalf(t, "Unexpected nil pointer for %s", desc) - } -} - -func AssertNoErr(t *testing.T, err error) { - if err != nil { - Fatalf(t, "Unexpected error: %s", err) - } -} - -func AssertEqualuint64(t *testing.T, got, wanted uint64, desc string) { - if got != wanted { - Fatalf(t, "Expected %s %d but got %d", desc, wanted, got) - } -} - -func AssertEqualInt(t *testing.T, got, wanted int, desc string) { - if got != wanted { - Fatalf(t, "Expected %s %d but got %d", desc, wanted, got) - } -} - -func AssertNotEqualInt(t *testing.T, got, wanted int, desc string) { - if got == wanted { - Fatalf(t, "Expected %s %d to be different to %d", desc, wanted, got) - } -} - -func AssertEqualString(t *testing.T, got, wanted string, desc string) { - if got != wanted { - Fatalf(t, "Expected %s '%s' but got '%s'", desc, wanted, got) - } -} -func AssertEquals(t *testing.T, a1, a2 interface{}) { - if !reflect.DeepEqual(a1, a2) { - Fatalf(t, "Expected %+v == %+v", a1, a2) - } -} - -func AssertStatus(t *testing.T, got int, wanted int, desc string) { - if got != wanted { - Fatalf(t, "Expected %s %d but got %d", desc, wanted, got) - } -} - -func AssertErrorInterface(t *testing.T, got interface{}, wanted interface{}, desc string) { - gotT, wantedT := reflect.TypeOf(got), reflect.TypeOf(wanted).Elem() - if got == nil { - Fatalf(t, "Expected %s but got nil (%s)", wantedT.String(), desc) - } - if !gotT.Implements(wantedT) { - Fatalf(t, "Expected %s but got %s (%s)", wantedT.String(), gotT.String(), desc) - } -} - -func AssertErrorType(t *testing.T, got interface{}, wanted interface{}, desc string) { - gotT, wantedT := reflect.TypeOf(got), reflect.TypeOf(wanted).Elem() - if got == nil { - Fatalf(t, "Expected %s but got nil (%s)", wantedT.String(), desc) - } - if gotT != wantedT { - Fatalf(t, "Expected %s but got %s (%s)", wantedT.String(), gotT.String(), desc) - } -} - -func AssertType(t *testing.T, got interface{}, wanted interface{}, desc string) { - gotT, wantedT := reflect.TypeOf(got), reflect.TypeOf(wanted) - if gotT != wantedT { - Fatalf(t, "Expected %s but got %s (%s)", wantedT.String(), gotT.String(), desc) - } -} + "github.com/stretchr/testify/require" +) -func AssertEmpty(t *testing.T, array interface{}, desc string) { - if reflect.ValueOf(array).Len() != 0 { - Fatalf(t, "Expected empty %s but got %s", desc, array) - } +func AssertErrorInterface(t *testing.T, expected interface{}, actual error, desc string) { + require.Error(t, actual, desc) + require.Implements(t, expected, actual, desc) } -func AssertSuccess(t *testing.T, err error) { - if err != nil { - Fatalf(t, "Expected success, got '%s'", err.Error()) +func AssertErrorType(t *testing.T, expected interface{}, actual error, desc string) { + require.Error(t, actual, desc) + // require.IsType doesn't take the pointer element, and doesn't resolve + // through interfaces, so we have to do this one ourselves. + actualT, expectedT := reflect.TypeOf(actual), reflect.TypeOf(expected).Elem() + if actualT != expectedT { + require.FailNow( + t, + fmt.Sprintf("Expected %s but got %s", expectedT.String(), actualT.String()), + desc, + ) } } -func AssertPanic(t *testing.T, f func()) { - wrapper := func() (paniced bool) { - defer func() { - if err := recover(); err != nil { - paniced = true - } - }() - - f() - return - } - AssertTrue(t, wrapper(), "Expected panic") -} - -// Like testing.Fatalf, but adds the stack trace of the current call -func Fatalf(t *testing.T, format string, args ...interface{}) { - t.Fatalf(format+"\n%s", append(args, StackTrace())...) -} - -func StackTrace() string { - return stackTrace(false) -} - func stackTrace(all bool) string { buf := make([]byte, 1<<20) stacklen := runtime.Stack(buf, all) From aea1a2b08c5f73714d035c26ae28d401736a5bf1 Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Wed, 17 Jun 2015 17:00:36 +0100 Subject: [PATCH 4/4] have travis fetch any test-only dependencies before building tests --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index 76176d744b..3e39eef01d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -18,6 +18,7 @@ install: - pip install --user --upgrade gcloud gsutil - bin/setup-ci-secrets $encrypted_5ba036e89377_key $encrypted_5ba036e89377_iv - make travis + - go get ./... script: - bin/lint .