pkg/xapp/metrics_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   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
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  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 ==================================================================================
  18 */
  19
  20 package xapp
  21
  22 import (
  23         "testing"
  24 )
  25
  26 func TestMetricCounter(t *testing.T) {
  27         TestCounterOpt := CounterOpts{Name: "CounterBlaah1", Help: "CounterBlaah1"}
  28         ret1 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
  29         ret1.Inc()
  30         ret2 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
  31         ret2.Inc()
  32         if ret1 != ret2 {
  33                 t.Errorf("ret1 not same than ret2. cache not working?")
  34         }
  35 }
  36
  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"},
  43         }
  44
  45         ret1 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
  46
  47         if len(ret1) == 0 {
  48                 t.Errorf("ret1 counter group is empty")
  49         }
  50
  51         ret1["CounterBlaah1"].Inc()
  52         ret1["CounterBlaah2"].Inc()
  53         ret1["CounterBlaah3"].Inc()
  54         ret1["CounterBlaah4"].Inc()
  55
  56         ret2 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
  57
  58         if len(ret2) == 0 {
  59                 t.Errorf("ret2 counter group is empty")
  60         }
  61
  62         ret2["CounterBlaah1"].Inc()
  63         ret2["CounterBlaah2"].Inc()
  64         ret2["CounterBlaah3"].Inc()
  65         ret2["CounterBlaah4"].Inc()
  66
  67         if len(ret1) != len(ret2) {
  68                 t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
  69         }
  70 }
  71
  72 func TestMetricLabeledCounter(t *testing.T) {
  73         //
  74         //
  75         c_1_1 := Metric.RegisterLabeledCounter(
  76                 CounterOpts{Name: "counter1", Help: "counter1"},
  77                 []string{"name", "event"},
  78                 []string{"name1", "event1"},
  79                 "SUBSYSTEML0")
  80
  81         c_1_2 := Metric.RegisterLabeledCounter(
  82                 CounterOpts{Name: "counter1", Help: "counter1"},
  83                 []string{"name", "event"},
  84                 []string{"name1", "event1"},
  85                 "SUBSYSTEML0")
  86
  87         c_1_1.Inc()
  88         c_1_2.Inc()
  89         if c_1_1 != c_1_2 {
  90                 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
  91         }
  92
  93         //
  94         //
  95         c_2_1 := Metric.RegisterLabeledCounter(
  96                 CounterOpts{Name: "counter1", Help: "counter1"},
  97                 []string{"name", "event"},
  98                 []string{"name1", "event2"},
  99                 "SUBSYSTEML0")
 100
 101         c_2_2 := Metric.RegisterLabeledCounter(
 102                 CounterOpts{Name: "counter1", Help: "counter1"},
 103                 []string{"name", "event"},
 104                 []string{"name1", "event2"},
 105                 "SUBSYSTEML0")
 106
 107         c_2_1.Inc()
 108         c_2_2.Inc()
 109         if c_2_1 != c_2_2 {
 110                 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
 111         }
 112
 113         if c_1_1 == c_2_1 {
 114                 t.Errorf("c_1_1 same than c_2_1. what?")
 115         }
 116         if c_1_2 == c_2_2 {
 117                 t.Errorf("c_1_2 same than c_2_2. what?")
 118         }
 119
 120 }
 121
 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")
 128
 129         ret := Metric.RegisterLabeledCounter(
 130                 CounterOpts{Name: "counter1", Help: "counter1"},
 131                 []string{"name", "eventmiss"},
 132                 []string{"name1", "event1"},
 133                 "SUBSYSTEMLERRMISSMATCH")
 134
 135         if ret != nil {
 136                 t.Errorf("Returned counter even its labels are mismatching")
 137         }
 138
 139         ret = Metric.RegisterLabeledCounter(
 140                 CounterOpts{Name: "counter1", Help: "counter1"},
 141                 []string{"name"},
 142                 []string{"name1"},
 143                 "SUBSYSTEMLERRMISSMATCH")
 144
 145         if ret != nil {
 146                 t.Errorf("Returned counter even its labels are mismatching")
 147         }
 148
 149 }
 150
 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")
 157
 158         ret := Metric.RegisterLabeledCounter(
 159                 CounterOpts{Name: "counter1", Help: "counter1"},
 160                 []string{"event", "name"},
 161                 []string{"name1", "event1"},
 162                 "SUBSYSTEMLERRWRONGORDER")
 163
 164         if ret != nil {
 165                 t.Errorf("Returned counter even its labels order is wrong")
 166         }
 167 }
 168
 169 func TestMetricLabeledCounterCounterNameExists(t *testing.T) {
 170         Metric.RegisterCounter(
 171                 CounterOpts{Name: "counter1", Help: "counter1"},
 172                 "SUBSYSTEMLERRNAMEEXISTS")
 173
 174         ret := Metric.RegisterLabeledCounter(
 175                 CounterOpts{Name: "counter1", Help: "counter1"},
 176                 []string{"name", "event"},
 177                 []string{"name1", "event1"},
 178                 "SUBSYSTEMLERRNAMEEXISTS")
 179
 180         if ret != nil {
 181                 t.Errorf("Returned labeled counter even its name conflicts with existing counter name")
 182         }
 183 }
 184
 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")
 191
 192         ret := Metric.RegisterCounter(
 193                 CounterOpts{Name: "counter2", Help: "counter2"},
 194                 "SUBSYSTEMLERRNAMEEXISTS")
 195
 196         if ret != nil {
 197                 t.Errorf("Returned counter even its name conflicts with existing labeled counter name")
 198         }
 199 }
 200
 201 func TestMetricLabeledCounterGroup(t *testing.T) {
 202         //
 203         //
 204         c_grp1 := Metric.RegisterLabeledCounterGroup(
 205                 []CounterOpts{{Name: "counter1", Help: "counter1"}},
 206                 []string{"name", "event"},
 207                 []string{"name1", "event1"},
 208                 "SUBSYSTEML1")
 209
 210         if _, ok := c_grp1["counter1"]; ok == false {
 211                 t.Errorf("c_grp1 counter1 not exists")
 212         }
 213         c_grp1["counter1"].Inc()
 214
 215         //
 216         //
 217         c_grp2 := Metric.RegisterLabeledCounterGroup(
 218                 []CounterOpts{{Name: "counter1", Help: "counter1"}},
 219                 []string{"name", "event"},
 220                 []string{"name1", "event2"},
 221                 "SUBSYSTEML1")
 222
 223         if _, ok := c_grp2["counter1"]; ok == false {
 224                 t.Errorf("c_grp2 counter1 not exists")
 225         }
 226         c_grp2["counter1"].Inc()
 227 }
 228
 229 func TestMetricGauge(t *testing.T) {
 230         TestGaugeOpts := CounterOpts{Name: "GaugeBlaah1", Help: "GaugeBlaah1"}
 231         ret1 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
 232         ret1.Inc()
 233         ret2 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
 234         ret2.Inc()
 235         if ret1 != ret2 {
 236                 t.Errorf("ret1 not same than ret2. cache not working?")
 237         }
 238 }
 239
 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"},
 246         }
 247
 248         ret1 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
 249
 250         if len(ret1) == 0 {
 251                 t.Errorf("ret1 gauge group is empty")
 252         }
 253
 254         ret1["GaugeBlaah1"].Inc()
 255         ret1["GaugeBlaah2"].Inc()
 256         ret1["GaugeBlaah3"].Inc()
 257         ret1["GaugeBlaah4"].Inc()
 258
 259         ret2 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
 260
 261         if len(ret2) == 0 {
 262                 t.Errorf("ret2 gauge group is empty")
 263         }
 264
 265         ret2["GaugeBlaah1"].Inc()
 266         ret2["GaugeBlaah2"].Inc()
 267         ret2["GaugeBlaah3"].Inc()
 268         ret2["GaugeBlaah4"].Inc()
 269
 270         if len(ret1) != len(ret2) {
 271                 t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
 272         }
 273 }
 274
 275 func TestMetricLabeledGauge(t *testing.T) {
 276         //
 277         //
 278         c_1_1 := Metric.RegisterLabeledGauge(
 279                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 280                 []string{"name", "event"},
 281                 []string{"name1", "event1"},
 282                 "SUBSYSTEML0")
 283
 284         c_1_2 := Metric.RegisterLabeledGauge(
 285                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 286                 []string{"name", "event"},
 287                 []string{"name1", "event1"},
 288                 "SUBSYSTEML0")
 289
 290         c_1_1.Inc()
 291         c_1_2.Inc()
 292         if c_1_1 != c_1_2 {
 293                 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
 294         }
 295
 296         //
 297         //
 298         c_2_1 := Metric.RegisterLabeledGauge(
 299                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 300                 []string{"name", "event"},
 301                 []string{"name1", "event2"},
 302                 "SUBSYSTEML0")
 303
 304         c_2_2 := Metric.RegisterLabeledGauge(
 305                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 306                 []string{"name", "event"},
 307                 []string{"name1", "event2"},
 308                 "SUBSYSTEML0")
 309
 310         c_2_1.Inc()
 311         c_2_2.Inc()
 312         if c_2_1 != c_2_2 {
 313                 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
 314         }
 315
 316         if c_1_1 == c_2_1 {
 317                 t.Errorf("c_1_1 same than c_2_1. what?")
 318         }
 319         if c_1_2 == c_2_2 {
 320                 t.Errorf("c_1_2 same than c_2_2. what?")
 321         }
 322
 323 }
 324
 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")
 331
 332         ret := Metric.RegisterLabeledGauge(
 333                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 334                 []string{"name", "eventmiss"},
 335                 []string{"name1", "event1"},
 336                 "SUBSYSTEMLERRMISSMATCH")
 337
 338         if ret != nil {
 339                 t.Errorf("Returned gauge even its labels are mismatching")
 340         }
 341
 342         ret = Metric.RegisterLabeledGauge(
 343                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 344                 []string{"name"},
 345                 []string{"name1"},
 346                 "SUBSYSTEMLERRMISSMATCH")
 347
 348         if ret != nil {
 349                 t.Errorf("Returned gauge even its labels are mismatching")
 350         }
 351
 352 }
 353
 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")
 360
 361         ret := Metric.RegisterLabeledGauge(
 362                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 363                 []string{"event", "name"},
 364                 []string{"name1", "event1"},
 365                 "SUBSYSTEMLERRWRONGORDER")
 366
 367         if ret != nil {
 368                 t.Errorf("Returned gauge even its labels order is wrong")
 369         }
 370
 371 }
 372
 373 func TestMetricLabeledGaugeGaugeNameExists(t *testing.T) {
 374         Metric.RegisterGauge(
 375                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 376                 "SUBSYSTEMLERRNAMEEXISTS")
 377
 378         ret := Metric.RegisterLabeledGauge(
 379                 CounterOpts{Name: "gauge1", Help: "gauge1"},
 380                 []string{"name", "event"},
 381                 []string{"name1", "event1"},
 382                 "SUBSYSTEMLERRNAMEEXISTS")
 383
 384         if ret != nil {
 385                 t.Errorf("Returned labeled gauge even its name conflicts with existing gauge name")
 386         }
 387 }
 388
 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")
 395
 396         ret := Metric.RegisterGauge(
 397                 CounterOpts{Name: "gauge2", Help: "gauge2"},
 398                 "SUBSYSTEMLERRNAMEEXISTS")
 399
 400         if ret != nil {
 401                 t.Errorf("Returned gauge even its name conflicts with existing labeled gauge name")
 402         }
 403 }
 404
 405 func TestMetricLabeledGaugeGroup(t *testing.T) {
 406         //
 407         //
 408         g_grp1 := Metric.RegisterLabeledGaugeGroup(
 409                 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
 410                 []string{"name", "event"},
 411                 []string{"name1", "event1"},
 412                 "SUBSYSTEML1")
 413
 414         if _, ok := g_grp1["gauge1"]; ok == false {
 415                 t.Errorf("g_grp1 gauge1 not exists")
 416         }
 417         g_grp1["gauge1"].Inc()
 418
 419         //
 420         //
 421         g_grp2 := Metric.RegisterLabeledGaugeGroup(
 422                 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
 423                 []string{"name", "event"},
 424                 []string{"name1", "event2"},
 425                 "SUBSYSTEML1")
 426
 427         if _, ok := g_grp2["gauge1"]; ok == false {
 428                 t.Errorf("g_grp2 gauge1 not exists")
 429         }
 430         g_grp2["gauge1"].Inc()
 431 }
 432
 433 func TestMetricGroupCache(t *testing.T) {
 434         //
 435         //
 436         c_grp1 := Metric.RegisterLabeledCounterGroup(
 437                 []CounterOpts{{Name: "counter1", Help: "counter1"}},
 438                 []string{"name", "event"},
 439                 []string{"name1", "event1"},
 440                 "SUBSYSTEML1")
 441         if _, ok := c_grp1["counter1"]; ok == false {
 442                 t.Errorf("c_grp1 counter1 not exists")
 443         }
 444         c_grp1["counter1"].Inc()
 445
 446         //
 447         //
 448         c_grp2 := Metric.RegisterLabeledCounterGroup(
 449                 []CounterOpts{{Name: "counter1", Help: "counter1"}},
 450                 []string{"name", "event"},
 451                 []string{"name1", "event2"},
 452                 "SUBSYSTEML1")
 453         if _, ok := c_grp2["counter1"]; ok == false {
 454                 t.Errorf("c_grp2 counter1 not exists")
 455         }
 456         c_grp2["counter1"].Inc()
 457
 458         //
 459         //
 460         g_grp1 := Metric.RegisterLabeledGaugeGroup(
 461                 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
 462                 []string{"name", "event"},
 463                 []string{"name1", "event1"},
 464                 "SUBSYSTEML1")
 465         if _, ok := g_grp1["gauge1"]; ok == false {
 466                 t.Errorf("g_grp1 gauge1 not exists")
 467         }
 468         g_grp1["gauge1"].Inc()
 469
 470         //
 471         //
 472         g_grp2 := Metric.RegisterLabeledGaugeGroup(
 473                 []CounterOpts{{Name: "gauge1", Help: "gauge1"}},
 474                 []string{"name", "event"},
 475                 []string{"name1", "event2"},
 476                 "SUBSYSTEML1")
 477         if _, ok := g_grp2["gauge1"]; ok == false {
 478                 t.Errorf("g_grp2 gauge1 not exists")
 479         }
 480         g_grp2["gauge1"].Inc()
 481
 482         //
 483         //
 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)
 489
 490         if m_grp == nil {
 491                 t.Errorf("Cache failed")
 492         }
 493
 494         if m_grp.CIs("event1_counter1") == false {
 495                 t.Errorf("m_grp.Counters event1_counter1 not exists")
 496         }
 497         m_grp.CInc("event1_counter1")
 498
 499         if m_grp.CIs("event2_counter1") == false {
 500                 t.Errorf("m_grp.Counters event2_counter1 not exists")
 501         }
 502         m_grp.CInc("event2_counter1")
 503
 504         if m_grp.GIs("event1_gauge1") == false {
 505                 t.Errorf("m_grp.Gauges event1_gauge1 not exists")
 506         }
 507         m_grp.GInc("event1_gauge1")
 508
 509         if m_grp.GIs("event2_gauge1") == false {
 510                 t.Errorf("m_grp.Gauges event2_gauge1 not exists")
 511         }
 512         m_grp.GInc("event2_gauge1")
 513
 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)
 519 }
 520
 521 type registerer struct{}
 522
 523 func (met *registerer) RegisterCounter(opts CounterOpts) Counter {
 524         return Metric.RegisterLabeledCounter(
 525                 opts,
 526                 []string{"host", "interface"},
 527                 []string{"testhost", "testinterface"},
 528                 "SUBSYSTEMAUTO")
 529 }
 530
 531 func (met *registerer) RegisterGauge(opts CounterOpts) Gauge {
 532         return Metric.RegisterLabeledGauge(
 533                 opts,
 534                 []string{"host", "interface"},
 535                 []string{"testhost", "testinterface"},
 536                 "SUBSYSTEMAUTO")
 537 }
 538
 539 func TestMetricCounterAutoCGetNoReg(t *testing.T) {
 540         m_grp := NewMetricGroupsCache()
 541         m_grp.CGet("cautotest1")
 542 }
 543
 544 func TestMetricCounterAutoCGetFunc(t *testing.T) {
 545         m_grp := NewMetricGroupsCache()
 546         m_reg := &registerer{}
 547         m_grp.Registerer(MetricGroupsCacheCounterRegistererFunc(m_reg.RegisterCounter), nil)
 548         m_grp.CGet("cautotest1")
 549 }
 550
 551 func TestMetricCounterAutoCGet(t *testing.T) {
 552         m_grp := NewMetricGroupsCacheWithRegisterers(&registerer{}, nil)
 553         m_grp.CGet("cautotest1")
 554 }
 555
 556 func TestMetricCounterAutoCInc(t *testing.T) {
 557         m_grp := NewMetricGroupsCache()
 558         m_grp.Registerer(&registerer{}, nil)
 559         m_grp.CInc("cautotest1")
 560 }
 561
 562 func TestMetricCounterAutoCAdd(t *testing.T) {
 563         m_grp := NewMetricGroupsCache()
 564         m_grp.Registerer(&registerer{}, nil)
 565         m_grp.CAdd("cautotest1", float64(10))
 566 }
 567
 568 func TestMetricCounterAutoGGetNoReg(t *testing.T) {
 569         m_grp := NewMetricGroupsCache()
 570         m_grp.GGet("gautotest1")
 571 }
 572
 573 func TestMetricCounterAutoGGetFunc(t *testing.T) {
 574         m_grp := NewMetricGroupsCache()
 575         m_reg := &registerer{}
 576         m_grp.Registerer(nil, MetricGroupsCacheGaugeRegistererFunc(m_reg.RegisterGauge))
 577         m_grp.GGet("gautotest1")
 578 }
 579
 580 func TestMetricCounterAutoGGet(t *testing.T) {
 581         m_grp := NewMetricGroupsCacheWithRegisterers(nil, &registerer{})
 582         m_grp.GGet("gautotest1")
 583 }
 584
 585 func TestMetricCounterAutoGInc(t *testing.T) {
 586         m_grp := NewMetricGroupsCache()
 587         m_grp.Registerer(nil, &registerer{})
 588         m_grp.GInc("gautotest1")
 589 }
 590
 591 func TestMetricCounterAutoGSet(t *testing.T) {
 592         m_grp := NewMetricGroupsCache()
 593         m_grp.Registerer(nil, &registerer{})
 594         m_grp.GSet("gautotest1", float64(10))
 595 }
 596
 597 func TestMetricCounterAutoGAdd(t *testing.T) {
 598         m_grp := NewMetricGroupsCache()
 599         m_grp.Registerer(nil, &registerer{})
 600         m_grp.GAdd("gautotest1", float64(10))
 601 }
 602
 603 func TestMetricCounterAutoGDec(t *testing.T) {
 604         m_grp := NewMetricGroupsCache()
 605         m_grp.Registerer(nil, &registerer{})
 606         m_grp.GDec("gautotest1")
 607 }
 608
 609 // ----
 610 // VECTORS ARE OLD WAY
 611 // *Labeled* will do all work under the hood
 612 // ----
 613
 614 var mCVect CounterVec
 615 var mGVect GaugeVec
 616
 617 var mCGroupVect map[string]CounterVec
 618 var mGGroupVect map[string]GaugeVec
 619
 620 func TestMetricSetup(t *testing.T) {
 621         mCVect = Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "event"}, "SUBSYSTEM0")
 622
 623         mCGroupVect = Metric.RegisterCounterVecGroup(
 624                 []CounterOpts{
 625                         {Name: "counter1", Help: "counter1"},
 626                 },
 627                 []string{"name", "event"},
 628                 "SUBSYSTEM1")
 629
 630         mGVect = Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "event"}, "SUBSYSTEM0")
 631
 632         mGGroupVect = Metric.RegisterGaugeVecGroup(
 633                 []CounterOpts{
 634                         {Name: "gauge1", Help: "gauge1"},
 635                 },
 636                 []string{"name", "event"},
 637                 "SUBSYSTEM1")
 638
 639         tmpCVect := Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "event"}, "SUBSYSTEM0")
 640
 641         if tmpCVect.Vec != mCVect.Vec {
 642                 t.Errorf("tmpCVect not same than mCVect. cache not working?")
 643         }
 644
 645         tmpGVect := Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "event"}, "SUBSYSTEM0")
 646
 647         if tmpGVect.Vec != mGVect.Vec {
 648                 t.Errorf("tmpGVect not same than mGVect. cache not working?")
 649         }
 650
 651 }
 652
 653 func TestMetricCounterVector(t *testing.T) {
 654         //
 655         //
 656         c_1_1 := Metric.GetCounterFromVect([]string{"name1", "event1"}, mCVect)
 657         c_1_1.Inc()
 658         c_1_2 := Metric.GetCounterFromVect([]string{"name1", "event1"}, mCVect)
 659         c_1_2.Inc()
 660         if c_1_1 != c_1_2 {
 661                 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
 662         }
 663         //
 664         //
 665         c_2_1 := Metric.GetCounterFromVect([]string{"name1", "event2"}, mCVect)
 666         c_2_1.Inc()
 667         c_2_2 := Metric.GetCounterFromVect([]string{"name1", "event2"}, mCVect)
 668         c_2_2.Inc()
 669         if c_2_1 != c_2_2 {
 670                 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
 671         }
 672         if c_1_1 == c_2_1 {
 673                 t.Errorf("c_1_1 same than c_2_1. what?")
 674         }
 675
 676 }
 677
 678 func TestMetricCounterGroupVector(t *testing.T) {
 679         //
 680         //
 681         c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCGroupVect)
 682         if _, ok := c_grp1["counter1"]; ok == false {
 683                 t.Errorf("c_grp1 counter1 not exists")
 684         }
 685         c_grp1["counter1"].Inc()
 686
 687         //
 688         //
 689         c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCGroupVect)
 690         if _, ok := c_grp2["counter1"]; ok == false {
 691                 t.Errorf("c_grp2 counter1 not exists")
 692         }
 693         c_grp2["counter1"].Inc()
 694 }
 695
 696 func TestMetricGaugeVector(t *testing.T) {
 697         //
 698         //
 699         c_1_1 := Metric.GetGaugeFromVect([]string{"name1", "event1"}, mGVect)
 700         c_1_1.Inc()
 701         c_1_2 := Metric.GetGaugeFromVect([]string{"name1", "event1"}, mGVect)
 702         c_1_2.Inc()
 703         if c_1_1 != c_1_2 {
 704                 t.Errorf("c_1_1 not same than c_1_2. cache not working?")
 705         }
 706         //
 707         //
 708         c_2_1 := Metric.GetGaugeFromVect([]string{"name1", "event2"}, mGVect)
 709         c_2_1.Inc()
 710         c_2_2 := Metric.GetGaugeFromVect([]string{"name1", "event2"}, mGVect)
 711         c_2_2.Inc()
 712         if c_2_1 != c_2_2 {
 713                 t.Errorf("c_2_1 not same than c_2_2. cache not working?")
 714         }
 715         if c_1_1 == c_2_1 {
 716                 t.Errorf("c_1_1 same than c_2_1. what?")
 717         }
 718 }
 719
 720 func TestMetricGaugeGroupVector(t *testing.T) {
 721         //
 722         //
 723         g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGGroupVect)
 724         if _, ok := g_grp1["gauge1"]; ok == false {
 725                 t.Errorf("g_grp1 gauge1 not exists")
 726         }
 727         g_grp1["gauge1"].Inc()
 728
 729         //
 730         //
 731         g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGGroupVect)
 732         if _, ok := g_grp2["gauge1"]; ok == false {
 733                 t.Errorf("g_grp2 gauge1 not exists")
 734         }
 735         g_grp2["gauge1"].Inc()
 736 }
 737
 738 func TestMetricCounterGroupVectorPrefix(t *testing.T) {
 739         //
 740         //
 741         c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCGroupVect)
 742         if _, ok := c_grp1["event1_counter1"]; ok == false {
 743                 t.Errorf("c_grp1 event1_counter1 not exists")
 744         }
 745         c_grp1["event1_counter1"].Inc()
 746
 747         //
 748         //
 749         c_grp2 := Metric.GetCounterGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mCGroupVect)
 750         if _, ok := c_grp2["event2_counter1"]; ok == false {
 751                 t.Errorf("c_grp2 event2_counter1 not exists")
 752         }
 753         c_grp2["event2_counter1"].Inc()
 754
 755         //
 756         //
 757         m_grp := NewMetricGroupsCache()
 758         m_grp.CombineCounterGroups(c_grp1, c_grp2)
 759
 760         //
 761         //
 762         if m_grp.CIs("event1_counter1") == false {
 763                 t.Errorf("m_grp event1_counter1 not exists")
 764         }
 765         m_grp.CInc("event1_counter1")
 766
 767         //
 768         //
 769         if m_grp.CIs("event2_counter1") == false {
 770                 t.Errorf("m_grp event2_counter1 not exists")
 771         }
 772
 773         m_grp.CAdd("event2_counter1", 1)
 774         m_grp.CGet("event2_counter1")
 775 }
 776
 777 func TestMetricGaugeGroupVectorPrefix(t *testing.T) {
 778         //
 779         //
 780         g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGGroupVect)
 781         if _, ok := g_grp1["event1_gauge1"]; ok == false {
 782                 t.Errorf("g_grp1 event1_gauge1 not exists")
 783         }
 784         g_grp1["event1_gauge1"].Inc()
 785
 786         //
 787         //
 788         g_grp2 := Metric.GetGaugeGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mGGroupVect)
 789         if _, ok := g_grp2["event2_gauge1"]; ok == false {
 790                 t.Errorf("g_grp2 event2_gauge1 not exists")
 791         }
 792         g_grp2["event2_gauge1"].Inc()
 793
 794         m_grp := NewMetricGroupsCache()
 795         m_grp.CombineGaugeGroups(g_grp1, g_grp2)
 796
 797         //
 798         //
 799         if m_grp.GIs("event1_gauge1") == false {
 800                 t.Errorf("m_grp event1_gauge1 not exists")
 801         }
 802         m_grp.GInc("event1_gauge1")
 803
 804         //
 805         //
 806         if m_grp.GIs("event2_gauge1") == false {
 807                 t.Errorf("m_grp event2_gauge1 not exists")
 808         }
 809         m_grp.GInc("event2_gauge1")
 810
 811         m_grp.GGet("event2_gauge1")
 812         m_grp.GDec("event2_gauge1")
 813         m_grp.GSet("event2_gauge1", 1)
 814 }
 815
 816 func TestMetricGroupCacheWithVect(t *testing.T) {
 817         //
 818         //
 819         c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCGroupVect)
 820         if _, ok := c_grp1["counter1"]; ok == false {
 821                 t.Errorf("c_grp1 counter1 not exists")
 822         }
 823         c_grp1["counter1"].Inc()
 824
 825         //
 826         //
 827         c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCGroupVect)
 828         if _, ok := c_grp2["counter1"]; ok == false {
 829                 t.Errorf("c_grp2 counter1 not exists")
 830         }
 831         c_grp2["counter1"].Inc()
 832
 833         //
 834         //
 835         g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGGroupVect)
 836         if _, ok := g_grp1["gauge1"]; ok == false {
 837                 t.Errorf("g_grp1 gauge1 not exists")
 838         }
 839         g_grp1["gauge1"].Inc()
 840
 841         //
 842         //
 843         g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGGroupVect)
 844         if _, ok := g_grp2["gauge1"]; ok == false {
 845                 t.Errorf("g_grp2 gauge1 not exists")
 846         }
 847         g_grp2["gauge1"].Inc()
 848
 849         //
 850         //
 851         m_grp := NewMetricGroupsCache()
 852         m_grp.CombineCounterGroupsWithPrefix("event1_", c_grp1)
 853         m_grp.CombineCounterGroupsWithPrefix("event2_", c_grp2)
 854         m_grp.CombineGaugeGroupsWithPrefix("event1_", g_grp1)
 855         m_grp.CombineGaugeGroupsWithPrefix("event2_", g_grp2)
 856
 857         if m_grp == nil {
 858                 t.Errorf("Cache failed")
 859         }
 860
 861         if m_grp.CIs("event1_counter1") == false {
 862                 t.Errorf("m_grp.Counters event1_counter1 not exists")
 863         }
 864         m_grp.CInc("event1_counter1")
 865
 866         if m_grp.CIs("event2_counter1") == false {
 867                 t.Errorf("m_grp.Counters event2_counter1 not exists")
 868         }
 869         m_grp.CInc("event2_counter1")
 870
 871         if m_grp.GIs("event1_gauge1") == false {
 872                 t.Errorf("m_grp.Gauges event1_gauge1 not exists")
 873         }
 874         m_grp.GInc("event1_gauge1")
 875
 876         if m_grp.GIs("event2_gauge1") == false {
 877                 t.Errorf("m_grp.Gauges event2_gauge1 not exists")
 878         }
 879         m_grp.GInc("event2_gauge1")
 880
 881         m_grp.CAdd("event2_counter1", 1)
 882         m_grp.CGet("event2_counter1")
 883         m_grp.GGet("event2_gauge1")
 884         m_grp.GDec("event2_gauge1")
 885         m_grp.GSet("event2_gauge1", 1)
 886 }