Add tests for external wallet cleanup in CollectEndorsementsView

Tests verify that Done() is called on external wallet signers even when
errors occur during the signature collection process. This ensures proper
resource cleanup in all scenarios:

- Success case: Done() called once per external wallet
- Error in issue signatures: Done() still called
- Error in transfer signatures: Done() still called
- Multiple external wallets: Done() called on all wallets even if one fails

The tests use mock external wallet signers to verify the cleanup behavior
introduced by the defer-based fix.

Author: AKRAM@il.ibm.com

token/services/ttx/collectendorsements_test.go

@@ -0,0 +1,291 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package ttx_test
+
+import (
+	"testing"
+
+	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/endpoint"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
+	"github.com/hyperledger-labs/fabric-token-sdk/token"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/driver/mock"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx"
+	mock2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/mock"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/tokenapi"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// mockExternalWalletSigner is a mock implementation of ExternalWalletSigner
+type mockExternalWalletSigner struct {
+	signCalled int
+	doneCalled int
+	signError  error
+	doneError  error
+}
+
+func (m *mockExternalWalletSigner) Sign(party view.Identity, message []byte) ([]byte, error) {
+	m.signCalled++
+	if m.signError != nil {
+		return nil, m.signError
+	}
+	return []byte("external_signature"), nil
+}
+
+func (m *mockExternalWalletSigner) Done() error {
+	m.doneCalled++
+	return m.doneError
+}
+
+func TestCollectEndorsementsView_ExternalWalletCleanup(t *testing.T) {
+	testCases := []struct {
+		name                    string
+		setupError              error
+		expectDoneCalled        bool
+		expectDoneCallCount     int
+		errorInSignature        bool
+		errorInTransferSignature bool
+	}{
+		{
+			name:                "success - Done called once",
+			setupError:          nil,
+			expectDoneCalled:    true,
+			expectDoneCallCount: 1,
+		},
+		{
+			name:                "error in issue signatures - Done still called",
+			setupError:          nil,
+			expectDoneCalled:    true,
+			expectDoneCallCount: 1,
+			errorInSignature:    true,
+		},
+		{
+			name:                     "error in transfer signatures - Done still called",
+			setupError:               nil,
+			expectDoneCalled:         true,
+			expectDoneCallCount:      1,
+			errorInTransferSignature: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Setup mock context
+			ctx := &mock2.Context{}
+			ctx.ContextReturns(t.Context())
+
+			// Setup token management service
+			tms := &mock2.TokenManagementServiceWithExtensions{}
+			tms.NetworkReturns("test_network")
+			tms.ChannelReturns("test_channel")
+			tmsID := token.TMSID{
+				Network:   "test_network",
+				Channel:   "test_channel",
+				Namespace: "test_namespace",
+			}
+			tms.IDReturns(tmsID)
+
+			// Setup token deserializer and identity provider
+			tokenDes := &mock.Deserializer{}
+			tokenIP := &mock.IdentityProvider{}
+			tokenIP.IsMeReturns(false) // Not me, so it will try external wallet
+			tms.SigServiceReturns(token.NewSignatureService(tokenDes, tokenIP))
+
+			// Setup wallet manager with external wallet
+			walletManager := &mock2.WalletManager{}
+			wallet := &mock2.Wallet{}
+			wallet.IDReturns("external_wallet_1")
+			walletManager.OwnerWalletReturns(wallet)
+			tms.WalletManagerReturns(walletManager)
+
+			tokenAPITMS := tokenapi.NewMockedManagementService(t, tmsID)
+			tms.SetTokenManagementServiceStub = func(arg1 *token.Request) error {
+				arg1.SetTokenService(tokenAPITMS)
+				return nil
+			}
+
+			tmsp := &mock2.TokenManagementServiceProvider{}
+			tmsp.TokenManagementServiceReturns(tms, nil)
+
+			network := &mock2.Network{}
+			network.ComputeTxIDReturns("test_anchor")
+			np := &mock2.NetworkProvider{}
+			np.GetNetworkReturns(network, nil)
+
+			// Create request with issue metadata
+			req := token.NewRequest(nil, "test_anchor")
+			req.Metadata.Issues = []*driver.IssueMetadata{
+				{
+					Issuer: driver.AuditableIdentity{
+						Identity: []byte("external_issuer"),
+					},
+				},
+			}
+			tms.NewRequestReturns(req, nil)
+
+			// Setup context service calls
+			ctx.GetServiceReturnsOnCall(0, tmsp, nil)
+			ctx.GetServiceReturnsOnCall(1, np, nil)
+			ctx.GetServiceReturnsOnCall(2, &endpoint.Service{}, nil)
+			ctx.GetServiceReturnsOnCall(3, np, nil)
+			ctx.GetServiceReturnsOnCall(4, tmsp, nil)
+
+			// Create transaction
+			tx, err := ttx.NewTransaction(ctx, []byte("test_signer"))
+			require.NoError(t, err)
+
+			// Create mock external wallet signer
+			mockEWS := &mockExternalWalletSigner{}
+			if tc.errorInSignature {
+				mockEWS.signError = errors.New("signature error")
+			}
+
+			// Create CollectEndorsementsView with external wallet signer option
+			opts := []ttx.EndorsementsOpt{
+				ttx.WithExternalWalletSignerProvider(func(walletID string) ttx.ExternalWalletSigner {
+					return mockEWS
+				}),
+				ttx.WithSkipApproval(),
+				ttx.WithSkipAuditing(),
+			}
+
+			view := ttx.NewCollectEndorsementsView(tx, opts...)
+
+			// Call the view
+			_, err = view.Call(ctx)
+
+			// Verify Done was called regardless of error
+			if tc.expectDoneCalled {
+				assert.Equal(t, tc.expectDoneCallCount, mockEWS.doneCalled,
+					"Done() should be called %d time(s)", tc.expectDoneCallCount)
+			} else {
+				assert.Equal(t, 0, mockEWS.doneCalled, "Done() should not be called")
+			}
+
+			// Verify error behavior
+			if tc.errorInSignature || tc.errorInTransferSignature {
+				require.Error(t, err, "Expected error when signature fails")
+			}
+		})
+	}
+}
+
+func TestCollectEndorsementsView_MultipleExternalWallets(t *testing.T) {
+	// Setup mock context
+	ctx := &mock2.Context{}
+	ctx.ContextReturns(t.Context())
+
+	// Setup token management service
+	tms := &mock2.TokenManagementServiceWithExtensions{}
+	tms.NetworkReturns("test_network")
+	tms.ChannelReturns("test_channel")
+	tmsID := token.TMSID{
+		Network:   "test_network",
+		Channel:   "test_channel",
+		Namespace: "test_namespace",
+	}
+	tms.IDReturns(tmsID)
+
+	// Setup token deserializer and identity provider
+	tokenDes := &mock.Deserializer{}
+	tokenIP := &mock.IdentityProvider{}
+	tokenIP.IsMeReturns(false)
+	tms.SigServiceReturns(token.NewSignatureService(tokenDes, tokenIP))
+
+	// Setup wallet manager with multiple external wallets
+	walletManager := &mock2.WalletManager{}
+	wallet1 := &mock2.Wallet{}
+	wallet1.IDReturns("external_wallet_1")
+	wallet2 := &mock2.Wallet{}
+	wallet2.IDReturns("external_wallet_2")
+
+	callCount := 0
+	walletManager.OwnerWalletStub = func(ctx2 interface{}, identity view.Identity) interface{} {
+		callCount++
+		if callCount%2 == 1 {
+			return wallet1
+		}
+		return wallet2
+	}
+	tms.WalletManagerReturns(walletManager)
+
+	tokenAPITMS := tokenapi.NewMockedManagementService(t, tmsID)
+	tms.SetTokenManagementServiceStub = func(arg1 *token.Request) error {
+		arg1.SetTokenService(tokenAPITMS)
+		return nil
+	}
+
+	tmsp := &mock2.TokenManagementServiceProvider{}
+	tmsp.TokenManagementServiceReturns(tms, nil)
+
+	network := &mock2.Network{}
+	network.ComputeTxIDReturns("test_anchor")
+	np := &mock2.NetworkProvider{}
+	np.GetNetworkReturns(network, nil)
+
+	// Create request with multiple issues
+	req := token.NewRequest(nil, "test_anchor")
+	req.Metadata.Issues = []*driver.IssueMetadata{
+		{
+			Issuer: driver.AuditableIdentity{
+				Identity: []byte("external_issuer_1"),
+			},
+		},
+		{
+			Issuer: driver.AuditableIdentity{
+				Identity: []byte("external_issuer_2"),
+			},
+		},
+	}
+	tms.NewRequestReturns(req, nil)
+
+	// Setup context service calls
+	ctx.GetServiceReturnsOnCall(0, tmsp, nil)
+	ctx.GetServiceReturnsOnCall(1, np, nil)
+	ctx.GetServiceReturnsOnCall(2, &endpoint.Service{}, nil)
+	ctx.GetServiceReturnsOnCall(3, np, nil)
+	ctx.GetServiceReturnsOnCall(4, tmsp, nil)
+
+	// Create transaction
+	tx, err := ttx.NewTransaction(ctx, []byte("test_signer"))
+	require.NoError(t, err)
+
+	// Create mock external wallet signers
+	mockEWS1 := &mockExternalWalletSigner{}
+	mockEWS2 := &mockExternalWalletSigner{}
+
+	// Simulate error in second wallet's signature
+	mockEWS2.signError = errors.New("wallet 2 signature error")
+
+	walletSigners := map[string]*mockExternalWalletSigner{
+		"external_wallet_1": mockEWS1,
+		"external_wallet_2": mockEWS2,
+	}
+
+	// Create CollectEndorsementsView with external wallet signer option
+	opts := []ttx.EndorsementsOpt{
+		ttx.WithExternalWalletSignerProvider(func(walletID string) ttx.ExternalWalletSigner {
+			return walletSigners[walletID]
+		}),
+		ttx.WithSkipApproval(),
+		ttx.WithSkipAuditing(),
+	}
+
+	view := ttx.NewCollectEndorsementsView(tx, opts...)
+
+	// Call the view - should fail due to wallet 2 error
+	_, err = view.Call(ctx)
+	require.Error(t, err, "Expected error from wallet 2")
+
+	// Verify Done was called on both wallets despite the error
+	assert.Equal(t, 1, mockEWS1.doneCalled, "Done() should be called on wallet 1")
+	assert.Equal(t, 1, mockEWS2.doneCalled, "Done() should be called on wallet 2 even after error")
+}
+
+// Made with Bob