Improved metrics
[ric-plt/xapp-frame.git] / pkg / xapp / metrics_test.go
index bd7c737..4c98c95 100755 (executable)
@@ -23,52 +23,135 @@ import (
        "testing"
 )
 
-var mCVect map[string]CounterVec
-var mGVect map[string]GaugeVec
-var mGGroup map[string]Gauge
+var mCVect CounterVec
+var mGVect GaugeVec
+
+var mCGroupVect map[string]CounterVec
+var mGGroupVect map[string]GaugeVec
 
 func TestMetricSetup(t *testing.T) {
-       mCVect = Metric.RegisterCounterVecGroup(
+       mCVect = Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "event"}, "SUBSYSTEM0")
+
+       mCGroupVect = Metric.RegisterCounterVecGroup(
                []CounterOpts{
                        {Name: "counter1", Help: "counter1"},
                },
                []string{"name", "event"},
-               "SUBSYSTEM")
+               "SUBSYSTEM1")
 
-       mGVect = Metric.RegisterGaugeVecGroup(
+       mGVect = Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "event"}, "SUBSYSTEM0")
+
+       mGGroupVect = Metric.RegisterGaugeVecGroup(
                []CounterOpts{
-                       {Name: "counter2", Help: "counter2"},
+                       {Name: "gauge1", Help: "gauge1"},
                },
                []string{"name", "event"},
-               "SUBSYSTEM")
+               "SUBSYSTEM1")
+
+       tmpCVect := Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "event"}, "SUBSYSTEM0")
+
+       if tmpCVect.Vec != mCVect.Vec {
+               t.Errorf("tmpCVect not same than mCVect. cache not working?")
+       }
+
+       tmpGVect := Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "event"}, "SUBSYSTEM0")
+
+       if tmpGVect.Vec != mGVect.Vec {
+               t.Errorf("tmpGVect not same than mGVect. cache not working?")
+       }
+
+       Metric.RegisterCounterVec(CounterOpts{Name: "counter1", Help: "counter1"}, []string{"name", "eventMismatch"}, "SUBSYSTEM0")
+       Metric.RegisterGaugeVec(CounterOpts{Name: "gauge1", Help: "gauge1"}, []string{"name", "eventMismatch"}, "SUBSYSTEM0")
 
