Merge lp:~chipaca/ubuntu-push/protocol-testing into lp:ubuntu-push

[John Lenton]

split the testing facilities present in protocol_test out into protocol/testing

split the testing facilities present in protocol_test out into protocol/testing

[lp:~chipaca/ubuntu-push/protocol-testing]

27. By John Lenton on 2014-01-24

oops, testMsg too

28. By John Lenton on 2014-01-24

and if I remember to bzr add testing, everybody is happy

[Samuele Pedroni (pedronis)]

I'm a bit wondering why we would need to reuse these instead of testProtocol and friends in session_test.go

review: Needs Fixing

[Samuele Pedroni (pedronis)]

sorry, I wanted to pick need information

review: Needs Information

[John Lenton (chipaca)]

Ignorance, alone. Will tinker with testProtocol, hopefully it does what I need -- testConn is quite slow going!

Unmerged revisions

28. By John Lenton on 2014-01-24

and if I remember to bzr add testing, everybody is happy

27. By John Lenton on 2014-01-24

oops, testMsg too

26. By John Lenton on 2014-01-24

split the testing facilities present in protocol_test out into protocol/testing

25. By John Lenton on 2014-01-23

Merged redialer into bushtest.

24. By John Lenton on 2014-01-23

unit tests, schmnit tests. Covered a bit of bus with an integration test.

=== modified file 'protocol/protocol_test.go'
--- protocol/protocol_test.go	2014-01-14 15:35:20 +0000
+++ protocol/protocol_test.go	2014-01-24 00:49:53 +0000
@@ -22,7 +22,7 @@
 	// "fmt"
 	"io"
 	. "launchpad.net/gocheck"
-	"net"
+	teepot "launchpad.net/ubuntu-push/protocol/testing"
 	"testing"
 	"time"
 )
@@ -33,112 +33,32 @@
 
 var _ = Suite(&protocolSuite{})
 
