storj/satellite/payments/stripecoinpayments/stripemock.go
Yaroslav Vorobiov 3639c5ee1e satellite/payments/stripecoinpayments: skip paying invoices with due date
When running pay invoices command skip invoices that has due date set, so
customers can still pay it themselves until due date.

https://github.com/storj/storj/issues/5453

Change-Id: I8e557062491ab0c8246b28bc5ca57e845eb32e29
2023-01-24 15:12:29 +01:00

674 lines
17 KiB
Go

// Copyright (C) 2020 Storj Labs, Inc.
// See LICENSE for copying information.
package stripecoinpayments
import (
"context"
"errors"
"fmt"
"sync"
"time"
"github.com/stripe/stripe-go/v72"
"github.com/stripe/stripe-go/v72/charge"
"github.com/stripe/stripe-go/v72/customerbalancetransaction"
"github.com/stripe/stripe-go/v72/form"
"github.com/stripe/stripe-go/v72/invoice"
"github.com/stripe/stripe-go/v72/invoiceitem"
"github.com/stripe/stripe-go/v72/paymentmethod"
"github.com/stripe/stripe-go/v72/promotioncode"
"storj.io/common/storj"
"storj.io/common/testrand"
"storj.io/common/uuid"
"storj.io/storj/satellite/console"
)
// mocks synchronized map for caching mockStripeClient.
//
// The satellite has a Core part and API part which mostly duplicate each
// other. Each of them have a StripeClient instance. This is not a problem in
// production, because the stripeClient implementation is stateless and calls
// the Web API of the same Stripe backend. But it is a problem in test
// environments as the mockStripeClient is stateful - the data is stored in
// in-memory maps. Therefore, we need the Core and API parts share the same
// instance of mockStripeClient.
var mocks = struct {
sync.Mutex
m map[storj.NodeID]*mockStripeState
}{
m: make(map[storj.NodeID]*mockStripeState),
}
var (
testPromoCodes = map[string]*stripe.PromotionCode{
"promo1": {
ID: "p1",
Coupon: &stripe.Coupon{
AmountOff: 500,
Currency: stripe.CurrencyUSD,
Name: "Test Promo Code 1",
ID: "c1",
},
},
"promo2": {
ID: "p2",
Coupon: &stripe.Coupon{
PercentOff: 50,
Name: "Test Promo Code 2",
ID: "c2",
},
},
}
promoIDs = map[string]*stripe.PromotionCode{
"p1": testPromoCodes["promo1"],
"p2": testPromoCodes["promo2"],
}
couponIDs = map[string]*stripe.Coupon{
"c1": testPromoCodes["promo1"].Coupon,
"c2": testPromoCodes["promo2"].Coupon,
}
)
// mockStripeState Stripe client mock.
type mockStripeState struct {
customers *mockCustomersState
paymentMethods *mockPaymentMethods
invoices *mockInvoices
invoiceItems *mockInvoiceItems
customerBalanceTransactions *mockCustomerBalanceTransactions
charges *mockCharges
promoCodes *mockPromoCodes
creditNotes *mockCreditNotes
}
type mockStripeClient struct {
customersDB CustomersDB
usersDB console.Users
*mockStripeState
}
// mockEmptyQuery is a query with no results.
var mockEmptyQuery = stripe.Query(func(*stripe.Params, *form.Values) ([]interface{}, stripe.ListContainer, error) {
return nil, newListContainer(&stripe.ListMeta{}), nil
})
// NewStripeMock creates new Stripe client mock.
//
// A new mock is returned for each unique id. If this method is called multiple
// times with the same id, it will return the same mock instance for that id.
//
// If called by satellite component, the id param should be the peer.ID().
// If called by CLI tool, the id param should be a zero value, i.e. storj.NodeID{}.
// If called by satellitedb test case, the id param should be a random value,
// i.e. testrand.NodeID().
func NewStripeMock(id storj.NodeID, customersDB CustomersDB, usersDB console.Users) StripeClient {
mocks.Lock()
defer mocks.Unlock()
state, ok := mocks.m[id]
if !ok {
state = &mockStripeState{
customers: &mockCustomersState{},
paymentMethods: newMockPaymentMethods(),
invoices: newMockInvoices(),
invoiceItems: newMockInvoiceItems(),
customerBalanceTransactions: newMockCustomerBalanceTransactions(),
charges: &mockCharges{},
promoCodes: &mockPromoCodes{
promoCodes: testPromoCodes,
},
}
state.invoices.invoiceItems = state.invoiceItems
mocks.m[id] = state
}
return &mockStripeClient{
customersDB: customersDB,
usersDB: usersDB,
mockStripeState: state,
}
}
func (m *mockStripeClient) Customers() StripeCustomers {
mocks.Lock()
defer mocks.Unlock()
return &mockCustomers{
customersDB: m.customersDB,
usersDB: m.usersDB,
state: m.customers,
}
}
func (m *mockStripeClient) PaymentMethods() StripePaymentMethods {
return m.paymentMethods
}
func (m *mockStripeClient) Invoices() StripeInvoices {
return m.invoices
}
func (m *mockStripeClient) InvoiceItems() StripeInvoiceItems {
return m.invoiceItems
}
func (m *mockStripeClient) CustomerBalanceTransactions() StripeCustomerBalanceTransactions {
return m.customerBalanceTransactions
}
func (m *mockStripeClient) Charges() StripeCharges {
return m.charges
}
func (m *mockStripeClient) PromoCodes() StripePromoCodes {
return m.promoCodes
}
func (m *mockStripeClient) CreditNotes() StripeCreditNotes {
return m.creditNotes
}
type mockCustomers struct {
customersDB CustomersDB
usersDB console.Users
state *mockCustomersState
}
type mockCustomersState struct {
customers []*stripe.Customer
repopulated bool
}
// The Stripe Client Mock is in-memory so all data is lost when the satellite is stopped.
// We need to repopulate the mock on every restart to ensure that requests to the mock
// for existing users won't fail with errors like "customer not found".
func (m *mockCustomers) repopulate() error {
mocks.Lock()
defer mocks.Unlock()
if !m.state.repopulated {
const limit = 25
ctx := context.TODO()
cusPage, err := m.customersDB.List(ctx, 0, limit, time.Now())
if err != nil {
return err
}
for _, cus := range cusPage.Customers {
user, err := m.usersDB.Get(ctx, cus.UserID)
if err != nil {
return err
}
m.state.customers = append(m.state.customers, newMockCustomer(cus.ID, user.Email))
}
for cusPage.Next {
cusPage, err = m.customersDB.List(ctx, cusPage.NextOffset, limit, time.Now())
if err != nil {
return err
}
for _, cus := range cusPage.Customers {
user, err := m.usersDB.Get(ctx, cus.UserID)
if err != nil {
return err
}
m.state.customers = append(m.state.customers, newMockCustomer(cus.ID, user.Email))
}
}
m.state.repopulated = true
}
return nil
}
func newMockCustomer(id, email string) *stripe.Customer {
return &stripe.Customer{
ID: id,
Email: email,
InvoiceSettings: &stripe.CustomerInvoiceSettings{
DefaultPaymentMethod: &stripe.PaymentMethod{
ID: "pm_card_mastercard",
},
},
}
}
func (m *mockCustomers) New(params *stripe.CustomerParams) (*stripe.Customer, error) {
if err := m.repopulate(); err != nil {
return nil, err
}
uuid, err := uuid.New()
if err != nil {
return nil, err
}
customer := newMockCustomer(uuid.String(), *params.Email)
if params.PromotionCode != nil && promoIDs[*params.PromotionCode] != nil {
customer.Discount = &stripe.Discount{Coupon: promoIDs[*params.PromotionCode].Coupon}
}
if params.Coupon != nil {
customer.Discount = &stripe.Discount{Coupon: couponIDs[*params.Coupon]}
}
mocks.Lock()
defer mocks.Unlock()
m.state.customers = append(m.state.customers, customer)
return customer, nil
}
func (m *mockCustomers) Get(id string, params *stripe.CustomerParams) (*stripe.Customer, error) {
if err := m.repopulate(); err != nil {
return nil, err
}
mocks.Lock()
defer mocks.Unlock()
for _, customer := range m.state.customers {
if id == customer.ID {
return customer, nil
}
}
return nil, errors.New("customer not found")
}
func (m *mockCustomers) Update(id string, params *stripe.CustomerParams) (*stripe.Customer, error) {
if err := m.repopulate(); err != nil {
return nil, err
}
customer, err := m.Get(id, nil)
if err != nil {
return nil, err
}
if params == nil {
return customer, nil
}
mocks.Lock()
defer mocks.Unlock()
if params.Metadata != nil {
customer.Metadata = params.Metadata
}
if params.PromotionCode != nil && promoIDs[*params.PromotionCode] != nil {
customer.Discount = &stripe.Discount{Coupon: promoIDs[*params.PromotionCode].Coupon}
}
if params.Coupon != nil {
customer.Discount = &stripe.Discount{Coupon: &stripe.Coupon{ID: *params.Coupon}}
}
// TODO update customer with more params as necessary
return customer, nil
}
type mockPaymentMethods struct {
// attached contains a mapping of customerID to its paymentMethods
attached map[string][]*stripe.PaymentMethod
// unattached contains created but not attached paymentMethods
unattached []*stripe.PaymentMethod
}
func newMockPaymentMethods() *mockPaymentMethods {
return &mockPaymentMethods{
attached: map[string][]*stripe.PaymentMethod{},
}
}
// listContainer implements Stripe's ListContainer interface.
type listContainer struct {
listMeta *stripe.ListMeta
}
func newListContainer(meta *stripe.ListMeta) *listContainer {
return &listContainer{listMeta: meta}
}
func (c *listContainer) GetListMeta() *stripe.ListMeta {
return c.listMeta
}
func (m *mockPaymentMethods) List(listParams *stripe.PaymentMethodListParams) *paymentmethod.Iter {
mocks.Lock()
defer mocks.Unlock()
listMeta := &stripe.ListMeta{
HasMore: false,
TotalCount: uint32(len(m.attached)),
}
lc := newListContainer(listMeta)
query := stripe.Query(func(*stripe.Params, *form.Values) ([]interface{}, stripe.ListContainer, error) {
list, ok := m.attached[*listParams.Customer]
if !ok {
list = []*stripe.PaymentMethod{}
}
ret := make([]interface{}, len(list))
for i, v := range list {
ret[i] = v
}
return ret, lc, nil
})
return &paymentmethod.Iter{Iter: stripe.GetIter(nil, query)}
}
func (m *mockPaymentMethods) New(params *stripe.PaymentMethodParams) (*stripe.PaymentMethod, error) {
randID := testrand.BucketName()
newMethod := &stripe.PaymentMethod{
ID: fmt.Sprintf("pm_card_%s", randID),
Card: &stripe.PaymentMethodCard{
ExpMonth: 12,
ExpYear: 2050,
Brand: "Mastercard",
Last4: "4444",
Description: randID,
},
Type: stripe.PaymentMethodTypeCard,
}
mocks.Lock()
defer mocks.Unlock()
m.unattached = append(m.unattached, newMethod)
return newMethod, nil
}
func (m *mockPaymentMethods) Attach(id string, params *stripe.PaymentMethodAttachParams) (*stripe.PaymentMethod, error) {
mocks.Lock()
defer mocks.Unlock()
var method *stripe.PaymentMethod
for _, candidate := range m.unattached {
if candidate.ID == id {
method = candidate
}
}
attached, ok := m.attached[*params.Customer]
if !ok {
attached = []*stripe.PaymentMethod{}
}
m.attached[*params.Customer] = append(attached, method)
return method, nil
}
func (m *mockPaymentMethods) Detach(id string, params *stripe.PaymentMethodDetachParams) (*stripe.PaymentMethod, error) {
mocks.Lock()
defer mocks.Unlock()
var unattached *stripe.PaymentMethod
for user, userMethods := range m.attached {
var remaining []*stripe.PaymentMethod
for _, method := range userMethods {
if id == method.ID {
unattached = method
} else {
remaining = append(remaining, method)
}
}
m.attached[user] = remaining
}
return unattached, nil
}
type mockInvoices struct {
invoices map[string][]*stripe.Invoice
invoiceItems *mockInvoiceItems
}
func newMockInvoices() *mockInvoices {
return &mockInvoices{
invoices: make(map[string][]*stripe.Invoice),
}
}
func (m *mockInvoices) New(params *stripe.InvoiceParams) (*stripe.Invoice, error) {
mocks.Lock()
defer mocks.Unlock()
items, ok := m.invoiceItems.items[*params.Customer]
if !ok || len(items) == 0 {
return nil, &stripe.Error{Code: stripe.ErrorCodeInvoiceNoCustomerLineItems}
}
due := int64(0)
if params.DueDate != nil {
due = *params.DueDate
}
invoice := &stripe.Invoice{
ID: "in_" + string(testrand.RandAlphaNumeric(25)),
Customer: &stripe.Customer{ID: *params.Customer},
DueDate: due,
}
m.invoices[*params.Customer] = append(m.invoices[*params.Customer], invoice)
for _, item := range items {
if item.Invoice == nil {
item.Invoice = invoice
}
}
return invoice, nil
}
func (m *mockInvoices) List(listParams *stripe.InvoiceListParams) *invoice.Iter {
mocks.Lock()
defer mocks.Unlock()
listMeta := &stripe.ListMeta{
HasMore: false,
TotalCount: uint32(len(m.invoices)),
}
lc := newListContainer(listMeta)
query := stripe.Query(func(*stripe.Params, *form.Values) (ret []interface{}, _ stripe.ListContainer, _ error) {
if listParams.Customer == nil {
for _, invoices := range m.invoices {
for _, invoice := range invoices {
ret = append(ret, invoice)
}
}
} else if list, ok := m.invoices[*listParams.Customer]; ok {
for _, invoice := range list {
ret = append(ret, invoice)
}
}
return ret, lc, nil
})
return &invoice.Iter{Iter: stripe.GetIter(nil, query)}
}
func (m *mockInvoices) Update(id string, params *stripe.InvoiceParams) (invoice *stripe.Invoice, err error) {
for _, invoices := range m.invoices {
for _, invoice := range invoices {
if invoice.ID == id {
return invoice, nil
}
}
}
return nil, errors.New("invoice not found")
}
func (m *mockInvoices) FinalizeInvoice(id string, params *stripe.InvoiceFinalizeParams) (*stripe.Invoice, error) {
return nil, nil
}
func (m *mockInvoices) Pay(id string, params *stripe.InvoicePayParams) (*stripe.Invoice, error) {
for _, invoices := range m.invoices {
for i, invoice := range invoices {
if invoice.ID == id {
m.invoices[invoice.Customer.ID][i].Status = stripe.InvoiceStatusPaid
return invoice, nil
}
}
}
return nil, nil
}
type mockInvoiceItems struct {
items map[string][]*stripe.InvoiceItem
}
func newMockInvoiceItems() *mockInvoiceItems {
return &mockInvoiceItems{
items: make(map[string][]*stripe.InvoiceItem),
}
}
func (m *mockInvoiceItems) Update(id string, params *stripe.InvoiceItemParams) (*stripe.InvoiceItem, error) {
return nil, nil
}
func (m *mockInvoiceItems) Del(id string, params *stripe.InvoiceItemParams) (*stripe.InvoiceItem, error) {
return nil, nil
}
func (m *mockInvoiceItems) New(params *stripe.InvoiceItemParams) (*stripe.InvoiceItem, error) {
mocks.Lock()
defer mocks.Unlock()
item := &stripe.InvoiceItem{
Metadata: params.Metadata,
}
if params.UnitAmountDecimal != nil {
item.UnitAmountDecimal = *params.UnitAmountDecimal
}
m.items[*params.Customer] = append(m.items[*params.Customer], item)
return item, nil
}
func (m *mockInvoiceItems) List(listParams *stripe.InvoiceItemListParams) *invoiceitem.Iter {
mocks.Lock()
defer mocks.Unlock()
listMeta := &stripe.ListMeta{
HasMore: false,
TotalCount: uint32(len(m.items)),
}
lc := newListContainer(listMeta)
query := stripe.Query(func(*stripe.Params, *form.Values) ([]interface{}, stripe.ListContainer, error) {
list, ok := m.items[*listParams.Customer]
if !ok {
list = []*stripe.InvoiceItem{}
}
ret := make([]interface{}, len(list))
for i, v := range list {
ret[i] = v
}
return ret, lc, nil
})
return &invoiceitem.Iter{Iter: stripe.GetIter(nil, query)}
}
type mockCustomerBalanceTransactions struct {
transactions map[string][]*stripe.CustomerBalanceTransaction
}
func newMockCustomerBalanceTransactions() *mockCustomerBalanceTransactions {
return &mockCustomerBalanceTransactions{
transactions: make(map[string][]*stripe.CustomerBalanceTransaction),
}
}
func (m *mockCustomerBalanceTransactions) New(params *stripe.CustomerBalanceTransactionParams) (*stripe.CustomerBalanceTransaction, error) {
tx := &stripe.CustomerBalanceTransaction{
Type: stripe.CustomerBalanceTransactionTypeAdjustment,
Amount: *params.Amount,
Description: *params.Description,
Metadata: params.Metadata,
Created: time.Now().Unix(),
}
mocks.Lock()
defer mocks.Unlock()
m.transactions[*params.Customer] = append(m.transactions[*params.Customer], tx)
return tx, nil
}
func (m *mockCustomerBalanceTransactions) List(listParams *stripe.CustomerBalanceTransactionListParams) *customerbalancetransaction.Iter {
mocks.Lock()
defer mocks.Unlock()
query := stripe.Query(func(p *stripe.Params, b *form.Values) ([]interface{}, stripe.ListContainer, error) {
txs := m.transactions[*listParams.Customer]
ret := make([]interface{}, len(txs))
for i, v := range txs {
ret[i] = v
}
listMeta := &stripe.ListMeta{
TotalCount: uint32(len(txs)),
}
lc := newListContainer(listMeta)
return ret, lc, nil
})
return &customerbalancetransaction.Iter{Iter: stripe.GetIter(listParams, query)}
}
type mockCharges struct {
}
func (m *mockCharges) List(listParams *stripe.ChargeListParams) *charge.Iter {
return &charge.Iter{Iter: stripe.GetIter(listParams, mockEmptyQuery)}
}
type mockPromoCodes struct {
promoCodes map[string]*stripe.PromotionCode
}
func (m *mockPromoCodes) List(params *stripe.PromotionCodeListParams) *promotioncode.Iter {
mocks.Lock()
defer mocks.Unlock()
query := stripe.Query(func(p *stripe.Params, b *form.Values) ([]interface{}, stripe.ListContainer, error) {
promoCode := m.promoCodes[*params.Code]
if promoCode == nil {
return make([]interface{}, 0), &stripe.ListMeta{TotalCount: 0}, nil
}
ret := make([]interface{}, 1)
ret[0] = promoCode
listMeta := &stripe.ListMeta{
TotalCount: 1,
}
lc := newListContainer(listMeta)
return ret, lc, nil
})
return &promotioncode.Iter{Iter: stripe.GetIter(params, query)}
}
type mockCreditNotes struct {
}
func (m mockCreditNotes) New(params *stripe.CreditNoteParams) (*stripe.CreditNote, error) {
return nil, nil
}