98234e76b7
This change introduces a new user status, LegalHold to be used to pause an account while it is under legal review. It also modifies the condition whether to generate invoices for a user to apply to this new status. Issue: storj/storj-private#492 Change-Id: Idc9a6166cc96178a95e45cf7c0f2e982631ca021
1699 lines
59 KiB
Go
1699 lines
59 KiB
Go
// Copyright (C) 2020 Storj Labs, Inc.
|
|
// See LICENSE for copying information.
|
|
|
|
package stripe_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
"sort"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/shopspring/decimal"
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/stripe/stripe-go/v75"
|
|
"go.uber.org/zap"
|
|
|
|
"storj.io/common/currency"
|
|
"storj.io/common/memory"
|
|
"storj.io/common/pb"
|
|
"storj.io/common/testcontext"
|
|
"storj.io/common/testrand"
|
|
"storj.io/common/uuid"
|
|
"storj.io/storj/private/blockchain"
|
|
"storj.io/storj/private/testplanet"
|
|
"storj.io/storj/satellite"
|
|
"storj.io/storj/satellite/accounting"
|
|
"storj.io/storj/satellite/buckets"
|
|
"storj.io/storj/satellite/console"
|
|
"storj.io/storj/satellite/metabase"
|
|
"storj.io/storj/satellite/payments"
|
|
"storj.io/storj/satellite/payments/billing"
|
|
"storj.io/storj/satellite/payments/paymentsconfig"
|
|
stripe1 "storj.io/storj/satellite/payments/stripe"
|
|
)
|
|
|
|
func TestService_SetInvoiceStatusUncollectible(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
invoiceBalance := currency.AmountFromBaseUnits(800, currency.USDollars)
|
|
usdCurrency := string(stripe.CurrencyUSD)
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice
|
|
inv, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice item
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(invoiceBalance.BaseUnits()),
|
|
Currency: stripe.String(usdCurrency),
|
|
Customer: &customer,
|
|
Invoice: &inv.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
finalizeParams := &stripe.InvoiceFinalizeInvoiceParams{Params: stripe.Params{Context: ctx}}
|
|
|
|
// finalize invoice
|
|
inv, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv.Status)
|
|
|
|
// run update invoice status to uncollectible
|
|
// beginning of last month
|
|
startPeriod := time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, -1, 0)
|
|
// end of current month
|
|
endPeriod := time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, 1, -1)
|
|
|
|
t.Run("update invoice status to uncollectible", func(t *testing.T) {
|
|
err = payments.StripeService.SetInvoiceStatus(ctx, startPeriod, endPeriod, "uncollectible", false)
|
|
require.NoError(t, err)
|
|
|
|
iter := satellite.API.Payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
})
|
|
iter.Next()
|
|
require.Equal(t, stripe.InvoiceStatusUncollectible, iter.Invoice().Status)
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestService_SetInvoiceStatusVoid(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
invoiceBalance := currency.AmountFromBaseUnits(800, currency.USDollars)
|
|
usdCurrency := string(stripe.CurrencyUSD)
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice
|
|
inv, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice item
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(invoiceBalance.BaseUnits()),
|
|
Currency: stripe.String(usdCurrency),
|
|
Customer: &customer,
|
|
Invoice: &inv.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
finalizeParams := &stripe.InvoiceFinalizeInvoiceParams{Params: stripe.Params{Context: ctx}}
|
|
|
|
// finalize invoice
|
|
inv, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv.Status)
|
|
|
|
// run update invoice status to uncollectible
|
|
// beginning of last month
|
|
startPeriod := time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, -1, 0)
|
|
// end of current month
|
|
endPeriod := time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, 1, -1)
|
|
|
|
t.Run("update invoice status to void", func(t *testing.T) {
|
|
err = payments.StripeService.SetInvoiceStatus(ctx, startPeriod, endPeriod, "void", false)
|
|
require.NoError(t, err)
|
|
|
|
iter := satellite.API.Payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
})
|
|
iter.Next()
|
|
require.Equal(t, stripe.InvoiceStatusVoid, iter.Invoice().Status)
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestService_SetInvoiceStatusPaid(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
invoiceBalance := currency.AmountFromBaseUnits(800, currency.USDollars)
|
|
usdCurrency := string(stripe.CurrencyUSD)
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice
|
|
inv, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice item
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(invoiceBalance.BaseUnits()),
|
|
Currency: stripe.String(usdCurrency),
|
|
Customer: &customer,
|
|
Invoice: &inv.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
finalizeParams := &stripe.InvoiceFinalizeInvoiceParams{Params: stripe.Params{Context: ctx}}
|
|
|
|
// finalize invoice
|
|
inv, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv.Status)
|
|
|
|
// run update invoice status to uncollectible
|
|
// beginning of last month
|
|
startPeriod := time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, -1, 0)
|
|
// end of current month
|
|
endPeriod := time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, 1, -1)
|
|
|
|
t.Run("update invoice status to paid", func(t *testing.T) {
|
|
err = payments.StripeService.SetInvoiceStatus(ctx, startPeriod, endPeriod, "paid", false)
|
|
require.NoError(t, err)
|
|
|
|
iter := satellite.API.Payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
})
|
|
iter.Next()
|
|
require.Equal(t, stripe.InvoiceStatusPaid, iter.Invoice().Status)
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestService_SetInvoiceStatusInvalid(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
invoiceBalance := currency.AmountFromBaseUnits(800, currency.USDollars)
|
|
usdCurrency := string(stripe.CurrencyUSD)
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice
|
|
inv, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice item
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(invoiceBalance.BaseUnits()),
|
|
Currency: stripe.String(usdCurrency),
|
|
Customer: &customer,
|
|
Invoice: &inv.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
finalizeParams := &stripe.InvoiceFinalizeInvoiceParams{Params: stripe.Params{Context: ctx}}
|
|
|
|
// finalize invoice
|
|
inv, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv.Status)
|
|
|
|
// run update invoice status to uncollectible
|
|
// beginning of last month
|
|
startPeriod := time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, -1, 0)
|
|
// end of current month
|
|
endPeriod := time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, 1, -1)
|
|
|
|
t.Run("update invoice status to invalid", func(t *testing.T) {
|
|
err = payments.StripeService.SetInvoiceStatus(ctx, startPeriod, endPeriod, "not a real status", false)
|
|
require.Error(t, err)
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestService_BalanceInvoiceItems(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
numberOfUsers := 10
|
|
users := make([]*console.User, numberOfUsers)
|
|
projects := make([]*console.Project, numberOfUsers)
|
|
// create a bunch of users
|
|
for i := 0; i < numberOfUsers; i++ {
|
|
var err error
|
|
|
|
users[i], err = satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser" + strconv.Itoa(i),
|
|
Email: "user@test" + strconv.Itoa(i),
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
|
|
projects[i], err = satellite.AddProject(ctx, users[i].ID, "testproject-"+strconv.Itoa(i))
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// give one of the users a stripe balance
|
|
cusID, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, users[4].ID)
|
|
require.NoError(t, err)
|
|
_, err = payments.StripeClient.Customers().Update(cusID, &stripe.CustomerParams{
|
|
Params: stripe.Params{
|
|
Context: ctx,
|
|
},
|
|
Balance: stripe.Int64(1000),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// convert the stripe balance into an invoice item
|
|
require.NoError(t, payments.StripeService.CreateBalanceInvoiceItems(ctx))
|
|
|
|
// check that the invoice item was created
|
|
itr := payments.StripeClient.InvoiceItems().List(&stripe.InvoiceItemListParams{
|
|
Customer: stripe.String(cusID),
|
|
})
|
|
require.True(t, itr.Next())
|
|
require.NoError(t, itr.Err())
|
|
require.Equal(t, int64(1000), itr.InvoiceItem().UnitAmount)
|
|
|
|
// check that the stripe balance was reset
|
|
cus, err := payments.StripeClient.Customers().Get(cusID, &stripe.CustomerParams{
|
|
Params: stripe.Params{
|
|
Context: ctx,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(0), cus.Balance)
|
|
|
|
// Deactivate the users and give them balances
|
|
statusPending := console.PendingDeletion
|
|
statusDeleted := console.Deleted
|
|
statusLegalHold := console.LegalHold
|
|
for i, user := range users {
|
|
cusID, err = satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
_, err = payments.StripeClient.Customers().Update(cusID, &stripe.CustomerParams{
|
|
Params: stripe.Params{
|
|
Context: ctx,
|
|
},
|
|
Balance: stripe.Int64(1000),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
var status *console.UserStatus
|
|
if i%2 == 0 {
|
|
status = &statusDeleted
|
|
} else if i%3 == 0 {
|
|
status = &statusPending
|
|
} else {
|
|
status = &statusLegalHold
|
|
}
|
|
err := satellite.DB.Console().Users().Update(ctx, user.ID, console.UpdateUserRequest{
|
|
Status: status,
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// try to convert the stripe balance into an invoice item
|
|
require.NoError(t, payments.StripeService.CreateBalanceInvoiceItems(ctx))
|
|
|
|
// check no invoice item was created since all users are deactivated
|
|
itr = payments.StripeClient.InvoiceItems().List(&stripe.InvoiceItemListParams{
|
|
Customer: stripe.String(cusID),
|
|
})
|
|
require.NoError(t, itr.Err())
|
|
require.False(t, itr.Next())
|
|
})
|
|
}
|
|
|
|
func TestService_InvoiceElementsProcessing(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
|
|
// pick a specific date so that it doesn't fail if it's the last day of the month
|
|
// keep month + 1 because user needs to be created before calculation
|
|
period := time.Date(time.Now().Year(), time.Now().Month()+1, 20, 0, 0, 0, 0, time.UTC)
|
|
|
|
numberOfProjects := 19
|
|
numberOfInactiveUsers := 5
|
|
status := console.PendingDeletion
|
|
// user to be deactivated later
|
|
var activeUser console.User
|
|
// generate test data, each user has one project and some credits
|
|
for i := 0; i < numberOfProjects; i++ {
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser" + strconv.Itoa(i),
|
|
Email: "user@test" + strconv.Itoa(i),
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
|
|
project, err := satellite.AddProject(ctx, user.ID, "testproject-"+strconv.Itoa(i))
|
|
require.NoError(t, err)
|
|
|
|
err = satellite.DB.Orders().UpdateBucketBandwidthSettle(ctx, project.ID, []byte("testbucket"),
|
|
pb.PieceAction_GET, int64(i+10)*memory.GiB.Int64(), 0, period)
|
|
require.NoError(t, err)
|
|
|
|
if i < numberOfProjects-numberOfInactiveUsers {
|
|
activeUser = *user
|
|
continue
|
|
}
|
|
if i%2 == 0 {
|
|
status = console.Deleted
|
|
} else if i%3 == 0 {
|
|
status = console.PendingDeletion
|
|
} else {
|
|
status = console.LegalHold
|
|
}
|
|
err = satellite.DB.Console().Users().Update(ctx, user.ID, console.UpdateUserRequest{
|
|
Status: &status,
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
satellite.API.Payments.StripeService.SetNow(func() time.Time {
|
|
return time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
})
|
|
err := satellite.API.Payments.StripeService.PrepareInvoiceProjectRecords(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
start := time.Date(period.Year(), period.Month(), 1, 0, 0, 0, 0, time.UTC)
|
|
end := time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
|
|
// check if we have project record for each project, except for inactive users
|
|
recordsPage, err := satellite.DB.StripeCoinPayments().ProjectRecords().ListUnapplied(ctx, uuid.UUID{}, 40, start, end)
|
|
require.NoError(t, err)
|
|
require.Equal(t, numberOfProjects-numberOfInactiveUsers, len(recordsPage.Records))
|
|
|
|
// deactivate user
|
|
err = satellite.DB.Console().Users().Update(ctx, activeUser.ID, console.UpdateUserRequest{
|
|
Status: &status,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = satellite.API.Payments.StripeService.InvoiceApplyProjectRecords(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
// verify that we applied all unapplied project records
|
|
recordsPage, err = satellite.DB.StripeCoinPayments().ProjectRecords().ListUnapplied(ctx, uuid.UUID{}, 40, start, end)
|
|
require.NoError(t, err)
|
|
// the 1 remaining record is for the now inactive user
|
|
require.Equal(t, 1, len(recordsPage.Records))
|
|
})
|
|
}
|
|
|
|
func TestService_InvoiceUserWithManyProjects(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
// pick a specific date so that it doesn't fail if it's the last day of the month
|
|
// keep month + 1 because user needs to be created before calculation
|
|
period := time.Date(time.Now().Year(), time.Now().Month()+1, 20, 0, 0, 0, 0, time.UTC)
|
|
|
|
payments.StripeService.SetNow(func() time.Time {
|
|
return time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
})
|
|
start := time.Date(period.Year(), period.Month(), 1, 0, 0, 0, 0, time.UTC)
|
|
end := time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
|
|
numberOfProjects := 5
|
|
storageHours := 24
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, numberOfProjects)
|
|
require.NoError(t, err)
|
|
|
|
projects := make([]*console.Project, numberOfProjects)
|
|
projectsEgress := make([]int64, len(projects))
|
|
projectsStorage := make([]int64, len(projects))
|
|
for i := 0; i < len(projects); i++ {
|
|
projects[i], err = satellite.AddProject(ctx, user.ID, "testproject-"+strconv.Itoa(i))
|
|
require.NoError(t, err)
|
|
|
|
projectsEgress[i] = int64(i+10) * memory.GiB.Int64()
|
|
projectsStorage[i] = int64(i+1) * memory.TiB.Int64()
|
|
totalSegments := int64(i + 1)
|
|
generateProjectStorage(ctx, t, satellite.DB,
|
|
projects[i].ID,
|
|
period,
|
|
period.Add(time.Duration(storageHours)*time.Hour),
|
|
projectsEgress[i],
|
|
projectsStorage[i],
|
|
totalSegments)
|
|
// verify that projects don't have records yet
|
|
projectRecord, err := satellite.DB.StripeCoinPayments().ProjectRecords().Get(ctx, projects[i].ID, start, end)
|
|
require.NoError(t, err)
|
|
require.Nil(t, projectRecord)
|
|
}
|
|
|
|
err = payments.StripeService.PrepareInvoiceProjectRecords(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
for i := 0; i < len(projects); i++ {
|
|
projectRecord, err := satellite.DB.StripeCoinPayments().ProjectRecords().Get(ctx, projects[i].ID, start, end)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, projectRecord)
|
|
require.Equal(t, projects[i].ID, projectRecord.ProjectID)
|
|
require.Equal(t, projectsEgress[i], projectRecord.Egress)
|
|
|
|
expectedStorage := float64(projectsStorage[i] * int64(storageHours))
|
|
require.Equal(t, expectedStorage, projectRecord.Storage)
|
|
|
|
expectedSegmentsCount := float64((i + 1) * storageHours)
|
|
require.Equal(t, expectedSegmentsCount, projectRecord.Segments)
|
|
}
|
|
|
|
// run all parts of invoice generation to see if there are no unexpected errors
|
|
err = payments.StripeService.InvoiceApplyProjectRecords(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
// deactivate user
|
|
pendingDeletionStatus := console.PendingDeletion
|
|
activeStatus := console.Active
|
|
err = satellite.DB.Console().Users().Update(ctx, user.ID, console.UpdateUserRequest{
|
|
Status: &pendingDeletionStatus,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payments.StripeService.CreateInvoices(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
// invoice wasn't created because user is deactivated
|
|
itr := payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{})
|
|
require.False(t, itr.Next())
|
|
require.NoError(t, itr.Err())
|
|
|
|
err = satellite.DB.Console().Users().Update(ctx, user.ID, console.UpdateUserRequest{
|
|
Status: &activeStatus,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payments.StripeService.CreateInvoices(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
// invoice was created because user is active
|
|
itr = payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{})
|
|
require.True(t, itr.Next())
|
|
require.NoError(t, itr.Err())
|
|
})
|
|
}
|
|
|
|
func TestService_FinalizeInvoices(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
stripeClient := satellite.API.Payments.StripeClient
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice
|
|
inv, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice item
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(1000),
|
|
Currency: stripe.String(string(stripe.CurrencyUSD)),
|
|
Customer: &customer,
|
|
Invoice: &inv.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
itr := stripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
Customer: &customer,
|
|
})
|
|
require.True(t, itr.Next())
|
|
require.NoError(t, itr.Err())
|
|
require.Equal(t, stripe.InvoiceStatusDraft, itr.Invoice().Status)
|
|
|
|
// deactivate user
|
|
pendingDeletionStatus := console.PendingDeletion
|
|
err = satellite.DB.Console().Users().Update(ctx, user.ID, console.UpdateUserRequest{
|
|
Status: &pendingDeletionStatus,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = satellite.API.Payments.StripeService.FinalizeInvoices(ctx)
|
|
require.NoError(t, err)
|
|
|
|
itr = stripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
Customer: &customer,
|
|
})
|
|
require.True(t, itr.Next())
|
|
require.NoError(t, itr.Err())
|
|
// finalizing did not work because user is deactivated
|
|
require.Equal(t, stripe.InvoiceStatusDraft, itr.Invoice().Status)
|
|
|
|
activeStatus := console.Active
|
|
err = satellite.DB.Console().Users().Update(ctx, user.ID, console.UpdateUserRequest{
|
|
Status: &activeStatus,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = satellite.API.Payments.StripeService.FinalizeInvoices(ctx)
|
|
require.NoError(t, err)
|
|
|
|
itr = stripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
Customer: &customer,
|
|
})
|
|
require.True(t, itr.Next())
|
|
require.NoError(t, itr.Err())
|
|
require.Equal(t, stripe.InvoiceStatusOpen, itr.Invoice().Status)
|
|
})
|
|
}
|
|
|
|
func TestService_ProjectsWithMembers(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
|
|
// pick a specific date so that it doesn't fail if it's the last day of the month
|
|
// keep month + 1 because user needs to be created before calculation
|
|
period := time.Date(time.Now().Year(), time.Now().Month()+1, 20, 0, 0, 0, 0, time.UTC)
|
|
|
|
numberOfUsers := 5
|
|
users := make([]*console.User, numberOfUsers)
|
|
projects := make([]*console.Project, numberOfUsers)
|
|
for i := 0; i < numberOfUsers; i++ {
|
|
var err error
|
|
|
|
users[i], err = satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser" + strconv.Itoa(i),
|
|
Email: "user@test" + strconv.Itoa(i),
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
|
|
projects[i], err = satellite.AddProject(ctx, users[i].ID, "testproject-"+strconv.Itoa(i))
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// all users are members in all projects
|
|
for _, project := range projects {
|
|
for _, user := range users {
|
|
if project.OwnerID != user.ID {
|
|
_, err := satellite.DB.Console().ProjectMembers().Insert(ctx, user.ID, project.ID)
|
|
require.NoError(t, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
satellite.API.Payments.StripeService.SetNow(func() time.Time {
|
|
return time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
})
|
|
err := satellite.API.Payments.StripeService.PrepareInvoiceProjectRecords(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
start := time.Date(period.Year(), period.Month(), 1, 0, 0, 0, 0, time.UTC)
|
|
end := time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
|
|
recordsPage, err := satellite.DB.StripeCoinPayments().ProjectRecords().ListUnapplied(ctx, uuid.UUID{}, 40, start, end)
|
|
require.NoError(t, err)
|
|
require.Equal(t, len(projects), len(recordsPage.Records))
|
|
})
|
|
}
|
|
|
|
func TestService_InvoiceItemsFromProjectUsage(t *testing.T) {
|
|
const (
|
|
projectName = "my-project"
|
|
partnerName = "partner"
|
|
noOverridePartnerName = "no-override"
|
|
|
|
hoursPerMonth = 24 * 30
|
|
bytesPerMegabyte = int64(memory.MB / memory.B)
|
|
byteHoursPerMBMonth = hoursPerMonth * bytesPerMegabyte
|
|
)
|
|
|
|
var (
|
|
defaultPrice = paymentsconfig.ProjectUsagePrice{
|
|
StorageTB: "1",
|
|
EgressTB: "2",
|
|
Segment: "3",
|
|
}
|
|
partnerPrice = paymentsconfig.ProjectUsagePrice{
|
|
StorageTB: "4",
|
|
EgressTB: "5",
|
|
Segment: "6",
|
|
EgressDiscountRatio: 0.5,
|
|
}
|
|
)
|
|
defaultModel, err := defaultPrice.ToModel()
|
|
require.NoError(t, err)
|
|
partnerModel, err := partnerPrice.ToModel()
|
|
require.NoError(t, err)
|
|
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.UsagePrice = defaultPrice
|
|
config.Payments.UsagePriceOverrides.SetMap(map[string]paymentsconfig.ProjectUsagePrice{
|
|
partnerName: partnerPrice,
|
|
})
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
usage := map[string]accounting.ProjectUsage{
|
|
"": {
|
|
Storage: 10000000000, // Byte-hours
|
|
Egress: 123 * memory.GB.Int64(), // Bytes
|
|
SegmentCount: 200000, // Segment-Hours
|
|
},
|
|
partnerName: {
|
|
Storage: 20000000000,
|
|
Egress: 456 * memory.GB.Int64(),
|
|
SegmentCount: 400000,
|
|
},
|
|
noOverridePartnerName: {
|
|
Storage: 30000000000,
|
|
Egress: 789 * memory.GB.Int64(),
|
|
SegmentCount: 600000,
|
|
},
|
|
}
|
|
|
|
items := planet.Satellites[0].API.Payments.StripeService.InvoiceItemsFromProjectUsage(projectName, usage)
|
|
require.Len(t, items, len(usage)*3)
|
|
|
|
for i, tt := range []struct {
|
|
name string
|
|
partner string
|
|
priceModel payments.ProjectUsagePriceModel
|
|
}{
|
|
{"default pricing - no partner", "", defaultModel},
|
|
{"default pricing - no override for partner", noOverridePartnerName, defaultModel},
|
|
{"partner pricing", partnerName, partnerModel},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
prefix := "Project " + projectName
|
|
if tt.partner != "" {
|
|
prefix += " (" + tt.partner + ")"
|
|
}
|
|
|
|
usage := usage[tt.partner]
|
|
usage.Egress -= int64(math.Round(usage.Storage / hoursPerMonth * tt.priceModel.EgressDiscountRatio))
|
|
if usage.Egress < 0 {
|
|
usage.Egress = 0
|
|
}
|
|
|
|
expectedStorageQuantity := int64(math.Round(usage.Storage / float64(byteHoursPerMBMonth)))
|
|
expectedEgressQuantity := int64(math.Round(float64(usage.Egress) / float64(bytesPerMegabyte)))
|
|
expectedSegmentQuantity := int64(math.Round(usage.SegmentCount / hoursPerMonth))
|
|
|
|
items := items[i*3 : (i*3)+3]
|
|
for _, item := range items {
|
|
require.NotNil(t, item)
|
|
}
|
|
|
|
require.Equal(t, prefix+" - Segment Storage (MB-Month)", *items[0].Description)
|
|
require.Equal(t, expectedStorageQuantity, *items[0].Quantity)
|
|
storage, _ := tt.priceModel.StorageMBMonthCents.Float64()
|
|
require.Equal(t, storage, *items[0].UnitAmountDecimal)
|
|
|
|
require.Equal(t, prefix+" - Egress Bandwidth (MB)", *items[1].Description)
|
|
require.Equal(t, expectedEgressQuantity, *items[1].Quantity)
|
|
egress, _ := tt.priceModel.EgressMBCents.Float64()
|
|
require.Equal(t, egress, *items[1].UnitAmountDecimal)
|
|
|
|
require.Equal(t, prefix+" - Segment Fee (Segment-Month)", *items[2].Description)
|
|
require.Equal(t, expectedSegmentQuantity, *items[2].Quantity)
|
|
segment, _ := tt.priceModel.SegmentMonthCents.Float64()
|
|
require.Equal(t, segment, *items[2].UnitAmountDecimal)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestService_PayInvoiceFromTokenBalance(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
tokenBalance := currency.AmountFromBaseUnits(1000, currency.USDollars)
|
|
invoiceBalance := currency.AmountFromBaseUnits(800, currency.USDollars)
|
|
usdCurrency := string(stripe.CurrencyUSD)
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice
|
|
inv, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice item
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(invoiceBalance.BaseUnits()),
|
|
Currency: stripe.String(usdCurrency),
|
|
Customer: &customer,
|
|
Invoice: &inv.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
finalizeParams := &stripe.InvoiceFinalizeInvoiceParams{Params: stripe.Params{Context: ctx}}
|
|
|
|
// finalize invoice
|
|
inv, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv.Status)
|
|
|
|
// setup storjscan wallet
|
|
address, err := blockchain.BytesToAddress(testrand.Bytes(20))
|
|
require.NoError(t, err)
|
|
userID := user.ID
|
|
err = satellite.DB.Wallets().Add(ctx, userID, address)
|
|
require.NoError(t, err)
|
|
_, err = satellite.DB.Billing().Insert(ctx, billing.Transaction{
|
|
UserID: userID,
|
|
Amount: tokenBalance,
|
|
Description: "token payment credit",
|
|
Source: billing.StorjScanSource,
|
|
Status: billing.TransactionStatusCompleted,
|
|
Type: billing.TransactionTypeCredit,
|
|
Metadata: nil,
|
|
Timestamp: time.Now(),
|
|
CreatedAt: time.Now(),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// run apply token balance to see if there are no unexpected errors
|
|
err = payments.StripeService.InvoiceApplyTokenBalance(ctx, time.Time{})
|
|
require.NoError(t, err)
|
|
|
|
err = satellite.API.Payments.StripeService.PayInvoices(ctx, time.Time{})
|
|
require.NoError(t, err)
|
|
|
|
iter := satellite.API.Payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
})
|
|
iter.Next()
|
|
require.Equal(t, stripe.InvoiceStatusPaid, iter.Invoice().Status)
|
|
|
|
// balance is in USDollars Micro, so it needs to be converted before comparison
|
|
balance, err := satellite.DB.Billing().GetBalance(ctx, userID)
|
|
balance = currency.AmountFromDecimal(balance.AsDecimal().Truncate(2), currency.USDollars)
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, tokenBalance.BaseUnits()-invoiceBalance.BaseUnits(), balance.BaseUnits())
|
|
})
|
|
}
|
|
|
|
func TestService_PayMultipleInvoiceFromTokenBalance(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
|
|
// create user
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice one
|
|
inv1, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice two
|
|
inv2, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice items
|
|
for _, info := range []struct {
|
|
invID string
|
|
amount int64
|
|
}{
|
|
{inv1.ID, 75}, {inv2.ID, 100},
|
|
} {
|
|
for i := 0; i < 2; i++ {
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(info.amount),
|
|
Currency: stripe.String(string(stripe.CurrencyUSD)),
|
|
Customer: &customer,
|
|
Invoice: stripe.String(info.invID),
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
}
|
|
|
|
finalizeParams := &stripe.InvoiceFinalizeInvoiceParams{Params: stripe.Params{Context: ctx}}
|
|
|
|
// finalize invoice one
|
|
inv1, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv1.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv1.Status)
|
|
|
|
// finalize invoice two
|
|
inv2, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv2.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv2.Status)
|
|
|
|
// setup storjscan wallet and user balance
|
|
address, err := blockchain.BytesToAddress(testrand.Bytes(20))
|
|
require.NoError(t, err)
|
|
userID := user.ID
|
|
err = satellite.DB.Wallets().Add(ctx, userID, address)
|
|
require.NoError(t, err)
|
|
// User balance is not enough to cover full amount of both invoices
|
|
_, err = satellite.DB.Billing().Insert(ctx, billing.Transaction{
|
|
UserID: userID,
|
|
Amount: currency.AmountFromBaseUnits(300, currency.USDollars),
|
|
Description: "token payment credit",
|
|
Source: billing.StorjScanSource,
|
|
Status: billing.TransactionStatusCompleted,
|
|
Type: billing.TransactionTypeCredit,
|
|
Metadata: nil,
|
|
Timestamp: time.Now(),
|
|
CreatedAt: time.Now(),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// attempt to apply token balance to invoices
|
|
err = satellite.API.Payments.StripeService.InvoiceApplyTokenBalance(ctx, time.Time{})
|
|
require.NoError(t, err)
|
|
|
|
err = satellite.API.Payments.StripeService.PayInvoices(ctx, time.Time{})
|
|
require.NoError(t, err)
|
|
|
|
iter := satellite.API.Payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
})
|
|
for iter.Next() {
|
|
if iter.Invoice().AmountRemaining == 0 {
|
|
require.Equal(t, stripe.InvoiceStatusPaid, iter.Invoice().Status)
|
|
} else {
|
|
require.Equal(t, stripe.InvoiceStatusOpen, iter.Invoice().Status)
|
|
}
|
|
}
|
|
require.NoError(t, iter.Err())
|
|
balance, err := satellite.DB.Billing().GetBalance(ctx, userID)
|
|
require.NoError(t, err)
|
|
require.False(t, balance.IsNegative())
|
|
require.Zero(t, balance.BaseUnits())
|
|
})
|
|
}
|
|
|
|
func TestService_PayMultipleInvoiceForCustomer(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
|
|
// create user
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice one
|
|
inv1, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
DefaultPaymentMethod: stripe.String(stripe1.MockInvoicesPaySuccess),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice two
|
|
inv2, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
DefaultPaymentMethod: stripe.String(stripe1.MockInvoicesPaySuccess),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// create invoice items
|
|
for _, info := range []struct {
|
|
invID string
|
|
amount int64
|
|
}{
|
|
{inv1.ID, 75}, {inv2.ID, 100},
|
|
} {
|
|
for i := 0; i < 2; i++ {
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(info.amount),
|
|
Currency: stripe.String(string(stripe.CurrencyUSD)),
|
|
Customer: &customer,
|
|
Invoice: stripe.String(info.invID),
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
}
|
|
|
|
finalizeParams := &stripe.InvoiceFinalizeInvoiceParams{Params: stripe.Params{Context: ctx}}
|
|
|
|
// finalize invoice one
|
|
inv1, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv1.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv1.Status)
|
|
|
|
// finalize invoice two
|
|
inv2, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv2.ID, finalizeParams)
|
|
inv2.Metadata = map[string]string{"PaymentMethod": stripe1.MockInvoicesPaySuccess}
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv2.Status)
|
|
|
|
// setup storjscan wallet and user balance
|
|
address, err := blockchain.BytesToAddress(testrand.Bytes(20))
|
|
require.NoError(t, err)
|
|
userID := user.ID
|
|
err = satellite.DB.Wallets().Add(ctx, userID, address)
|
|
require.NoError(t, err)
|
|
// User balance is not enough to cover full amount of both invoices
|
|
_, err = satellite.DB.Billing().Insert(ctx, billing.Transaction{
|
|
UserID: userID,
|
|
Amount: currency.AmountFromBaseUnits(300, currency.USDollars),
|
|
Description: "token payment credit",
|
|
Source: billing.StorjScanSource,
|
|
Status: billing.TransactionStatusCompleted,
|
|
Type: billing.TransactionTypeCredit,
|
|
Metadata: nil,
|
|
Timestamp: time.Now(),
|
|
CreatedAt: time.Now(),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// attempt to pay user invoices, CC should be used to cover remainder after token balance
|
|
err = satellite.API.Payments.StripeService.InvoiceApplyCustomerTokenBalance(ctx, customer)
|
|
require.NoError(t, err)
|
|
err = satellite.API.Payments.StripeService.PayCustomerInvoices(ctx, customer)
|
|
require.NoError(t, err)
|
|
|
|
iter := satellite.API.Payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
})
|
|
var stripeInvoices []*stripe.Invoice
|
|
for iter.Next() {
|
|
stripeInvoices = append(stripeInvoices, iter.Invoice())
|
|
}
|
|
require.Equal(t, 2, len(stripeInvoices))
|
|
require.Equal(t, stripe.InvoiceStatusPaid, stripeInvoices[0].Status)
|
|
require.Equal(t, stripe.InvoiceStatusPaid, stripeInvoices[1].Status)
|
|
require.NoError(t, iter.Err())
|
|
balance, err := satellite.DB.Billing().GetBalance(ctx, userID)
|
|
require.NoError(t, err)
|
|
require.False(t, balance.IsNegative())
|
|
require.Zero(t, balance.BaseUnits())
|
|
|
|
// create another invoice
|
|
inv3, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
DefaultPaymentMethod: stripe.String(stripe1.MockInvoicesPaySuccess),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(100),
|
|
Currency: stripe.String(string(stripe.CurrencyUSD)),
|
|
Customer: &customer,
|
|
Invoice: stripe.String(inv3.ID),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = satellite.API.Payments.StripeService.FinalizeInvoices(ctx)
|
|
require.NoError(t, err)
|
|
|
|
// deactivate user
|
|
status := console.PendingDeletion
|
|
err = satellite.DB.Console().Users().Update(ctx, user.ID, console.UpdateUserRequest{
|
|
Status: &status,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// attempt to pay user invoices should not succeed since the user is now deactivated.
|
|
err = satellite.API.Payments.StripeService.PayCustomerInvoices(ctx, customer)
|
|
require.Error(t, err)
|
|
})
|
|
}
|
|
|
|
func TestFailPendingInvoicePayment(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.ListingLimit = 4
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
tokenBalance := currency.AmountFromBaseUnits(1000, currency.USDollars)
|
|
invoiceBalance := currency.AmountFromBaseUnits(800, currency.USDollars)
|
|
usdCurrency := string(stripe.CurrencyUSD)
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "testuser",
|
|
Email: "user@test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
customer, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// create invoice
|
|
inv, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &customer,
|
|
DefaultPaymentMethod: stripe.String(stripe1.MockInvoicesPaySuccess),
|
|
Metadata: map[string]string{"mock": stripe1.MockInvoicesPayFailure},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(invoiceBalance.BaseUnits()),
|
|
Currency: stripe.String(usdCurrency),
|
|
Customer: &customer,
|
|
Invoice: stripe.String(inv.ID),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// finalize invoice
|
|
err = satellite.API.Payments.StripeService.FinalizeInvoices(ctx)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv.Status)
|
|
|
|
// setup storjscan wallet
|
|
address, err := blockchain.BytesToAddress(testrand.Bytes(20))
|
|
require.NoError(t, err)
|
|
userID := user.ID
|
|
err = satellite.DB.Wallets().Add(ctx, userID, address)
|
|
require.NoError(t, err)
|
|
_, err = satellite.DB.Billing().Insert(ctx, billing.Transaction{
|
|
UserID: userID,
|
|
Amount: tokenBalance,
|
|
Description: "token payment credit",
|
|
Source: billing.StorjScanSource,
|
|
Status: billing.TransactionStatusCompleted,
|
|
Type: billing.TransactionTypeCredit,
|
|
Metadata: nil,
|
|
Timestamp: time.Now(),
|
|
CreatedAt: time.Now(),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// run apply token balance to see if there are no unexpected errors
|
|
err = payments.StripeService.InvoiceApplyTokenBalance(ctx, time.Time{})
|
|
require.Error(t, err)
|
|
|
|
iter := satellite.API.Payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
})
|
|
iter.Next()
|
|
require.Equal(t, stripe.InvoiceStatusOpen, iter.Invoice().Status)
|
|
|
|
// balance is in USDollars Micro, so it needs to be converted before comparison
|
|
balance, err := satellite.DB.Billing().GetBalance(ctx, userID)
|
|
balance = currency.AmountFromDecimal(balance.AsDecimal().Truncate(2), currency.USDollars)
|
|
require.NoError(t, err)
|
|
|
|
// verify user balance wasn't changed
|
|
require.Equal(t, tokenBalance.BaseUnits(), balance.BaseUnits())
|
|
})
|
|
}
|
|
|
|
func TestService_GenerateInvoice(t *testing.T) {
|
|
for _, testCase := range []struct {
|
|
desc string
|
|
skipEmptyInvoices bool
|
|
addProjectUsage bool
|
|
expectInvoice bool
|
|
}{
|
|
{
|
|
desc: "invoice with non-empty usage created if not configured to skip",
|
|
skipEmptyInvoices: false,
|
|
addProjectUsage: true,
|
|
expectInvoice: true,
|
|
},
|
|
{
|
|
desc: "invoice with non-empty usage created if configured to skip",
|
|
skipEmptyInvoices: true,
|
|
addProjectUsage: true,
|
|
expectInvoice: true,
|
|
},
|
|
{
|
|
desc: "invoice with empty usage created if not configured to skip",
|
|
skipEmptyInvoices: false,
|
|
addProjectUsage: false,
|
|
expectInvoice: true,
|
|
},
|
|
{
|
|
desc: "invoice with empty usage not created if configured to skip",
|
|
skipEmptyInvoices: true,
|
|
addProjectUsage: false,
|
|
expectInvoice: false,
|
|
},
|
|
} {
|
|
t.Run(testCase.desc, func(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.StripeCoinPayments.SkipEmptyInvoices = testCase.skipEmptyInvoices
|
|
config.Payments.StripeCoinPayments.StripeFreeTierCouponID = stripe1.MockCouponID1
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
payments := satellite.API.Payments
|
|
|
|
// pick a specific date so that it doesn't fail if it's the last day of the month
|
|
// keep month + 1 because user needs to be created before calculation
|
|
period := time.Date(time.Now().Year(), time.Now().Month()+1, 20, 0, 0, 0, 0, time.UTC)
|
|
|
|
payments.StripeService.SetNow(func() time.Time {
|
|
return time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
})
|
|
start := time.Date(period.Year(), period.Month(), 1, 0, 0, 0, 0, time.UTC)
|
|
end := time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
|
|
user, err := satellite.AddUser(ctx, console.CreateUser{
|
|
FullName: "Test User",
|
|
Email: "test@mail.test",
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
|
|
proj, err := satellite.AddProject(ctx, user.ID, "testproject")
|
|
require.NoError(t, err)
|
|
|
|
// optionally add some usage for the project
|
|
if testCase.addProjectUsage {
|
|
generateProjectStorage(ctx, t, satellite.DB,
|
|
proj.ID,
|
|
period,
|
|
period.Add(24*time.Hour),
|
|
100000,
|
|
200000,
|
|
99)
|
|
}
|
|
|
|
require.NoError(t, payments.StripeService.GenerateInvoices(ctx, start))
|
|
|
|
// ensure project record was generated
|
|
err = satellite.DB.StripeCoinPayments().ProjectRecords().Check(ctx, proj.ID, start, end)
|
|
require.ErrorIs(t, stripe1.ErrProjectRecordExists, err)
|
|
|
|
rec, err := satellite.DB.StripeCoinPayments().ProjectRecords().Get(ctx, proj.ID, start, end)
|
|
require.NotNil(t, rec)
|
|
require.NoError(t, err)
|
|
|
|
// validate generated invoices
|
|
cusID, err := satellite.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
invoice, hasInvoice := getCustomerInvoice(ctx, payments.StripeClient, cusID)
|
|
invoiceItems := getCustomerInvoiceItems(ctx, payments.StripeClient, cusID)
|
|
|
|
// If invoicing empty usage invoices was skipped, then we don't
|
|
// expect an invoice or invoice items.
|
|
if !testCase.expectInvoice {
|
|
require.False(t, hasInvoice, "expected no invoice but got one")
|
|
require.Nil(t, invoice, "expected no invoice but got one")
|
|
require.Empty(t, invoiceItems, "not expecting any invoice items")
|
|
return
|
|
}
|
|
|
|
// Otherwise, we expect one or more line items that have been
|
|
// associated with the newly created invoice.
|
|
require.True(t, hasInvoice, "expected invoice but did not get one")
|
|
require.NotNil(t, invoice, "expected invoice but did not get one")
|
|
require.NotZero(t, len(invoiceItems), "expecting one or more invoice items")
|
|
for _, item := range invoiceItems {
|
|
require.Contains(t, item.Metadata, "projectID")
|
|
require.Equal(t, item.Metadata["projectID"], proj.ID.String())
|
|
require.NotNil(t, item.Invoice)
|
|
require.Equal(t, invoice.ID, item.Invoice.ID)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func getCustomerInvoice(ctx context.Context, stripeClient stripe1.Client, cusID string) (*stripe.Invoice, bool) {
|
|
iter := stripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
Customer: &cusID,
|
|
})
|
|
if iter.Next() {
|
|
return iter.Invoice(), true
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
func getCustomerInvoiceItems(ctx context.Context, stripeClient stripe1.Client, cusID string) (items []*stripe.InvoiceItem) {
|
|
iter := stripeClient.InvoiceItems().List(&stripe.InvoiceItemListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
Customer: &cusID,
|
|
})
|
|
for iter.Next() {
|
|
items = append(items, iter.InvoiceItem())
|
|
}
|
|
return items
|
|
}
|
|
|
|
func generateProjectStorage(ctx context.Context, tb testing.TB, db satellite.DB, projectID uuid.UUID, start, end time.Time, egress, totalBytes, totalSegments int64) {
|
|
// generate egress
|
|
err := db.Orders().UpdateBucketBandwidthSettle(ctx, projectID, []byte("testbucket"),
|
|
pb.PieceAction_GET, egress, 0, start)
|
|
require.NoError(tb, err)
|
|
|
|
// generate storage
|
|
tallies := map[metabase.BucketLocation]*accounting.BucketTally{
|
|
{}: {
|
|
BucketLocation: metabase.BucketLocation{
|
|
ProjectID: projectID,
|
|
BucketName: "testbucket",
|
|
},
|
|
TotalBytes: totalBytes,
|
|
TotalSegments: totalSegments,
|
|
},
|
|
}
|
|
err = db.ProjectAccounting().SaveTallies(ctx, start, tallies)
|
|
require.NoError(tb, err)
|
|
|
|
err = db.ProjectAccounting().SaveTallies(ctx, end, tallies)
|
|
require.NoError(tb, err)
|
|
}
|
|
|
|
func TestProjectUsagePrice(t *testing.T) {
|
|
var (
|
|
defaultPrice = paymentsconfig.ProjectUsagePrice{
|
|
StorageTB: "1",
|
|
EgressTB: "2",
|
|
Segment: "3",
|
|
}
|
|
partnerName = "partner"
|
|
partnerPrice = paymentsconfig.ProjectUsagePrice{
|
|
StorageTB: "4",
|
|
EgressTB: "5",
|
|
Segment: "6",
|
|
}
|
|
)
|
|
defaultModel, err := defaultPrice.ToModel()
|
|
require.NoError(t, err)
|
|
partnerModel, err := partnerPrice.ToModel()
|
|
require.NoError(t, err)
|
|
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
Reconfigure: testplanet.Reconfigure{
|
|
Satellite: func(log *zap.Logger, index int, config *satellite.Config) {
|
|
config.Payments.UsagePrice = defaultPrice
|
|
config.Payments.UsagePriceOverrides.SetMap(map[string]paymentsconfig.ProjectUsagePrice{
|
|
partnerName: partnerPrice,
|
|
})
|
|
},
|
|
},
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
sat := planet.Satellites[0]
|
|
|
|
// pick a specific date so that it doesn't fail if it's the last day of the month
|
|
// keep month + 1 because user needs to be created before calculation
|
|
period := time.Date(time.Now().Year(), time.Now().Month()+1, 20, 0, 0, 0, 0, time.UTC)
|
|
sat.API.Payments.StripeService.SetNow(func() time.Time {
|
|
return time.Date(period.Year(), period.Month()+1, 1, 0, 0, 0, 0, time.UTC)
|
|
})
|
|
|
|
for i, tt := range []struct {
|
|
name string
|
|
userAgent []byte
|
|
expectedPrice payments.ProjectUsagePriceModel
|
|
}{
|
|
{"default pricing", nil, defaultModel},
|
|
{"default pricing - user agent is not valid partner name", []byte("invalid/v0.0"), defaultModel},
|
|
{"partner pricing - user agent is partner name", []byte(partnerName), partnerModel},
|
|
{"partner pricing - user agent prefixed with partner name", []byte(partnerName + " invalid/v0.0"), partnerModel},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
user, err := sat.AddUser(ctx, console.CreateUser{
|
|
FullName: "Test User",
|
|
Email: fmt.Sprintf("user%d@mail.test", i),
|
|
UserAgent: tt.userAgent,
|
|
}, 1)
|
|
require.NoError(t, err)
|
|
|
|
project, err := sat.AddProject(ctx, user.ID, "testproject")
|
|
require.NoError(t, err)
|
|
|
|
bucket, err := sat.DB.Buckets().CreateBucket(ctx, buckets.Bucket{
|
|
ID: testrand.UUID(),
|
|
Name: testrand.BucketName(),
|
|
ProjectID: project.ID,
|
|
UserAgent: tt.userAgent,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = sat.DB.Orders().UpdateBucketBandwidthSettle(ctx, project.ID, []byte(bucket.Name),
|
|
pb.PieceAction_GET, memory.TB.Int64(), 0, period)
|
|
require.NoError(t, err)
|
|
|
|
err = sat.API.Payments.StripeService.PrepareInvoiceProjectRecords(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
err = sat.API.Payments.StripeService.InvoiceApplyProjectRecords(ctx, period)
|
|
require.NoError(t, err)
|
|
|
|
cusID, err := sat.DB.StripeCoinPayments().Customers().GetCustomerID(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
items := getCustomerInvoiceItems(ctx, sat.API.Payments.StripeClient, cusID)
|
|
require.Len(t, items, 3)
|
|
sort.Slice(items, func(i, j int) bool {
|
|
return items[i].Description < items[j].Description
|
|
})
|
|
egress, _ := tt.expectedPrice.EgressMBCents.Float64()
|
|
require.Equal(t, egress, items[0].UnitAmountDecimal)
|
|
segment, _ := tt.expectedPrice.SegmentMonthCents.Float64()
|
|
require.Equal(t, segment, items[1].UnitAmountDecimal)
|
|
storage, _ := tt.expectedPrice.StorageMBMonthCents.Float64()
|
|
require.Equal(t, storage, items[2].UnitAmountDecimal)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestPayInvoicesSkipDue(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
|
|
cus1 := "cus_1"
|
|
cus2 := "cus_2"
|
|
due := time.Now().Add(14 * 24 * time.Hour).Unix()
|
|
|
|
for _, cusID := range []string{cus1, cus2} {
|
|
_, err := satellite.API.Payments.StripeClient.InvoiceItems().New(&stripe.InvoiceItemParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Amount: stripe.Int64(100),
|
|
Currency: stripe.String(string(stripe.CurrencyUSD)),
|
|
Customer: stripe.String(cusID),
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
inv, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &cus1,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
finalizeParams := &stripe.InvoiceFinalizeInvoiceParams{Params: stripe.Params{Context: ctx}}
|
|
|
|
inv, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(inv.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, inv.Status)
|
|
|
|
invWithDue, err := satellite.API.Payments.StripeClient.Invoices().New(&stripe.InvoiceParams{
|
|
Params: stripe.Params{Context: ctx},
|
|
Customer: &cus2,
|
|
DueDate: &due,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
invWithDue, err = satellite.API.Payments.StripeClient.Invoices().FinalizeInvoice(invWithDue.ID, finalizeParams)
|
|
require.NoError(t, err)
|
|
require.Equal(t, stripe.InvoiceStatusOpen, invWithDue.Status)
|
|
|
|
err = satellite.API.Payments.StripeService.PayInvoices(ctx, time.Time{})
|
|
require.NoError(t, err)
|
|
|
|
iter := satellite.API.Payments.StripeClient.Invoices().List(&stripe.InvoiceListParams{
|
|
ListParams: stripe.ListParams{Context: ctx},
|
|
})
|
|
for iter.Next() {
|
|
i := iter.Invoice()
|
|
if i.ID == inv.ID {
|
|
require.Equal(t, stripe.InvoiceStatusPaid, i.Status)
|
|
}
|
|
// when due date is set invoice should not be paid
|
|
if i.ID == invWithDue.ID {
|
|
require.Equal(t, stripe.InvoiceStatusOpen, i.Status)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRemoveExpiredPackageCredit(t *testing.T) {
|
|
testplanet.Run(t, testplanet.Config{
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 4,
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
satellite := planet.Satellites[0]
|
|
p := satellite.API.Payments
|
|
u0 := planet.Uplinks[0].Projects[0].Owner.ID
|
|
u1 := planet.Uplinks[1].Projects[0].Owner.ID
|
|
u2 := planet.Uplinks[2].Projects[0].Owner.ID
|
|
u3 := planet.Uplinks[3].Projects[0].Owner.ID
|
|
|
|
credit := int64(1000)
|
|
pkgDesc := "test package plan"
|
|
now := time.Now()
|
|
expiredPurchase := now.AddDate(-1, -1, 0)
|
|
|
|
removeExpiredCredit := func(u uuid.UUID, expectAlert bool, purchaseTime *time.Time) {
|
|
require.NoError(t, p.Accounts.UpdatePackage(ctx, u, &pkgDesc, purchaseTime))
|
|
cPage, err := satellite.API.DB.StripeCoinPayments().Customers().List(ctx, uuid.UUID{}, 10, time.Now().Add(1*time.Hour))
|
|
require.NoError(t, err)
|
|
var c stripe1.Customer
|
|
for _, cus := range cPage.Customers {
|
|
if cus.UserID == u {
|
|
c = cus
|
|
}
|
|
}
|
|
|
|
alertSent, err := p.StripeService.RemoveExpiredPackageCredit(ctx, stripe1.Customer{
|
|
ID: c.ID,
|
|
UserID: c.UserID,
|
|
PackagePlan: c.PackagePlan,
|
|
PackagePurchasedAt: c.PackagePurchasedAt,
|
|
})
|
|
require.NoError(t, err)
|
|
if expectAlert {
|
|
require.True(t, alertSent)
|
|
} else {
|
|
require.False(t, alertSent)
|
|
}
|
|
}
|
|
|
|
checkCreditAndPackage := func(u uuid.UUID, expectedBalance int64, expectNilPackage bool) {
|
|
b, err := p.Accounts.Balances().Get(ctx, u)
|
|
require.NoError(t, err)
|
|
require.Equal(t, decimal.NewFromInt(expectedBalance), b.Credits)
|
|
|
|
dbPkgInfo, dbPurchaseTime, err := p.StripeService.Accounts().GetPackageInfo(ctx, u)
|
|
require.NoError(t, err)
|
|
if expectNilPackage {
|
|
require.Nil(t, dbPkgInfo)
|
|
require.Nil(t, dbPurchaseTime)
|
|
} else {
|
|
require.NotNil(t, dbPkgInfo)
|
|
require.NotNil(t, dbPurchaseTime)
|
|
}
|
|
}
|
|
|
|
t.Run("nil package plan returns safely", func(t *testing.T) {
|
|
_, err := p.StripeService.RemoveExpiredPackageCredit(ctx, stripe1.Customer{
|
|
ID: "test-customer-ID",
|
|
UserID: testrand.UUID(),
|
|
PackagePlan: nil,
|
|
PackagePurchasedAt: &now,
|
|
})
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("nil package purchase time returns safely", func(t *testing.T) {
|
|
_, err := p.StripeService.RemoveExpiredPackageCredit(ctx, stripe1.Customer{
|
|
ID: "test-customer-ID",
|
|
UserID: testrand.UUID(),
|
|
PackagePlan: new(string),
|
|
PackagePurchasedAt: nil,
|
|
})
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("package not expired retains credit", func(t *testing.T) {
|
|
b, err := p.Accounts.Balances().ApplyCredit(ctx, u3, credit, pkgDesc)
|
|
require.NoError(t, err)
|
|
require.Equal(t, decimal.NewFromInt(credit), b.Credits)
|
|
|
|
removeExpiredCredit(u3, false, &now)
|
|
checkCreditAndPackage(u3, credit, false)
|
|
})
|
|
|
|
t.Run("used all credit", func(t *testing.T) {
|
|
b, err := p.Accounts.Balances().ApplyCredit(ctx, u0, credit, pkgDesc)
|
|
require.NoError(t, err)
|
|
require.Equal(t, decimal.NewFromInt(credit), b.Credits)
|
|
|
|
// remove credit as if they used it all
|
|
b, err = p.Accounts.Balances().ApplyCredit(ctx, u0, -credit, pkgDesc)
|
|
require.NoError(t, err)
|
|
require.Equal(t, decimal.NewFromInt(0), b.Credits)
|
|
|
|
removeExpiredCredit(u0, false, &expiredPurchase)
|
|
checkCreditAndPackage(u0, 0, true)
|
|
})
|
|
|
|
t.Run("has remaining credit but no credit source other than package", func(t *testing.T) {
|
|
b, err := p.Accounts.Balances().ApplyCredit(ctx, u1, credit, pkgDesc)
|
|
require.NoError(t, err)
|
|
require.Equal(t, decimal.NewFromInt(credit), b.Credits)
|
|
|
|
// remove some credit, but not all, as if it were used
|
|
toRemove := credit / 2
|
|
remaining := credit - toRemove
|
|
b, err = p.Accounts.Balances().ApplyCredit(ctx, u1, -toRemove, pkgDesc)
|
|
require.NoError(t, err)
|
|
require.Equal(t, decimal.NewFromInt(remaining), b.Credits)
|
|
|
|
removeExpiredCredit(u1, false, &expiredPurchase)
|
|
checkCreditAndPackage(u1, 0, true)
|
|
})
|
|
|
|
t.Run("has additional credit source", func(t *testing.T) {
|
|
b, err := p.Accounts.Balances().ApplyCredit(ctx, u2, credit, pkgDesc)
|
|
require.NoError(t, err)
|
|
require.Equal(t, decimal.NewFromInt(credit), b.Credits)
|
|
|
|
// give additional credit
|
|
additional := int64(2000)
|
|
b, err = p.Accounts.Balances().ApplyCredit(ctx, u2, additional, "additional credit")
|
|
require.NoError(t, err)
|
|
require.Equal(t, decimal.NewFromInt(credit+additional), b.Credits)
|
|
|
|
removeExpiredCredit(u2, true, &expiredPurchase)
|
|
checkCreditAndPackage(u2, credit+additional, false)
|
|
})
|
|
})
|
|
}
|