payments/ce/plugins/plaid/create_user_link_test.go at main

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

Files

T

zeekay 7d727874d5 chore: rebrand Formance Payments -> Hanzo Payments (hanzo-fi)

- go.mod module path + all self-imports: github.com/formancehq/payments -> github.com/hanzo-fi/payments
  (1590 .go files / 3152 refs; 20 modules: root, pkg/client, pkg/domain, 18 ce/plugins).
  External dep kept: formancehq/go-libs.
- plugins: each ce/plugins/* consumed a *published* pkg/domain; added local
  'replace .../pkg/domain => ../../../pkg/domain' (consistent with root) so every
  standalone plugin module builds in-monorepo. compile-plugin.sh MOD var rebranded too.
- branding: README, LICENSE (dual MIT+EE; upstream copyright retained + Hanzo added),
  goreleaser (release images -> registry.hanzo.ai/hanzo-fi, OCI labels, homepage),
  proto go_package, renovate, speakeasy gen.yaml, connector-template *.gotpl.
- CI: removed Numary/Formance workflows + composite action; added canonical hanzo.yml +
  cicd.yml (hanzoai/ci, gated HANZO_CI_ENABLED) + secretless ci.yml (go build/vet).
- kept as data/compat keys: wire capability enums ALLOW_FORMANCE_*, generated SDK type
  client.Formance, domain field FormanceRedirectURL, OTEL_SERVICE_NAME, upstream base image.
- verified: go build ./... (default + -tags ee) + all 20 nested modules green.

2026-07-05 13:08:55 -07:00

381 lines

11 KiB

Go

Raw Permalink Blame History

 package plaid
 import (
 	"errors"
 	"time"
 	"github.com/hanzo-fi/payments/ce/plugins/plaid/client"
 	"github.com/hanzo-fi/payments/pkg/domain/models"
 	"github.com/google/uuid"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	gomock "go.uber.org/mock/gomock"
 )
 var _ = Describe("Plaid *Plugin Create User Link", func() {
 	Context("create user link", func() {
 		var (
 			ctrl *gomock.Controller
 			plg  models.Plugin
 			m    *client.MockClient
 		)
 		BeforeEach(func() {
 			ctrl = gomock.NewController(GinkgoT())
 			m = client.NewMockClient(ctrl)
 			plg = &Plugin{client: m}
 		})
 		AfterEach(func() {
 			ctrl.Finish()
 		})
 		It("should return an error - missing application name", func(ctx SpecContext) {
 			req := models.CreateUserLinkRequest{
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID: uuid.New(),
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing application name"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - missing payment service user", func(ctx SpecContext) {
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing payment service user"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - missing payment service user name", func(ctx SpecContext) {
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID: uuid.New(),
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing payment service user name"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - missing payment service user locale", func(ctx SpecContext) {
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing payment service user locale"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - missing payment service user country", func(ctx SpecContext) {
 			locale := "en-US"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing payment service user country"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - unsupported country", func(ctx SpecContext) {
 			locale := "en-US"
 			country := "XX"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("unsupported payment service user country"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - missing redirect URI", func(ctx SpecContext) {
 			locale := "en-US"
 			country := "US"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing redirect URI"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - missing open banking connections", func(ctx SpecContext) {
 			locale := "en-US"
 			country := "US"
 			redirectURL := "https://example.com/callback"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 				ClientRedirectURL: &redirectURL,
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing open banking connections"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - missing open banking connections metadata", func(ctx SpecContext) {
 			locale := "en-US"
 			country := "US"
 			redirectURL := "https://example.com/callback"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 				ClientRedirectURL:        &redirectURL,
 				OpenBankingForwardedUser: &models.OpenBankingForwardedUser{},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing open banking connections metadata"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - missing user token", func(ctx SpecContext) {
 			locale := "en-US"
 			country := "US"
 			redirectURL := "https://example.com/callback"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 				ClientRedirectURL: &redirectURL,
 				OpenBankingForwardedUser: &models.OpenBankingForwardedUser{
 					Metadata: map[string]string{},
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("missing user token"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - invalid locale", func(ctx SpecContext) {
 			locale := "invalid-locale"
 			country := "US"
 			redirectURL := "https://example.com/callback"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 				ClientRedirectURL: &redirectURL,
 				OpenBankingForwardedUser: &models.OpenBankingForwardedUser{
 					Metadata: map[string]string{
 						UserTokenMetadataKey: "user-token-123",
 					},
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("invalid locale"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should return an error - unsupported locale", func(ctx SpecContext) {
 			locale := "xx-XX"
 			country := "US"
 			redirectURL := "https://example.com/callback"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   uuid.New(),
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 				ClientRedirectURL: &redirectURL,
 				OpenBankingForwardedUser: &models.OpenBankingForwardedUser{
 					Metadata: map[string]string{
 						UserTokenMetadataKey: "user-token-123",
 					},
 				},
 			}
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err.Error()).To(ContainSubstring("invalid locale"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 		It("should create user link successfully", func(ctx SpecContext) {
 			userID := uuid.New()
 			locale := "en-US"
 			country := "US"
 			redirectURL := "https://example.com/callback"
 			webhookURL := "https://example.com/webhook"
 			attemptID := uuid.New()
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   userID,
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 				ClientRedirectURL: &redirectURL,
 				WebhookBaseURL:    webhookURL,
 				AttemptID:         attemptID.String(),
 				OpenBankingForwardedUser: &models.OpenBankingForwardedUser{
 					Metadata: map[string]string{
 						UserTokenMetadataKey: "user-token-123",
 					},
 				},
 			}
 			expectedReq := client.CreateLinkTokenRequest{
 				ApplicationName: "Test",
 				UserID:          userID.String(),
 				UserToken:       "user-token-123",
 				Language:        "en",
 				CountryCode:     "US",
 				RedirectURI:     "https://example.com/callback",
 				WebhookBaseURL:  "https://example.com/webhook",
 				AttemptID:       attemptID.String(),
 			}
 			expectedResp := client.CreateLinkTokenResponse{
 				LinkToken:     "link-token-123",
 				HostedLinkUrl: "https://plaid.com/link",
 				Expiration:    time.Now().Add(time.Hour),
 			}
 			m.EXPECT().CreateLinkToken(gomock.Any(), expectedReq).Return(expectedResp, nil)
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).To(BeNil())
 			Expect(resp.Link).To(Equal("https://plaid.com/link"))
 			Expect(resp.TemporaryLinkToken.Token).To(Equal("link-token-123"))
 			Expect(resp.TemporaryLinkToken.ExpiresAt).To(Equal(expectedResp.Expiration))
 		})
 		It("should return an error - client create link token error", func(ctx SpecContext) {
 			userID := uuid.New()
 			locale := "en-US"
 			country := "US"
 			redirectURL := "https://example.com/callback"
 			req := models.CreateUserLinkRequest{
 				ApplicationName: "Test",
 				PaymentServiceUser: &models.PSPPaymentServiceUser{
 					ID:   userID,
 					Name: "John Doe",
 					ContactDetails: &models.ContactDetails{
 						Locale: &locale,
 					},
 					Address: &models.Address{
 						Country: &country,
 					},
 				},
 				ClientRedirectURL: &redirectURL,
 				OpenBankingForwardedUser: &models.OpenBankingForwardedUser{
 					Metadata: map[string]string{
 						UserTokenMetadataKey: "user-token-123",
 					},
 				},
 			}
 			m.EXPECT().CreateLinkToken(gomock.Any(), gomock.Any()).Return(client.CreateLinkTokenResponse{}, errors.New("client error"))
 			resp, err := plg.CreateUserLink(ctx, req)
 			Expect(err).ToNot(BeNil())
 			Expect(err).To(MatchError("client error"))
 			Expect(resp).To(Equal(models.CreateUserLinkResponse{}))
 		})
 	})
 })

381 lines 11 KiB Go Raw Permalink Blame History

381 lines

11 KiB

Go

Raw Permalink Blame History