~chipaca/ubuntu-push/session-refactor-002

 

/////

 

        log  *helpers.TestLogger

        lvls func() (seenstate.SeenState, error)

}

 

        cs.log = helpers.NewTestLogger(c, "debug")

}

 

// in-memory level map testing

 

// sqlite level map testing

 

var _ = Suite(&clientSqlevelsSessionSuite{})

 

  parseServerAddrSpec() tests

****************************************************************/

 

        hEp, fallbackHosts := parseServerAddrSpec("http://foo/hosts")

        c.Check(hEp, Equals, "http://foo/hosts")

        c.Check(fallbackHosts, IsNil)

}

 

/****************************************************************

****************************************************************/

 

var dummyConf = ClientSessionConfig{}

 

        c.Check(sess, NotNil)

        c.Check(err, IsNil)

        c.Check(sess.fallbackHosts, DeepEquals, []string{"foo:443"})

        c.Check(sess.State(), Equals, Disconnected)

}

 

        c.Assert(err, IsNil)

        c.Check(sess.getHost, NotNil)

}

var certfile string = helpers.SourceRelative("../../server/acceptance/ssl/testing.cert")

var pem, _ = ioutil.ReadFile(certfile)

 

        conf := ClientSessionConfig{PEM: pem}

        c.Check(sess, NotNil)

        c.Assert(err, IsNil)

        c.Check(sess.TLS.RootCAs, NotNil)

}

 

        badpem := []byte("This is not the PEM you're looking for.")

        conf := ClientSessionConfig{PEM: badpem}

        c.Check(sess, IsNil)

        c.Check(err, NotNil)

}

 

        ferr := func() (seenstate.SeenState, error) { return nil, errors.New("Busted.") }

        c.Check(sess, IsNil)

        c.Assert(err, NotNil)

}

  getHosts() tests

****************************************************************/

 

        fallback := []string{"foo:443", "bar:443"}

        err := sess.getHosts()

        c.Assert(err, IsNil)

        c.Check(sess.deliveryHosts, DeepEquals, fallback)

        return &gethosts.Host{thg.domain, thg.hosts}, thg.err

}

 

        hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}

        err := sess.getHosts()

        c.Assert(err, IsNil)

        c.Check(sess.deliveryHosts, DeepEquals, []string{"foo:443", "bar:443"})

}

 

        c.Assert(err, IsNil)

        hostsErr := errors.New("failed")

        hostGetter := &testHostGetter{"", nil, hostsErr}

        c.Check(sess.State(), Equals, Error)

}

 

        hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}

                getHost: hostGetter,

                ClientSessionConfig: ClientSessionConfig{

                        HostsCachingExpiryTime: 2 * time.Hour,

        c.Check(sess.deliveryHosts, DeepEquals, []string{"baz:443"})

}

 

        hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}

                getHost: hostGetter,

                ClientSessionConfig: ClientSessionConfig{

                        HostsCachingExpiryTime: 2 * time.Hour,

  addAuthorization() tests

****************************************************************/

 

        url := "xyzzy://"

        sess.AuthGetter = func(url string) string { return url + " auth'ed" }

        sess.AuthURL = url

        c.Assert(sess.auth, Equals, "")

        c.Check(sess.auth, Equals, "xyzzy:// auth'ed")

}

 

        sess.AuthGetter = nil

        c.Assert(sess.auth, Equals, "")

        err := sess.addAuthorization()

  startConnectionAttempt()/nextHostToTry()/started tests

****************************************************************/

 

        since := time.Since(time.Time{})

                ClientSessionConfig: ClientSessionConfig{

                        ExpectAllRepairedTime: 10 * time.Second,

                },

        sess.tryHost = 2

}

 

        since := time.Since(time.Time{})

                ClientSessionConfig: ClientSessionConfig{

                        ExpectAllRepairedTime: 10 * time.Second,

                },

        c.Check(sess.startConnectionAttempt, PanicMatches, "should have got hosts from config or remote at this point")

}

 

                deliveryHosts: []string{"foo:443", "bar:443", "baz:443"},

                tryHost:       0,

                leftToTry:     3,

        c.Check(sess.tryHost, Equals, 1)

}

 

        c.Assert(err, IsNil)

 

        sess.deliveryHosts = []string{"foo:443", "bar:443", "baz:443"}

  connect() tests

****************************************************************/

 

        c.Assert(err, IsNil)

        sess.deliveryHosts = []string{"nowhere"}

        sess.clearShouldDelay()

        c.Check(sess.State(), Equals, Error)

}

 

        srv, err := net.Listen("tcp", "localhost:0")

        c.Assert(err, IsNil)

        defer srv.Close()

        c.Assert(err, IsNil)

        sess.deliveryHosts = []string{srv.Addr().String()}

        sess.clearShouldDelay()

        c.Check(sess.State(), Equals, Connected)

}

 

        srv, err := net.Listen("tcp", "localhost:0")

        c.Assert(err, IsNil)

        defer srv.Close()

        c.Assert(err, IsNil)

        sess.deliveryHosts = []string{"nowhere", srv.Addr().String()}

        sess.clearShouldDelay()

        c.Check(sess.tryHost, Equals, 0)

}

 

        srv, err := net.Listen("tcp", "localhost:0")

        c.Assert(err, IsNil)

        srv.Close()

        c.Assert(err, IsNil)

        sess.deliveryHosts = []string{srv.Addr().String()}

  Close() tests

