lnd_test: shutdown nodes using defers

This commit adds the helper method shutdownAndAssert, and makes us shut
down nodes created temporarily during the test cases using defers
instead of at the end of the test. This makes it easier to remember to
shut them down, as it is done right after they are started.

lnd_test.go

@@ -381,6 +381,15 @@ func assertNumConnections(ctxt context.Context, t *harnessTest,
 	}
 }
 
+// shutdownAndAssert shuts down the given node and asserts that no errors
+// occur.
+func shutdownAndAssert(net *lntest.NetworkHarness, t *harnessTest,
+	node *lntest.HarnessNode) {
+	if err := net.ShutdownNode(node); err != nil {
+		t.Fatalf("unable to shutdown %v: %v", node.Name(), err)
+	}
+}
+
 // calcStaticFee calculates appropriate fees for commitment transactions.  This
 // function provides a simple way to allow test balance assertions to take fee
 // calculations into account.
@@ -461,11 +470,7 @@ func testOnchainFundRecovery(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create node with seed; %v", err)
 	}
-
+	shutdownAndAssert(net, t, carol)
-	err = net.ShutdownNode(carol)
-	if err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 
 	// Create a closure for testing the recovery of Carol's wallet. This
 	// method takes the expected value of Carol's balance when using the
@@ -517,10 +522,7 @@ func testOnchainFundRecovery(net *lntest.NetworkHarness, t *harnessTest) {
 
 		// Lastly, shutdown this Carol so we can move on to the next
 		// restoration.
-		err = net.ShutdownNode(node)
+		shutdownAndAssert(net, t, node)
-		if err != nil {
-			t.Fatalf("unable to shutdown node: %v", err)
-		}
 	}
 
 	// Create a closure-factory for building closures that can generate and
