wehub-resource-sync
f99010fae1
CI / lint (push) Failing after 1s
CI / frontend (push) Failing after 1s
CI / scripts (push) Failing after 1s
CI / Go Test (ubuntu-latest) (push) Failing after 0s
CI / frontend-node-25 (push) Failing after 1s
CI / docs (push) Failing after 0s
CI / coverage (push) Failing after 0s
CI / e2e (push) Failing after 0s
Docker / build-and-push (push) Failing after 1s
CI / integration (push) Failing after 4m43s
CI / Go Test (windows-latest) (push) Has been cancelled
CI / Desktop Unit Tests (Windows) (push) Has been cancelled
Desktop Artifacts / Desktop Build (Linux (arm64)) (push) Has been cancelled
Desktop Artifacts / Desktop Build (Linux) (push) Has been cancelled
Desktop Artifacts / Desktop Build (Windows) (push) Has been cancelled
Desktop Artifacts (macOS) / Desktop Build (macOS (aarch64)) (push) Has been cancelled
Desktop Artifacts (macOS) / Desktop Build (macOS (x86_64)) (push) Has been cancelled
250 lines
9.6 KiB
Go
250 lines
9.6 KiB
Go
package activity
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func loc(t *testing.T, name string) *time.Location {
|
|
t.Helper()
|
|
l, err := time.LoadLocation(name)
|
|
require.NoError(t, err)
|
|
return l
|
|
}
|
|
|
|
func mustRFC3339(t *testing.T, s string) time.Time {
|
|
t.Helper()
|
|
ts, err := time.Parse(time.RFC3339, s)
|
|
require.NoError(t, err)
|
|
return ts.UTC()
|
|
}
|
|
|
|
func TestResolveQuery_PresetDayUTC(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
q, err := ResolveQuery(QueryInput{Preset: "day", Date: "2026-06-16", Timezone: "UTC"}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-16T00:00:00Z"), q.RangeStart)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-17T00:00:00Z"), q.RangeEnd)
|
|
assert.Equal(t, BucketMinute, q.Bucket.Unit)
|
|
assert.Equal(t, 300, q.Bucket.NominalSeconds)
|
|
assert.False(t, q.Partial, "past day is complete")
|
|
assert.Equal(t, q.RangeEnd, q.EffectiveEnd, "complete day clamps to range_end")
|
|
assert.InDelta(t, 300.0, q.GapCapSeconds, 0)
|
|
}
|
|
|
|
func TestResolveQuery_EmptyInputDefaultsToToday(t *testing.T) {
|
|
now := mustRFC3339(t, "2026-06-17T09:30:00Z")
|
|
q, err := ResolveQuery(QueryInput{}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-17T00:00:00Z"), q.RangeStart)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-18T00:00:00Z"), q.RangeEnd)
|
|
assert.Equal(t, BucketMinute, q.Bucket.Unit, "empty input defaults to the day preset")
|
|
}
|
|
|
|
func TestResolveQuery_PresetWeekISOMonday(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
// 2026-06-17 is a Wednesday; ISO week starts Monday 2026-06-15.
|
|
q, err := ResolveQuery(QueryInput{Preset: "week", Date: "2026-06-17", Timezone: "UTC"}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-15T00:00:00Z"), q.RangeStart)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-22T00:00:00Z"), q.RangeEnd)
|
|
assert.Equal(t, BucketHour, q.Bucket.Unit, "7d range auto-buckets hourly")
|
|
}
|
|
|
|
func TestResolveQuery_PresetMonthUTC(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
q, err := ResolveQuery(QueryInput{Preset: "month", Date: "2026-02-14", Timezone: "UTC"}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, mustRFC3339(t, "2026-02-01T00:00:00Z"), q.RangeStart)
|
|
assert.Equal(t, mustRFC3339(t, "2026-03-01T00:00:00Z"), q.RangeEnd)
|
|
assert.Equal(t, BucketDay, q.Bucket.Unit, "28d range auto-buckets daily")
|
|
}
|
|
|
|
func TestResolveQuery_PresetDayDSTSpringForward(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
// America/New_York springs forward 2026-03-08: local day is 23h.
|
|
q, err := ResolveQuery(QueryInput{Preset: "day", Date: "2026-03-08", Timezone: "America/New_York"}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 23*time.Hour, q.RangeEnd.Sub(q.RangeStart), "spring-forward day is 23h")
|
|
}
|
|
|
|
func TestResolveQuery_PresetDayDSTFallBack(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
// America/New_York falls back 2026-11-01: local day is 25h.
|
|
q, err := ResolveQuery(QueryInput{Preset: "day", Date: "2026-11-01", Timezone: "America/New_York"}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 25*time.Hour, q.RangeEnd.Sub(q.RangeStart), "fall-back day is 25h")
|
|
}
|
|
|
|
func TestResolveQuery_MonthSpanningDST(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
// March 2026 in New York spans the spring-forward; month is 31 calendar
|
|
// days but one hour short of 31*24h.
|
|
q, err := ResolveQuery(QueryInput{Preset: "month", Date: "2026-03-10", Timezone: "America/New_York"}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 31*24*time.Hour-time.Hour, q.RangeEnd.Sub(q.RangeStart),
|
|
"March in NY is 31 days minus the lost DST hour")
|
|
}
|
|
|
|
func TestResolveBucket_Thresholds(t *testing.T) {
|
|
l := time.UTC
|
|
start := mustRFC3339(t, "2026-06-01T00:00:00Z")
|
|
cases := []struct {
|
|
name string
|
|
dur time.Duration
|
|
unit BucketUnit
|
|
secs int
|
|
}{
|
|
{"exactly 36h is minute", 36 * time.Hour, BucketMinute, 300},
|
|
{"just over 36h is hour", 36*time.Hour + time.Second, BucketHour, 3600},
|
|
{"exactly 14d is hour", 14 * 24 * time.Hour, BucketHour, 3600},
|
|
{"just over 14d is day", 14*24*time.Hour + time.Second, BucketDay, 86400},
|
|
{"exactly 90d is day", 90 * 24 * time.Hour, BucketDay, 86400},
|
|
{"just over 90d is week", 90*24*time.Hour + time.Second, BucketWeek, 604800},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
spec, err := ResolveBucket(start, start.Add(tc.dur), "", l)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tc.unit, spec.Unit)
|
|
assert.Equal(t, tc.secs, spec.NominalSeconds)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestResolveBucket_OverrideAllowList(t *testing.T) {
|
|
l := time.UTC
|
|
start := mustRFC3339(t, "2026-06-01T00:00:00Z")
|
|
end := start.Add(48 * time.Hour)
|
|
ok := map[string]BucketSpec{
|
|
"5m": {BucketMinute, 300},
|
|
"15m": {BucketMinute, 900},
|
|
"1h": {BucketHour, 3600},
|
|
"1d": {BucketDay, 86400},
|
|
"1w": {BucketWeek, 604800},
|
|
}
|
|
for k, want := range ok {
|
|
spec, err := ResolveBucket(start, end, k, l)
|
|
require.NoErrorf(t, err, "override %q", k)
|
|
assert.Equalf(t, want, spec, "override %q", k)
|
|
}
|
|
_, err := ResolveBucket(start, end, "2h", l)
|
|
require.Error(t, err, "off-allow-list override is rejected")
|
|
}
|
|
|
|
func TestResolveQuery_BucketCountCap(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
// 5m buckets over a full year is ~105k buckets > 2000.
|
|
_, err := ResolveQuery(QueryInput{
|
|
Preset: "custom", Timezone: "UTC",
|
|
From: "2026-01-01T00:00:00Z", To: "2026-12-31T00:00:00Z",
|
|
BucketOverride: "5m",
|
|
}, now)
|
|
require.Error(t, err, "5m over a year exceeds the 2000-bucket cap")
|
|
}
|
|
|
|
func TestResolveQuery_MaxRangeOneYear(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
_, err := ResolveQuery(QueryInput{
|
|
Preset: "custom", Timezone: "UTC",
|
|
From: "2026-01-01T00:00:00Z", To: "2027-01-02T00:00:00Z",
|
|
}, now)
|
|
require.Error(t, err, "range over one year is rejected")
|
|
}
|
|
|
|
func TestResolveQuery_FromAfterToRejected(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
_, err := ResolveQuery(QueryInput{
|
|
Preset: "custom", Timezone: "UTC",
|
|
From: "2026-06-02T00:00:00Z", To: "2026-06-01T00:00:00Z",
|
|
}, now)
|
|
require.Error(t, err, "from >= to is rejected")
|
|
_, err = ResolveQuery(QueryInput{
|
|
Preset: "custom", Timezone: "UTC",
|
|
From: "2026-06-01T00:00:00Z", To: "2026-06-01T00:00:00Z",
|
|
}, now)
|
|
require.Error(t, err, "zero-length range is rejected")
|
|
}
|
|
|
|
func TestResolveQuery_CustomRequiresBothBounds(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
_, err := ResolveQuery(QueryInput{Preset: "custom", Timezone: "UTC", From: "2026-06-01T00:00:00Z"}, now)
|
|
require.Error(t, err, "custom needs both from and to")
|
|
}
|
|
|
|
func TestResolveQuery_InvalidTimezone(t *testing.T) {
|
|
now := mustRFC3339(t, "2030-01-01T00:00:00Z")
|
|
_, err := ResolveQuery(QueryInput{Preset: "day", Date: "2026-06-16", Timezone: "Fake/Zone"}, now)
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestResolveQuery_FutureRangeClamps(t *testing.T) {
|
|
now := mustRFC3339(t, "2026-06-16T00:00:00Z")
|
|
q, err := ResolveQuery(QueryInput{Preset: "day", Date: "2026-06-20", Timezone: "UTC"}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, q.RangeStart, q.EffectiveEnd, "fully future range clamps effective_end to range_start")
|
|
assert.True(t, q.Partial, "future range is partial")
|
|
}
|
|
|
|
func TestBuildBuckets_FixedDurationWithShortFinal(t *testing.T) {
|
|
l := time.UTC
|
|
start := mustRFC3339(t, "2026-06-16T10:00:00Z")
|
|
end := mustRFC3339(t, "2026-06-16T10:12:00Z") // 12 minutes
|
|
ws, err := BuildBuckets(start, end, BucketSpec{BucketMinute, 300}, l)
|
|
require.NoError(t, err)
|
|
require.Len(t, ws, 3, "12 minutes / 5 = 2 full + 1 short bucket")
|
|
assert.Equal(t, start, ws[0].Start)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-16T10:05:00Z"), ws[0].End)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-16T10:10:00Z"), ws[2].Start)
|
|
assert.Equal(t, end, ws[2].End, "final bucket clipped to range end")
|
|
}
|
|
|
|
func TestBuildBuckets_CalendarDayLocalBoundaries(t *testing.T) {
|
|
l := loc(t, "America/New_York")
|
|
// Two local days; the boundary is local midnight (04:00Z in EDT).
|
|
start := mustRFC3339(t, "2026-06-16T04:00:00Z")
|
|
end := mustRFC3339(t, "2026-06-18T04:00:00Z")
|
|
ws, err := BuildBuckets(start, end, BucketSpec{BucketDay, 86400}, l)
|
|
require.NoError(t, err)
|
|
require.Len(t, ws, 2)
|
|
assert.Equal(t, start, ws[0].Start)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-17T04:00:00Z"), ws[0].End,
|
|
"calendar day boundary is local midnight")
|
|
assert.Equal(t, end, ws[1].End)
|
|
}
|
|
|
|
func TestBuildBuckets_CalendarDaySpansDST(t *testing.T) {
|
|
l := loc(t, "America/New_York")
|
|
// Spring forward 2026-03-08 (23h local day) then a normal 24h day.
|
|
start := mustRFC3339(t, "2026-03-08T05:00:00Z") // 2026-03-08 00:00 EST
|
|
end := mustRFC3339(t, "2026-03-10T04:00:00Z") // 2026-03-10 00:00 EDT
|
|
ws, err := BuildBuckets(start, end, BucketSpec{BucketDay, 86400}, l)
|
|
require.NoError(t, err)
|
|
require.Len(t, ws, 2)
|
|
assert.Equal(t, 23*time.Hour, ws[0].End.Sub(ws[0].Start), "spring-forward calendar day is 23h")
|
|
assert.Equal(t, 24*time.Hour, ws[1].End.Sub(ws[1].Start), "following day is 24h")
|
|
}
|
|
|
|
func TestBuildBuckets_CalendarDayFallBack25h(t *testing.T) {
|
|
l := loc(t, "America/New_York")
|
|
start := mustRFC3339(t, "2026-11-01T04:00:00Z") // 2026-11-01 00:00 EDT
|
|
end := mustRFC3339(t, "2026-11-02T05:00:00Z") // 2026-11-02 00:00 EST
|
|
ws, err := BuildBuckets(start, end, BucketSpec{BucketDay, 86400}, l)
|
|
require.NoError(t, err)
|
|
require.Len(t, ws, 1)
|
|
assert.Equal(t, 25*time.Hour, ws[0].End.Sub(ws[0].Start), "fall-back calendar day is 25h")
|
|
}
|
|
|
|
func TestBuildBuckets_CalendarWeekISOMonday(t *testing.T) {
|
|
l := time.UTC
|
|
start := mustRFC3339(t, "2026-06-15T00:00:00Z") // Monday
|
|
end := mustRFC3339(t, "2026-06-29T00:00:00Z") // two ISO weeks later
|
|
ws, err := BuildBuckets(start, end, BucketSpec{BucketWeek, 604800}, l)
|
|
require.NoError(t, err)
|
|
require.Len(t, ws, 2)
|
|
assert.Equal(t, mustRFC3339(t, "2026-06-22T00:00:00Z"), ws[0].End)
|
|
}
|