2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
26 func TestMetricCounter(t *testing.T) {
27 TestCounterOpt := CounterOpts{Name: "CounterBlaah1", Help: "CounterBlaah1"}
28 ret1 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
30 ret2 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
33 t.Errorf("ret1 not same than ret2. cache not working?")
37 func TestMetricCounterGroup(t *testing.T) {
38 var TestCounterOpts = []CounterOpts{
39 {Name: "CounterBlaah1", Help: "CounterBlaah1"},
40 {Name: "CounterBlaah2", Help: "CounterBlaah2"},
41 {Name: "CounterBlaah3", Help: "CounterBlaah3"},
42 {Name: "CounterBlaah4", Help: "CounterBlaah4"},
45 ret1 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
48 t.Errorf("ret1 counter group is empty")
51 ret1["CounterBlaah1"].Inc()
52 ret1["CounterBlaah2"].Inc()
53 ret1["CounterBlaah3"].Inc()
54 ret1["CounterBlaah4"].Inc()
56 ret2 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
59 t.Errorf("ret2 counter group is empty")
62 ret2["CounterBlaah1"].Inc()
63 ret2["CounterBlaah2"].Inc()
64 ret2["CounterBlaah3"].Inc()
65 ret2["CounterBlaah4"].Inc()
67 if len(ret1) != len(ret2) {
68 t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
72 func TestMetricLabeledCounter(t *testing.T) {
75 c_1_1 := Metric.RegisterLabeledCounter(
76 CounterOpts{Name: "counter1", Help: "counter1"},
77 []string{"name", "event"},
78 []string{"name1", "event1"},
81 c_1_2 := Metric.RegisterLabeledCounter(
82 CounterOpts{Name: "counter1", Help: "counter1"},
83 []string{"name", "event"},
84 []string{"name1", "event1"},
90 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
95 c_2_1 := Metric.RegisterLabeledCounter(
96 CounterOpts{Name: "counter1", Help: "counter1"},
97 []string{"name", "event"},
98 []string{"name1", "event2"},
101 c_2_2 := Metric.RegisterLabeledCounter(
102 CounterOpts{Name: "counter1", Help: "counter1"},
103 []string{"name", "event"},
104 []string{"name1", "event2"},
110 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
114 t.Errorf("c_1_1 same than c_2_1. what?")
117 t.Errorf("c_1_2 same than c_2_2. what?")
122 func TestMetricLabeledCounterMissmatch(t *testing.T) {
123 Metric.RegisterLabeledCounter(
124 CounterOpts{Name: "counter1", Help: "counter1"},
125 []string{"name", "event"},
126 []string{"name1", "event1"},
127 "SUBSYSTEMLERRMISSMATCH")
129 ret := Metric.RegisterLabeledCounter(
130 CounterOpts{Name: "counter1", Help: "counter1"},
131 []string{"name", "eventmiss"},
132 []string{"name1", "event1"},
133 "SUBSYSTEMLERRMISSMATCH")
136 t.Errorf("Returned counter even its labels are mismatching")
139 ret = Metric.RegisterLabeledCounter(
140 CounterOpts{Name: "counter1", Help: "counter1"},
143 "SUBSYSTEMLERRMISSMATCH")
146 t.Errorf("Returned counter even its labels are mismatching")
151 func TestMetricLabeledCounterWrongOrder(t *testing.T) {
152 Metric.RegisterLabeledCounter(
153 CounterOpts{Name: "counter1", Help: "counter1"},
154 []string{"name", "event"},
155 []string{"name1", "event1"},
156 "SUBSYSTEMLERRWRONGORDER")
158 ret := Metric.RegisterLabeledCounter(
159 CounterOpts{Name: "counter1", Help: "counter1"},
160 []string{"event", "name"},
161 []string{"name1", "event1"},
162 "SUBSYSTEMLERRWRONGORDER")
165 t.Errorf("Returned counter even its labels order is wrong")
169 func TestMetricLabeledCounterCounterNameExists(t *testing.T) {
170 Metric.RegisterCounter(
171 CounterOpts{Name: "counter1", Help: "counter1"},
172 "SUBSYSTEMLERRNAMEEXISTS")
174 ret := Metric.RegisterLabeledCounter(
175 CounterOpts{Name: "counter1", Help: "counter1"},
176 []string{"name", "event"},
177 []string{"name1", "event1"},
178 "SUBSYSTEMLERRNAMEEXISTS")
181 t.Errorf("Returned labeled counter even its name conflicts with existing counter name")
185 func TestMetricCounterLabeledCounterNameExists(t *testing.T) {
186 Metric.RegisterLabeledCounter(
187 CounterOpts{Name: "counter2", Help: "counter2"},
188 []string{"name", "event"},
189 []string{"name1", "event1"},
190 "SUBSYSTEMLERRNAMEEXISTS")
192 ret := Metric.RegisterCounter(
193 CounterOpts{Name: "counter2", Help: "counter2"},
194 "SUBSYSTEMLERRNAMEEXISTS")
197 t.Errorf("Returned counter even its name conflicts with existing labeled counter name")
201 func TestMetricLabeledCounterGroup(t *testing.T) {
204 c_grp1 := Metric.RegisterLabeledCounterGroup(
205 []CounterOpts{{Name: "counter1", Help: "counter1"}},
206 []string{"name", "event"},
207 []string{"name1", "event1"},
210 if _, ok := c_grp1["counter1"]; ok == false {
211 t.Errorf("c_grp1 counter1 not exists")
213 c_grp1["counter1"].Inc()
217 c_grp2 := Metric.RegisterLabeledCounterGroup(
218 []CounterOpts{{Name: "counter1", Help: "counter1"}},
219 []string{"name", "event"},
220 []string{"name1", "event2"},
223 if _, ok := c_grp2["counter1"]; ok == false {
224 t.Errorf("c_grp2 counter1 not exists")
226 c_grp2["counter1"].Inc()
229 func TestMetricGauge(t *testing.T) {
230 TestGaugeOpts := CounterOpts{Name: "GaugeBlaah1", Help: "GaugeBlaah1"}
231 ret1 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
233 ret2 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
236 t.Errorf("ret1 not same than ret2. cache not working?")
240 func TestMetricGaugeGroup(t *testing.T) {
241 var TestGaugeOpts = []CounterOpts{
242 {Name: "GaugeBlaah1", Help: "GaugeBlaah1"},
243 {Name: "GaugeBlaah2", Help: "GaugeBlaah2"},
244 {Name: "GaugeBlaah3", Help: "GaugeBlaah3"},
245 {Name: "GaugeBlaah4", Help: "GaugeBlaah4"},
248 ret1 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
251 t.Errorf("ret1 gauge group is empty")
254 ret1["GaugeBlaah1"].Inc()
255 ret1["GaugeBlaah2"].Inc()
256 ret1["GaugeBlaah3"].Inc()
257 ret1["GaugeBlaah4"].Inc()
259 ret2 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
262 t.Errorf("ret2 gauge group is empty")
265 ret2["GaugeBlaah1"].Inc()
266 ret2["GaugeBlaah2"].Inc()
267 ret2["GaugeBlaah3"].Inc()
268 ret2["GaugeBlaah4"].Inc()
270 if len(ret1) != len(ret2) {
271 t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
275 func TestMetricLabeledGauge(t *testing.T) {
278 c_1_1 := Metric.RegisterLabeledGauge(
279 CounterOpts{Name: "gauge1", Help: "gauge1"},
280 []string{"name", "event"},
281 []string{"name1", "event1"},
284 c_1_2 := Metric.RegisterLabeledGauge(
285 CounterOpts{Name: "gauge1", Help: "gauge1"},
286 []string{"name", "event"},
287 []string{"name1", "event1"},
293 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
298 c_2_1 := Metric.RegisterLabeledGauge(
299 CounterOpts{Name: "gauge1", Help: "gauge1"},
300 []string{"name", "event"},
301 []string{"name1", "event2"},
304 c_2_2 := Metric.RegisterLabeledGauge(
305 CounterOpts{Name: "gauge1", Help: "gauge1"},
306 []string{"name", "event"},
307 []string{"name1", "event2"},
313 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
317 t.Errorf("c_1_1 same than c_2_1. what?")
320 t.Errorf("c_1_2 same than c_2_2. what?")
325 func TestMetricLabeledGaugeMissmatch(t *testing.T) {
326 Metric.RegisterLabeledGauge(
327 CounterOpts{Name: "gauge1", Help: "gauge1"},
328 []string{"name", "event"},
329 []string{"name1", "event1"},
330 "SUBSYSTEMLERRMISSMATCH")
332 ret := Metric.RegisterLabeledGauge(
333 CounterOpts{Name: "gauge1", Help: "gauge1"},
334 []string{"name", "eventmiss"},
335 []string{"name1", "event1"},
336 "SUBSYSTEMLERRMISSMATCH")
339 t.Errorf("Returned gauge even its labels are mismatching")
342 ret = Metric.RegisterLabeledGauge(
343 CounterOpts{Name: "gauge1", Help: "gauge1"},
346 "SUBSYSTEMLERRMISSMATCH")
349 t.Errorf("Returned gauge even its labels are mismatching")
354 func TestMetricLabeledGaugeWrongOrder(t *testing.T) {
355 Metric.RegisterLabeledGauge(
356 CounterOpts{Name: "gauge1", Help: "gauge1"},
357 []string{"name", "event"},
358 []string{"name1", "event1"},
359 "SUBSYSTEMLERRWRONGORDER")
361 ret := Metric.RegisterLabeledGauge(
362 CounterOpts{Name: "gauge1", Help: "gauge1"},
363 []string{"event", "name"},
364 []string{"name1", "event1"},
365 "SUBSYSTEMLERRWRONGORDER")
368 t.Errorf("Returned gauge even its labels order is wrong")
373 func TestMetricLabeledGaugeGaugeNameExists(t *testing.T) {
374 Metric.RegisterGauge(
375 CounterOpts{Name: "gauge1", Help: "gauge1"},
376 "SUBSYSTEMLERRNAMEEXISTS")
378 ret := Metric.RegisterLabeledGauge(
379 CounterOpts{Name: "gauge1", Help: "gauge1"},
380 []string{"name", "event"},
381 []string{"name1", "event1"},
382 "SUBSYSTEMLERRNAMEEXISTS")
385 t.Errorf("Returned labeled gauge even its name conflicts with existing gauge name")
389 func TestMetricGaugeLabeledGaugeNameExists(t *testing.T) {
390 Metric.RegisterLabeledGauge(
391 CounterOpts{Name: "gauge2", Help: "gauge2"},
392 []string{"name", "event"},
393 []string{"name1", "event1"},
394 "SUBSYSTEMLERRNAMEEXISTS")
396 ret := Metric.RegisterGauge(
397 CounterOpts{Name: "gauge2", Help: "gauge2"},
398 "SUBSYSTEMLERRNAMEEXISTS")
401 t.Errorf("Returned gauge even its name conflicts with existing labeled gauge name")
405 func TestMetricLabeledGaugeGroup(t *testing.T) {
408 g_grp1 := Metric.RegisterLabeledGaugeGroup(
409 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
410 []string{"name", "event"},
411 []string{"name1", "event1"},
414 if _, ok := g_grp1["gauge1"]; ok == false {
415 t.Errorf("g_grp1 gauge1 not exists")
417 g_grp1["gauge1"].Inc()
421 g_grp2 := Metric.RegisterLabeledGaugeGroup(
422 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
423 []string{"name", "event"},
424 []string{"name1", "event2"},
427 if _, ok := g_grp2["gauge1"]; ok == false {
428 t.Errorf("g_grp2 gauge1 not exists")
430 g_grp2["gauge1"].Inc()
433 func TestMetricGroupCache(t *testing.T) {
436 c_grp1 := Metric.RegisterLabeledCounterGroup(
437 []CounterOpts{{Name: "counter1", Help: "counter1"}},
438 []string{"name", "event"},
439 []string{"name1", "event1"},
441 if _, ok := c_grp1["counter1"]; ok == false {
442 t.Errorf("c_grp1 counter1 not exists")
444 c_grp1["counter1"].Inc()
448 c_grp2 := Metric.RegisterLabeledCounterGroup(
449 []CounterOpts{{Name: "counter1", Help: "counter1"}},
450 []string{"name", "event"},
451 []string{"name1", "event2"},
453 if _, ok := c_grp2["counter1"]; ok == false {
454 t.Errorf("c_grp2 counter1 not exists")
456 c_grp2["counter1"].Inc()
460 g_grp1 := Metric.RegisterLabeledGaugeGroup(
461 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
462 []string{"name", "event"},
463 []string{"name1", "event1"},
465 if _, ok := g_grp1["gauge1"]; ok == false {
466 t.Errorf("g_grp1 gauge1 not exists")
468 g_grp1["gauge1"].Inc()
472 g_grp2 := Metric.RegisterLabeledGaugeGroup(
473 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
474 []string{"name", "event"},
475 []string{"name1", "event2"},
477 if _, ok := g_grp2["gauge1"]; ok == false {
478 t.Errorf("g_grp2 gauge1 not exists")
480 g_grp2["gauge1"].Inc()
484 m_grp := NewMetricGroupsCache()
485 m_grp.CombineCounterGroupsWithPrefix("event1_", c_grp1)
486 m_grp.CombineCounterGroupsWithPrefix("event2_", c_grp2)
487 m_grp.CombineGaugeGroupsWithPrefix("event1_", g_grp1)
488 m_grp.CombineGaugeGroupsWithPrefix("event2_", g_grp2)
491 t.Errorf("Cache failed")
494 if m_grp.CIs("event1_counter1") == false {
495 t.Errorf("m_grp.Counters event1_counter1 not exists")
497 m_grp.CInc("event1_counter1")
499 if m_grp.CIs("event2_counter1") == false {
500 t.Errorf("m_grp.Counters event2_counter1 not exists")
502 m_grp.CInc("event2_counter1")
504 if m_grp.GIs("event1_gauge1") == false {
505 t.Errorf("m_grp.Gauges event1_gauge1 not exists")
507 m_grp.GInc("event1_gauge1")
509 if m_grp.GIs("event2_gauge1") == false {
510 t.Errorf("m_grp.Gauges event2_gauge1 not exists")
512 m_grp.GInc("event2_gauge1")
514 m_grp.CAdd("event2_counter1", 1)
515 m_grp.CGet("event2_counter1")
516 m_grp.GGet("event2_gauge1")
517 m_grp.GDec("event2_gauge1")
518 m_grp.GSet("event2_gauge1", 1)
521 type registerer struct{}
523 func (met *registerer) RegisterCounter(opts CounterOpts) Counter {
524 return Metric.RegisterLabeledCounter(
526 []string{"host", "interface"},
527 []string{"testhost", "testinterface"},
531 func (met *registerer) RegisterGauge(opts CounterOpts) Gauge {
532 return Metric.RegisterLabeledGauge(
534 []string{"host", "interface"},
535 []string{"testhost", "testinterface"},
539 func TestMetricCounterAutoCGetNoReg(t *testing.T) {
540 m_grp := NewMetricGroupsCache()
541 m_grp.CGet("cautotest1")
544 func TestMetricCounterAutoCGetFunc(t *testing.T) {
545 m_grp := NewMetricGroupsCache()
546 m_reg := ®isterer{}
547 m_grp.Registerer(MetricGroupsCacheCounterRegistererFunc(m_reg.RegisterCounter), nil)
548 m_grp.CGet("cautotest1")
551 func TestMetricCounterAutoCGet(t *testing.T) {
552 m_grp := NewMetricGroupsCacheWithRegisterers(®isterer{}, nil)
553 m_grp.CGet("cautotest1")
556 func TestMetricCounterAutoCInc(t *testing.T) {
557 m_grp := NewMetricGroupsCache()
558 m_grp.Registerer(®isterer{}, nil)
559 m_grp.CInc("cautotest1")
562 func TestMetricCounterAutoCAdd(t *testing.T) {
563 m_grp := NewMetricGroupsCache()
564 m_grp.Registerer(®isterer{}, nil)
565 m_grp.CAdd("cautotest1", float64(10))
568 func TestMetricCounterAutoGGetNoReg(t *testing.T) {
569 m_grp := NewMetricGroupsCache()
570 m_grp.GGet("gautotest1")
573 func TestMetricCounterAutoGGetFunc(t *testing.T) {
574 m_grp := NewMetricGroupsCache()
575 m_reg := ®isterer{}
576 m_grp.Registerer(nil, MetricGroupsCacheGaugeRegistererFunc(m_reg.RegisterGauge))
577 m_grp.GGet("gautotest1")
580 func TestMetricCounterAutoGGet(t *testing.T) {
581 m_grp := NewMetricGroupsCacheWithRegisterers(nil, ®isterer{})
582 m_grp.GGet("gautotest1")
585 func TestMetricCounterAutoGInc(t *testing.T) {
586 m_grp := NewMetricGroupsCache()
587 m_grp.Registerer(nil, ®isterer{})
588 m_grp.GInc("gautotest1")
591 func TestMetricCounterAutoGSet(t *testing.T) {
592 m_grp := NewMetricGroupsCache()
593 m_grp.Registerer(nil, ®isterer{})
594 m_grp.GSet("gautotest1", float64(10))
597 func TestMetricCounterAutoGAdd(t *testing.T) {
598 m_grp := NewMetricGroupsCache()
599 m_grp.Registerer(nil, ®isterer{})
600 m_grp.GAdd("gautotest1", float64(10))
603 func TestMetricCounterAutoGDec(t *testing.T) {
604 m_grp := NewMetricGroupsCache()
605 m_grp.Registerer(nil, ®isterer{})
606 m_grp.GDec("gautotest1")