@@ -712,6 +714,10 @@ func testUpdateChannelPolicy(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+
+	// Clean up carol's node when the test finishes.
+	defer shutdownAndAssert(net, t, carol)
+
 	carolUpdates, cQuit := subscribeGraphNotifications(t, ctxb, carol)
 	defer close(cQuit)
 
@@ -992,11 +998,6 @@ func testUpdateChannelPolicy(net *lntest.NetworkHarness, t *harnessTest) {
 	closeChannelAndAssert(ctxt, t, net, net.Bob, chanPoint2, false)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, chanPoint3, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
-
-	// Clean up carol's node.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testOpenChannelAfterReorg tests that in the case where we have an open
@@ -1343,6 +1344,10 @@ func testChannelFundingPersistence(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new node: %v", err)
 	}
+
+	// Clean up carol's node when the test finishes.
+	defer shutdownAndAssert(net, t, carol)
+
 	ctxt, _ := context.WithTimeout(ctxb, timeout)
 	if err := net.ConnectNodes(ctxt, net.Alice, carol); err != nil {
 		t.Fatalf("unable to connect alice to carol: %v", err)
@@ -1449,11 +1454,6 @@ func testChannelFundingPersistence(net *lntest.NetworkHarness, t *harnessTest) {
 	}
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, chanPoint, false)
-
-	// Clean up carol's node.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testChannelBalance creates a new channel between Alice and  Bob, then
@@ -2257,6 +2257,11 @@ func testSphinxReplayPersistence(net *lntest.NetworkHarness, t *harnessTest) {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
 
+	// We must remember to shutdown the nodes we created for the duration
+	// of the tests, only leaving the two seed nodes (Alice and Bob) within
+	// our test network.
+	defer shutdownAndAssert(net, t, dave)
+
 	// Next, we'll create Carol and establish a channel to from her to
 	// Dave. Carol is started in both unsafe-replay and unsafe-disconnect,
 	// which will cause her to replay any pending Adds held in memory upon
@@ -2265,6 +2270,8 @@ func testSphinxReplayPersistence(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, carol, dave); err != nil {
 		t.Fatalf("unable to connect carol to dave: %v", err)
 	}
@@ -2401,16 +2408,6 @@ func testSphinxReplayPersistence(net *lntest.NetworkHarness, t *harnessTest) {
 
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPoint, true)
-
-	// Finally, shutdown the nodes we created for the duration of the
-	// tests, only leaving the two seed nodes (Alice and Bob) within our
-	// test network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 func testSingleHopInvoice(net *lntest.NetworkHarness, t *harnessTest) {
@@ -2788,6 +2785,8 @@ func testMultiHopPayments(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, dave, net.Alice); err != nil {
 		t.Fatalf("unable to connect dave to alice: %v", err)
 	}
@@ -2819,6 +2818,8 @@ func testMultiHopPayments(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, carol, dave); err != nil {
 		t.Fatalf("unable to connect carol to dave: %v", err)
 	}
@@ -2991,16 +2992,6 @@ func testMultiHopPayments(net *lntest.NetworkHarness, t *harnessTest) {
 	closeChannelAndAssert(ctxt, t, net, dave, chanPointDave, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointCarol, false)
-
-	// Finally, shutdown the nodes we created for the duration of the
-	// tests, only leaving the two seed nodes (Alice and Bob) within our
-	// test network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 // testSingleHopSendToRoute tests that payments are properly processed
@@ -3189,6 +3180,8 @@ func testMultiHopSendToRoute(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, carol, net.Bob); err != nil {
 		t.Fatalf("unable to connect carol to alice: %v", err)
 	}
@@ -3339,13 +3332,6 @@ func testMultiHopSendToRoute(net *lntest.NetworkHarness, t *harnessTest) {
 	closeChannelAndAssert(ctxt, t, net, net.Alice, chanPointAlice, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointBob, false)
-
-	// Finally, shutdown the nodes we created for the duration of the tests,
-	// only leaving the two seed nodes (Alice and Bob) within our test
-	// network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testSendToRouteErrorPropagation tests propagation of errors that occur
@@ -3376,6 +3362,8 @@ func testSendToRouteErrorPropagation(net *lntest.NetworkHarness, t *harnessTest)
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	err = net.SendCoins(ctxb, btcutil.SatoshiPerBitcoin, carol)
 	if err != nil {
 		t.Fatalf("unable to send coins to carol: %v", err)
@@ -3385,6 +3373,8 @@ func testSendToRouteErrorPropagation(net *lntest.NetworkHarness, t *harnessTest)
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, charlie)
+
 	err = net.SendCoins(ctxb, btcutil.SatoshiPerBitcoin, charlie)
 	if err != nil {
 		t.Fatalf("unable to send coins to charlie: %v", err)
@@ -3459,17 +3449,6 @@ func testSendToRouteErrorPropagation(net *lntest.NetworkHarness, t *harnessTest)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, chanPointAlice, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointCarol, false)
-
-	// Finally, shutdown the nodes we created to make fake route,
-	// only leaving the two seed nodes (Alice and Bob) within our test
-	// network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-
-	if err := net.ShutdownNode(charlie); err != nil {
-		t.Fatalf("unable to shutdown charlie: %v", err)
-	}
 }
 
 // testPrivateChannels tests that a private channel can be used for
@@ -3517,6 +3496,8 @@ func testPrivateChannels(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, dave, net.Alice); err != nil {
 		t.Fatalf("unable to connect dave to alice: %v", err)
 	}
@@ -3548,6 +3529,8 @@ func testPrivateChannels(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, carol, dave); err != nil {
 		t.Fatalf("unable to connect carol to dave: %v", err)
 	}
@@ -3801,16 +3784,6 @@ func testPrivateChannels(net *lntest.NetworkHarness, t *harnessTest) {
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointCarol, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointPrivate, false)
-
-	// Finally, shutdown the nodes we created for the duration of the tests,
-	// only leaving the two seed nodes (Alice and Bob) within our test
-	// network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 // testInvoiceRoutingHints tests that the routing hints for an invoice are
@@ -3840,6 +3813,8 @@ func testInvoiceRoutingHints(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create carol's node: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, net.Alice, carol); err != nil {
 		t.Fatalf("unable to connect alice to carol: %v", err)
 	}
@@ -3856,6 +3831,8 @@ func testInvoiceRoutingHints(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create dave's node: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, net.Alice, dave); err != nil {
 		t.Fatalf("unable to connect alice to dave: %v", err)
 	}
@@ -3895,9 +3872,7 @@ func testInvoiceRoutingHints(net *lntest.NetworkHarness, t *harnessTest) {
 	}
 
 	// Now that the channels are open, we'll take down Eve's node.
-	if err := net.ShutdownNode(eve); err != nil {
+	shutdownAndAssert(net, t, eve)
-		t.Fatalf("unable to shutdown eve: %v", err)
-	}
 
 	// Create an invoice for Alice that will populate the routing hints.
 	invoice := &lnrpc.Invoice{
@@ -3981,13 +3956,6 @@ func testInvoiceRoutingHints(net *lntest.NetworkHarness, t *harnessTest) {
 	// is offline.
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, chanPointEve, true)
-
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol's node: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave's node: %v", err)
-	}
 }
 
 // testMultiHopOverPrivateChannels tests that private channels can be used as
@@ -4042,6 +4010,8 @@ func testMultiHopOverPrivateChannels(net *lntest.NetworkHarness, t *harnessTest)
 	if err != nil {
 		t.Fatalf("unable to create carol's node: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, net.Bob, carol); err != nil {
 		t.Fatalf("unable to connect bob to carol: %v", err)
 	}
@@ -4089,6 +4059,8 @@ func testMultiHopOverPrivateChannels(net *lntest.NetworkHarness, t *harnessTest)
 	if err != nil {
 		t.Fatalf("unable to create dave's node: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, carol, dave); err != nil {
 		t.Fatalf("unable to connect carol to dave: %v", err)
 	}
@@ -4198,13 +4170,6 @@ func testMultiHopOverPrivateChannels(net *lntest.NetworkHarness, t *harnessTest)
 	closeChannelAndAssert(ctxt, t, net, net.Bob, chanPointBob, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointCarol, false)
-
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol's node: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave's node: %v", err)
-	}
 }
 
 func testInvoiceSubscriptions(net *lntest.NetworkHarness, t *harnessTest) {
@@ -4357,6 +4322,7 @@ func testMaxPendingChannels(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
 
 	ctx, _ = context.WithTimeout(context.Background(), timeout)
 	if err := net.ConnectNodes(ctx, net.Alice, carol); err != nil {
@@ -4449,13 +4415,6 @@ func testMaxPendingChannels(net *lntest.NetworkHarness, t *harnessTest) {
 		ctxt, _ := context.WithTimeout(context.Background(), timeout)
 		closeChannelAndAssert(ctxt, t, net, net.Alice, chanPoint, false)
 	}
-
-	// Finally, shutdown the node we created for the duration of the tests,
-	// only leaving the two seed nodes (Alice and Bob) within our test
-	// network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 func copyFile(dest, src string) error {
@@ -4542,6 +4501,7 @@ func testFailingChannel(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
 
 	// Let Alice connect and open a channel to Carol,
 	if err := net.ConnectNodes(ctxb, net.Alice, carol); err != nil {
@@ -4707,13 +4667,6 @@ func testFailingChannel(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("%v", predErr)
 	}
-
-	// Finally, shutdown the node we created for the duration of the tests,
-	// only leaving the two seed nodes (Alice and Bob) within our test
-	// network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testRevokedCloseRetribution tests that Alice is able carry out
@@ -5875,9 +5828,8 @@ out:
 	// We'll attempt to complete the original invoice we created with Carol
 	// above, but before we do so, Carol will go offline, resulting in a
 	// failed payment.
-	if err := net.ShutdownNode(carol); err != nil {
+	shutdownAndAssert(net, t, carol)
-		t.Fatalf("unable to shutdown carol: %v", err)
+
-	}
 	// TODO(roasbeef): mission control
 	time.Sleep(time.Second * 5)
 
@@ -6082,6 +6034,7 @@ func testGraphTopologyNotifications(net *lntest.NetworkHarness, t *harnessTest)
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
 
 	if err := net.ConnectNodes(ctxb, net.Bob, carol); err != nil {
 		t.Fatalf("unable to connect bob to carol: %v", err)
@@ -6149,11 +6102,6 @@ func testGraphTopologyNotifications(net *lntest.NetworkHarness, t *harnessTest)
 	closeChannelAndAssert(ctxt, t, net, net.Bob, chanPoint, false)
 
 	close(quit)
-
-	// Finally, shutdown carol as our test has concluded successfully.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testNodeAnnouncement ensures that when a node is started with one or more
@@ -6178,6 +6126,7 @@ func testNodeAnnouncement(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
 
 	// We must let Dave have an open channel before he can send a node
 	// announcement, so we open a channel with Bob,
@@ -6237,10 +6186,6 @@ func testNodeAnnouncement(net *lntest.NetworkHarness, t *harnessTest) {
 	// Close the channel between Bob and Dave.
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, net.Bob, chanPoint, false)
-
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 func testNodeSignVerify(net *lntest.NetworkHarness, t *harnessTest) {
@@ -6285,6 +6230,7 @@ func testNodeSignVerify(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new node: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
 
 	carolMsg := []byte("carol msg")
 
@@ -6309,11 +6255,6 @@ func testNodeSignVerify(net *lntest.NetworkHarness, t *harnessTest) {
 		t.Fatalf("carol's signature doesn't contain her pubkey")
 	}
 
-	// Clean up carol's node.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-
 	// Close the channel between alice and bob.
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, aliceBobCh, false)
@@ -6918,6 +6859,9 @@ func testMultiHopHtlcLocalTimeout(net *lntest.NetworkHarness, t *harnessTest) {
 	// self.
 	aliceChanPoint, bobChanPoint, carol := createThreeHopHodlNetwork(t, net)
 
+	// Clean up carol's node when the test finishes.
+	defer shutdownAndAssert(net, t, carol)
+
 	time.Sleep(time.Second * 1)
 
 	// Now that our channels are set up, we'll send two HTLC's from Alice
@@ -7129,11 +7073,6 @@ func testMultiHopHtlcLocalTimeout(net *lntest.NetworkHarness, t *harnessTest) {
 
 	ctxt, _ := context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, aliceChanPoint, false)
-
-	// Clean up carol's node.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testMultiHopReceiverChainClaim tests that in the multi-hop setting, if the
@@ -7152,6 +7091,9 @@ func testMultiHopReceiverChainClaim(net *lntest.NetworkHarness, t *harnessTest)
 	// self.
 	aliceChanPoint, bobChanPoint, carol := createThreeHopHodlNetwork(t, net)
 
+	// Clean up carol's node when the test finishes.
+	defer shutdownAndAssert(net, t, carol)
+
 	// With the network active, we'll now add a new invoice at Carol's end.
 	invoiceReq := &lnrpc.Invoice{
 		Value: 100000,
@@ -7354,11 +7296,6 @@ func testMultiHopReceiverChainClaim(net *lntest.NetworkHarness, t *harnessTest)
 	// carol to conclude the test.
 	ctxt, _ := context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, aliceChanPoint, false)
-
-	// Clean up carol's node.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testMultiHopLocalForceCloseOnChainHtlcTimeout tests that in a multi-hop HTLC
@@ -7377,6 +7314,9 @@ func testMultiHopLocalForceCloseOnChainHtlcTimeout(net *lntest.NetworkHarness,
 	// self.
 	aliceChanPoint, bobChanPoint, carol := createThreeHopHodlNetwork(t, net)
 
+	// Clean up carol's node when the test finishes.
+	defer shutdownAndAssert(net, t, carol)
+
 	// With our channels set up, we'll then send a single HTLC from Alice
 	// to Carol. As Carol is in hodl mode, she won't settle this HTLC which
 	// opens up the base for out tests.
@@ -7609,11 +7549,6 @@ func testMultiHopLocalForceCloseOnChainHtlcTimeout(net *lntest.NetworkHarness,
 
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, aliceChanPoint, false)
-
-	// Clean up carol's node.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testMultiHopRemoteForceCloseOnChainHtlcTimeout tests that if we extend a
@@ -7632,6 +7567,9 @@ func testMultiHopRemoteForceCloseOnChainHtlcTimeout(net *lntest.NetworkHarness,
 	// self.
 	aliceChanPoint, bobChanPoint, carol := createThreeHopHodlNetwork(t, net)
 
+	// Clean up carol's node when the test finishes.
+	defer shutdownAndAssert(net, t, carol)
+
 	// With our channels set up, we'll then send a single HTLC from Alice
 	// to Carol. As Carol is in hodl mode, she won't settle this HTLC which
 	// opens up the base for out tests.
@@ -7824,9 +7762,6 @@ func testMultiHopRemoteForceCloseOnChainHtlcTimeout(net *lntest.NetworkHarness,
 	// needed.
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, net.Alice, aliceChanPoint, false)
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testMultiHopHtlcLocalChainClaim tests that in a multi-hop HTLC scenario, if
@@ -7844,6 +7779,9 @@ func testMultiHopHtlcLocalChainClaim(net *lntest.NetworkHarness, t *harnessTest)
 	// self.
 	aliceChanPoint, bobChanPoint, carol := createThreeHopHodlNetwork(t, net)
 
+	// Clean up carol's node when the test finishes.
+	defer shutdownAndAssert(net, t, carol)
+
 	// With the network active, we'll now add a new invoice at Carol's end.
 	invoiceReq := &lnrpc.Invoice{
 		Value: 100000,
@@ -8053,11 +7991,6 @@ func testMultiHopHtlcLocalChainClaim(net *lntest.NetworkHarness, t *harnessTest)
 	if err != nil {
 		t.Fatalf(predErr.Error())
 	}
-
-	// Clean up carol's node.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testMultiHopHtlcRemoteChainClaim tests that in the multi-hop HTLC scenario,
@@ -8075,6 +8008,9 @@ func testMultiHopHtlcRemoteChainClaim(net *lntest.NetworkHarness, t *harnessTest
 	// self.
 	aliceChanPoint, bobChanPoint, carol := createThreeHopHodlNetwork(t, net)
 
+	// Clean up carol's node when the test finishes.
+	defer shutdownAndAssert(net, t, carol)
+
 	// With the network active, we'll now add a new invoice at Carol's end.
 	invoiceReq := &lnrpc.Invoice{
 		Value: 100000,
@@ -8244,10 +8180,6 @@ func testMultiHopHtlcRemoteChainClaim(net *lntest.NetworkHarness, t *harnessTest
 	if err != nil {
 		t.Fatalf(predErr.Error())
 	}
-
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 }
 
 // testSwitchCircuitPersistence creates a multihop network to ensure the sender
@@ -8299,6 +8231,8 @@ func testSwitchCircuitPersistence(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, dave, net.Alice); err != nil {
 		t.Fatalf("unable to connect dave to alice: %v", err)
 	}
@@ -8331,6 +8265,8 @@ func testSwitchCircuitPersistence(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, carol, dave); err != nil {
 		t.Fatalf("unable to connect carol to dave: %v", err)
 	}
@@ -8557,16 +8493,6 @@ func testSwitchCircuitPersistence(net *lntest.NetworkHarness, t *harnessTest) {
 	closeChannelAndAssert(ctxt, t, net, dave, chanPointDave, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointCarol, false)
-
-	// Finally, shutdown the nodes we created for the duration of the tests,
-	// only leaving the two seed nodes (Alice and Bob) within our test
-	// network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 // testSwitchOfflineDelivery constructs a set of multihop payments, and tests
@@ -8620,6 +8546,8 @@ func testSwitchOfflineDelivery(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, dave, net.Alice); err != nil {
 		t.Fatalf("unable to connect dave to alice: %v", err)
 	}
@@ -8652,6 +8580,8 @@ func testSwitchOfflineDelivery(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, carol, dave); err != nil {
 		t.Fatalf("unable to connect carol to dave: %v", err)
 	}
@@ -8882,16 +8812,6 @@ func testSwitchOfflineDelivery(net *lntest.NetworkHarness, t *harnessTest) {
 	closeChannelAndAssert(ctxt, t, net, dave, chanPointDave, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointCarol, false)
-
-	// Finally, shutdown the nodes we created for the duration of the tests,
-	// only leaving the two seed nodes (Alice and Bob) within our test
-	// network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 // testSwitchOfflineDeliveryPersistence constructs a set of multihop payments,
@@ -8946,6 +8866,8 @@ func testSwitchOfflineDeliveryPersistence(net *lntest.NetworkHarness, t *harness
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, dave, net.Alice); err != nil {
 		t.Fatalf("unable to connect dave to alice: %v", err)
 	}
@@ -8978,6 +8900,8 @@ func testSwitchOfflineDeliveryPersistence(net *lntest.NetworkHarness, t *harness
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, carol, dave); err != nil {
 		t.Fatalf("unable to connect carol to dave: %v", err)
 	}
@@ -9207,16 +9131,6 @@ func testSwitchOfflineDeliveryPersistence(net *lntest.NetworkHarness, t *harness
 	closeChannelAndAssert(ctxt, t, net, dave, chanPointDave, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointCarol, false)
-
-	// Finally, shutdown the nodes we created for the duration of the tests,
-	// only leaving the two seed nodes (Alice and Bob) within our test
-	// network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 // testSwitchOfflineDeliveryOutgoingOffline constructs a set of multihop payments,
@@ -9273,6 +9187,8 @@ func testSwitchOfflineDeliveryOutgoingOffline(
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, dave, net.Alice); err != nil {
 		t.Fatalf("unable to connect dave to alice: %v", err)
 	}
@@ -9442,9 +9358,7 @@ func testSwitchOfflineDeliveryOutgoingOffline(
 	// Shutdown carol and leave her offline for the rest of the test. This
 	// is critical, as we wish to see if Dave can propragate settles even if
 	// the outgoing link is never revived.
-	if err := net.ShutdownNode(carol); err != nil {
+	shutdownAndAssert(net, t, carol)
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
 
 	// Now restart Dave, ensuring he is both persisting the settles, and is
 	// able to reforward them to Alice after recovering from a restart.
@@ -9493,13 +9407,6 @@ func testSwitchOfflineDeliveryOutgoingOffline(
 	closeChannelAndAssert(ctxt, t, net, net.Alice, chanPointAlice, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, dave, chanPointDave, false)
-
-	// Finally, shutdown Dave, the remaining node we created for the
-	// duration of the tests, only leaving the two seed nodes (Alice and
-	// Bob) within our test network.
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 // computeFee calculates the payment fee as specified in BOLT07
@@ -9529,6 +9436,8 @@ func testQueryRoutes(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, carol)
+
 	if err := net.ConnectNodes(ctxb, carol, net.Bob); err != nil {
 		t.Fatalf("unable to connect carol to bob: %v", err)
 	}
@@ -9547,6 +9456,8 @@ func testQueryRoutes(net *lntest.NetworkHarness, t *harnessTest) {
 	if err != nil {
 		t.Fatalf("unable to create new nodes: %v", err)
 	}
+	defer shutdownAndAssert(net, t, dave)
+
 	if err := net.ConnectNodes(ctxb, dave, carol); err != nil {
 		t.Fatalf("unable to connect dave to carol: %v", err)
 	}
@@ -9685,16 +9596,6 @@ func testQueryRoutes(net *lntest.NetworkHarness, t *harnessTest) {
 	closeChannelAndAssert(ctxt, t, net, net.Bob, chanPointBob, false)
 	ctxt, _ = context.WithTimeout(ctxb, timeout)
 	closeChannelAndAssert(ctxt, t, net, carol, chanPointCarol, false)
-
-	// Finally, shutdown Carol and Dave, the remaining node we created for the
-	// duration of the tests, only leaving the two seed nodes (Alice and
-	// Bob) within our test network.
-	if err := net.ShutdownNode(carol); err != nil {
-		t.Fatalf("unable to shutdown carol: %v", err)
-	}
-	if err := net.ShutdownNode(dave); err != nil {
-		t.Fatalf("unable to shutdown dave: %v", err)
-	}
 }
 
 type testCase struct {