itest: test both client transport modes

In this commit, various changes are made to the itests so that all tests
are run with the various different setups.

Author: ellemouton

itest/client_harness.go

@@ -12,10 +12,13 @@ import (
 	"github.com/lightninglabs/lightning-node-connect/mailbox"
 	"github.com/lightningnetwork/lnd/keychain"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
 )
 
 type clientHarness struct {
 	serverAddr string
+	grpcClient bool
+	tlsConfig  *tls.Config
 
 	grpcConn   *grpc.ClientConn
 	clientConn mockrpc.MockServiceClient
@@ -28,15 +31,24 @@ type clientHarness struct {
 	cancel func()
 }
 
-func newClientHarness(serverAddress string, entropy []byte) (*clientHarness,
-	error) {
+func newClientHarness(serverAddress string, entropy []byte, insecure,
+	grpcClient bool) (*clientHarness, error) {
 
 	privKey, err := btcec.NewPrivateKey()
 	if err != nil {
 		return nil, err
 	}
 
+	tlsConfig := &tls.Config{}
+	if insecure {
+		tlsConfig = &tls.Config{
+			InsecureSkipVerify: true,
+		}
+	}
+
 	return &clientHarness{
+		tlsConfig:         tlsConfig,
+		grpcClient:        grpcClient,
 		serverAddr:        serverAddress,
 		passphraseEntropy: entropy,
 		localStatic:       &keychain.PrivKeyECDH{PrivKey: privKey},
@@ -62,18 +74,27 @@ func (c *clientHarness) start() error {
 		},
 	)
 
-	transportConn, err := mailbox.NewWebsocketsClient(
-		ctx, c.serverAddr, connData,
-	)
+	var err error
+	if c.grpcClient {
+		c.client, err = mailbox.NewGrpcClient(
+			ctx, c.serverAddr, connData,
+			grpc.WithTransportCredentials(
+				credentials.NewTLS(c.tlsConfig),
+			),
+		)
+	} else {
+		c.client, err = mailbox.NewWebsocketsClient(
+			ctx, c.serverAddr, connData,
+		)
+	}
 	if err != nil {
 		return err
 	}
-	c.client = transportConn
 
 	noiseConn := mailbox.NewNoiseGrpcConn(connData)
 
 	dialOpts := []grpc.DialOption{
-		grpc.WithContextDialer(transportConn.Dial),
+		grpc.WithContextDialer(c.client.Dial),
 		grpc.WithTransportCredentials(noiseConn),
 		grpc.WithPerRPCCredentials(noiseConn),
 		grpc.WithDefaultCallOptions(

itest/connection_test.go

@@ -46,7 +46,6 @@ func testHashmailServerReconnect(t *harnessTest) {
 
 	// Shut down hashmail server
 	require.NoError(t.t, t.hmserver.stop())
-	t.t.Logf("")
 
 	// Check that the client and server status are updated appropriately.
 	assertServerStatus(t, mailbox.ServerStatusNotConnected)

itest/integration_test.go

@@ -1,96 +1,61 @@
 package itest
 
 import (
+	"fmt"
 	"testing"
 )
 
-const testnetMailbox = "mailbox.testnet.lightningcluster.com:443"
-
 // TestLightningNodeConnect runs the itests against a local mailbox instance.
 func TestLightningNodeConnect(t *testing.T) {
 	// If no tests are registered, then we can exit early.
 	if len(testCases) == 0 {
 		t.Skip("integration tests not selected")
 	}
 
-	ht := newHarnessTest(t, nil, nil, nil)
-	ht.setupLogging()
+	setupLogging(t)
+
+	testConfigs := []*testConfig{
+		{stagingMailbox: false, grpcClientConn: false},
+		{stagingMailbox: false, grpcClientConn: true},
+		{stagingMailbox: true, grpcClientConn: false},
+		{stagingMailbox: true, grpcClientConn: true},
+	}
 
 	t.Logf("Running %v integration tests", len(testCases))
 	for _, testCase := range testCases {
 
 		testCase := testCase
+		for _, config := range testConfigs {
+			config := config
 
-		success := t.Run(testCase.name, func(t1 *testing.T) {
-			clientHarness, serverHarness, hashmailHarness := setupHarnesses(t1)
-
-			ht := newHarnessTest(
-				t1, clientHarness, serverHarness,
-				hashmailHarness,
-			)
-
-			// Now we have everything to run the test case.
-			ht.RunTestCase(testCase)
-
-			// Shut down both client, server and hashmail server
-			// to remove all state.
-			err := ht.shutdown()
-			if err != nil {
-				t1.Fatalf("error shutting down harness: %v",
-					err)
+			if config.stagingMailbox && testCase.localMailboxOnly {
+				continue
 			}
-		})
-
-		// Close at the first failure. Mimic behavior of original test
-		// framework.
-		if !success {
-			break
-		}
-	}
-}
-
-// TestLightningNodeConnectTestnetMailbox runs the itests using the mailbox
-// running in the LL testnet environment.
-func TestLightningNodeConnectTestnetMailbox(t *testing.T) {
-	// If no tests are registered, then we can exit early.
-	if len(stagingMailboxTests) == 0 {
-		t.Skip("integration tests not selected")
-	}
 
-	ht := newHarnessTest(t, nil, nil, nil)
-	ht.setupLogging()
-
-	t.Logf("Running %v integration tests", len(stagingMailboxTests))
-	for _, testCase := range stagingMailboxTests {
-
-		testCase := testCase
-
-		success := t.Run(testCase.name, func(t1 *testing.T) {
-			clientHarness, serverHarness :=
-				setupClientAndServerHarnesses(
-					t1, testnetMailbox, false,
-				)
-
-			ht := newHarnessTest(
-				t1, clientHarness, serverHarness, nil,
-			)
-
-			// Now we have everything to run the test case.
-			ht.RunTestCase(testCase)
-
-			// Shut down both client, server and hashmail server
-			// to remove all state.
-			err := ht.shutdown()
-			if err != nil {
-				t1.Fatalf("error shutting down harness: %v",
-					err)
+			name := fmt.Sprintf("%s(stagingMailbox:%t,"+
+				"grpcClientConn:%t)", testCase.name,
+				config.stagingMailbox, config.grpcClientConn)
+
+			success := t.Run(name, func(t1 *testing.T) {
+				ht := newHarnessTest(t1, config)
+
+				// Now we have everything to run the test case.
+				ht.RunTestCase(testCase)
+
+				// Shut down both client, server and hashmail
+				// server to remove all state.
+				err := ht.shutdown()
+				if err != nil {
+					t1.Fatalf("error shutting down "+
+						"harness: %v", err)
+				}
+			})
+
+			// Close at the first failure. Mimic behavior of
+			// original test framework.
+			if !success {
+				break
 			}
-		})
-
-		// Close at the first failure. Mimic behavior of original test
-		// framework.
-		if !success {
-			break
 		}
 	}
 }

itest/test_harness.go

@@ -17,10 +17,16 @@ import (
 
 var interceptor *signal.Interceptor
 
+const testnetMailbox = "mailbox.testnet.lightningcluster.com:443"
+
 // testCase is a struct that holds a single test case.
 type testCase struct {
 	name string
 	test func(t *harnessTest)
+
+	// localMailboxOnly indicates if the test should only be run against a
+	// local mailbox instance and not against the staging mailbox.
+	localMailboxOnly bool
 }
 
 // harnessTest wraps a regular testing.T providing enhanced error detection
@@ -41,12 +47,59 @@ type harnessTest struct {
 	hmserver *hashmailHarness
 }
 
+// testConfig determines the way in which the test will be set up.
+type testConfig struct {
+	stagingMailbox bool
+	grpcClientConn bool
+}
+
 // newHarnessTest creates a new instance of a harnessTest from a regular
 // testing.T instance.
-func newHarnessTest(t *testing.T, client *clientHarness, server *serverHarness,
-	hashmail *hashmailHarness) *harnessTest {
+func newHarnessTest(t *testing.T, cfg *testConfig) *harnessTest {
+	ht := &harnessTest{t: t}
+
+	mailboxAddr := testnetMailbox
+	var insecure bool
+	if !cfg.stagingMailbox {
+		ht.hmserver = newHashmailHarness()
+		if err := ht.hmserver.start(); err != nil {
+			t.Fatalf("could not start hashmail server: %v", err)
+		}
+		mailboxAddr = ht.hmserver.apertureCfg.ListenAddr
+		insecure = true
+	}
+
+	var err error
+	ht.server, err = newServerHarness(mailboxAddr, insecure)
+	require.NoError(t, err)
+	require.NoError(t, ht.server.start())
+	t.Cleanup(func() {
+		ht.server.stop()
+	})
+
+	select {
+	case err := <-ht.server.errChan:
+		if err != nil {
+			t.Fatalf("could not start server: %v", err)
+		}
+	default:
+	}
 
-	return &harnessTest{t, nil, client, server, hashmail}
+	// Give the server some time to set up the first mailbox
+	time.Sleep(1000 * time.Millisecond)
+
+	ht.client, err = newClientHarness(
+		mailboxAddr, ht.server.passphraseEntropy, insecure,
+		cfg.grpcClientConn,
+	)
+	require.NoError(t, err)
+
+	require.NoError(t, ht.client.start())
+	t.Cleanup(func() {
+		_ = ht.client.cleanup()
+	})
+
+	return ht
 }
 
 // Skipf calls the underlying testing.T's Skip method, causing the current test
@@ -98,93 +151,46 @@ func (h *harnessTest) Log(args ...interface{}) {
 
 // setupLogging initializes the logging subsystem for the server and client
 // packages.
-func (h *harnessTest) setupLogging() {
+func setupLogging(t *testing.T) {
 	logWriter := build.NewRotatingLogWriter()
 
 	if interceptor != nil {
 		return
 	}
 
 	ic, err := signal.Intercept()
-	require.NoError(h.t, err)
+	require.NoError(t, err)
 	interceptor = &ic
 
 	aperture.SetupLoggers(logWriter, *interceptor)
-	lnd.AddSubLogger(logWriter, mailbox.Subsystem, *interceptor, mailbox.UseLogger)
+	lnd.AddSubLogger(
+		logWriter, mailbox.Subsystem, *interceptor, mailbox.UseLogger,
+	)
 	lnd.AddSubLogger(logWriter, gbn.Subsystem, *interceptor, gbn.UseLogger)
 
 	err = build.ParseAndSetDebugLevels(
 		"debug,PRXY=warn,GOBN=trace", logWriter,
 	)
-	require.NoError(h.t, err)
+	require.NoError(t, err)
 }
 
 // shutdown stops the client, server and hashmail server
 func (h *harnessTest) shutdown() error {
 	var returnErr error
 
-	if h.hmserver != nil {
-		err := h.hmserver.stop()
-		if err != nil {
-			returnErr = err
-		}
-	}
-
 	err := h.client.cleanup()
 	if err != nil {
 		returnErr = err
 	}
 
 	h.server.stop()
-	return returnErr
-}
-
-// setupHarnesses creates new server, client and hashmail harnesses.
-func setupHarnesses(t *testing.T) (*clientHarness, *serverHarness,
-	*hashmailHarness) {
-
-	hashmailHarness := newHashmailHarness()
-	if err := hashmailHarness.start(); err != nil {
-		t.Fatalf("could not start hashmail server: %v", err)
-	}
-
-	client, server := setupClientAndServerHarnesses(
-		t, hashmailHarness.apertureCfg.ListenAddr, true,
-	)
-
-	return client, server, hashmailHarness
-}
-
-func setupClientAndServerHarnesses(t *testing.T,
-	mailboxAddr string, insecure bool) (*clientHarness, *serverHarness) {
-
-	serverHarness, err := newServerHarness(mailboxAddr, insecure)
-	require.NoError(t, err)
-	require.NoError(t, serverHarness.start())
-	t.Cleanup(func() {
-		serverHarness.stop()
-	})
 
-	select {
-	case err := <-serverHarness.errChan:
+	if h.hmserver != nil {
+		err := h.hmserver.stop()
 		if err != nil {
-			t.Fatalf("could not start server: %v", err)
+			returnErr = err
 		}
-	default:
 	}
 
-	// Give the server some time to set up the first mailbox
-	time.Sleep(1000 * time.Millisecond)
-
-	clientHarness, err := newClientHarness(
-		mailboxAddr, serverHarness.passphraseEntropy,
-	)
-	require.NoError(t, err)
-
-	require.NoError(t, clientHarness.start())
-	t.Cleanup(func() {
-		_ = clientHarness.cleanup()
-	})
-
-	return clientHarness, serverHarness
+	return returnErr
 }