Merge lp:~chipaca/ubuntu-push/session-refactor-001 into lp:ubuntu-push/automatic

[John Lenton]

Unmerged revisions

366. By John Lenton on 2015-02-06

protect the chs with a lock. any lock will do.

365. By John Lenton on 2015-02-06

added SetChForTesting, for testing

364. By John Lenton on 2015-02-06

first step

363. By John Lenton on 2015-02-05

Merged explicit-check-for-oversize-webcheck-response-bodies into session-refactor.

=== modified file 'client/client.go'
--- client/client.go	2015-01-26 21:00:27 +0000
+++ client/client.go	2015-02-12 14:33:25 +0000
@@ -116,7 +116,7 @@
 	systemImageInfo    *systemimage.InfoResult
 	connCh             chan bool
 	hasConnectivity    bool
-	session            *session.ClientSession
+	session            session.ClientSession
 	sessionConnectedCh chan uint32
 	pushService        PushService
 	postalService      PostalService
@@ -483,11 +483,11 @@
 			accountshandler()
 		case state := <-client.connCh:
 			connhandler(state)
-		case bcast := <-client.session.BroadcastCh:
+		case bcast := <-client.session.GetBroadcastCh():
 			bcasthandler(bcast)
-		case aucast := <-client.session.NotificationsCh:
+		case aucast := <-client.session.GetNotificationsCh():
 			ucasthandler(aucast)
-		case err := <-client.session.ErrCh:
+		case err := <-client.session.GetErrCh():
 			errhandler(err)
 		case count := <-client.sessionConnectedCh:
 			client.log.Debugf("session connected after %d attempts", count)
 
=== modified file 'client/client_test.go'
--- client/client_test.go	2015-02-06 13:09:16 +0000
+++ client/client_test.go	2015-02-12 14:33:25 +0000
@@ -528,7 +528,7 @@
 func (cs *clientSuite) TestDerivePollerSetup(c *C) {
 	cs.writeTestConfig(map[string]interface{}{})
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.session = new(session.ClientSession)
+	cli.session = new(session.ConcreteSession)
 	err := cli.configure()
 	c.Assert(err, IsNil)
 	expected := &poller.PollerSetup{
@@ -1031,8 +1031,9 @@
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSessionAndPoller(), IsNil)
-	cli.session.BroadcastCh = make(chan *session.BroadcastNotification, 1)
-	cli.session.BroadcastCh <- &session.BroadcastNotification{}
+	bcastCh := make(chan *session.BroadcastNotification, 1)
+	cli.session.SetChForTesting(bcastCh, nil, nil)
+	bcastCh <- &session.BroadcastNotification{}
 
 	ch := make(chan bool, 1)
 	go cli.doLoop(nopConn, func(_ *session.BroadcastNotification) error { ch <- true; return nil }, nopUcast, nopError, nopUnregister, nopAcct)
@@ -1044,8 +1045,9 @@
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSessionAndPoller(), IsNil)
-	cli.session.NotificationsCh = make(chan session.AddressedNotification, 1)
-	cli.session.NotificationsCh <- session.AddressedNotification{}
+	notifCh := make(chan session.AddressedNotification, 1)
+	cli.session.SetChForTesting(nil, notifCh, nil)
+	notifCh <- session.AddressedNotification{}
 
 	ch := make(chan bool, 1)
 	go cli.doLoop(nopConn, nopBcast, func(session.AddressedNotification) error { ch <- true; return nil }, nopError, nopUnregister, nopAcct)
@@ -1057,8 +1059,9 @@
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSessionAndPoller(), IsNil)
-	cli.session.ErrCh = make(chan error, 1)
-	cli.session.ErrCh <- nil
+	errCh := make(chan error, 1)
+	cli.session.SetChForTesting(nil, nil, errCh)
+	errCh <- nil
 
 	ch := make(chan bool, 1)
 	go cli.doLoop(nopConn, nopBcast, nopUcast, func(error) { ch <- true }, nopUnregister, nopAcct)
@@ -1137,8 +1140,9 @@
 
 	c.Assert(cli.initSessionAndPoller(), IsNil)
 
-	cli.session.BroadcastCh = make(chan *session.BroadcastNotification)
-	cli.session.ErrCh = make(chan error)
+	bcastCh := make(chan *session.BroadcastNotification)
+	errCh := make(chan error)
+	cli.session.SetChForTesting(bcastCh, nil, errCh)
 
 	// we use tick() to make sure things have been through the
 	// event loop at least once before looking at things;
@@ -1165,12 +1169,12 @@
 
 	//  * session.BroadcastCh to the notifications handler
 	c.Check(d.bcastCount, Equals, 0)
-	cli.session.BroadcastCh <- positiveBroadcastNotification
+	bcastCh <- positiveBroadcastNotification
 	tick()
 	c.Check(d.bcastCount, Equals, 1)
 
 	//  * session.ErrCh to the error handler
-	cli.session.ErrCh <- nil
+	errCh <- nil
 	tick()
 	c.Check(cs.log.Captured(), Matches, "(?ms).*session exited.*")
 }
 
