Update tests to use sweet

aphistic · Jul 12, 2018 · eb93248 · eb93248
1 parent b8be15e
commit eb93248
Show file tree

Hide file tree

Showing 8 changed files with 127 additions and 104 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -1,12 +1,10 @@
 language: go
 
 go:
-    - 1.2
-    - 1.3
-    - 1.4
-    - 1.5
-    - 1.6
     - 1.7
+    - 1.8
+    - 1.9
+    - 1.10
     - tip
 
 script:

diff --git a/chunker.go b/chunker.go
@@ -16,7 +16,7 @@ type chunker struct {
 
 func newChunker(w io.Writer, chunkSize int) (*chunker, error) {
 	if chunkSize < 13 {
-		return nil, errors.New("Chunk size must be at least 13.")
+		return nil, ErrChunkTooSmall
 	}
 
 	c := &chunker{

diff --git a/chunker_test.go b/chunker_test.go
@@ -1,44 +1,45 @@
 package golf
 
 import (
-	. "gopkg.in/check.v1"
+	"fmt"
+
+	"github.com/aphistic/sweet"
+	. "github.com/onsi/gomega"
 )
 
-func (s *GolfSuite) TestChunkerNew(c *C) {
+type ChunkerSuite struct{}
+
+func (s *ChunkerSuite) TestChunkerNew(t sweet.T) {
 	w := newTestWriter()
 	chnk, err := newChunker(w, 1234)
 
-	c.Check(err, IsNil)
+	Expect(err).To(BeNil())
 
-	c.Check(chnk, NotNil)
-	c.Check(chnk, NotNil)
-	c.Check(chnk.w, Equals, w)
-	c.Check(chnk.chunkSize, Equals, 1234)
+	Expect(chnk).ToNot(BeNil())
+	Expect(chnk.w).To(Equal(w))
+	Expect(chnk.chunkSize).To(Equal(1234))
 }
 
-func (s *GolfSuite) TestChunkerNewChunkTooSmall(c *C) {
+func (s *ChunkerSuite) TestChunkerNewChunkTooSmall(t sweet.T) {
 	w := newTestWriter()
 
 	_, err := newChunker(w, -1)
-	c.Check(err, NotNil)
-	c.Check(err.Error(), Equals, "Chunk size must be at least 13.")
+	Expect(err).To(Equal(ErrChunkTooSmall))
 }
 
-func (s *GolfSuite) TestChunkerWrite(c *C) {
+func (s *ChunkerSuite) TestChunkerWrite(t sweet.T) {
 	chnk, _ := newChunker(nil, 15)
 
-	c.Check(chnk.buff, HasLen, 0)
+	Expect(chnk.buff).To(HaveLen(0))
 
 	chnk.Write([]byte{1, 2, 3, 4})
-	c.Check(chnk.buff, HasLen, 4)
-	c.Check(chnk.buff[0:], DeepEquals, []byte{1, 2, 3, 4})
+	Expect(chnk.buff).To(Equal([]byte{1, 2, 3, 4}))
 
 	chnk.Write([]byte{5, 6, 7, 8})
-	c.Check(chnk.buff, HasLen, 8)
-	c.Check(chnk.buff[0:], DeepEquals, []byte{1, 2, 3, 4, 5, 6, 7, 8})
+	Expect(chnk.buff).To(Equal([]byte{1, 2, 3, 4, 5, 6, 7, 8}))
 }
 
-func (s *GolfSuite) TestChunkerFlush(c *C) {
+func (s *ChunkerSuite) TestChunkerFlush(t sweet.T) {
 	// With a chunk size of 13 it should leave space for 1 byte of
 	// data after the header (12 bytes). So there should be a total
 	// of 5 packets written
@@ -47,35 +48,28 @@ func (s *GolfSuite) TestChunkerFlush(c *C) {
 	chnk, _ := newChunker(w, 13)
 
 	chnk.Write([]byte{1, 2, 3, 4, 5})
-	c.Check(chnk.buff, HasLen, 5)
+	Expect(chnk.buff).To(Equal([]byte{1, 2, 3, 4, 5}))
 
 	chnk.flushWithId([]byte{1, 2, 3, 4, 5, 6, 7, 8})
 
-	c.Assert(w.Written, HasLen, 5)
+	Expect(w.Written).To(HaveLen(5))
 
-	c.Check(w.Written[0], DeepEquals,
-		[]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 0, 5, 1})
-	c.Check(w.Written[1], DeepEquals,
-		[]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 1, 5, 2})
-	c.Check(w.Written[2], DeepEquals,
-		[]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 2, 5, 3})
-	c.Check(w.Written[3], DeepEquals,
-		[]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 3, 5, 4})
-	c.Check(w.Written[4], DeepEquals,
-		[]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 4, 5, 5})
+	Expect(w.Written[0]).To(Equal([]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 0, 5, 1}))
+	Expect(w.Written[1]).To(Equal([]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 1, 5, 2}))
+	Expect(w.Written[2]).To(Equal([]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 2, 5, 3}))
+	Expect(w.Written[3]).To(Equal([]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 3, 5, 4}))
+	Expect(w.Written[4]).To(Equal([]byte{0x1e, 0x0f, 1, 2, 3, 4, 5, 6, 7, 8, 4, 5, 5}))
 
