github.com/grafana/pyroscope@v1.18.0/pkg/phlaredb/tsdb/index/chunk_test.go (about)

     1  package index
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/require"
     7  )
     8  
     9  // Test all sort variants
    10  func TestChunkMetasSort(t *testing.T) {
    11  	for _, tc := range []struct {
    12  		desc string
    13  		a, b ChunkMeta
    14  	}{
    15  		{
    16  			desc: "prefer mintime",
    17  			a: ChunkMeta{
    18  				MinTime: 0,
    19  				MaxTime: 5,
    20  			},
    21  			b: ChunkMeta{
    22  				MinTime: 1,
    23  				MaxTime: 4,
    24  			},
    25  		},
    26  		{
    27  			desc: "delegate maxtime",
    28  			a: ChunkMeta{
    29  				MaxTime:  2,
    30  				Checksum: 2,
    31  			},
    32  			b: ChunkMeta{
    33  				MaxTime:  3,
    34  				Checksum: 1,
    35  			},
    36  		},
    37  		{
    38  			desc: "delegate checksum",
    39  			a: ChunkMeta{
    40  				Checksum: 1,
    41  			},
    42  			b: ChunkMeta{
    43  				Checksum: 2,
    44  			},
    45  		},
    46  	} {
    47  		t.Run(tc.desc, func(t *testing.T) {
    48  			xs := ChunkMetas{tc.a, tc.b}
    49  			require.Equal(t, true, xs.Less(0, 1))
    50  			require.Equal(t, false, xs.Less(1, 0))
    51  		})
    52  	}
    53  }
    54  
    55  func TestChunkMetasFinalize(t *testing.T) {
    56  	mkMeta := func(x int) ChunkMeta {
    57  		return ChunkMeta{
    58  			MinTime:  int64(x),
    59  			Checksum: uint32(x),
    60  		}
    61  	}
    62  	for _, tc := range []struct {
    63  		desc          string
    64  		input, output ChunkMetas
    65  	}{
    66  		{
    67  			desc: "reorder",
    68  			input: []ChunkMeta{
    69  				mkMeta(2),
    70  				mkMeta(1),
    71  				mkMeta(3),
    72  			},
    73  			output: []ChunkMeta{
    74  				mkMeta(1),
    75  				mkMeta(2),
    76  				mkMeta(3),
    77  			},
    78  		},
    79  		{
    80  			desc: "remove duplicates",
    81  			input: []ChunkMeta{
    82  				mkMeta(1),
    83  				mkMeta(2),
    84  				mkMeta(2),
    85  				mkMeta(3),
    86  			},
    87  			output: []ChunkMeta{
    88  				mkMeta(1),
    89  				mkMeta(2),
    90  				mkMeta(3),
    91  			},
    92  		},
    93  		{
    94  			desc: "remove trailing duplicates",
    95  			input: []ChunkMeta{
    96  				mkMeta(1),
    97  				mkMeta(2),
    98  				mkMeta(2),
    99  				mkMeta(3),
   100  				mkMeta(4),
   101  				mkMeta(4),
   102  				mkMeta(5),
   103  				mkMeta(5),
   104  			},
   105  			output: []ChunkMeta{
   106  				mkMeta(1),
   107  				mkMeta(2),
   108  				mkMeta(3),
   109  				mkMeta(4),
   110  				mkMeta(5),
   111  			},
   112  		},
   113  		{
   114  			desc: "cleanup after last duplicate",
   115  			input: []ChunkMeta{
   116  				mkMeta(1),
   117  				mkMeta(2),
   118  				mkMeta(2),
   119  				mkMeta(3),
   120  				mkMeta(4),
   121  				mkMeta(5),
   122  				mkMeta(5),
   123  				mkMeta(6),
   124  				mkMeta(7),
   125  			},
   126  			output: []ChunkMeta{
   127  				mkMeta(1),
   128  				mkMeta(2),
   129  				mkMeta(3),
   130  				mkMeta(4),
   131  				mkMeta(5),
   132  				mkMeta(6),
   133  				mkMeta(7),
   134  			},
   135  		},
   136  	} {
   137  		t.Run(tc.desc, func(t *testing.T) {
   138  			require.Equal(t, tc.output, tc.input.Finalize())
   139  		})
   140  	}
   141  }