Merge lp:~chipaca/ubuntu-push/chamera-orchestra into lp:ubuntu-push

[John Lenton]

and this completes the client library (for now)

[lp:~chipaca/ubuntu-push/chamera-orchestra]

54. By John Lenton on 2014-02-05

[r=pedronis] Reworked or refactored util/redialer, and a bit of client/session, and client.

[Samuele Pedroni (pedronis)]

203 + aCh <- notifications.RawActionReply{}

couldn't this be closed to the actual check? like the rest?

219 + // sessionConnectedCh to nothing in particular, but it'll help sync this test
220 + cli.sessionConnectedCh <- 42
221 + cli.sessionConnectedCh <- 42 // we check things one loop later (loopy, i know)

these comments didn't help me understand that cli.sessionConnectedCh sending is used to assure that we went through the full preceding loop

[Samuele Pedroni (pedronis)]

I'm getting this sort of error in a lxc, running tests in go client

2014/02/05 18:58:51.638238 ERROR Failed gettting current state: org.freedesktop.DBus.Error.ServiceUnknown: The name org.freedesktop.NetworkManager was not provided by any .service files

I don't know if it applies to tarmac or not,

also the tests never finish

review: Needs Fixing

[Samuele Pedroni (pedronis)]

s/go client/client/

[Samuele Pedroni (pedronis)]

I'm surprised there's no race in TestLoop, I had to invent SyncedLogBuffer for that situation

in case it's solvable using a TestLogger

[Samuele Pedroni (pedronis)]

the need fixing is because in that faling scenario the test doesn't stop, there's a missing timeout when waiting for some channel?

[lp:~chipaca/ubuntu-push/chamera-orchestra]

55. By John Lenton on 2014-02-05

[r=pedronis] TestLogger

[John Lenton (chipaca)]

Ah, yes, stuffing things into aCh should be further down.
Was thinking about the race myself too, not sure why I'm getting away with it.

[John Lenton (chipaca)]

P.s. that's not the only potential race in tests i'm getting away with, i think.

[lp:~chipaca/ubuntu-push/chamera-orchestra]

56. By Samuele Pedroni on 2014-02-06

[r=chipaca] be explicit with the MinLogger interface, stops 1.1 compiler from exploding

[Samuele Pedroni (pedronis)]

looks good! there's a race in the test though

review: Approve

[lp:~chipaca/ubuntu-push/chamera-orchestra]

57. By John Lenton on 2014-02-06

[r=pedronis] and this completes the client library (for now)

=== modified file 'bus/bus.go'
--- bus/bus.go	2014-01-23 14:33:08 +0000
+++ bus/bus.go	2014-02-06 13:26:26 +0000
@@ -80,3 +80,9 @@
 	Path      string
 	Interface string
 }
+
+var BusDaemonAddress = Address{
+	dbus.BUS_DAEMON_NAME,
+	string(dbus.BUS_DAEMON_PATH),
+	dbus.BUS_DAEMON_IFACE,
+}

