Merge lp:~pedronis/ubuntu-push/kindpool-test-derace into lp:ubuntu-push

[Samuele Pedroni]

avoid rare race in kindpool_test.go

avoid rare race in test,

better to change globals once in SetUpSuite than again and again in SetUpTest

[lp:~pedronis/ubuntu-push/kindpool-test-derace]

314. By Samuele Pedroni on 2014-08-22

avoid rare race in test

Unmerged revisions

=== modified file 'bus/notifications/raw.go'
--- bus/notifications/raw.go	2014-07-27 00:58:08 +0000
+++ bus/notifications/raw.go	2014-08-22 14:47:03 +0000
@@ -144,7 +144,7 @@
 	}
 
 	hints := make(map[string]*dbus.Variant)
-	hints["x-canonical-secondary-icon"] = &dbus.Variant{app.Icon()}
+	hints["x-canonical-secondary-icon"] = &dbus.Variant{app.SymbolicIcon()}
 
 	appId := app.Original()
 	actions := make([]string, 2*len(card.Actions))

=== modified file 'bus/notifications/raw_test.go'
--- bus/notifications/raw_test.go	2014-07-27 00:58:08 +0000
+++ bus/notifications/raw_test.go	2014-08-22 14:47:03 +0000
@@ -210,6 +210,19 @@
 	c.Check(hints["x-canonical-secondary-icon"], NotNil)
 }
 
+func (s *RawSuite) TestPresentUsesSymbolic(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	worked := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true}})
+	c.Assert(worked, Equals, true)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Assert(callArgs[0].Args, HasLen, 8)
+	hints, ok := callArgs[0].Args[6].(map[string]*dbus.Variant)
+	c.Assert(ok, Equals, true)
+	c.Check(hints["x-canonical-secondary-icon"].Value.(string), Equals, "-symbolic")
+}
+
 func (s *RawSuite) TestPresentNoNotificationPanics(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)

=== modified file 'click/click.go'
--- click/click.go	2014-08-06 02:44:06 +0000
+++ click/click.go	2014-08-22 14:47:03 +0000
@@ -136,6 +136,19 @@
 	return cappinfo.AppIconFromDesktopId(app.DesktopId())
 }
 
+func _symbolic(icon string) string {
+	if strings.ContainsRune(icon, '/') {
+		return icon
+	}
+	return icon + "-symbolic"
+}
+
+var symbolic = _symbolic
+
+func (app *AppId) SymbolicIcon() string {
+	return symbolic(app.Icon())
+}
+
 func (app *AppId) MarshalJSON() ([]byte, error) {
 	return json.Marshal(app.Original())
 }

=== modified file 'click/click_test.go'
--- click/click_test.go	2014-08-06 03:50:14 +0000
+++ click/click_test.go	2014-08-22 14:47:03 +0000
@@ -182,3 +182,21 @@
 	c.Check(app, NotNil)
 	c.Check(app.Original(), Equals, "_non-existent-app")
 }
+
+func (s *clickSuite) TestSymbolicAppendsSymbolicIfIconIsName(c *C) {
+	symb := symbolic("foo")
+	c.Check(symb, Equals, "foo-symbolic")
+}
+
+func (s *clickSuite) TestSymbolicLeavesAloneIfIconIsPath(c *C) {
+	symb := symbolic("foo/bar")
+	c.Check(symb, Equals, "foo/bar")
+}
+
+func (s *clickSuite) TestSymbolicIconCallsSymbolic(c *C) {
+	symbolic = func(string) string { return "xyzzy" }
+	defer func() { symbolic = _symbolic }()
+	app, err := ParseAppId("_python3.4")
+	c.Assert(err, IsNil)
+	c.Check(app.SymbolicIcon(), Equals, "xyzzy")
+}

=== modified file 'client/client_test.go'
--- client/client_test.go	2014-08-12 00:32:32 +0000
+++ client/client_test.go	2014-08-22 14:47:03 +0000
@@ -143,7 +143,11 @@
 
 func (cs *clientSuite) SetUpSuite(c *C) {
 	config.IgnoreParsedFlags = true // because configure() uses <flags>
-	newIdentifier = func() (identifier.Id, error) { return idtesting.Settable(), nil }
+	newIdentifier = func() (identifier.Id, error) {
+		id := idtesting.Settable()
+		id.Set("42") // must be hex of len 32
+		return id, nil
+	}
 	cs.timeouts = util.SwapTimeouts([]time.Duration{0})
 	cs.leveldbPath = ""
 }
