mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
354 lines
11 KiB
Go
354 lines
11 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 (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/cgrates/cgrates/utils"
|
|
)
|
|
|
|
func TestRankingDescSorterSortStatIDs(t *testing.T) {
|
|
Metrics := map[string]map[string]float64{
|
|
"STATS1": {"*acc": 12.1, "*tcc": 24.2},
|
|
"STATS2": {"*acc": 12.1, "*tcc": 24.3},
|
|
"STATS3": {"*acc": 10.1, "*tcc": 25.3},
|
|
"STATS4": {"*tcc": 26.3},
|
|
}
|
|
sortMetrics := []string{"*acc", "*tcc"}
|
|
rdscSrtr := newRankingDescSorter(sortMetrics, Metrics)
|
|
eStatIDs := []string{"STATS2", "STATS1", "STATS3", "STATS4"}
|
|
if statIDs := rdscSrtr.sortStatIDs(); !reflect.DeepEqual(eStatIDs, statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", eStatIDs, statIDs)
|
|
}
|
|
sortMetrics = []string{"*acc:false", "*tcc"} // changed the order of checks, stats4 should come first
|
|
rdscSrtr = newRankingDescSorter(sortMetrics, Metrics)
|
|
eStatIDs = []string{"STATS3", "STATS2", "STATS1", "STATS4"}
|
|
if statIDs := rdscSrtr.sortStatIDs(); !reflect.DeepEqual(eStatIDs, statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", eStatIDs, statIDs)
|
|
}
|
|
sortMetrics = []string{"*tcc", "*acc:true"} // changed the order of checks, stats4 should come first
|
|
rdscSrtr = newRankingDescSorter(sortMetrics, Metrics)
|
|
eStatIDs = []string{"STATS4", "STATS3", "STATS2", "STATS1"}
|
|
if statIDs := rdscSrtr.sortStatIDs(); !reflect.DeepEqual(eStatIDs, statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", eStatIDs, statIDs)
|
|
}
|
|
sortMetrics = []string{"*tcc:false", "*acc"} // reversed *tcc which should consider ascendent instead of descendent
|
|
rdscSrtr = newRankingDescSorter(sortMetrics, Metrics)
|
|
eStatIDs = []string{"STATS1", "STATS2", "STATS3", "STATS4"}
|
|
if statIDs := rdscSrtr.sortStatIDs(); !reflect.DeepEqual(eStatIDs, statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", eStatIDs, statIDs)
|
|
}
|
|
}
|
|
|
|
func TestRankingAscSorterSortStatIDs(t *testing.T) {
|
|
Metrics := map[string]map[string]float64{
|
|
"STATS1": {"*acc": 12.1, "*tcc": 24.2},
|
|
"STATS2": {"*acc": 12.1, "*tcc": 24.3},
|
|
"STATS3": {"*acc": 10.1, "*tcc": 25.3},
|
|
"STATS4": {"*tcc": 26.3},
|
|
}
|
|
sortMetrics := []string{"*acc", "*tcc"}
|
|
rtAscSrtr := newRankingAscSorter(sortMetrics, Metrics)
|
|
eStatIDs := []string{"STATS3", "STATS1", "STATS2", "STATS4"}
|
|
if statIDs := rtAscSrtr.sortStatIDs(); !reflect.DeepEqual(eStatIDs, statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", eStatIDs, statIDs)
|
|
}
|
|
sortMetrics = []string{"*acc:false", "*tcc"}
|
|
rtAscSrtr = newRankingAscSorter(sortMetrics, Metrics)
|
|
eStatIDs = []string{"STATS1", "STATS2", "STATS3", "STATS4"}
|
|
if statIDs := rtAscSrtr.sortStatIDs(); !reflect.DeepEqual(eStatIDs, statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", eStatIDs, statIDs)
|
|
}
|
|
sortMetrics = []string{"*tcc", "*acc:true"}
|
|
rtAscSrtr = newRankingAscSorter(sortMetrics, Metrics)
|
|
eStatIDs = []string{"STATS1", "STATS2", "STATS3", "STATS4"}
|
|
if statIDs := rtAscSrtr.sortStatIDs(); !reflect.DeepEqual(eStatIDs, statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", eStatIDs, statIDs)
|
|
}
|
|
sortMetrics = []string{"*tcc:false", "*acc"}
|
|
rtAscSrtr = newRankingAscSorter(sortMetrics, Metrics)
|
|
eStatIDs = []string{"STATS4", "STATS3", "STATS2", "STATS1"}
|
|
if statIDs := rtAscSrtr.sortStatIDs(); !reflect.DeepEqual(eStatIDs, statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", eStatIDs, statIDs)
|
|
}
|
|
}
|
|
|
|
func TestRankingMixedOrder(t *testing.T) {
|
|
statmetrics := map[string]map[string]float64{
|
|
"Stat1": {"*acc": 13},
|
|
"Stat6": {"*acc": 10, "*pdd": 700, "*tcc": 121},
|
|
"Stat2": {"*acc": 14},
|
|
"Stat5": {"*acc": 10, "*pdd": 700, "*tcc": 120},
|
|
"Stat3": {"*acc": 12.1, "*pdd": 900},
|
|
"Stat7": {"*acc": 10, "*pdd": 600, "*tcc": 123},
|
|
"Stat4": {"*acc": 12.1, "*pdd": 1000},
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
sortMetric []string
|
|
sorter string
|
|
statIDs []string
|
|
expErr error
|
|
}{
|
|
{
|
|
name: "TestSortStatsAsc",
|
|
sortMetric: []string{"*acc", "*pdd:false", "*tcc"},
|
|
sorter: "*asc",
|
|
statIDs: []string{"Stat5", "Stat6", "Stat7", "Stat4", "Stat3", "Stat1", "Stat2"},
|
|
},
|
|
{
|
|
name: "TestSortStatsDesc",
|
|
sortMetric: []string{"*tcc", "*pdd:false", "*acc"},
|
|
sorter: "*desc",
|
|
statIDs: []string{"Stat7", "Stat6", "Stat5", "Stat3", "Stat4", "Stat2", "Stat1"},
|
|
},
|
|
{
|
|
name: "TestSortStatsDesc2",
|
|
sortMetric: []string{"*acc", "*tcc", "*pdd:false"},
|
|
sorter: "*desc",
|
|
statIDs: []string{"Stat2", "Stat1", "Stat3", "Stat4", "Stat7", "Stat6", "Stat5"},
|
|
},
|
|
{
|
|
name: "TestSortStatsAsc2",
|
|
sortMetric: []string{"*tcc", "*pdd:false", "*acc"},
|
|
sorter: "*asc",
|
|
statIDs: []string{"Stat5", "Stat6", "Stat7", "Stat4", "Stat3", "Stat1", "Stat2"},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
rs, err := newRankingSorter(tc.sorter, tc.sortMetric, statmetrics)
|
|
if tc.expErr != nil {
|
|
if err == nil {
|
|
t.Error("Expected error, got nil")
|
|
}
|
|
if tc.expErr.Error() != err.Error() {
|
|
t.Errorf("Expected error: %v, got: %v", tc.expErr, err)
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Errorf("Unexpected error: %v", err)
|
|
}
|
|
if resStatIDs := rs.sortStatIDs(); !reflect.DeepEqual(resStatIDs, tc.statIDs) {
|
|
t.Errorf("Expecting: %v, received %v", tc.statIDs, resStatIDs)
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestTenantID(t *testing.T) {
|
|
ranking := &Ranking{
|
|
Tenant: "tenant1",
|
|
ID: "ranking1",
|
|
}
|
|
expectedTenantID := utils.ConcatenatedKey(ranking.Tenant, ranking.ID)
|
|
actualTenantID := ranking.TenantID()
|
|
if actualTenantID != expectedTenantID {
|
|
t.Errorf("Expected TenantID %q, got %q", expectedTenantID, actualTenantID)
|
|
}
|
|
}
|
|
|
|
func TestNewRankingSorter(t *testing.T) {
|
|
Metrics := map[string]map[string]float64{
|
|
"STATS1": {"*acc": 12.1, "*tcc": 24.2},
|
|
"STATS2": {"*acc": 12.1, "*tcc": 24.3},
|
|
"STATS3": {"*acc": 10.1, "*tcc": 25.3},
|
|
"STATS4": {"*tcc": 26.3},
|
|
}
|
|
|
|
tests := []struct {
|
|
sortingType string
|
|
sortingParams []string
|
|
expectErr bool
|
|
expectSorterType string
|
|
}{
|
|
{
|
|
sortingType: utils.MetaAsc,
|
|
sortingParams: []string{"*acc"},
|
|
expectErr: false,
|
|
expectSorterType: "RankingAscSorter",
|
|
},
|
|
{
|
|
sortingType: utils.MetaDesc,
|
|
sortingParams: []string{"*tcc"},
|
|
expectErr: false,
|
|
expectSorterType: "RankingDescSorter",
|
|
},
|
|
{
|
|
sortingType: "unsupported",
|
|
sortingParams: []string{"*tcc"},
|
|
expectErr: true,
|
|
expectSorterType: "",
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
rkSorter, err := newRankingSorter(test.sortingType, test.sortingParams, Metrics)
|
|
|
|
if test.expectErr {
|
|
if err == nil {
|
|
t.Errorf("Expected an error for sorting type %q, but got none", test.sortingType)
|
|
}
|
|
} else {
|
|
if err != nil {
|
|
t.Errorf("Did not expect an error for sorting type %q, but got: %v", test.sortingType, err)
|
|
}
|
|
switch test.sortingType {
|
|
case utils.MetaAsc:
|
|
if _, ok := rkSorter.(*rankingAscSorter); !ok {
|
|
t.Errorf("Expected sorter type 'rankingAscSorter', but got %T", rkSorter)
|
|
}
|
|
case utils.MetaDesc:
|
|
if _, ok := rkSorter.(*rankingDescSorter); !ok {
|
|
t.Errorf("Expected sorter type 'rankingDescSorter', but got %T", rkSorter)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRankingProfileClone(t *testing.T) {
|
|
|
|
t.Run("Empty fields", func(t *testing.T) {
|
|
original := &RankingProfile{}
|
|
|
|
clone := original.Clone()
|
|
|
|
if clone.Tenant != "" ||
|
|
clone.ID != "" ||
|
|
clone.Schedule != "" ||
|
|
clone.StatIDs != nil ||
|
|
clone.MetricIDs != nil ||
|
|
clone.Sorting != "" ||
|
|
clone.SortingParameters != nil ||
|
|
clone.Stored != false ||
|
|
clone.ThresholdIDs != nil {
|
|
t.Errorf("Clone method did not create an empty RankingProfile for empty original")
|
|
}
|
|
})
|
|
|
|
t.Run("Nil slices", func(t *testing.T) {
|
|
original := &RankingProfile{
|
|
Tenant: "tenant",
|
|
ID: "profile_id",
|
|
Schedule: "0 * * * *",
|
|
}
|
|
|
|
clone := original.Clone()
|
|
|
|
if clone.StatIDs != nil ||
|
|
clone.MetricIDs != nil ||
|
|
clone.SortingParameters != nil ||
|
|
clone.ThresholdIDs != nil {
|
|
t.Errorf("Clone method did not handle nil slices correctly")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestNewRankingFromProfile(t *testing.T) {
|
|
rkP := &RankingProfile{
|
|
Tenant: "tenant",
|
|
ID: "profile_id",
|
|
Schedule: "0 * * * *",
|
|
StatIDs: []string{"stat1", "stat2"},
|
|
MetricIDs: []string{"metricA", "metricB"},
|
|
Sorting: "asc",
|
|
SortingParameters: []string{"metricA:true", "metricB:false"},
|
|
Stored: true,
|
|
ThresholdIDs: []string{"threshold1", "threshold2"},
|
|
}
|
|
|
|
expectedRk := &Ranking{
|
|
Tenant: rkP.Tenant,
|
|
ID: rkP.ID,
|
|
Sorting: rkP.Sorting,
|
|
Metrics: make(map[string]map[string]float64),
|
|
rkPrfl: rkP,
|
|
metricIDs: utils.NewStringSet(rkP.MetricIDs),
|
|
}
|
|
|
|
rk := NewRankingFromProfile(rkP)
|
|
|
|
if rk.Tenant != expectedRk.Tenant ||
|
|
rk.ID != expectedRk.ID ||
|
|
rk.Sorting != expectedRk.Sorting ||
|
|
rk.rkPrfl != expectedRk.rkPrfl ||
|
|
!reflect.DeepEqual(rk.metricIDs, expectedRk.metricIDs) {
|
|
t.Errorf("NewRankingFromProfile returned unexpected Ranking object")
|
|
}
|
|
|
|
}
|
|
|
|
func TestRankingSortStatss(t *testing.T) {
|
|
metrics := map[string]map[string]float64{
|
|
"STAT1": {"metric1": 10.1, "metric2": 5.2},
|
|
"STAT2": {"metric1": 9.1, "metric2": 6.2},
|
|
"STAT3": {"metric1": 11.1, "metric2": 4.2},
|
|
}
|
|
|
|
_, err := rankingSortStats("valid", []string{"metric1"}, metrics)
|
|
if err != nil {
|
|
expectedErr := "NOT_IMPLEMENTED:valid"
|
|
if err.Error() != expectedErr {
|
|
t.Errorf("expected error %v, got %v", expectedErr, err)
|
|
}
|
|
}
|
|
|
|
_, err = rankingSortStats("invalid", []string{"metric1"}, metrics)
|
|
if err == nil {
|
|
t.Errorf("expected an error for invalid sorting type, but got nil")
|
|
}
|
|
}
|
|
|
|
func TestRankingAscSorterEmptyStatIDs(t *testing.T) {
|
|
rkASrtr := &rankingAscSorter{
|
|
statIDs: []string{},
|
|
Metrics: make(map[string]map[string]float64),
|
|
sMetricIDs: []string{},
|
|
sMetricRev: utils.StringSet{},
|
|
}
|
|
|
|
sortedStatIDs := rkASrtr.sortStatIDs()
|
|
|
|
if len(sortedStatIDs) != 0 {
|
|
t.Errorf("expected sortedStatIDs to be empty, got %v", sortedStatIDs)
|
|
}
|
|
}
|
|
|
|
func TestRankingDescSorterEmptyStatIDs(t *testing.T) {
|
|
rkDsrtr := &rankingDescSorter{
|
|
statIDs: []string{},
|
|
Metrics: make(map[string]map[string]float64),
|
|
sMetricIDs: []string{},
|
|
sMetricRev: utils.StringSet{},
|
|
}
|
|
|
|
sortedStatIDs := rkDsrtr.sortStatIDs()
|
|
|
|
if len(sortedStatIDs) != 0 {
|
|
t.Errorf("expected sortedStatIDs to be empty, got %v", sortedStatIDs)
|
|
}
|
|
}
|