****************************************************************/

 

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestClose"}

        sess.Close()

        c.Check(sess.State(), Equals, Disconnected)

}

 

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestCloseTwice"}

        sess.Close()

        c.Check(sess.State(), Equals, Disconnected)

}

 

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestCloseFails", CloseCondition: condition.Work(false)}

        sess.Close()

func (*derp) Redial() uint32 { return 0 }

func (d *derp) Stop()        { d.stopped = true }

 

        c.Assert(err, IsNil)

        ar := new(derp)

        sess.retrier = ar

  AutoRedial() tests

****************************************************************/

 

        // checks that AutoRedial sets up a retrier and tries redialing it

        c.Assert(err, IsNil)

        ar := new(derp)

        sess.retrier = ar

        c.Check(ar.stopped, Equals, true)

}

 

        // checks that AutoRedial stops the previous retrier

        c.Assert(err, IsNil)

        ch := make(chan uint32)

        c.Check(sess.retrier, IsNil)

        c.Check(<-ch, Not(Equals), 0)

}

 

        c.Assert(err, IsNil)

        flag := false

        sess.AutoRedial(nil)

        c.Check(flag, Equals, true)

}

 

        c.Assert(err, IsNil)

        sess.AutoRedial(nil)

        c.Check(sess.ShouldDelay(), Equals, false)

        sess.stopRedial()

****************************************************************/

 

type msgSuite struct {

        upCh   chan interface{}

        downCh chan interface{}

        errCh  chan error

        conf := ClientSessionConfig{

                ExchangeTimeout: time.Millisecond,

        }

        c.Assert(err, IsNil)

        s.sess.Connection = &testConn{Name: "TestHandle*"}

        s.errCh = make(chan error, 1)

/****************************************************************

  start() tests

****************************************************************/

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestStartFailsIfSetDeadlineFails",

                DeadlineCondition: condition.Work(false)} // setdeadline will fail

        c.Check(sess.State(), Equals, Error)

}

 

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestStartFailsIfWriteFails",

                WriteCondition: condition.Work(false)} // write will fail

        c.Check(sess.State(), Equals, Error)

}

 

        c.Assert(err, IsNil)

        sess.SeenState = &brokenSeenState{}

        sess.Connection = &testConn{Name: "TestStartConnectMessageFails"}

        c.Check(err, ErrorMatches, "broken.")

}

 

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestStartConnectMessageFails"}

        errCh := make(chan error, 1)

        c.Check(sess.State(), Equals, Error)

}

 

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestStartConnackReadError"}

        errCh := make(chan error, 1)

        c.Check(sess.State(), Equals, Error)

}

 

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestStartBadConnack"}

        errCh := make(chan error, 1)

        c.Check(sess.State(), Equals, Error)

}

 

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestStartBadConnack"}

        errCh := make(chan error, 1)

        c.Check(sess.State(), Equals, Error)

}

 

        info := map[string]interface{}{

                "foo": 1,

                "bar": "baz",

        conf := ClientSessionConfig{

                Info: info,

        }

        c.Assert(err, IsNil)

        sess.Connection = &testConn{Name: "TestStartWorks"}

        sess.setCookie("COOKIE")

  run() tests

****************************************************************/

 

        c.Assert(err, IsNil)

        failure := errors.New("TestRunBailsIfAuthCheckFails")

        has_closed := false

        c.Check(has_closed, Equals, true)

}

 

        c.Assert(err, IsNil)

        failure := errors.New("TestRunBailsIfHostGetterFails")

        has_closed := false

        c.Check(has_closed, Equals, true)

}

 

        c.Assert(err, IsNil)

        failure := errors.New("TestRunBailsIfConnectFails")

        err = sess.run(

        c.Check(err, Equals, failure)

}

 

        c.Assert(err, IsNil)

        failure := errors.New("TestRunBailsIfStartFails")

        err = sess.run(

        c.Check(err, Equals, failure)

}

 

        c.Assert(err, IsNil)

        // just to make a point: until here we haven't set ErrCh & BroadcastCh (no

        // biggie if this stops being true)

  Jitter() tests

****************************************************************/

 

        c.Assert(err, IsNil)

        num_tries := 20       // should do the math

        spread := time.Second //

  Dial() tests

****************************************************************/

 

        // one last unhappy test

        c.Assert(err, IsNil)

        sess.Protocolator = nil

        c.Check(sess.Dial, PanicMatches, ".*protocol constructor.")

        }

)

 

        // a borked server name

        lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)

        c.Assert(err, IsNil)

        }))

        defer ts.Close()

 

        c.Assert(err, IsNil)

        tconn := &testConn{}

        sess.Connection = tconn

        c.Check(sess.State(), Equals, Error)

}

 

        // happy path thoughts

        lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)

        c.Assert(err, IsNil)

        }))

        defer ts.Close()

 

        c.Assert(err, IsNil)

        tconn := &testConn{CloseCondition: condition.Fail2Work(10)}

        sess.Connection = tconn

        c.Check(<-sess.ErrCh, Equals, failure)

}

 

        // happy path thoughts

        lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)

        c.Assert(err, IsNil)

        c.Assert(err, IsNil)

        defer sess.Close()

 

  redialDelay() tests

****************************************************************/

 

        c.Assert(err, IsNil)

        c.Check(sess.ShouldDelay(), Equals, false)

        sess.setShouldDelay()

        c.Check(sess.ShouldDelay(), Equals, false)

}

 

        c.Assert(err, IsNil)

        sess.redialDelays = []time.Duration{17, 42}

        n := 0

  ClearCookie() tests

****************************************************************/

 

        c.Assert(err, IsNil)

        c.Check(sess.getCookie(), Equals, "")

        sess.setCookie("COOKIE")