gtime: Add ParseDuration function (#28525)

* gtime: Make calculations independent of current time

Signed-off-by: Arve Knudsen <arve.knudsen@gmail.com>

* Introduce gtime.ParseDuration function

Signed-off-by: Arve Knudsen <arve.knudsen@gmail.com>

* gtime: Fix ParseDuration

Signed-off-by: Arve Knudsen <arve.knudsen@gmail.com>

pkg/components/gtime/gtime.go

@@ -10,17 +10,19 @@ import (
 var dateUnitPattern = regexp.MustCompile(`^(\d+)([dwMy])$`)
 
 // ParseInterval parses an interval with support for all units that Grafana uses.
-func ParseInterval(interval string) (time.Duration, error) {
-	result := dateUnitPattern.FindSubmatch([]byte(interval))
-
-	if len(result) != 3 {
-		return time.ParseDuration(interval)
+// An interval is relative the current wall time.
+func ParseInterval(inp string) (time.Duration, error) {
+	dur, period, err := parse(inp)
+	if err != nil {
+		return 0, err
+	}
+	if period == "" {
+		return dur, nil
 	}
 
-	num, _ := strconv.Atoi(string(result[1]))
-	period := string(result[2])
-	now := time.Now()
+	num := int(dur)
 
+	now := time.Now()
 	switch period {
 	case "d":
 		return now.Sub(now.AddDate(0, 0, -num)), nil
@@ -32,5 +34,52 @@ func ParseInterval(interval string) (time.Duration, error) {
 		return now.Sub(now.AddDate(-num, 0, 0)), nil
 	}
 
-	return 0, fmt.Errorf("ParseInterval: invalid duration %q", interval)
+	return 0, fmt.Errorf("invalid interval %q", inp)
+}
+
+// ParseDuration parses a duration with support for all units that Grafana uses.
+// Durations are independent of wall time.
+func ParseDuration(inp string) (time.Duration, error) {
+	dur, period, err := parse(inp)
+	if err != nil {
+		return 0, err
+	}
+	if period == "" {
+		return dur, nil
+	}
+
+	// The average number of days in a year, using the Julian calendar
+	const daysInAYear = 365.25
+	const day = 24 * time.Hour
+	const week = 7 * day
+	const year = time.Duration(float64(day) * daysInAYear)
+	const month = time.Duration(float64(year) / 12)
+
+	switch period {
+	case "d":
+		return dur * day, nil
+	case "w":
+		return dur * week, nil
+	case "M":
+		return dur * month, nil
+	case "y":
+		return dur * year, nil
+	}
+
+	return 0, fmt.Errorf("invalid duration %q", inp)
+}
+
+func parse(inp string) (time.Duration, string, error) {
+	result := dateUnitPattern.FindSubmatch([]byte(inp))
+	if len(result) != 3 {
+		dur, err := time.ParseDuration(inp)
+		return dur, "", err
+	}
+
+	num, err := strconv.Atoi(string(result[1]))
+	if err != nil {
+		return 0, "", err
+	}
+
+	return time.Duration(num), string(result[2]), nil
 }

pkg/components/gtime/gtime_test.go

@@ -13,27 +13,57 @@ func TestParseInterval(t *testing.T) {
 	now := time.Now()
 
 	tcs := []struct {
-		interval string
+		inp      string
 		duration time.Duration
 		err      *regexp.Regexp
 	}{
-		{interval: "1d", duration: now.Sub(now.AddDate(0, 0, -1))},
-		{interval: "1w", duration: now.Sub(now.AddDate(0, 0, -7))},
-		{interval: "2w", duration: now.Sub(now.AddDate(0, 0, -14))},
-		{interval: "1M", duration: now.Sub(now.AddDate(0, -1, 0))},
-		{interval: "1y", duration: now.Sub(now.AddDate(-1, 0, 0))},
-		{interval: "5y", duration: now.Sub(now.AddDate(-5, 0, 0))},
-		{interval: "invalid-duration", err: regexp.MustCompile(`^time: invalid duration "?invalid-duration"?$`)},
+		{inp: "1d", duration: now.Sub(now.AddDate(0, 0, -1))},
+		{inp: "1w", duration: now.Sub(now.AddDate(0, 0, -7))},
+		{inp: "2w", duration: now.Sub(now.AddDate(0, 0, -14))},
+		{inp: "1M", duration: now.Sub(now.AddDate(0, -1, 0))},
+		{inp: "1y", duration: now.Sub(now.AddDate(-1, 0, 0))},
+		{inp: "5y", duration: now.Sub(now.AddDate(-5, 0, 0))},
+		{inp: "invalid-duration", err: regexp.MustCompile(`^time: invalid duration "?invalid-duration"?$`)},
 	}
-
 	for i, tc := range tcs {
 		t.Run(fmt.Sprintf("testcase %d", i), func(t *testing.T) {
-			res, err := ParseInterval(tc.interval)
+			res, err := ParseInterval(tc.inp)
 			if tc.err == nil {
-				require.NoError(t, err, "interval %q", tc.interval)
-				require.Equal(t, tc.duration, res, "interval %q", tc.interval)
+				require.NoError(t, err, "input %q", tc.inp)
+				require.Equal(t, tc.duration, res, "input %q", tc.inp)
 			} else {
-				require.Error(t, err, "interval %q", tc.interval)
+				require.Error(t, err, "input %q", tc.inp)
+				require.Regexp(t, tc.err, err.Error())
+			}
+		})
+	}
+}
+
+func TestParseDuration(t *testing.T) {
+	tcs := []struct {
+		inp      string
+		duration time.Duration
+		err      *regexp.Regexp
+	}{
+		{inp: "1s", duration: time.Second},
+		{inp: "1m", duration: time.Minute},
+		{inp: "1h", duration: time.Hour},
+		{inp: "1d", duration: 24 * time.Hour},
+		{inp: "1w", duration: 7 * 24 * time.Hour},
+		{inp: "2w", duration: 2 * 7 * 24 * time.Hour},
+		{inp: "1M", duration: time.Duration(730.5 * float64(time.Hour))},
+		{inp: "1y", duration: 365.25 * 24 * time.Hour},
+		{inp: "5y", duration: 5 * 365.25 * 24 * time.Hour},
+		{inp: "invalid-duration", err: regexp.MustCompile(`^time: invalid duration "?invalid-duration"?$`)},
+	}
+	for i, tc := range tcs {
+		t.Run(fmt.Sprintf("testcase %d", i), func(t *testing.T) {
+			res, err := ParseDuration(tc.inp)
+			if tc.err == nil {
+				require.NoError(t, err, "input %q", tc.inp)
+				require.Equal(t, tc.duration, res, "input %q", tc.inp)
+			} else {
+				require.Error(t, err, "input %q", tc.inp)
 				require.Regexp(t, tc.err, err.Error())
 			}
 		})