payments/internal/models/plugin_test.go at release/v3.2

mirror of https://github.com/hanzo-fi/payments.git synced 2026-10-30 20:31:20 +00:00

Files

T

CrimsonandGitHub db0561d07e fix(column): Various fixes for Column Payments (#431 )

* Set webhook ID as payment adjustment ID when adjustment created via webhook

* Fetch Column payments oldest to newest

* Ensure that webhook secrets are fetched when containers restart

* Regenerate plugin code for tests

* Add paging to fetch webhook request

* Add WorkerPool unit test to increase test coverage

* Guard against unhandled webhooks in Column plugin initiation

* Rename Timeline.LatestID to Timeline.LastSeenID for clarity

* Add metadata column to webhooks_configs table

* Persist webhook_configs.metadata

* Persist Column webhook secrets as metadata in webhooks_configs

* Remove PSPWebhookConfig from InstallResponse

* Stop passing context to initWebhookConfig()

* Don't pass context to RegisterPlugin func

* Don't pass context to plugins.RegisterPlugin

2025-05-12 09:24:59 +00:00

378 lines

8.4 KiB

Go

Raw Permalink Blame History

 package models_test
 import (
 	"context"
 	"encoding/json"
 	"testing"
 	"github.com/formancehq/payments/internal/models"
 	"github.com/stretchr/testify/assert"
 	"go.uber.org/mock/gomock"
 )
 func TestMockPlugin(t *testing.T) {
 	t.Parallel()
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	mockPlugin := models.NewMockPlugin(ctrl)
 	t.Run("Name", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		mockPlugin.EXPECT().Name().Return("test-plugin")
 		name := mockPlugin.Name()
 		assert.Equal(t, "test-plugin", name)
 	})
 	t.Run("Install", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.InstallRequest{
 			ConnectorID: "test-connector",
 		}
 		resp := models.InstallResponse{
 			Workflow: models.ConnectorTasksTree{},
 		}
 		mockPlugin.EXPECT().Install(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.Install(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp.Workflow, result.Workflow)
 	})
 	t.Run("Uninstall", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.UninstallRequest{
 			ConnectorID: "test-connector",
 		}
 		resp := models.UninstallResponse{}
 		mockPlugin.EXPECT().Uninstall(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.Uninstall(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("CreateBankAccount", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.CreateBankAccountRequest{
 			BankAccount: models.BankAccount{},
 		}
 		resp := models.CreateBankAccountResponse{
 			RelatedAccount: models.PSPAccount{},
 		}
 		mockPlugin.EXPECT().CreateBankAccount(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.CreateBankAccount(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("CreatePayout", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.CreatePayoutRequest{
 			PaymentInitiation: models.PSPPaymentInitiation{},
 		}
 		resp := models.CreatePayoutResponse{
 			Payment:         nil,
 			PollingPayoutID: nil,
 		}
 		mockPlugin.EXPECT().CreatePayout(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.CreatePayout(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("CreateTransfer", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.CreateTransferRequest{
 			PaymentInitiation: models.PSPPaymentInitiation{},
 		}
 		resp := models.CreateTransferResponse{
 			Payment:           nil,
 			PollingTransferID: nil,
 		}
 		mockPlugin.EXPECT().CreateTransfer(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.CreateTransfer(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("CreateWebhooks", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.CreateWebhooksRequest{
 			ConnectorID:    "test-connector",
 			WebhookBaseUrl: "https://example.com/webhooks",
 			FromPayload:    json.RawMessage(`{}`),
 		}
 		resp := models.CreateWebhooksResponse{
 			Others: []models.PSPOther{},
 		}
 		mockPlugin.EXPECT().CreateWebhooks(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.CreateWebhooks(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("FetchNextAccounts", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.FetchNextAccountsRequest{
 			FromPayload: json.RawMessage(`{}`),
 			State:       json.RawMessage(`{}`),
 			PageSize:    10,
 		}
 		resp := models.FetchNextAccountsResponse{
 			Accounts: []models.PSPAccount{},
 			NewState: json.RawMessage(`{}`),
 			HasMore:  false,
 		}
 		mockPlugin.EXPECT().FetchNextAccounts(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.FetchNextAccounts(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("FetchNextBalances", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.FetchNextBalancesRequest{
 			FromPayload: json.RawMessage(`{}`),
 			State:       json.RawMessage(`{}`),
 			PageSize:    10,
 		}
 		resp := models.FetchNextBalancesResponse{
 			Balances: []models.PSPBalance{},
 			NewState: json.RawMessage(`{}`),
 			HasMore:  false,
 		}
 		mockPlugin.EXPECT().FetchNextBalances(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.FetchNextBalances(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("FetchNextExternalAccounts", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.FetchNextExternalAccountsRequest{
 			FromPayload: json.RawMessage(`{}`),
 			State:       json.RawMessage(`{}`),
 			PageSize:    10,
 		}
 		resp := models.FetchNextExternalAccountsResponse{
 			ExternalAccounts: []models.PSPAccount{},
 			NewState:         json.RawMessage(`{}`),
 			HasMore:          false,
 		}
 		mockPlugin.EXPECT().FetchNextExternalAccounts(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.FetchNextExternalAccounts(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("FetchNextOthers", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.FetchNextOthersRequest{
 			Name:        "test",
 			FromPayload: json.RawMessage(`{}`),
 			State:       json.RawMessage(`{}`),
 			PageSize:    10,
 		}
 		resp := models.FetchNextOthersResponse{
 			Others:   []models.PSPOther{},
 			NewState: json.RawMessage(`{}`),
 			HasMore:  false,
 		}
 		mockPlugin.EXPECT().FetchNextOthers(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.FetchNextOthers(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("FetchNextPayments", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.FetchNextPaymentsRequest{
 			FromPayload: json.RawMessage(`{}`),
 			State:       json.RawMessage(`{}`),
 			PageSize:    10,
 		}
 		resp := models.FetchNextPaymentsResponse{
 			Payments: []models.PSPPayment{},
 			NewState: json.RawMessage(`{}`),
 			HasMore:  false,
 		}
 		mockPlugin.EXPECT().FetchNextPayments(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.FetchNextPayments(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("PollPayoutStatus", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.PollPayoutStatusRequest{
 			PayoutID: "test-payout",
 		}
 		resp := models.PollPayoutStatusResponse{
 			Payment: nil,
 			Error:   nil,
 		}
 		mockPlugin.EXPECT().PollPayoutStatus(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.PollPayoutStatus(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("PollTransferStatus", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.PollTransferStatusRequest{
 			TransferID: "test-transfer",
 		}
 		resp := models.PollTransferStatusResponse{
 			Payment: nil,
 			Error:   nil,
 		}
 		mockPlugin.EXPECT().PollTransferStatus(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.PollTransferStatus(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("ReversePayout", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.ReversePayoutRequest{
 			PaymentInitiationReversal: models.PSPPaymentInitiationReversal{},
 		}
 		resp := models.ReversePayoutResponse{
 			Payment: models.PSPPayment{},
 		}
 		mockPlugin.EXPECT().ReversePayout(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.ReversePayout(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("ReverseTransfer", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.ReverseTransferRequest{
 			PaymentInitiationReversal: models.PSPPaymentInitiationReversal{},
 		}
 		resp := models.ReverseTransferResponse{
 			Payment: models.PSPPayment{},
 		}
 		mockPlugin.EXPECT().ReverseTransfer(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.ReverseTransfer(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 	t.Run("TranslateWebhook", func(t *testing.T) {
 		t.Parallel()
 		// Given
 		ctx := context.Background()
 		req := models.TranslateWebhookRequest{
 			Name:    "test-webhook",
 			Webhook: models.PSPWebhook{},
 		}
 		resp := models.TranslateWebhookResponse{
 			Responses: []models.WebhookResponse{},
 		}
 		mockPlugin.EXPECT().TranslateWebhook(ctx, req).Return(resp, nil)
 		result, err := mockPlugin.TranslateWebhook(ctx, req)
 		assert.NoError(t, err)
 		assert.Equal(t, resp, result)
 	})
 }

378 lines 8.4 KiB Go Raw Permalink Blame History

378 lines

8.4 KiB

Go

Raw Permalink Blame History