=== modified file 'bus/connectivity/connectivity.go'
--- bus/connectivity/connectivity.go	2014-02-05 02:13:35 +0000
+++ bus/connectivity/connectivity.go	2014-02-06 13:26:26 +0000
@@ -63,6 +63,8 @@
 // up the watch.
 func (cs *connectedState) start() networkmanager.State {
 	var initial networkmanager.State
+	var ch <-chan networkmanager.State
+	var err error
 	for {
 		ar := util.NewAutoRedialer(cs.endp)
 		cs.connAttempts += ar.Redial()
@@ -72,20 +74,22 @@
 		initial = nm.GetState()
 		if initial == networkmanager.Unknown {
 			cs.log.Debugf("Failed to get state.")
-			cs.endp.Close()
-			continue
+			goto Continue
 		}
 
 		// set up the watch
-		ch, err := nm.WatchState()
+		ch, err = nm.WatchState()
 		if err != nil {
 			cs.log.Debugf("Failed to set up the watch: %s", err)
-			cs.endp.Close()
-			continue
+			goto Continue
 		}
 
 		cs.networkStateCh = ch
 		return initial
+
+	Continue:
+		cs.endp.Close()
+		time.Sleep(10 * time.Millisecond) // that should cool things
 	}
 }
 

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2014-02-05 02:15:55 +0000
+++ bus/endpoint.go	2014-02-06 13:26:26 +0000
@@ -19,6 +19,7 @@
 // Here we define the Endpoint, which represents the DBus connection itself.
 
 import (
+	"errors"
 	"fmt"
 	"launchpad.net/go-dbus/v1"
 	"launchpad.net/ubuntu-push/logger"
@@ -64,8 +65,39 @@
 	if err != nil {
 		return err
 	}
+	d := dbus.BusDaemon{bus.Object(dbus.BUS_DAEMON_NAME, dbus.BUS_DAEMON_PATH)}
+	name := endp.addr.Name
+	hasOwner, err := d.NameHasOwner(name)
+	if err != nil {
+		endp.log.Debugf("Unable to determine ownership of %#v: %v", name, err)
+		bus.Close()
+		return err
+	}
+	if !hasOwner {
+		// maybe it's waiting to be activated?
+		names, err := d.ListActivatableNames()
+		if err != nil {
+			endp.log.Debugf("%#v has no owner, and when listing activatable: %v", name, err)
+			bus.Close()
+			return err
+		}
+		found := false
+		for _, name := range names {
+			if name == name {
+				found = true
+				break
+			}
+		}
+		if !found {
+			msg := fmt.Sprintf("%#v has no owner, and not in activatables", name)
+			endp.log.Debugf(msg)
+			bus.Close()
+			return errors.New(msg)
+		}
+	}
+	endp.log.Infof("%#v dialed in.", name)
 	endp.bus = bus
-	endp.proxy = bus.Object(endp.addr.Name, dbus.ObjectPath(endp.addr.Path))
+	endp.proxy = bus.Object(name, dbus.ObjectPath(endp.addr.Path))
 	return nil
 }
 

=== modified file 'bus/endpoint_test.go'
--- bus/endpoint_test.go	2014-02-05 18:17:26 +0000
+++ bus/endpoint_test.go	2014-02-06 13:26:26 +0000
@@ -39,6 +39,13 @@
 // Tests that we can connect to the *actual* system bus.
 // XXX maybe connect to a mock/fake/etc bus?
 func (s *EndpointSuite) TestDial(c *C) {
+	// if somebody's set up the env var, assume it's "live"
+	if os.Getenv("DBUS_SYSTEM_BUS_ADDRESS") == "" {
+		// otherwise, check
+		if _, err := os.Stat("/var/run/dbus/system_bus_socket"); os.IsNotExist(err) {
+			c.Skip("system bus not present")
+		}
+	}
 	endp := newEndpoint(SystemBus, Address{"", "", ""}, s.log)
 	c.Assert(endp.bus, IsNil)
 	err := endp.Dial()

=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2014-02-05 02:13:35 +0000
+++ bus/testing/testing_endpoint.go	2014-02-06 13:26:26 +0000
@@ -23,6 +23,7 @@
 	"fmt"
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/testing/condition"
+	"sync"
 	"time"
 )
 
@@ -37,6 +38,7 @@
 	retvals     [][]interface{}
 	watchTicker chan bool
 	callArgs    []callArgs
+	callArgsLck sync.RWMutex
 }
 
 // Build a bus.Endpoint that calls OK() on its condition before returning
