github.com/yankunsam/loki/v2@v2.6.3-0.20220817130409-389df5235c27/pkg/util/time_test.go (about)

     1  package util
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func TestTimeFromMillis(t *testing.T) {
    13  	var testExpr = []struct {
    14  		input    int64
    15  		expected time.Time
    16  	}{
    17  		{input: 1000, expected: time.Unix(1, 0)},
    18  		{input: 1500, expected: time.Unix(1, 500*nanosecondsInMillisecond)},
    19  	}
    20  
    21  	for i, c := range testExpr {
    22  		t.Run(fmt.Sprint(i), func(t *testing.T) {
    23  			res := TimeFromMillis(c.input)
    24  			require.Equal(t, c.expected, res)
    25  		})
    26  	}
    27  }
    28  
    29  func TestDurationWithJitter(t *testing.T) {
    30  	const numRuns = 1000
    31  
    32  	for i := 0; i < numRuns; i++ {
    33  		actual := DurationWithJitter(time.Minute, 0.5)
    34  		assert.GreaterOrEqual(t, int64(actual), int64(30*time.Second))
    35  		assert.LessOrEqual(t, int64(actual), int64(90*time.Second))
    36  	}
    37  }
    38  
    39  func TestDurationWithJitter_ZeroInputDuration(t *testing.T) {
    40  	assert.Equal(t, time.Duration(0), DurationWithJitter(time.Duration(0), 0.5))
    41  }
    42  
    43  func TestDurationWithPositiveJitter(t *testing.T) {
    44  	const numRuns = 1000
    45  
    46  	for i := 0; i < numRuns; i++ {
    47  		actual := DurationWithPositiveJitter(time.Minute, 0.5)
    48  		assert.GreaterOrEqual(t, int64(actual), int64(60*time.Second))
    49  		assert.LessOrEqual(t, int64(actual), int64(90*time.Second))
    50  	}
    51  }
    52  
    53  func TestDurationWithPositiveJitter_ZeroInputDuration(t *testing.T) {
    54  	assert.Equal(t, time.Duration(0), DurationWithPositiveJitter(time.Duration(0), 0.5))
    55  }
    56  
    57  func TestParseTime(t *testing.T) {
    58  	var tests = []struct {
    59  		input  string
    60  		fail   bool
    61  		result time.Time
    62  	}{
    63  		{
    64  			input: "",
    65  			fail:  true,
    66  		}, {
    67  			input: "abc",
    68  			fail:  true,
    69  		}, {
    70  			input: "30s",
    71  			fail:  true,
    72  		}, {
    73  			input:  "123",
    74  			result: time.Unix(123, 0),
    75  		}, {
    76  			input:  "123.123",
    77  			result: time.Unix(123, 123000000),
    78  		}, {
    79  			input:  "2015-06-03T13:21:58.555Z",
    80  			result: time.Unix(1433337718, 555*time.Millisecond.Nanoseconds()),
    81  		}, {
    82  			input:  "2015-06-03T14:21:58.555+01:00",
    83  			result: time.Unix(1433337718, 555*time.Millisecond.Nanoseconds()),
    84  		}, {
    85  			// Test nanosecond rounding.
    86  			input:  "2015-06-03T13:21:58.56789Z",
    87  			result: time.Unix(1433337718, 567*1e6),
    88  		}, {
    89  			// Test float rounding.
    90  			input:  "1543578564.705",
    91  			result: time.Unix(1543578564, 705*1e6),
    92  		},
    93  	}
    94  
    95  	for _, test := range tests {
    96  		ts, err := ParseTime(test.input)
    97  		if test.fail {
    98  			require.Error(t, err)
    99  			continue
   100  		}
   101  
   102  		require.NoError(t, err)
   103  		assert.Equal(t, TimeToMillis(test.result), ts)
   104  	}
   105  }
   106  
   107  func TestNewDisableableTicker_Enabled(t *testing.T) {
   108  	stop, ch := NewDisableableTicker(10 * time.Millisecond)
   109  	defer stop()
   110  
   111  	time.Sleep(100 * time.Millisecond)
   112  
   113  	select {
   114  	case <-ch:
   115  		break
   116  	default:
   117  		t.Error("ticker should have ticked when enabled")
   118  	}
   119  }
   120  
   121  func TestNewDisableableTicker_Disabled(t *testing.T) {
   122  	stop, ch := NewDisableableTicker(0)
   123  	defer stop()
   124  
   125  	time.Sleep(100 * time.Millisecond)
   126  
   127  	select {
   128  	case <-ch:
   129  		t.Error("ticker should not have ticked when disabled")
   130  	default:
   131  		break
   132  	}
   133  }