Merge lp:~pedronis/ubuntu-push/acceptance-flex-2 into lp:ubuntu-push

[Samuele Pedroni]

restructure acceptance tests into reusable suites

restructure acceptance tests into reusable suites

[John Lenton (chipaca)]

Thank you!

review: Approve

=== added file 'server/acceptance/acceptance_test.go'
--- server/acceptance/acceptance_test.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/acceptance_test.go	2014-02-11 20:40:06 +0000
@@ -0,0 +1,62 @@
+/*
+ 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 acceptance_test
+
+import (
+	"flag"
+	"fmt"
+	"strings"
+	"testing"
+
+	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/server/acceptance/suites"
+)
+
+func TestAcceptance(t *testing.T) { TestingT(t) }
+
+var serverCmd = flag.String("server", "", "server to test")
+var serverAuxCfg = flag.String("auxcfg", "", "auxiliary config for the server")
+
+func testServerConfig(addr, httpAddr string) map[string]interface{} {
+	cfg := make(map[string]interface{})
+	suites.FillServerConfig(cfg, addr)
+	suites.FillHTTPServerConfig(cfg, httpAddr)
+	return cfg
+}
+
+// Start a server.
+func StartServer(c *C) (<-chan string, func(), string, string) {
+	if *serverCmd == "" {
+		c.Skip("executable server not specified")
+	}
+	tmpDir := c.MkDir()
+	cfg := testServerConfig("127.0.0.1:0", "127.0.0.1:0")
+	cfgFilename := suites.WriteConfig(c, tmpDir, "config.json", cfg)
+	cfgs := append(strings.Fields(*serverAuxCfg), cfgFilename)
+	logs, killServer := suites.RunAndObserve(c, *serverCmd, cfgs...)
+	serverHTTPAddr := suites.ExtractListeningAddr(c, logs, suites.HTTPListeningOnPat)
+	serverURL := fmt.Sprintf("http://%s", serverHTTPAddr)
+	serverAddr := suites.ExtractListeningAddr(c, logs, suites.DevListeningOnPat)
+	return logs, killServer, serverAddr, serverURL
+}
+
+// ping pong/connectivity
+var _ = Suite(&suites.PingPongAcceptanceSuite{suites.AcceptanceSuite{StartServer: StartServer}})
+
+// broadcast
+var _ = Suite(&suites.BroadcastAcceptanceSuite{suites.AcceptanceSuite{StartServer: StartServer}})

=== added directory 'server/acceptance/suites'
=== renamed file 'server/acceptance/acceptance_test.go' => 'server/acceptance/suites/broadcast.go'
--- server/acceptance/acceptance_test.go	2014-02-11 20:40:06 +0000
+++ server/acceptance/suites/broadcast.go	2014-02-11 20:40:06 +0000
@@ -14,248 +14,30 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-package acceptance
+package suites
 
 import (
-	"bytes"
 	"encoding/json"
-	"flag"
 	"fmt"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"runtime"
 	"strings"
-	"testing"
 	"time"
 
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/protocol"
 	"launchpad.net/ubuntu-push/server/api"
-	helpers "launchpad.net/ubuntu-push/testing"
 )
 
-func TestAcceptance(t *testing.T) { TestingT(t) }
-
-type acceptanceSuite struct {
-	serverKill   func()
-	serverAddr   string
-	serverURL    string
-	serverEvents <-chan string
-	httpClient   *http.Client
-}
-
-var _ = Suite(&acceptanceSuite{})
-
-var serverCmd = flag.String("server", "", "server to test")
-var serverAuxCfg = flag.String("auxcfg", "", "auxiliary config for the server")
-
-func testServerConfig(addr, httpAddr string) map[string]interface{} {
-	cfg := make(map[string]interface{})
-	FillServerConfig(cfg, addr)
-	FillHTTPServerConfig(cfg, httpAddr)
-	return cfg
-}
-
-func testClientSession(addr string, deviceId string, reportPings bool) *ClientSession {
-	certPEMBlock, err := ioutil.ReadFile(helpers.SourceRelative("config/testing.cert"))
-	if err != nil {
-		panic(fmt.Sprintf("could not read config/testing.cert: %v", err))
-	}
-	return &ClientSession{
-		ExchangeTimeout: 100 * time.Millisecond,
-		ServerAddr:      addr,
-		CertPEMBlock:    certPEMBlock,
-		DeviceId:        deviceId,
-		ReportPings:     reportPings,
-	}
-}
-
-// start a new server for each test
-func (s *acceptanceSuite) SetUpTest(c *C) {
-	if *serverCmd == "" {
-		c.Skip("executable server not specified")
-	}
-	tmpDir := c.MkDir()
-	cfg := testServerConfig("127.0.0.1:0", "127.0.0.1:0")
-	cfgFilename := WriteConfig(c, tmpDir, "config.json", cfg)
-	cfgs := append(strings.Fields(*serverAuxCfg), cfgFilename)
-	serverEvents, killServer := RunAndObserve(c, *serverCmd, cfgs...)
-	s.serverKill = killServer
-	serverHTTPAddr := ExtractListeningAddr(c, serverEvents, HTTPListeningOnPat)
-	s.serverURL = fmt.Sprintf("http://%s", serverHTTPAddr)
-	s.serverAddr = ExtractListeningAddr(c, serverEvents, DevListeningOnPat)
-	s.serverEvents = serverEvents
-	s.httpClient = &http.Client{}
-}
-
-func (s *acceptanceSuite) TearDownTest(c *C) {
-	if s.serverKill != nil {
-		s.serverKill()
-	}
-}
-
-// Tests about connection, ping-pong, disconnection scenarios
-
-// typically combined with -gocheck.vv or test selection
-var logTraffic = flag.Bool("logTraffic", false, "log traffic")
-
-type connInterceptor func(ic *interceptingConn, op string, b []byte) (bool, int, error)
-
-type interceptingConn struct {
-	net.Conn
-	totalRead    int
-	totalWritten int
-	intercept    connInterceptor
-}
-
-func (ic *interceptingConn) Write(b []byte) (n int, err error) {
-	done := false
-	before := ic.totalWritten
-	if ic.intercept != nil {
-		done, n, err = ic.intercept(ic, "write", b)
-	}
-	if !done {
-		n, err = ic.Conn.Write(b)
-	}
-	ic.totalWritten += n
-	if *logTraffic {
-		fmt.Printf("W[%v]: %d %#v %v %d\n", ic.Conn.LocalAddr(), before, string(b[:n]), err, ic.totalWritten)
-	}
-	return
-}
-
-func (ic *interceptingConn) Read(b []byte) (n int, err error) {
-	done := false
-	before := ic.totalRead
-	if ic.intercept != nil {
-		done, n, err = ic.intercept(ic, "read", b)
-	}
-	if !done {
-		n, err = ic.Conn.Read(b)
-	}
-	ic.totalRead += n
-	if *logTraffic {
-		fmt.Printf("R[%v]: %d %#v %v %d\n", ic.Conn.LocalAddr(), before, string(b[:n]), err, ic.totalRead)
-	}
-	return
-}
-
-func (s *acceptanceSuite) TestConnectPingPing(c *C) {
-	errCh := make(chan error, 1)
-	events := make(chan string, 10)
-	sess := testClientSession(s.serverAddr, "DEVA", true)
-	err := sess.Dial()
-	c.Assert(err, IsNil)
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// would be 3rd ping read, based on logged traffic
-		if op == "read" && ic.totalRead >= 79 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	sess.Connection = &interceptingConn{sess.Connection, 0, 0, intercept}
-	go func() {
-		errCh <- sess.Run(events)
-	}()
-	connectCli := NextEvent(events, errCh)
-	connectSrv := NextEvent(s.serverEvents, nil)
-	registeredSrv := NextEvent(s.serverEvents, nil)
-	tconnect := time.Now()
-	c.Assert(connectSrv, Matches, ".*session.* connected .*")
-	c.Assert(registeredSrv, Matches, ".*session.* registered DEVA")
-	c.Assert(strings.HasSuffix(connectSrv, connectCli), Equals, true)
-	c.Assert(NextEvent(events, errCh), Equals, "Ping")
-	elapsedOfPing := float64(time.Since(tconnect)) / float64(500*time.Millisecond)
-	c.Check(elapsedOfPing >= 1.0, Equals, true)
-	c.Check(elapsedOfPing < 1.05, Equals, true)
-	c.Assert(NextEvent(events, errCh), Equals, "Ping")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* ended with: EOF")
-	c.Check(len(errCh), Equals, 0)
-}
-
-func (s *acceptanceSuite) TestConnectPingNeverPong(c *C) {
-	errCh := make(chan error, 1)
-	events := make(chan string, 10)
-	sess := testClientSession(s.serverAddr, "DEVB", true)
-	err := sess.Dial()
-	c.Assert(err, IsNil)
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// would be pong to 2nd ping, based on logged traffic
-		if op == "write" && ic.totalRead >= 67 {
-			time.Sleep(200 * time.Millisecond)
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	sess.Connection = &interceptingConn{sess.Connection, 0, 0, intercept}
-	go func() {
-		errCh <- sess.Run(events)
-	}()
-	c.Assert(NextEvent(events, errCh), Matches, "connected .*")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* registered .*")
-	c.Assert(NextEvent(events, errCh), Equals, "Ping")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*timeout`)
-	c.Check(len(errCh), Equals, 0)
-}
-
-// Tests about broadcast
-
+// BroadCastAcceptanceSuite has tests about broadcast.
+type BroadcastAcceptanceSuite struct {
+	AcceptanceSuite
+}
+
+// Long after the end of the tests.
 var future = time.Now().Add(9 * time.Hour).Format(time.RFC3339)
 
-func (s *acceptanceSuite) postRequest(path string, message interface{}) (string, error) {
-	packedMessage, err := json.Marshal(message)
-	if err != nil {
-		panic(err)
-	}
-	reader := bytes.NewReader(packedMessage)
-
-	url := s.serverURL + path
-	request, _ := http.NewRequest("POST", url, reader)
-	request.ContentLength = int64(reader.Len())
-	request.Header.Set("Content-Type", "application/json")
-
-	resp, err := s.httpClient.Do(request)
-	if err != nil {
-		panic(err)
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	return string(body), err
-}
-
-func (s *acceptanceSuite) startClient(c *C, devId string, intercept connInterceptor, levels map[string]int64) (<-chan string, <-chan error) {
-	errCh := make(chan error, 1)
-	events := make(chan string, 10)
-	sess := testClientSession(s.serverAddr, devId, false)
-	sess.Levels = levels
-	err := sess.Dial()
-	c.Assert(err, IsNil)
-	sess.Connection = &interceptingConn{sess.Connection, 0, 0, intercept}
-	go func() {
-		errCh <- sess.Run(events)
-	}()
-	c.Assert(NextEvent(events, errCh), Matches, "connected .*")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* registered "+devId)
-	return events, errCh
-}
-
-func (s *acceptanceSuite) TestBroadcastToConnected(c *C) {
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	events, errCh := s.startClient(c, "DEVB", intercept, nil)
+func (s *BroadcastAcceptanceSuite) TestBroadcastToConnected(c *C) {
+	events, errCh, stop := s.startClient(c, "DEVB", nil)
 	got, err := s.postRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
@@ -264,12 +46,12 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`)
-	clientShutdown <- true
+	stop()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
-func (s *acceptanceSuite) TestBroadcastPending(c *C) {
+func (s *BroadcastAcceptanceSuite) TestBroadcastPending(c *C) {
 	// send broadcast that will be pending
 	got, err := s.postRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
@@ -279,24 +61,15 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	events, errCh := s.startClient(c, "DEVB", intercept, nil)
+	events, errCh, stop := s.startClient(c, "DEVB", nil)
 	// gettting pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`)
-	clientShutdown <- true
+	stop()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
-func (s *acceptanceSuite) TestBroadcasLargeNeedsSplitting(c *C) {
+func (s *BroadcastAcceptanceSuite) TestBroadcasLargeNeedsSplitting(c *C) {
 	// send bunch of broadcasts that will be pending
 	payloadFmt := fmt.Sprintf(`{"b":%%d,"bloat":"%s"}`, strings.Repeat("x", 1024*2))
 	for i := 0; i < 32; i++ {
@@ -309,38 +82,20 @@
 		c.Assert(got, Matches, ".*ok.*")
 	}
 
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	events, errCh := s.startClient(c, "DEVC", intercept, nil)
+	events, errCh, stop := s.startClient(c, "DEVC", nil)
 	// gettting pending on connect
 	c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:30 payloads:\[{"b":0,.*`)
 	c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:32 payloads:\[.*`)
-	clientShutdown <- true
+	stop()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
-func (s *acceptanceSuite) TestBroadcastDistribution2(c *C) {
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
+func (s *BroadcastAcceptanceSuite) TestBroadcastDistribution2(c *C) {
 	// start 1st clinet
-	events1, errCh1 := s.startClient(c, "DEV1", intercept, nil)
+	events1, errCh1, stop1 := s.startClient(c, "DEV1", nil)
 	// start 2nd client
-	events2, errCh2 := s.startClient(c, "DEV2", intercept, nil)
+	events2, errCh2, stop2 := s.startClient(c, "DEV2", nil)
 	// broadcast
 	got, err := s.postRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
@@ -351,24 +106,16 @@
 	c.Assert(got, Matches, ".*ok.*")
 	c.Check(NextEvent(events1, errCh1), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`)
 	c.Check(NextEvent(events2, errCh2), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`)
-	clientShutdown <- true
+	stop1()
+	stop2()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh1), Equals, 0)
 	c.Check(len(errCh2), Equals, 0)
 }
 
-func (s *acceptanceSuite) TestBroadcastFilterByLevel(c *C) {
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	events, errCh := s.startClient(c, "DEVD", intercept, nil)
+func (s *BroadcastAcceptanceSuite) TestBroadcastFilterByLevel(c *C) {
+	events, errCh, stop := s.startClient(c, "DEVD", nil)
 	got, err := s.postRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
@@ -377,7 +124,7 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`)
-	clientShutdown <- true
+	stop()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 	// another broadcast
@@ -389,17 +136,16 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 	// reconnect, provide levels, get only later notification
-	<-clientShutdown // reset
-	events, errCh = s.startClient(c, "DEVD", intercept, map[string]int64{
+	events, errCh, stop = s.startClient(c, "DEVD", map[string]int64{
 		protocol.SystemChannelId: 1,
 	})
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`)
-	clientShutdown <- true
+	stop()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
-func (s *acceptanceSuite) TestBroadcastTooAhead(c *C) {
+func (s *BroadcastAcceptanceSuite) TestBroadcastTooAhead(c *C) {
 	// send broadcasts that will be pending
 	got, err := s.postRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
@@ -416,47 +162,29 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	events, errCh := s.startClient(c, "DEVB", intercept, map[string]int64{
+	events, errCh, stop := s.startClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: 10,
 	})
 	// gettting last one pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`)
-	clientShutdown <- true
+	stop()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
-func (s *acceptanceSuite) TestBroadcastTooAheadOnEmpty(c *C) {
+func (s *BroadcastAcceptanceSuite) TestBroadcastTooAheadOnEmpty(c *C) {
 	// nothing there
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	events, errCh := s.startClient(c, "DEVB", intercept, map[string]int64{
+	events, errCh, stop := s.startClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: 10,
 	})
 	// gettting empty pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:0 payloads:null`)
-	clientShutdown <- true
+	stop()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
-func (s *acceptanceSuite) TestBroadcastWayBehind(c *C) {
+func (s *BroadcastAcceptanceSuite) TestBroadcastWayBehind(c *C) {
 	// send broadcasts that will be pending
 	got, err := s.postRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
@@ -473,21 +201,12 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	events, errCh := s.startClient(c, "DEVB", intercept, map[string]int64{
+	events, errCh, stop := s.startClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: -10,
 	})
 	// gettting pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":1},{"b":2}]`)
-	clientShutdown <- true
+	stop()
 	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }

=== renamed file 'server/acceptance/acceptance_helpers.go' => 'server/acceptance/suites/helpers.go'
--- server/acceptance/acceptance_helpers.go	2014-02-11 20:40:06 +0000
+++ server/acceptance/suites/helpers.go	2014-02-11 20:40:06 +0000
@@ -14,7 +14,7 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-package acceptance
+package suites
 
 import (
 	"bufio"
@@ -48,8 +48,8 @@
 		"session_queue_size": 10,
 		"broker_queue_size":  100,
 		"addr":               addr,
-		"key_pem_file":       helpers.SourceRelative("config/testing.key"),
-		"cert_pem_file":      helpers.SourceRelative("config/testing.cert"),
+		"key_pem_file":       helpers.SourceRelative("../config/testing.key"),
+		"cert_pem_file":      helpers.SourceRelative("../config/testing.cert"),
 	})
 }
 

=== added file 'server/acceptance/suites/pingpong.go'
--- server/acceptance/suites/pingpong.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/suites/pingpong.go	2014-02-11 20:40:06 +0000
@@ -0,0 +1,93 @@
+/*
+ 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 suites
+
+import (
+	"runtime"
+	"strings"
+	"time"
+
+	. "launchpad.net/gocheck"
+)
+
+// PingPongAcceptanceSuite has tests about connectivity and ping-pong requests.
+type PingPongAcceptanceSuite struct {
+	AcceptanceSuite
+}
+
+// Tests about connection, ping-pong, disconnection scenarios
+
+func (s *PingPongAcceptanceSuite) TestConnectPingPing(c *C) {
+	errCh := make(chan error, 1)
+	events := make(chan string, 10)
+	sess := testClientSession(s.serverAddr, "DEVA", true)
+	err := sess.Dial()
+	c.Assert(err, IsNil)
+	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
+		// would be 3rd ping read, based on logged traffic
+		if op == "read" && ic.totalRead >= 79 {
+			// exit the sess.Run() goroutine, client will close
+			runtime.Goexit()
+		}
+		return false, 0, nil
+	}
+	sess.Connection = &interceptingConn{sess.Connection, 0, 0, intercept}
+	go func() {
+		errCh <- sess.Run(events)
+	}()
+	connectCli := NextEvent(events, errCh)
+	connectSrv := NextEvent(s.serverEvents, nil)
+	registeredSrv := NextEvent(s.serverEvents, nil)
+	tconnect := time.Now()
+	c.Assert(connectSrv, Matches, ".*session.* connected .*")
+	c.Assert(registeredSrv, Matches, ".*session.* registered DEVA")
+	c.Assert(strings.HasSuffix(connectSrv, connectCli), Equals, true)
+	c.Assert(NextEvent(events, errCh), Equals, "Ping")
+	elapsedOfPing := float64(time.Since(tconnect)) / float64(500*time.Millisecond)
+	c.Check(elapsedOfPing >= 1.0, Equals, true)
+	c.Check(elapsedOfPing < 1.05, Equals, true)
+	c.Assert(NextEvent(events, errCh), Equals, "Ping")
+	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* ended with: EOF")
+	c.Check(len(errCh), Equals, 0)
+}
+
+func (s *PingPongAcceptanceSuite) TestConnectPingNeverPong(c *C) {
+	errCh := make(chan error, 1)
+	events := make(chan string, 10)
+	sess := testClientSession(s.serverAddr, "DEVB", true)
+	err := sess.Dial()
+	c.Assert(err, IsNil)
+	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
+		// would be pong to 2nd ping, based on logged traffic
+		if op == "write" && ic.totalRead >= 67 {
+			time.Sleep(200 * time.Millisecond)
+			// exit the sess.Run() goroutine, client will close
+			runtime.Goexit()
+		}
+		return false, 0, nil
+	}
+	sess.Connection = &interceptingConn{sess.Connection, 0, 0, intercept}
+	go func() {
+		errCh <- sess.Run(events)
+	}()
+	c.Assert(NextEvent(events, errCh), Matches, "connected .*")
+	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*")
+	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* registered .*")
+	c.Assert(NextEvent(events, errCh), Equals, "Ping")
+	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*timeout`)
+	c.Check(len(errCh), Equals, 0)
+}

=== added file 'server/acceptance/suites/suite.go'
--- server/acceptance/suites/suite.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/suites/suite.go	2014-02-11 20:40:06 +0000
@@ -0,0 +1,170 @@
+/*
+ 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 suites contains reusable acceptance test suites.
+package suites
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"runtime"
+	"time"
+
+	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/server/acceptance"
+	helpers "launchpad.net/ubuntu-push/testing"
+)
+
+// AcceptanceSuite has the basic functionality of the acceptance suites.
+type AcceptanceSuite struct {
+	// hook to start the server(s)
+	StartServer func(c *C) (logs <-chan string, kill func(), serverAddr, apiURL string)
+	// running bits
+	serverKill   func()
+	serverAddr   string
+	serverAPIURL string
+	serverEvents <-chan string
+	httpClient   *http.Client
+}
+
+// Start a new server for each test.
+func (s *AcceptanceSuite) SetUpTest(c *C) {
+	logs, kill, addr, url := s.StartServer(c)
+	s.serverEvents = logs
+	s.serverKill = kill
+	s.serverAddr = addr
+	s.serverAPIURL = url
+	s.httpClient = &http.Client{}
+}
+
+func (s *AcceptanceSuite) TearDownTest(c *C) {
+	if s.serverKill != nil {
+		s.serverKill()
+	}
+}
+
+// Post a request.
+func (s *AcceptanceSuite) postRequest(path string, message interface{}) (string, error) {
+	packedMessage, err := json.Marshal(message)
+	if err != nil {
+		panic(err)
+	}
+	reader := bytes.NewReader(packedMessage)
+
+	url := s.serverAPIURL + path
+	request, _ := http.NewRequest("POST", url, reader)
+	request.ContentLength = int64(reader.Len())
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := s.httpClient.Do(request)
+	if err != nil {
+		panic(err)
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	return string(body), err
+}
+
+func testClientSession(addr string, deviceId string, reportPings bool) *acceptance.ClientSession {
+	certPEMBlock, err := ioutil.ReadFile(helpers.SourceRelative("../config/testing.cert"))
+	if err != nil {
+		panic(fmt.Sprintf("could not read config/testing.cert: %v", err))
+	}
+	return &acceptance.ClientSession{
+		ExchangeTimeout: 100 * time.Millisecond,
+		ServerAddr:      addr,
+		CertPEMBlock:    certPEMBlock,
+		DeviceId:        deviceId,
+		ReportPings:     reportPings,
+	}
+}
+
+// typically combined with -gocheck.vv or test selection
+var logTraffic = flag.Bool("logTraffic", false, "log traffic")
+
+type connInterceptor func(ic *interceptingConn, op string, b []byte) (bool, int, error)
+
+type interceptingConn struct {
+	net.Conn
+	totalRead    int
+	totalWritten int
+	intercept    connInterceptor
+}
+
+func (ic *interceptingConn) Write(b []byte) (n int, err error) {
+	done := false
+	before := ic.totalWritten
+	if ic.intercept != nil {
+		done, n, err = ic.intercept(ic, "write", b)
+	}
+	if !done {
+		n, err = ic.Conn.Write(b)
+	}
+	ic.totalWritten += n
+	if *logTraffic {
+		fmt.Printf("W[%v]: %d %#v %v %d\n", ic.Conn.LocalAddr(), before, string(b[:n]), err, ic.totalWritten)
+	}
+	return
+}
+
+func (ic *interceptingConn) Read(b []byte) (n int, err error) {
+	done := false
+	before := ic.totalRead
+	if ic.intercept != nil {
+		done, n, err = ic.intercept(ic, "read", b)
+	}
+	if !done {
+		n, err = ic.Conn.Read(b)
+	}
+	ic.totalRead += n
+	if *logTraffic {
+		fmt.Printf("R[%v]: %d %#v %v %d\n", ic.Conn.LocalAddr(), before, string(b[:n]), err, ic.totalRead)
+	}
+	return
+}
+
+// Start a client.
+func (s *AcceptanceSuite) startClient(c *C, devId string, levels map[string]int64) (events <-chan string, errorCh <-chan error, stop func()) {
+	errCh := make(chan error, 1)
+	cliEvents := make(chan string, 10)
+	sess := testClientSession(s.serverAddr, devId, false)
+	sess.Levels = levels
+	err := sess.Dial()
+	c.Assert(err, IsNil)
+	clientShutdown := make(chan bool, 1) // abused as an atomic flag
+	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
+		// read after ack
+		if op == "read" && len(clientShutdown) > 0 {
+			// exit the sess.Run() goroutine, client will close
+			runtime.Goexit()
+		}
+		return false, 0, nil
+	}
+	sess.Connection = &interceptingConn{sess.Connection, 0, 0, intercept}
+	go func() {
+		errCh <- sess.Run(cliEvents)
+	}()
+	c.Assert(NextEvent(cliEvents, errCh), Matches, "connected .*")
+	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*")
+	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* registered "+devId)
+	return cliEvents, errCh, func() { clientShutdown <- true }
+}