-type deadline struct {
-	kind      string
-	deadAfter time.Duration
-}
-
-func (d *deadline) setDeadAfter(t time.Time) {
-	deadAfter := t.Sub(time.Now())
-	d.deadAfter = (deadAfter + time.Millisecond/2) / time.Millisecond * time.Millisecond
-}
-
-type rw struct {
-	buf []byte
-	n   int
-	err error
-}
-
-type testConn struct {
-	deadlines []*deadline
-	reads     []rw
-	writes    []*rw
-}
-
-func (tc *testConn) LocalAddr() net.Addr {
-	return nil
-}
-
-func (tc *testConn) RemoteAddr() net.Addr {
-	return nil
-}
-
-func (tc *testConn) Close() error {
-	return nil
-}
-
-func (tc *testConn) SetDeadline(t time.Time) error {
-	deadline := tc.deadlines[0]
-	deadline.kind = "both"
-	deadline.setDeadAfter(t)
-	tc.deadlines = tc.deadlines[1:]
-	return nil
-}
-
-func (tc *testConn) SetReadDeadline(t time.Time) error {
-	deadline := tc.deadlines[0]
-	deadline.kind = "read"
-	deadline.setDeadAfter(t)
-	tc.deadlines = tc.deadlines[1:]
-	return nil
-}
-
-func (tc *testConn) SetWriteDeadline(t time.Time) error {
-	deadline := tc.deadlines[0]
-	deadline.kind = "write"
-	deadline.setDeadAfter(t)
-	tc.deadlines = tc.deadlines[1:]
-	return nil
-}
-
-func (tc *testConn) Read(buf []byte) (n int, err error) {
-	read := tc.reads[0]
-	copy(buf, read.buf)
-	tc.reads = tc.reads[1:]
-	return read.n, read.err
-}
-
-func (tc *testConn) Write(buf []byte) (n int, err error) {
-	write := tc.writes[0]
-	n = copy(write.buf, buf)
-	write.buf = write.buf[:n]
-	write.n = n
-	err = write.err
-	tc.writes = tc.writes[1:]
-	return
-}
-
 func (s *protocolSuite) TestReadWireFormatVersion(c *C) {
-	deadl := deadline{}
-	read1 := rw{buf: []byte{42}, n: 1}
-	tc := &testConn{reads: []rw{read1}, deadlines: []*deadline{&deadl}}
+	deadl := teepot.Deadline{}
+	read1 := teepot.RW{Buf: []byte{42}, N: 1}
+	tc := &teepot.TestConn{Reads: []teepot.RW{read1}, Deadlines: []*teepot.Deadline{&deadl}}
 	ver, err := ReadWireFormatVersion(tc, time.Minute)
 	c.Check(err, IsNil)
 	c.Check(ver, Equals, 42)
-	c.Check(deadl.kind, Equals, "read")
-	c.Check(deadl.deadAfter, Equals, time.Minute)
+	c.Check(deadl.Kind, Equals, "read")
+	c.Check(deadl.DeadAfter, Equals, time.Minute)
 }
 
 func (s *protocolSuite) TestReadWireFormatVersionError(c *C) {
-	deadl := deadline{}
-	read1 := rw{err: io.EOF}
-	tc := &testConn{reads: []rw{read1}, deadlines: []*deadline{&deadl}}
+	deadl := teepot.Deadline{}
+	read1 := teepot.RW{Err: io.EOF}
+	tc := &teepot.TestConn{Reads: []teepot.RW{read1}, Deadlines: []*teepot.Deadline{&deadl}}
 	_, err := ReadWireFormatVersion(tc, time.Minute)
 	c.Check(err, Equals, io.EOF)
 }
 
 func (s *protocolSuite) TestSetDeadline(c *C) {
-	deadl := deadline{}
-	tc := &testConn{deadlines: []*deadline{&deadl}}
+	deadl := teepot.Deadline{}
+	tc := &teepot.TestConn{Deadlines: []*teepot.Deadline{&deadl}}
 	pc := NewProtocol0(tc)
 	pc.SetDeadline(time.Now().Add(time.Minute))
-	c.Check(deadl.kind, Equals, "both")
-	c.Check(deadl.deadAfter, Equals, time.Minute)
-}
-
-type testMsg struct {
-	Type string `json:"T"`
-	A    uint64
+	c.Check(deadl.Kind, Equals, "both")
+	c.Check(deadl.DeadAfter, Equals, time.Minute)
 }
 
 func lengthAsBytes(length uint16) []byte {
@@ -149,43 +69,43 @@
 }
 
 func (s *protocolSuite) TestReadMessage(c *C) {
-	msgBuf, _ := json.Marshal(testMsg{Type: "msg", A: 2000})
-	readMsgLen := rw{buf: lengthAsBytes(uint16(len(msgBuf))), n: 2}
-	readMsgBody := rw{buf: msgBuf, n: len(msgBuf)}
-	tc := &testConn{reads: []rw{readMsgLen, readMsgBody}}
+	msgBuf, _ := json.Marshal(teepot.TestMsg{Type: "msg", A: 2000})
+	readMsgLen := teepot.RW{Buf: lengthAsBytes(uint16(len(msgBuf))), N: 2}
+	readMsgBody := teepot.RW{Buf: msgBuf, N: len(msgBuf)}
+	tc := &teepot.TestConn{Reads: []teepot.RW{readMsgLen, readMsgBody}}
 	pc := NewProtocol0(tc)
-	var recvMsg testMsg
+	var recvMsg teepot.TestMsg
 	err := pc.ReadMessage(&recvMsg)
 	c.Check(err, IsNil)
-	c.Check(recvMsg, DeepEquals, testMsg{Type: "msg", A: 2000})
+	c.Check(recvMsg, DeepEquals, teepot.TestMsg{Type: "msg", A: 2000})
 }
 
 func (s *protocolSuite) TestReadMessageBits(c *C) {
-	msgBuf, _ := json.Marshal(testMsg{Type: "msg", A: 2000})
-	readMsgLen := rw{buf: lengthAsBytes(uint16(len(msgBuf))), n: 2}
-	readMsgBody1 := rw{buf: msgBuf[:5], n: 5}
-	readMsgBody2 := rw{buf: msgBuf[5:], n: len(msgBuf) - 5}
-	tc := &testConn{reads: []rw{readMsgLen, readMsgBody1, readMsgBody2}}
+	msgBuf, _ := json.Marshal(teepot.TestMsg{Type: "msg", A: 2000})
+	readMsgLen := teepot.RW{Buf: lengthAsBytes(uint16(len(msgBuf))), N: 2}
+	readMsgBody1 := teepot.RW{Buf: msgBuf[:5], N: 5}
+	readMsgBody2 := teepot.RW{Buf: msgBuf[5:], N: len(msgBuf) - 5}
+	tc := &teepot.TestConn{Reads: []teepot.RW{readMsgLen, readMsgBody1, readMsgBody2}}
 	pc := NewProtocol0(tc)
-	var recvMsg testMsg
+	var recvMsg teepot.TestMsg
 	err := pc.ReadMessage(&recvMsg)
 	c.Check(err, IsNil)
-	c.Check(recvMsg, DeepEquals, testMsg{Type: "msg", A: 2000})
+	c.Check(recvMsg, DeepEquals, teepot.TestMsg{Type: "msg", A: 2000})
 }
 
 func (s *protocolSuite) TestReadMessageIOErrors(c *C) {
-	msgBuf, _ := json.Marshal(testMsg{Type: "msg", A: 2000})
-	readMsgLenErr := rw{n: 1, err: io.ErrClosedPipe}
-	tc1 := &testConn{reads: []rw{readMsgLenErr}}
+	msgBuf, _ := json.Marshal(teepot.TestMsg{Type: "msg", A: 2000})
+	readMsgLenErr := teepot.RW{N: 1, Err: io.ErrClosedPipe}
+	tc1 := &teepot.TestConn{Reads: []teepot.RW{readMsgLenErr}}
 	pc1 := NewProtocol0(tc1)
-	var recvMsg testMsg
+	var recvMsg teepot.TestMsg
 	err := pc1.ReadMessage(&recvMsg)
 	c.Check(err, Equals, io.ErrClosedPipe)
 
-	readMsgLen := rw{buf: lengthAsBytes(uint16(len(msgBuf))), n: 2}
-	readMsgBody1 := rw{buf: msgBuf[:5], n: 5}
-	readMsgBody2Err := rw{n: 2, err: io.EOF}
-	tc2 := &testConn{reads: []rw{readMsgLen, readMsgBody1, readMsgBody2Err}}
+	readMsgLen := teepot.RW{Buf: lengthAsBytes(uint16(len(msgBuf))), N: 2}
+	readMsgBody1 := teepot.RW{Buf: msgBuf[:5], N: 5}
+	readMsgBody2Err := teepot.RW{N: 2, Err: io.EOF}
+	tc2 := &teepot.TestConn{Reads: []teepot.RW{readMsgLen, readMsgBody1, readMsgBody2Err}}
 	pc2 := NewProtocol0(tc2)
 	err = pc2.ReadMessage(&recvMsg)
 	c.Check(err, Equals, io.EOF)
@@ -193,35 +113,35 @@
 
 func (s *protocolSuite) TestReadMessageBrokenJSON(c *C) {
 	msgBuf := []byte("{\"T\"}")
-	readMsgLen := rw{buf: lengthAsBytes(uint16(len(msgBuf))), n: 2}
-	readMsgBody := rw{buf: msgBuf, n: len(msgBuf)}
-	tc := &testConn{reads: []rw{readMsgLen, readMsgBody}}
+	readMsgLen := teepot.RW{Buf: lengthAsBytes(uint16(len(msgBuf))), N: 2}
+	readMsgBody := teepot.RW{Buf: msgBuf, N: len(msgBuf)}
+	tc := &teepot.TestConn{Reads: []teepot.RW{readMsgLen, readMsgBody}}
 	pc := NewProtocol0(tc)
-	var recvMsg testMsg
+	var recvMsg teepot.TestMsg
 	err := pc.ReadMessage(&recvMsg)
 	c.Check(err, FitsTypeOf, &json.SyntaxError{})
 }
 
 func (s *protocolSuite) TestWriteMessage(c *C) {
-	writeMsg := rw{buf: make([]byte, 64)}
-	tc := &testConn{writes: []*rw{&writeMsg}}
+	writeMsg := teepot.RW{Buf: make([]byte, 64)}
+	tc := &teepot.TestConn{Writes: []*teepot.RW{&writeMsg}}
 	pc := NewProtocol0(tc)
-	msg := testMsg{Type: "m", A: 9999}
+	msg := teepot.TestMsg{Type: "m", A: 9999}
 	err := pc.WriteMessage(&msg)
 	c.Check(err, IsNil)
-	var msgLen int = int(binary.BigEndian.Uint16(writeMsg.buf[:2]))
-	c.Check(msgLen, Equals, len(writeMsg.buf)-2)
-	var wroteMsg testMsg
-	formatErr := json.Unmarshal(writeMsg.buf[2:], &wroteMsg)
+	var msgLen int = int(binary.BigEndian.Uint16(writeMsg.Buf[:2]))
+	c.Check(msgLen, Equals, len(writeMsg.Buf)-2)
+	var wroteMsg teepot.TestMsg
+	formatErr := json.Unmarshal(writeMsg.Buf[2:], &wroteMsg)
 	c.Check(formatErr, IsNil)
-	c.Check(wroteMsg, DeepEquals, testMsg{Type: "m", A: 9999})
+	c.Check(wroteMsg, DeepEquals, teepot.TestMsg{Type: "m", A: 9999})
 }
 
 func (s *protocolSuite) TestWriteMessageIOErrors(c *C) {
-	writeMsgErr := rw{buf: make([]byte, 0), err: io.ErrClosedPipe}
-	tc1 := &testConn{writes: []*rw{&writeMsgErr}}
+	writeMsgErr := teepot.RW{Buf: make([]byte, 0), Err: io.ErrClosedPipe}
+	tc1 := &teepot.TestConn{Writes: []*teepot.RW{&writeMsgErr}}
 	pc1 := NewProtocol0(tc1)
-	msg := testMsg{Type: "m", A: 9999}
+	msg := teepot.TestMsg{Type: "m", A: 9999}
 	err := pc1.WriteMessage(&msg)
 	c.Check(err, Equals, io.ErrClosedPipe)
 }

=== added directory 'protocol/testing'
=== added file 'protocol/testing/testing.go'
--- protocol/testing/testing.go	1970-01-01 00:00:00 +0000
+++ protocol/testing/testing.go	2014-01-24 00:49:53 +0000
@@ -0,0 +1,102 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package testing
+
+import (
+	"net"
+	"time"
+)
+
+type Deadline struct {
+	Kind      string
+	DeadAfter time.Duration
+}
+
+func (d *Deadline) SetDeadAfter(t time.Time) {
+	deadAfter := t.Sub(time.Now())
+	d.DeadAfter = (deadAfter + time.Millisecond/2) / time.Millisecond * time.Millisecond
+}
+
+type RW struct {
+	Buf []byte
+	N   int
+	Err error
+}
+
+type TestConn struct {
+	Deadlines []*Deadline
+	Reads     []RW
+	Writes    []*RW
+}
+
+func (tc *TestConn) LocalAddr() net.Addr {
+	return nil
+}
+
+func (tc *TestConn) RemoteAddr() net.Addr {
+	return nil
+}
+
+func (tc *TestConn) Close() error {
+	return nil
+}
+
+func (tc *TestConn) SetDeadline(t time.Time) error {
+	deadline := tc.Deadlines[0]
+	deadline.Kind = "both"
+	deadline.SetDeadAfter(t)
+	tc.Deadlines = tc.Deadlines[1:]
+	return nil
+}
+
+func (tc *TestConn) SetReadDeadline(t time.Time) error {
+	deadline := tc.Deadlines[0]
+	deadline.Kind = "read"
+	deadline.SetDeadAfter(t)
+	tc.Deadlines = tc.Deadlines[1:]
+	return nil
+}
+
+func (tc *TestConn) SetWriteDeadline(t time.Time) error {
+	deadline := tc.Deadlines[0]
+	deadline.Kind = "write"
+	deadline.SetDeadAfter(t)
+	tc.Deadlines = tc.Deadlines[1:]
+	return nil
+}
+
+func (tc *TestConn) Read(buf []byte) (n int, err error) {
+	read := tc.Reads[0]
+	copy(buf, read.Buf)
+	tc.Reads = tc.Reads[1:]
+	return read.N, read.Err
+}
+
+func (tc *TestConn) Write(buf []byte) (n int, err error) {
+	write := tc.Writes[0]
+	n = copy(write.Buf, buf)
+	write.Buf = write.Buf[:n]
+	write.N = n
+	err = write.Err
+	tc.Writes = tc.Writes[1:]
+	return
+}
+
+type TestMsg struct {
+	Type string `json:"T"`
+	A    uint64
+}