@@ -1141,7 +1145,7 @@
 	// and now everthing is better! We have a config,
 	c.Check(string(cli.config.Addr), Equals, ":0")
 	// and a device id,
-	c.Check(cli.deviceId, HasLen, 32)
+	c.Check(cli.deviceId, HasLen, 40)
 	// and a session,
 	c.Check(cli.session, NotNil)
 	// and a bus,

=== modified file 'dependencies.tsv'
--- dependencies.tsv	2014-07-26 07:28:59 +0000
+++ dependencies.tsv	2014-08-22 14:47:03 +0000
@@ -1,5 +1,5 @@
 code.google.com/p/go-uuid	hg	7dda39b2e7d5e265014674c5af696ba4186679e9	11
 code.google.com/p/gosqlite	hg	74691fb6f83716190870cde1b658538dd4b18eb0	15
-launchpad.net/go-dbus/v1	bzr	[e-mail]-20140530132806-hpqbkxczif6o1dpz	127
+launchpad.net/go-dbus/v1	bzr	[e-mail]-20140801110939-lzfql7fk76dt6ckd	128
 launchpad.net/go-xdg/v0	bzr	[e-mail]-20140208094800-gubd5md7cro3mtxa	10
 launchpad.net/gocheck	bzr	[e-mail]-20140225173054-xu9zlkf9kxhvow02	87

=== modified file 'launch_helper/kindpool.go'
--- launch_helper/kindpool.go	2014-07-29 15:24:01 +0000
+++ launch_helper/kindpool.go	2014-08-22 14:47:03 +0000
@@ -72,7 +72,7 @@
 func DefaultLaunchers(log logger.Logger) map[string]HelperLauncher {
 	return map[string]HelperLauncher{
 		"click":  cual.New(log),
-		"legacy": legacy.New(),
+		"legacy": legacy.New(log),
 	}
 }
 

=== modified file 'launch_helper/kindpool_test.go'
--- launch_helper/kindpool_test.go	2014-08-08 09:03:42 +0000
+++ launch_helper/kindpool_test.go	2014-08-22 14:47:03 +0000
@@ -102,16 +102,22 @@
 	return args
 }
 
