formancehq · paul-nicolas · Apr 29, 2025 · Apr 23, 2025 · Apr 25, 2025 · Apr 25, 2025
@@ -66,6 +66,13 @@ type Backend interface {
 	PaymentInitiationRelatedPaymentsList(ctx context.Context, id models.PaymentInitiationID, query storage.ListPaymentInitiationRelatedPaymentsQuery) (*bunpaginate.Cursor[models.Payment], error)
 	PaymentInitiationRelatedPaymentsListAll(ctx context.Context, id models.PaymentInitiationID) ([]models.Payment, error)
 
+	// Payment Service Users
+	PaymentServiceUsersCreate(ctx context.Context, psu models.PaymentServiceUser) error
+	PaymentServiceUsersGet(ctx context.Context, id uuid.UUID) (*models.PaymentServiceUser, error)
+	PaymentServiceUsersList(ctx context.Context, query storage.ListPSUsQuery) (*bunpaginate.Cursor[models.PaymentServiceUser], error)
+	PaymentServiceUsersForwardBankAccountToConnector(ctx context.Context, psuID, bankAccountID uuid.UUID, connectorID models.ConnectorID) (models.Task, error)
+	PaymentServiceUsersAddBankAccount(ctx context.Context, psuID uuid.UUID, bankAccountID uuid.UUID) error
+
 	// Pools
 	PoolsCreate(ctx context.Context, pool models.Pool) error
 	PoolsGet(ctx context.Context, id uuid.UUID) (*models.Pool, error)

@@ -8,7 +8,17 @@
 )
 
 func (s *Service) BankAccountsForwardToConnector(ctx context.Context, bankAccountID uuid.UUID, connectorID models.ConnectorID, waitResult bool) (models.Task, error) {
-	task, err := s.engine.ForwardBankAccount(ctx, bankAccountID, connectorID, waitResult)
+	ba, err := s.storage.BankAccountsGet(ctx, bankAccountID, true)
+	if err != nil {
+		return models.Task{}, newStorageError(err, "failed to get bank account")
+	}
+
+	if ba == nil {
+		// Should not happen, but just in case
+		return models.Task{}, newStorageError(nil, "bank account not found")
+	}
+
+	task, err := s.engine.ForwardBankAccount(ctx, *ba, connectorID, waitResult)
 	if err != nil {
 		return models.Task{}, handleEngineErrors(err)
 	}

@@ -29,46 +29,69 @@ func TestBankAccountsForwardToConnector(t *testing.T) {
 	}
 
 	tests := []struct {
-		name          string
-		bankAccountID uuid.UUID
-		err           error
-		expectedError error
-		typedError    bool
+		name                 string
+		bankAccountID        uuid.UUID
+		engineErr            error
+		storageErr           error
+		expectedEngineError  error
+		expectedStorageError error
+		typedError           bool
 	}{
 		{
-			name:          "success",
-			err:           nil,
-			expectedError: nil,
+			name:      "success",
+			engineErr: nil,
 		},
 		{
-			name:          "validation error",
-			err:           engine.ErrValidation,
-			expectedError: ErrValidation,
-			typedError:    true,
+			name:                "validation error",
+			engineErr:           engine.ErrValidation,
+			expectedEngineError: ErrValidation,
+			typedError:          true,
 		},
 		{
-			name:          "not found error",
-			err:           engine.ErrNotFound,
-			expectedError: ErrNotFound,
-			typedError:    true,
+			name:                "not found error",
+			engineErr:           engine.ErrNotFound,
+			expectedEngineError: ErrNotFound,
+			typedError:          true,
 		},
 		{
-			name:          "other error",
-			err:           fmt.Errorf("error"),
-			expectedError: fmt.Errorf("error"),
+			name:                "other error",
+			engineErr:           fmt.Errorf("error"),
+			expectedEngineError: fmt.Errorf("error"),
+		},
+		{
+			name:                 "storage error not found",
+			storageErr:           storage.ErrNotFound,
+			typedError:           true,
+			expectedStorageError: newStorageError(storage.ErrNotFound, "failed to get bank account"),
+		},
+		{
+			name:                 "other error",
+			storageErr:           fmt.Errorf("error"),
+			expectedStorageError: newStorageError(fmt.Errorf("error"), "failed to get bank account"),
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			eng.EXPECT().ForwardBankAccount(gomock.Any(), test.bankAccountID, connectorID, false).Return(models.Task{}, test.err)
+			store.EXPECT().BankAccountsGet(gomock.Any(), test.bankAccountID, true).Return(&models.BankAccount{}, test.storageErr)
+
+			if test.storageErr == nil {
+				eng.EXPECT().ForwardBankAccount(gomock.Any(), models.BankAccount{}, connectorID, false).Return(models.Task{}, test.engineErr)
+			}
 			_, err := s.BankAccountsForwardToConnector(context.Background(), test.bankAccountID, connectorID, false)
-			if test.expectedError == nil {
+			switch {
+			case test.expectedEngineError != nil && test.typedError:
+				require.ErrorIs(t, err, test.expectedEngineError)
+			case test.expectedEngineError != nil && !test.typedError:
+				require.Error(t, err)
+				require.Equal(t, test.expectedEngineError.Error(), err.Error())
+			case test.expectedStorageError != nil && test.typedError:
+				require.ErrorIs(t, err, test.expectedStorageError)
+			case test.expectedStorageError != nil && !test.typedError:
+				require.Error(t, err)
+				require.Equal(t, test.expectedStorageError.Error(), err.Error())
+			default:
 				require.NoError(t, err)
-			} else if test.typedError {
-				require.ErrorIs(t, err, test.expectedError)
-			} else {
-				require.Equal(t, test.expectedError, err)
 			}
 		})
 	}

@@ -0,0 +1,11 @@
+package services
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+)
+
+func (s *Service) PaymentServiceUsersAddBankAccount(ctx context.Context, psuID uuid.UUID, bankAccountID uuid.UUID) error {
+	return newStorageError(s.storage.PaymentServiceUsersAddBankAccount(ctx, psuID, bankAccountID), "failed to add bank account to payment service user")
+}
@@ -0,0 +1,59 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/formancehq/payments/internal/connectors/engine"
+	"github.com/formancehq/payments/internal/storage"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+	gomock "go.uber.org/mock/gomock"
+)
+
+func TestPaymentServiceUsersAddBankAccount(t *testing.T) {
+	t.Parallel()
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	store := storage.NewMockStorage(ctrl)
+	eng := engine.NewMockEngine(ctrl)
+
+	s := New(store, eng, false)
+
+	tests := []struct {
+		name          string
+		err           error
+		expectedError error
+	}{
+		{
+			name:          "success",
+			err:           nil,
+			expectedError: nil,
+		},
+		{
+			name:          "storage error not found",
+			err:           storage.ErrNotFound,
+			expectedError: newStorageError(storage.ErrNotFound, "failed to add bank account to payment service user"),
+		},
+		{
+			name:          "other error",
+			err:           fmt.Errorf("error"),
+			expectedError: newStorageError(fmt.Errorf("error"), "failed to add bank account to payment service user"),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			psuID, baID := uuid.New(), uuid.New()
+			store.EXPECT().PaymentServiceUsersAddBankAccount(gomock.Any(), psuID, baID).Return(test.err)
+			err := s.PaymentServiceUsersAddBankAccount(context.Background(), psuID, baID)
+			if test.expectedError == nil {
+				require.NoError(t, err)
+			} else {
+				require.Equal(t, test.expectedError, err)
+			}
+		})
+	}
+}
@@ -0,0 +1,11 @@
+package services
+
+import (
+	"context"
+
+	"github.com/formancehq/payments/internal/models"
+)
+
+func (s *Service) PaymentServiceUsersCreate(ctx context.Context, psu models.PaymentServiceUser) error {
+	return newStorageError(s.storage.PaymentServiceUsersCreate(ctx, psu), "cannot create payment service user")
+}
@@ -0,0 +1,58 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/formancehq/payments/internal/connectors/engine"
+	"github.com/formancehq/payments/internal/models"
+	"github.com/formancehq/payments/internal/storage"
+	"github.com/stretchr/testify/require"
+	gomock "go.uber.org/mock/gomock"
+)
+
+func TestPSUCreate(t *testing.T) {
+	t.Parallel()
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	store := storage.NewMockStorage(ctrl)
+	eng := engine.NewMockEngine(ctrl)
+
+	s := New(store, eng, false)
+
+	tests := []struct {
+		name          string
+		err           error
+		expectedError error
+	}{
+		{
+			name:          "success",
+			err:           nil,
+			expectedError: nil,
+		},
+		{
+			name:          "storage error not found",
+			err:           storage.ErrNotFound,
+			expectedError: newStorageError(storage.ErrNotFound, "cannot create payment service user"),
+		},
+		{
+			name:          "other error",
+			err:           fmt.Errorf("error"),
+			expectedError: newStorageError(fmt.Errorf("error"), "cannot create payment service user"),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			store.EXPECT().PaymentServiceUsersCreate(gomock.Any(), models.PaymentServiceUser{}).Return(test.err)
+			err := s.PaymentServiceUsersCreate(context.Background(), models.PaymentServiceUser{})
+			if test.expectedError == nil {
+				require.NoError(t, err)
+			} else {
+				require.Equal(t, test.expectedError, err)
+			}
+		})
+	}
+}
@@ -0,0 +1,35 @@
+package services
+
+import (
+	"context"
+
+	"github.com/formancehq/payments/internal/models"
+	"github.com/formancehq/payments/internal/storage"
+	"github.com/google/uuid"
+)
+
+func (s *Service) PaymentServiceUsersForwardBankAccountToConnector(ctx context.Context, psuID, bankAccountID uuid.UUID, connectorID models.ConnectorID) (models.Task, error) {
+	ba, err := s.storage.BankAccountsGet(ctx, bankAccountID, true)
+	if err != nil {
+		return models.Task{}, newStorageError(err, "failed to get bank account")
+	}
+
+	if ba == nil {
+		// Should not happen, but just in case
+		return models.Task{}, newStorageError(storage.ErrNotFound, "bank account not found")
+	}
+
+	psu, err := s.storage.PaymentServiceUsersGet(ctx, psuID)
+	if err != nil {
+		return models.Task{}, newStorageError(err, "failed to get payment service user")
+	}
+
+	models.FillBankAccountMetadataWithPaymentServiceUserInfo(ba, psu)
+
+	task, err := s.engine.ForwardBankAccount(ctx, *ba, connectorID, false)
+	if err != nil {
+		return models.Task{}, handleEngineErrors(err)
+	}
+
+	return task, nil
+}