worker/peergrouper: implement worker

worker/peergrouper/worker_test.go

 // Copyright 2014 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package peergrouper
 
 import (
         "errors"
         "fmt"
         "time"
 
@@ skipping 29 matching lines @@
 func (s *workerSuite) SetUpTest(c *gc.C) {
         s.LoggingSuite.SetUpTest(c)
         resetErrors()
 }
 
 // initState initializes the fake state with a single
 // replicaset member and numMachines machines
 // primed to vote.
 func initState(c *gc.C, st *fakeState, numMachines int) {
         var ids []string
-        for i := 10; i < 13; i++ {
+        for i := 10; i < 10+numMachines; i++ {
                 id := fmt.Sprint(i)
                 m := st.addMachine(id, true)
                 m.setStateHostPort(fmt.Sprintf("0.1.2.%d:%d", i, mongoPort))
                 ids = append(ids, id)
         }
         st.machine("10").SetHasVote(true)
         st.setStateServers(ids...)
         st.session.Set(mkMembers("0v"))
         st.session.setStatus(mkStatuses("0p"))
         st.check = checkInvariants
@@ skipping 85 matching lines @@
         // members.
         st.machine("11").setStateHostPort("0.1.99.99:9876")
 
         mustNext(c, memberWatcher)
         expectMembers := mkMembers("0v 1 2")
         expectMembers[1].Address = "0.1.99.99:9876"
         c.Assert(memberWatcher.Value(), jc.DeepEquals, expectMembers)
 }
 
 var fatalErrorsTests = []struct {
-        errPat    string

[dimitern, 2014/02/26 15:50:00]

s/errPat/pattern/ ?

[rog, 2014/02/26 16:58:09]

Done.

-        err       error

[dimitern, 2014/02/26 15:50:00]

Do you really need err here when it's always the same in the table below? Also,
perhaps move the table inside TestFatalErrors if it's used only there.

[rog, 2014/02/26 16:58:09]

Done.
I prefer not to clutter the test function with all the table
data.

-        expectErr string
+        errPattern string
+        err        error
+        expectErr  string
 }{{
-        errPat:    "State.StateServerInfo",
-        err:       errors.New("sample"),
-        expectErr: "cannot get state server info: sample",
-}, {
-        errPat:    "Machine.SetHasVote 11 true",
-        err:       errors.New("sample"),
-        expectErr: `cannot set voting status of "11" to true: sample`,
-}, {
-        errPat:    "Session.CurrentStatus",
-        err:       errors.New("sample"),
-        expectErr: "cannot get replica set status: sample",
-}, {
-        errPat:    "Session.CurrentMembers",
-        err:       errors.New("sample"),
-        expectErr: "cannot get replica set members: sample",
+        errPattern: "State.StateServerInfo",
+        expectErr:  "cannot get state server info: sample",
+}, {
+        errPattern: "Machine.SetHasVote 11 true",
+        expectErr:  `cannot set voting status of "11" to true: sample`,
+}, {
+        errPattern: "Session.CurrentStatus",
+        expectErr:  "cannot get replica set status: sample",
+}, {
+        errPattern: "Session.CurrentMembers",
+        expectErr:  "cannot get replica set members: sample",
+}, {
+        errPattern: "State.Machine *",
+        expectErr:  `cannot get machine "10": sample`,
 }}
 
 func (s *workerSuite) TestFatalErrors(c *gc.C) {
         testbase.PatchValue(&pollInterval, 5*time.Millisecond)
         for i, test := range fatalErrorsTests {
-                c.Logf("test %d: %s -> %s", i, test.errPat, test.expectErr)
+                c.Logf("test %d: %s -> %s", i, test.errPattern, test.expectErr)
                 resetErrors()
                 st := newFakeState()
                 st.session.InstantlyReady = true
                 initState(c, st, 3)
-                setErrorFor(test.errPat, test.err)
+                setErrorFor(test.errPattern, errors.New("sample"))
                 w := newWorker(st)
                 done := make(chan error)
                 go func() {
                         done <- w.Wait()
                 }()
                 select {
                 case err := <-done:
                         c.Assert(err, gc.ErrorMatches, test.expectErr)
                 case <-time.After(coretesting.LongWait):
                         c.Fatalf("timed out waiting for error")
@@ skipping 35 matching lines @@
                 val = w.Value()
                 c.Logf("mustNext done %p, ok %v", w, ok)
                 done <- struct{}{}
         }()
         select {
         case <-done:
                 return
         case <-time.After(coretesting.LongWait):
                 c.Fatalf("timed out waiting for value to be set")
         }
         panic("unreachable")

[dimitern, 2014/02/26 15:50:00]

no need for this?

[rog, 2014/02/26 16:58:09]

we do need it because the go compiler doesn't
know that c.Fatalf never returns.

 }