1package statsd
2
3import (
4	"testing"
5	"time"
6
7	"github.com/stretchr/testify/assert"
8)
9
10func TestFormatAppendTags(t *testing.T) {
11	var buffer []byte
12	buffer = appendTags(buffer, []string{"global:tag"}, []string{"tag:tag", "tag2:tag2"})
13	assert.Equal(t, `|#global:tag,tag:tag,tag2:tag2`, string(buffer))
14
15	var buffer2 []byte
16	buffer2 = appendTags(buffer2, []string{"global:tag"}, nil)
17	assert.Equal(t, `|#global:tag`, string(buffer2))
18
19	var buffer3 []byte
20	buffer3 = appendTags(buffer3, nil, []string{"tag:tag", "tag2:tag2"})
21	assert.Equal(t, `|#tag:tag,tag2:tag2`, string(buffer3))
22
23	var buffer4 []byte
24	buffer4 = appendTags(buffer4, nil, nil)
25	assert.Equal(t, "", string(buffer4))
26}
27
28func TestFormatAppendTagsAggregated(t *testing.T) {
29	var buffer []byte
30	buffer = appendTagsAggregated(buffer, []string{"global:tag"}, "tag:tag,tag2:tag2")
31	assert.Equal(t, `|#global:tag,tag:tag,tag2:tag2`, string(buffer))
32
33	var buffer2 []byte
34	buffer2 = appendTagsAggregated(buffer2, []string{"global:tag"}, "")
35	assert.Equal(t, `|#global:tag`, string(buffer2))
36
37	var buffer3 []byte
38	buffer3 = appendTagsAggregated(buffer3, nil, "tag:tag,tag2:tag2")
39	assert.Equal(t, `|#tag:tag,tag2:tag2`, string(buffer3))
40
41	var buffer4 []byte
42	buffer4 = appendTagsAggregated(buffer4, nil, "")
43	assert.Equal(t, "", string(buffer4))
44}
45
46func TestFormatAppendGauge(t *testing.T) {
47	var buffer []byte
48	buffer = appendGauge(buffer, "namespace.", []string{"global:tag"}, "gauge", 1., []string{"tag:tag"}, 1)
49	assert.Equal(t, `namespace.gauge:1|g|#global:tag,tag:tag`, string(buffer))
50}
51
52func TestFormatAppendCount(t *testing.T) {
53	var buffer []byte
54	buffer = appendCount(buffer, "namespace.", []string{"global:tag"}, "count", 2, []string{"tag:tag"}, 1)
55	assert.Equal(t, `namespace.count:2|c|#global:tag,tag:tag`, string(buffer))
56}
57
58func TestFormatAppendHistogram(t *testing.T) {
59	var buffer []byte
60	buffer = appendHistogram(buffer, "namespace.", []string{"global:tag"}, "histogram", 3., []string{"tag:tag"}, 1)
61	assert.Equal(t, `namespace.histogram:3|h|#global:tag,tag:tag`, string(buffer))
62}
63
64func TestFormatAppendDistribution(t *testing.T) {
65	var buffer []byte
66	buffer = appendDistribution(buffer, "namespace.", []string{"global:tag"}, "distribution", 4., []string{"tag:tag"}, 1)
67	assert.Equal(t, `namespace.distribution:4|d|#global:tag,tag:tag`, string(buffer))
68}
69
70func TestFormatAppendSet(t *testing.T) {
71	var buffer []byte
72	buffer = appendSet(buffer, "namespace.", []string{"global:tag"}, "set", "five", []string{"tag:tag"}, 1)
73	assert.Equal(t, `namespace.set:five|s|#global:tag,tag:tag`, string(buffer))
74}
75
76func TestFormatAppendTiming(t *testing.T) {
77	var buffer []byte
78	buffer = appendTiming(buffer, "namespace.", []string{"global:tag"}, "timing", 6., []string{"tag:tag"}, 1)
79	assert.Equal(t, `namespace.timing:6.000000|ms|#global:tag,tag:tag`, string(buffer))
80}
81
82func TestFormatNoTag(t *testing.T) {
83	var buffer []byte
84	buffer = appendGauge(buffer, "", []string{}, "gauge", 1., []string{}, 1)
85	assert.Equal(t, `gauge:1|g`, string(buffer))
86}
87
88func TestFormatOneTag(t *testing.T) {
89	var buffer []byte
90	buffer = appendGauge(buffer, "", []string{}, "gauge", 1., []string{"tag1:tag1"}, 1)
91	assert.Equal(t, `gauge:1|g|#tag1:tag1`, string(buffer))
92}
93
94func TestFormatTwoTag(t *testing.T) {
95	var buffer []byte
96	buffer = appendGauge(buffer, "", []string{}, "metric", 1., []string{"tag1:tag1", "tag2:tag2"}, 1)
97	assert.Equal(t, `metric:1|g|#tag1:tag1,tag2:tag2`, string(buffer))
98}
99
100func TestFormatRate(t *testing.T) {
101	var buffer []byte
102	buffer = appendGauge(buffer, "", []string{}, "metric", 1., []string{}, 0.1)
103	assert.Equal(t, `metric:1|g|@0.1`, string(buffer))
104}
105
106func TestFormatRateAndTag(t *testing.T) {
107	var buffer []byte
108	buffer = appendGauge(buffer, "", []string{}, "metric", 1., []string{"tag1:tag1"}, 0.1)
109	assert.Equal(t, `metric:1|g|@0.1|#tag1:tag1`, string(buffer))
110}
111
112func TestFormatNil(t *testing.T) {
113	var buffer []byte
114	buffer = appendGauge(buffer, "", nil, "metric", 1., nil, 1)
115	assert.Equal(t, `metric:1|g`, string(buffer))
116}
117
118func TestFormatTagRemoveNewLines(t *testing.T) {
119	var buffer []byte
120	buffer = appendGauge(buffer, "", []string{"tag\n:d\nog\n"}, "metric", 1., []string{"\ntag\n:d\nog2\n"}, 0.1)
121	assert.Equal(t, `metric:1|g|@0.1|#tag:dog,tag:dog2`, string(buffer))
122}
123
124func TestFormatEvent(t *testing.T) {
125	var buffer []byte
126	buffer = appendEvent(buffer, Event{
127		Title: "EvenTitle",
128		Text:  "EventText",
129	}, []string{})
130	assert.Equal(t, `_e{9,9}:EvenTitle|EventText`, string(buffer))
131}
132
133func TestFormatEventEscapeText(t *testing.T) {
134	var buffer []byte
135	buffer = appendEvent(buffer, Event{
136		Title: "EvenTitle",
137		Text:  "\nEventText\nLine2\n\nLine4\n",
138	}, []string{})
139	assert.Equal(t, `_e{9,29}:EvenTitle|\nEventText\nLine2\n\nLine4\n`, string(buffer))
140}
141
142func TestFormatEventTimeStamp(t *testing.T) {
143	var buffer []byte
144	buffer = appendEvent(buffer, Event{
145		Title:     "EvenTitle",
146		Text:      "EventText",
147		Timestamp: time.Date(2016, time.August, 15, 0, 0, 0, 0, time.UTC),
148	}, []string{})
149	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|d:1471219200`, string(buffer))
150}
151
152func TestFormatEventHostname(t *testing.T) {
153	var buffer []byte
154	buffer = appendEvent(buffer, Event{
155		Title:    "EvenTitle",
156		Text:     "EventText",
157		Hostname: "hostname",
158	}, []string{})
159	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|h:hostname`, string(buffer))
160}
161
162func TestFormatEventAggregationKey(t *testing.T) {
163	var buffer []byte
164	buffer = appendEvent(buffer, Event{
165		Title:          "EvenTitle",
166		Text:           "EventText",
167		AggregationKey: "aggregationKey",
168	}, []string{})
169	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|k:aggregationKey`, string(buffer))
170}
171
172func TestFormatEventPriority(t *testing.T) {
173	var buffer []byte
174	buffer = appendEvent(buffer, Event{
175		Title:    "EvenTitle",
176		Text:     "EventText",
177		Priority: "priority",
178	}, []string{})
179	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|p:priority`, string(buffer))
180}
181
182func TestFormatEventSourceTypeName(t *testing.T) {
183	var buffer []byte
184	buffer = appendEvent(buffer, Event{
185		Title:          "EvenTitle",
186		Text:           "EventText",
187		SourceTypeName: "sourceTypeName",
188	}, []string{})
189	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|s:sourceTypeName`, string(buffer))
190}
191
192func TestFormatEventAlertType(t *testing.T) {
193	var buffer []byte
194	buffer = appendEvent(buffer, Event{
195		Title:     "EvenTitle",
196		Text:      "EventText",
197		AlertType: "alertType",
198	}, []string{})
199	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|t:alertType`, string(buffer))
200}
201
202func TestFormatEventOneTag(t *testing.T) {
203	var buffer []byte
204	buffer = appendEvent(buffer, Event{
205		Title: "EvenTitle",
206		Text:  "EventText",
207	}, []string{"tag:test"})
208	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|#tag:test`, string(buffer))
209}
210
211func TestFormatEventTwoTag(t *testing.T) {
212	var buffer []byte
213	buffer = appendEvent(buffer, Event{
214		Title: "EvenTitle",
215		Text:  "EventText",
216		Tags:  []string{"tag1:test"},
217	}, []string{"tag2:test"})
218	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|#tag2:test,tag1:test`, string(buffer))
219}
220
221func TestFormatEventAllOptions(t *testing.T) {
222	var buffer []byte
223	buffer = appendEvent(buffer, Event{
224		Title:          "EvenTitle",
225		Text:           "EventText",
226		Timestamp:      time.Date(2016, time.August, 15, 0, 0, 0, 0, time.UTC),
227		Hostname:       "hostname",
228		AggregationKey: "aggregationKey",
229		Priority:       "priority",
230		SourceTypeName: "SourceTypeName",
231		AlertType:      "alertType",
232		Tags:           []string{"tag:normal"},
233	}, []string{"tag:global"})
234	assert.Equal(t, `_e{9,9}:EvenTitle|EventText|d:1471219200|h:hostname|k:aggregationKey|p:priority|s:SourceTypeName|t:alertType|#tag:global,tag:normal`, string(buffer))
235}
236
237func TestFormatEventNil(t *testing.T) {
238	var buffer []byte
239	buffer = appendEvent(buffer, Event{}, []string{})
240	assert.Equal(t, `_e{0,0}:|`, string(buffer))
241}
242
243func TestFormatServiceCheck(t *testing.T) {
244	var buffer []byte
245	buffer = appendServiceCheck(buffer, ServiceCheck{
246		Name:   "service.check",
247		Status: Ok,
248	}, []string{})
249	assert.Equal(t, `_sc|service.check|0`, string(buffer))
250}
251
252func TestFormatServiceCheckEscape(t *testing.T) {
253	var buffer []byte
254	buffer = appendServiceCheck(buffer, ServiceCheck{
255		Name:    "service.check",
256		Status:  Ok,
257		Message: "\n\nmessagem:hello...\n\nm:aa\nm:m",
258	}, []string{})
259	assert.Equal(t, `_sc|service.check|0|m:\n\nmessagem\:hello...\n\nm\:aa\nm\:m`, string(buffer))
260}
261
262func TestFormatServiceCheckTimestamp(t *testing.T) {
263	var buffer []byte
264	buffer = appendServiceCheck(buffer, ServiceCheck{
265		Name:      "service.check",
266		Status:    Ok,
267		Timestamp: time.Date(2016, time.August, 15, 0, 0, 0, 0, time.UTC),
268	}, []string{})
269	assert.Equal(t, `_sc|service.check|0|d:1471219200`, string(buffer))
270}
271
272func TestFormatServiceCheckHostname(t *testing.T) {
273	var buffer []byte
274	buffer = appendServiceCheck(buffer, ServiceCheck{
275		Name:     "service.check",
276		Status:   Ok,
277		Hostname: "hostname",
278	}, []string{})
279	assert.Equal(t, `_sc|service.check|0|h:hostname`, string(buffer))
280}
281
282func TestFormatServiceCheckMessage(t *testing.T) {
283	var buffer []byte
284	buffer = appendServiceCheck(buffer, ServiceCheck{
285		Name:    "service.check",
286		Status:  Ok,
287		Message: "message",
288	}, []string{})
289	assert.Equal(t, `_sc|service.check|0|m:message`, string(buffer))
290}
291
292func TestFormatServiceCheckOneTag(t *testing.T) {
293	var buffer []byte
294	buffer = appendServiceCheck(buffer, ServiceCheck{
295		Name:   "service.check",
296		Status: Ok,
297		Tags:   []string{"tag:tag"},
298	}, []string{})
299	assert.Equal(t, `_sc|service.check|0|#tag:tag`, string(buffer))
300}
301
302func TestFormatServiceCheckTwoTag(t *testing.T) {
303	var buffer []byte
304	buffer = appendServiceCheck(buffer, ServiceCheck{
305		Name:   "service.check",
306		Status: Ok,
307		Tags:   []string{"tag1:tag1"},
308	}, []string{"tag2:tag2"})
309	assert.Equal(t, `_sc|service.check|0|#tag2:tag2,tag1:tag1`, string(buffer))
310}
311
312func TestFormatServiceCheckAllOptions(t *testing.T) {
313	var buffer []byte
314	buffer = appendServiceCheck(buffer, ServiceCheck{
315		Name:      "service.check",
316		Status:    Ok,
317		Timestamp: time.Date(2016, time.August, 15, 0, 0, 0, 0, time.UTC),
318		Hostname:  "hostname",
319		Message:   "message",
320		Tags:      []string{"tag1:tag1"},
321	}, []string{"tag2:tag2"})
322	assert.Equal(t, `_sc|service.check|0|d:1471219200|h:hostname|#tag2:tag2,tag1:tag1|m:message`, string(buffer))
323}
324
325func TestFormatServiceCheckNil(t *testing.T) {
326	var buffer []byte
327	buffer = appendServiceCheck(buffer, ServiceCheck{}, nil)
328	assert.Equal(t, `_sc||0`, string(buffer))
329}
330
331func TestFormatSeparator(t *testing.T) {
332	var buffer []byte
333	buffer = appendSeparator(buffer)
334	assert.Equal(t, "\n", string(buffer))
335}
336