-       mGGroup = Metric.RegisterGaugeGroup(
-               []CounterOpts{
-                       {Name: "counter3", Help: "counter3"},
-               },
-               "SUBSYSTEM2")
 }
 
 func TestMetricCounter(t *testing.T) {
+       TestCounterOpt := CounterOpts{Name: "CounterBlaah1", Help: "CounterBlaah1"}
+       ret1 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
+       ret1.Inc()
+       ret2 := Metric.RegisterCounter(TestCounterOpt, "TestMetricCounter")
+       ret2.Inc()
+       if ret1 != ret2 {
+               t.Errorf("ret1 not same than ret2. cache not working?")
+       }
+}
+
+func TestMetricCounterGroup(t *testing.T) {
        var TestCounterOpts = []CounterOpts{
-               {Name: "Blaah1", Help: "Blaah1"},
-               {Name: "Blaah2", Help: "Blaah2"},
-               {Name: "Blaah3", Help: "Blaah3"},
-               {Name: "Blaah4", Help: "Blaah4"},
+               {Name: "CounterBlaah1", Help: "CounterBlaah1"},
+               {Name: "CounterBlaah2", Help: "CounterBlaah2"},
+               {Name: "CounterBlaah3", Help: "CounterBlaah3"},
+               {Name: "CounterBlaah4", Help: "CounterBlaah4"},
        }
 
-       ret1 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounter")
+       ret1 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
 
        if len(ret1) == 0 {
                t.Errorf("ret1 counter group is empty")
        }
 
-       ret2 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounter")
+       ret1["CounterBlaah1"].Inc()
+       ret1["CounterBlaah2"].Inc()
+       ret1["CounterBlaah3"].Inc()
+       ret1["CounterBlaah4"].Inc()
+
+       ret2 := Metric.RegisterCounterGroup(TestCounterOpts, "TestMetricCounterGroup")
 
        if len(ret2) == 0 {
                t.Errorf("ret2 counter group is empty")
        }
 
+       ret2["CounterBlaah1"].Inc()
+       ret2["CounterBlaah2"].Inc()
+       ret2["CounterBlaah3"].Inc()
+       ret2["CounterBlaah4"].Inc()
+
+       if len(ret1) != len(ret2) {
+               t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
+       }
+}
+
+func TestMetricGauge(t *testing.T) {
+       TestGaugeOpts := CounterOpts{Name: "GaugeBlaah1", Help: "GaugeBlaah1"}
+       ret1 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
+       ret1.Inc()
+       ret2 := Metric.RegisterGauge(TestGaugeOpts, "TestMetricGauge")
+       ret2.Inc()
+       if ret1 != ret2 {
+               t.Errorf("ret1 not same than ret2. cache not working?")
+       }
+}
+
+func TestMetricGaugeGroup(t *testing.T) {
+       var TestGaugeOpts = []CounterOpts{
+               {Name: "GaugeBlaah1", Help: "GaugeBlaah1"},
+               {Name: "GaugeBlaah2", Help: "GaugeBlaah2"},
+               {Name: "GaugeBlaah3", Help: "GaugeBlaah3"},
+               {Name: "GaugeBlaah4", Help: "GaugeBlaah4"},
+       }
+
+       ret1 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
+
+       if len(ret1) == 0 {
+               t.Errorf("ret1 gauge group is empty")
+       }
+
+       ret1["GaugeBlaah1"].Inc()
+       ret1["GaugeBlaah2"].Inc()
+       ret1["GaugeBlaah3"].Inc()
+       ret1["GaugeBlaah4"].Inc()
+
+       ret2 := Metric.RegisterGaugeGroup(TestGaugeOpts, "TestMetricGaugeGroup")
+
+       if len(ret2) == 0 {
+               t.Errorf("ret2 gauge group is empty")
+       }
+
+       ret2["GaugeBlaah1"].Inc()
+       ret2["GaugeBlaah2"].Inc()
+       ret2["GaugeBlaah3"].Inc()
+       ret2["GaugeBlaah4"].Inc()
+
        if len(ret1) != len(ret2) {
                t.Errorf("ret1 len %d differs from ret2 len %d", len(ret1), len(ret2))
        }
@@ -77,7 +160,32 @@ func TestMetricCounter(t *testing.T) {
 func TestMetricCounterVector(t *testing.T) {
        //
        //
-       c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCVect)
+       c_1_1 := Metric.GetCounterFromVect([]string{"name1", "event1"}, mCVect)
+       c_1_1.Inc()
+       c_1_2 := Metric.GetCounterFromVect([]string{"name1", "event1"}, mCVect)
+       c_1_2.Inc()
+       if c_1_1 != c_1_2 {
+               t.Errorf("c_1_1 not same than c_1_2. cache not working?")
+       }
+       //
+       //
+       c_2_1 := Metric.GetCounterFromVect([]string{"name1", "event2"}, mCVect)
+       c_2_1.Inc()
+       c_2_2 := Metric.GetCounterFromVect([]string{"name1", "event2"}, mCVect)
+       c_2_2.Inc()
+       if c_2_1 != c_2_2 {
+               t.Errorf("c_2_1 not same than c_2_2. cache not working?")
+       }
+       if c_1_1 == c_2_1 {
+               t.Errorf("c_1_1 same than c_2_1. what?")
+       }
+
+}
+
+func TestMetricCounterGroupVector(t *testing.T) {
+       //
+       //
+       c_grp1 := Metric.GetCounterGroupFromVects([]string{"name1", "event1"}, mCGroupVect)
        if _, ok := c_grp1["counter1"]; ok == false {
                t.Errorf("c_grp1 counter1 not exists")
        }
@@ -85,7 +193,7 @@ func TestMetricCounterVector(t *testing.T) {
 
        //
        //
-       c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCVect)
+       c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCGroupVect)
        if _, ok := c_grp2["counter1"]; ok == false {
                t.Errorf("c_grp2 counter1 not exists")
        }
@@ -95,25 +203,49 @@ func TestMetricCounterVector(t *testing.T) {
 func TestMetricGaugeVector(t *testing.T) {
        //
        //
-       g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGVect)
-       if _, ok := g_grp1["counter2"]; ok == false {
-               t.Errorf("g_grp1 counter2 not exists")
+       c_1_1 := Metric.GetGaugeFromVect([]string{"name1", "event1"}, mGVect)
+       c_1_1.Inc()
+       c_1_2 := Metric.GetGaugeFromVect([]string{"name1", "event1"}, mGVect)
+       c_1_2.Inc()
+       if c_1_1 != c_1_2 {
+               t.Errorf("c_1_1 not same than c_1_2. cache not working?")
        }
-       g_grp1["counter2"].Inc()
+       //
+       //
+       c_2_1 := Metric.GetGaugeFromVect([]string{"name1", "event2"}, mGVect)
+       c_2_1.Inc()
+       c_2_2 := Metric.GetGaugeFromVect([]string{"name1", "event2"}, mGVect)
+       c_2_2.Inc()
+       if c_2_1 != c_2_2 {
+               t.Errorf("c_2_1 not same than c_2_2. cache not working?")
+       }
+       if c_1_1 == c_2_1 {
+               t.Errorf("c_1_1 same than c_2_1. what?")
+       }
+}
 
+func TestMetricGaugeGroupVector(t *testing.T) {
        //
        //
-       g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGVect)
-       if _, ok := g_grp2["counter2"]; ok == false {
-               t.Errorf("g_grp2 counter2 not exists")
+       g_grp1 := Metric.GetGaugeGroupFromVects([]string{"name1", "event1"}, mGGroupVect)
+       if _, ok := g_grp1["gauge1"]; ok == false {
+               t.Errorf("g_grp1 gauge1 not exists")
        }
-       g_grp2["counter2"].Inc()
+       g_grp1["gauge1"].Inc()
+
+       //
+       //
+       g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGGroupVect)
+       if _, ok := g_grp2["gauge1"]; ok == false {
+               t.Errorf("g_grp2 gauge1 not exists")
+       }
+       g_grp2["gauge1"].Inc()
 }
 
-func TestMetricCounterVectorPrefix(t *testing.T) {
+func TestMetricCounterGroupVectorPrefix(t *testing.T) {
        //
        //
-       c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCVect)
+       c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCGroupVect)
        if _, ok := c_grp1["event1_counter1"]; ok == false {
                t.Errorf("c_grp1 event1_counter1 not exists")
        }
@@ -121,7 +253,7 @@ func TestMetricCounterVectorPrefix(t *testing.T) {
 
        //
        //
-       c_grp2 := Metric.GetCounterGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mCVect)
+       c_grp2 := Metric.GetCounterGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mCGroupVect)
        if _, ok := c_grp2["event2_counter1"]; ok == false {
                t.Errorf("c_grp2 event2_counter1 not exists")
        }
