Merge lp:~chipaca/ubuntu-push/small-reorg into lp:ubuntu-push

[John Lenton]

Killed checkRunnable; renamed: Dial -> connect, run -> loop.

Killed checkRunnable; renamed: Dial -> connect, run -> loop.

[Samuele Pedroni (pedronis)]

review: Approve

=== modified file 'client/session/session.go'
--- client/session/session.go	2014-01-31 19:42:28 +0000
+++ client/session/session.go	2014-01-31 21:54:22 +0000
@@ -83,12 +83,12 @@
 	return sess, nil
 }
 
-// Dial connects to a server using the configuration in the ClientSession
-// and sets up the connection.
-func (sess *ClientSession) Dial() error {
+// connect to a server using the configuration in the ClientSession
+// and set up the connection.
+func (sess *ClientSession) connect() error {
 	conn, err := net.DialTimeout("tcp", sess.ServerAddr, sess.ExchangeTimeout)
 	if err != nil {
-		return err
+		return fmt.Errorf("connect: %s", err)
 	}
 	sess.Connection = tls.Client(conn, sess.TLS)
 	return nil
@@ -104,17 +104,6 @@
 	}
 }
 
-// call this to ensure the session is sane to run
-func (sess *ClientSession) checkRunnable() error {
-	if sess.Connection == nil {
-		return errors.New("can't run disconnected.")
-	}
-	if sess.Protocolator == nil {
-		return errors.New("can't run without a protocol constructor.")
-	}
-	return nil
-}
-
 // handle "ping" messages
 func (sess *ClientSession) handlePing() error {
 	err := sess.proto.WriteMessage(protocol.PingPongMsg{Type: "pong"})
@@ -144,8 +133,8 @@
 	return nil
 }
 
-// Run the session with the server, emits a stream of events.
-func (sess *ClientSession) run() error {
+// loop runs the session with the server, emits a stream of events.
+func (sess *ClientSession) loop() error {
 	var err error
 	var recv serverMsg
 	for {
@@ -167,7 +156,7 @@
 	}
 }
 
-// Call this when you've connected and are ready to start running.
+// Call this when you've connected and want to start looping.
 func (sess *ClientSession) start() error {
 	conn := sess.Connection
 	err := conn.SetDeadline(time.Now().Add(sess.ExchangeTimeout))

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-01-31 19:56:16 +0000
+++ client/session/session_test.go	2014-01-31 21:54:22 +0000
@@ -186,34 +186,34 @@
 }
 
 /****************************************************************
-  Dial() tests
+  connect() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestDialFailsWithNoAddress(c *C) {
+func (cs *clientSessionSuite) TestConnectFailsWithNoAddress(c *C) {
 	sess, err := NewSession("", nil, 0, "wah", debuglog)
 	c.Assert(err, IsNil)
-	err = sess.Dial()
-	c.Check(err, ErrorMatches, ".*dial.*address.*")
+	err = sess.connect()
+	c.Check(err, ErrorMatches, ".*connect.*address.*")
 }
 
-func (cs *clientSessionSuite) TestDialConnects(c *C) {
+func (cs *clientSessionSuite) TestConnectConnects(c *C) {
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
 	defer srv.Close()
 	sess, err := NewSession(srv.Addr().String(), nil, 0, "wah", debuglog)
 	c.Assert(err, IsNil)
-	err = sess.Dial()
+	err = sess.connect()
 	c.Check(err, IsNil)
 	c.Check(sess.Connection, NotNil)
 }
 
-func (cs *clientSessionSuite) TestDialConnectFail(c *C) {
+func (cs *clientSessionSuite) TestConnectConnectFail(c *C) {
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
 	sess, err := NewSession(srv.Addr().String(), nil, 0, "wah", debuglog)
 	srv.Close()
 	c.Assert(err, IsNil)
-	err = sess.Dial()
+	err = sess.connect()
 	c.Check(err, ErrorMatches, ".*connection refused")
 }
 
@@ -248,35 +248,6 @@
 }
 
 /****************************************************************
-  checkRunnable() tests
-****************************************************************/
-
-func (cs *clientSessionSuite) TestCheckRunnableFailsIfNoConnection(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", debuglog)
-	c.Assert(err, IsNil)
-	// no connection!
-	c.Check(sess.checkRunnable(), NotNil)
-}
-
-func (cs *clientSessionSuite) TestCheckRunnableFailsIfNoProtocolator(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", debuglog)
-	c.Assert(err, IsNil)
-	// set up the connection
-	sess.Connection = &testConn{}
-	// And stomp on the protocolator
-	sess.Protocolator = nil
-	c.Check(sess.checkRunnable(), NotNil)
-}
-
-func (cs *clientSessionSuite) TestCheckRunnable(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", debuglog)
-	c.Assert(err, IsNil)
-	// set up the connection
-	sess.Connection = &testConn{}
-	c.Check(sess.checkRunnable(), IsNil)
-}
-
-/****************************************************************
   handlePing() tests
 ****************************************************************/
 
@@ -374,28 +345,28 @@
 }
 
 /****************************************************************
-  run() tests
+  loop() tests
 ****************************************************************/
 
-type runSuite msgSuite
-
-var _ = Suite(&runSuite{})
-
-func (s *runSuite) SetUpTest(c *C) {
+type loopSuite msgSuite
+
+var _ = Suite(&loopSuite{})
+
+func (s *loopSuite) SetUpTest(c *C) {
 	(*msgSuite)(s).SetUpTest(c)
-	s.sess.Connection.(*testConn).Name = "TestRun* (small r)"
+	s.sess.Connection.(*testConn).Name = "TestLoop*"
 	go func() {
-		s.errCh <- s.sess.run()
+		s.errCh <- s.sess.loop()
 	}()
 }
 
-func (s *runSuite) TestRunReadError(c *C) {
+func (s *loopSuite) TestLoopReadError(c *C) {
 	s.upCh <- errors.New("Read")
 	err := <-s.errCh
 	c.Check(err, ErrorMatches, "Read")
 }
 
-func (s *runSuite) TestRunPing(c *C) {
+func (s *loopSuite) TestLoopPing(c *C) {
 	c.Check(takeNext(s.downCh), Equals, "deadline 1ms")
 	s.upCh <- protocol.PingPongMsg{Type: "ping"}
 	c.Check(takeNext(s.downCh), Equals, protocol.PingPongMsg{Type: "pong"})
@@ -404,7 +375,7 @@
 	c.Check(<-s.errCh, Equals, failure)
 }
 
-func (s *runSuite) TestRunLoopsDaLoop(c *C) {
+func (s *loopSuite) TestLoopLoopsDaLoop(c *C) {
 	for i := 1; i < 10; i++ {
 		c.Check(takeNext(s.downCh), Equals, "deadline 1ms")
 		s.upCh <- protocol.PingPongMsg{Type: "ping"}
@@ -416,7 +387,7 @@
 	c.Check(<-s.errCh, Equals, failure)
 }
 
-func (s *runSuite) TestRunBroadcast(c *C) {
+func (s *loopSuite) TestLoopBroadcast(c *C) {
 	b := &protocol.BroadcastMsg{
 		Type:     "broadcast",
 		AppId:    "--ignored--",