Unit tests for commands

go.mod

@@ -12,7 +12,7 @@ require (
 	github.com/gorilla/mux v1.8.1
 	github.com/nodeset-org/hyperdrive-daemon v1.0.0
 	github.com/nodeset-org/nodeset-svc-mock v0.2.0
-	github.com/nodeset-org/osha v0.2.0
+	github.com/nodeset-org/osha v0.2.1-0.20240620212038-8021d567be75
 	github.com/rocket-pool/batch-query v1.0.0
 	github.com/rocket-pool/node-manager-core v0.5.1-0.20240620041049-333f5150790e
 	github.com/stretchr/testify v1.9.0
@@ -171,3 +171,5 @@ require (
 	lukechampine.com/blake3 v1.2.1 // indirect
 	rsc.io/tmplfunc v0.0.3 // indirect
 )
+
+// replace github.com/nodeset-org/osha => ../osha

go.sum

@@ -382,8 +382,8 @@ github.com/nodeset-org/hyperdrive-daemon v1.0.0 h1:gacaa2kP2wv1dBO4cpG03RGsdmCTi
 github.com/nodeset-org/hyperdrive-daemon v1.0.0/go.mod h1:bkAacICyImNf7/nrHGiTuysDMCxtOq4wQ6dk1d2PbvI=
 github.com/nodeset-org/nodeset-svc-mock v0.2.0 h1:JBR0EqHGNkRvVaidUWZcShb+WgOgIaTcaeYzV0/TAvo=
 github.com/nodeset-org/nodeset-svc-mock v0.2.0/go.mod h1:pbff0NjIm7oCmBRKgXkXIWp/a9/zAXaS7BDJ69wR4GU=
-github.com/nodeset-org/osha v0.2.0 h1:k/rqy8Qun/EAnodU+yZy98OSHWK36PzmBfLXvb2uVw8=
-github.com/nodeset-org/osha v0.2.0/go.mod h1:qkXYqNHUom/vRxlP7sj7Ilq1bvaSv4AhjfyOAGIwoSk=
+github.com/nodeset-org/osha v0.2.1-0.20240620212038-8021d567be75 h1:GTkS8r/fV8DJ/wVeugD2nbCgRpc3pAFLenvKOrHZPow=
+github.com/nodeset-org/osha v0.2.1-0.20240620212038-8021d567be75/go.mod h1:qkXYqNHUom/vRxlP7sj7Ilq1bvaSv4AhjfyOAGIwoSk=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=

internal/tests/api/main_test.go

@@ -8,70 +8,74 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/nodeset-org/hyperdrive-daemon/shared/types/api"
 	swtesting "github.com/nodeset-org/hyperdrive-stakewise/testing"
 	"github.com/nodeset-org/osha/keys"
+	"github.com/rocket-pool/node-manager-core/api/types"
 	"github.com/rocket-pool/node-manager-core/log"
 	"github.com/rocket-pool/node-manager-core/wallet"
 )
 
 // Various singleton variables used for testing
 var (
-	testMgr     *swtesting.StakeWiseTestManager = nil
-	wg          *sync.WaitGroup                 = nil
-	logger      *slog.Logger                    = nil
-	nodeAddress common.Address
-	nsEmail     string = "[email protected]"
+	testMgr             *swtesting.StakeWiseTestManager = nil
+	unregisteredTestMgr *swtesting.StakeWiseTestManager = nil
+	wg                  *sync.WaitGroup                 = nil
+	logger              *slog.Logger                    = nil
+	nodeAddress         common.Address
+	nsEmail             string = "[email protected]"
 )
 