@@ -45,7 +47,7 @@
 // NOTE: Call() always returns the first return value; Watch() will provide
 // each of them in turn, irrespective of whether Call has been called.
 func NewMultiValuedTestingEndpoint(dialCond condition.Interface, callCond condition.Interface, retvalses ...[]interface{}) bus.Endpoint {
-	return &testingEndpoint{dialCond, callCond, retvalses, nil, nil}
+	return &testingEndpoint{dialCond: dialCond, callCond: callCond, retvals: retvalses}
 }
 
 func NewTestingEndpoint(dialCond condition.Interface, callCond condition.Interface, retvals ...interface{}) bus.Endpoint {
@@ -53,7 +55,7 @@
 	for i, x := range retvals {
 		retvalses[i] = []interface{}{x}
 	}
-	return &testingEndpoint{dialCond, callCond, retvalses, nil, nil}
+	return &testingEndpoint{dialCond: dialCond, callCond: callCond, retvals: retvalses}
 }
 
 // If SetWatchTicker is called with a non-nil watchTicker, it is used
@@ -65,6 +67,8 @@
 
 // GetCallArgs returns a list of the arguments for each Call() invocation.
 func GetCallArgs(tc bus.Endpoint) []callArgs {
+	tc.(*testingEndpoint).callArgsLck.RLock()
+	defer tc.(*testingEndpoint).callArgsLck.RUnlock()
 	return tc.(*testingEndpoint).callArgs
 }
 
@@ -92,6 +96,9 @@
 // See Endpoint's Call. This Call will check its condition to decide whether
 // to return an error, or the first of its return values
 func (tc *testingEndpoint) Call(member string, args ...interface{}) ([]interface{}, error) {
+	tc.callArgsLck.Lock()
+	defer tc.callArgsLck.Unlock()
+
 	tc.callArgs = append(tc.callArgs, callArgs{member, args})
 	if tc.callCond.OK() {
 		if len(tc.retvals) == 0 {

=== modified file 'client/client.go'
--- client/client.go	2014-02-05 02:13:35 +0000
+++ client/client.go	2014-02-06 13:26:26 +0000
@@ -66,8 +66,8 @@
 	sessionConnectedCh chan uint32
 }
 
-// Configure loads the configuration specified in configPath, and sets it up.
-func (client *Client) Configure(configPath string) error {
+// configure loads the configuration specified in configPath, and sets it up.
+func (client *Client) configure(configPath string) error {
 	f, err := os.Open(configPath)
 	if err != nil {
 		return fmt.Errorf("opening config: %v", err)
@@ -210,3 +210,30 @@
 		}
 	}
 }
+
+// doStart calls each of its arguments in order, returning the first non-nil
+// error (or nil at the end)
+func (client *Client) doStart(fs ...func() error) error {
+	for _, f := range fs {
+		if err := f(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Loop calls doLoop with the "real" handlers
+func (client *Client) Loop() {
+	client.doLoop(client.handleConnState, client.handleClick,
+		client.handleNotification, client.handleErr)
+}
+
+// Start calls doStart with the "real" starters
+func (client *Client) Start(configPath string) error {
+	return client.doStart(
+		func() error { return client.configure(configPath) },
+		client.getDeviceId,
+		client.initSession,
+		client.takeTheBus,
+	)
+}

=== modified file 'client/client_test.go'
--- client/client_test.go	2014-02-05 18:17:26 +0000
+++ client/client_test.go	2014-02-06 13:26:26 +0000
@@ -17,16 +17,15 @@
 package client
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"io/ioutil"
 	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/bus/notifications"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/client/session"
-	"launchpad.net/ubuntu-push/logger"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"launchpad.net/ubuntu-push/util"
@@ -54,7 +53,7 @@
 type clientSuite struct {
 	timeouts   []time.Duration
 	configPath string
-	log        logger.Logger
+	log        *helpers.TestLogger
 }
 
 var _ = Suite(&clientSuite{})
@@ -100,12 +99,12 @@
 }
 
 /*****************************************************************
-    Configure tests
+    configure tests
 ******************************************************************/
 
 func (cs *clientSuite) TestConfigureWorks(c *C) {
 	cli := new(Client)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, IsNil)
 	c.Assert(cli.config, NotNil)
 	c.Check(cli.config.ExchangeTimeout.Duration, Equals, time.Duration(10*time.Millisecond))
@@ -114,7 +113,7 @@
 func (cs *clientSuite) TestConfigureSetsUpLog(c *C) {
 	cli := new(Client)
 	c.Check(cli.log, IsNil)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, IsNil)
 	c.Assert(cli.log, NotNil)
 }
@@ -122,7 +121,7 @@
 func (cs *clientSuite) TestConfigureSetsUpPEM(c *C) {
 	cli := new(Client)
 	c.Check(cli.pem, IsNil)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, IsNil)
 	c.Assert(cli.pem, NotNil)
 }
@@ -130,7 +129,7 @@
 func (cs *clientSuite) TestConfigureSetsUpIdder(c *C) {
 	cli := new(Client)
 	c.Check(cli.idder, IsNil)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, IsNil)
 	c.Assert(cli.idder, DeepEquals, identifier.New())
 }
@@ -140,7 +139,7 @@
 	c.Check(cli.notificationsEndp, IsNil)
 	c.Check(cli.urlDispatcherEndp, IsNil)
 	c.Check(cli.connectivityEndp, IsNil)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, IsNil)
 	c.Assert(cli.notificationsEndp, NotNil)
 	c.Assert(cli.urlDispatcherEndp, NotNil)
