MiFaZhan
310 lines
10 KiB
Go
310 lines
10 KiB
Go
package trafficusage
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
|
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
|
)
|
|
|
|
func stubDailyTrigger(t *testing.T) {
|
|
t.Helper()
|
|
originalNow := dailyUsageNow
|
|
originalRunID := dailyUsageRunID
|
|
originalEnabled := dailyUsageRabbitEnabled
|
|
originalPublish := dailyUsagePublish
|
|
t.Cleanup(func() {
|
|
dailyUsageNow = originalNow
|
|
dailyUsageRunID = originalRunID
|
|
dailyUsageRabbitEnabled = originalEnabled
|
|
dailyUsagePublish = originalPublish
|
|
})
|
|
}
|
|
|
|
// TestStartDailyPublishesPreviousShanghaiDay pins the period: the run must cover
|
|
// the previous calendar day in Asia/Shanghai, matching what the legacy admin
|
|
// scan wrote, so the migration cannot shift the day by one.
|
|
func TestStartDailyPublishesPreviousShanghaiDay(t *testing.T) {
|
|
stubDailyTrigger(t)
|
|
|
|
dailyUsageNow = func() time.Time {
|
|
// 2026-10-10 06:00 +08:00 -> the previous day is 20261009.
|
|
return time.Date(2026, time.October, 10, 6, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60))
|
|
}
|
|
dailyUsageRunID = func() string { return "test-run" }
|
|
dailyUsageRabbitEnabled = func(context.Context) bool { return true }
|
|
|
|
var publishedQueue string
|
|
var published model.TrafficUsageDailyStartMessage
|
|
dailyUsagePublish = func(_ context.Context, queue string, data any) error {
|
|
publishedQueue = queue
|
|
published = data.(model.TrafficUsageDailyStartMessage)
|
|
return nil
|
|
}
|
|
|
|
if err := NewTrafficUsageDailySync().StartDaily(context.Background()); err != nil {
|
|
t.Fatalf("StartDaily() error = %v", err)
|
|
}
|
|
if publishedQueue != consts.QueueTrafficUsageDailyStart {
|
|
t.Fatalf("queue = %q, want %q", publishedQueue, consts.QueueTrafficUsageDailyStart)
|
|
}
|
|
if published.QueryDate != "20261009" {
|
|
t.Fatalf("queryDate = %q, want 20261009", published.QueryDate)
|
|
}
|
|
if published.RunID != "daily-usage-20261009-test-run" {
|
|
t.Fatalf("runId = %q", published.RunID)
|
|
}
|
|
if published.Operation != model.OperationPreviousDayUsageFullSync {
|
|
t.Fatalf("operation = %q", published.Operation)
|
|
}
|
|
}
|
|
|
|
// TestStartDailyUsesShanghaiDayAcrossUTCMidnight guards the timezone bug that
|
|
// the legacy code carried: a UTC instant just after midnight is still the
|
|
// previous day in Shanghai, so the period must not be computed in UTC.
|
|
func TestStartDailyUsesShanghaiDayAcrossUTCMidnight(t *testing.T) {
|
|
stubDailyTrigger(t)
|
|
|
|
// 2026-10-09 17:30 UTC == 2026-10-10 01:30 +08:00 -> previous day 20261009.
|
|
dailyUsageNow = func() time.Time {
|
|
return time.Date(2026, time.October, 9, 17, 30, 0, 0, time.UTC)
|
|
}
|
|
dailyUsageRunID = func() string { return "tz-run" }
|
|
dailyUsageRabbitEnabled = func(context.Context) bool { return true }
|
|
|
|
var published model.TrafficUsageDailyStartMessage
|
|
dailyUsagePublish = func(_ context.Context, _ string, data any) error {
|
|
published = data.(model.TrafficUsageDailyStartMessage)
|
|
return nil
|
|
}
|
|
|
|
if err := NewTrafficUsageDailySync().StartDaily(context.Background()); err != nil {
|
|
t.Fatalf("StartDaily() error = %v", err)
|
|
}
|
|
if published.QueryDate != "20261009" {
|
|
t.Fatalf("queryDate = %q, want 20261009 (Shanghai, not UTC)", published.QueryDate)
|
|
}
|
|
if published.TriggeredAt != "2026-10-10T01:30:00+08:00" {
|
|
t.Fatalf("triggeredAt = %q, want the Shanghai instant", published.TriggeredAt)
|
|
}
|
|
}
|
|
|
|
func TestStartDailyRunScopedForwardsScope(t *testing.T) {
|
|
stubDailyTrigger(t)
|
|
|
|
dailyUsageNow = func() time.Time {
|
|
return time.Date(2026, time.October, 10, 6, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60))
|
|
}
|
|
dailyUsageRunID = func() string { return "scoped-run" }
|
|
dailyUsageRabbitEnabled = func(context.Context) bool { return true }
|
|
|
|
var published model.TrafficUsageDailyStartMessage
|
|
dailyUsagePublish = func(_ context.Context, _ string, data any) error {
|
|
published = data.(model.TrafficUsageDailyStartMessage)
|
|
return nil
|
|
}
|
|
|
|
runID, err := NewTrafficUsageDailySync().StartDailyRunScoped(context.Background(), &model.SyncScope{Channels: []string{"217"}})
|
|
if err != nil {
|
|
t.Fatalf("StartDailyRunScoped() error = %v", err)
|
|
}
|
|
if runID != "daily-usage-20261009-scoped-run" {
|
|
t.Fatalf("runId = %q", runID)
|
|
}
|
|
if published.Scope == nil || published.Scope.ChannelCount() != 1 || !published.Scope.Allows("217") {
|
|
t.Fatalf("scope = %+v, want channel 217 only", published.Scope)
|
|
}
|
|
}
|
|
|
|
func TestStartDailyRejectsInvalidScope(t *testing.T) {
|
|
stubDailyTrigger(t)
|
|
|
|
dailyUsageRabbitEnabled = func(context.Context) bool { return true }
|
|
called := false
|
|
dailyUsagePublish = func(context.Context, string, any) error {
|
|
called = true
|
|
return nil
|
|
}
|
|
|
|
if _, err := NewTrafficUsageDailySync().StartDailyRunScoped(context.Background(), &model.SyncScope{Channels: []string{"invalid/chan"}}); err == nil {
|
|
t.Fatal("expected an invalid chanKey to be rejected")
|
|
}
|
|
if called {
|
|
t.Fatal("publisher called for a rejected scope")
|
|
}
|
|
}
|
|
|
|
func TestStartDailyReturnsPublishError(t *testing.T) {
|
|
stubDailyTrigger(t)
|
|
|
|
dailyUsageNow = func() time.Time { return time.Date(2026, time.October, 10, 6, 0, 0, 0, time.UTC) }
|
|
dailyUsageRunID = func() string { return "err-run" }
|
|
dailyUsageRabbitEnabled = func(context.Context) bool { return true }
|
|
dailyUsagePublish = func(context.Context, string, any) error {
|
|
return errors.New("broker unavailable")
|
|
}
|
|
|
|
if err := NewTrafficUsageDailySync().StartDaily(context.Background()); err == nil {
|
|
t.Fatal("StartDaily() error = nil, want publish error")
|
|
}
|
|
}
|
|
|
|
func TestStartDailySkipsWhenRabbitMQDisabled(t *testing.T) {
|
|
stubDailyTrigger(t)
|
|
|
|
dailyUsageRabbitEnabled = func(context.Context) bool { return false }
|
|
called := false
|
|
dailyUsagePublish = func(context.Context, string, any) error {
|
|
called = true
|
|
return nil
|
|
}
|
|
|
|
if err := NewTrafficUsageDailySync().StartDaily(context.Background()); err == nil {
|
|
t.Fatal("StartDaily() error = nil, want disabled error")
|
|
}
|
|
if called {
|
|
t.Fatal("publisher called while RabbitMQ is disabled")
|
|
}
|
|
}
|
|
|
|
// dailyBackfillClock pins "now" for the period-aware daily tests: 2026-10-20
|
|
// 06:00 +08:00, so the default day is 20261019 and nothing later is valid.
|
|
func dailyBackfillClock(t *testing.T) {
|
|
t.Helper()
|
|
stubDailyTrigger(t)
|
|
dailyUsageNow = func() time.Time {
|
|
return time.Date(2026, time.October, 20, 6, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60))
|
|
}
|
|
dailyUsageRunID = func() string { return "backfill-run" }
|
|
dailyUsageRabbitEnabled = func(context.Context) bool { return true }
|
|
}
|
|
|
|
func captureDailyStart(t *testing.T) *model.TrafficUsageDailyStartMessage {
|
|
t.Helper()
|
|
published := &model.TrafficUsageDailyStartMessage{}
|
|
dailyUsagePublish = func(_ context.Context, _ string, data any) error {
|
|
*published = data.(model.TrafficUsageDailyStartMessage)
|
|
return nil
|
|
}
|
|
return published
|
|
}
|
|
|
|
func TestStartDailyRunScopedAtUsesGivenDate(t *testing.T) {
|
|
dailyBackfillClock(t)
|
|
published := captureDailyStart(t)
|
|
|
|
runID, err := NewTrafficUsageDailySync().StartDailyRunScopedAt(context.Background(), nil, "20261014")
|
|
if err != nil {
|
|
t.Fatalf("StartDailyRunScopedAt() error = %v", err)
|
|
}
|
|
if published.QueryDate != "20261014" {
|
|
t.Fatalf("queryDate = %q, want 20261014", published.QueryDate)
|
|
}
|
|
if runID != "daily-usage-20261014-backfill-run" {
|
|
t.Fatalf("runId = %q", runID)
|
|
}
|
|
if published.Operation != model.OperationPreviousDayUsageFullSync {
|
|
t.Fatalf("operation = %q", published.Operation)
|
|
}
|
|
}
|
|
|
|
func TestStartDailyRunScopedAtRejectsFutureDate(t *testing.T) {
|
|
dailyBackfillClock(t)
|
|
called := false
|
|
dailyUsagePublish = func(context.Context, string, any) error {
|
|
called = true
|
|
return nil
|
|
}
|
|
|
|
for _, queryDate := range []string{"20261020", "20261021", "20270101"} {
|
|
if _, err := NewTrafficUsageDailySync().StartDailyRunScopedAt(context.Background(), nil, queryDate); err == nil {
|
|
t.Fatalf("queryDate %q accepted, want a future-date error", queryDate)
|
|
}
|
|
}
|
|
if called {
|
|
t.Fatal("publisher called for a rejected date")
|
|
}
|
|
}
|
|
|
|
func TestStartDailyRunScopedAtRejectsMalformedDate(t *testing.T) {
|
|
dailyBackfillClock(t)
|
|
called := false
|
|
dailyUsagePublish = func(context.Context, string, any) error {
|
|
called = true
|
|
return nil
|
|
}
|
|
|
|
for _, queryDate := range []string{"2026-10-14", "abc", "2026101", "202610140", "20261314"} {
|
|
if _, err := NewTrafficUsageDailySync().StartDailyRunScopedAt(context.Background(), nil, queryDate); err == nil {
|
|
t.Fatalf("queryDate %q accepted, want a format error", queryDate)
|
|
}
|
|
}
|
|
if called {
|
|
t.Fatal("publisher called for a malformed date")
|
|
}
|
|
}
|
|
|
|
func TestStartDailyRunScopedAtRejectsDateBeforeLowerBound(t *testing.T) {
|
|
dailyBackfillClock(t)
|
|
called := false
|
|
dailyUsagePublish = func(context.Context, string, any) error {
|
|
called = true
|
|
return nil
|
|
}
|
|
|
|
for _, queryDate := range []string{"20191231", "19990101"} {
|
|
if _, err := NewTrafficUsageDailySync().StartDailyRunScopedAt(context.Background(), nil, queryDate); err == nil {
|
|
t.Fatalf("queryDate %q accepted, want a lower-bound error", queryDate)
|
|
}
|
|
}
|
|
if called {
|
|
t.Fatal("publisher called for a date below the lower bound")
|
|
}
|
|
}
|
|
|
|
func TestStartDailyRunScopedAtEmptyFallsBackToYesterday(t *testing.T) {
|
|
dailyBackfillClock(t)
|
|
published := captureDailyStart(t)
|
|
|
|
runID, err := NewTrafficUsageDailySync().StartDailyRunScopedAt(context.Background(), nil, "")
|
|
if err != nil {
|
|
t.Fatalf("StartDailyRunScopedAt() error = %v", err)
|
|
}
|
|
if published.QueryDate != "20261019" {
|
|
t.Fatalf("queryDate = %q, want 20261019 (yesterday)", published.QueryDate)
|
|
}
|
|
if runID != "daily-usage-20261019-backfill-run" {
|
|
t.Fatalf("runId = %q", runID)
|
|
}
|
|
}
|
|
|
|
// TestStartDailyRunScopedAtEmptyMatchesLegacyScoped keeps the backward
|
|
// compatibility promise concrete: the old entry point and an empty period must
|
|
// publish byte-identical messages.
|
|
func TestStartDailyRunScopedAtEmptyMatchesLegacyScoped(t *testing.T) {
|
|
dailyBackfillClock(t)
|
|
var messages []model.TrafficUsageDailyStartMessage
|
|
dailyUsagePublish = func(_ context.Context, _ string, data any) error {
|
|
messages = append(messages, data.(model.TrafficUsageDailyStartMessage))
|
|
return nil
|
|
}
|
|
|
|
legacyID, err := NewTrafficUsageDailySync().StartDailyRunScoped(context.Background(), nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
atID, err := NewTrafficUsageDailySync().StartDailyRunScopedAt(context.Background(), nil, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(messages) != 2 {
|
|
t.Fatalf("published %d messages, want 2", len(messages))
|
|
}
|
|
if legacyID != atID || messages[0] != messages[1] {
|
|
t.Fatalf("legacy = %+v/%q, at = %+v/%q", messages[0], legacyID, messages[1], atID)
|
|
}
|
|
}
|