757 lines
18 KiB
Go
757 lines
18 KiB
Go
// Copyright 2020 Prometheus Team
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package timeinterval
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
var timeIntervalTestCases = []struct {
|
|
validTimeStrings []string
|
|
invalidTimeStrings []string
|
|
timeInterval TimeInterval
|
|
}{
|
|
{
|
|
timeInterval: TimeInterval{},
|
|
validTimeStrings: []string{
|
|
"02 Jan 06 15:04 +0000",
|
|
"03 Jan 07 10:04 +0000",
|
|
"04 Jan 06 09:04 +0000",
|
|
},
|
|
invalidTimeStrings: []string{},
|
|
},
|
|
{
|
|
// 9am to 5pm, monday to friday
|
|
timeInterval: TimeInterval{
|
|
Times: []TimeRange{{StartMinute: 540, EndMinute: 1020}},
|
|
Weekdays: []WeekdayRange{{InclusiveRange{Begin: 1, End: 5}}},
|
|
},
|
|
validTimeStrings: []string{
|
|
"04 May 20 15:04 +0000",
|
|
"05 May 20 10:04 +0000",
|
|
"09 Jun 20 09:04 +0000",
|
|
},
|
|
invalidTimeStrings: []string{
|
|
"03 May 20 15:04 +0000",
|
|
"04 May 20 08:59 +0000",
|
|
"05 May 20 05:00 +0000",
|
|
},
|
|
},
|
|
{
|
|
// Easter 2020
|
|
timeInterval: TimeInterval{
|
|
DaysOfMonth: []DayOfMonthRange{{InclusiveRange{Begin: 4, End: 6}}},
|
|
Months: []MonthRange{{InclusiveRange{Begin: 4, End: 4}}},
|
|
Years: []YearRange{{InclusiveRange{Begin: 2020, End: 2020}}},
|
|
},
|
|
validTimeStrings: []string{
|
|
"04 Apr 20 15:04 +0000",
|
|
"05 Apr 20 00:00 +0000",
|
|
"06 Apr 20 23:05 +0000",
|
|
},
|
|
invalidTimeStrings: []string{
|
|
"03 May 18 15:04 +0000",
|
|
"03 Apr 20 23:59 +0000",
|
|
"04 Jun 20 23:59 +0000",
|
|
"06 Apr 19 23:59 +0000",
|
|
"07 Apr 20 00:00 +0000",
|
|
},
|
|
},
|
|
{
|
|
// Check negative days of month, last 3 days of each month
|
|
timeInterval: TimeInterval{
|
|
DaysOfMonth: []DayOfMonthRange{{InclusiveRange{Begin: -3, End: -1}}},
|
|
},
|
|
validTimeStrings: []string{
|
|
"31 Jan 20 15:04 +0000",
|
|
"30 Jan 20 15:04 +0000",
|
|
"29 Jan 20 15:04 +0000",
|
|
"30 Jun 20 00:00 +0000",
|
|
"29 Feb 20 23:05 +0000",
|
|
},
|
|
invalidTimeStrings: []string{
|
|
"03 May 18 15:04 +0000",
|
|
"27 Jan 20 15:04 +0000",
|
|
"03 Apr 20 23:59 +0000",
|
|
"04 Jun 20 23:59 +0000",
|
|
"06 Apr 19 23:59 +0000",
|
|
"07 Apr 20 00:00 +0000",
|
|
"01 Mar 20 00:00 +0000",
|
|
},
|
|
},
|
|
{
|
|
// Check out of bound days are clamped to month boundaries
|
|
timeInterval: TimeInterval{
|
|
Months: []MonthRange{{InclusiveRange{Begin: 6, End: 6}}},
|
|
DaysOfMonth: []DayOfMonthRange{{InclusiveRange{Begin: -31, End: 31}}},
|
|
},
|
|
validTimeStrings: []string{
|
|
"30 Jun 20 00:00 +0000",
|
|
"01 Jun 20 00:00 +0000",
|
|
},
|
|
invalidTimeStrings: []string{
|
|
"31 May 20 00:00 +0000",
|
|
"1 Jul 20 00:00 +0000",
|
|
},
|
|
},
|
|
{
|
|
// Check alternative timezones can be used to compare times.
|
|
// AEST 9AM to 5PM, Monday to Friday.
|
|
timeInterval: TimeInterval{
|
|
Times: []TimeRange{{StartMinute: 540, EndMinute: 1020}},
|
|
Weekdays: []WeekdayRange{{InclusiveRange{Begin: 1, End: 5}}},
|
|
Location: &Location{mustLoadLocation("Australia/Sydney")},
|
|
},
|
|
validTimeStrings: []string{
|
|
"06 Apr 21 13:00 +1000",
|
|
},
|
|
invalidTimeStrings: []string{
|
|
"06 Apr 21 13:00 +0000",
|
|
},
|
|
},
|
|
{
|
|
// Check an alternative timezone during daylight savings time.
|
|
timeInterval: TimeInterval{
|
|
Times: []TimeRange{{StartMinute: 540, EndMinute: 1020}},
|
|
Weekdays: []WeekdayRange{{InclusiveRange{Begin: 1, End: 5}}},
|
|
Months: []MonthRange{{InclusiveRange{Begin: 11, End: 11}}},
|
|
Location: &Location{mustLoadLocation("Australia/Sydney")},
|
|
},
|
|
validTimeStrings: []string{
|
|
"01 Nov 21 09:00 +1100",
|
|
"31 Oct 21 22:00 +0000",
|
|
},
|
|
invalidTimeStrings: []string{
|
|
"31 Oct 21 21:00 +0000",
|
|
},
|
|
},
|
|
}
|
|
|
|
var timeStringTestCases = []struct {
|
|
timeString string
|
|
TimeRange TimeRange
|
|
expectError bool
|
|
}{
|
|
{
|
|
timeString: "{'start_time': '00:00', 'end_time': '24:00'}",
|
|
TimeRange: TimeRange{StartMinute: 0, EndMinute: 1440},
|
|
expectError: false,
|
|
},
|
|
{
|
|
timeString: "{'start_time': '01:35', 'end_time': '17:39'}",
|
|
TimeRange: TimeRange{StartMinute: 95, EndMinute: 1059},
|
|
expectError: false,
|
|
},
|
|
{
|
|
timeString: "{'start_time': '09:35', 'end_time': '09:39'}",
|
|
TimeRange: TimeRange{StartMinute: 575, EndMinute: 579},
|
|
expectError: false,
|
|
},
|
|
{
|
|
// Error: Begin and End times are the same
|
|
timeString: "{'start_time': '17:31', 'end_time': '17:31'}",
|
|
TimeRange: TimeRange{},
|
|
expectError: true,
|
|
},
|
|
{
|
|
// Error: End time out of range
|
|
timeString: "{'start_time': '12:30', 'end_time': '24:01'}",
|
|
TimeRange: TimeRange{},
|
|
expectError: true,
|
|
},
|
|
{
|
|
// Error: Start time greater than End time
|
|
timeString: "{'start_time': '09:30', 'end_time': '07:41'}",
|
|
TimeRange: TimeRange{},
|
|
expectError: true,
|
|
},
|
|
{
|
|
// Error: Start time out of range and greater than End time
|
|
timeString: "{'start_time': '24:00', 'end_time': '17:41'}",
|
|
TimeRange: TimeRange{},
|
|
expectError: true,
|
|
},
|
|
{
|
|
// Error: No range specified
|
|
timeString: "{'start_time': '14:03'}",
|
|
TimeRange: TimeRange{},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
var yamlUnmarshalTestCases = []struct {
|
|
in string
|
|
intervals []TimeInterval
|
|
contains []string
|
|
excludes []string
|
|
expectError bool
|
|
err string
|
|
}{
|
|
{
|
|
// Simple business hours test
|
|
in: `
|
|
---
|
|
- weekdays: ['monday:friday']
|
|
times:
|
|
- start_time: '09:00'
|
|
end_time: '17:00'
|
|
`,
|
|
intervals: []TimeInterval{
|
|
{
|
|
Weekdays: []WeekdayRange{{InclusiveRange{Begin: 1, End: 5}}},
|
|
Times: []TimeRange{{StartMinute: 540, EndMinute: 1020}},
|
|
},
|
|
},
|
|
contains: []string{
|
|
"08 Jul 20 09:00 +0000",
|
|
"08 Jul 20 16:59 +0000",
|
|
},
|
|
excludes: []string{
|
|
"08 Jul 20 05:00 +0000",
|
|
"08 Jul 20 08:59 +0000",
|
|
},
|
|
expectError: false,
|
|
},
|
|
{
|
|
// More advanced test with negative indices and ranges
|
|
in: `
|
|
---
|
|
# Last week, excluding Saturday, of the first quarter of the year during business hours from 2020 to 2025 and 2030-2035
|
|
- weekdays: ['monday:friday', 'sunday']
|
|
months: ['january:march']
|
|
days_of_month: ['-7:-1']
|
|
years: ['2020:2025', '2030:2035']
|
|
times:
|
|
- start_time: '09:00'
|
|
end_time: '17:00'
|
|
`,
|
|
intervals: []TimeInterval{
|
|
{
|
|
Weekdays: []WeekdayRange{{InclusiveRange{Begin: 1, End: 5}}, {InclusiveRange{Begin: 0, End: 0}}},
|
|
Times: []TimeRange{{StartMinute: 540, EndMinute: 1020}},
|
|
Months: []MonthRange{{InclusiveRange{1, 3}}},
|
|
DaysOfMonth: []DayOfMonthRange{{InclusiveRange{-7, -1}}},
|
|
Years: []YearRange{{InclusiveRange{2020, 2025}}, {InclusiveRange{2030, 2035}}},
|
|
},
|
|
},
|
|
contains: []string{
|
|
"27 Jan 21 09:00 +0000",
|
|
"28 Jan 21 16:59 +0000",
|
|
"29 Jan 21 13:00 +0000",
|
|
"31 Mar 25 13:00 +0000",
|
|
"31 Mar 25 13:00 +0000",
|
|
"31 Jan 35 13:00 +0000",
|
|
},
|
|
excludes: []string{
|
|
"30 Jan 21 13:00 +0000", // Saturday
|
|
"01 Apr 21 13:00 +0000", // 4th month
|
|
"30 Jan 26 13:00 +0000", // 2026
|
|
"31 Jan 35 17:01 +0000", // After 5pm
|
|
},
|
|
expectError: false,
|
|
},
|
|
{
|
|
in: `
|
|
---
|
|
- weekdays: ['monday:friday']
|
|
times:
|
|
- start_time: '09:00'
|
|
end_time: '17:00'`,
|
|
intervals: []TimeInterval{
|
|
{
|
|
Weekdays: []WeekdayRange{{InclusiveRange{Begin: 1, End: 5}}},
|
|
Times: []TimeRange{{StartMinute: 540, EndMinute: 1020}},
|
|
},
|
|
},
|
|
contains: []string{
|
|
"01 Apr 21 13:00 +0000",
|
|
},
|
|
},
|
|
{
|
|
// Invalid start time.
|
|
in: `
|
|
---
|
|
- times:
|
|
- start_time: '01:99'
|
|
end_time: '23:59'`,
|
|
expectError: true,
|
|
err: "couldn't parse timestamp 01:99, invalid format",
|
|
},
|
|
{
|
|
// Invalid end time.
|
|
in: `
|
|
---
|
|
- times:
|
|
- start_time: '00:00'
|
|
end_time: '99:99'`,
|
|
expectError: true,
|
|
err: "couldn't parse timestamp 99:99, invalid format",
|
|
},
|
|
{
|
|
// Start day before end day.
|
|
in: `
|
|
---
|
|
- weekdays: ['friday:monday']`,
|
|
expectError: true,
|
|
err: "start day cannot be before end day",
|
|
},
|
|
{
|
|
// Invalid weekdays.
|
|
in: `
|
|
---
|
|
- weekdays: ['blurgsday:flurgsday']
|
|
`,
|
|
expectError: true,
|
|
err: "blurgsday is not a valid weekday",
|
|
},
|
|
{
|
|
// Numeric weekdays aren't allowed.
|
|
in: `
|
|
---
|
|
- weekdays: ['1:3']
|
|
`,
|
|
expectError: true,
|
|
err: "1 is not a valid weekday",
|
|
},
|
|
{
|
|
// Negative numeric weekdays aren't allowed.
|
|
in: `
|
|
---
|
|
- weekdays: ['-2:-1']
|
|
`,
|
|
expectError: true,
|
|
err: "-2 is not a valid weekday",
|
|
},
|
|
{
|
|
// 0 day of month.
|
|
in: `
|
|
---
|
|
- days_of_month: ['0']
|
|
`,
|
|
expectError: true,
|
|
err: "0 is not a valid day of the month: out of range",
|
|
},
|
|
{
|
|
// Start day of month < 0.
|
|
in: `
|
|
---
|
|
- days_of_month: ['-50:-20']
|
|
`,
|
|
expectError: true,
|
|
err: "-50 is not a valid day of the month: out of range",
|
|
},
|
|
{
|
|
// End day of month > 31.
|
|
in: `
|
|
---
|
|
- days_of_month: ['1:50']
|
|
`,
|
|
expectError: true,
|
|
err: "50 is not a valid day of the month: out of range",
|
|
},
|
|
{
|
|
// Negative indices should work.
|
|
in: `
|
|
---
|
|
- days_of_month: ['1:-1']
|
|
`,
|
|
intervals: []TimeInterval{
|
|
{
|
|
DaysOfMonth: []DayOfMonthRange{{InclusiveRange{1, -1}}},
|
|
},
|
|
},
|
|
expectError: false,
|
|
},
|
|
{
|
|
// End day must be negative if begin day is negative.
|
|
in: `
|
|
---
|
|
- days_of_month: ['-15:5']
|
|
`,
|
|
expectError: true,
|
|
err: "end day must be negative if start day is negative",
|
|
},
|
|
{
|
|
// Negative end date before positive positive start date.
|
|
in: `
|
|
---
|
|
- days_of_month: ['10:-25']
|
|
`,
|
|
expectError: true,
|
|
err: "end day -25 is always before start day 10",
|
|
},
|
|
{
|
|
// Months should work regardless of case
|
|
in: `
|
|
---
|
|
- months: ['January:december']
|
|
`,
|
|
expectError: false,
|
|
intervals: []TimeInterval{
|
|
{
|
|
Months: []MonthRange{{InclusiveRange{1, 12}}},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Time zones may be specified by location.
|
|
in: `
|
|
---
|
|
- years: ['2020:2022']
|
|
location: 'Australia/Sydney'
|
|
`,
|
|
expectError: false,
|
|
intervals: []TimeInterval{
|
|
{
|
|
Years: []YearRange{{InclusiveRange{2020, 2022}}},
|
|
Location: &Location{mustLoadLocation("Australia/Sydney")},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Invalid start month.
|
|
in: `
|
|
---
|
|
- months: ['martius:june']
|
|
`,
|
|
expectError: true,
|
|
err: "martius is not a valid month",
|
|
},
|
|
{
|
|
// Invalid end month.
|
|
in: `
|
|
---
|
|
- months: ['march:junius']
|
|
`,
|
|
expectError: true,
|
|
err: "junius is not a valid month",
|
|
},
|
|
{
|
|
// Start month after end month.
|
|
in: `
|
|
---
|
|
- months: ['december:january']
|
|
`,
|
|
expectError: true,
|
|
err: "end month january is before start month december",
|
|
},
|
|
{
|
|
// Start year after end year.
|
|
in: `
|
|
---
|
|
- years: ['2022:2020']
|
|
`,
|
|
expectError: true,
|
|
err: "end year 2020 is before start year 2022",
|
|
},
|
|
}
|
|
|
|
func TestYamlUnmarshal(t *testing.T) {
|
|
for _, tc := range yamlUnmarshalTestCases {
|
|
var ti []TimeInterval
|
|
err := yaml.Unmarshal([]byte(tc.in), &ti)
|
|
if err != nil && !tc.expectError {
|
|
t.Errorf("Received unexpected error: %v when parsing %v", err, tc.in)
|
|
} else if err == nil && tc.expectError {
|
|
t.Errorf("Expected error when unmarshalling %s but didn't receive one", tc.in)
|
|
} else if err != nil && tc.expectError {
|
|
if err.Error() != tc.err {
|
|
t.Errorf("Incorrect error: Want %s, got %s", tc.err, err.Error())
|
|
}
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(ti, tc.intervals) {
|
|
t.Errorf("Error unmarshalling %s: Want %+v, got %+v", tc.in, tc.intervals, ti)
|
|
}
|
|
for _, ts := range tc.contains {
|
|
_t, _ := time.Parse(time.RFC822Z, ts)
|
|
isContained := false
|
|
for _, interval := range ti {
|
|
if interval.ContainsTime(_t) {
|
|
isContained = true
|
|
}
|
|
}
|
|
if !isContained {
|
|
t.Errorf("Expected intervals to contain time %s", _t)
|
|
}
|
|
}
|
|
for _, ts := range tc.excludes {
|
|
_t, _ := time.Parse(time.RFC822Z, ts)
|
|
isContained := false
|
|
for _, interval := range ti {
|
|
if interval.ContainsTime(_t) {
|
|
isContained = true
|
|
}
|
|
}
|
|
if isContained {
|
|
t.Errorf("Expected intervals to exclude time %s", _t)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestContainsTime(t *testing.T) {
|
|
for _, tc := range timeIntervalTestCases {
|
|
for _, ts := range tc.validTimeStrings {
|
|
_t, _ := time.Parse(time.RFC822Z, ts)
|
|
if !tc.timeInterval.ContainsTime(_t) {
|
|
t.Errorf("Expected period %+v to contain %+v", tc.timeInterval, _t)
|
|
}
|
|
}
|
|
for _, ts := range tc.invalidTimeStrings {
|
|
_t, _ := time.Parse(time.RFC822Z, ts)
|
|
if tc.timeInterval.ContainsTime(_t) {
|
|
t.Errorf("Period %+v not expected to contain %+v", tc.timeInterval, _t)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseTimeString(t *testing.T) {
|
|
for _, tc := range timeStringTestCases {
|
|
var tr TimeRange
|
|
err := yaml.Unmarshal([]byte(tc.timeString), &tr)
|
|
if err != nil && !tc.expectError {
|
|
t.Errorf("Received unexpected error: %v when parsing %v", err, tc.timeString)
|
|
} else if err == nil && tc.expectError {
|
|
t.Errorf("Expected error for invalid string %s but didn't receive one", tc.timeString)
|
|
} else if !reflect.DeepEqual(tr, tc.TimeRange) {
|
|
t.Errorf("Error parsing time string %s: Want %+v, got %+v", tc.timeString, tc.TimeRange, tr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestYamlMarshal(t *testing.T) {
|
|
for _, tc := range yamlUnmarshalTestCases {
|
|
if tc.expectError {
|
|
continue
|
|
}
|
|
var ti []TimeInterval
|
|
err := yaml.Unmarshal([]byte(tc.in), &ti)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
out, err := yaml.Marshal(&ti)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
var ti2 []TimeInterval
|
|
yaml.Unmarshal(out, &ti2)
|
|
if !reflect.DeepEqual(ti, ti2) {
|
|
t.Errorf("Re-marshalling %s produced a different TimeInterval.", tc.in)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test JSON marshalling by marshalling a time interval
|
|
// and then unmarshalling to ensure they're identical
|
|
func TestJsonMarshal(t *testing.T) {
|
|
for _, tc := range yamlUnmarshalTestCases {
|
|
if tc.expectError {
|
|
continue
|
|
}
|
|
var ti []TimeInterval
|
|
err := yaml.Unmarshal([]byte(tc.in), &ti)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
out, err := json.Marshal(&ti)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
var ti2 []TimeInterval
|
|
json.Unmarshal(out, &ti2)
|
|
if !reflect.DeepEqual(ti, ti2) {
|
|
t.Errorf("Re-marshalling %s produced a different TimeInterval. Used:\n%s and got:\n%v", tc.in, out, ti2)
|
|
}
|
|
}
|
|
}
|
|
|
|
var completeTestCases = []struct {
|
|
in string
|
|
contains []string
|
|
excludes []string
|
|
}{
|
|
{
|
|
in: `
|
|
---
|
|
weekdays: ['monday:wednesday', 'saturday', 'sunday']
|
|
times:
|
|
- start_time: '13:00'
|
|
end_time: '15:00'
|
|
days_of_month: ['1', '10', '20:-1']
|
|
years: ['2020:2023']
|
|
months: ['january:march']
|
|
`,
|
|
contains: []string{
|
|
"10 Jan 21 13:00 +0000",
|
|
"30 Jan 21 14:24 +0000",
|
|
},
|
|
excludes: []string{
|
|
"09 Jan 21 13:00 +0000",
|
|
"20 Jan 21 12:59 +0000",
|
|
"02 Feb 21 13:00 +0000",
|
|
},
|
|
},
|
|
{
|
|
// Check for broken clamping (clamping begin date after end of month to the end of the month)
|
|
in: `
|
|
---
|
|
days_of_month: ['30:31']
|
|
years: ['2020:2023']
|
|
months: ['february']
|
|
`,
|
|
excludes: []string{
|
|
"28 Feb 21 13:00 +0000",
|
|
},
|
|
},
|
|
}
|
|
|
|
// Tests the entire flow from unmarshalling to containing a time
|
|
func TestTimeIntervalComplete(t *testing.T) {
|
|
for _, tc := range completeTestCases {
|
|
var ti TimeInterval
|
|
if err := yaml.Unmarshal([]byte(tc.in), &ti); err != nil {
|
|
t.Error(err)
|
|
}
|
|
for _, ts := range tc.contains {
|
|
tt, err := time.Parse(time.RFC822Z, ts)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !ti.ContainsTime(tt) {
|
|
t.Errorf("Expected %s to contain %s", tc.in, ts)
|
|
}
|
|
}
|
|
for _, ts := range tc.excludes {
|
|
tt, err := time.Parse(time.RFC822Z, ts)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if ti.ContainsTime(tt) {
|
|
t.Errorf("Expected %s to exclude %s", tc.in, ts)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Utility function for declaring time locations in test cases. Panic if the location can't be loaded.
|
|
func mustLoadLocation(name string) *time.Location {
|
|
loc, err := time.LoadLocation(name)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return loc
|
|
}
|
|
|
|
func TestIntervener_Mutes(t *testing.T) {
|
|
// muteIn mutes alerts outside business hours in November, using the +1100 timezone.
|
|
muteIn := `
|
|
---
|
|
- weekdays:
|
|
- monday:friday
|
|
location: Australia/Sydney
|
|
months:
|
|
- November
|
|
times:
|
|
- start_time: 00:00
|
|
end_time: 09:00
|
|
- start_time: 17:00
|
|
end_time: 24:00
|
|
- weekdays:
|
|
- saturday
|
|
- sunday
|
|
months:
|
|
- November
|
|
location: 'Australia/Sydney'
|
|
`
|
|
intervalName := "test"
|
|
var intervals []TimeInterval
|
|
err := yaml.Unmarshal([]byte(muteIn), &intervals)
|
|
require.NoError(t, err)
|
|
m := map[string][]TimeInterval{intervalName: intervals}
|
|
|
|
tc := []struct {
|
|
name string
|
|
firedAt string
|
|
expected bool
|
|
err error
|
|
}{
|
|
{
|
|
name: "Should not mute on Friday during business hours",
|
|
firedAt: "19 Nov 21 13:00 +1100",
|
|
expected: false,
|
|
},
|
|
{
|
|
name: "Should not mute on a Tuesday before 5pm",
|
|
firedAt: "16 Nov 21 16:59 +1100",
|
|
expected: false,
|
|
},
|
|
{
|
|
name: "Should mute on a Saturday",
|
|
firedAt: "20 Nov 21 10:00 +1100",
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "Should mute before 9am on a Wednesday",
|
|
firedAt: "17 Nov 21 05:00 +1100",
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "Should mute even if we are in a different timezone (KST)",
|
|
firedAt: "14 Nov 21 20:00 +0900",
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "Should mute even if the timezone is UTC",
|
|
firedAt: "14 Nov 21 21:30 +0000",
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "Should not mute different timezone (KST)",
|
|
firedAt: "15 Nov 22 14:30 +0900",
|
|
expected: false,
|
|
},
|
|
{
|
|
name: "Should mute in a different timezone (PET)",
|
|
firedAt: "15 Nov 21 02:00 -0500",
|
|
expected: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tc {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
now, err := time.Parse(time.RFC822Z, tt.firedAt)
|
|
require.NoError(t, err)
|
|
|
|
intervener := NewIntervener(m)
|
|
|
|
expected, err := intervener.Mutes([]string{intervalName}, now)
|
|
if err != nil {
|
|
require.Error(t, tt.err)
|
|
require.False(t, tt.expected)
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
require.Equal(t, expected, tt.expected)
|
|
})
|
|
}
|
|
}
|