fix: high frequency intervals could not be used with some monitor/check types (#339)

* feat: make frequency and frequency_offset consistent

* feat: add tests to make sure frequency and frequency offset work

* chore: bump Go SDK to v1.18.1 which contains the fix

* chore: clarify documentation

Author: sorccu

checkly/attribute_frequency.go

@@ -0,0 +1,93 @@
+package checkly
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+const frequencyAttributeName = "frequency"
+
+type FrequencyAttributeSchemaOptions struct {
+	Monitor            bool
+	AllowHighFrequency bool
+	Disclaimer         string
+}
+
+func makeFrequencyAttributeSchema(options FrequencyAttributeSchemaOptions) *schema.Schema {
+	name := "check"
+	if options.Monitor {
+		name = "monitor"
+	}
+
+	allow := allowedValues[int]{
+		{
+			Value:       0,
+			Description: "high frequency - use `frequency_offset` to define the actual frequency",
+		},
+		{
+			Value:       1,
+			Description: "1 minute",
+		},
+		{
+			Value:       2,
+			Description: "2 minutes",
+		},
+		{
+			Value:       5,
+			Description: "5 minutes",
+		},
+		{
+			Value:       10,
+			Description: "10 minutes",
+		},
+		{
+			Value:       15,
+			Description: "15 minutes",
+		},
+		{
+			Value:       30,
+			Description: "30 minutes",
+		},
+		{
+			Value:       60,
+			Description: "1 hour",
+		},
+		{
+			Value:       120,
+			Description: "2 hours",
+		},
+		{
+			Value:       180,
+			Description: "3 hours",
+		},
+		{
+			Value:       360,
+			Description: "6 hours",
+		},
+		{
+			Value:       720,
+			Description: "12 hours",
+		},
+		{
+			Value:       1440,
+			Description: "24 hours",
+		},
+	}
+
+	if !options.AllowHighFrequency {
+		allow = allow[1:]
+	}
+
+	var disclaimer string
+	if options.Disclaimer != "" {
+		disclaimer = options.Disclaimer + " "
+	}
+
+	return &schema.Schema{
+		Description:  disclaimer + fmt.Sprintf("Controls how often the %s should run. Defined in minutes. %s", name, allow.String()),
+		Type:         schema.TypeInt,
+		Required:     true,
+		ValidateFunc: validateOneOf(allow.Values()),
+	}
+}

checkly/attribute_frequency_offset.go

@@ -0,0 +1,67 @@
+package checkly
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+const frequencyOffsetAttributeName = "frequency_offset"
+
+type FrequencyOffsetAttributeSchemaOptions struct {
+	Monitor    bool
+	Disclaimer string
+}
+
+func makeFrequencyOffsetAttributeSchema(options FrequencyOffsetAttributeSchemaOptions) *schema.Schema {
+	name := "check"
+	if options.Monitor {
+		name = "monitor"
+	}
+
+	allow := allowedValues[int]{
+		{
+			Value:       0,
+			Description: "disabled - use `frequency` to define the actual frequency",
+		},
+		{
+			Value:       10,
+			Description: "10 seconds",
+		},
+		{
+			Value:       20,
+			Description: "20 seconds",
+		},
+		{
+			Value:       30,
+			Description: "30 seconds",
+		},
+	}
+
+	var disclaimer string
+	if options.Disclaimer != "" {
+		disclaimer = options.Disclaimer + " "
+	}
+
+	return &schema.Schema{
+		Description:  disclaimer + fmt.Sprintf("When `frequency` is `0` (high frequency), `frequency_offset` is required and it alone controls how often the %s should run. Defined in seconds. %s", name, allow.String()),
+		Type:         schema.TypeInt,
+		Optional:     true,
+		ValidateFunc: validateOneOf(allow.Values()),
+	}
+}
+
+func FrequencyOffsetCustomizeDiff(_ context.Context, diff *schema.ResourceDiff, meta any) error {
+	frequency := diff.Get(frequencyAttributeName).(int)
+	offset := diff.Get(frequencyOffsetAttributeName).(int)
+
+	switch {
+	case frequency > 0 && offset != 0:
+		return fmt.Errorf(`"frequency_offset" can only be set when "frequency" is 0`)
+	case frequency == 0 && offset == 0:
+		return fmt.Errorf(`"frequency_offset" is required when "frequency" is 0`)
+	}
+
+	return nil
+}

checkly/helpers.go

@@ -3,9 +3,11 @@ package checkly
 import (
 	"crypto/sha256"
 	"encoding/hex"
+	"fmt"
 	"io"
 	"os"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -34,3 +36,59 @@ func checksumSha256(r io.Reader) string {
 
 	return checksum
 }
+
+type allowedValue[T any] struct {
+	Value       T
+	Description string
+}
+
+func (v *allowedValue[T]) String() string {
+	if v.Description != "" {
+		return fmt.Sprintf("`%v` (%s)", v.Value, v.Description)
+	}
+
+	return fmt.Sprintf("`%v`", v.Value)
+}
+
+type allowedValues[T any] []allowedValue[T]
+
+func (v *allowedValues[T]) Values() []T {
+	s := make([]T, 0, len(*v))
+
+	for _, value := range *v {
+		s = append(s, value.Value)
+	}
+
+	return s
+}
+
+func (v *allowedValues[T]) String() string {
+	l := len(*v)
+	switch l {
+	case 0:
+		return "There are no allowed values."
+	case 1:
+		return fmt.Sprintf("The only allowed value is %s.", (*v)[0].String())
+	default:
+		head := (*v)[:l-1]
+		last := (*v)[l-1]
+
+		var buf strings.Builder
+
+		buf.WriteString("The allowed values are ")
+
+		for i, value := range head {
+			if i > 0 {
+				buf.WriteString(", ")
+			}
+
+			buf.WriteString(value.String())
+		}
+
+		buf.WriteString(" and ")
+		buf.WriteString(last.String())
+		buf.WriteString(".")
+
+		return buf.String()
+	}
+}

checkly/resource_check.go

@@ -38,30 +38,14 @@ func resourceCheck() *schema.Resource {
 				Required:    true,
 				Description: "The type of the check. Possible values are `API`, `BROWSER`, and `MULTI_STEP`.",
 			},
-			"frequency": {
-				Type:     schema.TypeInt,
-				Required: true,
-				ValidateFunc: func(val interface{}, key string) (warns []string, errs []error) {
-					v := val.(int)
-					valid := false
-					validFreqs := []int{0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, 1440}
-					for _, i := range validFreqs {
-						if v == i {
-							valid = true
-						}
-					}
-					if !valid {
-						errs = append(errs, fmt.Errorf("%q must be one of %v, got %d", key, validFreqs, v))
-					}
-					return warns, errs
-				},
-				Description: "The frequency in minutes to run the check. Possible values are `0`, `1`, `2`, `5`, `10`, `15`, `30`, `60`, `120`, `180`, `360`, `720`, and `1440`.",
-			},
-			"frequency_offset": {
-				Type:        schema.TypeInt,
-				Optional:    true,
-				Description: "This property only valid for API high frequency checks. To create a hight frequency check, the property `frequency` must be `0` and `frequency_offset` could be `10`, `20` or `30`.",
-			},
+			frequencyAttributeName: makeFrequencyAttributeSchema(FrequencyAttributeSchemaOptions{
+				Monitor:            false,
+				AllowHighFrequency: true,
+			}),
+			frequencyOffsetAttributeName: makeFrequencyOffsetAttributeSchema(FrequencyOffsetAttributeSchemaOptions{
+				Monitor:    true,
+				Disclaimer: "Only relevant when `type` is `API`.",
+			}),
 			"activated": {
 				Type:        schema.TypeBool,
 				Required:    true,
@@ -392,6 +376,7 @@ func resourceCheck() *schema.Resource {
 		},
 		CustomizeDiff: customdiff.Sequence(
 			RetryStrategyCustomizeDiff,
+			FrequencyOffsetCustomizeDiff,
 		),
 	}
 }
@@ -487,9 +472,11 @@ func resourceDataFromCheck(c *checkly.Check, d *schema.ResourceData) error {
 	sort.Strings(c.Tags)
 	d.Set("tags", c.Tags)
 
-	d.Set("frequency", c.Frequency)
+	d.Set(frequencyAttributeName, c.Frequency)
 	if c.Frequency == 0 {
-		d.Set("frequency_offset", c.FrequencyOffset)
+		d.Set(frequencyOffsetAttributeName, c.FrequencyOffset)
+	} else {
+		d.Set(frequencyOffsetAttributeName, nil)
 	}
 
 	if c.RuntimeID != nil {
@@ -591,7 +578,7 @@ func checkFromResourceData(d *schema.ResourceData) (checkly.Check, error) {
 		ID:                        d.Id(),
 		Name:                      d.Get("name").(string),
 		Type:                      d.Get("type").(string),
-		Frequency:                 d.Get("frequency").(int),
+		Frequency:                 d.Get(frequencyAttributeName).(int),
 		Activated:                 d.Get("activated").(bool),
 		Muted:                     d.Get("muted").(bool),
 		ShouldFail:                d.Get("should_fail").(bool),
@@ -636,10 +623,10 @@ func checkFromResourceData(d *schema.ResourceData) (checkly.Check, error) {
 	if check.Type == checkly.TypeAPI {
 		// this will prevent subsequent apply from causing a tf config change in browser checks
 		check.Request = requestFromSet(d.Get("request").(*schema.Set))
-		check.FrequencyOffset = d.Get("frequency_offset").(int)
+		check.FrequencyOffset = d.Get(frequencyOffsetAttributeName).(int)
 
 		if check.Frequency == 0 && (check.FrequencyOffset != 10 && check.FrequencyOffset != 20 && check.FrequencyOffset != 30) {
-			return check, errors.New("when property frequency is 0, frequency_offset must be 10, 20 or 30")
+			return check, errors.New("when `frequency` is 0, `frequency_offset` must be 10, 20 or 30")
 		}
 
 		if check.SSLCheckDomain != "" {