@@ -150,20 +149,20 @@
 func (cs *clientSuite) TestConfigureSetsUpConnCh(c *C) {
 	cli := new(Client)
 	c.Check(cli.connCh, IsNil)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, IsNil)
 	c.Assert(cli.connCh, NotNil)
 }
 
 func (cs *clientSuite) TestConfigureBailsOnBadFilename(c *C) {
 	cli := new(Client)
-	err := cli.Configure("/does/not/exist")
+	err := cli.configure("/does/not/exist")
 	c.Assert(err, NotNil)
 }
 
 func (cs *clientSuite) TestConfigureBailsOnBadConfig(c *C) {
 	cli := new(Client)
-	err := cli.Configure("/etc/passwd")
+	err := cli.configure("/etc/passwd")
 	c.Assert(err, NotNil)
 }
 
@@ -180,7 +179,7 @@
 }`), 0600)
 
 	cli := new(Client)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, NotNil)
 }
 
@@ -197,7 +196,7 @@
 }`), 0600)
 
 	cli := new(Client)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, NotNil)
 }
 
@@ -245,7 +244,7 @@
 	// ok, create the thing
 	cli := new(Client)
 	cli.log = cs.log
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	c.Assert(err, IsNil)
 	// the user actions channel has not been set up
 	c.Check(cli.actionsCh, IsNil)
