github.com/onsi/gomega@v1.32.0/internal/duration_bundle.go (about)

     1  package internal
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"reflect"
     7  	"time"
     8  )
     9  
    10  type DurationBundle struct {
    11  	EventuallyTimeout           time.Duration
    12  	EventuallyPollingInterval   time.Duration
    13  	ConsistentlyDuration        time.Duration
    14  	ConsistentlyPollingInterval time.Duration
    15  }
    16  
    17  const (
    18  	EventuallyTimeoutEnvVarName         = "GOMEGA_DEFAULT_EVENTUALLY_TIMEOUT"
    19  	EventuallyPollingIntervalEnvVarName = "GOMEGA_DEFAULT_EVENTUALLY_POLLING_INTERVAL"
    20  
    21  	ConsistentlyDurationEnvVarName        = "GOMEGA_DEFAULT_CONSISTENTLY_DURATION"
    22  	ConsistentlyPollingIntervalEnvVarName = "GOMEGA_DEFAULT_CONSISTENTLY_POLLING_INTERVAL"
    23  )
    24  
    25  func FetchDefaultDurationBundle() DurationBundle {
    26  	return DurationBundle{
    27  		EventuallyTimeout:         durationFromEnv(EventuallyTimeoutEnvVarName, time.Second),
    28  		EventuallyPollingInterval: durationFromEnv(EventuallyPollingIntervalEnvVarName, 10*time.Millisecond),
    29  
    30  		ConsistentlyDuration:        durationFromEnv(ConsistentlyDurationEnvVarName, 100*time.Millisecond),
    31  		ConsistentlyPollingInterval: durationFromEnv(ConsistentlyPollingIntervalEnvVarName, 10*time.Millisecond),
    32  	}
    33  }
    34  
    35  func durationFromEnv(key string, defaultDuration time.Duration) time.Duration {
    36  	value := os.Getenv(key)
    37  	if value == "" {
    38  		return defaultDuration
    39  	}
    40  	duration, err := time.ParseDuration(value)
    41  	if err != nil {
    42  		panic(fmt.Sprintf("Expected a duration when using %s!  Parse error %v", key, err))
    43  	}
    44  	return duration
    45  }
    46  
    47  func toDuration(input interface{}) (time.Duration, error) {
    48  	duration, ok := input.(time.Duration)
    49  	if ok {
    50  		return duration, nil
    51  	}
    52  
    53  	value := reflect.ValueOf(input)
    54  	kind := reflect.TypeOf(input).Kind()
    55  
    56  	if reflect.Int <= kind && kind <= reflect.Int64 {
    57  		return time.Duration(value.Int()) * time.Second, nil
    58  	} else if reflect.Uint <= kind && kind <= reflect.Uint64 {
    59  		return time.Duration(value.Uint()) * time.Second, nil
    60  	} else if reflect.Float32 <= kind && kind <= reflect.Float64 {
    61  		return time.Duration(value.Float() * float64(time.Second)), nil
    62  	} else if reflect.String == kind {
    63  		duration, err := time.ParseDuration(value.String())
    64  		if err != nil {
    65  			return 0, fmt.Errorf("%#v is not a valid parsable duration string: %w", input, err)
    66  		}
    67  		return duration, nil
    68  	}
    69  
    70  	return 0, fmt.Errorf("%#v is not a valid interval. Must be a time.Duration, a parsable duration string, or a number.", input)
    71  }