Replacing custom testing helpers with testify, where possible

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")
 }

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")
 }

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")
 }

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.

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)
 	}

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 {

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

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))
 }

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"))

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)")
 }

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")
 }

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")
 }