weekdays to use a bitmap, add (minimal) tests

cmd/kured/main.go

@@ -85,7 +85,7 @@ func main() {
 	rootCmd.PersistentFlags().StringArrayVar(&podSelectors, "blocking-pod-selector", nil,
 		"label selector identifying pods whose presence should prevent reboots")
 
-	rootCmd.PersistentFlags().StringSliceVar(&rebootDays, "reboot-on-days", []string{"sun", "mon", "tue", "wed", "thu", "fri", "sat"},
+	rootCmd.PersistentFlags().StringSliceVar(&rebootDays, "reboot-on-days", timewindow.EveryDay,
 		"only reboot on these days")
 	rootCmd.PersistentFlags().StringVar(&rebootStart, "start-time", "0:00",
 		"only reboot after this time of day")

pkg/timewindow/days.go

@@ -7,6 +7,9 @@ import (
 	"time"
 )
 
+var EveryDay = []string{"su", "mo", "tu", "we", "th", "fr", "sa"}
+
+// dayStrings maps day strings to time.Weekdays
 var dayStrings = map[string]time.Weekday{
 	"su":        time.Sunday,
 	"sun":       time.Sunday,
@@ -31,39 +34,48 @@ var dayStrings = map[string]time.Weekday{
 	"saturday":  time.Saturday,
 }
 
-type weekdays []time.Weekday
+type weekdays uint32
 
+// parseWeekdays creates a set of weekdays from a string slice
 func parseWeekdays(days []string) (weekdays, error) {
-	var result []time.Weekday
+	var result uint32
 	for _, day := range days {
-		weekday, err := parseWeekday(day)
-		if err != nil {
-			return nil, err
+		if len(day) == 0 {
+			continue
 		}
 
-		result = append(result, weekday)
+		weekday, err := parseWeekday(day)
+		if err != nil {
+			return weekdays(0), err
+		}
+
+		result |= 1 << uint32(weekday)
 	}
 
 	return weekdays(result), nil
 }
 
+// Contains returns true if the specified weekday is a member of this set.
 func (w weekdays) Contains(day time.Weekday) bool {
-	for _, d := range w {
-		if d == day {
-			return true
+	return uint32(w)&(1<<uint32(day)) != 0
+}
+
+// String returns a string representation of the set of weekdays.
+func (w weekdays) String() string {
+	if uint32(w) == 0 {
+		return "(No days)"
+	}
+
+	var b strings.Builder
+	for i := uint32(0); i < 7; i++ {
+		if uint32(w)&(1<<i) != 0 {
+			b.WriteString(time.Weekday(i).String()[0:3])
+		} else {
+			b.WriteString("---")
 		}
 	}
 
-	return false
-}
-
-func (w weekdays) String() string {
-	var days []string
-	for _, d := range w {
-		days = append(days, d.String())
-	}
-
-	return strings.Join(days, ",")
+	return b.String()
 }
 
 func parseWeekday(day string) (time.Weekday, error) {
@@ -75,8 +87,8 @@ func parseWeekday(day string) (time.Weekday, error) {
 		}
 	}
 
-	if day, ok := dayStrings[strings.ToLower(day)]; ok {
-		return day, nil
+	if weekday, ok := dayStrings[strings.ToLower(day)]; ok {
+		return weekday, nil
 	} else {
 		return time.Sunday, fmt.Errorf("Invalid weekday: %s", day)
 	}

pkg/timewindow/days_test.go

@@ -0,0 +1,46 @@
+package timewindow
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestParseWeekdays(t *testing.T) {
+	tests := []struct {
+		input  string
+		result string
+	}{
+		{"0,4", "Sun---------Thu------"},
+		{"su,mo,tu", "SunMonTue------------"},
+		{"sunday,tu,thu", "Sun---Tue---Thu------"},
+		{"THURSDAY", "------------Thu------"},
+		{"we,WED,WeDnEsDaY", "---------Wed---------"},
+		{"", "(No days)"},
+		{",,,", "(No days)"},
+	}
+
+	for _, tst := range tests {
+		res, err := parseWeekdays(strings.Split(tst.input, ","))
+		if err != nil {
+			t.Errorf("Received error for input %s: %v", tst.input, err)
+		} else if res.String() != tst.result {
+			t.Errorf("Test %s: Expected %s got %s", tst.input, tst.result, res.String())
+		}
+	}
+}
+
+func TestParseWeekdaysErrors(t *testing.T) {
+	tests := []string{
+		"15",
+		"-8",
+		"8",
+		"mon,tue,wed,fridayyyy",
+	}
+
+	for _, tst := range tests {
+		_, err := parseWeekdays(strings.Split(tst, ","))
+		if err == nil {
+			t.Errorf("Expected to receive error for input %s", tst)
+		}
+	}
+}

pkg/timewindow/timewindow.go

@@ -5,7 +5,7 @@ import (
 	"time"
 )
 
-// Represents a time window
+// TimeWindow specifies a schedule of days and times.
 type TimeWindow struct {
 	days      weekdays
 	location  *time.Location
@@ -13,6 +13,7 @@ type TimeWindow struct {
 	endTime   time.Time
 }
 
+// New creates a TimeWindow instance based on string inputs specifying a schedule.
 func New(days []string, startTime, endTime, location string) (*TimeWindow, error) {
 	tw := &TimeWindow{}
 
@@ -36,6 +37,7 @@ func New(days []string, startTime, endTime, location string) (*TimeWindow, error
 	return tw, nil
 }
 
+// Contains determines whether the specified time is within this time window.
 func (tw *TimeWindow) Contains(t time.Time) bool {
 	loctime := t.In(tw.location)
 	if !tw.days.Contains(loctime.Weekday()) {
@@ -48,10 +50,12 @@ func (tw *TimeWindow) Contains(t time.Time) bool {
 	return loctime.After(start) && loctime.Before(end)
 }
 
+// String returns a string representation of this time window.
 func (tw *TimeWindow) String() string {
 	return fmt.Sprintf("%s between %02d:%02d and %02d:%02d %s", tw.days.String(), tw.startTime.Hour(), tw.startTime.Minute(), tw.endTime.Hour(), tw.endTime.Minute(), tw.location.String())
 }
 
+// parseTime tries to parse a time with several formats.
 func parseTime(s string, loc *time.Location) (time.Time, error) {
 	fmts := []string{"15:04", "15:04:06", "03:04pm", "15", "03pm", "3pm"}
 	for _, f := range fmts {

pkg/timewindow/timewindow_test.go

@@ -0,0 +1,56 @@
+package timewindow
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestTimeWindows(t *testing.T) {
+	type testcase struct {
+		time   string
+		result bool
+	}
+
+	tests := []struct {
+		days  string
+		start string
+		end   string
+		loc   string
+		cases []testcase
+	}{
+		{"mon,tue,wed,thu,fri", "9am", "5pm", "America/Los_Angeles", []testcase{
+			{"2019/04/04 00:49 PDT", false},
+			{"2019/04/05 08:59 PDT", false},
+			{"2019/04/05 9:01 PDT", true},
+			{"2019/03/31 10:00 PDT", false},
+			{"2019/04/04 12:00 PDT", true},
+			{"2019/04/04 11:59 UTC", false},
+		}},
+		{"mon,we,fri", "10:01", "11:30am", "America/Los_Angeles", []testcase{
+			{"2019/04/05 10:30 PDT", true},
+			{"2019/04/06 10:30 PDT", false},
+			{"2019/04/07 10:30 PDT", false},
+			{"2019/04/08 10:30 PDT", true},
+			{"2019/04/09 10:30 PDT", false},
+			{"2019/04/10 10:30 PDT", true},
+			{"2019/04/11 10:30 PDT", false},
+		}},
+	}
+
+	for i, tst := range tests {
+		tw, err := New(strings.Split(tst.days, ","), tst.start, tst.end, tst.loc)
+		if err != nil {
+			t.Errorf("Test [%d] failed to create TimeWindow: %v", i, err)
+		}
+
+		for _, cas := range tst.cases {
+			tm, err := time.ParseInLocation("2006/01/02 15:04 MST", cas.time, tw.location)
+			if err != nil {
+				t.Errorf("Failed to parse time \"%s\": %v", cas.time, err)
+			} else if cas.result != tw.Contains(tm) {
+				t.Errorf("(%s) contains (%s) didn't match expected result of %v", tw.String(), cas.time, cas.result)
+			}
+		}
+	}
+}