-// Initialize a common server used by all tests
 func TestMain(m *testing.M) {
 	wg = &sync.WaitGroup{}
 	var err error
 
-	// Create a new test manager
-	testMgr, err = swtesting.NewStakeWiseTestManager("localhost", "localhost", "localhost")
+	// Create the new test managers
+	unregisteredTestMgr, err = initializeTestManager()
 	if err != nil {
 		fail("error creating test manager: %v", err)
 	}
+	testMgr, err = initializeTestManager()
+	if err != nil {
+		fail("error creating test manager: %v", err)
+	}
+
 	logger = testMgr.GetLogger()
 
 	// Generate a new wallet
+	password := "test_password123"
+
 	derivationPath := string(wallet.DerivationPath_Default)
+	// Unregistered client
+	unregisteredIndex := uint64(9999999)
+	unregisteredRecoverResponse, err := recoverWallet(unregisteredTestMgr, "radar blur cabbage chef fix engine embark joy scheme fiction master release", &unregisteredIndex, password, derivationPath)
+	if err != nil {
+		fail("error recovering unregistered wallet: %v", err)
+	}
+
+	// Fully registered client
 	index := uint64(0)
-	password := "test_password123"
-	hdClient := testMgr.HyperdriveTestManager.GetApiClient()
-	recoverResponse, err := hdClient.Wallet.Recover(&derivationPath, keys.DefaultMnemonic, &index, password, true)
+	recoverResponse, err := recoverWallet(testMgr, keys.DefaultMnemonic, &index, password, derivationPath)
 	if err != nil {
 		fail("error generating wallet: %v", err)
 	}
 	nodeAddress = recoverResponse.Data.AccountAddress
 
 	// Set up NodeSet with the StakeWise vault
-	sp := testMgr.GetStakeWiseServiceProvider()
-	res := sp.GetResources()
-	nsServer := testMgr.GetNodeSetMockServer().GetManager()
-	err = nsServer.AddStakeWiseVault(*res.Vault, res.EthNetworkName)
+	err = setupNodeSet(testMgr, nsEmail, recoverResponse.Data.AccountAddress)
 	if err != nil {
-		fail("error adding stakewise vault to nodeset: %v", err)
+		fail("error setup NodeSet: %v", err)
 	}
 
-	// Make a NodeSet account
-	err = nsServer.AddUser(nsEmail)
-	if err != nil {
-		fail("error adding user to nodeset: %v", err)
-	}
-	err = nsServer.WhitelistNodeAccount(nsEmail, nodeAddress)
+	err = setupNodeSet(unregisteredTestMgr, nsEmail, unregisteredRecoverResponse.Data.AccountAddress)
 	if err != nil {
-		fail("error adding node account to nodeset: %v", err)
+		fail("error setup NodeSet: %v", err)
 	}
 
 	// Register with NodeSet
-	logger := log.NewDefaultLogger()
-	ctx := logger.CreateContextWithLogger(sp.GetBaseContext())
-	nsClient := testMgr.GetStakeWiseServiceProvider().GetNodesetClient()
-	err = nsClient.RegisterNode(ctx, nsEmail, nodeAddress)
+	err = registerNodeSet(testMgr, nsEmail, nodeAddress)
 	if err != nil {
-		fail("error registering node with nodeset: %v", err)
+		fail("error registering NodeSet: %v", err)
 	}
 
 	// Run tests
@@ -82,6 +86,42 @@ func TestMain(m *testing.M) {
 	os.Exit(code)
 }
 
+func initializeTestManager() (*swtesting.StakeWiseTestManager, error) {
+	return swtesting.NewStakeWiseTestManager("localhost", "localhost", "localhost")
+}
+
+func recoverWallet(_testMgr *swtesting.StakeWiseTestManager, mnemonic string, index *uint64, password, derivationPath string) (*types.ApiResponse[api.WalletRecoverData], error) {
+	hdClient := _testMgr.HyperdriveTestManager.GetApiClient()
+	return hdClient.Wallet.Recover(&derivationPath, mnemonic, index, password, true)
+}
+
+func setupNodeSet(_testMgr *swtesting.StakeWiseTestManager, email string, account common.Address) error {
+	sp := _testMgr.GetStakeWiseServiceProvider()
+	res := sp.GetResources()
+	nsServer := _testMgr.GetNodeSetMockServer().GetManager()
+
+	if err := nsServer.AddStakeWiseVault(*res.Vault, res.EthNetworkName); err != nil {
+		return fmt.Errorf("error adding stakewise vault to nodeset: %w", err)
+	}
+
+	if err := nsServer.AddUser(email); err != nil {
+		return fmt.Errorf("error adding user to nodeset: %w", err)
+	}
+
+	if err := nsServer.WhitelistNodeAccount(email, account); err != nil {
+		return fmt.Errorf("error whitelisting node account: %w", err)
+	}
+
+	return nil
+}
+
+func registerNodeSet(_testMgr *swtesting.StakeWiseTestManager, email string, nodeAddress common.Address) error {
+	logger := log.NewDefaultLogger()
+	ctx := logger.CreateContextWithLogger(_testMgr.GetStakeWiseServiceProvider().GetBaseContext())
+	nsClient := _testMgr.GetStakeWiseServiceProvider().GetNodesetClient()
+	return nsClient.RegisterNode(ctx, email, nodeAddress)
+}
+
 func fail(format string, args ...any) {
 	fmt.Fprintf(os.Stderr, format, args...)
 	cleanup()

internal/tests/api/nodeset_test.go

@@ -0,0 +1,58 @@
+package api_test
+
+import (
+	"testing"
+
+	swapi "github.com/nodeset-org/hyperdrive-stakewise/shared/api"
+	"github.com/nodeset-org/osha"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRegistrationStatus_Registered(t *testing.T) {
+	// Take a snapshot, revert at the end
+	snapshotName, err := testMgr.CreateCustomSnapshot(osha.Service_EthClients | osha.Service_Filesystem)
+	if err != nil {
+		fail("Error creating custom snapshot: %v", err)
+	}
+	defer status_cleanup(testMgr, snapshotName)
+
+	client := testMgr.GetApiClient()
+	response, err := client.Nodeset.RegistrationStatus()
+	require.NoError(t, err)
+
+	require.Equal(t, "", response.Data.ErrorMessage)
+	require.Equal(t, swapi.NodesetRegistrationStatus_Registered, response.Data.Status)
+}
+func TestUploadDepositData(t *testing.T) {
+	// Take a snapshot, revert at the end
+	snapshotName, err := testMgr.CreateCustomSnapshot(osha.Service_EthClients | osha.Service_Filesystem)
+	if err != nil {
+		fail("Error creating custom snapshot: %v", err)
+	}
+	defer status_cleanup(testMgr, snapshotName)
+}
+
+func TestRegisterNode_AlreadyRegisteredError(t *testing.T) {
+	// Take a snapshot, revert at the end
+	snapshotName, err := testMgr.CreateCustomSnapshot(osha.Service_EthClients | osha.Service_Filesystem)
+	if err != nil {
+		fail("Error creating custom snapshot: %v", err)
+	}
+	defer status_cleanup(testMgr, snapshotName)
+
+	client := testMgr.GetApiClient()
+	_, err = client.Nodeset.RegisterNode("[email protected]")
+	require.Error(t, err)
+}
+
+func TestRegisterNode_Success(t *testing.T) {
+	// Take a snapshot, revert at the end
+	snapshotName, err := unregisteredTestMgr.CreateCustomSnapshot(osha.Service_EthClients | osha.Service_Filesystem)
+	if err != nil {
+		fail("Error creating custom snapshot: %v", err)
+	}
+	defer status_cleanup(unregisteredTestMgr, snapshotName)
+	client := unregisteredTestMgr.GetApiClient()
+	_, err = client.Nodeset.RegisterNode("[email protected]")
+	require.NoError(t, err)
+}

internal/tests/api/status_test.go

@@ -5,6 +5,8 @@ import (
 	"strconv"
 	"testing"
 
+	swtesting "github.com/nodeset-org/hyperdrive-stakewise/testing"
+
 	swtypes "github.com/nodeset-org/hyperdrive-stakewise/shared/types"
 	"github.com/nodeset-org/osha"
 	"github.com/rocket-pool/node-manager-core/beacon"
@@ -19,7 +21,7 @@ func TestValidatorStatus_Active(t *testing.T) {
 	if err != nil {
 		fail("Error creating custom snapshot: %v", err)
 	}
-	defer status_cleanup(snapshotName)
+	defer status_cleanup(testMgr, snapshotName)
 
 	// Get some resources
 	sp := testMgr.GetStakeWiseServiceProvider()
@@ -96,7 +98,7 @@ func TestValidatorStatus_Active(t *testing.T) {
 }
 
 // Clean up after each test
-func status_cleanup(snapshotName string) {
+func status_cleanup(_testMgr *swtesting.StakeWiseTestManager, snapshotName string) {
 	// Handle panics
 	r := recover()
 	if r != nil {
@@ -105,23 +107,23 @@ func status_cleanup(snapshotName string) {
 	}
 
 	// Revert to the snapshot taken at the start of the test
-	err := testMgr.RevertToCustomSnapshot(snapshotName)
+	err := _testMgr.RevertToCustomSnapshot(snapshotName)
 	if err != nil {
 		fail("Error reverting to custom snapshot: %v", err)
 	}
 
 	// Reload the HD wallet to undo any changes made during the test
-	err = testMgr.GetServiceProvider().GetWallet().Reload(testMgr.GetLogger())
+	err = _testMgr.GetServiceProvider().GetWallet().Reload(_testMgr.GetLogger())
 	if err != nil {
 		fail("Error reloading hyperdrive wallet: %v", err)
 	}
 
 	// Reload the SW wallet to undo any changes made during the test
-	err = testMgr.GetStakeWiseServiceProvider().GetWallet().Reload()
+	err = _testMgr.GetStakeWiseServiceProvider().GetWallet().Reload()
 	if err != nil {
 		fail("Error reloading stakewise wallet: %v", err)
 	}
 
 	// Log out of the NS mock server
-	testMgr.GetStakeWiseServiceProvider().GetNodesetClient().Logout()
+	_testMgr.GetStakeWiseServiceProvider().GetNodesetClient().Logout()
 }

internal/tests/api/validator_test.go

@@ -0,0 +1,54 @@
+package api_test
+
+import (
+	"testing"
+
+	"github.com/nodeset-org/osha"
+	"github.com/rocket-pool/node-manager-core/beacon"
+	"github.com/rocket-pool/node-manager-core/node/validator"
+	"github.com/stretchr/testify/require"
+)
+
+func TestExit_EmptyPubkeys(t *testing.T) {
+	// Take a snapshot, revert at the end
+	snapshotName, err := testMgr.CreateCustomSnapshot(osha.Service_EthClients | osha.Service_Filesystem)
+	if err != nil {
+		fail("Error creating custom snapshot: %v", err)
+	}
+	defer status_cleanup(testMgr, snapshotName)
+	client := testMgr.GetApiClient()
+	pubkeys := []beacon.ValidatorPubkey{}
+
+	_, err = client.Validator.Exit(pubkeys, nil, false)
+	require.Error(t, err)
+}
+
+func TestExit(t *testing.T) {
+	snapshotName, err := testMgr.CreateCustomSnapshot(osha.Service_EthClients | osha.Service_Filesystem)
+	if err != nil {
+		fail("Error creating custom snapshot: %v", err)
+	}
+	defer status_cleanup(testMgr, snapshotName)
+
+	sp := testMgr.GetStakeWiseServiceProvider()
+	wallet := sp.GetWallet()
+	vault := *sp.GetResources().Vault
+
+	// Generate a validator key
+	key, err := wallet.GenerateNewValidatorKey()
+	require.NoError(t, err)
+	pubkey := beacon.ValidatorPubkey(key.PublicKey().Marshal())
+	t.Logf("Validator key generated, pubkey = %s", pubkey.HexWithPrefix())
+
+	// Add the validator to Beacon
+	creds := validator.GetWithdrawalCredsFromAddress(vault)
+	bn := testMgr.GetBeaconMockManager()
+	_, err = bn.AddValidator(pubkey, creds)
+	require.NoError(t, err)
+	t.Log("Validator added to the beacon chain")
+
+	client := testMgr.GetApiClient()
+	response, err := client.Validator.Exit([]beacon.ValidatorPubkey{pubkey}, nil, false)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(response.Data.ExitInfos))
+}