666 lines
14 KiB
Go
666 lines
14 KiB
Go
package deduction
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestSubscribe_Validate(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
sub Subscribe
|
|
wantErr bool
|
|
errType error
|
|
}{
|
|
{
|
|
name: "valid subscription",
|
|
sub: Subscribe{
|
|
StartTime: time.Now(),
|
|
ExpireTime: time.Now().Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 100,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: 50,
|
|
},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "negative traffic",
|
|
sub: Subscribe{
|
|
StartTime: time.Now(),
|
|
ExpireTime: time.Now().Add(24 * time.Hour),
|
|
Traffic: -1000,
|
|
Download: 100,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: 50,
|
|
},
|
|
wantErr: true,
|
|
errType: ErrInvalidTraffic,
|
|
},
|
|
{
|
|
name: "negative download",
|
|
sub: Subscribe{
|
|
StartTime: time.Now(),
|
|
ExpireTime: time.Now().Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: -100,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: 50,
|
|
},
|
|
wantErr: true,
|
|
errType: ErrInvalidTraffic,
|
|
},
|
|
{
|
|
name: "download + upload exceeds traffic",
|
|
sub: Subscribe{
|
|
StartTime: time.Now(),
|
|
ExpireTime: time.Now().Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 600,
|
|
Upload: 500,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: 50,
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "expire time before start time",
|
|
sub: Subscribe{
|
|
StartTime: time.Now(),
|
|
ExpireTime: time.Now().Add(-24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 100,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: 50,
|
|
},
|
|
wantErr: true,
|
|
errType: ErrInvalidTimeRange,
|
|
},
|
|
{
|
|
name: "invalid deduction ratio - negative",
|
|
sub: Subscribe{
|
|
StartTime: time.Now(),
|
|
ExpireTime: time.Now().Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 100,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: -10,
|
|
},
|
|
wantErr: true,
|
|
errType: ErrInvalidDeductionRatio,
|
|
},
|
|
{
|
|
name: "invalid deduction ratio - over 100",
|
|
sub: Subscribe{
|
|
StartTime: time.Now(),
|
|
ExpireTime: time.Now().Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 100,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: 150,
|
|
},
|
|
wantErr: true,
|
|
errType: ErrInvalidDeductionRatio,
|
|
},
|
|
{
|
|
name: "invalid unit time",
|
|
sub: Subscribe{
|
|
StartTime: time.Now(),
|
|
ExpireTime: time.Now().Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 100,
|
|
Upload: 200,
|
|
UnitTime: "InvalidUnit",
|
|
DeductionRatio: 50,
|
|
},
|
|
wantErr: true,
|
|
errType: ErrInvalidUnitTime,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := tt.sub.Validate()
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("Subscribe.Validate() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
if tt.errType != nil && err != tt.errType {
|
|
t.Errorf("Subscribe.Validate() error = %v, want %v", err, tt.errType)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestOrder_Validate(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
order Order
|
|
wantErr bool
|
|
errType error
|
|
}{
|
|
{
|
|
name: "valid order",
|
|
order: Order{Amount: 1000, Quantity: 2},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "zero quantity",
|
|
order: Order{Amount: 1000, Quantity: 0},
|
|
wantErr: true,
|
|
errType: ErrInvalidQuantity,
|
|
},
|
|
{
|
|
name: "negative quantity",
|
|
order: Order{Amount: 1000, Quantity: -1},
|
|
wantErr: true,
|
|
errType: ErrInvalidQuantity,
|
|
},
|
|
{
|
|
name: "negative amount",
|
|
order: Order{Amount: -1000, Quantity: 2},
|
|
wantErr: true,
|
|
errType: ErrInvalidAmount,
|
|
},
|
|
{
|
|
name: "zero amount is valid",
|
|
order: Order{Amount: 0, Quantity: 1},
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := tt.order.Validate()
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("Order.Validate() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
if tt.errType != nil && err != tt.errType {
|
|
t.Errorf("Order.Validate() error = %v, want %v", err, tt.errType)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSafeMultiply(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
a, b int64
|
|
want int64
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "normal multiplication",
|
|
a: 10,
|
|
b: 20,
|
|
want: 200,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "zero multiplication",
|
|
a: 10,
|
|
b: 0,
|
|
want: 0,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "negative multiplication",
|
|
a: -10,
|
|
b: 20,
|
|
want: -200,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "overflow case",
|
|
a: math.MaxInt64,
|
|
b: 2,
|
|
want: 0,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "large numbers no overflow",
|
|
a: 1000000,
|
|
b: 1000000,
|
|
want: 1000000000000,
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := safeMultiply(tt.a, tt.b)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("safeMultiply() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
if got != tt.want {
|
|
t.Errorf("safeMultiply() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSafeAdd(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
a, b int64
|
|
want int64
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "normal addition",
|
|
a: 10,
|
|
b: 20,
|
|
want: 30,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "negative addition",
|
|
a: -10,
|
|
b: 5,
|
|
want: -5,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "overflow case",
|
|
a: math.MaxInt64,
|
|
b: 1,
|
|
want: 0,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "underflow case",
|
|
a: math.MinInt64,
|
|
b: -1,
|
|
want: 0,
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := safeAdd(tt.a, tt.b)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("safeAdd() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
if got != tt.want {
|
|
t.Errorf("safeAdd() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSafeDivide(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
a, b int64
|
|
want int64
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "normal division",
|
|
a: 20,
|
|
b: 10,
|
|
want: 2,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "division by zero",
|
|
a: 20,
|
|
b: 0,
|
|
want: 0,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "negative division",
|
|
a: -20,
|
|
b: 10,
|
|
want: -2,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "zero dividend",
|
|
a: 0,
|
|
b: 10,
|
|
want: 0,
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := safeDivide(tt.a, tt.b)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("safeDivide() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
if got != tt.want {
|
|
t.Errorf("safeDivide() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCalculateWeights(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
deductionRatio int64
|
|
wantTrafficWeight float64
|
|
wantTimeWeight float64
|
|
}{
|
|
{
|
|
name: "zero ratio",
|
|
deductionRatio: 0,
|
|
wantTrafficWeight: 0,
|
|
wantTimeWeight: 0,
|
|
},
|
|
{
|
|
name: "50% ratio",
|
|
deductionRatio: 50,
|
|
wantTrafficWeight: 0.5,
|
|
wantTimeWeight: 0.5,
|
|
},
|
|
{
|
|
name: "75% ratio",
|
|
deductionRatio: 75,
|
|
wantTrafficWeight: 0.75,
|
|
wantTimeWeight: 0.25,
|
|
},
|
|
{
|
|
name: "100% ratio",
|
|
deductionRatio: 100,
|
|
wantTrafficWeight: 1.0,
|
|
wantTimeWeight: 0.0,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
gotTrafficWeight, gotTimeWeight := calculateWeights(tt.deductionRatio)
|
|
if gotTrafficWeight != tt.wantTrafficWeight {
|
|
t.Errorf("calculateWeights() trafficWeight = %v, want %v", gotTrafficWeight, tt.wantTrafficWeight)
|
|
}
|
|
if gotTimeWeight != tt.wantTimeWeight {
|
|
t.Errorf("calculateWeights() timeWeight = %v, want %v", gotTimeWeight, tt.wantTimeWeight)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCalculateProportionalAmount(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
unitPrice int64
|
|
remaining int64
|
|
total int64
|
|
want int64
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "normal calculation",
|
|
unitPrice: 100,
|
|
remaining: 50,
|
|
total: 100,
|
|
want: 50,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "zero total",
|
|
unitPrice: 100,
|
|
remaining: 50,
|
|
total: 0,
|
|
want: 0,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "zero remaining",
|
|
unitPrice: 100,
|
|
remaining: 0,
|
|
total: 100,
|
|
want: 0,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "quarter remaining",
|
|
unitPrice: 200,
|
|
remaining: 25,
|
|
total: 100,
|
|
want: 50,
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := calculateProportionalAmount(tt.unitPrice, tt.remaining, tt.total)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("calculateProportionalAmount() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
if got != tt.want {
|
|
t.Errorf("calculateProportionalAmount() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCalculateNoLimitAmount(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
sub Subscribe
|
|
order Order
|
|
want int64
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "normal no limit calculation",
|
|
sub: Subscribe{
|
|
Traffic: 1000,
|
|
Download: 300,
|
|
Upload: 200,
|
|
},
|
|
order: Order{
|
|
Amount: 1000,
|
|
},
|
|
want: 500, // (1000 - 300 - 200) / 1000 * 1000 = 500
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "zero traffic",
|
|
sub: Subscribe{
|
|
Traffic: 0,
|
|
Download: 0,
|
|
Upload: 0,
|
|
},
|
|
order: Order{
|
|
Amount: 1000,
|
|
},
|
|
want: 0,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "overused traffic",
|
|
sub: Subscribe{
|
|
Traffic: 1000,
|
|
Download: 600,
|
|
Upload: 500,
|
|
},
|
|
order: Order{
|
|
Amount: 1000,
|
|
},
|
|
want: 0, // usedTraffic would be negative, clamped to 0
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := calculateNoLimitAmount(tt.sub, tt.order)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("calculateNoLimitAmount() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
if got != tt.want {
|
|
t.Errorf("calculateNoLimitAmount() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCalculateRemainingAmount(t *testing.T) {
|
|
now := time.Now()
|
|
|
|
tests := []struct {
|
|
name string
|
|
sub Subscribe
|
|
order Order
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "valid no limit subscription",
|
|
sub: Subscribe{
|
|
StartTime: now.Add(-24 * time.Hour),
|
|
ExpireTime: now.Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 300,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeNoLimit,
|
|
ResetCycle: ResetCycleNone,
|
|
DeductionRatio: 0,
|
|
},
|
|
order: Order{
|
|
Amount: 1000,
|
|
Quantity: 1,
|
|
},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "invalid subscription",
|
|
sub: Subscribe{
|
|
StartTime: now,
|
|
ExpireTime: now.Add(-24 * time.Hour), // Invalid: expire before start
|
|
Traffic: 1000,
|
|
Download: 300,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: 0,
|
|
},
|
|
order: Order{
|
|
Amount: 1000,
|
|
Quantity: 1,
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "invalid order",
|
|
sub: Subscribe{
|
|
StartTime: now.Add(-24 * time.Hour),
|
|
ExpireTime: now.Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 300,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
DeductionRatio: 0,
|
|
},
|
|
order: Order{
|
|
Amount: 1000,
|
|
Quantity: 0, // Invalid: zero quantity
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "no limit with reset cycle",
|
|
sub: Subscribe{
|
|
StartTime: now.Add(-24 * time.Hour),
|
|
ExpireTime: now.Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 300,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeNoLimit,
|
|
ResetCycle: ResetCycleMonthly, // Should return 0
|
|
DeductionRatio: 0,
|
|
},
|
|
order: Order{
|
|
Amount: 1000,
|
|
Quantity: 1,
|
|
},
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
_, err := CalculateRemainingAmount(tt.sub, tt.order)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("CalculateRemainingAmount() error = %v, wantErr %v", err, tt.wantErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCalculateRemainingAmount_NoLimitWithResetCycle(t *testing.T) {
|
|
now := time.Now()
|
|
sub := Subscribe{
|
|
StartTime: now.Add(-24 * time.Hour),
|
|
ExpireTime: now.Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 300,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeNoLimit,
|
|
ResetCycle: ResetCycleMonthly,
|
|
DeductionRatio: 0,
|
|
}
|
|
order := Order{
|
|
Amount: 1000,
|
|
Quantity: 1,
|
|
}
|
|
|
|
got, err := CalculateRemainingAmount(sub, order)
|
|
if err != nil {
|
|
t.Errorf("CalculateRemainingAmount() error = %v", err)
|
|
return
|
|
}
|
|
if got != 0 {
|
|
t.Errorf("CalculateRemainingAmount() = %v, want 0", got)
|
|
}
|
|
}
|
|
|
|
// Benchmark tests
|
|
func BenchmarkCalculateRemainingAmount(b *testing.B) {
|
|
now := time.Now()
|
|
sub := Subscribe{
|
|
StartTime: now.Add(-24 * time.Hour),
|
|
ExpireTime: now.Add(24 * time.Hour),
|
|
Traffic: 1000,
|
|
Download: 300,
|
|
Upload: 200,
|
|
UnitTime: UnitTimeMonth,
|
|
ResetCycle: ResetCycleNone,
|
|
DeductionRatio: 50,
|
|
}
|
|
order := Order{
|
|
Amount: 1000,
|
|
Quantity: 1,
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = CalculateRemainingAmount(sub, order)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSafeMultiply(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = safeMultiply(12345, 67890)
|
|
}
|
|
}
|