=== modified file 'client/session/session.go'
--- client/session/session.go	2015-01-22 11:05:37 +0000
+++ client/session/session.go	2015-02-12 14:33:25 +0000
@@ -120,8 +120,20 @@
 	AddresseeChecker       AddresseeChecking
 }
 
-// ClientSession holds a client<->server session and its configuration.
-type ClientSession struct {
+type ClientSession interface {
+	State() ClientSessionState
+	Close()
+	AutoRedial(done chan uint32)
+	ClearCookie()
+	Dial() error
+	GetBroadcastCh() chan *BroadcastNotification
+	GetNotificationsCh() chan AddressedNotification
+	GetErrCh() chan error
+	SetChForTesting(chan *BroadcastNotification, chan AddressedNotification, chan error)
+}
+
+// ConcreteSession holds a client<->server session and its configuration.
+type ConcreteSession struct {
 	// configuration
 	DeviceId string
 	ClientSessionConfig
@@ -157,13 +169,13 @@
 	// autoredial knobs
 	shouldDelayP    *uint32
 	lastAutoRedial  time.Time
-	redialDelay     func(*ClientSession) time.Duration
+	redialDelay     func(*ConcreteSession) time.Duration
 	redialJitter    func(time.Duration) time.Duration
 	redialDelays    []time.Duration
 	redialDelaysIdx int
 }
 
-func redialDelay(sess *ClientSession) time.Duration {
+func redialDelay(sess *ConcreteSession) time.Duration {
 	if sess.ShouldDelay() {
 		t := sess.redialDelays[sess.redialDelaysIdx]
 		if len(sess.redialDelays) > sess.redialDelaysIdx+1 {
@@ -178,7 +190,13 @@
 
 func NewSession(serverAddrSpec string, conf ClientSessionConfig,
 	deviceId string, seenStateFactory func() (seenstate.SeenState, error),
-	log logger.Logger) (*ClientSession, error) {
+	log logger.Logger) (ClientSession, error) {
+	return newSession(serverAddrSpec, conf, deviceId, seenStateFactory, log)
+}
+
+func newSession(serverAddrSpec string, conf ClientSessionConfig,
+	deviceId string, seenStateFactory func() (seenstate.SeenState, error),
+	log logger.Logger) (*ConcreteSession, error) {
 	state := uint32(Disconnected)
 	seenState, err := seenStateFactory()
 	if err != nil {
@@ -191,7 +209,7 @@
 		getHost = gethosts.New(deviceId, hostsEndpoint, conf.ExchangeTimeout)
 	}
 	var shouldDelay uint32 = 0
-	sess := &ClientSession{
+	sess := &ConcreteSession{
 		ClientSessionConfig: conf,
 		getHost:             getHost,
 		fallbackHosts:       fallbackHosts,
@@ -218,59 +236,83 @@
 	return sess, nil
 }
 
-func (sess *ClientSession) ShouldDelay() bool {
+func (sess *ConcreteSession) GetBroadcastCh() chan *BroadcastNotification {
+	return sess.BroadcastCh
+}
+func (sess *ConcreteSession) GetNotificationsCh() chan AddressedNotification {
+	return sess.NotificationsCh
+}
+func (sess *ConcreteSession) GetErrCh() chan error {
+	return sess.ErrCh
+}
+func (sess *ConcreteSession) SetChForTesting(bch chan *BroadcastNotification, nch chan AddressedNotification, ech chan error) {
+	// abusing connLock a bit
+	sess.connLock.Lock()
+	defer sess.connLock.Unlock()
+	if bch != nil {
+		sess.BroadcastCh = bch
+	}
+	if nch != nil {
+		sess.NotificationsCh = nch
+	}
+	if ech != nil {
+		sess.ErrCh = ech
+	}
+}
+
+func (sess *ConcreteSession) ShouldDelay() bool {
 	return atomic.LoadUint32(sess.shouldDelayP) != 0
 }
 
-func (sess *ClientSession) setShouldDelay() {
+func (sess *ConcreteSession) setShouldDelay() {
 	atomic.StoreUint32(sess.shouldDelayP, uint32(1))
 }
 
-func (sess *ClientSession) clearShouldDelay() {
+func (sess *ConcreteSession) clearShouldDelay() {
 	atomic.StoreUint32(sess.shouldDelayP, uint32(0))
 }
 
-func (sess *ClientSession) State() ClientSessionState {
+func (sess *ConcreteSession) State() ClientSessionState {
 	return ClientSessionState(atomic.LoadUint32(sess.stateP))
 }
 
-func (sess *ClientSession) setState(state ClientSessionState) {
+func (sess *ConcreteSession) setState(state ClientSessionState) {
 	sess.Log.Debugf("session.setState: %s -> %s", ClientSessionState(atomic.LoadUint32(sess.stateP)), state)
 	atomic.StoreUint32(sess.stateP, uint32(state))
 }
 
-func (sess *ClientSession) setConnection(conn net.Conn) {
+func (sess *ConcreteSession) setConnection(conn net.Conn) {
 	sess.connLock.Lock()
 	defer sess.connLock.Unlock()
 	sess.Connection = conn
 }
 
-func (sess *ClientSession) getConnection() net.Conn {
+func (sess *ConcreteSession) getConnection() net.Conn {
 	sess.connLock.RLock()
 	defer sess.connLock.RUnlock()
 	return sess.Connection
 }
 
-func (sess *ClientSession) setCookie(cookie string) {
+func (sess *ConcreteSession) setCookie(cookie string) {
 	sess.connLock.Lock()
 	defer sess.connLock.Unlock()
 	sess.cookie = cookie
 }
 
-func (sess *ClientSession) getCookie() string {
+func (sess *ConcreteSession) getCookie() string {
 	sess.connLock.RLock()
 	defer sess.connLock.RUnlock()
 	return sess.cookie
 }
 
-func (sess *ClientSession) ClearCookie() {
+func (sess *ConcreteSession) ClearCookie() {
 	sess.connLock.Lock()
 	defer sess.connLock.Unlock()
 	sess.cookie = ""
 }
 
 // getHosts sets deliveryHosts possibly querying a remote endpoint
-func (sess *ClientSession) getHosts() error {
+func (sess *ConcreteSession) getHosts() error {
 	if sess.getHost != nil {
 		if sess.deliveryHosts != nil && sess.timeSince(sess.deliveryHostsTimestamp) < sess.HostsCachingExpiryTime {
 			return nil
@@ -294,7 +336,7 @@
 
 // addAuthorization gets the authorization blob to send to the server
 // and adds it to the session.
-func (sess *ClientSession) addAuthorization() error {
+func (sess *ConcreteSession) addAuthorization() error {
 	if sess.AuthGetter != nil {
 		sess.Log.Debugf("adding authorization")
 		sess.auth = sess.AuthGetter(sess.AuthURL)
@@ -302,13 +344,13 @@
 	return nil
 }
 
-func (sess *ClientSession) resetHosts() {
+func (sess *ConcreteSession) resetHosts() {
 	sess.deliveryHosts = nil
 }
 
 // startConnectionAttempt/nextHostToTry help connect iterating over candidate hosts
 
-func (sess *ClientSession) startConnectionAttempt() {
+func (sess *ConcreteSession) startConnectionAttempt() {
 	if sess.timeSince(sess.lastAttemptTimestamp) > sess.ExpectAllRepairedTime {
 		sess.tryHost = 0
 	}
@@ -319,7 +361,7 @@
 	sess.lastAttemptTimestamp = time.Now()
 }
 
-func (sess *ClientSession) nextHostToTry() string {
+func (sess *ConcreteSession) nextHostToTry() string {
 	if sess.leftToTry == 0 {
 		return ""
 	}
@@ -331,7 +373,7 @@
 
 // we reached the Started state, we can retry with the same host if we
 // have to retry again
-func (sess *ClientSession) started() {
+func (sess *ConcreteSession) started() {
 	sess.tryHost--
 	if sess.tryHost == -1 {
 		sess.tryHost = len(sess.deliveryHosts) - 1
@@ -341,7 +383,7 @@
 
 // connect to a server using the configuration in the ClientSession
 // and set up the connection.
-func (sess *ClientSession) connect() error {
+func (sess *ConcreteSession) connect() error {
 	sess.setShouldDelay()
 	sess.startConnectionAttempt()
 	var err error
@@ -363,7 +405,7 @@
 	return nil
 }
 
-func (sess *ClientSession) stopRedial() {
+func (sess *ConcreteSession) stopRedial() {
 	sess.retrierLock.Lock()
 	defer sess.retrierLock.Unlock()
 	if sess.retrier != nil {
@@ -372,7 +414,7 @@
 	}
 }
 
-func (sess *ClientSession) AutoRedial(doneCh chan uint32) {
+func (sess *ConcreteSession) AutoRedial(doneCh chan uint32) {
 	sess.stopRedial()
 	if time.Since(sess.lastAutoRedial) < 2*time.Second {
 		sess.setShouldDelay()
@@ -398,12 +440,12 @@
 	}()
 }
 
-func (sess *ClientSession) Close() {
+func (sess *ConcreteSession) Close() {
 	sess.stopRedial()
 	sess.doClose()
 }
 
-func (sess *ClientSession) doClose() {
+func (sess *ConcreteSession) doClose() {
 	sess.connLock.Lock()
 	defer sess.connLock.Unlock()
 	if sess.Connection != nil {
@@ -417,7 +459,7 @@
 }
 
 // handle "ping" messages
-func (sess *ClientSession) handlePing() error {
+func (sess *ConcreteSession) handlePing() error {
 	err := sess.proto.WriteMessage(protocol.PingPongMsg{Type: "pong"})
 	if err == nil {
 		sess.Log.Debugf("ping.")
@@ -429,7 +471,7 @@
 	return err
 }
 
-func (sess *ClientSession) decodeBroadcast(bcast *serverMsg) *BroadcastNotification {
+func (sess *ConcreteSession) decodeBroadcast(bcast *serverMsg) *BroadcastNotification {
 	decoded := make([]map[string]interface{}, 0)
 	for _, p := range bcast.Payloads {
 		var v map[string]interface{}
@@ -447,7 +489,7 @@
 }
 
 // handle "broadcast" messages
-func (sess *ClientSession) handleBroadcast(bcast *serverMsg) error {
+func (sess *ConcreteSession) handleBroadcast(bcast *serverMsg) error {
 	err := sess.SeenState.SetLevel(bcast.ChanId, bcast.TopLevel)
 	if err != nil {
 		sess.setState(Error)
@@ -478,7 +520,7 @@
 }
 
 // handle "notifications" messages
-func (sess *ClientSession) handleNotifications(ucast *serverMsg) error {
+func (sess *ConcreteSession) handleNotifications(ucast *serverMsg) error {
 	notifs, err := sess.SeenState.FilterBySeen(ucast.Notifications)
 	if err != nil {
 		sess.setState(Error)
@@ -512,7 +554,7 @@
 }
 
 // handle "connbroken" messages
-func (sess *ClientSession) handleConnBroken(connBroken *serverMsg) error {
+func (sess *ConcreteSession) handleConnBroken(connBroken *serverMsg) error {
 	sess.setState(Error)
 	reason := connBroken.Reason
 	err := fmt.Errorf("server broke connection: %s", reason)
@@ -525,7 +567,7 @@
 }
 
 // handle "setparams" messages
-func (sess *ClientSession) handleSetParams(setParams *serverMsg) error {
+func (sess *ConcreteSession) handleSetParams(setParams *serverMsg) error {
 	if setParams.SetCookie != "" {
 		sess.setCookie(setParams.SetCookie)
 	}
@@ -533,7 +575,7 @@
 }
 
 // loop runs the session with the server, emits a stream of events.
-func (sess *ClientSession) loop() error {
+func (sess *ConcreteSession) loop() error {
 	var err error
 	var recv serverMsg
 	sess.setState(Running)
@@ -571,7 +613,7 @@
 }
 
 // Call this when you've connected and want to start looping.
-func (sess *ClientSession) start() error {
+func (sess *ConcreteSession) start() error {
 	conn := sess.getConnection()
 	err := conn.SetDeadline(time.Now().Add(sess.ExchangeTimeout))
 	if err != nil {
@@ -634,7 +676,7 @@
 
 // run calls connect, and if it works it calls start, and if it works
 // it runs loop in a goroutine, and ships its return value over ErrCh.
-func (sess *ClientSession) run(closer func(), authChecker, hostGetter, connecter, starter, looper func() error) error {
+func (sess *ConcreteSession) run(closer func(), authChecker, hostGetter, connecter, starter, looper func() error) error {
 	closer()
 	if err := authChecker(); err != nil {
 		return err
@@ -656,7 +698,7 @@
 }
 
 // This Jitter returns a random time.Duration somewhere in [-spread, spread].
-func (sess *ClientSession) Jitter(spread time.Duration) time.Duration {
+func (sess *ConcreteSession) Jitter(spread time.Duration) time.Duration {
 	if spread < 0 {
 		panic("spread must be non-negative")
 	}
@@ -666,7 +708,7 @@
 
 // Dial takes the session from newly created (or newly disconnected)
 // to running the main loop.
-func (sess *ClientSession) Dial() error {
+func (sess *ConcreteSession) Dial() error {
 	if sess.Protocolator == nil {
 		// a missing protocolator means you've willfully overridden
 		// it; returning an error here would prompt AutoRedial to just
 
=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2015-02-02 16:49:46 +0000
+++ client/session/session_test.go	2015-02-12 14:33:25 +0000
@@ -169,20 +169,20 @@
 
 /////
 
-type clientSessionSuite struct {
+type ConcreteSessionSuite struct {
 	log  *helpers.TestLogger
 	lvls func() (seenstate.SeenState, error)
 }
 
-func (cs *clientSessionSuite) SetUpTest(c *C) {
+func (cs *ConcreteSessionSuite) SetUpTest(c *C) {
 	cs.log = helpers.NewTestLogger(c, "debug")
 }
 
 // in-memory level map testing
-var _ = Suite(&clientSessionSuite{lvls: seenstate.NewSeenState})
+var _ = Suite(&ConcreteSessionSuite{lvls: seenstate.NewSeenState})
 
 // sqlite level map testing
-type clientSqlevelsSessionSuite struct{ clientSessionSuite }
+type clientSqlevelsSessionSuite struct{ ConcreteSessionSuite }
 
 var _ = Suite(&clientSqlevelsSessionSuite{})
 
@@ -194,7 +194,7 @@
   parseServerAddrSpec() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestParseServerAddrSpec(c *C) {
+func (cs *ConcreteSessionSuite) TestParseServerAddrSpec(c *C) {
 	hEp, fallbackHosts := parseServerAddrSpec("http://foo/hosts")
 	c.Check(hEp, Equals, "http://foo/hosts")
 	c.Check(fallbackHosts, IsNil)
@@ -209,13 +209,13 @@
 }
 
 /****************************************************************
-  NewSession() tests
+  newSession() tests
 ****************************************************************/
 
 var dummyConf = ClientSessionConfig{}
 
-func (cs *clientSessionSuite) TestNewSessionPlainWorks(c *C) {
-	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestnewSessionPlainWorks(c *C) {
+	sess, err := newSession("foo:443", dummyConf, "", cs.lvls, cs.log)
 	c.Check(sess, NotNil)
 	c.Check(err, IsNil)
 	c.Check(sess.fallbackHosts, DeepEquals, []string{"foo:443"})
@@ -228,8 +228,8 @@
 	c.Check(sess.State(), Equals, Disconnected)
 }
 
-func (cs *clientSessionSuite) TestNewSessionHostEndpointWorks(c *C) {
-	sess, err := NewSession("http://foo/hosts", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestnewSessionHostEndpointWorks(c *C) {
+	sess, err := newSession("http://foo/hosts", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	c.Check(sess.getHost, NotNil)
 }
@@ -237,25 +237,25 @@
 var certfile string = helpers.SourceRelative("../../server/acceptance/ssl/testing.cert")
 var pem, _ = ioutil.ReadFile(certfile)
 
-func (cs *clientSessionSuite) TestNewSessionPEMWorks(c *C) {
+func (cs *ConcreteSessionSuite) TestnewSessionPEMWorks(c *C) {
 	conf := ClientSessionConfig{PEM: pem}
-	sess, err := NewSession("", conf, "wah", cs.lvls, cs.log)
+	sess, err := newSession("", conf, "wah", cs.lvls, cs.log)
 	c.Check(sess, NotNil)
 	c.Assert(err, IsNil)
 	c.Check(sess.TLS.RootCAs, NotNil)
 }
 
-func (cs *clientSessionSuite) TestNewSessionBadPEMFileContentFails(c *C) {
+func (cs *ConcreteSessionSuite) TestnewSessionBadPEMFileContentFails(c *C) {
 	badpem := []byte("This is not the PEM you're looking for.")
 	conf := ClientSessionConfig{PEM: badpem}
-	sess, err := NewSession("", conf, "wah", cs.lvls, cs.log)
+	sess, err := newSession("", conf, "wah", cs.lvls, cs.log)
 	c.Check(sess, IsNil)
 	c.Check(err, NotNil)
 }
 
-func (cs *clientSessionSuite) TestNewSessionBadSeenStateFails(c *C) {
+func (cs *ConcreteSessionSuite) TestnewSessionBadSeenStateFails(c *C) {
 	ferr := func() (seenstate.SeenState, error) { return nil, errors.New("Busted.") }
-	sess, err := NewSession("", dummyConf, "wah", ferr, cs.log)
+	sess, err := newSession("", dummyConf, "wah", ferr, cs.log)
 	c.Check(sess, IsNil)
 	c.Assert(err, NotNil)
 }
@@ -264,9 +264,9 @@
   getHosts() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestGetHostsFallback(c *C) {
+func (cs *ConcreteSessionSuite) TestGetHostsFallback(c *C) {
 	fallback := []string{"foo:443", "bar:443"}
-	sess := &ClientSession{fallbackHosts: fallback}
+	sess := &ConcreteSession{fallbackHosts: fallback}
 	err := sess.getHosts()
 	c.Assert(err, IsNil)
 	c.Check(sess.deliveryHosts, DeepEquals, fallback)
@@ -282,16 +282,16 @@
 	return &gethosts.Host{thg.domain, thg.hosts}, thg.err
 }
 
-func (cs *clientSessionSuite) TestGetHostsRemote(c *C) {
+func (cs *ConcreteSessionSuite) TestGetHostsRemote(c *C) {
 	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
-	sess := &ClientSession{getHost: hostGetter, timeSince: time.Since}
+	sess := &ConcreteSession{getHost: hostGetter, timeSince: time.Since}
 	err := sess.getHosts()
 	c.Assert(err, IsNil)
 	c.Check(sess.deliveryHosts, DeepEquals, []string{"foo:443", "bar:443"})
 }
 
-func (cs *clientSessionSuite) TestGetHostsRemoteError(c *C) {
-	sess, err := NewSession("", dummyConf, "", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestGetHostsRemoteError(c *C) {
+	sess, err := newSession("", dummyConf, "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	hostsErr := errors.New("failed")
 	hostGetter := &testHostGetter{"", nil, hostsErr}
@@ -302,9 +302,9 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestGetHostsRemoteCaching(c *C) {
+func (cs *ConcreteSessionSuite) TestGetHostsRemoteCaching(c *C) {
 	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
-	sess := &ClientSession{
+	sess := &ConcreteSession{
 		getHost: hostGetter,
 		ClientSessionConfig: ClientSessionConfig{
 			HostsCachingExpiryTime: 2 * time.Hour,
@@ -327,9 +327,9 @@
 	c.Check(sess.deliveryHosts, DeepEquals, []string{"baz:443"})
 }
 
-func (cs *clientSessionSuite) TestGetHostsRemoteCachingReset(c *C) {
+func (cs *ConcreteSessionSuite) TestGetHostsRemoteCachingReset(c *C) {
 	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
-	sess := &ClientSession{
+	sess := &ConcreteSession{
 		getHost: hostGetter,
 		ClientSessionConfig: ClientSessionConfig{
 			HostsCachingExpiryTime: 2 * time.Hour,
@@ -354,9 +354,9 @@
   addAuthorization() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestAddAuthorizationAddsAuthorization(c *C) {
+func (cs *ConcreteSessionSuite) TestAddAuthorizationAddsAuthorization(c *C) {
 	url := "xyzzy://"
-	sess := &ClientSession{Log: cs.log}
+	sess := &ConcreteSession{Log: cs.log}
 	sess.AuthGetter = func(url string) string { return url + " auth'ed" }
 	sess.AuthURL = url
 	c.Assert(sess.auth, Equals, "")
@@ -365,8 +365,8 @@
 	c.Check(sess.auth, Equals, "xyzzy:// auth'ed")
 }
 
-func (cs *clientSessionSuite) TestAddAuthorizationSkipsIfUnset(c *C) {
-	sess := &ClientSession{Log: cs.log}
+func (cs *ConcreteSessionSuite) TestAddAuthorizationSkipsIfUnset(c *C) {
+	sess := &ConcreteSession{Log: cs.log}
 	sess.AuthGetter = nil
 	c.Assert(sess.auth, Equals, "")
 	err := sess.addAuthorization()
@@ -378,9 +378,9 @@
   startConnectionAttempt()/nextHostToTry()/started tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestStartConnectionAttempt(c *C) {
+func (cs *ConcreteSessionSuite) TestStartConnectionAttempt(c *C) {
 	since := time.Since(time.Time{})
-	sess := &ClientSession{
+	sess := &ConcreteSession{
 		ClientSessionConfig: ClientSessionConfig{
 			ExpectAllRepairedTime: 10 * time.Second,
 		},
@@ -402,9 +402,9 @@
 	sess.tryHost = 2
 }
 
-func (cs *clientSessionSuite) TestStartConnectionAttemptNoHostsPanic(c *C) {
+func (cs *ConcreteSessionSuite) TestStartConnectionAttemptNoHostsPanic(c *C) {
 	since := time.Since(time.Time{})
-	sess := &ClientSession{
+	sess := &ConcreteSession{
 		ClientSessionConfig: ClientSessionConfig{
 			ExpectAllRepairedTime: 10 * time.Second,
 		},
@@ -415,8 +415,8 @@
 	c.Check(sess.startConnectionAttempt, PanicMatches, "should have got hosts from config or remote at this point")
 }
 
-func (cs *clientSessionSuite) TestNextHostToTry(c *C) {
-	sess := &ClientSession{
+func (cs *ConcreteSessionSuite) TestNextHostToTry(c *C) {
+	sess := &ConcreteSession{
 		deliveryHosts: []string{"foo:443", "bar:443", "baz:443"},
 		tryHost:       0,
 		leftToTry:     3,
@@ -438,8 +438,8 @@
 	c.Check(sess.tryHost, Equals, 1)
 }
 
-func (cs *clientSessionSuite) TestStarted(c *C) {
-	sess, err := NewSession("", dummyConf, "", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestStarted(c *C) {
+	sess, err := newSession("", dummyConf, "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 
 	sess.deliveryHosts = []string{"foo:443", "bar:443", "baz:443"}
@@ -457,8 +457,8 @@
   connect() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestConnectFailsWithNoAddress(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestConnectFailsWithNoAddress(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{"nowhere"}
 	sess.clearShouldDelay()
@@ -468,11 +468,11 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestConnectConnects(c *C) {
+func (cs *ConcreteSessionSuite) TestConnectConnects(c *C) {
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
 	defer srv.Close()
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{srv.Addr().String()}
 	sess.clearShouldDelay()
@@ -483,11 +483,11 @@
 	c.Check(sess.State(), Equals, Connected)
 }
 
-func (cs *clientSessionSuite) TestConnectSecondConnects(c *C) {
+func (cs *ConcreteSessionSuite) TestConnectSecondConnects(c *C) {
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
 	defer srv.Close()
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{"nowhere", srv.Addr().String()}
 	sess.clearShouldDelay()
@@ -499,10 +499,10 @@
 	c.Check(sess.tryHost, Equals, 0)
 }
 
-func (cs *clientSessionSuite) TestConnectConnectFail(c *C) {
+func (cs *ConcreteSessionSuite) TestConnectConnectFail(c *C) {
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
-	sess, err := NewSession(srv.Addr().String(), dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession(srv.Addr().String(), dummyConf, "wah", cs.lvls, cs.log)
 	srv.Close()
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{srv.Addr().String()}
@@ -517,8 +517,8 @@
   Close() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestClose(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestClose(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestClose"}
 	sess.Close()
@@ -526,8 +526,8 @@
 	c.Check(sess.State(), Equals, Disconnected)
 }
 
-func (cs *clientSessionSuite) TestCloseTwice(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestCloseTwice(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestCloseTwice"}
 	sess.Close()
@@ -537,8 +537,8 @@
 	c.Check(sess.State(), Equals, Disconnected)
 }
 
-func (cs *clientSessionSuite) TestCloseFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestCloseFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestCloseFails", CloseCondition: condition.Work(false)}
 	sess.Close()
@@ -551,8 +551,8 @@
 func (*derp) Redial() uint32 { return 0 }
 func (d *derp) Stop()        { d.stopped = true }
 
-func (cs *clientSessionSuite) TestCloseStopsRetrier(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestCloseStopsRetrier(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	ar := new(derp)
 	sess.retrier = ar
@@ -567,9 +567,9 @@
   AutoRedial() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestAutoRedialWorks(c *C) {
+func (cs *ConcreteSessionSuite) TestAutoRedialWorks(c *C) {
 	// checks that AutoRedial sets up a retrier and tries redialing it
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	ar := new(derp)
 	sess.retrier = ar
@@ -578,9 +578,9 @@
 	c.Check(ar.stopped, Equals, true)
 }
 
-func (cs *clientSessionSuite) TestAutoRedialStopsRetrier(c *C) {
+func (cs *ConcreteSessionSuite) TestAutoRedialStopsRetrier(c *C) {
 	// checks that AutoRedial stops the previous retrier
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	ch := make(chan uint32)
 	c.Check(sess.retrier, IsNil)
@@ -590,19 +590,19 @@
 	c.Check(<-ch, Not(Equals), 0)
 }
 
-func (cs *clientSessionSuite) TestAutoRedialCallsRedialDelay(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestAutoRedialCallsRedialDelay(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	flag := false
-	sess.redialDelay = func(sess *ClientSession) time.Duration { flag = true; return 0 }
+	sess.redialDelay = func(sess *ConcreteSession) time.Duration { flag = true; return 0 }
 	sess.AutoRedial(nil)
 	c.Check(flag, Equals, true)
 }
 
-func (cs *clientSessionSuite) TestAutoRedialSetsRedialDelayIfTooQuick(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestAutoRedialSetsRedialDelayIfTooQuick(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
-	sess.redialDelay = func(sess *ClientSession) time.Duration { return 0 }
+	sess.redialDelay = func(sess *ConcreteSession) time.Duration { return 0 }
 	sess.AutoRedial(nil)
 	c.Check(sess.ShouldDelay(), Equals, false)
 	sess.stopRedial()
@@ -616,7 +616,7 @@
 ****************************************************************/
 
 type msgSuite struct {
-	sess   *ClientSession
+	sess   *ConcreteSession
 	upCh   chan interface{}
 	downCh chan interface{}
 	errCh  chan error
@@ -629,7 +629,7 @@
 	conf := ClientSessionConfig{
 		ExchangeTimeout: time.Millisecond,
 	}
-	s.sess, err = NewSession("", conf, "wah", seenstate.NewSeenState, helpers.NewTestLogger(c, "debug"))
+	s.sess, err = newSession("", conf, "wah", seenstate.NewSeenState, helpers.NewTestLogger(c, "debug"))
 	c.Assert(err, IsNil)
 	s.sess.Connection = &testConn{Name: "TestHandle*"}
 	s.errCh = make(chan error, 1)
@@ -1167,8 +1167,8 @@
 /****************************************************************
   start() tests
 ****************************************************************/
-func (cs *clientSessionSuite) TestStartFailsIfSetDeadlineFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestStartFailsIfSetDeadlineFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartFailsIfSetDeadlineFails",
 		DeadlineCondition: condition.Work(false)} // setdeadline will fail
@@ -1177,8 +1177,8 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestStartFailsIfWriteFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestStartFailsIfWriteFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartFailsIfWriteFails",
 		WriteCondition: condition.Work(false)} // write will fail
@@ -1187,8 +1187,8 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestStartFailsIfGetLevelsFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestStartFailsIfGetLevelsFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.SeenState = &brokenSeenState{}
 	sess.Connection = &testConn{Name: "TestStartConnectMessageFails"}
@@ -1207,8 +1207,8 @@
 	c.Check(err, ErrorMatches, "broken.")
 }
 
-func (cs *clientSessionSuite) TestStartConnectMessageFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestStartConnectMessageFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartConnectMessageFails"}
 	errCh := make(chan error, 1)
@@ -1234,8 +1234,8 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestStartConnackReadError(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestStartConnackReadError(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartConnackReadError"}
 	errCh := make(chan error, 1)
@@ -1258,8 +1258,8 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestStartBadConnack(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestStartBadConnack(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartBadConnack"}
 	errCh := make(chan error, 1)
@@ -1282,8 +1282,8 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestStartNotConnack(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestStartNotConnack(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartBadConnack"}
 	errCh := make(chan error, 1)
@@ -1306,7 +1306,7 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestStartWorks(c *C) {
+func (cs *ConcreteSessionSuite) TestStartWorks(c *C) {
 	info := map[string]interface{}{
 		"foo": 1,
 		"bar": "baz",
@@ -1314,7 +1314,7 @@
 	conf := ClientSessionConfig{
 		Info: info,
 	}
-	sess, err := NewSession("", conf, "wah", cs.lvls, cs.log)
+	sess, err := newSession("", conf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartWorks"}
 	sess.setCookie("COOKIE")
@@ -1350,8 +1350,8 @@
   run() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestRunBailsIfAuthCheckFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestRunBailsIfAuthCheckFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	failure := errors.New("TestRunBailsIfAuthCheckFails")
 	has_closed := false
@@ -1366,8 +1366,8 @@
 	c.Check(has_closed, Equals, true)
 }
 
-func (cs *clientSessionSuite) TestRunBailsIfHostGetterFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestRunBailsIfHostGetterFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	failure := errors.New("TestRunBailsIfHostGetterFails")
 	has_closed := false
@@ -1382,8 +1382,8 @@
 	c.Check(has_closed, Equals, true)
 }
 
-func (cs *clientSessionSuite) TestRunBailsIfConnectFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestRunBailsIfConnectFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	failure := errors.New("TestRunBailsIfConnectFails")
 	err = sess.run(
@@ -1396,8 +1396,8 @@
 	c.Check(err, Equals, failure)
 }
 
-func (cs *clientSessionSuite) TestRunBailsIfStartFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestRunBailsIfStartFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	failure := errors.New("TestRunBailsIfStartFails")
 	err = sess.run(
@@ -1410,8 +1410,8 @@
 	c.Check(err, Equals, failure)
 }
 
-func (cs *clientSessionSuite) TestRunRunsEvenIfLoopFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestRunRunsEvenIfLoopFails(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	// just to make a point: until here we haven't set ErrCh & BroadcastCh (no
 	// biggie if this stops being true)
@@ -1441,8 +1441,8 @@
   Jitter() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestJitter(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestJitter(c *C) {
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	num_tries := 20       // should do the math
 	spread := time.Second //
@@ -1472,9 +1472,9 @@
   Dial() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestDialPanics(c *C) {
+func (cs *ConcreteSessionSuite) TestDialPanics(c *C) {
 	// one last unhappy test
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Protocolator = nil
 	c.Check(sess.Dial, PanicMatches, ".*protocol constructor.")
@@ -1488,7 +1488,7 @@
 	}
 )
 
-func (cs *clientSessionSuite) TestDialBadServerName(c *C) {
+func (cs *ConcreteSessionSuite) TestDialBadServerName(c *C) {
 	// a borked server name
 	lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)
 	c.Assert(err, IsNil)
@@ -1506,7 +1506,7 @@
 	}))
 	defer ts.Close()
 
-	sess, err := NewSession(ts.URL, dialTestConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession(ts.URL, dialTestConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	tconn := &testConn{}
 	sess.Connection = tconn
@@ -1533,7 +1533,7 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-func (cs *clientSessionSuite) TestDialWorks(c *C) {
+func (cs *ConcreteSessionSuite) TestDialWorks(c *C) {
 	// happy path thoughts
 	lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)
 	c.Assert(err, IsNil)
@@ -1551,7 +1551,7 @@
 	}))
 	defer ts.Close()
 
-	sess, err := NewSession(ts.URL, dialTestConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession(ts.URL, dialTestConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	tconn := &testConn{CloseCondition: condition.Fail2Work(10)}
 	sess.Connection = tconn
@@ -1634,11 +1634,11 @@
 	c.Check(<-sess.ErrCh, Equals, failure)
 }
 
-func (cs *clientSessionSuite) TestDialWorksDirect(c *C) {
+func (cs *ConcreteSessionSuite) TestDialWorksDirect(c *C) {
 	// happy path thoughts
 	lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)
 	c.Assert(err, IsNil)
-	sess, err := NewSession(lst.Addr().String(), dialTestConf, "wah", cs.lvls, cs.log)
+	sess, err := newSession(lst.Addr().String(), dialTestConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	defer sess.Close()
 
@@ -1658,8 +1658,8 @@
   redialDelay() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestShouldDelay(c *C) {
-	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestShouldDelay(c *C) {
+	sess, err := newSession("foo:443", dummyConf, "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	c.Check(sess.ShouldDelay(), Equals, false)
 	sess.setShouldDelay()
@@ -1668,8 +1668,8 @@
 	c.Check(sess.ShouldDelay(), Equals, false)
 }
 
-func (cs *clientSessionSuite) TestRedialDelay(c *C) {
-	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestRedialDelay(c *C) {
+	sess, err := newSession("foo:443", dummyConf, "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.redialDelays = []time.Duration{17, 42}
 	n := 0
@@ -1693,8 +1693,8 @@
   ClearCookie() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestClearCookie(c *C) {
-	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+func (cs *ConcreteSessionSuite) TestClearCookie(c *C) {
+	sess, err := newSession("foo:443", dummyConf, "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	c.Check(sess.getCookie(), Equals, "")
 	sess.setCookie("COOKIE")