all: sync with master; upd chlog
This commit is contained in:
Ainar Garipov
250
internal/schedule/schedule.go
Normal file
250
internal/schedule/schedule.go
Normal file
@@ -0,0 +1,250 @@
|
||||
// Package schedule provides types for scheduling.
|
||||
package schedule
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/AdguardTeam/golibs/errors"
|
||||
"github.com/AdguardTeam/golibs/timeutil"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// Weekly is a schedule for one week. Each day of the week has one range with
|
||||
// a beginning and an end.
|
||||
type Weekly struct {
|
||||
// location is used to calculate the offsets of the day ranges.
|
||||
location *time.Location
|
||||
|
||||
// days are the day ranges of this schedule. The indexes of this array are
|
||||
// the [time.Weekday] values.
|
||||
days [7]dayRange
|
||||
}
|
||||
|
||||
// EmptyWeekly creates empty weekly schedule with local time zone.
|
||||
func EmptyWeekly() (w *Weekly) {
|
||||
return &Weekly{
|
||||
location: time.Local,
|
||||
}
|
||||
}
|
||||
|
||||
// FullWeekly creates full weekly schedule with local time zone.
|
||||
//
|
||||
// TODO(s.chzhen): Consider moving into tests.
|
||||
func FullWeekly() (w *Weekly) {
|
||||
fullDay := dayRange{start: 0, end: maxDayRange}
|
||||
|
||||
return &Weekly{
|
||||
location: time.Local,
|
||||
days: [7]dayRange{
|
||||
time.Sunday: fullDay,
|
||||
time.Monday: fullDay,
|
||||
time.Tuesday: fullDay,
|
||||
time.Wednesday: fullDay,
|
||||
time.Thursday: fullDay,
|
||||
time.Friday: fullDay,
|
||||
time.Saturday: fullDay,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// Clone returns a deep copy of a weekly.
|
||||
func (w *Weekly) Clone() (c *Weekly) {
|
||||
// NOTE: Do not use time.LoadLocation, because the results will be
|
||||
// different on time zone database update.
|
||||
return &Weekly{
|
||||
location: w.location,
|
||||
days: w.days,
|
||||
}
|
||||
}
|
||||
|
||||
// Contains returns true if t is within the corresponding day range of the
|
||||
// schedule in the schedule's time zone.
|
||||
func (w *Weekly) Contains(t time.Time) (ok bool) {
|
||||
t = t.In(w.location)
|
||||
wd := t.Weekday()
|
||||
dr := w.days[wd]
|
||||
|
||||
// Calculate the offset of the day range.
|
||||
//
|
||||
// NOTE: Do not use [time.Truncate] since it requires UTC time zone.
|
||||
y, m, d := t.Date()
|
||||
day := time.Date(y, m, d, 0, 0, 0, 0, w.location)
|
||||
offset := t.Sub(day)
|
||||
|
||||
return dr.contains(offset)
|
||||
}
|
||||
|
||||
// type check
|
||||
var _ yaml.Unmarshaler = (*Weekly)(nil)
|
||||
|
||||
// UnmarshalYAML implements the [yaml.Unmarshaler] interface for *Weekly.
|
||||
func (w *Weekly) UnmarshalYAML(value *yaml.Node) (err error) {
|
||||
conf := &weeklyConfig{}
|
||||
|
||||
err = value.Decode(conf)
|
||||
if err != nil {
|
||||
// Don't wrap the error since it's informative enough as is.
|
||||
return err
|
||||
}
|
||||
|
||||
weekly := Weekly{}
|
||||
|
||||
weekly.location, err = time.LoadLocation(conf.TimeZone)
|
||||
if err != nil {
|
||||
// Don't wrap the error since it's informative enough as is.
|
||||
return err
|
||||
}
|
||||
|
||||
days := []dayConfig{
|
||||
time.Sunday: conf.Sunday,
|
||||
time.Monday: conf.Monday,
|
||||
time.Tuesday: conf.Tuesday,
|
||||
time.Wednesday: conf.Wednesday,
|
||||
time.Thursday: conf.Thursday,
|
||||
time.Friday: conf.Friday,
|
||||
time.Saturday: conf.Saturday,
|
||||
}
|
||||
for i, d := range days {
|
||||
r := dayRange{
|
||||
start: d.Start.Duration,
|
||||
end: d.End.Duration,
|
||||
}
|
||||
|
||||
err = w.validate(r)
|
||||
if err != nil {
|
||||
return fmt.Errorf("weekday %s: %w", time.Weekday(i), err)
|
||||
}
|
||||
|
||||
weekly.days[i] = r
|
||||
}
|
||||
|
||||
*w = weekly
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// weeklyConfig is the YAML configuration structure of Weekly.
|
||||
type weeklyConfig struct {
|
||||
// TimeZone is the local time zone.
|
||||
TimeZone string `yaml:"time_zone"`
|
||||
|
||||
// Days of the week.
|
||||
|
||||
Sunday dayConfig `yaml:"sun,omitempty"`
|
||||
Monday dayConfig `yaml:"mon,omitempty"`
|
||||
Tuesday dayConfig `yaml:"tue,omitempty"`
|
||||
Wednesday dayConfig `yaml:"wed,omitempty"`
|
||||
Thursday dayConfig `yaml:"thu,omitempty"`
|
||||
Friday dayConfig `yaml:"fri,omitempty"`
|
||||
Saturday dayConfig `yaml:"sat,omitempty"`
|
||||
}
|
||||
|
||||
// dayConfig is the YAML configuration structure of dayRange.
|
||||
type dayConfig struct {
|
||||
Start timeutil.Duration `yaml:"start"`
|
||||
End timeutil.Duration `yaml:"end"`
|
||||
}
|
||||
|
||||
// maxDayRange is the maximum value for day range end.
|
||||
const maxDayRange = 24 * time.Hour
|
||||
|
||||
// validate returns the day range rounding errors, if any.
|
||||
func (w *Weekly) validate(r dayRange) (err error) {
|
||||
defer func() { err = errors.Annotate(err, "bad day range: %w") }()
|
||||
|
||||
err = r.validate()
|
||||
if err != nil {
|
||||
// Don't wrap the error since it's informative enough as is.
|
||||
return err
|
||||
}
|
||||
|
||||
start := r.start.Truncate(time.Minute)
|
||||
end := r.end.Truncate(time.Minute)
|
||||
|
||||
switch {
|
||||
case start != r.start:
|
||||
return fmt.Errorf("start %s isn't rounded to minutes", r.start)
|
||||
case end != r.end:
|
||||
return fmt.Errorf("end %s isn't rounded to minutes", r.end)
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// type check
|
||||
var _ yaml.Marshaler = (*Weekly)(nil)
|
||||
|
||||
// MarshalYAML implements the [yaml.Marshaler] interface for *Weekly.
|
||||
func (w *Weekly) MarshalYAML() (v any, err error) {
|
||||
return weeklyConfig{
|
||||
TimeZone: w.location.String(),
|
||||
Sunday: dayConfig{
|
||||
Start: timeutil.Duration{Duration: w.days[time.Sunday].start},
|
||||
End: timeutil.Duration{Duration: w.days[time.Sunday].end},
|
||||
},
|
||||
Monday: dayConfig{
|
||||
Start: timeutil.Duration{Duration: w.days[time.Monday].start},
|
||||
End: timeutil.Duration{Duration: w.days[time.Monday].end},
|
||||
},
|
||||
Tuesday: dayConfig{
|
||||
Start: timeutil.Duration{Duration: w.days[time.Tuesday].start},
|
||||
End: timeutil.Duration{Duration: w.days[time.Tuesday].end},
|
||||
},
|
||||
Wednesday: dayConfig{
|
||||
Start: timeutil.Duration{Duration: w.days[time.Wednesday].start},
|
||||
End: timeutil.Duration{Duration: w.days[time.Wednesday].end},
|
||||
},
|
||||
Thursday: dayConfig{
|
||||
Start: timeutil.Duration{Duration: w.days[time.Thursday].start},
|
||||
End: timeutil.Duration{Duration: w.days[time.Thursday].end},
|
||||
},
|
||||
Friday: dayConfig{
|
||||
Start: timeutil.Duration{Duration: w.days[time.Friday].start},
|
||||
End: timeutil.Duration{Duration: w.days[time.Friday].end},
|
||||
},
|
||||
Saturday: dayConfig{
|
||||
Start: timeutil.Duration{Duration: w.days[time.Saturday].start},
|
||||
End: timeutil.Duration{Duration: w.days[time.Saturday].end},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
// dayRange represents a single interval within a day. The interval begins at
|
||||
// start and ends before end. That is, it contains a time point T if start <=
|
||||
// T < end.
|
||||
type dayRange struct {
|
||||
// start is an offset from the beginning of the day. It must be greater
|
||||
// than or equal to zero and less than 24h.
|
||||
start time.Duration
|
||||
|
||||
// end is an offset from the beginning of the day. It must be greater than
|
||||
// or equal to zero and less than or equal to 24h.
|
||||
end time.Duration
|
||||
}
|
||||
|
||||
// validate returns the day range validation errors, if any.
|
||||
func (r dayRange) validate() (err error) {
|
||||
switch {
|
||||
case r == dayRange{}:
|
||||
return nil
|
||||
case r.start < 0:
|
||||
return fmt.Errorf("start %s is negative", r.start)
|
||||
case r.end < 0:
|
||||
return fmt.Errorf("end %s is negative", r.end)
|
||||
case r.start >= r.end:
|
||||
return fmt.Errorf("start %s is greater or equal to end %s", r.start, r.end)
|
||||
case r.start >= maxDayRange:
|
||||
return fmt.Errorf("start %s is greater or equal to %s", r.start, maxDayRange)
|
||||
case r.end > maxDayRange:
|
||||
return fmt.Errorf("end %s is greater than %s", r.end, maxDayRange)
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// contains returns true if start <= offset < end, where offset is the time
|
||||
// duration from the beginning of the day.
|
||||
func (r *dayRange) contains(offset time.Duration) (ok bool) {
|
||||
return r.start <= offset && offset < r.end
|
||||
}
|
||||
371
internal/schedule/schedule_internal_test.go
Normal file
371
internal/schedule/schedule_internal_test.go
Normal file
@@ -0,0 +1,371 @@
|
||||
package schedule
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/AdguardTeam/golibs/testutil"
|
||||
"github.com/AdguardTeam/golibs/timeutil"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
func TestWeekly_Contains(t *testing.T) {
|
||||
baseTime := time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)
|
||||
otherTime := baseTime.Add(1 * timeutil.Day)
|
||||
|
||||
// NOTE: In the Etc area the sign of the offsets is flipped. So, Etc/GMT-3
|
||||
// is actually UTC+03:00.
|
||||
otherTZ := time.FixedZone("Etc/GMT-3", 3*60*60)
|
||||
|
||||
// baseSchedule, 12:00 to 14:00.
|
||||
baseSchedule := &Weekly{
|
||||
days: [7]dayRange{
|
||||
time.Friday: {start: 12 * time.Hour, end: 14 * time.Hour},
|
||||
},
|
||||
location: time.UTC,
|
||||
}
|
||||
|
||||
// allDaySchedule, 00:00 to 24:00.
|
||||
allDaySchedule := &Weekly{
|
||||
days: [7]dayRange{
|
||||
time.Friday: {start: 0, end: 24 * time.Hour},
|
||||
},
|
||||
location: time.UTC,
|
||||
}
|
||||
|
||||
// oneMinSchedule, 00:00 to 00:01.
|
||||
oneMinSchedule := &Weekly{
|
||||
days: [7]dayRange{
|
||||
time.Friday: {start: 0, end: 1 * time.Minute},
|
||||
},
|
||||
location: time.UTC,
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
schedule *Weekly
|
||||
assert assert.BoolAssertionFunc
|
||||
t time.Time
|
||||
name string
|
||||
}{{
|
||||
schedule: EmptyWeekly(),
|
||||
assert: assert.False,
|
||||
t: baseTime,
|
||||
name: "empty",
|
||||
}, {
|
||||
schedule: allDaySchedule,
|
||||
assert: assert.True,
|
||||
t: baseTime,
|
||||
name: "same_day_all_day",
|
||||
}, {
|
||||
schedule: baseSchedule,
|
||||
assert: assert.True,
|
||||
t: baseTime.Add(13 * time.Hour),
|
||||
name: "same_day_inside",
|
||||
}, {
|
||||
schedule: baseSchedule,
|
||||
assert: assert.False,
|
||||
t: baseTime.Add(11 * time.Hour),
|
||||
name: "same_day_outside",
|
||||
}, {
|
||||
schedule: allDaySchedule,
|
||||
assert: assert.True,
|
||||
t: baseTime.Add(24*time.Hour - time.Second),
|
||||
name: "same_day_last_second",
|
||||
}, {
|
||||
schedule: allDaySchedule,
|
||||
assert: assert.False,
|
||||
t: otherTime,
|
||||
name: "other_day_all_day",
|
||||
}, {
|
||||
schedule: baseSchedule,
|
||||
assert: assert.False,
|
||||
t: otherTime.Add(13 * time.Hour),
|
||||
name: "other_day_inside",
|
||||
}, {
|
||||
schedule: baseSchedule,
|
||||
assert: assert.False,
|
||||
t: otherTime.Add(11 * time.Hour),
|
||||
name: "other_day_outside",
|
||||
}, {
|
||||
schedule: baseSchedule,
|
||||
assert: assert.True,
|
||||
t: baseTime.Add(13 * time.Hour).In(otherTZ),
|
||||
name: "same_day_inside_other_tz",
|
||||
}, {
|
||||
schedule: baseSchedule,
|
||||
assert: assert.False,
|
||||
t: baseTime.Add(11 * time.Hour).In(otherTZ),
|
||||
name: "same_day_outside_other_tz",
|
||||
}, {
|
||||
schedule: oneMinSchedule,
|
||||
assert: assert.True,
|
||||
t: baseTime,
|
||||
name: "one_minute_beginning",
|
||||
}, {
|
||||
schedule: oneMinSchedule,
|
||||
assert: assert.True,
|
||||
t: baseTime.Add(1*time.Minute - 1),
|
||||
name: "one_minute_end",
|
||||
}, {
|
||||
schedule: oneMinSchedule,
|
||||
assert: assert.False,
|
||||
t: baseTime.Add(1 * time.Minute),
|
||||
name: "one_minute_past_end",
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
tc.assert(t, tc.schedule.Contains(tc.t))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
const brusselsSunday = `
|
||||
sun:
|
||||
start: 12h
|
||||
end: 14h
|
||||
time_zone: Europe/Brussels
|
||||
`
|
||||
|
||||
func TestWeekly_UnmarshalYAML(t *testing.T) {
|
||||
const (
|
||||
sameTime = `
|
||||
sun:
|
||||
start: 9h
|
||||
end: 9h
|
||||
`
|
||||
negativeStart = `
|
||||
sun:
|
||||
start: -1h
|
||||
end: 1h
|
||||
`
|
||||
badTZ = `
|
||||
time_zone: "bad_timezone"
|
||||
`
|
||||
badYAML = `
|
||||
yaml: "bad"
|
||||
yaml: "bad"
|
||||
`
|
||||
)
|
||||
|
||||
brusseltsTZ, err := time.LoadLocation("Europe/Brussels")
|
||||
require.NoError(t, err)
|
||||
|
||||
brusselsWeekly := &Weekly{
|
||||
days: [7]dayRange{{
|
||||
start: time.Hour * 12,
|
||||
end: time.Hour * 14,
|
||||
}},
|
||||
location: brusseltsTZ,
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
name string
|
||||
wantErrMsg string
|
||||
data []byte
|
||||
want *Weekly
|
||||
}{{
|
||||
name: "empty",
|
||||
wantErrMsg: "",
|
||||
data: []byte(""),
|
||||
want: &Weekly{},
|
||||
}, {
|
||||
name: "null",
|
||||
wantErrMsg: "",
|
||||
data: []byte("null"),
|
||||
want: &Weekly{},
|
||||
}, {
|
||||
name: "brussels_sunday",
|
||||
wantErrMsg: "",
|
||||
data: []byte(brusselsSunday),
|
||||
want: brusselsWeekly,
|
||||
}, {
|
||||
name: "start_equal_end",
|
||||
wantErrMsg: "weekday Sunday: bad day range: start 9h0m0s is greater or equal to end 9h0m0s",
|
||||
data: []byte(sameTime),
|
||||
want: &Weekly{},
|
||||
}, {
|
||||
name: "start_negative",
|
||||
wantErrMsg: "weekday Sunday: bad day range: start -1h0m0s is negative",
|
||||
data: []byte(negativeStart),
|
||||
want: &Weekly{},
|
||||
}, {
|
||||
name: "bad_time_zone",
|
||||
wantErrMsg: "unknown time zone bad_timezone",
|
||||
data: []byte(badTZ),
|
||||
want: &Weekly{},
|
||||
}, {
|
||||
name: "bad_yaml",
|
||||
wantErrMsg: "yaml: unmarshal errors:\n line 3: mapping key \"yaml\" already defined at line 2",
|
||||
data: []byte(badYAML),
|
||||
want: &Weekly{},
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
w := &Weekly{}
|
||||
err = yaml.Unmarshal(tc.data, w)
|
||||
testutil.AssertErrorMsg(t, tc.wantErrMsg, err)
|
||||
|
||||
assert.Equal(t, tc.want, w)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWeekly_MarshalYAML(t *testing.T) {
|
||||
brusselsTZ, err := time.LoadLocation("Europe/Brussels")
|
||||
require.NoError(t, err)
|
||||
|
||||
brusselsWeekly := &Weekly{
|
||||
days: [7]dayRange{time.Sunday: {
|
||||
start: time.Hour * 12,
|
||||
end: time.Hour * 14,
|
||||
}},
|
||||
location: brusselsTZ,
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
name string
|
||||
data []byte
|
||||
want *Weekly
|
||||
}{{
|
||||
name: "empty",
|
||||
data: []byte(""),
|
||||
want: &Weekly{},
|
||||
}, {
|
||||
name: "null",
|
||||
data: []byte("null"),
|
||||
want: &Weekly{},
|
||||
}, {
|
||||
name: "brussels_sunday",
|
||||
data: []byte(brusselsSunday),
|
||||
want: brusselsWeekly,
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
var data []byte
|
||||
data, err = yaml.Marshal(brusselsWeekly)
|
||||
require.NoError(t, err)
|
||||
|
||||
w := &Weekly{}
|
||||
err = yaml.Unmarshal(data, w)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, brusselsWeekly, w)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWeekly_Validate(t *testing.T) {
|
||||
testCases := []struct {
|
||||
name string
|
||||
in dayRange
|
||||
wantErrMsg string
|
||||
}{{
|
||||
name: "empty",
|
||||
wantErrMsg: "",
|
||||
in: dayRange{},
|
||||
}, {
|
||||
name: "start_seconds",
|
||||
wantErrMsg: "bad day range: start 1s isn't rounded to minutes",
|
||||
in: dayRange{
|
||||
start: time.Second,
|
||||
end: time.Hour,
|
||||
},
|
||||
}, {
|
||||
name: "end_seconds",
|
||||
wantErrMsg: "bad day range: end 1s isn't rounded to minutes",
|
||||
in: dayRange{
|
||||
start: 0,
|
||||
end: time.Second,
|
||||
},
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
w := &Weekly{}
|
||||
err := w.validate(tc.in)
|
||||
|
||||
testutil.AssertErrorMsg(t, tc.wantErrMsg, err)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDayRange_Validate(t *testing.T) {
|
||||
testCases := []struct {
|
||||
name string
|
||||
in dayRange
|
||||
wantErrMsg string
|
||||
}{{
|
||||
name: "empty",
|
||||
wantErrMsg: "",
|
||||
in: dayRange{},
|
||||
}, {
|
||||
name: "valid",
|
||||
wantErrMsg: "",
|
||||
in: dayRange{
|
||||
start: time.Hour,
|
||||
end: time.Hour * 2,
|
||||
},
|
||||
}, {
|
||||
name: "valid_end_max",
|
||||
wantErrMsg: "",
|
||||
in: dayRange{
|
||||
start: 0,
|
||||
end: time.Hour * 24,
|
||||
},
|
||||
}, {
|
||||
name: "start_negative",
|
||||
wantErrMsg: "start -1h0m0s is negative",
|
||||
in: dayRange{
|
||||
start: time.Hour * -1,
|
||||
end: time.Hour * 2,
|
||||
},
|
||||
}, {
|
||||
name: "end_negative",
|
||||
wantErrMsg: "end -1h0m0s is negative",
|
||||
in: dayRange{
|
||||
start: 0,
|
||||
end: time.Hour * -1,
|
||||
},
|
||||
}, {
|
||||
name: "start_equal_end",
|
||||
wantErrMsg: "start 1h0m0s is greater or equal to end 1h0m0s",
|
||||
in: dayRange{
|
||||
start: time.Hour,
|
||||
end: time.Hour,
|
||||
},
|
||||
}, {
|
||||
name: "start_greater_end",
|
||||
wantErrMsg: "start 2h0m0s is greater or equal to end 1h0m0s",
|
||||
in: dayRange{
|
||||
start: time.Hour * 2,
|
||||
end: time.Hour,
|
||||
},
|
||||
}, {
|
||||
name: "start_equal_max",
|
||||
wantErrMsg: "start 24h0m0s is greater or equal to 24h0m0s",
|
||||
in: dayRange{
|
||||
start: time.Hour * 24,
|
||||
end: time.Hour * 48,
|
||||
},
|
||||
}, {
|
||||
name: "end_greater_max",
|
||||
wantErrMsg: "end 48h0m0s is greater than 24h0m0s",
|
||||
in: dayRange{
|
||||
start: 0,
|
||||
end: time.Hour * 48,
|
||||
},
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
err := tc.in.validate()
|
||||
|
||||
testutil.AssertErrorMsg(t, tc.wantErrMsg, err)
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user