From a95f58431c2c3a3312a72e6216d4c23c9ab2a442 Mon Sep 17 00:00:00 2001
From: CURZOLA Pierre <pierre.curzola@gmail.com>
Date: Mon, 17 Jul 2023 17:44:43 +0200
Subject: [PATCH] test(maintenance): refacto how we test

---
 db/maintenance/info_test.go | 92 ++++++++++++++++++-------------------
 1 file changed, 44 insertions(+), 48 deletions(-)

diff --git a/db/maintenance/info_test.go b/db/maintenance/info_test.go
index a383b8d61..acb0fc188 100644
--- a/db/maintenance/info_test.go
+++ b/db/maintenance/info_test.go
@@ -5,71 +5,67 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
-	"github.com/Scalingo/cli/utils"
 	"github.com/Scalingo/go-scalingo/v6"
 )
 
+type test struct {
+	maintenanceStatuses []scalingo.MaintenanceStatus
+	expectedRunTime     time.Time
+	maintenanceRunDate  time.Time
+}
+
 func TestGetNextMaintenanceLocalWindow(t *testing.T) {
-	now := dateOfTheWeekUTC(time.Wednesday, 8)
+	now := dateAt(t, "Wednesday, 19-Jul-23 08:00:00 UTC")
 
-	tests := map[string]struct {
-		maintenanceTimeData        time.Time
-		expectedMaintenanceRunTime func(time.Time, scalingo.MaintenanceStatus) time.Time
-	}{
-		"it should be executed next week": {
-			maintenanceTimeData: dateOfTheWeekUTC(time.Sunday, 0),
-			expectedMaintenanceRunTime: func(maintenanceData time.Time, _ scalingo.MaintenanceStatus) time.Time {
-				return maintenanceData.AddDate(0, 0, 7)
-			},
+	tests := map[string]test{
+		"when the maintenance is notified, queued or scheduled, the maintenance should be executed a week later when execution date is in the past": {
+			maintenanceStatuses: []scalingo.MaintenanceStatus{scalingo.MaintenanceStatusNotified, scalingo.MaintenanceStatusQueued, scalingo.MaintenanceStatusScheduled},
+			maintenanceRunDate:  dateAt(t, "Sunday, 16-Jul-23 00:00:00 UTC"),
+			expectedRunTime:     dateAt(t, "Sunday, 23-Jul-23 00:00:00 UTC"),
 		},
-		"it should be ongoing": {
-			maintenanceTimeData: dateOfTheWeekUTC(time.Wednesday, 7),
-			expectedMaintenanceRunTime: func(maintenanceData time.Time, maintenanceType scalingo.MaintenanceStatus) time.Time {
-				if maintenanceType == scalingo.MaintenanceStatusScheduled {
-					return maintenanceData.AddDate(0, 0, 7)
-				}
-				return maintenanceData
-			},
+		"when the maintenance is notified or queued, the maintenance should be ongoing when execution date is within maintenance boundaries": {
+			maintenanceStatuses: []scalingo.MaintenanceStatus{scalingo.MaintenanceStatusNotified, scalingo.MaintenanceStatusQueued},
+			maintenanceRunDate:  dateAt(t, "Wednesday, 19-Jul-23 07:00:00 UTC"),
+			expectedRunTime:     dateAt(t, "Wednesday, 19-Jul-23 07:00:00 UTC"),
 		},
-		"it should be executed this week": {
-			maintenanceTimeData: dateOfTheWeekUTC(time.Saturday, 7),
-			expectedMaintenanceRunTime: func(maintenanceData time.Time, maintenanceType scalingo.MaintenanceStatus) time.Time {
-				return maintenanceData
-			},
+		"when the maintenance is scheduled, the maintenance should be executed when execution date is within maintenance boundaries": {
+			maintenanceStatuses: []scalingo.MaintenanceStatus{scalingo.MaintenanceStatusScheduled},
+			maintenanceRunDate:  dateAt(t, "Wednesday, 19-Jul-23 07:00:00 UTC"),
+			expectedRunTime:     dateAt(t, "Saturday, 26-Jul-23 07:00:00 UTC"),
+		},
+		"when the maintenance is notified, queued or scheduled, the maintenance should be executed this week when execution date in future": {
+			maintenanceStatuses: []scalingo.MaintenanceStatus{scalingo.MaintenanceStatusNotified, scalingo.MaintenanceStatusQueued, scalingo.MaintenanceStatusScheduled},
+			maintenanceRunDate:  dateAt(t, "Saturday, 22-Jul-23 07:00:00 UTC"),
+			expectedRunTime:     dateAt(t, "Saturday, 22-Jul-23 07:00:00 UTC"),
 		},
 	}
-	for _, maintenanceType := range []scalingo.MaintenanceStatus{
-		scalingo.MaintenanceStatusNotified,
-		scalingo.MaintenanceStatusQueued,
-		scalingo.MaintenanceStatusScheduled,
-	} {
-		for testName, test := range tests {
-			t.Run("when the maintenance is "+string(maintenanceType)+"/"+testName, func(t *testing.T) {
-				// given
-				expectedRunTime := test.expectedMaintenanceRunTime(test.maintenanceTimeData, maintenanceType)
 
-				maintenanceWindow := scalingo.MaintenanceWindow{
-					WeekdayUTC:      int(test.maintenanceTimeData.Weekday()),
-					StartingHourUTC: test.maintenanceTimeData.Hour(),
-					DurationInHour:  8,
-				}
+	for testName, test := range tests {
+		t.Run(testName, func(t *testing.T) {
+			maintenanceWindow := scalingo.MaintenanceWindow{
+				WeekdayUTC:      int(test.maintenanceRunDate.Weekday()),
+				StartingHourUTC: test.maintenanceRunDate.Hour(),
+				DurationInHour:  8,
+			}
 
+			for _, status := range test.maintenanceStatuses {
 				// when
-				nextExec, untilExec := getNextLocalMaintenanceWindow(now, maintenanceWindow, maintenanceType)
+				nextExec, untilExec := getNextLocalMaintenanceWindow(now, maintenanceWindow, status)
 
 				// Then
-				assert.Equal(t, expectedRunTime.Local(), nextExec)
-				assert.Equal(t, expectedRunTime.Local().Add(time.Duration(maintenanceWindow.DurationInHour)*time.Hour), untilExec)
-			})
-		}
+				assert.Equal(t, test.expectedRunTime.Local(), nextExec)
+				assert.Equal(t, test.expectedRunTime.Local().Add(time.Duration(maintenanceWindow.DurationInHour)*time.Hour), untilExec)
+			}
+		})
 	}
 }
 
-func dateOfTheWeekUTC(weekday time.Weekday, hour int) time.Time {
-	date := utils.BeginningOfWeek(time.Now().In(time.UTC))
-	date = date.AddDate(0, 0, int(weekday)-1)
-	date = date.Add(time.Duration(hour) * time.Hour)
+func dateAt(t *testing.T, date string) time.Time {
+	parsedTime, err := time.Parse(time.RFC850, date)
+
+	require.NoError(t, err)
 
-	return date
+	return parsedTime
 }