mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
981 lines
28 KiB
Go
981 lines
28 KiB
Go
/*
|
|
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
|
|
Copyright (C) ITsysCOM GmbH
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
package engine
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/cgrates/cgrates/utils"
|
|
)
|
|
|
|
var sq *StatQueue
|
|
|
|
func TestStatQueuesSort(t *testing.T) {
|
|
sInsts := StatQueues{
|
|
&StatQueue{sqPrfl: &StatQueueProfile{ID: "FIRST", Weight: 30.0}},
|
|
&StatQueue{sqPrfl: &StatQueueProfile{ID: "SECOND", Weight: 40.0}},
|
|
&StatQueue{sqPrfl: &StatQueueProfile{ID: "THIRD", Weight: 30.0}},
|
|
&StatQueue{sqPrfl: &StatQueueProfile{ID: "FOURTH", Weight: 35.0}},
|
|
}
|
|
sInsts.Sort()
|
|
eSInst := StatQueues{
|
|
&StatQueue{sqPrfl: &StatQueueProfile{ID: "SECOND", Weight: 40.0}},
|
|
&StatQueue{sqPrfl: &StatQueueProfile{ID: "FOURTH", Weight: 35.0}},
|
|
&StatQueue{sqPrfl: &StatQueueProfile{ID: "FIRST", Weight: 30.0}},
|
|
&StatQueue{sqPrfl: &StatQueueProfile{ID: "THIRD", Weight: 30.0}},
|
|
}
|
|
if !reflect.DeepEqual(eSInst, sInsts) {
|
|
t.Errorf("expecting: %+v, received: %+v", eSInst, sInsts)
|
|
}
|
|
}
|
|
|
|
func TestStatRemEventWithID(t *testing.T) {
|
|
sq = &StatQueue{
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: &StatASR{
|
|
Answered: 1,
|
|
Count: 2,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestRemEventWithID_1": {Stat: 1, CompressFactor: 1},
|
|
"cgrates.org:TestRemEventWithID_2": {Stat: 0, CompressFactor: 1},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
asrMetric := sq.SQMetrics[utils.MetaASR].(*StatASR)
|
|
if asr := asrMetric.GetFloat64Value(); asr != 50 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
}
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_1")
|
|
if asr := asrMetric.GetFloat64Value(); asr != 0 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 1 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_5") // non existent
|
|
if asr := asrMetric.GetFloat64Value(); asr != 0 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 1 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_2")
|
|
if asr := asrMetric.GetFloat64Value(); asr != -1 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 0 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_2")
|
|
if asr := asrMetric.GetFloat64Value(); asr != -1 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 0 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
}
|
|
|
|
func TestStatRemEventWithID2(t *testing.T) {
|
|
sq = &StatQueue{
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestRemEventWithID_1": {Stat: 1, CompressFactor: 2},
|
|
"cgrates.org:TestRemEventWithID_2": {Stat: 0, CompressFactor: 2},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
asrMetric := sq.SQMetrics[utils.MetaASR].(*StatASR)
|
|
if asr := asrMetric.GetFloat64Value(); asr != 50 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
}
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_1")
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_2")
|
|
if asr := asrMetric.GetFloat64Value(); asr != 50 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 2 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_5") // non existent
|
|
if asr := asrMetric.GetFloat64Value(); asr != 50 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 2 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_2")
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_1")
|
|
if asr := asrMetric.GetFloat64Value(); asr != -1 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 0 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
sq.remEventWithID("cgrates.org:TestRemEventWithID_2")
|
|
if asr := asrMetric.GetFloat64Value(); asr != -1 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 0 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
}
|
|
|
|
func TestStatRemExpired(t *testing.T) {
|
|
sq = &StatQueue{
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: &StatASR{
|
|
Answered: 2,
|
|
Count: 3,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_1": {Stat: 1, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_2": {Stat: 0, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_3": {Stat: 1, CompressFactor: 1},
|
|
},
|
|
},
|
|
},
|
|
SQItems: []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_1", utils.TimePointer(time.Now())},
|
|
{"cgrates.org:TestStatRemExpired_2", utils.TimePointer(time.Now())},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(time.Now().Add(time.Duration(time.Minute)))},
|
|
},
|
|
}
|
|
asrMetric := sq.SQMetrics[utils.MetaASR].(*StatASR)
|
|
if asr := asrMetric.GetFloat64Value(); asr != 66.66667 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
}
|
|
sq.remExpired()
|
|
if asr := asrMetric.GetFloat64Value(); asr != 100 {
|
|
t.Errorf("received asrMetric: %v", asrMetric)
|
|
} else if len(asrMetric.Events) != 1 {
|
|
t.Errorf("unexpected Events in asrMetric: %+v", asrMetric.Events)
|
|
}
|
|
if len(sq.SQItems) != 1 {
|
|
t.Errorf("Unexpected items: %+v", sq.SQItems)
|
|
}
|
|
}
|
|
|
|
func TestStatRemOnQueueLength(t *testing.T) {
|
|
sq = &StatQueue{
|
|
sqPrfl: &StatQueueProfile{
|
|
QueueLength: 2,
|
|
},
|
|
SQItems: []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_1", nil},
|
|
},
|
|
}
|
|
sq.remOnQueueLength()
|
|
if len(sq.SQItems) != 1 {
|
|
t.Errorf("wrong items: %+v", sq.SQItems)
|
|
}
|
|
sq.SQItems = []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_1", nil},
|
|
{"cgrates.org:TestStatRemExpired_2", nil},
|
|
}
|
|
sq.remOnQueueLength()
|
|
if len(sq.SQItems) != 1 {
|
|
t.Errorf("wrong items: %+v", sq.SQItems)
|
|
} else if sq.SQItems[0].EventID != "cgrates.org:TestStatRemExpired_2" {
|
|
t.Errorf("wrong item in SQItems: %+v", sq.SQItems[0])
|
|
}
|
|
sq.sqPrfl.QueueLength = -1
|
|
sq.SQItems = []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_1", nil},
|
|
{"cgrates.org:TestStatRemExpired_2", nil},
|
|
{"cgrates.org:TestStatRemExpired_3", nil},
|
|
}
|
|
sq.remOnQueueLength()
|
|
if len(sq.SQItems) != 3 {
|
|
t.Errorf("wrong items: %+v", sq.SQItems)
|
|
}
|
|
}
|
|
|
|
func TestStatAddStatEvent(t *testing.T) {
|
|
sq = &StatQueue{
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: &StatASR{
|
|
Answered: 1,
|
|
Count: 1,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_1": {Stat: 1, CompressFactor: 1},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
asrMetric := sq.SQMetrics[utils.MetaASR].(*StatASR)
|
|
if asr := asrMetric.GetFloat64Value(); asr != 100 {
|
|
t.Errorf("received ASR: %v", asr)
|
|
}
|
|
ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_1"}
|
|
sq.addStatEvent(ev1, nil)
|
|
if asr := asrMetric.GetFloat64Value(); asr != 50 {
|
|
t.Errorf("received ASR: %v", asr)
|
|
} else if asrMetric.Answered != 1 || asrMetric.Count != 2 {
|
|
t.Errorf("ASR: %v", asrMetric)
|
|
}
|
|
ev1.Event = map[string]any{
|
|
utils.AnswerTime: time.Now()}
|
|
sq.addStatEvent(ev1, nil)
|
|
if asr := asrMetric.GetFloat64Value(); asr != 66.66667 {
|
|
t.Errorf("received ASR: %v", asr)
|
|
} else if asrMetric.Answered != 2 || asrMetric.Count != 3 {
|
|
t.Errorf("ASR: %v", asrMetric)
|
|
}
|
|
}
|
|
|
|
func TestStatRemOnQueueLength2(t *testing.T) {
|
|
sq = &StatQueue{
|
|
sqPrfl: &StatQueueProfile{
|
|
QueueLength: 2,
|
|
FilterIDs: []string{"*string:~Account:1001;1002"},
|
|
},
|
|
SQItems: []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_1", nil},
|
|
{"cgrates.org:TestStatRemExpired_2", nil},
|
|
},
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaTCD: &StatTCD{
|
|
FilterIDs: []string{"*string:~*req.Account:1002"},
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_2": {Duration: 1 * time.Minute, CompressFactor: 1},
|
|
},
|
|
},
|
|
utils.MetaASR: &StatASR{
|
|
FilterIDs: []string{"*string:~*req.Account:1001"},
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_1": {Stat: 1, CompressFactor: 1},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
sq.remOnQueueLength()
|
|
if len(sq.SQItems) != 1 {
|
|
t.Errorf("wrong items: %+v", utils.ToJSON(sq.SQItems))
|
|
}
|
|
}
|
|
|
|
func TestStatCompress(t *testing.T) {
|
|
asr := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_1": {Stat: 1, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_2": {Stat: 0, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_3": {Stat: 1, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0, CompressFactor: 1},
|
|
},
|
|
}
|
|
expectedASR := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
sqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_1", utils.TimePointer(time.Now())},
|
|
{"cgrates.org:TestStatRemExpired_2", utils.TimePointer(time.Now().Add(time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(time.Now().Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
expectedSqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sq = &StatQueue{
|
|
SQItems: sqItems,
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: asr,
|
|
},
|
|
}
|
|
if sq.Compress(int64(100)) {
|
|
t.Errorf("StatQueue compressed: %s", utils.ToJSON(sq))
|
|
}
|
|
if !sq.Compress(int64(2)) {
|
|
t.Errorf("StatQueue not compressed: %s", utils.ToJSON(sq))
|
|
}
|
|
if !reflect.DeepEqual(sq.SQItems, expectedSqItems) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedSqItems), utils.ToJSON(sq.SQItems))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaASR].(*StatASR); !reflect.DeepEqual(*rply, *expectedASR) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedASR), utils.ToJSON(rply))
|
|
}
|
|
}
|
|
|
|
func TestStatCompress2(t *testing.T) {
|
|
asr := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_1": {Stat: 1, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_2": {Stat: 0, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_3": {Stat: 1, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0, CompressFactor: 1},
|
|
},
|
|
}
|
|
expectedASR := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
tcd := &StatTCD{
|
|
Sum: 3 * time.Minute,
|
|
Count: 2,
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_2": {Duration: 1 * time.Minute, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_3": {Duration: 2 * time.Minute, CompressFactor: 1},
|
|
},
|
|
}
|
|
expectedTCD := &StatTCD{
|
|
Sum: 3 * time.Minute,
|
|
Count: 2,
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Duration: 1*time.Minute + 30*time.Second, CompressFactor: 2},
|
|
},
|
|
}
|
|
sqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_1", utils.TimePointer(time.Now())},
|
|
{"cgrates.org:TestStatRemExpired_2", utils.TimePointer(time.Now().Add(time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(time.Now().Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
expectedSqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sq = &StatQueue{
|
|
SQItems: sqItems,
|
|
ttl: utils.DurationPointer(time.Second),
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: asr,
|
|
utils.MetaTCD: tcd,
|
|
},
|
|
}
|
|
if sq.Compress(int64(100)) {
|
|
t.Errorf("StatQueue compressed: %s", utils.ToJSON(sq))
|
|
}
|
|
if !sq.Compress(int64(2)) {
|
|
t.Errorf("StatQueue not compressed: %s", utils.ToJSON(sq))
|
|
}
|
|
if !reflect.DeepEqual(sq.SQItems, expectedSqItems) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedSqItems), utils.ToJSON(sq.SQItems))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaASR].(*StatASR); !reflect.DeepEqual(*rply, *expectedASR) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedASR), utils.ToJSON(rply))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaTCD].(*StatTCD); !reflect.DeepEqual(*rply, *expectedTCD) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedTCD), utils.ToJSON(rply))
|
|
}
|
|
}
|
|
|
|
func TestStatCompress3(t *testing.T) {
|
|
tmNow := time.Now()
|
|
asr := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_1": {Stat: 1, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_2": {Stat: 0, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_3": {Stat: 1, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0, CompressFactor: 1},
|
|
},
|
|
}
|
|
expectedASR := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
tcd := &StatTCD{
|
|
Sum: 3 * time.Minute,
|
|
Count: 2,
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_2": {Duration: 1 * time.Minute, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_3": {Duration: 2 * time.Minute, CompressFactor: 1},
|
|
},
|
|
}
|
|
expectedTCD := &StatTCD{
|
|
Sum: 3 * time.Minute,
|
|
Count: 2,
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_2": {Duration: 1 * time.Minute, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_3": {Duration: 2 * time.Minute, CompressFactor: 1},
|
|
},
|
|
}
|
|
sqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_1", utils.TimePointer(tmNow)},
|
|
{"cgrates.org:TestStatRemExpired_2", utils.TimePointer(tmNow.Add(time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(tmNow.Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
expectedSqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_2", utils.TimePointer(tmNow.Add(time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(tmNow.Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sq = &StatQueue{
|
|
SQItems: sqItems,
|
|
ttl: utils.DurationPointer(time.Second),
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: asr,
|
|
utils.MetaTCD: tcd,
|
|
},
|
|
}
|
|
if sq.Compress(int64(100)) {
|
|
t.Errorf("StatQueue compressed: %s", utils.ToJSON(sq))
|
|
}
|
|
if !sq.Compress(int64(3)) {
|
|
t.Errorf("StatQueue not compressed: %s", utils.ToJSON(sq))
|
|
}
|
|
if !reflect.DeepEqual(sq.SQItems, expectedSqItems) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedSqItems), utils.ToJSON(sq.SQItems))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaASR].(*StatASR); !reflect.DeepEqual(*rply, *expectedASR) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedASR), utils.ToJSON(rply))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaTCD].(*StatTCD); !reflect.DeepEqual(*rply, *expectedTCD) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedTCD), utils.ToJSON(rply))
|
|
}
|
|
}
|
|
|
|
func TestStatExpand(t *testing.T) {
|
|
expectedASR := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
asr := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
expectedSqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sq = &StatQueue{
|
|
SQItems: sqItems,
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: asr,
|
|
},
|
|
}
|
|
sq.Expand()
|
|
if !reflect.DeepEqual(sq.SQItems, expectedSqItems) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedSqItems), utils.ToJSON(sq.SQItems))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaASR].(*StatASR); !reflect.DeepEqual(*rply, *expectedASR) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedASR), utils.ToJSON(rply))
|
|
}
|
|
}
|
|
|
|
func TestStatExpand2(t *testing.T) {
|
|
tmNow := time.Now()
|
|
expectedASR := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
asr := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
expectedTCD := &StatTCD{
|
|
Sum: 3 * time.Minute,
|
|
Count: 2,
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Duration: 1*time.Minute + 30*time.Second, CompressFactor: 2},
|
|
},
|
|
}
|
|
tcd := &StatTCD{
|
|
Sum: 3 * time.Minute,
|
|
Count: 2,
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_4": {Duration: 1*time.Minute + 30*time.Second, CompressFactor: 2},
|
|
},
|
|
}
|
|
expectedSqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(tmNow.Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sq = &StatQueue{
|
|
SQItems: sqItems,
|
|
ttl: utils.DurationPointer(time.Second),
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: asr,
|
|
utils.MetaTCD: tcd,
|
|
},
|
|
}
|
|
sq.Expand()
|
|
if !reflect.DeepEqual(sq.SQItems, expectedSqItems) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedSqItems), utils.ToJSON(sq.SQItems))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaASR].(*StatASR); !reflect.DeepEqual(*rply, *expectedASR) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedASR), utils.ToJSON(rply))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaTCD].(*StatTCD); !reflect.DeepEqual(*rply, *expectedTCD) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedTCD), utils.ToJSON(rply))
|
|
}
|
|
}
|
|
func TestStatExpand3(t *testing.T) {
|
|
tmNow := time.Now()
|
|
expectedASR := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_3": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
asr := &StatASR{
|
|
Answered: 2,
|
|
Count: 4,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_3": {Stat: 0.5, CompressFactor: 4},
|
|
},
|
|
}
|
|
expectedTCD := &StatTCD{
|
|
Sum: 3 * time.Minute,
|
|
Count: 2,
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_2": {Duration: 1 * time.Minute, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_4": {Duration: 2 * time.Minute, CompressFactor: 1},
|
|
},
|
|
}
|
|
tcd := &StatTCD{
|
|
Sum: 3 * time.Minute,
|
|
Count: 2,
|
|
Events: map[string]*DurationWithCompress{
|
|
"cgrates.org:TestStatRemExpired_2": {Duration: 1 * time.Minute, CompressFactor: 1},
|
|
"cgrates.org:TestStatRemExpired_4": {Duration: 2 * time.Minute, CompressFactor: 1},
|
|
},
|
|
}
|
|
expectedSqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_2", utils.TimePointer(tmNow.Add(time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(tmNow.Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(tmNow.Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(tmNow.Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(tmNow.Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sqItems := []SQItem{
|
|
{"cgrates.org:TestStatRemExpired_2", utils.TimePointer(tmNow.Add(time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_3", utils.TimePointer(tmNow.Add(2 * time.Minute))},
|
|
{"cgrates.org:TestStatRemExpired_4", nil},
|
|
}
|
|
sq = &StatQueue{
|
|
SQItems: sqItems,
|
|
ttl: utils.DurationPointer(time.Second),
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: asr,
|
|
utils.MetaTCD: tcd,
|
|
},
|
|
}
|
|
sq.Expand()
|
|
if !reflect.DeepEqual(sq.SQItems, expectedSqItems) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedSqItems), utils.ToJSON(sq.SQItems))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaASR].(*StatASR); !reflect.DeepEqual(*rply, *expectedASR) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedASR), utils.ToJSON(rply))
|
|
}
|
|
if rply := sq.SQMetrics[utils.MetaTCD].(*StatTCD); !reflect.DeepEqual(*rply, *expectedTCD) {
|
|
t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedTCD), utils.ToJSON(rply))
|
|
}
|
|
}
|
|
|
|
func TestStatRemoveExpiredTTL(t *testing.T) {
|
|
sq = &StatQueue{
|
|
ttl: utils.DurationPointer(time.Duration(100 * time.Millisecond)),
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: &StatASR{
|
|
Answered: 1,
|
|
Count: 1,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_1": {Stat: 1, CompressFactor: 1},
|
|
},
|
|
},
|
|
},
|
|
sqPrfl: &StatQueueProfile{
|
|
QueueLength: 0, //unlimited que
|
|
},
|
|
}
|
|
|
|
//add ev1 with ttl 100ms (after 100ms the event should be removed)
|
|
ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_1"}
|
|
sq.ProcessEvent(ev1, nil)
|
|
|
|
if len(sq.SQItems) != 1 && sq.SQItems[0].EventID != "TestStatAddStatEvent_1" {
|
|
t.Errorf("Expecting: 1, received: %+v", len(sq.SQItems))
|
|
}
|
|
//after 150ms the event expired
|
|
time.Sleep(150 * time.Millisecond)
|
|
|
|
//processing a new event should clean the expired events and add the new one
|
|
ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_2"}
|
|
sq.ProcessEvent(ev2, nil)
|
|
if len(sq.SQItems) != 1 && sq.SQItems[0].EventID != "TestStatAddStatEvent_2" {
|
|
t.Errorf("Expecting: 1, received: %+v", len(sq.SQItems))
|
|
}
|
|
}
|
|
|
|
func TestStatRemoveExpiredQueue(t *testing.T) {
|
|
sq = &StatQueue{
|
|
SQMetrics: map[string]StatMetric{
|
|
utils.MetaASR: &StatASR{
|
|
Answered: 1,
|
|
Count: 1,
|
|
Events: map[string]*StatWithCompress{
|
|
"cgrates.org:TestStatRemExpired_1": {Stat: 1, CompressFactor: 1},
|
|
},
|
|
},
|
|
},
|
|
sqPrfl: &StatQueueProfile{
|
|
QueueLength: 2, //unlimited que
|
|
},
|
|
}
|
|
|
|
//add ev1 with ttl 100ms (after 100ms the event should be removed)
|
|
ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_1"}
|
|
sq.ProcessEvent(ev1, nil)
|
|
|
|
if len(sq.SQItems) != 1 && sq.SQItems[0].EventID != "TestStatAddStatEvent_1" {
|
|
t.Errorf("Expecting: 1, received: %+v", len(sq.SQItems))
|
|
}
|
|
//after 150ms the event expired
|
|
time.Sleep(150 * time.Millisecond)
|
|
|
|
//processing a new event should clean the expired events and add the new one
|
|
ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_2"}
|
|
sq.ProcessEvent(ev2, nil)
|
|
if len(sq.SQItems) != 2 && sq.SQItems[0].EventID != "TestStatAddStatEvent_1" &&
|
|
sq.SQItems[1].EventID != "TestStatAddStatEvent_2" {
|
|
t.Errorf("Expecting: 2, received: %+v", len(sq.SQItems))
|
|
}
|
|
|
|
//processing a new event should clean the expired events and add the new one
|
|
ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_3"}
|
|
sq.ProcessEvent(ev3, nil)
|
|
if len(sq.SQItems) != 2 && sq.SQItems[0].EventID != "TestStatAddStatEvent_2" &&
|
|
sq.SQItems[1].EventID != "TestStatAddStatEvent_3" {
|
|
t.Errorf("Expecting: 2, received: %+v", len(sq.SQItems))
|
|
}
|
|
}
|
|
|
|
var str string = "test"
|
|
var slc []string = []string{str}
|
|
var nm int = 1
|
|
var n int64 = 1
|
|
var fl float64 = 1.2
|
|
var tm time.Time = time.Date(2021, 8, 15, 14, 30, 45, 100, time.Local)
|
|
|
|
type jsonErr struct{}
|
|
|
|
func (je *jsonErr) Marshal(v any) ([]byte, error) {
|
|
return nil, fmt.Errorf("error test")
|
|
}
|
|
|
|
func (je *jsonErr) Unmarshal(data []byte, v any) error {
|
|
return fmt.Errorf("error test")
|
|
}
|
|
|
|
func TestLibStatsNewStoredStatQueue(t *testing.T) {
|
|
si := []SQItem{{
|
|
EventID: str,
|
|
ExpiryTime: &tm,
|
|
}}
|
|
msw := map[string]*StatWithCompress{"test": {
|
|
Stat: fl,
|
|
CompressFactor: nm,
|
|
}}
|
|
st := StatASR{
|
|
FilterIDs: slc,
|
|
Answered: fl,
|
|
Count: n,
|
|
Events: msw,
|
|
MinItems: nm,
|
|
val: &fl,
|
|
}
|
|
msm := map[string]StatMetric{"test": &st}
|
|
|
|
sq := StatQueue{
|
|
Tenant: str,
|
|
ID: str,
|
|
SQItems: si,
|
|
SQMetrics: msm,
|
|
MinItems: nm,
|
|
}
|
|
|
|
ms := JSONMarshaler{}
|
|
|
|
rcv, err := NewStoredStatQueue(&sq, &ms)
|
|
|
|
mrsh, errM := st.Marshal(&ms)
|
|
if errM != nil {
|
|
t.Error(errM)
|
|
}
|
|
exp := &StoredStatQueue{
|
|
Tenant: str,
|
|
ID: str,
|
|
SQItems: si,
|
|
SQMetrics: map[string][]byte{"test": mrsh},
|
|
MinItems: nm,
|
|
Compressed: false,
|
|
}
|
|
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected %s, received %s", utils.ToJSON(exp), utils.ToJSON(rcv))
|
|
}
|
|
|
|
me := jsonErr{}
|
|
|
|
rcv, err = NewStoredStatQueue(&sq, &me)
|
|
|
|
if err != nil {
|
|
if err.Error() != "error test" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestLibStatsSqID(t *testing.T) {
|
|
si := []SQItem{{
|
|
EventID: str,
|
|
ExpiryTime: &tm,
|
|
}}
|
|
msw := map[string]*StatWithCompress{"test": {
|
|
Stat: fl,
|
|
CompressFactor: nm,
|
|
}}
|
|
st := StatASR{
|
|
FilterIDs: slc,
|
|
Answered: fl,
|
|
Count: n,
|
|
Events: msw,
|
|
MinItems: nm,
|
|
val: &fl,
|
|
}
|
|
msm := map[string]StatMetric{"test": &st}
|
|
|
|
sq := StatQueue{
|
|
Tenant: str,
|
|
ID: str,
|
|
SQItems: si,
|
|
SQMetrics: msm,
|
|
MinItems: nm,
|
|
}
|
|
|
|
ms := JSONMarshaler{}
|
|
|
|
sqq, err := NewStoredStatQueue(&sq, &ms)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
rcv := sqq.SqID()
|
|
|
|
if rcv != "test:test" {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestLibStatsAsStatQueueNilReturn(t *testing.T) {
|
|
var sqq *StoredStatQueue
|
|
|
|
ms := JSONMarshaler{}
|
|
rcv, err := sqq.AsStatQueue(&ms)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestLibStatsAsStatQueue(t *testing.T) {
|
|
si := []SQItem{{
|
|
EventID: str,
|
|
ExpiryTime: &tm,
|
|
}}
|
|
msw := map[string]*StatWithCompress{"test": {
|
|
Stat: fl,
|
|
CompressFactor: nm,
|
|
}}
|
|
st := StatASR{
|
|
FilterIDs: slc,
|
|
Answered: fl,
|
|
Count: n,
|
|
Events: msw,
|
|
MinItems: nm,
|
|
}
|
|
msm := map[string]StatMetric{"*asr": &st}
|
|
|
|
sq := StatQueue{
|
|
Tenant: str,
|
|
ID: str,
|
|
SQItems: si,
|
|
SQMetrics: msm,
|
|
MinItems: nm,
|
|
}
|
|
|
|
ms := JSONMarshaler{}
|
|
|
|
sqq, errSqq := NewStoredStatQueue(&sq, &ms)
|
|
if errSqq != nil {
|
|
t.Error(errSqq)
|
|
}
|
|
|
|
sqq.Compressed = true
|
|
rcv, err := sqq.AsStatQueue(&ms)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
exp := &sq
|
|
|
|
if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected %v, received %v", exp, rcv)
|
|
}
|
|
|
|
msm2 := map[string]StatMetric{"*test": &st}
|
|
|
|
sq2 := StatQueue{
|
|
Tenant: str,
|
|
ID: str,
|
|
SQItems: si,
|
|
SQMetrics: msm2,
|
|
MinItems: nm,
|
|
}
|
|
|
|
ms2 := JSONMarshaler{}
|
|
|
|
sqq2, errSqq2 := NewStoredStatQueue(&sq2, &ms2)
|
|
if errSqq2 != nil {
|
|
t.Error(errSqq2)
|
|
}
|
|
|
|
rcv, err = sqq2.AsStatQueue(&ms2)
|
|
if err != nil {
|
|
if err.Error() != "unsupported metric type <*test>" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
|
|
msm3 := map[string]StatMetric{"*asr": &st}
|
|
|
|
sq3 := StatQueue{
|
|
Tenant: str,
|
|
ID: str,
|
|
SQItems: si,
|
|
SQMetrics: msm3,
|
|
MinItems: nm,
|
|
}
|
|
|
|
ms3 := JSONMarshaler{}
|
|
|
|
sqq3, errSqq3 := NewStoredStatQueue(&sq3, &ms3)
|
|
if errSqq3 != nil {
|
|
t.Error(errSqq3)
|
|
}
|
|
|
|
me := jsonErr{}
|
|
rcv, err = sqq3.AsStatQueue(&me)
|
|
if err != nil {
|
|
if err.Error() != "error test" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestLibStatsLock(t *testing.T) {
|
|
si := []SQItem{{
|
|
EventID: str,
|
|
ExpiryTime: &tm,
|
|
}}
|
|
msw := map[string]*StatWithCompress{"test": {
|
|
Stat: fl,
|
|
CompressFactor: nm,
|
|
}}
|
|
st := StatASR{
|
|
FilterIDs: slc,
|
|
Answered: fl,
|
|
Count: n,
|
|
Events: msw,
|
|
MinItems: nm,
|
|
}
|
|
msm := map[string]StatMetric{"*asr": &st}
|
|
|
|
var rwm sync.RWMutex
|
|
sq := StatQueue{
|
|
lk: rwm,
|
|
Tenant: str,
|
|
ID: str,
|
|
SQItems: si,
|
|
SQMetrics: msm,
|
|
MinItems: nm,
|
|
}
|
|
|
|
nExp := sq
|
|
|
|
sq.Lock()
|
|
|
|
if reflect.DeepEqual(sq, nExp) {
|
|
t.Error("didn't lock")
|
|
}
|
|
|
|
sq.Unlock()
|
|
|
|
if !reflect.DeepEqual(sq, nExp) {
|
|
t.Error("didn't lock")
|
|
}
|
|
}
|