+func (s *poolSuite) SetUpSuite(c *C) {
+	xdgCacheHome = c.MkDir
+}
+
+func (s *poolSuite) TearDownSuite(c *C) {
+	xdgCacheHome = xdg.Cache.Home
+}
+
 func (s *poolSuite) SetUpTest(c *C) {
 	s.log = helpers.NewTestLogger(c, "debug")
 	s.fakeLauncher = &fakeHelperLauncher{argCh: make(chan [5]string, 10)}
 	s.pool = NewHelperPool(map[string]HelperLauncher{"fake": s.fakeLauncher}, s.log)
-	xdgCacheHome = c.MkDir
 }
 
 func (s *poolSuite) TearDownTest(c *C) {
 	s.pool = nil
-	xdgCacheHome = xdg.Cache.Home
 }
 
 func (s *poolSuite) TestDefaultLaunchers(c *C) {
@@ -379,8 +385,9 @@
 }
 
 func (s *poolSuite) TestGetTempFilename(c *C) {
+	tmpDir := c.MkDir()
 	GetTempDir = func(pkgName string) (string, error) {
-		return c.MkDir(), nil
+		return tmpDir, nil
 	}
 	// restore it when we are done
 	defer func() {

=== modified file 'launch_helper/legacy/legacy.go'
--- launch_helper/legacy/legacy.go	2014-07-18 20:45:21 +0000
+++ launch_helper/legacy/legacy.go	2014-08-22 14:47:03 +0000
@@ -18,20 +18,23 @@
 package legacy
 
 import (
+	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strconv"
 
 	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/logger"
 )
 
 type legacyHelperLauncher struct {
+	log  logger.Logger
 	done func(string)
 }
 
-func New() *legacyHelperLauncher {
-	return new(legacyHelperLauncher)
+func New(log logger.Logger) *legacyHelperLauncher {
+	return &legacyHelperLauncher{log: log}
 }
 
 func (lhl *legacyHelperLauncher) InstallObserver(done func(string)) error {
@@ -50,9 +53,10 @@
 func (lhl *legacyHelperLauncher) Launch(_, progname, f1, f2 string) (string, error) {
 	cmd := exec.Command(progname, f1, f2)
 	cmd.Stdin = nil
-	cmd.Stdout = nil
-	cmd.Stderr = nil
-
+	var stdout_r, stdout_w = io.Pipe()
+	var stderr_r, stderr_w = io.Pipe()
+	cmd.Stdout = stdout_w
+	cmd.Stderr = stderr_w
 	err := cmd.Start()
 	if err != nil {
 		return "", err
@@ -63,7 +67,17 @@
 	}
 	id := strconv.FormatInt((int64)(proc.Pid), 36)
 	go func() {
-		proc.Wait()
+		state, p_err := proc.Wait()
+		if p_err != nil || !state.Success() {
+			// Helper failed, log output
+			var data []byte
+			stdout_w.Close()
+			stdout_r.Read(data)
+			lhl.log.Errorf("Legacy helper failed. Stdout: %s", data)
+			stderr_w.Close()
+			stderr_r.Read(data)
+			lhl.log.Errorf("Legacy helper failed. Stderr: %s", data)
+		}
 		lhl.done(id)
 	}()
 

=== modified file 'launch_helper/legacy/legacy_test.go'
--- launch_helper/legacy/legacy_test.go	2014-07-18 20:45:21 +0000
+++ launch_helper/legacy/legacy_test.go	2014-08-22 14:47:03 +0000
@@ -32,7 +32,7 @@
 	select {
 	case s := <-ch:
 		return s
-	case <-time.After(time.Second):
+	case <-time.After(5 * time.Second):
 		c.Fatal("timed out waiting for value")
 		return ""
 	}
@@ -42,12 +42,14 @@
 
 type legacySuite struct {
 	lhl *legacyHelperLauncher
+	log *helpers.TestLogger
 }
 
 var _ = Suite(&legacySuite{})
 
 func (ls *legacySuite) SetUpTest(c *C) {
-	ls.lhl = New()
+	ls.log = helpers.NewTestLogger(c, "info")
+	ls.lhl = New(ls.log)
 }
 
 func (ls *legacySuite) TestInstallObserver(c *C) {
@@ -94,12 +96,24 @@
 	c.Assert(err, NotNil)
 }
 
+func (ls *legacySuite) TestHelperFails(c *C) {
+	ch := make(chan string, 1)
+	c.Assert(ls.lhl.InstallObserver(func(id string) { ch <- id }), IsNil)
+
+	_, err := ls.lhl.Launch("", "/bin/false", "", "")
+	c.Assert(err, IsNil)
+
+	takeNext(ch, c)
+	c.Check(ls.log.Captured(), Matches, "(?s).*Legacy helper failed.*")
+}
+
 func (ls *legacySuite) TestStop(c *C) {
 	ch := make(chan string, 1)
 	c.Assert(ls.lhl.InstallObserver(func(id string) { ch <- id }), IsNil)
 
 	exe := helpers.ScriptAbsPath("slow-helper.sh")
 	id, err := ls.lhl.Launch("", exe, "", "")
+	c.Assert(err, IsNil)
 
 	err = ls.lhl.Stop("", "===")
 	c.Check(err, NotNil) // not a valid id

=== modified file 'server/acceptance/acceptanceclient.go'
--- server/acceptance/acceptanceclient.go	2014-06-05 09:32:43 +0000
+++ server/acceptance/acceptanceclient.go	2014-08-22 14:47:03 +0000
@@ -19,9 +19,7 @@
 
 import (
 	"crypto/tls"
-	"crypto/x509"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net"
 	"strings"
@@ -40,35 +38,36 @@
 	ImageChannel    string
 	ServerAddr      string
 	ExchangeTimeout time.Duration
-	CertPEMBlock    []byte
 	ReportPings     bool
 	Levels          map[string]int64
-	Insecure        bool   // don't verify certs
+	TLSConfig       *tls.Config
 	Prefix          string // prefix for events
 	Auth            string
 	// connection
 	Connection net.Conn
 }
 
-// Dial connects to a server using the configuration in the ClientSession
-// and sets up the connection.
+// Dial connects to a server using the configuration in the
+// ClientSession and sets up the connection.
 func (sess *ClientSession) Dial() error {
 	conn, err := net.DialTimeout("tcp", sess.ServerAddr, sess.ExchangeTimeout)
 	if err != nil {
 		return err
 	}
-	tlsConfig := &tls.Config{}
-	if sess.CertPEMBlock != nil {
-		cp := x509.NewCertPool()
-		ok := cp.AppendCertsFromPEM(sess.CertPEMBlock)
-		if !ok {
-			return errors.New("dial: could not parse certificate")
-		}
-		tlsConfig.RootCAs = cp
+	sess.TLSWrapAndSet(conn)
+	return nil
+}
+
+// TLSWrapAndSet wraps a socket connection in tls and sets it as
+// session.Connection. For use instead of Dial().
+func (sess *ClientSession) TLSWrapAndSet(conn net.Conn) {
+	var tlsConfig *tls.Config
+	if sess.TLSConfig != nil {
+		tlsConfig = sess.TLSConfig
+	} else {
+		tlsConfig = &tls.Config{}
 	}
-	tlsConfig.InsecureSkipVerify = sess.Insecure
 	sess.Connection = tls.Client(conn, tlsConfig)
-	return nil
 }
 
 type serverMsg struct {

=== added file 'server/acceptance/cmd/acceptanceclient.go'
--- server/acceptance/cmd/acceptanceclient.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/cmd/acceptanceclient.go	2014-08-22 14:47:03 +0000
@@ -0,0 +1,54 @@
+/*
+ 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/>.
+*/
+
+// acceptanceclient command for playing.
+package main
+
+import (
+	"log"
+	"os/exec"
+	"strings"
+
+	"launchpad.net/ubuntu-push/server/acceptance"
+	"launchpad.net/ubuntu-push/server/acceptance/kit"
+)
+
+type configuration struct {
+	kit.Configuration
+	AuthHelper string `json:"auth_helper"`
+	WaitFor    string `json:"wait_for"`
+}
+
+func main() {
+	kit.Defaults["auth_helper"] = ""
+	kit.Defaults["wait_for"] = ""
+	cfg := &configuration{}
+	kit.CliLoop(cfg, &cfg.Configuration, func(session *acceptance.ClientSession, cfgDir string) {
+		log.Printf("with: %#v", session)
+	}, func(url string) string {
+		if cfg.AuthHelper == "" {
+			return ""
+		}
+		auth, err := exec.Command(cfg.AuthHelper, url).Output()
+		if err != nil {
+			log.Fatalf("auth helper: %v", err)
+		}
+		return strings.TrimSpace(string(auth))
+	}, func() string {
+		return cfg.WaitFor
+	}, func() {
+	})
+}

=== added directory 'server/acceptance/kit'
=== added file 'server/acceptance/kit/api.go'
--- server/acceptance/kit/api.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/kit/api.go	2014-08-22 14:47:03 +0000
@@ -0,0 +1,82 @@
+/*
+ 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 kit contains reusable building blocks for acceptance.
+package kit
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net/http"
+)
+
+// APIClient helps making api requests.
+type APIClient struct {
+	ServerAPIURL string
+	// hook to adjust requests
+	MassageRequest func(req *http.Request, message interface{}) *http.Request
+	// other state
+	httpClient *http.Client
+}
+
+// SetupClient sets up the http client to make requests.
+func (api *APIClient) SetupClient(tlsConfig *tls.Config) {
+	api.httpClient = &http.Client{
+		Transport: &http.Transport{TLSClientConfig: tlsConfig},
+	}
+}
+
+var ErrNOk = errors.New("not ok")
+
+// Post a API request.
+func (api *APIClient) PostRequest(path string, message interface{}) (map[string]interface{}, error) {
+	packedMessage, err := json.Marshal(message)
+	if err != nil {
+		panic(err)
+	}
+	reader := bytes.NewReader(packedMessage)
+
+	url := api.ServerAPIURL + path
+	request, _ := http.NewRequest("POST", url, reader)
+	request.ContentLength = int64(reader.Len())
+	request.Header.Set("Content-Type", "application/json")
+
+	if api.MassageRequest != nil {
+		request = api.MassageRequest(request, message)
+	}
+
+	resp, err := api.httpClient.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	var res map[string]interface{}
+	err = json.Unmarshal(body, &res)
+	if err != nil {
+		return nil, err
+	}
+	if ok, _ := res["ok"].(bool); !ok {
+		return res, ErrNOk
+	}
+	return res, nil
+}

=== renamed file 'server/acceptance/cmd/acceptanceclient.go' => 'server/acceptance/kit/cliloop.go'
--- server/acceptance/cmd/acceptanceclient.go	2014-07-11 21:24:21 +0000
+++ server/acceptance/kit/cliloop.go	2014-08-22 14:47:03 +0000
@@ -14,15 +14,13 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-// acceptanceclient command for playing.
-package main
+package kit
 
 import (
 	"flag"
 	"fmt"
 	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -32,27 +30,58 @@
 	"launchpad.net/ubuntu-push/server/acceptance"
 )
 
-var (
-	insecureFlag    = flag.Bool("insecure", false, "disable checking of server certificate and hostname")
-	reportPingsFlag = flag.Bool("reportPings", true, "report each Ping from the server")
-	deviceModel     = flag.String("model", "?", "device image model")
-	imageChannel    = flag.String("imageChannel", "?", "image channel")
-)
-
-type configuration struct {
+type Configuration struct {
 	// session configuration
 	ExchangeTimeout config.ConfigTimeDuration `json:"exchange_timeout"`
 	// server connection config
-	Addr        config.ConfigHostPort
-	CertPEMFile string                    `json:"cert_pem_file"`
-	AuthHelper  string                    `json:"auth_helper"`
-	RunTimeout  config.ConfigTimeDuration `json:"run_timeout"`
-	WaitFor     string                    `json:"wait_for"`
-}
-
-func main() {
+	Target      string                `json:"target"`
+	Addr        config.ConfigHostPort `json:"addr"`
+	CertPEMFile string                `json:"cert_pem_file"`
+	Insecure    bool                  `json:"insecure" help:"disable checking of server certificate and hostname"`
+	Domain      string                `json:"domain" help:"domain for tls connect"`
+	// run timeout
+	RunTimeout config.ConfigTimeDuration `json:"run_timeout"`
+	// flags
+	ReportPings  bool   `json:"reportPings" help:"report each Ping from the server"`
+	DeviceModel  string `json:"model" help:"device image model"`
+	ImageChannel string `json:"imageChannel" help:"image channel"`
+}
+
+func (cfg *Configuration) PickByTarget(what, productionValue, stagingValue string) (value string) {
+	switch cfg.Target {
+	case "production":
+		value = productionValue
+	case "staging":
+		value = stagingValue
+	case "":
+		log.Fatalf("either %s or target must be given", what)
+	default:
+		log.Fatalf("if specified target should be production|staging")
+	}
+	return
+}
+
+// Control.
+var (
+	Name     = "acceptanceclient"
+	Defaults = map[string]interface{}{
+		"target":           "",
+		"addr":             ":0",
+		"exchange_timeout": "5s",
+		"cert_pem_file":    "",
+		"insecure":         false,
+		"domain":           "",
+		"run_timeout":      "0s",
+		"reportPings":      true,
+		"model":            "?",
+		"imageChannel":     "?",
+	}
+)
+
+// CliLoop parses command line arguments and runs a client loop.
+func CliLoop(totalCfg interface{}, cfg *Configuration, onSetup func(sess *acceptance.ClientSession, cfgDir string), auth func(string) string, waitFor func() string, onConnect func()) {
 	flag.Usage = func() {
-		fmt.Fprintf(os.Stderr, "Usage: acceptancclient [options] <device id>\n")
+		fmt.Fprintf(os.Stderr, "Usage: %s [options] <device id>\n", Name)
 		flag.PrintDefaults()
 	}
 	missingArg := func(what string) {
@@ -60,14 +89,7 @@
 		flag.Usage()
 		os.Exit(2)
 	}
-	cfg := &configuration{}
-	err := config.ReadFilesDefaults(cfg, map[string]interface{}{
-		"exchange_timeout": "5s",
-		"cert_pem_file":    "",
-		"auth_helper":      "",
-		"run_timeout":      "0s",
-		"wait_for":         "",
-	}, "<flags>")
+	err := config.ReadFilesDefaults(totalCfg, Defaults, "<flags>")
 	if err != nil {
 		log.Fatalf("reading config: %v", err)
 	}
@@ -76,36 +98,34 @@
 	case narg < 1:
 		missingArg("device-id")
 	}
+	addr := ""
+	if cfg.Addr == ":0" {
+		addr = cfg.PickByTarget("addr", "push-delivery.ubuntu.com:443",
+			"push-delivery.staging.ubuntu.com:443")
+	} else {
+		addr = cfg.Addr.HostPort()
+	}
 	session := &acceptance.ClientSession{
 		ExchangeTimeout: cfg.ExchangeTimeout.TimeDuration(),
-		ServerAddr:      cfg.Addr.HostPort(),
+		ServerAddr:      addr,
 		DeviceId:        flag.Arg(0),
 		// flags
-		Model:        *deviceModel,
-		ImageChannel: *imageChannel,
-		ReportPings:  *reportPingsFlag,
-		Insecure:     *insecureFlag,
-	}
-	log.Printf("with: %#v", session)
-	if !*insecureFlag && cfg.CertPEMFile != "" {
-		cfgDir := filepath.Dir(flag.Lookup("cfg@").Value.String())
-		log.Printf("cert: %v relToDir: %v", cfg.CertPEMFile, cfgDir)
-		session.CertPEMBlock, err = config.LoadFile(cfg.CertPEMFile, cfgDir)
-		if err != nil {
-			log.Fatalf("reading CertPEMFile: %v", err)
-		}
-	}
-	if len(cfg.AuthHelper) != 0 {
-		auth, err := exec.Command(cfg.AuthHelper, "https://push.ubuntu.com/").Output()
-		if err != nil {
-			log.Fatalf("auth helper: %v", err)
-		}
-		session.Auth = strings.TrimSpace(string(auth))
-	}
+		Model:        cfg.DeviceModel,
+		ImageChannel: cfg.ImageChannel,
+		ReportPings:  cfg.ReportPings,
+	}
+	cfgDir := filepath.Dir(flag.Lookup("cfg@").Value.String())
+	onSetup(session, cfgDir)
+	session.TLSConfig, err = MakeTLSConfig(cfg.Domain, cfg.Insecure, cfg.CertPEMFile, cfgDir)
+	if err != nil {
+		log.Fatalf("tls config: %v", err)
+	}
+	session.Auth = auth("https://push.ubuntu.com/")
 	var waitForRegexp *regexp.Regexp
-	if cfg.WaitFor != "" {
+	waitForStr := waitFor()
+	if waitForStr != "" {
 		var err error
-		waitForRegexp, err = regexp.Compile(cfg.WaitFor)
+		waitForRegexp, err = regexp.Compile(waitForStr)
 		if err != nil {
 			log.Fatalf("wait_for regexp: %v", err)
 		}
@@ -118,6 +138,9 @@
 	go func() {
 		for {
 			ev := <-events
+			if strings.HasPrefix(ev, "connected") {
+				onConnect()
+			}
 			if waitForRegexp != nil && waitForRegexp.MatchString(ev) {
 				log.Println("<matching-event>:", ev)
 				os.Exit(0)

=== added file 'server/acceptance/kit/helpers.go'
--- server/acceptance/kit/helpers.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/kit/helpers.go	2014-08-22 14:47:03 +0000
@@ -0,0 +1,46 @@
+/*
+ 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 kit
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"fmt"
+
+	"launchpad.net/ubuntu-push/config"
+)
+
+// MakeTLSConfig makes a tls.Config, optionally reading a cert from
+// disk, possibly relative to relDir.
+func MakeTLSConfig(domain string, insecure bool, certPEMFile string, relDir string) (*tls.Config, error) {
+	tlsConfig := &tls.Config{}
+	tlsConfig.ServerName = domain
+	tlsConfig.InsecureSkipVerify = insecure
+	if !insecure && certPEMFile != "" {
+		certPEMBlock, err := config.LoadFile(certPEMFile, relDir)
+		if err != nil {
+			return nil, fmt.Errorf("reading cert: %v", err)
+		}
+		cp := x509.NewCertPool()
+		ok := cp.AppendCertsFromPEM(certPEMBlock)
+		if !ok {
+			return nil, fmt.Errorf("could not parse certificate")
+		}
+		tlsConfig.RootCAs = cp
+	}
+	return tlsConfig, nil
+}

=== modified file 'server/acceptance/suites/broadcast.go'
--- server/acceptance/suites/broadcast.go	2014-06-25 11:00:15 +0000
+++ server/acceptance/suites/broadcast.go	2014-08-22 14:47:03 +0000
@@ -41,8 +41,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 42}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"img1/m1":42}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -56,14 +55,13 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m2": 10}`),
 	})
-	c.Assert(err, IsNil)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 20}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"img1/m1":20}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -77,8 +75,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClient(c, "DEVB", nil)
 	// gettting pending on connect
@@ -97,8 +94,7 @@
 			ExpireOn: future,
 			Data:     json.RawMessage(fmt.Sprintf(payloadFmt, i)),
 		})
-		c.Assert(err, IsNil)
-		c.Assert(got, Matches, OK)
+		c.Assert(err, IsNil, Commentf("%v", got))
 	}
 
 	events, errCh, stop := s.StartClient(c, "DEVC", nil)
@@ -130,8 +126,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 42}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events1, errCh1), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"img1/m1":42}]`)
 	c.Check(NextEvent(events2, errCh2), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"img1/m1":42}]`)
 	stop1()
@@ -149,8 +144,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"img1/m1":1}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -161,8 +155,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	// reconnect, provide levels, get only later notification
 	events, errCh, stop = s.StartClient(c, "DEVD", map[string]int64{
 		protocol.SystemChannelId: 1,
@@ -180,15 +173,13 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: 10,
@@ -219,15 +210,13 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: -10,
@@ -246,15 +235,13 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: time.Now().Add(1 * time.Second).Format(time.RFC3339),
 		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	time.Sleep(2 * time.Second)
 	// second broadcast is expired

=== modified file 'server/acceptance/suites/suite.go'
--- server/acceptance/suites/suite.go	2014-06-25 11:00:15 +0000
+++ server/acceptance/suites/suite.go	2014-08-22 14:47:03 +0000
@@ -18,13 +18,9 @@
 package suites
 
 import (
-	"bytes"
-	"encoding/json"
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"net"
-	"net/http"
 	"os"
 	"runtime"
 	"time"
@@ -32,6 +28,7 @@
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/server/acceptance"
+	"launchpad.net/ubuntu-push/server/acceptance/kit"
 	helpers "launchpad.net/ubuntu-push/testing"
 )
 
@@ -84,14 +81,10 @@
 	StartServer func(c *C, s *AcceptanceSuite, handle *ServerHandle)
 	// populated by StartServer
 	ServerHandle
-	ServerAPIURL string
+	kit.APIClient // has ServerAPIURL
 	// KillGroup should be populated by StartServer with functions
 	// to kill the server process
 	KillGroup map[string]func(os.Signal)
-	// hook to adjust requests
-	MassageRequest func(req *http.Request, message interface{}) *http.Request
-	// other state
-	httpClient *http.Client
 }
 
 // Start a new server for each test.
@@ -101,7 +94,7 @@
 	c.Assert(s.ServerHandle.ServerEvents, NotNil)
 	c.Assert(s.ServerHandle.ServerAddr, Not(Equals), "")
 	c.Assert(s.ServerAPIURL, Not(Equals), "")
-	s.httpClient = &http.Client{}
+	s.SetupClient(nil)
 }
 
 func (s *AcceptanceSuite) TearDownTest(c *C) {
@@ -110,45 +103,19 @@
 	}
 }
 
-// Post a API 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")
-
-	if s.MassageRequest != nil {
-		request = s.MassageRequest(request, message)
-	}
-
-	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, model, imageChannel string, reportPings bool) *acceptance.ClientSession {
-	certPEMBlock, err := ioutil.ReadFile(helpers.SourceRelative("../ssl/testing.cert"))
+	tlsConfig, err := kit.MakeTLSConfig("", false, helpers.SourceRelative("../ssl/testing.cert"), "")
 	if err != nil {
 		panic(fmt.Sprintf("could not read ssl/testing.cert: %v", err))
 	}
 	return &acceptance.ClientSession{
 		ExchangeTimeout: 100 * time.Millisecond,
 		ServerAddr:      addr,
-		CertPEMBlock:    certPEMBlock,
 		DeviceId:        deviceId,
 		Model:           model,
 		ImageChannel:    imageChannel,
 		ReportPings:     reportPings,
+		TLSConfig:       tlsConfig,
 	}
 }
 
@@ -198,5 +165,3 @@
 
 // Long after the end of the tests.
 var future = time.Now().Add(9 * time.Hour).Format(time.RFC3339)
-
-const OK = `.*"ok":true.*`

=== modified file 'server/acceptance/suites/unicast.go'
--- server/acceptance/suites/unicast.go	2014-07-14 15:23:17 +0000
+++ server/acceptance/suites/unicast.go	2014-08-22 14:47:03 +0000
@@ -23,6 +23,7 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/server/acceptance/kit"
 	"launchpad.net/ubuntu-push/server/api"
 )
 
@@ -45,20 +46,15 @@
 		DeviceId: "DEV1",
 		AppId:    "app1",
 	})
-	c.Assert(err, IsNil)
-	c.Assert(res, Matches, OK)
-	var reg map[string]interface{}
-	err = json.Unmarshal([]byte(res), &reg)
-	c.Assert(err, IsNil)
+	c.Assert(err, IsNil, Commentf("%v", res))
 	events, errCh, stop := s.StartClientAuth(c, "DEV1", nil, auth)
 	got, err := s.PostRequest("/notify", &api.Unicast{
-		Token:    reg["token"].(string),
+		Token:    res["token"].(string),
 		AppId:    "app1",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"a": 42}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events, errCh), Equals, `unicast app:app1 payload:{"a":42};`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -80,8 +76,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"to": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/notify", &api.Unicast{
 		UserId:   userId2,
 		DeviceId: "DEV2",
@@ -89,8 +84,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"to": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events1, errCh1), Equals, `unicast app:app1 payload:{"to":1};`)
 	c.Check(NextEvent(events2, errCh2), Equals, `unicast app:app1 payload:{"to":2};`)
 	stop1()
@@ -111,8 +105,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"a": 42}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	// get pending on connect
 	events, errCh, stop := s.StartClientAuth(c, "DEV1", nil, auth)
@@ -134,8 +127,7 @@
 			ExpireOn: future,
 			Data:     json.RawMessage(fmt.Sprintf(payloadFmt, i)),
 		})
-		c.Assert(err, IsNil)
-		c.Assert(got, Matches, OK)
+		c.Assert(err, IsNil, Commentf("%v", got))
 	}
 
 	events, errCh, stop := s.StartClientAuth(c, "DEV2", nil, auth)
@@ -168,8 +160,7 @@
 			ExpireOn: future,
 			Data:     json.RawMessage(fmt.Sprintf(payloadFmt, i)),
 		})
-		c.Assert(err, IsNil)
-		c.Assert(got, Matches, OK)
+		c.Assert(err, IsNil, Commentf("%v", got))
 	}
 
 	got, err := s.PostRequest("/notify", &api.Unicast{
@@ -179,8 +170,9 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(fmt.Sprintf(payloadFmt, MaxNotificationsPerApplication)),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, `.*"error":"too-many-pending".*`)
+	c.Assert(err, Equals, kit.ErrNOk, Commentf("%v", got))
+	errorStr, _ := got["error"].(string)
+	c.Assert(errorStr, Equals, "too-many-pending")
 
 	// clear all pending
 	got, err = s.PostRequest("/notify", &api.Unicast{
@@ -191,8 +183,7 @@
 		Data:         json.RawMessage(fmt.Sprintf(payloadFmt, 1000)),
 		ClearPending: true,
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClientAuth(c, "DEV2", nil, auth)
 	// getting the 1 pending on connect
@@ -214,8 +205,7 @@
 		Data:       json.RawMessage(`{"m": 1}`),
 		ReplaceTag: "tagFoo",
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	// replace
 	got, err = s.PostRequest("/notify", &api.Unicast{
@@ -226,8 +216,7 @@
 		Data:       json.RawMessage(`{"m": 2}`),
 		ReplaceTag: "tagFoo",
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClientAuth(c, "DEV2", nil, auth)
 	// getting the 1 pending on connect