errors.go

@@ -49,4 +49,5 @@ var (
 	ErrCannotLoadStatsFromDatabase  = fmt.Errorf("errors while loading stats from database")
 	ErrInvalidTime                  = fmt.Errorf("invalid time")
 	ErrSchedulerMisconfiguration    = fmt.Errorf("scheduler misconfiguration")
+	ErrInvalidDuration              = fmt.Errorf("invalid duration")
 )

schedule-interval_test.go

+// Copyright 2023 schukai GmbH
+// SPDX-License-Identifier: AGPL-3.0
+
+package jobqueue
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"gopkg.in/yaml.v3"
+	"testing"
+	"time"
+)
+
+// TestUnmarshalYAML tests the unmarshalling of the SchedulerPersistence struct
+func TestUnmarshalYAML(t *testing.T) {
+
+	yamlStr := `
+time: "2023-12-06T15:04:05Z"
+interval: "1h30m"
+`
+
+	sp := SchedulerPersistence{}
+
+	err := yaml.Unmarshal([]byte(yamlStr), &sp)
+	assert.NoError(t, err)
+
+	expectedTime, _ := time.Parse(time.RFC3339, "2023-12-06T15:04:05Z")
+	assert.Equal(t, expectedTime, *sp.Time, "the time should be parsed correctly")
+
+	expectedInterval, _ := time.ParseDuration("1h30m")
+	assert.Equal(t, expectedInterval, sp.Delay, "the interval should be parsed correctly")
+}
+
+// TestUnmarshalJSON tests the UnmarshalJSON method
+func TestUnmarshalJSON(t *testing.T) {
+	// Example JSON string representing SchedulerPersistence
+	jsonStr := `{
+		"time": "2023-12-06T15:04:05Z",
+		"interval": "1h30m"
+	}`
+
+	// Create an instance of SchedulerPersistence
+	sp := SchedulerPersistence{}
+
+	// Unmarshal the JSON string into the sp structure
+	err := json.Unmarshal([]byte(jsonStr), &sp)
+	assert.NoError(t, err, "Unmarshalling should not produce an error")
+
+	// Verify that the Time field is correctly parsed
+	expectedTime, _ := time.Parse(time.RFC3339, "2023-12-06T15:04:05Z")
+	if sp.Time != nil {
+		assert.Equal(t, expectedTime, *sp.Time, "Time should be correctly parsed")
+	} else {
+		t.Error("Time field is nil, but it should not be")
+	}
+
+	// Verify that the Delay field is correctly parsed
+	expectedInterval, _ := time.ParseDuration("1h30m")
+	assert.Equal(t, expectedInterval, sp.Delay, "Interval should be correctly parsed")
+}

scheduler.go

@@ -41,7 +41,8 @@ func (sp *SchedulerPersistence) UnmarshalJSON(data []byte) error {
 	// Anonymous structure to avoid endless recursion
 	type Alias SchedulerPersistence
 	aux := &struct {
-		Time *string `json:"time,omitempty"`
+		Time     *string `json:"time,omitempty"`
+		Interval *string `json:"interval,omitempty"` // Ensure this matches the JSON field name
 		*Alias
 	}{
 		Alias: (*Alias)(sp),
@@ -66,5 +67,54 @@ func (sp *SchedulerPersistence) UnmarshalJSON(data []byte) error {
 		sp.Time = &t
 	}
 
+	if aux.Interval != nil {
+		d, err := time.ParseDuration(*aux.Interval)
+		if err != nil {
+			return err
+		}
+		sp.Delay = d
+	}
+
+	return nil
+}
+
+func (sp *SchedulerPersistence) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	// Anonymous structure to avoid endless recursion
+	type Alias SchedulerPersistence
+	aux := &struct {
+		Time     *string `yaml:"time,omitempty"`
+		Interval *string `yaml:"interval,omitempty"`
+		*Alias
+	}{
+		Alias: (*Alias)(sp),
+	}
+
+	if err := unmarshal(&aux); err != nil {
+		return err
+	}
+
+	if aux.Time != nil {
+		var t time.Time
+		var err error
+		for _, format := range SupportedTimeFormats {
+			t, err = time.Parse(format, *aux.Time)
+			if err == nil {
+				break
+			}
+		}
+		if err != nil {
+			return err
+		}
+		sp.Time = &t
+	}
+
+	if aux.Interval != nil {
+		d, err := time.ParseDuration(*aux.Interval)
+		if err != nil {
+			return err
+		}
+		sp.Delay = d
+	}
+
 	return nil
 }