694 lines
19 KiB
Go
694 lines
19 KiB
Go
// Copyright (C) 2020 Storj Labs, Inc.
|
|
// See LICENSE for copying information.
|
|
|
|
package payouts_test
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/zap/zaptest"
|
|
|
|
"storj.io/common/testcontext"
|
|
"storj.io/common/testrand"
|
|
"storj.io/storj/storagenode"
|
|
"storj.io/storj/storagenode/payouts"
|
|
"storj.io/storj/storagenode/storagenodedb/storagenodedbtest"
|
|
)
|
|
|
|
func TestHeldAmountDB(t *testing.T) {
|
|
storagenodedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db storagenode.DB) {
|
|
payout := db.Payout()
|
|
satelliteID := testrand.NodeID()
|
|
period := "2020-01"
|
|
paystub := payouts.PayStub{
|
|
SatelliteID: satelliteID,
|
|
Period: "2020-01",
|
|
Created: time.Now().UTC(),
|
|
Codes: "1",
|
|
UsageAtRest: 1,
|
|
UsageGet: 2,
|
|
UsagePut: 3,
|
|
UsageGetRepair: 4,
|
|
UsagePutRepair: 5,
|
|
UsageGetAudit: 6,
|
|
CompAtRest: 7,
|
|
CompGet: 8,
|
|
CompPut: 9,
|
|
CompGetRepair: 10,
|
|
CompPutRepair: 11,
|
|
CompGetAudit: 12,
|
|
SurgePercent: 13,
|
|
Held: 14,
|
|
Owed: 15,
|
|
Disposed: 16,
|
|
}
|
|
paystub2 := paystub
|
|
paystub2.Period = "2020-02"
|
|
paystub2.Created = paystub.Created.Add(time.Hour * 24 * 30)
|
|
|
|
t.Run("Test StorePayStub", func(t *testing.T) {
|
|
err := payout.StorePayStub(ctx, paystub)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
payment := payouts.Payment{
|
|
SatelliteID: satelliteID,
|
|
Period: period,
|
|
Receipt: "test",
|
|
}
|
|
|
|
t.Run("Test GetPayStub", func(t *testing.T) {
|
|
err := payout.StorePayment(ctx, payment)
|
|
assert.NoError(t, err)
|
|
|
|
stub, err := payout.GetPayStub(ctx, satelliteID, period)
|
|
assert.NoError(t, err)
|
|
receipt, err := payout.GetReceipt(ctx, satelliteID, period)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, stub.Period, paystub.Period)
|
|
assert.Equal(t, stub.Created, paystub.Created)
|
|
assert.Equal(t, stub.Codes, paystub.Codes)
|
|
assert.Equal(t, stub.CompAtRest, paystub.CompAtRest)
|
|
assert.Equal(t, stub.CompGet, paystub.CompGet)
|
|
assert.Equal(t, stub.CompGetAudit, paystub.CompGetAudit)
|
|
assert.Equal(t, stub.CompGetRepair, paystub.CompGetRepair)
|
|
assert.Equal(t, stub.CompPut, paystub.CompPut)
|
|
assert.Equal(t, stub.CompPutRepair, paystub.CompPutRepair)
|
|
assert.Equal(t, stub.Disposed, paystub.Disposed)
|
|
assert.Equal(t, stub.Held, paystub.Held)
|
|
assert.Equal(t, stub.Owed, paystub.Owed)
|
|
assert.Equal(t, stub.Paid, paystub.Paid)
|
|
assert.Equal(t, stub.SatelliteID, paystub.SatelliteID)
|
|
assert.Equal(t, stub.SurgePercent, paystub.SurgePercent)
|
|
assert.Equal(t, stub.UsageAtRest, paystub.UsageAtRest)
|
|
assert.Equal(t, stub.UsageGet, paystub.UsageGet)
|
|
assert.Equal(t, stub.UsageGetAudit, paystub.UsageGetAudit)
|
|
assert.Equal(t, stub.UsageGetRepair, paystub.UsageGetRepair)
|
|
assert.Equal(t, stub.UsagePut, paystub.UsagePut)
|
|
assert.Equal(t, stub.UsagePutRepair, paystub.UsagePutRepair)
|
|
assert.Equal(t, receipt, payment.Receipt)
|
|
|
|
stub, err = payout.GetPayStub(ctx, satelliteID, "")
|
|
assert.Error(t, err)
|
|
assert.Equal(t, true, payouts.ErrNoPayStubForPeriod.Has(err))
|
|
assert.Nil(t, stub)
|
|
assert.NotNil(t, receipt)
|
|
receipt, err = payout.GetReceipt(ctx, satelliteID, "")
|
|
assert.Error(t, err)
|
|
assert.Equal(t, true, payouts.ErrNoPayStubForPeriod.Has(err))
|
|
|
|
stub, err = payout.GetPayStub(ctx, testrand.NodeID(), period)
|
|
assert.Error(t, err)
|
|
assert.Equal(t, true, payouts.ErrNoPayStubForPeriod.Has(err))
|
|
assert.Nil(t, stub)
|
|
assert.NotNil(t, receipt)
|
|
})
|
|
|
|
t.Run("Test AllPayStubs", func(t *testing.T) {
|
|
stubs, err := payout.AllPayStubs(ctx, period)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, stubs)
|
|
assert.Equal(t, 1, len(stubs))
|
|
assert.Equal(t, stubs[0].Period, paystub.Period)
|
|
assert.Equal(t, stubs[0].Created, paystub.Created)
|
|
assert.Equal(t, stubs[0].Codes, paystub.Codes)
|
|
assert.Equal(t, stubs[0].CompAtRest, paystub.CompAtRest)
|
|
assert.Equal(t, stubs[0].CompGet, paystub.CompGet)
|
|
assert.Equal(t, stubs[0].CompGetAudit, paystub.CompGetAudit)
|
|
assert.Equal(t, stubs[0].CompGetRepair, paystub.CompGetRepair)
|
|
assert.Equal(t, stubs[0].CompPut, paystub.CompPut)
|
|
assert.Equal(t, stubs[0].CompPutRepair, paystub.CompPutRepair)
|
|
assert.Equal(t, stubs[0].Disposed, paystub.Disposed)
|
|
assert.Equal(t, stubs[0].Held, paystub.Held)
|
|
assert.Equal(t, stubs[0].Owed, paystub.Owed)
|
|
assert.Equal(t, stubs[0].Paid, paystub.Paid)
|
|
assert.Equal(t, stubs[0].SatelliteID, paystub.SatelliteID)
|
|
assert.Equal(t, stubs[0].SurgePercent, paystub.SurgePercent)
|
|
assert.Equal(t, stubs[0].UsageAtRest, paystub.UsageAtRest)
|
|
assert.Equal(t, stubs[0].UsageGet, paystub.UsageGet)
|
|
assert.Equal(t, stubs[0].UsageGetAudit, paystub.UsageGetAudit)
|
|
assert.Equal(t, stubs[0].UsageGetRepair, paystub.UsageGetRepair)
|
|
assert.Equal(t, stubs[0].UsagePut, paystub.UsagePut)
|
|
assert.Equal(t, stubs[0].UsagePutRepair, paystub.UsagePutRepair)
|
|
|
|
stubs, err = payout.AllPayStubs(ctx, "")
|
|
assert.Equal(t, len(stubs), 0)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
payment = payouts.Payment{
|
|
ID: 1,
|
|
Created: time.Now().UTC(),
|
|
SatelliteID: satelliteID,
|
|
Period: period,
|
|
Amount: 228,
|
|
Receipt: "receipt",
|
|
Notes: "notes",
|
|
}
|
|
|
|
t.Run("Test StorePayment", func(t *testing.T) {
|
|
err := payout.StorePayment(ctx, payment)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
t.Run("Test SatellitesHeldbackHistory", func(t *testing.T) {
|
|
heldback, err := payout.SatellitesHeldbackHistory(ctx, satelliteID)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, heldback[0].Amount, paystub.Held)
|
|
assert.Equal(t, heldback[0].Period, paystub.Period)
|
|
})
|
|
|
|
t.Run("Test SatellitePeriods", func(t *testing.T) {
|
|
periods, err := payout.SatellitePeriods(ctx, paystub.SatelliteID)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, periods)
|
|
assert.Equal(t, 1, len(periods))
|
|
assert.Equal(t, paystub.Period, periods[0])
|
|
|
|
err = payout.StorePayStub(ctx, paystub2)
|
|
require.NoError(t, err)
|
|
|
|
periods, err = payout.SatellitePeriods(ctx, paystub.SatelliteID)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, periods)
|
|
assert.Equal(t, 2, len(periods))
|
|
assert.Equal(t, paystub.Period, periods[0])
|
|
assert.Equal(t, paystub2.Period, periods[1])
|
|
})
|
|
|
|
t.Run("Test AllPeriods", func(t *testing.T) {
|
|
periods, err := payout.AllPeriods(ctx)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, periods)
|
|
assert.Equal(t, 2, len(periods))
|
|
assert.Equal(t, paystub.Period, periods[0])
|
|
assert.Equal(t, paystub2.Period, periods[1])
|
|
|
|
paystub3 := paystub2
|
|
paystub3.SatelliteID = testrand.NodeID()
|
|
paystub3.Period = "2020-03"
|
|
paystub3.Created = paystub2.Created.Add(time.Hour * 24 * 30)
|
|
|
|
err = payout.StorePayStub(ctx, paystub3)
|
|
require.NoError(t, err)
|
|
|
|
periods, err = payout.AllPeriods(ctx)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, periods)
|
|
assert.Equal(t, 3, len(periods))
|
|
assert.Equal(t, paystub.Period, periods[0])
|
|
assert.Equal(t, paystub2.Period, periods[1])
|
|
assert.Equal(t, paystub3.Period, periods[2])
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestSatellitePayStubPeriodCached(t *testing.T) {
|
|
storagenodedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db storagenode.DB) {
|
|
heldAmountDB := db.Payout()
|
|
reputationDB := db.Reputation()
|
|
satellitesDB := db.Satellites()
|
|
log := zaptest.NewLogger(t)
|
|
service, err := payouts.NewService(log, heldAmountDB, reputationDB, satellitesDB)
|
|
require.NoError(t, err)
|
|
|
|
payStub := payouts.PayStub{
|
|
SatelliteID: testrand.NodeID(),
|
|
Created: time.Now().UTC(),
|
|
Codes: "code",
|
|
UsageAtRest: 1,
|
|
UsageGet: 2,
|
|
UsagePut: 3,
|
|
UsageGetRepair: 4,
|
|
UsagePutRepair: 5,
|
|
UsageGetAudit: 6,
|
|
CompAtRest: 7,
|
|
CompGet: 8,
|
|
CompPut: 9,
|
|
CompGetRepair: 10,
|
|
CompPutRepair: 11,
|
|
CompGetAudit: 12,
|
|
SurgePercent: 13,
|
|
Held: 14,
|
|
Owed: 15,
|
|
Disposed: 16,
|
|
Paid: 17,
|
|
}
|
|
|
|
for i := 1; i < 4; i++ {
|
|
payStub.Period = fmt.Sprintf("2020-0%d", i)
|
|
err := heldAmountDB.StorePayStub(ctx, payStub)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
payStubs, err := service.SatellitePayStubPeriod(ctx, payStub.SatelliteID, "2020-01", "2020-03")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 3, len(payStubs))
|
|
|
|
payStubs, err = service.SatellitePayStubPeriod(ctx, payStub.SatelliteID, "2019-01", "2021-03")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 3, len(payStubs))
|
|
|
|
payStubs, err = service.SatellitePayStubPeriod(ctx, payStub.SatelliteID, "2019-01", "2020-01")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(payStubs))
|
|
})
|
|
}
|
|
|
|
func TestAllPayStubPeriodCached(t *testing.T) {
|
|
storagenodedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db storagenode.DB) {
|
|
heldAmountDB := db.Payout()
|
|
reputationDB := db.Reputation()
|
|
satellitesDB := db.Satellites()
|
|
log := zaptest.NewLogger(t)
|
|
service, err := payouts.NewService(log, heldAmountDB, reputationDB, satellitesDB)
|
|
require.NoError(t, err)
|
|
|
|
payStub := payouts.PayStub{
|
|
SatelliteID: testrand.NodeID(),
|
|
Created: time.Now().UTC(),
|
|
Codes: "code",
|
|
UsageAtRest: 1,
|
|
UsageGet: 2,
|
|
UsagePut: 3,
|
|
UsageGetRepair: 4,
|
|
UsagePutRepair: 5,
|
|
UsageGetAudit: 6,
|
|
CompAtRest: 7,
|
|
CompGet: 8,
|
|
CompPut: 9,
|
|
CompGetRepair: 10,
|
|
CompPutRepair: 11,
|
|
CompGetAudit: 12,
|
|
SurgePercent: 13,
|
|
Held: 14,
|
|
Owed: 15,
|
|
Disposed: 16,
|
|
Paid: 17,
|
|
}
|
|
|
|
for i := 1; i < 4; i++ {
|
|
payStub.SatelliteID[0] += byte(i)
|
|
for j := 1; j < 4; j++ {
|
|
payStub.Period = fmt.Sprintf("2020-0%d", j)
|
|
err := heldAmountDB.StorePayStub(ctx, payStub)
|
|
require.NoError(t, err)
|
|
}
|
|
}
|
|
|
|
payStubs, err := service.AllPayStubsPeriod(ctx, "2020-01", "2020-03")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 9, len(payStubs))
|
|
|
|
payStubs, err = service.AllPayStubsPeriod(ctx, "2019-01", "2021-03")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 9, len(payStubs))
|
|
|
|
payStubs, err = service.AllPayStubsPeriod(ctx, "2019-01", "2020-01")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 3, len(payStubs))
|
|
|
|
payStubs, err = service.AllPayStubsPeriod(ctx, "2019-01", "2019-01")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 0, len(payStubs))
|
|
})
|
|
}
|
|
|
|
func TestPayouts(t *testing.T) {
|
|
storagenodedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db storagenode.DB) {
|
|
payout := db.Payout()
|
|
t.Run("Test SatelliteIDs", func(t *testing.T) {
|
|
id1 := testrand.NodeID()
|
|
id2 := testrand.NodeID()
|
|
id3 := testrand.NodeID()
|
|
err := payout.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: id1,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: id1,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: id2,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: id3,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: id3,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: id2,
|
|
})
|
|
require.NoError(t, err)
|
|
listIDs, err := payout.GetPayingSatellitesIDs(ctx)
|
|
require.Equal(t, len(listIDs), 3)
|
|
require.NoError(t, err)
|
|
})
|
|
t.Run("Test GetSatelliteEarned", func(t *testing.T) {
|
|
id1 := testrand.NodeID()
|
|
id2 := testrand.NodeID()
|
|
id3 := testrand.NodeID()
|
|
err := payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-11",
|
|
SatelliteID: id1,
|
|
CompGet: 11,
|
|
CompAtRest: 11,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-12",
|
|
SatelliteID: id1,
|
|
CompGet: 22,
|
|
CompAtRest: 22,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-11",
|
|
SatelliteID: id2,
|
|
CompGet: 33,
|
|
CompAtRest: 33,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-10",
|
|
SatelliteID: id3,
|
|
CompGet: 44,
|
|
CompAtRest: 44,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-11",
|
|
SatelliteID: id3,
|
|
CompGet: 55,
|
|
CompAtRest: 55,
|
|
})
|
|
require.NoError(t, err)
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-10",
|
|
SatelliteID: id2,
|
|
CompGet: 66,
|
|
CompAtRest: 66,
|
|
})
|
|
require.NoError(t, err)
|
|
satellite1Earned, err := payout.GetEarnedAtSatellite(ctx, id1)
|
|
require.Equal(t, int(satellite1Earned), 66)
|
|
require.NoError(t, err)
|
|
satellite2Earned, err := payout.GetEarnedAtSatellite(ctx, id2)
|
|
require.Equal(t, int(satellite2Earned), 198)
|
|
require.NoError(t, err)
|
|
satellite3Earned, err := payout.GetEarnedAtSatellite(ctx, id3)
|
|
require.Equal(t, int(satellite3Earned), 198)
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("Test GetSatelliteSummary", func(t *testing.T) {
|
|
id1 := testrand.NodeID()
|
|
id2 := testrand.NodeID()
|
|
|
|
err := payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-11",
|
|
SatelliteID: id1,
|
|
Paid: 11,
|
|
Held: 11,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-10",
|
|
SatelliteID: id1,
|
|
Paid: 22,
|
|
Held: 22,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-11",
|
|
SatelliteID: id2,
|
|
Paid: 33,
|
|
Held: 33,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payout.StorePayStub(ctx, payouts.PayStub{
|
|
Period: "2020-10",
|
|
SatelliteID: id2,
|
|
Paid: 66,
|
|
Held: 66,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
paid, held, err := payout.GetSatellitePeriodSummary(ctx, id1, "2020-10")
|
|
require.NoError(t, err)
|
|
require.Equal(t, paid, int64(22))
|
|
require.Equal(t, held, int64(22))
|
|
|
|
paid2, held2, err := payout.GetSatelliteSummary(ctx, id2)
|
|
require.NoError(t, err)
|
|
require.Equal(t, paid2, int64(99))
|
|
require.Equal(t, held2, int64(99))
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestUndistributed(t *testing.T) {
|
|
storagenodedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db storagenode.DB) {
|
|
payoutdb := db.Payout()
|
|
satelliteID1 := testrand.NodeID()
|
|
satelliteID2 := testrand.NodeID()
|
|
|
|
t.Run("empty db no error", func(t *testing.T) {
|
|
undistributed, err := payoutdb.GetUndistributed(ctx)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, undistributed, 0)
|
|
})
|
|
|
|
t.Run("few paystubs with different satellites", func(t *testing.T) {
|
|
err := payoutdb.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: satelliteID2,
|
|
Period: "2020-01",
|
|
Distributed: 150,
|
|
Paid: 250,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payoutdb.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: satelliteID2,
|
|
Period: "2020-02",
|
|
Distributed: 250,
|
|
Paid: 350,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payoutdb.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: satelliteID1,
|
|
Period: "2020-01",
|
|
Distributed: 100,
|
|
Paid: 300,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payoutdb.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: satelliteID1,
|
|
Period: "2020-02",
|
|
Distributed: 400,
|
|
Paid: 500,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
undistributed, err := payoutdb.GetUndistributed(ctx)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, undistributed, 500)
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestSummedPaystubs(t *testing.T) {
|
|
storagenodedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db storagenode.DB) {
|
|
payoutdb := db.Payout()
|
|
satelliteID1 := testrand.NodeID()
|
|
satelliteID2 := testrand.NodeID()
|
|
|
|
err := payoutdb.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: satelliteID2,
|
|
Period: "2020-01",
|
|
Distributed: 150,
|
|
Paid: 250,
|
|
Disposed: 100,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payoutdb.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: satelliteID2,
|
|
Period: "2020-02",
|
|
Distributed: 250,
|
|
Paid: 350,
|
|
Disposed: 200,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payoutdb.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: satelliteID1,
|
|
Period: "2020-01",
|
|
Distributed: 100,
|
|
Paid: 300,
|
|
Disposed: 300,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
err = payoutdb.StorePayStub(ctx, payouts.PayStub{
|
|
SatelliteID: satelliteID1,
|
|
Period: "2020-02",
|
|
Distributed: 400,
|
|
Paid: 500,
|
|
Disposed: 400,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
t.Run("all satellites period", func(t *testing.T) {
|
|
paystub, err := payoutdb.GetSatellitePaystubs(ctx, satelliteID1)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, paystub.Distributed, 500)
|
|
require.EqualValues(t, paystub.Paid, 800)
|
|
require.EqualValues(t, paystub.Disposed, 700)
|
|
})
|
|
|
|
t.Run("satellites period", func(t *testing.T) {
|
|
paystub, err := payoutdb.GetPaystubs(ctx)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, paystub.Distributed, 900)
|
|
require.EqualValues(t, paystub.Paid, 1400)
|
|
require.EqualValues(t, paystub.Disposed, 1000)
|
|
})
|
|
|
|
t.Run("all satellites period", func(t *testing.T) {
|
|
paystub, err := payoutdb.GetPeriodPaystubs(ctx, "2020-01")
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, paystub.Distributed, 250)
|
|
require.EqualValues(t, paystub.Paid, 550)
|
|
require.EqualValues(t, paystub.Disposed, 400)
|
|
})
|
|
|
|
t.Run("satellites period", func(t *testing.T) {
|
|
paystub, err := payoutdb.GetSatellitePeriodPaystubs(ctx, "2020-02", satelliteID2)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, paystub.Distributed, 250)
|
|
require.EqualValues(t, paystub.Paid, 350)
|
|
require.EqualValues(t, paystub.Disposed, 200)
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestDBHeldAmountHistory(t *testing.T) {
|
|
storagenodedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db storagenode.DB) {
|
|
payoutsDB := db.Payout()
|
|
satelliteID1 := testrand.NodeID()
|
|
satelliteID2 := testrand.NodeID()
|
|
|
|
paystubs := []payouts.PayStub{
|
|
{
|
|
SatelliteID: satelliteID1,
|
|
Period: "2021-01",
|
|
Held: 10,
|
|
},
|
|
{
|
|
SatelliteID: satelliteID1,
|
|
Period: "2021-02",
|
|
Held: 10,
|
|
},
|
|
{
|
|
SatelliteID: satelliteID1,
|
|
Period: "2021-03",
|
|
Held: 10,
|
|
},
|
|
{
|
|
SatelliteID: satelliteID1,
|
|
Period: "2021-04",
|
|
Held: 10,
|
|
},
|
|
{
|
|
SatelliteID: satelliteID2,
|
|
Period: "2021-01",
|
|
Held: 0,
|
|
},
|
|
{
|
|
SatelliteID: satelliteID2,
|
|
Period: "2021-02",
|
|
Held: 0,
|
|
},
|
|
{
|
|
SatelliteID: satelliteID2,
|
|
Period: "2021-03",
|
|
Held: 0,
|
|
},
|
|
{
|
|
SatelliteID: satelliteID2,
|
|
Period: "2021-04",
|
|
Held: 0,
|
|
},
|
|
}
|
|
|
|
expected := []payouts.HeldAmountHistory{
|
|
{
|
|
SatelliteID: satelliteID1,
|
|
HeldAmounts: []payouts.HeldForPeriod{
|
|
{
|
|
Period: "2021-01",
|
|
Amount: 10,
|
|
},
|
|
{
|
|
Period: "2021-02",
|
|
Amount: 10,
|
|
},
|
|
{
|
|
Period: "2021-03",
|
|
Amount: 10,
|
|
},
|
|
{
|
|
Period: "2021-04",
|
|
Amount: 10,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
SatelliteID: satelliteID2,
|
|
HeldAmounts: []payouts.HeldForPeriod{
|
|
{
|
|
Period: "2021-01",
|
|
Amount: 0,
|
|
},
|
|
{
|
|
Period: "2021-02",
|
|
Amount: 0,
|
|
},
|
|
{
|
|
Period: "2021-03",
|
|
Amount: 0,
|
|
},
|
|
{
|
|
Period: "2021-04",
|
|
Amount: 0,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, paystub := range paystubs {
|
|
err := payoutsDB.StorePayStub(ctx, paystub)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
history, err := payoutsDB.HeldAmountHistory(ctx)
|
|
require.NoError(t, err)
|
|
require.ElementsMatch(t, expected, history)
|
|
})
|
|
}
|