Debian Codegraph @

tsdb/index/tsi1/measurement_block_test.go

raw
1 package tsi1_test
2
3 import (
4 "bytes"
5 "encoding/binary"
6 "fmt"
7 "reflect"
8 "testing"
9
10 "github.com/influxdata/influxdb/tsdb/index/tsi1"
11 )
12
13 func TestReadMeasurementBlockTrailer(t *testing.T) {
14 // Build a trailer
15 var (
16 data = make([]byte, tsi1.MeasurementTrailerSize)
17 blockversion = uint16(1)
18 blockOffset, blockSize = uint64(1), uint64(2500)
19 hashIdxOffset, hashIdxSize = uint64(2501), uint64(1000)
20 sketchOffset, sketchSize = uint64(3501), uint64(250)
21 tsketchOffset, tsketchSize = uint64(3751), uint64(250)
22 )
23
24 binary.BigEndian.PutUint64(data[0:], blockOffset)
25 binary.BigEndian.PutUint64(data[8:], blockSize)
26 binary.BigEndian.PutUint64(data[16:], hashIdxOffset)
27 binary.BigEndian.PutUint64(data[24:], hashIdxSize)
28 binary.BigEndian.PutUint64(data[32:], sketchOffset)
29 binary.BigEndian.PutUint64(data[40:], sketchSize)
30 binary.BigEndian.PutUint64(data[48:], tsketchOffset)
31 binary.BigEndian.PutUint64(data[56:], tsketchSize)
32 binary.BigEndian.PutUint16(data[64:], blockversion)
33
34 trailer, err := tsi1.ReadMeasurementBlockTrailer(data)
35 if err != nil {
36 t.Logf("trailer is: %#v\n", trailer)
37 t.Fatal(err)
38 }
39
40 ok := true &&
41 trailer.Version == int(blockversion) &&
42 trailer.Data.Offset == int64(blockOffset) &&
43 trailer.Data.Size == int64(blockSize) &&
44 trailer.HashIndex.Offset == int64(hashIdxOffset) &&
45 trailer.HashIndex.Size == int64(hashIdxSize) &&
46 trailer.Sketch.Offset == int64(sketchOffset) &&
47 trailer.Sketch.Size == int64(sketchSize) &&
48 trailer.TSketch.Offset == int64(tsketchOffset) &&
49 trailer.TSketch.Size == int64(tsketchSize)
50
51 if !ok {
52 t.Fatalf("got %v\nwhich does not match expected", trailer)
53 }
54 }
55
56 func TestMeasurementBlockTrailer_WriteTo(t *testing.T) {
57 var trailer = tsi1.MeasurementBlockTrailer{
58 Version: 1,
59 Data: struct {
60 Offset int64
61 Size int64
62 }{Offset: 1, Size: 2},
63 HashIndex: struct {
64 Offset int64
65 Size int64
66 }{Offset: 3, Size: 4},
67 Sketch: struct {
68 Offset int64
69 Size int64
70 }{Offset: 5, Size: 6},
71 TSketch: struct {
72 Offset int64
73 Size int64
74 }{Offset: 7, Size: 8},
75 }
76
77 var buf bytes.Buffer
78 n, err := trailer.WriteTo(&buf)
79 if got, exp := n, int64(tsi1.MeasurementTrailerSize); got != exp {
80 t.Fatalf("got %v, exp %v", got, exp)
81 }
82
83 if got := err; got != nil {
84 t.Fatalf("got %v, exp %v", got, nil)
85 }
86
87 // Verify trailer written correctly.
88 exp := "" +
89 "0000000000000001" + // data offset
90 "0000000000000002" + // data size
91 "0000000000000003" + // hash index offset
92 "0000000000000004" + // hash index size
93 "0000000000000005" + // sketch offset
94 "0000000000000006" + // sketch size
95 "0000000000000007" + // tsketch offset
96 "0000000000000008" + // tsketch size
97 "0001" // version
98
99 if got, exp := fmt.Sprintf("%x", buf.String()), exp; got != exp {
100 t.Fatalf("got %v, exp %v", got, exp)
101 }
102 }
103
104 // Ensure measurement blocks can be written and opened.
105 func TestMeasurementBlockWriter(t *testing.T) {
106 ms := Measurements{
107 NewMeasurement([]byte("foo"), false, 100, 10, []uint64{1, 3, 4}),
108 NewMeasurement([]byte("bar"), false, 200, 20, []uint64{2}),
109 NewMeasurement([]byte("baz"), false, 300, 30, []uint64{5, 6}),
110 }
111
112 // Write the measurements to writer.
113 mw := tsi1.NewMeasurementBlockWriter()
114 for _, m := range ms {
115 mw.Add(m.Name, m.Deleted, m.Offset, m.Size, m.ids)
116 }
117
118 // Encode into buffer.
119 var buf bytes.Buffer
120 if n, err := mw.WriteTo(&buf); err != nil {
121 t.Fatal(err)
122 } else if n == 0 {
123 t.Fatal("expected bytes written")
124 }
125
126 // Unmarshal into a block.
127 var blk tsi1.MeasurementBlock
128 if err := blk.UnmarshalBinary(buf.Bytes()); err != nil {
129 t.Fatal(err)
130 }
131
132 // Verify data in block.
133 if e, ok := blk.Elem([]byte("foo")); !ok {
134 t.Fatal("expected element")
135 } else if e.TagBlockOffset() != 100 || e.TagBlockSize() != 10 {
136 t.Fatalf("unexpected offset/size: %v/%v", e.TagBlockOffset(), e.TagBlockSize())
137 } else if !reflect.DeepEqual(e.SeriesIDs(), []uint64{1, 3, 4}) {
138 t.Fatalf("unexpected series data: %#v", e.SeriesIDs())
139 }
140
141 if e, ok := blk.Elem([]byte("bar")); !ok {
142 t.Fatal("expected element")
143 } else if e.TagBlockOffset() != 200 || e.TagBlockSize() != 20 {
144 t.Fatalf("unexpected offset/size: %v/%v", e.TagBlockOffset(), e.TagBlockSize())
145 } else if !reflect.DeepEqual(e.SeriesIDs(), []uint64{2}) {
146 t.Fatalf("unexpected series data: %#v", e.SeriesIDs())
147 }
148
149 if e, ok := blk.Elem([]byte("baz")); !ok {
150 t.Fatal("expected element")
151 } else if e.TagBlockOffset() != 300 || e.TagBlockSize() != 30 {
152 t.Fatalf("unexpected offset/size: %v/%v", e.TagBlockOffset(), e.TagBlockSize())
153 } else if !reflect.DeepEqual(e.SeriesIDs(), []uint64{5, 6}) {
154 t.Fatalf("unexpected series data: %#v", e.SeriesIDs())
155 }
156
157 // Verify non-existent measurement doesn't exist.
158 if _, ok := blk.Elem([]byte("BAD_MEASUREMENT")); ok {
159 t.Fatal("expected no element")
160 }
161 }
162
163 type Measurements []Measurement
164
165 type Measurement struct {
166 Name []byte
167 Deleted bool
168 Offset int64
169 Size int64
170 ids []uint64
171 }
172
173 func NewMeasurement(name []byte, deleted bool, offset, size int64, ids []uint64) Measurement {
174 return Measurement{
175 Name: name,
176 Deleted: deleted,
177 Offset: offset,
178 Size: size,
179 ids: ids,
180 }
181 }