Unit tests and documentations

Signed-off-by: AkramBitar <akram@il.ibm.com>

Author: AkramBitar

token/request.go

@@ -1108,13 +1108,48 @@ func (r *Request) FromBytes(raw []byte) error {
 }
 
 // AddAuditorSignature adds an auditor signature to the request.
+// PreAllocateAuditorSignatures pre-allocates the auditor signatures slice to avoid repeated reallocations.
+// Call this method if you know the expected number of auditors in advance.
+func (r *Request) PreAllocateAuditorSignatures(expectedCount int) {
+	if expectedCount > 0 && cap(r.Actions.AuditorSignatures) < expectedCount {
+		r.Actions.AuditorSignatures = make([]*driver.AuditorSignature, 0, expectedCount)
+	}
+}
+
+// AddAuditorSignature adds a single auditor signature to the request.
+// For better performance when adding multiple signatures, consider using AddAuditorSignatures instead.
 func (r *Request) AddAuditorSignature(identity Identity, sigma []byte) {
 	r.Actions.AuditorSignatures = append(r.Actions.AuditorSignatures, &driver.AuditorSignature{
 		Identity:  identity,
 		Signature: sigma,
 	})
 }
 
+// AddAuditorSignatures adds multiple auditor signatures in a single operation.
+// This is more efficient than calling AddAuditorSignature multiple times.
+func (r *Request) AddAuditorSignatures(identities []Identity, sigmas [][]byte) error {
+	if len(identities) != len(sigmas) {
+		return errors.Errorf("identities and signatures length mismatch: %d != %d", len(identities), len(sigmas))
+	}
+
+	// Pre-allocate if needed
+	if cap(r.Actions.AuditorSignatures) < len(r.Actions.AuditorSignatures)+len(identities) {
+		newCap := len(r.Actions.AuditorSignatures) + len(identities)
+		newSlice := make([]*driver.AuditorSignature, len(r.Actions.AuditorSignatures), newCap)
+		copy(newSlice, r.Actions.AuditorSignatures)
+		r.Actions.AuditorSignatures = newSlice
+	}
+
+	for i := range identities {
+		r.Actions.AuditorSignatures = append(r.Actions.AuditorSignatures, &driver.AuditorSignature{
+			Identity:  identities[i],
+			Signature: sigmas[i],
+		})
+	}
+
+	return nil
+}
+
 func (r *Request) SetSignatures(sigmas map[string][]byte) bool {
 	signers := append(r.IssueSigners(), r.TransferSigners()...)
 	signatures := make([][]byte, len(signers))

token/sdk/db/checks.go

@@ -16,12 +16,15 @@ import (
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx"
 )
 
+// AuditorCheckServiceProvider creates check services for auditors.
+// It combines default checkers with custom checkers for database validation.
 type AuditorCheckServiceProvider struct {
 	tmsProvider     common.TokenManagementServiceProvider
 	networkProvider common.NetworkProvider
 	checkers        []common.NamedChecker
 }
 
+// NewAuditorCheckServiceProvider creates a new auditor check service provider.
 func NewAuditorCheckServiceProvider(tmsProvider common.TokenManagementServiceProvider, networkProvider common.NetworkProvider, checkers []common.NamedChecker) *AuditorCheckServiceProvider {
 	return &AuditorCheckServiceProvider{
 		tmsProvider:     tmsProvider,
@@ -30,16 +33,21 @@ func NewAuditorCheckServiceProvider(tmsProvider common.TokenManagementServicePro
 	}
 }
 
+// CheckService creates a check service for the given TMS ID and databases.
+// It combines default checkers with custom checkers provided during initialization.
 func (a *AuditorCheckServiceProvider) CheckService(id token.TMSID, adb *auditdb.StoreService, tdb *tokens.Service) (auditor.CheckService, error) {
 	return common.NewChecksService(append(common.NewDefaultCheckers(a.tmsProvider, a.networkProvider, adb, tdb, id), a.checkers...)), nil
 }
 
+// OwnerCheckServiceProvider creates check services for token owners.
+// It combines default checkers with custom checkers for database validation.
 type OwnerCheckServiceProvider struct {
 	tmsProvider     common.TokenManagementServiceProvider
 	networkProvider common.NetworkProvider
 	checkers        []common.NamedChecker
 }
 
+// NewOwnerCheckServiceProvider creates a new owner check service provider.
 func NewOwnerCheckServiceProvider(tmsProvider common.TokenManagementServiceProvider, networkProvider common.NetworkProvider, checkers []common.NamedChecker) *OwnerCheckServiceProvider {
 	return &OwnerCheckServiceProvider{
 		tmsProvider:     tmsProvider,
@@ -48,6 +56,8 @@ func NewOwnerCheckServiceProvider(tmsProvider common.TokenManagementServiceProvi
 	}
 }
 
+// CheckService creates a check service for the given TMS ID and databases.
+// It combines default checkers with custom checkers provided during initialization.
 func (a *OwnerCheckServiceProvider) CheckService(id token.TMSID, txdb *ttxdb.StoreService, tdb *tokens.Service) (ttx.CheckService, error) {
 	return common.NewChecksService(append(common.NewDefaultCheckers(a.tmsProvider, a.networkProvider, txdb, tdb, id), a.checkers...)), nil
 }

token/sdk/db/checks_test.go

@@ -0,0 +1,196 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package db
+
+import (
+	"context"
+	"testing"
+
+	"github.com/hyperledger-labs/fabric-token-sdk/token"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/storage/db/common"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/storage/db/common/mock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestNewAuditorCheckServiceProvider verifies that NewAuditorCheckServiceProvider
+// correctly initializes an AuditorCheckServiceProvider with the given dependencies.
+func TestNewAuditorCheckServiceProvider(t *testing.T) {
+	tmsProvider := &mock.TokenManagementServiceProvider{}
+	networkProvider := &mock.NetworkProvider{}
+	checkers := []common.NamedChecker{
+		{Name: "checker1", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+		{Name: "checker2", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+	}
+
+	provider := NewAuditorCheckServiceProvider(tmsProvider, networkProvider, checkers)
+
+	assert.NotNil(t, provider)
+	assert.Equal(t, tmsProvider, provider.tmsProvider)
+	assert.Equal(t, networkProvider, provider.networkProvider)
+	assert.Equal(t, checkers, provider.checkers)
+}
+
+// TestAuditorCheckServiceProvider_CheckService verifies that CheckService
+// creates a check service with default and custom checkers.
+func TestAuditorCheckServiceProvider_CheckService(t *testing.T) {
+	tmsProvider := &mock.TokenManagementServiceProvider{}
+	networkProvider := &mock.NetworkProvider{}
+	checkers := []common.NamedChecker{
+		{Name: "checker1", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+	}
+
+	provider := NewAuditorCheckServiceProvider(tmsProvider, networkProvider, checkers)
+
+	tmsID := token.TMSID{
+		Network:   "test-network",
+		Channel:   "test-channel",
+		Namespace: "test-namespace",
+	}
+
+	// Note: This test will return a service but we can't fully test it without mocking the dependencies
+	// The actual CheckService creation requires valid auditdb and tokens services
+	service, err := provider.CheckService(tmsID, nil, nil)
+
+	// We expect the service to be created even with nil dependencies
+	// as the common.NewChecksService should handle it
+	assert.NotNil(t, service)
+	assert.NoError(t, err)
+}
+
+// TestNewOwnerCheckServiceProvider verifies that NewOwnerCheckServiceProvider
+// correctly initializes an OwnerCheckServiceProvider with the given dependencies.
+func TestNewOwnerCheckServiceProvider(t *testing.T) {
+	tmsProvider := &mock.TokenManagementServiceProvider{}
+	networkProvider := &mock.NetworkProvider{}
+	checkers := []common.NamedChecker{
+		{Name: "checker1", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+		{Name: "checker2", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+	}
+
+	provider := NewOwnerCheckServiceProvider(tmsProvider, networkProvider, checkers)
+
+	assert.NotNil(t, provider)
+	assert.Equal(t, tmsProvider, provider.tmsProvider)
+	assert.Equal(t, networkProvider, provider.networkProvider)
+	assert.Equal(t, checkers, provider.checkers)
+}
+
+// TestOwnerCheckServiceProvider_CheckService verifies that CheckService
+// creates a check service with default and custom checkers.
+func TestOwnerCheckServiceProvider_CheckService(t *testing.T) {
+	tmsProvider := &mock.TokenManagementServiceProvider{}
+	networkProvider := &mock.NetworkProvider{}
+	checkers := []common.NamedChecker{
+		{Name: "checker1", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+	}
+
+	provider := NewOwnerCheckServiceProvider(tmsProvider, networkProvider, checkers)
+
+	tmsID := token.TMSID{
+		Network:   "test-network",
+		Channel:   "test-channel",
+		Namespace: "test-namespace",
+	}
+
+	// Note: This test will return a service but we can't fully test it without mocking the dependencies
+	service, err := provider.CheckService(tmsID, nil, nil)
+
+	// We expect the service to be created even with nil dependencies
+	assert.NotNil(t, service)
+	assert.NoError(t, err)
+}
+
+// TestAuditorCheckServiceProvider_WithMultipleCheckers verifies that the provider
+// correctly handles multiple custom checkers.
+func TestAuditorCheckServiceProvider_WithMultipleCheckers(t *testing.T) {
+	tmsProvider := &mock.TokenManagementServiceProvider{}
+	networkProvider := &mock.NetworkProvider{}
+
+	// Test with multiple checkers
+	checkers := []common.NamedChecker{
+		{Name: "checker1", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+		{Name: "checker2", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+		{Name: "checker3", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+	}
+
+	provider := NewAuditorCheckServiceProvider(tmsProvider, networkProvider, checkers)
+	require.NotNil(t, provider)
+	assert.Len(t, provider.checkers, 3)
+}
+
+// TestOwnerCheckServiceProvider_WithMultipleCheckers verifies that the provider
+// correctly handles multiple custom checkers.
+func TestOwnerCheckServiceProvider_WithMultipleCheckers(t *testing.T) {
+	tmsProvider := &mock.TokenManagementServiceProvider{}
+	networkProvider := &mock.NetworkProvider{}
+
+	// Test with multiple checkers
+	checkers := []common.NamedChecker{
+		{Name: "checker1", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+		{Name: "checker2", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+		{Name: "checker3", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+	}
+
+	provider := NewOwnerCheckServiceProvider(tmsProvider, networkProvider, checkers)
+	require.NotNil(t, provider)
+	assert.Len(t, provider.checkers, 3)
+}
+
+// TestAuditorCheckServiceProvider_WithEmptyCheckers verifies that the provider
+// works correctly with an empty checkers list.
+func TestAuditorCheckServiceProvider_WithEmptyCheckers(t *testing.T) {
+	tmsProvider := &mock.TokenManagementServiceProvider{}
+	networkProvider := &mock.NetworkProvider{}
+	checkers := []common.NamedChecker{}
+
+	provider := NewAuditorCheckServiceProvider(tmsProvider, networkProvider, checkers)
+	require.NotNil(t, provider)
+	assert.Empty(t, provider.checkers)
+}
+
+// TestOwnerCheckServiceProvider_WithEmptyCheckers verifies that the provider
+// works correctly with an empty checkers list.
+func TestOwnerCheckServiceProvider_WithEmptyCheckers(t *testing.T) {
+	tmsProvider := &mock.TokenManagementServiceProvider{}
+	networkProvider := &mock.NetworkProvider{}
+	checkers := []common.NamedChecker{}
+
+	provider := NewOwnerCheckServiceProvider(tmsProvider, networkProvider, checkers)
+	require.NotNil(t, provider)
+	assert.Empty(t, provider.checkers)
+}
+
+// TestAuditorCheckServiceProvider_WithNilProviders verifies that the provider
+// can be created with nil TMS and network providers.
+func TestAuditorCheckServiceProvider_WithNilProviders(t *testing.T) {
+	checkers := []common.NamedChecker{
+		{Name: "checker1", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+	}
+
+	// Test with nil providers - should still create the provider
+	provider := NewAuditorCheckServiceProvider(nil, nil, checkers)
+	require.NotNil(t, provider)
+	assert.Nil(t, provider.tmsProvider)
+	assert.Nil(t, provider.networkProvider)
+	assert.Len(t, provider.checkers, 1)
+}
+
+// TestOwnerCheckServiceProvider_WithNilProviders verifies that the provider
+// can be created with nil TMS and network providers.
+func TestOwnerCheckServiceProvider_WithNilProviders(t *testing.T) {
+	checkers := []common.NamedChecker{
+		{Name: "checker1", Checker: func(ctx context.Context) ([]string, error) { return nil, nil }},
+	}
+
+	// Test with nil providers - should still create the provider
+	provider := NewOwnerCheckServiceProvider(nil, nil, checkers)
+	require.NotNil(t, provider)
+	assert.Nil(t, provider.tmsProvider)
+	assert.Nil(t, provider.networkProvider)
+	assert.Len(t, provider.checkers, 1)
+}

token/sdk/dig/checks.go

@@ -12,6 +12,8 @@ import (
 	"go.uber.org/dig"
 )
 
+// NewAuditorCheckServiceProvider creates an auditor check service provider using dependency injection.
+// It aggregates TMS provider, network provider, and custom checkers from the DI container.
 func NewAuditorCheckServiceProvider(in struct {
 	dig.In
 	TMSProvider     common.TokenManagementServiceProvider
@@ -21,6 +23,8 @@ func NewAuditorCheckServiceProvider(in struct {
 	return db.NewAuditorCheckServiceProvider(in.TMSProvider, in.NetworkProvider, in.Checkers)
 }
 
+// NewOwnerCheckServiceProvider creates an owner check service provider using dependency injection.
+// It aggregates TMS provider, network provider, and custom checkers from the DI container.
 func NewOwnerCheckServiceProvider(in struct {
 	dig.In
 	TMSProvider     common.TokenManagementServiceProvider