@@ -149,49 +281,49 @@ func TestMetricCounterVectorPrefix(t *testing.T) {
        m_grp.CGet("event2_counter1")
 }
 
-func TestMetricGaugeVectorPrefix(t *testing.T) {
+func TestMetricGaugeGroupVectorPrefix(t *testing.T) {
        //
        //
-       g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGVect)
-       if _, ok := g_grp1["event1_counter2"]; ok == false {
-               t.Errorf("g_grp1 event1_counter2 not exists")
+       g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGGroupVect)
+       if _, ok := g_grp1["event1_gauge1"]; ok == false {
+               t.Errorf("g_grp1 event1_gauge1 not exists")
        }
-       g_grp1["event1_counter2"].Inc()
+       g_grp1["event1_gauge1"].Inc()
 
        //
        //
-       g_grp2 := Metric.GetGaugeGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mGVect)
-       if _, ok := g_grp2["event2_counter2"]; ok == false {
-               t.Errorf("g_grp2 event2_counter2 not exists")
+       g_grp2 := Metric.GetGaugeGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mGGroupVect)
+       if _, ok := g_grp2["event2_gauge1"]; ok == false {
+               t.Errorf("g_grp2 event2_gauge1 not exists")
        }
-       g_grp2["event2_counter2"].Inc()
+       g_grp2["event2_gauge1"].Inc()
 
        m_grp := NewMetricGroupsCache()
        m_grp.CombineGaugeGroups(g_grp1, g_grp2)
 
        //
        //
-       if m_grp.GIs("event1_counter2") == false {
-               t.Errorf("m_grp event1_counter2 not exists")
+       if m_grp.GIs("event1_gauge1") == false {
+               t.Errorf("m_grp event1_gauge1 not exists")
        }
-       m_grp.GInc("event1_counter2")
+       m_grp.GInc("event1_gauge1")
 
        //
        //
-       if m_grp.GIs("event2_counter2") == false {
-               t.Errorf("m_grp event2_counter2 not exists")
+       if m_grp.GIs("event2_gauge1") == false {
+               t.Errorf("m_grp event2_gauge1 not exists")
        }
-       m_grp.GInc("event2_counter2")
+       m_grp.GInc("event2_gauge1")
 
-       m_grp.GGet("event2_counter2")
-       m_grp.GDec("event2_counter2")
-       m_grp.GSet("event2_counter2", 1)
+       m_grp.GGet("event2_gauge1")
+       m_grp.GDec("event2_gauge1")
+       m_grp.GSet("event2_gauge1", 1)
 }
 
 func TestMetricGroupCache(t *testing.T) {
        //
        //
-       c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCVect)
+       c_grp1 := Metric.GetCounterGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mCGroupVect)
        if _, ok := c_grp1["event1_counter1"]; ok == false {
                t.Errorf("c_grp1 event1_counter1 not exists")
        }