-	c.Check(chnk.buff, HasLen, 0)
+	Expect(chnk.buff).To(Equal([]byte{}))
 }
 
-func (s *GolfSuite) TestChunkerFlushIdLength(c *C) {
+func (s *ChunkerSuite) TestChunkerFlushIdLength(t sweet.T) {
 	chnk, _ := newChunker(newTestWriter(), 13)
 	chnk.Write([]byte{1, 2, 3, 4, 5})
 
 	err := chnk.flushWithId([]byte{1, 2, 3, 4, 5, 6, 7})
-	c.Check(err, NotNil)
-	c.Check(err.Error(), Equals, "id length must be equal to 8")
+	Expect(err).To(Equal(fmt.Errorf("id length must be equal to 8")))
 
 	err = chnk.flushWithId([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9})
-	c.Check(err, NotNil)
-	c.Check(err.Error(), Equals, "id length must be equal to 8")
+	Expect(err).To(Equal(fmt.Errorf("id length must be equal to 8")))
 }
diff --git a/errors.go b/errors.go
@@ -0,0 +1,9 @@
+package golf
+
+import (
+	"errors"
+)
+
+var (
+	ErrChunkTooSmall = errors.New("chunk size is too small, it must be at least 13")
+)
diff --git a/json_test.go b/json_test.go
@@ -1,33 +1,38 @@
 package golf
 
 import (
-	. "gopkg.in/check.v1"
 	"time"
+
+	"github.com/aphistic/sweet"
+	. "github.com/onsi/gomega"
 )
 
-func (s *GolfSuite) TestJsonFloatNew(c *C) {
+type JSONSuite struct{}
+
+func (s *JSONSuite) TestJsonFloatNew(t sweet.T) {
 	f := newJsonFloat(12345)
-	c.Check(f.val, Equals, float64(12345))
+
+	Expect(f.val).To(Equal(float64(12345)))
 }
 
-func (s *GolfSuite) TestJsonFloatJson(c *C) {
+func (s *JSONSuite) TestJsonFloatJson(t sweet.T) {
 	f := newJsonFloat(float64(1440387554.671944965))
 
-	c.Check(f.val, Equals, 1440387554.671944965)
+	Expect(f.val).To(Equal(1440387554.671944965))
 
 	json, err := f.MarshalJSON()
-	c.Logf("%v", string(json))
-	c.Check(err, IsNil)
-	c.Check(string(json), Equals, "1440387554.671945")
+	t.Logf("%v", string(json))
+	Expect(err).To(BeNil())
+	Expect(string(json)).To(Equal("1440387554.671945"))
 }
 
-func (s *GolfSuite) TestJsonNoLogger(c *C) {
+func (s *JSONSuite) TestJsonNoLogger(t sweet.T) {
 	msg := newMessage()
 	msg.Level = LEVEL_CRIT
 	msg.Hostname = "hostname"
 
-	t := time.Unix(0, 1440387554671944965)
-	msg.Timestamp = &t
+	ts := time.Unix(0, 1440387554671944965)
+	msg.Timestamp = &ts
 
 	msg.ShortMessage = "short_message"
 	msg.FullMessage = "full_message"
@@ -36,14 +41,14 @@ func (s *GolfSuite) TestJsonNoLogger(c *C) {
 	msg.Attrs["attr2"] = 1234
 
 	json, _ := generateMsgJson(msg)
-	c.Check(json, Equals, `{`+
-		`"_attr1":"val1","_attr2":1234,"full_message":"full_message",`+
-		`"host":"hostname","level":2,"short_message":"short_message",`+
-		`"timestamp":1440387554.671945,"version":"1.1"`+
-		`}`)
+	Expect(json).To(Equal(`{` +
+		`"_attr1":"val1","_attr2":1234,"full_message":"full_message",` +
+		`"host":"hostname","level":2,"short_message":"short_message",` +
+		`"timestamp":1440387554.671945,"version":"1.1"` +
+		`}`))
 }
 
-func (s *GolfSuite) TestJsonWithLogger(c *C) {
+func (s *JSONSuite) TestJsonWithLogger(t sweet.T) {
 	l := newLogger()
 	l.SetAttr("attr1", "notval1")
 	l.SetAttr("attr3", "val3")
@@ -53,8 +58,8 @@ func (s *GolfSuite) TestJsonWithLogger(c *C) {
 	msg.Level = LEVEL_CRIT
 	msg.Hostname = "hostname"
 
-	t := time.Unix(0, 1440387554671944965)
-	msg.Timestamp = &t
+	ts := time.Unix(0, 1440387554671944965)
+	msg.Timestamp = &ts
 
 	msg.ShortMessage = "short_message"
 	msg.FullMessage = "full_message"
@@ -63,10 +68,10 @@ func (s *GolfSuite) TestJsonWithLogger(c *C) {
 	msg.Attrs["attr2"] = 1234
 
 	json, _ := generateMsgJson(msg)
-	c.Check(json, Equals, `{`+
-		`"_attr1":"val1","_attr2":1234,"_attr3":"val3",`+
-		`"full_message":"full_message","host":"hostname","level":2,`+
-		`"short_message":"short_message","timestamp":1440387554.671945,`+
-		`"version":"1.1"`+
-		`}`)
+	Expect(json).To(Equal(`{` +
+		`"_attr1":"val1","_attr2":1234,"_attr3":"val3",` +
+		`"full_message":"full_message","host":"hostname","level":2,` +
+		`"short_message":"short_message","timestamp":1440387554.671945,` +
+		`"version":"1.1"` +
+		`}`))
 }
diff --git a/log_default_test.go b/log_default_test.go
@@ -1,39 +1,44 @@
 package golf
 
 import (
-	. "gopkg.in/check.v1"
+	"github.com/aphistic/sweet"
+	. "github.com/onsi/gomega"
 )
 
-func (s *GolfSuite) TestGenDefaultMessageWithFormatNoParams(c *C) {
+func (s *GolfSuite) TestGenDefaultMessageWithFormatNoParams(t sweet.T) {
 	cl, err := NewClient()
-	c.Assert(cl, NotNil)
-	c.Assert(err, IsNil)
+	Expect(err).To(BeNil())
+	Expect(cl).ToNot(BeNil())
+
 	l, err := cl.NewLogger()
-	c.Assert(l, NotNil)
-	c.Assert(err, IsNil)
+	Expect(err).To(BeNil())
+	Expect(l).ToNot(BeNil())
+
 	DefaultLogger(l)
 
 	// Tests to make sure a string won't be double-formatted if
 	// no paramters are passed to the format string
 	msg := genDefaultMsg(nil, 1, "%2b")
-	c.Check(msg.Level, Equals, 1)
-	c.Check(msg.ShortMessage, Equals, "%2b")
-	c.Check(msg.Attrs, IsNil)
+	Expect(msg.Level).To(Equal(1))
+	Expect(msg.ShortMessage).To(Equal("%2b"))
+	Expect(msg.Attrs).To(BeNil())
 }
 
-func (s *GolfSuite) TestGenDefaultMessageWithFormat(c *C) {
+func (s *GolfSuite) TestGenDefaultMessageWithFormat(t sweet.T) {
 	cl, err := NewClient()
-	c.Assert(cl, NotNil)
-	c.Assert(err, IsNil)
+	Expect(err).To(BeNil())
+	Expect(cl).ToNot(BeNil())
+
 	l, err := cl.NewLogger()
-	c.Assert(l, NotNil)
-	c.Assert(err, IsNil)
+	Expect(err).To(BeNil())
+	Expect(l).ToNot(BeNil())
+
 	DefaultLogger(l)
 
 	// Tests to make sure a string will be formatted if
 	// paramters are passed to the format string
 	msg := genDefaultMsg(nil, 1, "%2b", true)
-	c.Check(msg.Level, Equals, 1)
-	c.Check(msg.ShortMessage, Equals, "%!b(bool=true)")
-	c.Check(msg.Attrs, IsNil)
+	Expect(msg.Level).To(Equal(1))
+	Expect(msg.ShortMessage).To(Equal("%!b(bool=true)"))
+	Expect(msg.Attrs).To(BeNil())
 }
diff --git a/log_test.go b/log_test.go
@@ -1,35 +1,40 @@
 package golf
 
-import . "gopkg.in/check.v1"
+import (
+	"github.com/aphistic/sweet"
+	. "github.com/onsi/gomega"
+)
 
-func (s *GolfSuite) TestGenMessageWithFormatNoParams(c *C) {
+func (s *GolfSuite) TestGenMessageWithFormatNoParams(t sweet.T) {
 	cl, err := NewClient()
-	c.Assert(cl, NotNil)
-	c.Assert(err, IsNil)
+	Expect(err).To(BeNil())
+	Expect(cl).ToNot(BeNil())
+
 	l, err := cl.NewLogger()
-	c.Assert(l, NotNil)
-	c.Assert(err, IsNil)
+	Expect(err).To(BeNil())
+	Expect(l).ToNot(BeNil())
 
 	// Tests to make sure a string won't be double-formatted if
 	// no paramters are passed to the format string
 	msg := l.genMsg(nil, 1, "%2b")
-	c.Check(msg.Level, Equals, 1)
-	c.Check(msg.ShortMessage, Equals, "%2b")
-	c.Check(msg.Attrs, IsNil)
+	Expect(msg.Level).To(Equal(1))
+	Expect(msg.ShortMessage).To(Equal("%2b"))
+	Expect(msg.Attrs).To(BeNil())
 }
 
-func (s *GolfSuite) TestGenMessageWithFormat(c *C) {
+func (s *GolfSuite) TestGenMessageWithFormat(t sweet.T) {
 	cl, err := NewClient()
-	c.Assert(cl, NotNil)
-	c.Assert(err, IsNil)
+	Expect(err).To(BeNil())
+	Expect(cl).ToNot(BeNil())
+
 	l, err := cl.NewLogger()
-	c.Assert(l, NotNil)
-	c.Assert(err, IsNil)
+	Expect(err).To(BeNil())
+	Expect(l).ToNot(BeNil())
 
 	// Tests to make sure a string will be formatted if
 	// paramters are passed to the format string
 	msg := l.genMsg(nil, 1, "%2b", true)
-	c.Check(msg.Level, Equals, 1)
-	c.Check(msg.ShortMessage, Equals, "%!b(bool=true)")
-	c.Check(msg.Attrs, IsNil)
+	Expect(msg.Level).To(Equal(1))
+	Expect(msg.ShortMessage).To(Equal("%!b(bool=true)"))
+	Expect(msg.Attrs).To(BeNil())
 }
diff --git a/main_test.go b/main_test.go
@@ -1,15 +1,22 @@
 package golf
 
 import (
-	. "gopkg.in/check.v1"
 	"testing"
+
+	"github.com/aphistic/sweet"
+	. "github.com/onsi/gomega"
 )
 
-func Test(t *testing.T) { TestingT(t) }
+func TestMain(m *testing.M) {
+	RegisterFailHandler(sweet.GomegaFail)
 
-type GolfSuite struct{}
+	sweet.Run(m, func(s *sweet.S) {
+		s.AddSuite(&ChunkerSuite{})
+		s.AddSuite(&GolfSuite{})
+	})
+}
 
-var _ = Suite(&GolfSuite{})
+type GolfSuite struct{}
 
 func Example() {
 	c, _ := NewClient()