@@ -272,7 +271,7 @@
 // takeTheBus can, in fact, fail
 func (cs *clientSuite) TestTakeTheBusCanFail(c *C) {
 	cli := new(Client)
-	err := cli.Configure(cs.configPath)
+	err := cli.configure(cs.configPath)
 	cli.log = cs.log
 	c.Assert(err, IsNil)
 	// the user actions channel has not been set up
@@ -292,13 +291,12 @@
 ******************************************************************/
 
 func (cs *clientSuite) TestHandleErr(c *C) {
-	buf := &bytes.Buffer{}
 	cli := new(Client)
-	cli.log = logger.NewSimpleLogger(buf, "debug")
-	cli.initSession()
+	cli.log = cs.log
+	c.Assert(cli.initSession(), IsNil)
 	cli.hasConnectivity = true
 	cli.handleErr(errors.New("bananas"))
-	c.Check(buf.String(), Matches, ".*session exited.*bananas\n")
+	c.Check(cs.log.Captured(), Matches, ".*session exited.*bananas\n")
 }
 
 /*****************************************************************
@@ -308,7 +306,7 @@
 func (cs *clientSuite) TestHandleConnStateD2C(c *C) {
 	cli := new(Client)
 	cli.log = cs.log
-	cli.initSession()
+	c.Assert(cli.initSession(), IsNil)
 
 	c.Assert(cli.hasConnectivity, Equals, false)
 	cli.handleConnState(true)
@@ -358,17 +356,16 @@
 ******************************************************************/
 
 func (cs *clientSuite) TestHandleNotification(c *C) {
-	buf := &bytes.Buffer{}
 	cli := new(Client)
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	cli.notificationsEndp = endp
-	cli.log = logger.NewSimpleLogger(buf, "debug")
+	cli.log = cs.log
 	c.Check(cli.handleNotification(), IsNil)
 	// check we sent the notification
 	args := testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 1)
 	c.Check(args[0].Member, Equals, "Notify")
-	c.Check(buf.String(), Matches, `.* got notification id \d+\s*`)
+	c.Check(cs.log.Captured(), Matches, `.* got notification id \d+\s*`)
 }
 
 func (cs *clientSuite) TestHandleNotificationFail(c *C) {
@@ -405,7 +402,7 @@
 	cli.log = cs.log
 	cli.connCh = make(chan bool, 1)
 	cli.connCh <- true
-	cli.initSession()
+	c.Assert(cli.initSession(), IsNil)
 
 	ch := make(chan bool, 1)
 	go cli.doLoop(func(bool) { ch <- true }, func() error { return nil }, func() error { return nil }, func(error) {})
@@ -415,7 +412,7 @@
 func (cs *clientSuite) TestDoLoopClick(c *C) {
 	cli := new(Client)
 	cli.log = cs.log
-	cli.initSession()
+	c.Assert(cli.initSession(), IsNil)
 	aCh := make(chan notifications.RawActionReply, 1)
 	aCh <- notifications.RawActionReply{}
 	cli.actionsCh = aCh
@@ -428,7 +425,7 @@
 func (cs *clientSuite) TestDoLoopNotif(c *C) {
 	cli := new(Client)
 	cli.log = cs.log
-	cli.initSession()
+	c.Assert(cli.initSession(), IsNil)
 	cli.session.MsgCh = make(chan *session.Notification, 1)
 	cli.session.MsgCh <- &session.Notification{}
 
@@ -440,7 +437,7 @@
 func (cs *clientSuite) TestDoLoopErr(c *C) {
 	cli := new(Client)
 	cli.log = cs.log
-	cli.initSession()
+	c.Assert(cli.initSession(), IsNil)
 	cli.session.ErrCh = make(chan error, 1)
 	cli.session.ErrCh <- nil
 
@@ -448,3 +445,149 @@
 	go cli.doLoop(func(bool) {}, func() error { return nil }, func() error { return nil }, func(error) { ch <- true })
 	c.Check(takeNextBool(ch), Equals, true)
 }
+
+/*****************************************************************
+    doStart tests
+******************************************************************/
+
+func (cs *clientSuite) TestDoStartWorks(c *C) {
+	cli := new(Client)
+	one_called := false
+	two_called := false
+	one := func() error { one_called = true; return nil }
+	two := func() error { two_called = true; return nil }
+	c.Check(cli.doStart(one, two), IsNil)
+	c.Check(one_called, Equals, true)
+	c.Check(two_called, Equals, true)
+}
+
+func (cs *clientSuite) TestDoStartFailsAsExpected(c *C) {
+	cli := new(Client)
+	one_called := false
+	two_called := false
+	failure := errors.New("Failure")
+	one := func() error { one_called = true; return failure }
+	two := func() error { two_called = true; return nil }
+	c.Check(cli.doStart(one, two), Equals, failure)
+	c.Check(one_called, Equals, true)
+	c.Check(two_called, Equals, false)
+}
+
+/*****************************************************************
+    Loop() tests
+******************************************************************/
+
+func (cs *clientSuite) TestLoop(c *C) {
+	cli := new(Client)
+	cli.connCh = make(chan bool)
+	cli.sessionConnectedCh = make(chan uint32)
+	aCh := make(chan notifications.RawActionReply, 1)
+	cli.actionsCh = aCh
+	cli.log = cs.log
+	cli.notificationsEndp = testibus.NewMultiValuedTestingEndpoint(condition.Work(true),
+		condition.Work(true), []interface{}{uint32(1), "hello"})
+	cli.urlDispatcherEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
+	cli.connectivityEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true),
+		uint32(networkmanager.ConnectedGlobal))
+
+	c.Assert(cli.initSession(), IsNil)
+
+	cli.session.MsgCh = make(chan *session.Notification)
+	cli.session.ErrCh = make(chan error)
+
+	// we use tick() to make sure things have been through the
+	// event loop at least once before looking at things;
+	// otherwise there's a race between what we're trying to look
+	// at and the loop itself.
+	tick := func() { cli.sessionConnectedCh <- 42 }
+
+	go cli.Loop()
+
+	// sessionConnectedCh to nothing in particular, but it'll help sync this test
+	cli.sessionConnectedCh <- 42
+	tick()
+	c.Check(cs.log.Captured(), Matches, "(?ms).*Session connected after 42 attempts$")
+
+	//  * actionsCh to the click handler/url dispatcher
+	aCh <- notifications.RawActionReply{}
+	tick()
+	uargs := testibus.GetCallArgs(cli.urlDispatcherEndp)
+	c.Assert(uargs, HasLen, 1)
+	c.Check(uargs[0].Member, Equals, "DispatchURL")
+
+	// loop() should have connected:
+	//  * connCh to the connectivity checker
+	c.Check(cli.hasConnectivity, Equals, false)
+	cli.connCh <- true
+	tick()
+	c.Check(cli.hasConnectivity, Equals, true)
+	cli.connCh <- false
+	tick()
+	c.Check(cli.hasConnectivity, Equals, false)
+
+	//  * session.MsgCh to the notifications handler
+	cli.session.MsgCh <- &session.Notification{}
+	tick()
+	nargs := testibus.GetCallArgs(cli.notificationsEndp)
+	c.Check(nargs, HasLen, 1)
+
+	//  * session.ErrCh to the error handler
+	cli.session.ErrCh <- nil
+	tick()
+	c.Check(cs.log.Captured(), Matches, "(?ms).*session exited.*")
+}
+
+/*****************************************************************
+    Start() tests
+******************************************************************/
+
+// XXX this is a hack.
+func (cs *clientSuite) hasDbus() bool {
+	for _, b := range []bus.Bus{bus.SystemBus, bus.SessionBus} {
+		if b.Endpoint(bus.BusDaemonAddress, cs.log).Dial() != nil {
+			return false
+		}
+	}
+	return true
+}
+
+func (cs *clientSuite) TestStart(c *C) {
+	if !cs.hasDbus() {
+		c.Skip("no dbus")
+	}
+
+	cli := new(Client)
+	// before start, everything sucks:
+	// no config,
+	c.Check(string(cli.config.Addr), Equals, "")
+	// no device id,
+	c.Check(cli.deviceId, HasLen, 0)
+	// no session,
+	c.Check(cli.session, IsNil)
+	// no bus,
+	c.Check(cli.notificationsEndp, IsNil)
+	// no nuthin'.
+
+	// so we start,
+	err := cli.Start(cs.configPath)
+	// and it works
+	c.Check(err, IsNil)
+
+	// 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, 128)
+	// and a session,
+	c.Check(cli.session, NotNil)
+	// and a bus,
+	c.Check(cli.notificationsEndp, NotNil)
+	// and everthying us just peachy!
+}
+
+func (cs *clientSuite) TestStartCanFail(c *C) {
+	cli := new(Client)
+	// easiest way for it to fail is to feed it a bad config
+	err := cli.Start("/does/not/exist")
+	// and it works. Err. Doesn't.
+	c.Check(err, NotNil)
+}