github.com/grafana/pyroscope@v1.18.0/pkg/frontend/split_by_interval_test.go (about)

     1  package frontend
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/stretchr/testify/require"
     8  
     9  	"github.com/grafana/pyroscope/pkg/iter"
    10  )
    11  
    12  func Test_TimeIntervalIterator(t *testing.T) {
    13  	type testCase struct {
    14  		description string
    15  		inputRange  TimeInterval
    16  		interval    time.Duration
    17  		alignment   time.Duration
    18  		expected    []TimeInterval
    19  	}
    20  
    21  	testCases := []testCase{
    22  		{
    23  			description: "misaligned time range",
    24  			inputRange:  TimeInterval{time.Unix(0, 1), time.Unix(0, 3602)},
    25  			interval:    900,
    26  			expected: []TimeInterval{
    27  				{time.Unix(0, 1), time.Unix(0, 899)},
    28  				{time.Unix(0, 900), time.Unix(0, 1799)},
    29  				{time.Unix(0, 1800), time.Unix(0, 2699)},
    30  				{time.Unix(0, 2700), time.Unix(0, 3599)},
    31  				{time.Unix(0, 3600), time.Unix(0, 3602)},
    32  			},
    33  		},
    34  		{
    35  			description: "misaligned time range with aligned interval",
    36  			inputRange:  TimeInterval{time.UnixMilli(1684840541938), time.UnixMilli(1684848292171)},
    37  			interval:    time.Minute * 15,
    38  			alignment:   time.Second * 15,
    39  			expected: []TimeInterval{
    40  				{Start: time.Unix(0, 1684840541938000000), End: time.Unix(0, 1684841441937999999)},
    41  				{Start: time.Unix(0, 1684841441938000000), End: time.Unix(0, 1684842341937999999)},
    42  				{Start: time.Unix(0, 1684842341938000000), End: time.Unix(0, 1684843241937999999)},
    43  				{Start: time.Unix(0, 1684843241938000000), End: time.Unix(0, 1684844141937999999)},
    44  				{Start: time.Unix(0, 1684844141938000000), End: time.Unix(0, 1684845041937999999)},
    45  				{Start: time.Unix(0, 1684845041938000000), End: time.Unix(0, 1684845941937999999)},
    46  				{Start: time.Unix(0, 1684845941938000000), End: time.Unix(0, 1684846841937999999)},
    47  				{Start: time.Unix(0, 1684846841938000000), End: time.Unix(0, 1684847741937999999)},
    48  				{Start: time.Unix(0, 1684847741938000000), End: time.Unix(0, 1684848292171000000)},
    49  			},
    50  		},
    51  		{
    52  			description: "round range",
    53  			inputRange:  TimeInterval{time.Unix(0, 0), time.Unix(0, 3600)},
    54  			interval:    900,
    55  			expected: []TimeInterval{
    56  				{time.Unix(0, 0), time.Unix(0, 899)},
    57  				{time.Unix(0, 900), time.Unix(0, 1799)},
    58  				{time.Unix(0, 1800), time.Unix(0, 2699)},
    59  				{time.Unix(0, 2700), time.Unix(0, 3600)},
    60  			},
    61  		},
    62  		{
    63  			description: "exact range",
    64  			inputRange:  TimeInterval{time.Unix(0, 900), time.Unix(0, 1800)},
    65  			interval:    900,
    66  			expected:    []TimeInterval{{time.Unix(0, 900), time.Unix(0, 1800)}},
    67  		},
    68  		{
    69  			description: "range less than interval",
    70  			inputRange:  TimeInterval{time.Unix(0, 1), time.Unix(0, 501)},
    71  			interval:    900,
    72  			expected: []TimeInterval{
    73  				{time.Unix(0, 1), time.Unix(0, 501)},
    74  			},
    75  		},
    76  		{
    77  			description: "range less than interval with alignment",
    78  			inputRange:  TimeInterval{time.Unix(0, 1), time.Unix(0, 501)},
    79  			interval:    900,
    80  			alignment:   37,
    81  			expected: []TimeInterval{
    82  				{time.Unix(0, 1), time.Unix(0, 501)},
    83  			},
    84  		},
    85  		{
    86  			description: "range less than alignment",
    87  			inputRange:  TimeInterval{time.Unix(0, 1), time.Unix(0, 501)},
    88  			alignment:   900,
    89  			interval:    90,
    90  			expected: []TimeInterval{
    91  				{time.Unix(0, 1), time.Unix(0, 501)},
    92  			},
    93  		},
    94  		{
    95  			description: "zero range",
    96  			interval:    900,
    97  		},
    98  		{
    99  			description: "zero range with alignment",
   100  			interval:    900,
   101  			alignment:   37,
   102  		},
   103  		{
   104  			description: "zero interval",
   105  			inputRange:  TimeInterval{time.Unix(0, 1), time.Unix(0, 501)},
   106  			expected: []TimeInterval{
   107  				{time.Unix(0, 1), time.Unix(0, 501)},
   108  			},
   109  		},
   110  		{
   111  			description: "zero interval with alignment",
   112  			inputRange:  TimeInterval{time.Unix(0, 1), time.Unix(0, 501)},
   113  			alignment:   37,
   114  			expected: []TimeInterval{
   115  				{time.Unix(0, 1), time.Unix(0, 501)},
   116  			},
   117  		},
   118  	}
   119  
   120  	for _, tc := range testCases {
   121  		tc := tc
   122  		t.Run(tc.description, func(t *testing.T) {
   123  			actual, err := iter.Slice[TimeInterval](NewTimeIntervalIterator(tc.inputRange.Start, tc.inputRange.End, tc.interval,
   124  				WithAlignment(tc.alignment)))
   125  			require.NoError(t, err)
   126  			require.Equal(t, tc.expected, actual)
   127  		})
   128  	}
   129  }
   130  
   131  func Test_TimeIntervalIterator_MillisecondsTruncation(t *testing.T) {
   132  	actual, err := iter.Slice[TimeInterval](NewTimeIntervalIterator(
   133  		time.UnixMilli(51),
   134  		time.UnixMilli(211),
   135  		50*time.Millisecond))
   136  
   137  	require.NoError(t, err)
   138  	require.Len(t, actual, 4)
   139  	require.Equal(t, int64(51), actual[0].Start.UnixMilli())
   140  	require.Equal(t, int64(99), actual[0].End.UnixMilli())
   141  	require.Equal(t, int64(100), actual[1].Start.UnixMilli())
   142  	require.Equal(t, int64(149), actual[1].End.UnixMilli())
   143  	require.Equal(t, int64(150), actual[2].Start.UnixMilli())
   144  	require.Equal(t, int64(199), actual[2].End.UnixMilli())
   145  	require.Equal(t, int64(200), actual[3].Start.UnixMilli())
   146  	require.Equal(t, int64(211), actual[3].End.UnixMilli())
   147  }