@@ -199,35 +331,35 @@ func TestMetricGroupCache(t *testing.T) {
 
        //
        //
-       c_grp2 := Metric.GetCounterGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mCVect)
-       if _, ok := c_grp2["event2_counter1"]; ok == false {
-               t.Errorf("c_grp2 event2_counter1 not exists")
+       c_grp2 := Metric.GetCounterGroupFromVects([]string{"name1", "event2"}, mCGroupVect)
+       if _, ok := c_grp2["counter1"]; ok == false {
+               t.Errorf("c_grp2 counter1 not exists")
        }
-       c_grp2["event2_counter1"].Inc()
+       c_grp2["counter1"].Inc()
 
        //
        //
-       g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGVect)
-       if _, ok := g_grp1["event1_counter2"]; ok == false {
-               t.Errorf("g_grp1 event1_counter2 not exists")
+       g_grp1 := Metric.GetGaugeGroupFromVectsWithPrefix("event1_", []string{"name1", "event1"}, mGGroupVect)
+       if _, ok := g_grp1["event1_gauge1"]; ok == false {
+               t.Errorf("g_grp1 event1_gauge1 not exists")
        }
-       g_grp1["event1_counter2"].Inc()
+       g_grp1["event1_gauge1"].Inc()
 
        //
        //
-       g_grp2 := Metric.GetGaugeGroupFromVectsWithPrefix("event2_", []string{"name1", "event2"}, mGVect)
-       if _, ok := g_grp2["event2_counter2"]; ok == false {
-               t.Errorf("g_grp2 event2_counter2 not exists")
+       g_grp2 := Metric.GetGaugeGroupFromVects([]string{"name1", "event2"}, mGGroupVect)
+       if _, ok := g_grp2["gauge1"]; ok == false {
+               t.Errorf("g_grp2 gauge1 not exists")
        }
-       g_grp2["event2_counter2"].Inc()
+       g_grp2["gauge1"].Inc()
 
        //
        //
        m_grp := NewMetricGroupsCache()
        m_grp.CombineCounterGroups(c_grp1)
-       m_grp.CombineCounterGroups(c_grp2)
+       m_grp.CombineCounterGroupsWithPrefix("event2_", c_grp2)
        m_grp.CombineGaugeGroups(g_grp1)
-       m_grp.CombineGaugeGroups(g_grp2)
+       m_grp.CombineGaugeGroupsWithPrefix("event2_", g_grp2)
 
        if m_grp == nil {
                t.Errorf("Cache failed")
@@ -243,19 +375,19 @@ func TestMetricGroupCache(t *testing.T) {
        }
        m_grp.CInc("event2_counter1")
 
-       if m_grp.GIs("event1_counter2") == false {
-               t.Errorf("m_grp.Gauges event1_counter2 not exists")
+       if m_grp.GIs("event1_gauge1") == false {
+               t.Errorf("m_grp.Gauges event1_gauge1 not exists")
        }
-       m_grp.GInc("event1_counter2")
+       m_grp.GInc("event1_gauge1")
 
-       if m_grp.GIs("event2_counter2") == false {
-               t.Errorf("m_grp.Gauges event2_counter2 not exists")
+       if m_grp.GIs("event2_gauge1") == false {
+               t.Errorf("m_grp.Gauges event2_gauge1 not exists")
        }
-       m_grp.GInc("event2_counter2")
+       m_grp.GInc("event2_gauge1")
 
        m_grp.CAdd("event2_counter1", 1)
        m_grp.CGet("event2_counter1")
-       m_grp.GGet("event2_counter2")
-       m_grp.GDec("event2_counter2")
-       m_grp.GSet("event2_counter2", 1)
+       m_grp.GGet("event2_gauge1")
+       m_grp.GDec("event2_gauge1")
+       m_grp.GSet("event2_gauge1", 1)
 }