Stopping Go routine from tests - go

Question

I have a node that I want to spin up until I decide I want to stop it. I currently have a Start method that blocks on the Contexts Done channel, I then have a Stop function that calls the cancel, in my tests my Start seems to hang forever and the Stop is never called. I can't work out why the Done signal isn't being called and stopping my node.
var (
// Ctx is the node's main context.
Ctx, cancel = context.WithCancel(context.Background())
// Cancel is a function used to initiate graceful shutdown.
Cancel = cancel
)
type (
Node struct {
database *store.Store
}
)
// Starts run the Node.
func (n *Node) Start() error {
var nodeError error
defer func() {
err := n.database.Close()
if err != nil {
nodeError = err
}
}()
<-Ctx.Done()
return nodeError
}
// Stop stops the node.
func (n *Node) Stop() {
Cancel()
}
And my test is:
func TestNode_Start(t *testing.T) {
n, _ := node.NewNode("1.0")
err := n.Start()
n.Stop()
assert.NoError(t, err)
}

Answer 1

There are several problems with your code. Let's break it down.
var (
// Ctx is the node's main context.
Ctx, cancel = context.WithCancel(context.Background())
// Cancel is a function used to initiate graceful shutdown.
Cancel = cancel
)
These should not be package variables. They should be instance variables--that is to say, members or the Node struct. By making these package variables, if you have multiple tests that use Node, they will all step on each others toes, cause race conditions, and crashes. So instead, do this:
type Node struct {
database *store.Store
ctx context.Context
cancel context.CancelFunc
}
Next, we see that you have a deferred function in your Start() method:
// Starts run the Node.
func (n *Node) Start() error {
var nodeError error
defer func() {
err := n.database.Close()
if err != nil {
nodeError = err
}
}()
/* snip */
This does not do what you expect. It closes the database connection as soon as Start() returns--before anything possibly has a chance to use it.
Instead, you should close the database connection as part of your Stop() method:
// Stop stops the node.
func (n *Node) Stop() error {
n.cancel()
return n.database.Close()
}
And finally, your Start() method blocks, because it waits for the context to cancel, which cannot possibly be canceled until Stop() is called, which is only ever called after Start() returns:
func (n *Node) Start() error {
/* snip */
<-Ctx.Done()
return nodeError
}
I cannot think of any reason to have <-Ctx.Done in Start() at all, so I would just remove it.
With all of my suggested changes, you should have something like this:
type Node struct {
database *store.Store
ctx context.Context
cancel context.CancelFunc
}
// Starts run the Node.
func (n *Node) Start() {
n.ctx, n.cancel = context.WithCancel(context.Background())
}
// Stop stops the node.
func (n *Node) Stop() error {
n.cancel()
return n.database.Close()
}
Of course, this still leaves open the question of if/where/how ctx is used. Since your original code didn't include that, I didn't either.