From 890fa18dc5ebf1ef8a9289b64f8dd0f21c413e1d Mon Sep 17 00:00:00 2001 From: Morgan Bauer Date: Thu, 1 Oct 2015 17:02:38 -0700 Subject: [PATCH] remove testify asserts from pkg/discovery Signed-off-by: Morgan Bauer --- discovery/discovery_test.go | 105 +++++++++++++++++++--------------- discovery/file/file_test.go | 72 ++++++++++++----------- discovery/generator_test.go | 60 ++++++++++--------- discovery/kv/kv_test.go | 66 +++++++++++---------- discovery/nodes/nodes_test.go | 40 +++++++------ 5 files changed, 188 insertions(+), 155 deletions(-) diff --git a/discovery/discovery_test.go b/discovery/discovery_test.go index b7128ff..ed0964d 100644 --- a/discovery/discovery_test.go +++ b/discovery/discovery_test.go @@ -3,92 +3,103 @@ package discovery import ( "testing" - "github.com/stretchr/testify/assert" + "github.com/go-check/check" ) -func TestNewEntry(t *testing.T) { +// Hook up gocheck into the "go test" runner. +func Test(t *testing.T) { check.TestingT(t) } + +type DiscoverySuite struct{} + +var _ = check.Suite(&DiscoverySuite{}) + +func (s *DiscoverySuite) TestNewEntry(c *check.C) { entry, err := NewEntry("127.0.0.1:2375") - assert.NoError(t, err) - assert.True(t, entry.Equals(&Entry{Host: "127.0.0.1", Port: "2375"})) - assert.Equal(t, entry.String(), "127.0.0.1:2375") + c.Assert(err, check.IsNil) + c.Assert(entry.Equals(&Entry{Host: "127.0.0.1", Port: "2375"}), check.Equals, true) + c.Assert(entry.String(), check.Equals, "127.0.0.1:2375") _, err = NewEntry("127.0.0.1") - assert.Error(t, err) + c.Assert(err, check.NotNil) } -func TestParse(t *testing.T) { +func (s *DiscoverySuite) TestParse(c *check.C) { scheme, uri := parse("127.0.0.1:2375") - assert.Equal(t, scheme, "nodes") - assert.Equal(t, uri, "127.0.0.1:2375") + c.Assert(scheme, check.Equals, "nodes") + c.Assert(uri, check.Equals, "127.0.0.1:2375") scheme, uri = parse("localhost:2375") - assert.Equal(t, scheme, "nodes") - assert.Equal(t, uri, "localhost:2375") + c.Assert(scheme, check.Equals, "nodes") + c.Assert(uri, check.Equals, "localhost:2375") scheme, uri = parse("scheme://127.0.0.1:2375") - assert.Equal(t, scheme, "scheme") - assert.Equal(t, uri, "127.0.0.1:2375") + c.Assert(scheme, check.Equals, "scheme") + c.Assert(uri, check.Equals, "127.0.0.1:2375") scheme, uri = parse("scheme://localhost:2375") - assert.Equal(t, scheme, "scheme") - assert.Equal(t, uri, "localhost:2375") + c.Assert(scheme, check.Equals, "scheme") + c.Assert(uri, check.Equals, "localhost:2375") scheme, uri = parse("") - assert.Equal(t, scheme, "nodes") - assert.Equal(t, uri, "") + c.Assert(scheme, check.Equals, "nodes") + c.Assert(uri, check.Equals, "") } -func TestCreateEntries(t *testing.T) { +func (s *DiscoverySuite) TestCreateEntries(c *check.C) { entries, err := CreateEntries(nil) - assert.Equal(t, entries, Entries{}) - assert.NoError(t, err) + c.Assert(entries, check.DeepEquals, Entries{}) + c.Assert(err, check.IsNil) entries, err = CreateEntries([]string{"127.0.0.1:2375", "127.0.0.2:2375", ""}) - assert.NoError(t, err) + c.Assert(err, check.IsNil) expected := Entries{ &Entry{Host: "127.0.0.1", Port: "2375"}, &Entry{Host: "127.0.0.2", Port: "2375"}, } - assert.True(t, entries.Equals(expected)) + c.Assert(entries.Equals(expected), check.Equals, true) _, err = CreateEntries([]string{"127.0.0.1", "127.0.0.2"}) - assert.Error(t, err) + c.Assert(err, check.NotNil) } -func TestContainsEntry(t *testing.T) { +func (s *DiscoverySuite) TestContainsEntry(c *check.C) { entries, err := CreateEntries([]string{"127.0.0.1:2375", "127.0.0.2:2375", ""}) - assert.NoError(t, err) - assert.True(t, entries.Contains(&Entry{Host: "127.0.0.1", Port: "2375"})) - assert.False(t, entries.Contains(&Entry{Host: "127.0.0.3", Port: "2375"})) + c.Assert(err, check.IsNil) + c.Assert(entries.Contains(&Entry{Host: "127.0.0.1", Port: "2375"}), check.Equals, true) + c.Assert(entries.Contains(&Entry{Host: "127.0.0.3", Port: "2375"}), check.Equals, false) } -func TestEntriesEquality(t *testing.T) { +func (s *DiscoverySuite) TestEntriesEquality(c *check.C) { entries := Entries{ &Entry{Host: "127.0.0.1", Port: "2375"}, &Entry{Host: "127.0.0.2", Port: "2375"}, } // Same - assert.True(t, entries.Equals(Entries{ + c.Assert(entries.Equals(Entries{ &Entry{Host: "127.0.0.1", Port: "2375"}, &Entry{Host: "127.0.0.2", Port: "2375"}, - })) + }), check. + Equals, true) // Different size - assert.False(t, entries.Equals(Entries{ + c.Assert(entries.Equals(Entries{ &Entry{Host: "127.0.0.1", Port: "2375"}, &Entry{Host: "127.0.0.2", Port: "2375"}, &Entry{Host: "127.0.0.3", Port: "2375"}, - })) + }), check. + Equals, false) // Different content - assert.False(t, entries.Equals(Entries{ + c.Assert(entries.Equals(Entries{ &Entry{Host: "127.0.0.1", Port: "2375"}, &Entry{Host: "127.0.0.42", Port: "2375"}, - })) + }), check. + Equals, false) + } -func TestEntriesDiff(t *testing.T) { +func (s *DiscoverySuite) TestEntriesDiff(c *check.C) { entry1 := &Entry{Host: "1.1.1.1", Port: "1111"} entry2 := &Entry{Host: "2.2.2.2", Port: "2222"} entry3 := &Entry{Host: "3.3.3.3", Port: "3333"} @@ -96,25 +107,25 @@ func TestEntriesDiff(t *testing.T) { // No diff added, removed := entries.Diff(Entries{entry2, entry1}) - assert.Empty(t, added) - assert.Empty(t, removed) + c.Assert(added, check.HasLen, 0) + c.Assert(removed, check.HasLen, 0) // Add added, removed = entries.Diff(Entries{entry2, entry3, entry1}) - assert.Len(t, added, 1) - assert.True(t, added.Contains(entry3)) - assert.Empty(t, removed) + c.Assert(added, check.HasLen, 1) + c.Assert(added.Contains(entry3), check.Equals, true) + c.Assert(removed, check.HasLen, 0) // Remove added, removed = entries.Diff(Entries{entry2}) - assert.Empty(t, added) - assert.Len(t, removed, 1) - assert.True(t, removed.Contains(entry1)) + c.Assert(added, check.HasLen, 0) + c.Assert(removed, check.HasLen, 1) + c.Assert(removed.Contains(entry1), check.Equals, true) // Add and remove added, removed = entries.Diff(Entries{entry1, entry3}) - assert.Len(t, added, 1) - assert.True(t, added.Contains(entry3)) - assert.Len(t, removed, 1) - assert.True(t, removed.Contains(entry2)) + c.Assert(added, check.HasLen, 1) + c.Assert(added.Contains(entry3), check.Equals, true) + c.Assert(removed, check.HasLen, 1) + c.Assert(removed.Contains(entry2), check.Equals, true) } diff --git a/discovery/file/file_test.go b/discovery/file/file_test.go index e9e2848..3289542 100644 --- a/discovery/file/file_test.go +++ b/discovery/file/file_test.go @@ -6,41 +6,49 @@ import ( "testing" "github.com/docker/docker/pkg/discovery" - "github.com/stretchr/testify/assert" + + "github.com/go-check/check" ) -func TestInitialize(t *testing.T) { +// Hook up gocheck into the "go test" runner. +func Test(t *testing.T) { check.TestingT(t) } + +type DiscoverySuite struct{} + +var _ = check.Suite(&DiscoverySuite{}) + +func (s *DiscoverySuite) TestInitialize(c *check.C) { d := &Discovery{} d.Initialize("/path/to/file", 1000, 0) - assert.Equal(t, d.path, "/path/to/file") + c.Assert(d.path, check.Equals, "/path/to/file") } -func TestNew(t *testing.T) { +func (s *DiscoverySuite) TestNew(c *check.C) { d, err := discovery.New("file:///path/to/file", 0, 0) - assert.NoError(t, err) - assert.Equal(t, d.(*Discovery).path, "/path/to/file") + c.Assert(err, check.IsNil) + c.Assert(d.(*Discovery).path, check.Equals, "/path/to/file") } -func TestContent(t *testing.T) { +func (s *DiscoverySuite) TestContent(c *check.C) { data := ` 1.1.1.[1:2]:1111 2.2.2.[2:4]:2222 ` ips := parseFileContent([]byte(data)) - assert.Len(t, ips, 5) - assert.Equal(t, ips[0], "1.1.1.1:1111") - assert.Equal(t, ips[1], "1.1.1.2:1111") - assert.Equal(t, ips[2], "2.2.2.2:2222") - assert.Equal(t, ips[3], "2.2.2.3:2222") - assert.Equal(t, ips[4], "2.2.2.4:2222") + c.Assert(ips, check.HasLen, 5) + c.Assert(ips[0], check.Equals, "1.1.1.1:1111") + c.Assert(ips[1], check.Equals, "1.1.1.2:1111") + c.Assert(ips[2], check.Equals, "2.2.2.2:2222") + c.Assert(ips[3], check.Equals, "2.2.2.3:2222") + c.Assert(ips[4], check.Equals, "2.2.2.4:2222") } -func TestRegister(t *testing.T) { +func (s *DiscoverySuite) TestRegister(c *check.C) { discovery := &Discovery{path: "/path/to/file"} - assert.Error(t, discovery.Register("0.0.0.0")) + c.Assert(discovery.Register("0.0.0.0"), check.NotNil) } -func TestParsingContentsWithComments(t *testing.T) { +func (s *DiscoverySuite) TestParsingContentsWithComments(c *check.C) { data := ` ### test ### 1.1.1.1:1111 # inline comment @@ -50,12 +58,12 @@ func TestParsingContentsWithComments(t *testing.T) { ### test ### ` ips := parseFileContent([]byte(data)) - assert.Len(t, ips, 2) - assert.Equal(t, "1.1.1.1:1111", ips[0]) - assert.Equal(t, "3.3.3.3:3333", ips[1]) + c.Assert(ips, check.HasLen, 2) + c.Assert("1.1.1.1:1111", check.Equals, ips[0]) + c.Assert("3.3.3.3:3333", check.Equals, ips[1]) } -func TestWatch(t *testing.T) { +func (s *DiscoverySuite) TestWatch(c *check.C) { data := ` 1.1.1.1:1111 2.2.2.2:2222 @@ -67,9 +75,9 @@ func TestWatch(t *testing.T) { // Create a temporary file and remove it. tmp, err := ioutil.TempFile(os.TempDir(), "discovery-file-test") - assert.NoError(t, err) - assert.NoError(t, tmp.Close()) - assert.NoError(t, os.Remove(tmp.Name())) + c.Assert(err, check.IsNil) + c.Assert(tmp.Close(), check.IsNil) + c.Assert(os.Remove(tmp.Name()), check.IsNil) // Set up file discovery. d := &Discovery{} @@ -78,7 +86,7 @@ func TestWatch(t *testing.T) { ch, errCh := d.Watch(stopCh) // Make sure it fires errors since the file doesn't exist. - assert.Error(t, <-errCh) + c.Assert(<-errCh, check.NotNil) // We have to drain the error channel otherwise Watch will get stuck. go func() { for range errCh { @@ -86,21 +94,21 @@ func TestWatch(t *testing.T) { }() // Write the file and make sure we get the expected value back. - assert.NoError(t, ioutil.WriteFile(tmp.Name(), []byte(data), 0600)) - assert.Equal(t, expected, <-ch) + c.Assert(ioutil.WriteFile(tmp.Name(), []byte(data), 0600), check.IsNil) + c.Assert(<-ch, check.DeepEquals, expected) // Add a new entry and look it up. expected = append(expected, &discovery.Entry{Host: "3.3.3.3", Port: "3333"}) f, err := os.OpenFile(tmp.Name(), os.O_APPEND|os.O_WRONLY, 0600) - assert.NoError(t, err) - assert.NotNil(t, f) + c.Assert(err, check.IsNil) + c.Assert(f, check.NotNil) _, err = f.WriteString("\n3.3.3.3:3333\n") - assert.NoError(t, err) + c.Assert(err, check.IsNil) f.Close() - assert.Equal(t, expected, <-ch) + c.Assert(<-ch, check.DeepEquals, expected) // Stop and make sure it closes all channels. close(stopCh) - assert.Nil(t, <-ch) - assert.Nil(t, <-errCh) + c.Assert(<-ch, check.IsNil) + c.Assert(<-errCh, check.IsNil) } diff --git a/discovery/generator_test.go b/discovery/generator_test.go index 7473344..6281c46 100644 --- a/discovery/generator_test.go +++ b/discovery/generator_test.go @@ -1,55 +1,53 @@ package discovery import ( - "testing" - - "github.com/stretchr/testify/assert" + "github.com/go-check/check" ) -func TestGeneratorNotGenerate(t *testing.T) { +func (s *DiscoverySuite) TestGeneratorNotGenerate(c *check.C) { ips := Generate("127.0.0.1") - assert.Equal(t, len(ips), 1) - assert.Equal(t, ips[0], "127.0.0.1") + c.Assert(len(ips), check.Equals, 1) + c.Assert(ips[0], check.Equals, "127.0.0.1") } -func TestGeneratorWithPortNotGenerate(t *testing.T) { +func (s *DiscoverySuite) TestGeneratorWithPortNotGenerate(c *check.C) { ips := Generate("127.0.0.1:8080") - assert.Equal(t, len(ips), 1) - assert.Equal(t, ips[0], "127.0.0.1:8080") + c.Assert(len(ips), check.Equals, 1) + c.Assert(ips[0], check.Equals, "127.0.0.1:8080") } -func TestGeneratorMatchFailedNotGenerate(t *testing.T) { +func (s *DiscoverySuite) TestGeneratorMatchFailedNotGenerate(c *check.C) { ips := Generate("127.0.0.[1]") - assert.Equal(t, len(ips), 1) - assert.Equal(t, ips[0], "127.0.0.[1]") + c.Assert(len(ips), check.Equals, 1) + c.Assert(ips[0], check.Equals, "127.0.0.[1]") } -func TestGeneratorWithPort(t *testing.T) { +func (s *DiscoverySuite) TestGeneratorWithPort(c *check.C) { ips := Generate("127.0.0.[1:11]:2375") - assert.Equal(t, len(ips), 11) - assert.Equal(t, ips[0], "127.0.0.1:2375") - assert.Equal(t, ips[1], "127.0.0.2:2375") - assert.Equal(t, ips[2], "127.0.0.3:2375") - assert.Equal(t, ips[3], "127.0.0.4:2375") - assert.Equal(t, ips[4], "127.0.0.5:2375") - assert.Equal(t, ips[5], "127.0.0.6:2375") - assert.Equal(t, ips[6], "127.0.0.7:2375") - assert.Equal(t, ips[7], "127.0.0.8:2375") - assert.Equal(t, ips[8], "127.0.0.9:2375") - assert.Equal(t, ips[9], "127.0.0.10:2375") - assert.Equal(t, ips[10], "127.0.0.11:2375") + c.Assert(len(ips), check.Equals, 11) + c.Assert(ips[0], check.Equals, "127.0.0.1:2375") + c.Assert(ips[1], check.Equals, "127.0.0.2:2375") + c.Assert(ips[2], check.Equals, "127.0.0.3:2375") + c.Assert(ips[3], check.Equals, "127.0.0.4:2375") + c.Assert(ips[4], check.Equals, "127.0.0.5:2375") + c.Assert(ips[5], check.Equals, "127.0.0.6:2375") + c.Assert(ips[6], check.Equals, "127.0.0.7:2375") + c.Assert(ips[7], check.Equals, "127.0.0.8:2375") + c.Assert(ips[8], check.Equals, "127.0.0.9:2375") + c.Assert(ips[9], check.Equals, "127.0.0.10:2375") + c.Assert(ips[10], check.Equals, "127.0.0.11:2375") } -func TestGenerateWithMalformedInputAtRangeStart(t *testing.T) { +func (s *DiscoverySuite) TestGenerateWithMalformedInputAtRangeStart(c *check.C) { malformedInput := "127.0.0.[x:11]:2375" ips := Generate(malformedInput) - assert.Equal(t, len(ips), 1) - assert.Equal(t, ips[0], malformedInput) + c.Assert(len(ips), check.Equals, 1) + c.Assert(ips[0], check.Equals, malformedInput) } -func TestGenerateWithMalformedInputAtRangeEnd(t *testing.T) { +func (s *DiscoverySuite) TestGenerateWithMalformedInputAtRangeEnd(c *check.C) { malformedInput := "127.0.0.[1:x]:2375" ips := Generate(malformedInput) - assert.Equal(t, len(ips), 1) - assert.Equal(t, ips[0], malformedInput) + c.Assert(len(ips), check.Equals, 1) + c.Assert(ips[0], check.Equals, malformedInput) } diff --git a/discovery/kv/kv_test.go b/discovery/kv/kv_test.go index dea34d6..514093e 100644 --- a/discovery/kv/kv_test.go +++ b/discovery/kv/kv_test.go @@ -9,58 +9,66 @@ import ( "github.com/docker/docker/pkg/discovery" "github.com/docker/libkv/store" libkvmock "github.com/docker/libkv/store/mock" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" + + "github.com/go-check/check" ) -func TestInitialize(t *testing.T) { +// Hook up gocheck into the "go test" runner. +func Test(t *testing.T) { check.TestingT(t) } + +type DiscoverySuite struct{} + +var _ = check.Suite(&DiscoverySuite{}) + +func (ds *DiscoverySuite) TestInitialize(c *check.C) { storeMock, err := libkvmock.New([]string{"127.0.0.1"}, nil) - assert.NotNil(t, storeMock) - assert.NoError(t, err) + c.Assert(storeMock, check.NotNil) + c.Assert(err, check.IsNil) d := &Discovery{backend: store.CONSUL} d.Initialize("127.0.0.1", 0, 0) d.store = storeMock s := d.store.(*libkvmock.Mock) - assert.Len(t, s.Endpoints, 1) - assert.Equal(t, s.Endpoints[0], "127.0.0.1") - assert.Equal(t, d.path, discoveryPath) + c.Assert(s.Endpoints, check.HasLen, 1) + c.Assert(s.Endpoints[0], check.Equals, "127.0.0.1") + c.Assert(d.path, check.Equals, discoveryPath) storeMock, err = libkvmock.New([]string{"127.0.0.1:1234"}, nil) - assert.NotNil(t, storeMock) - assert.NoError(t, err) + c.Assert(storeMock, check.NotNil) + c.Assert(err, check.IsNil) d = &Discovery{backend: store.CONSUL} d.Initialize("127.0.0.1:1234/path", 0, 0) d.store = storeMock s = d.store.(*libkvmock.Mock) - assert.Len(t, s.Endpoints, 1) - assert.Equal(t, s.Endpoints[0], "127.0.0.1:1234") - assert.Equal(t, d.path, "path/"+discoveryPath) + c.Assert(s.Endpoints, check.HasLen, 1) + c.Assert(s.Endpoints[0], check.Equals, "127.0.0.1:1234") + c.Assert(d.path, check.Equals, "path/"+discoveryPath) storeMock, err = libkvmock.New([]string{"127.0.0.1:1234", "127.0.0.2:1234", "127.0.0.3:1234"}, nil) - assert.NotNil(t, storeMock) - assert.NoError(t, err) + c.Assert(storeMock, check.NotNil) + c.Assert(err, check.IsNil) d = &Discovery{backend: store.CONSUL} d.Initialize("127.0.0.1:1234,127.0.0.2:1234,127.0.0.3:1234/path", 0, 0) d.store = storeMock s = d.store.(*libkvmock.Mock) - if assert.Len(t, s.Endpoints, 3) { - assert.Equal(t, s.Endpoints[0], "127.0.0.1:1234") - assert.Equal(t, s.Endpoints[1], "127.0.0.2:1234") - assert.Equal(t, s.Endpoints[2], "127.0.0.3:1234") - } - assert.Equal(t, d.path, "path/"+discoveryPath) + c.Assert(s.Endpoints, check.HasLen, 3) + c.Assert(s.Endpoints[0], check.Equals, "127.0.0.1:1234") + c.Assert(s.Endpoints[1], check.Equals, "127.0.0.2:1234") + c.Assert(s.Endpoints[2], check.Equals, "127.0.0.3:1234") + + c.Assert(d.path, check.Equals, "path/"+discoveryPath) } -func TestWatch(t *testing.T) { +func (ds *DiscoverySuite) TestWatch(c *check.C) { storeMock, err := libkvmock.New([]string{"127.0.0.1:1234"}, nil) - assert.NotNil(t, storeMock) - assert.NoError(t, err) + c.Assert(storeMock, check.NotNil) + c.Assert(err, check.IsNil) d := &Discovery{backend: store.CONSUL} d.Initialize("127.0.0.1:1234/path", 0, 0) @@ -86,7 +94,7 @@ func TestWatch(t *testing.T) { ch, errCh := d.Watch(stopCh) // It should fire an error since the first WatchTree call failed. - assert.EqualError(t, <-errCh, "test error") + c.Assert(<-errCh, check.ErrorMatches, "test error") // We have to drain the error channel otherwise Watch will get stuck. go func() { for range errCh { @@ -95,13 +103,13 @@ func TestWatch(t *testing.T) { // Push the entries into the store channel and make sure discovery emits. mockCh <- kvs - assert.Equal(t, <-ch, expected) + c.Assert(<-ch, check.DeepEquals, expected) // Add a new entry. expected = append(expected, &discovery.Entry{Host: "3.3.3.3", Port: "3333"}) kvs = append(kvs, &store.KVPair{Key: path.Join("path", discoveryPath, "3.3.3.3"), Value: []byte("3.3.3.3:3333")}) mockCh <- kvs - assert.Equal(t, <-ch, expected) + c.Assert(<-ch, check.DeepEquals, expected) // Make sure that if an error occurs it retries. // This third call to WatchTree will be checked later by AssertExpectations. @@ -112,8 +120,8 @@ func TestWatch(t *testing.T) { // Stop and make sure it closes all channels. close(stopCh) - assert.Nil(t, <-ch) - assert.Nil(t, <-errCh) + c.Assert(<-ch, check.IsNil) + c.Assert(<-errCh, check.IsNil) - s.AssertExpectations(t) + s.AssertExpectations(c) } diff --git a/discovery/nodes/nodes_test.go b/discovery/nodes/nodes_test.go index 4563551..f67cd5a 100644 --- a/discovery/nodes/nodes_test.go +++ b/discovery/nodes/nodes_test.go @@ -4,29 +4,37 @@ import ( "testing" "github.com/docker/docker/pkg/discovery" - "github.com/stretchr/testify/assert" + + "github.com/go-check/check" ) -func TestInitialize(t *testing.T) { +// Hook up gocheck into the "go test" runner. +func Test(t *testing.T) { check.TestingT(t) } + +type DiscoverySuite struct{} + +var _ = check.Suite(&DiscoverySuite{}) + +func (s *DiscoverySuite) TestInitialize(c *check.C) { d := &Discovery{} d.Initialize("1.1.1.1:1111,2.2.2.2:2222", 0, 0) - assert.Equal(t, len(d.entries), 2) - assert.Equal(t, d.entries[0].String(), "1.1.1.1:1111") - assert.Equal(t, d.entries[1].String(), "2.2.2.2:2222") + c.Assert(len(d.entries), check.Equals, 2) + c.Assert(d.entries[0].String(), check.Equals, "1.1.1.1:1111") + c.Assert(d.entries[1].String(), check.Equals, "2.2.2.2:2222") } -func TestInitializeWithPattern(t *testing.T) { +func (s *DiscoverySuite) TestInitializeWithPattern(c *check.C) { d := &Discovery{} d.Initialize("1.1.1.[1:2]:1111,2.2.2.[2:4]:2222", 0, 0) - assert.Equal(t, len(d.entries), 5) - assert.Equal(t, d.entries[0].String(), "1.1.1.1:1111") - assert.Equal(t, d.entries[1].String(), "1.1.1.2:1111") - assert.Equal(t, d.entries[2].String(), "2.2.2.2:2222") - assert.Equal(t, d.entries[3].String(), "2.2.2.3:2222") - assert.Equal(t, d.entries[4].String(), "2.2.2.4:2222") + c.Assert(len(d.entries), check.Equals, 5) + c.Assert(d.entries[0].String(), check.Equals, "1.1.1.1:1111") + c.Assert(d.entries[1].String(), check.Equals, "1.1.1.2:1111") + c.Assert(d.entries[2].String(), check.Equals, "2.2.2.2:2222") + c.Assert(d.entries[3].String(), check.Equals, "2.2.2.3:2222") + c.Assert(d.entries[4].String(), check.Equals, "2.2.2.4:2222") } -func TestWatch(t *testing.T) { +func (s *DiscoverySuite) TestWatch(c *check.C) { d := &Discovery{} d.Initialize("1.1.1.1:1111,2.2.2.2:2222", 0, 0) expected := discovery.Entries{ @@ -34,10 +42,10 @@ func TestWatch(t *testing.T) { &discovery.Entry{Host: "2.2.2.2", Port: "2222"}, } ch, _ := d.Watch(nil) - assert.True(t, expected.Equals(<-ch)) + c.Assert(expected.Equals(<-ch), check.Equals, true) } -func TestRegister(t *testing.T) { +func (s *DiscoverySuite) TestRegister(c *check.C) { d := &Discovery{} - assert.Error(t, d.Register("0.0.0.0")) + c.Assert(d.Register("0.0.0.0"), check.NotNil) }