func waiter(c *gc.C, m dependency.Manifold, w worker.Worker) gate.Waiter {
	var waiter gate.Waiter
	err := m.Output(w, &waiter)
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(waiter, gc.NotNil)
	return waiter
}

func unlocker(c *gc.C, m dependency.Manifold, w worker.Worker) gate.Unlocker {
	var unlocker gate.Unlocker
	err := m.Output(w, &unlocker)
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(unlocker, gc.NotNil)
	return unlocker
}

// RunAgentAPIManifold is useful for testing manifolds based on
// AgentAPIManifold. It takes the manifold, sets up the resources
// required to successfully pass AgentAPIManifold's checks and then
// runs the manifold start func.
//
// An agent and apiCaller may be optionally provided. If they are nil,
// dummy barely-good-enough defaults will be used (these dummies are
// fine not actually used for much).
func RunAgentAPIManifold(
	manifold dependency.Manifold, agent agent.Agent, apiCaller base.APICaller,
) (worker.Worker, error) {
	if agent == nil {
		agent = new(dummyAgent)
	}
	if apiCaller == nil {
		apiCaller = basetesting.APICallerFunc(
			func(string, int, string, string, interface{}, interface{}) error {
				return nil
			})
	}
	context := dt.StubContext(nil, map[string]interface{}{
		"agent-name":      agent,
		"api-caller-name": apiCaller,
	})
	return manifold.Start(context)
}

func assertGate(c *gc.C, manifold dependency.Manifold, unlocker gate.Unlocker) {
	w, err := manifold.Start(nil)
	c.Assert(err, jc.ErrorIsNil)
	defer worker.Stop(w)

	var waiter gate.Waiter
	err = manifold.Output(w, &waiter)
	c.Assert(err, jc.ErrorIsNil)

	select {
	case <-waiter.Unlocked():
		c.Fatalf("expected gate to be locked")
	default:
	}

	unlocker.Unlock()

	select {
	case <-waiter.Unlocked():
	default:
		c.Fatalf("expected gate to be unlocked")
	}
}