mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
918 lines
25 KiB
Go
918 lines
25 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 Affero 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 Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
package utils
|
|
|
|
import (
|
|
"errors"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestTrendProfileClone(t *testing.T) {
|
|
|
|
original := &TrendProfile{
|
|
Tenant: "cgrates.org",
|
|
ID: "ID",
|
|
Schedule: "Schedule",
|
|
StatID: "StatID",
|
|
Metrics: []string{"metric1", "metric2"},
|
|
TTL: 10 * time.Minute,
|
|
QueueLength: 100,
|
|
MinItems: 10,
|
|
CorrelationType: "average",
|
|
Tolerance: 0.05,
|
|
Stored: true,
|
|
ThresholdIDs: []string{"thresh1", "thresh2"},
|
|
}
|
|
|
|
cloned := original.Clone()
|
|
|
|
if cloned.Tenant != original.Tenant {
|
|
t.Errorf("Expected Tenant %s, but got %s", original.Tenant, cloned.Tenant)
|
|
}
|
|
if cloned.ID != original.ID {
|
|
t.Errorf("Expected ID %s, but got %s", original.ID, cloned.ID)
|
|
}
|
|
if cloned.Schedule != original.Schedule {
|
|
t.Errorf("Expected Schedule %s, but got %s", original.Schedule, cloned.Schedule)
|
|
}
|
|
if cloned.StatID != original.StatID {
|
|
t.Errorf("Expected StatID %s, but got %s", original.StatID, cloned.StatID)
|
|
}
|
|
if cloned.QueueLength != original.QueueLength {
|
|
t.Errorf("Expected QueueLength %d, but got %d", original.QueueLength, cloned.QueueLength)
|
|
}
|
|
if cloned.TTL != original.TTL {
|
|
t.Errorf("Expected TTL %v, but got %v", original.TTL, cloned.TTL)
|
|
}
|
|
if cloned.MinItems != original.MinItems {
|
|
t.Errorf("Expected MinItems %d, but got %d", original.MinItems, cloned.MinItems)
|
|
}
|
|
if cloned.CorrelationType != original.CorrelationType {
|
|
t.Errorf("Expected CorrelationType %s, but got %s", original.CorrelationType, cloned.CorrelationType)
|
|
}
|
|
if cloned.Tolerance != original.Tolerance {
|
|
t.Errorf("Expected Tolerance %f, but got %f", original.Tolerance, cloned.Tolerance)
|
|
}
|
|
if cloned.Stored != original.Stored {
|
|
t.Errorf("Expected Stored %v, but got %v", original.Stored, cloned.Stored)
|
|
}
|
|
|
|
if !reflect.DeepEqual(cloned.Metrics, original.Metrics) {
|
|
t.Errorf("Expected Metrics %v, but got %v", original.Metrics, cloned.Metrics)
|
|
}
|
|
if !reflect.DeepEqual(cloned.ThresholdIDs, original.ThresholdIDs) {
|
|
t.Errorf("Expected ThresholdIDs %v, but got %v", original.ThresholdIDs, cloned.ThresholdIDs)
|
|
}
|
|
|
|
if len(cloned.Metrics) > 0 && &cloned.Metrics[0] == &original.Metrics[0] {
|
|
t.Errorf("Metrics slice was not deep copied")
|
|
}
|
|
if len(cloned.ThresholdIDs) > 0 && &cloned.ThresholdIDs[0] == &original.ThresholdIDs[0] {
|
|
t.Errorf("ThresholdIDs slice was not deep copied")
|
|
}
|
|
}
|
|
|
|
func TestTrendProfileTenantIDAndTrendProfileWithAPIOpts(t *testing.T) {
|
|
|
|
tp := &TrendProfile{
|
|
Tenant: "cgrates.org",
|
|
ID: "trend1",
|
|
Schedule: "*/5 * * * *",
|
|
StatID: "StatID",
|
|
Metrics: []string{"metric1", "metric2"},
|
|
TTL: 10 * time.Minute,
|
|
QueueLength: 100,
|
|
MinItems: 10,
|
|
CorrelationType: "average",
|
|
Tolerance: 0.05,
|
|
Stored: true,
|
|
ThresholdIDs: []string{"thresh1", "thresh2"},
|
|
}
|
|
|
|
tenantID := tp.TenantID()
|
|
|
|
expectedTenantID := "cgrates.org" + ConcatenatedKeySep + "trend1"
|
|
if tenantID != expectedTenantID {
|
|
t.Errorf("Expected TenantID %s, but got %s", expectedTenantID, tenantID)
|
|
}
|
|
|
|
apiOpts := map[string]any{
|
|
"option1": "value1",
|
|
"option2": 42,
|
|
}
|
|
|
|
tpWithAPIOpts := &TrendProfileWithAPIOpts{
|
|
TrendProfile: tp,
|
|
APIOpts: apiOpts,
|
|
}
|
|
|
|
if tpWithAPIOpts.Tenant != "cgrates.org" {
|
|
t.Errorf("Expected Tenant %s, but got %s", "cgrates.org", tpWithAPIOpts.Tenant)
|
|
}
|
|
if tpWithAPIOpts.ID != "trend1" {
|
|
t.Errorf("Expected ID %s, but got %s", "trend1", tpWithAPIOpts.ID)
|
|
}
|
|
|
|
expectedAPIOpts := map[string]any{
|
|
"option1": "value1",
|
|
"option2": 42,
|
|
}
|
|
if !reflect.DeepEqual(tpWithAPIOpts.APIOpts, expectedAPIOpts) {
|
|
t.Errorf("Expected APIOpts %v, but got %v", expectedAPIOpts, tpWithAPIOpts.APIOpts)
|
|
}
|
|
|
|
}
|
|
|
|
func TestIndexesAppendMetric(t *testing.T) {
|
|
|
|
trend := &Trend{
|
|
mLast: make(map[string]time.Time),
|
|
mCounts: make(map[string]int),
|
|
mTotals: make(map[string]float64),
|
|
}
|
|
|
|
metric1 := &MetricWithTrend{ID: "metric1", Value: 5.0}
|
|
metric2 := &MetricWithTrend{ID: "metric2", Value: 3.0}
|
|
|
|
rTime1 := time.Now()
|
|
rTime2 := rTime1.Add(10 * time.Minute)
|
|
|
|
trend.IndexesAppendMetric(metric1, rTime1)
|
|
trend.IndexesAppendMetric(metric2, rTime2)
|
|
trend.IndexesAppendMetric(metric1, rTime2)
|
|
|
|
expectedMLast := map[string]time.Time{
|
|
"metric1": rTime2,
|
|
"metric2": rTime2,
|
|
}
|
|
if !reflect.DeepEqual(trend.mLast, expectedMLast) {
|
|
t.Errorf("Expected mLast %v, but got %v", expectedMLast, trend.mLast)
|
|
}
|
|
|
|
expectedMCounts := map[string]int{
|
|
"metric1": 2,
|
|
"metric2": 1,
|
|
}
|
|
if !reflect.DeepEqual(trend.mCounts, expectedMCounts) {
|
|
t.Errorf("Expected mCounts %v, but got %v", expectedMCounts, trend.mCounts)
|
|
}
|
|
|
|
expectedMTotals := map[string]float64{
|
|
"metric1": 10.0,
|
|
"metric2": 3.0,
|
|
}
|
|
if !reflect.DeepEqual(trend.mTotals, expectedMTotals) {
|
|
t.Errorf("Expected mTotals %v, but got %v", expectedMTotals, trend.mTotals)
|
|
}
|
|
}
|
|
|
|
func TestTrendTenantID(t *testing.T) {
|
|
trend := &Trend{
|
|
Tenant: "cgrates.org",
|
|
ID: "ID",
|
|
RunTimes: []time.Time{
|
|
time.Now(),
|
|
time.Now().Add(-1 * time.Hour),
|
|
},
|
|
Metrics: map[time.Time]map[string]*MetricWithTrend{
|
|
time.Now(): {
|
|
"metric1": {ID: "metric1", Value: 1.5},
|
|
"metric2": {ID: "metric2", Value: 2.0},
|
|
},
|
|
time.Now().Add(-1 * time.Hour): {
|
|
"metric1": {ID: "metric1", Value: 1.0},
|
|
},
|
|
},
|
|
CompressedMetrics: []byte{0x00, 0x01},
|
|
mLast: map[string]time.Time{
|
|
"metric1": time.Now(),
|
|
"metric2": time.Now().Add(-1 * time.Hour),
|
|
},
|
|
mCounts: map[string]int{
|
|
"metric1": 2,
|
|
"metric2": 1,
|
|
},
|
|
mTotals: map[string]float64{
|
|
"metric1": 2.5,
|
|
"metric2": 2.0,
|
|
},
|
|
tPrfl: &TrendProfile{
|
|
Tenant: "cgrates.org",
|
|
ID: "trendProfileID",
|
|
Schedule: "0 * * * *",
|
|
StatID: "statID1",
|
|
QueueLength: 10,
|
|
TTL: 5 * time.Minute,
|
|
MinItems: 1,
|
|
CorrelationType: "average",
|
|
Tolerance: 0.1,
|
|
Stored: true,
|
|
ThresholdIDs: []string{"threshold1", "threshold2"},
|
|
},
|
|
}
|
|
|
|
tenantID := trend.TenantID()
|
|
|
|
expectedTenantID := "cgrates.org:ID"
|
|
if tenantID != expectedTenantID {
|
|
t.Errorf("Expected TenantID %v, but got %v", expectedTenantID, tenantID)
|
|
}
|
|
|
|
if len(trend.RunTimes) != 2 {
|
|
t.Errorf("Expected 2 run times, but got %d", len(trend.RunTimes))
|
|
}
|
|
|
|
if len(trend.Metrics) != 2 {
|
|
t.Errorf("Expected 2 metrics time entries, but got %d", len(trend.Metrics))
|
|
}
|
|
|
|
if trend.tPrfl.QueueLength != 10 {
|
|
t.Errorf("Expected QueueLength 10, but got %d", trend.tPrfl.QueueLength)
|
|
}
|
|
}
|
|
|
|
func TestTComputeIndexes(t *testing.T) {
|
|
runTime1 := time.Now()
|
|
runTime2 := runTime1.Add(time.Minute)
|
|
|
|
trend := &Trend{
|
|
RunTimes: []time.Time{runTime1, runTime2},
|
|
Metrics: map[time.Time]map[string]*MetricWithTrend{
|
|
runTime1: {
|
|
"metric1": &MetricWithTrend{ID: "metric1", Value: 10.0},
|
|
"metric2": &MetricWithTrend{ID: "metric2", Value: 20.0},
|
|
},
|
|
runTime2: {
|
|
"metric1": &MetricWithTrend{ID: "metric1", Value: 15.0},
|
|
},
|
|
},
|
|
}
|
|
|
|
trend.computeIndexes()
|
|
|
|
if trend.mLast["metric1"] != runTime2 {
|
|
t.Errorf("Expected last time for metric1 to be %v, got %v", runTime2, trend.mLast["metric1"])
|
|
}
|
|
|
|
if trend.mCounts["metric1"] != 2 {
|
|
t.Errorf("Expected count for metric1 to be 2, got %d", trend.mCounts["metric1"])
|
|
}
|
|
|
|
if trend.mTotals["metric1"] != 25.0 {
|
|
t.Errorf("Expected total for metric1 to be 25.0, got %f", trend.mTotals["metric1"])
|
|
}
|
|
|
|
if trend.mLast["metric2"] != runTime1 {
|
|
t.Errorf("Expected last time for metric2 to be %v, got %v", runTime1, trend.mLast["metric2"])
|
|
}
|
|
|
|
if trend.mCounts["metric2"] != 1 {
|
|
t.Errorf("Expected count for metric2 to be 1, got %d", trend.mCounts["metric2"])
|
|
}
|
|
|
|
if trend.mTotals["metric2"] != 20.0 {
|
|
t.Errorf("Expected total for metric2 to be 20.0, got %f", trend.mTotals["metric2"])
|
|
}
|
|
}
|
|
|
|
func TestGetTrendLabel(t *testing.T) {
|
|
tests := []struct {
|
|
tGrowth float64
|
|
tolerance float64
|
|
expected string
|
|
}{
|
|
{1.0, 0.5, MetaPositive},
|
|
{-1.0, 0.5, MetaNegative},
|
|
{0.0, 0.5, MetaConstant},
|
|
{0.3, 0.5, MetaConstant},
|
|
{-0.3, 0.5, MetaConstant},
|
|
{0.6, 0.5, MetaPositive},
|
|
{-0.6, 0.5, MetaNegative},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
result := GetTrendLabel(test.tGrowth, test.tolerance)
|
|
if result != test.expected {
|
|
t.Errorf("For tGrowth: %f and tolerance: %f, expected %s, got %s", test.tGrowth, test.tolerance, test.expected, result)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetTrendGrowth(t *testing.T) {
|
|
|
|
trend := Trend{
|
|
mLast: map[string]time.Time{},
|
|
Metrics: map[time.Time]map[string]*MetricWithTrend{},
|
|
mTotals: map[string]float64{},
|
|
mCounts: map[string]int{},
|
|
}
|
|
|
|
_, err := trend.GetTrendGrowth("unknownID", 100, MetaLast, 2)
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Errorf("Expected error ErrNotFound, got: %v", err)
|
|
}
|
|
|
|
now := time.Now()
|
|
trend.mLast["metric1"] = now
|
|
|
|
_, err = trend.GetTrendGrowth("metric1", 100, MetaLast, 2)
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Errorf("Expected error ErrNotFound, got: %v", err)
|
|
}
|
|
|
|
trend.Metrics = map[time.Time]map[string]*MetricWithTrend{
|
|
now: {
|
|
"metric1": {ID: "metric1", Value: 80},
|
|
},
|
|
}
|
|
|
|
got, err := trend.GetTrendGrowth("metric1", 100, MetaLast, 2)
|
|
if err != nil || got != 25.0 {
|
|
t.Errorf("Mismatch for MetaLast correlation. Got: %v, expected: %v", got, 25.0)
|
|
}
|
|
|
|
trend.mTotals = map[string]float64{
|
|
"metric1": 400,
|
|
}
|
|
trend.mCounts = map[string]int{
|
|
"metric1": 4,
|
|
}
|
|
|
|
got, err = trend.GetTrendGrowth("metric1", 120, MetaAverage, 2)
|
|
if err != nil || got != 20.0 {
|
|
t.Errorf("Mismatch for MetaAverage correlation. Got: %v, expected: %v", got, 20.0)
|
|
}
|
|
|
|
_, err = trend.GetTrendGrowth("metric1", 100, "invalidCorrelation", 2)
|
|
if !errors.Is(err, ErrCorrelationUndefined) {
|
|
t.Errorf("Expected error ErrCorrelationUndefined, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNewTrendFromProfile(t *testing.T) {
|
|
profile := &TrendProfile{
|
|
Tenant: "cgrates.org",
|
|
ID: "trendProfileID",
|
|
Schedule: "@every 1sec",
|
|
StatID: "statID1",
|
|
QueueLength: 10,
|
|
TTL: 5 * time.Minute,
|
|
MinItems: 1,
|
|
CorrelationType: "average",
|
|
Tolerance: 0.1,
|
|
Stored: true,
|
|
ThresholdIDs: []string{"threshold1", "threshold2"},
|
|
}
|
|
|
|
trend := NewTrendFromProfile(profile)
|
|
|
|
if trend.Tenant != profile.Tenant {
|
|
t.Errorf("Expected Tenant %s, got %s", profile.Tenant, trend.Tenant)
|
|
}
|
|
if trend.ID != profile.ID {
|
|
t.Errorf("Expected ID %s, got %s", profile.ID, trend.ID)
|
|
}
|
|
if trend.RunTimes == nil {
|
|
t.Errorf("Expected RunTimes to be initialized, got nil")
|
|
}
|
|
if len(trend.RunTimes) != 0 {
|
|
t.Errorf("Expected RunTimes to be empty, got length %d", len(trend.RunTimes))
|
|
}
|
|
if trend.Metrics == nil {
|
|
t.Errorf("Expected Metrics to be initialized, got nil")
|
|
}
|
|
if len(trend.Metrics) != 0 {
|
|
t.Errorf("Expected Metrics to be empty, got length %d", len(trend.Metrics))
|
|
}
|
|
if trend.tPrfl != profile {
|
|
t.Errorf("Expected tPrfl to point to the original profile, got a different value")
|
|
}
|
|
}
|
|
|
|
func TestTrendProfileFieldAsString(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
fldPath []string
|
|
err error
|
|
val any
|
|
}{
|
|
{ID, []string{ID}, nil, "Trend1"},
|
|
{Tenant, []string{Tenant}, nil, "cgrates.org"},
|
|
{Schedule, []string{Schedule}, nil, "@every 1m"},
|
|
{StatID, []string{StatID}, nil, "Stat1"},
|
|
{Metrics, []string{Metrics + "[0]"}, nil, "*acc"},
|
|
{Metrics, []string{Metrics + "[1]"}, nil, "*tcd"},
|
|
{TTL, []string{TTL}, nil, 10 * time.Minute},
|
|
{QueueLength, []string{QueueLength}, nil, 100},
|
|
{MinItems, []string{MinItems}, nil, 10},
|
|
{CorrelationType, []string{CorrelationType}, nil, "*average"},
|
|
{Tolerance, []string{Tolerance}, nil, 0.05},
|
|
{Stored, []string{Stored}, nil, true},
|
|
{ThresholdIDs, []string{ThresholdIDs + "[0]"}, nil, "Thresh1"},
|
|
{ThresholdIDs, []string{ThresholdIDs + "[1]"}, nil, "Thresh2"},
|
|
{"NonExistingField", []string{"Field1"}, ErrNotFound, nil},
|
|
}
|
|
rp := &TrendProfile{
|
|
Tenant: "cgrates.org",
|
|
ID: "Trend1",
|
|
Schedule: "@every 1m",
|
|
StatID: "Stat1",
|
|
Metrics: []string{"*acc", "*tcd"},
|
|
TTL: 10 * time.Minute,
|
|
QueueLength: 100,
|
|
MinItems: 10,
|
|
CorrelationType: "*average",
|
|
Tolerance: 0.05,
|
|
Stored: true,
|
|
ThresholdIDs: []string{"Thresh1", "Thresh2"},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
val, err := rp.FieldAsInterface(tc.fldPath)
|
|
if tc.err != nil {
|
|
if err == nil {
|
|
t.Error("expect to receive an error")
|
|
}
|
|
if tc.err != err {
|
|
t.Errorf("expected %v,received %v", tc.err, err)
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Errorf("unexpected error %v", err)
|
|
}
|
|
if val != tc.val {
|
|
t.Errorf("expected %v,received %v", tc.val, val)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTrendCleanUp(t *testing.T) {
|
|
tm := time.Now().Add(-19 * time.Second)
|
|
tm2 := tm.Add(15 * time.Second)
|
|
tm3 := time.Now().Add(1)
|
|
tm4 := time.Now().Add(-5 * time.Second)
|
|
tm5 := time.Now().Add(-3 * time.Second)
|
|
tr := &Trend{
|
|
Tenant: "cgrates.org",
|
|
ID: "TREND1",
|
|
RunTimes: []time.Time{
|
|
tm,
|
|
tm2,
|
|
tm3,
|
|
tm4,
|
|
tm5,
|
|
},
|
|
Metrics: map[time.Time]map[string]*MetricWithTrend{
|
|
tm: {
|
|
MetaTCC: {ID: MetaTCC, Value: 13, TrendGrowth: -1, TrendLabel: NotAvailable},
|
|
MetaACC: {ID: MetaACC, Value: 13, TrendGrowth: -1, TrendLabel: NotAvailable},
|
|
},
|
|
tm2: {
|
|
MetaTCC: {ID: MetaTCC, Value: 30, TrendGrowth: 120, TrendLabel: MetaPositive},
|
|
MetaACC: {ID: MetaACC, Value: 15, TrendGrowth: 4, TrendLabel: MetaPositive},
|
|
},
|
|
tm3: {
|
|
MetaTCC: {ID: MetaTCC, Value: 30, TrendGrowth: 120, TrendLabel: MetaPositive},
|
|
MetaACC: {ID: MetaACC, Value: 15, TrendGrowth: 4, TrendLabel: MetaPositive},
|
|
},
|
|
tm4: {
|
|
MetaTCC: {ID: MetaTCC, Value: 30, TrendGrowth: 120, TrendLabel: MetaPositive},
|
|
MetaACC: {ID: MetaACC, Value: 15, TrendGrowth: 4, TrendLabel: MetaPositive},
|
|
},
|
|
tm5: {
|
|
MetaTCC: {ID: MetaTCC, Value: 30, TrendGrowth: 120, TrendLabel: MetaPositive},
|
|
MetaACC: {ID: MetaACC, Value: 15, TrendGrowth: 4, TrendLabel: MetaPositive},
|
|
},
|
|
},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
ttl time.Duration
|
|
tr *Trend
|
|
qLength int
|
|
altered bool
|
|
runtimesmetriclens int
|
|
}{
|
|
{"TTLlgThan0", 10 * time.Second, tr, 3, true, 3},
|
|
{"QueueLenLg0", -1, tr, 2, true, 2},
|
|
{"TLLExpiredAll", 2 * time.Second, tr, 0, true, 0},
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
altered := tc.tr.cleanup(tc.ttl, tc.qLength)
|
|
if tc.altered {
|
|
if !altered {
|
|
t.Errorf("expected trend to be altered")
|
|
}
|
|
if len(tc.tr.RunTimes) != tc.runtimesmetriclens || len(tc.tr.Metrics) != tc.runtimesmetriclens {
|
|
t.Errorf("expected len to be %d,got %d metrics,%d runtimes", tc.runtimesmetriclens, len(tc.tr.Metrics), len(tc.tr.RunTimes))
|
|
}
|
|
|
|
return
|
|
}
|
|
if altered {
|
|
t.Error("expected trend to not be altered")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTrendProfileString(t *testing.T) {
|
|
profile := &TrendProfile{
|
|
Tenant: "cgrates.org",
|
|
ID: "Trend1",
|
|
Schedule: "@every 1m",
|
|
StatID: "Stat1",
|
|
Metrics: []string{"*acc", "*tcd"},
|
|
TTL: 10 * time.Minute,
|
|
QueueLength: 100,
|
|
MinItems: 10,
|
|
CorrelationType: "*average",
|
|
Tolerance: 0.05,
|
|
Stored: true,
|
|
ThresholdIDs: []string{"Thresh1", "Thresh2"},
|
|
}
|
|
|
|
jsonStr := profile.String()
|
|
if jsonStr == "" {
|
|
t.Errorf("Expected non-empty JSON string representation of TrendProfile")
|
|
}
|
|
|
|
expectedFields := []string{
|
|
`"cgrates.org"`, `"Trend1"`, `"@every 1m"`, `"Stat1"`,
|
|
`"*acc"`, `"*tcd"`, `"*average"`, `true`, `"Thresh1"`, `"Thresh2"`,
|
|
}
|
|
|
|
for _, field := range expectedFields {
|
|
if !strings.Contains(jsonStr, field) {
|
|
t.Errorf("Expected JSON output to contain field: %s", field)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTrendProfileFieldAssString(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
fldPath []string
|
|
expected string
|
|
hasError bool
|
|
}{
|
|
{
|
|
name: "Valid Tenant Field",
|
|
fldPath: []string{"Tenant"},
|
|
expected: "cgrates.org",
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Valid ID Field",
|
|
fldPath: []string{"ID"},
|
|
expected: "Trend1",
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Valid Schedule Field",
|
|
fldPath: []string{"Schedule"},
|
|
expected: "@every 1m",
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Invalid Field Path",
|
|
fldPath: []string{"NonExistentField"},
|
|
expected: "",
|
|
hasError: true,
|
|
},
|
|
}
|
|
|
|
tp := &TrendProfile{
|
|
Tenant: "cgrates.org",
|
|
ID: "Trend1",
|
|
Schedule: "@every 1m",
|
|
StatID: "Stat1",
|
|
Metrics: []string{"*acc", "*tcd"},
|
|
TTL: 10 * time.Minute,
|
|
QueueLength: 100,
|
|
MinItems: 10,
|
|
CorrelationType: "*average",
|
|
Tolerance: 0.05,
|
|
Stored: true,
|
|
ThresholdIDs: []string{"Thresh1", "Thresh2"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := tp.FieldAsString(tt.fldPath)
|
|
|
|
if tt.hasError && err == nil {
|
|
t.Errorf("Expected error for fldPath %v, but got none", tt.fldPath)
|
|
} else if !tt.hasError && err != nil {
|
|
t.Errorf("Expected no error for fldPath %v, but got: %v", tt.fldPath, err)
|
|
}
|
|
|
|
if result != tt.expected {
|
|
t.Errorf("For fldPath %v, expected %v, but got %v", tt.fldPath, tt.expected, result)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTrendProfileSet(t *testing.T) {
|
|
tp := &TrendProfile{
|
|
Tenant: "cgrates.org",
|
|
ID: "Trend1",
|
|
Schedule: "@every 1m",
|
|
StatID: "Stat1",
|
|
Metrics: []string{"*acc", "*tcd"},
|
|
TTL: 10 * time.Minute,
|
|
QueueLength: 100,
|
|
MinItems: 10,
|
|
CorrelationType: "*average",
|
|
Tolerance: 0.05,
|
|
Stored: true,
|
|
ThresholdIDs: []string{"Thresh1", "Thresh2"},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
path []string
|
|
val any
|
|
expected any
|
|
hasError bool
|
|
}{
|
|
{
|
|
name: "Set Tenant",
|
|
path: []string{Tenant},
|
|
val: "newTenant",
|
|
expected: "newTenant",
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set ID",
|
|
path: []string{ID},
|
|
val: "newID",
|
|
expected: "newID",
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set Schedule",
|
|
path: []string{Schedule},
|
|
val: "@every 2m",
|
|
expected: "@every 2m",
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set StatID",
|
|
path: []string{StatID},
|
|
val: "newStatID",
|
|
expected: "newStatID",
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set Metrics",
|
|
path: []string{Metrics},
|
|
val: []string{"*newMetric"},
|
|
expected: []string{"*acc", "*tcd", "*newMetric"},
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set TTL",
|
|
path: []string{TTL},
|
|
val: "15m",
|
|
expected: 15 * time.Minute,
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set QueueLength",
|
|
path: []string{QueueLength},
|
|
val: 50,
|
|
expected: 50,
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set MinItems",
|
|
path: []string{MinItems},
|
|
val: 20,
|
|
expected: 20,
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set CorrelationType",
|
|
path: []string{CorrelationType},
|
|
val: "*sum",
|
|
expected: "*sum",
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set Tolerance",
|
|
path: []string{Tolerance},
|
|
val: 0.1,
|
|
expected: 0.1,
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set Stored",
|
|
path: []string{Stored},
|
|
val: false,
|
|
expected: false,
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set ThresholdIDs",
|
|
path: []string{ThresholdIDs},
|
|
val: []string{"Thresh3", "Thresh4"},
|
|
expected: []string{"Thresh1", "Thresh2", "Thresh3", "Thresh4"},
|
|
hasError: false,
|
|
},
|
|
{
|
|
name: "Set Invalid Path",
|
|
path: []string{"InvalidPath"},
|
|
val: "invalid",
|
|
expected: nil,
|
|
hasError: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := tp.Set(tt.path, tt.val, false)
|
|
|
|
if tt.hasError && err == nil {
|
|
t.Errorf("Expected error for path %v, but got none", tt.path)
|
|
} else if !tt.hasError && err != nil {
|
|
t.Errorf("Expected no error for path %v, but got: %v", tt.path, err)
|
|
}
|
|
|
|
switch tt.path[0] {
|
|
case Tenant:
|
|
if tp.Tenant != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.Tenant)
|
|
}
|
|
case ID:
|
|
if tp.ID != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.ID)
|
|
}
|
|
case Schedule:
|
|
if tp.Schedule != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.Schedule)
|
|
}
|
|
case StatID:
|
|
if tp.StatID != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.StatID)
|
|
}
|
|
case Metrics:
|
|
if len(tp.Metrics) != len(tt.expected.([]string)) {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.Metrics)
|
|
} else {
|
|
for i := range tp.Metrics {
|
|
if tp.Metrics[i] != tt.expected.([]string)[i] {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.Metrics)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
case TTL:
|
|
if tp.TTL != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.TTL)
|
|
}
|
|
case QueueLength:
|
|
if tp.QueueLength != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.QueueLength)
|
|
}
|
|
case MinItems:
|
|
if tp.MinItems != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.MinItems)
|
|
}
|
|
case CorrelationType:
|
|
if tp.CorrelationType != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.CorrelationType)
|
|
}
|
|
case Tolerance:
|
|
if tp.Tolerance != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.Tolerance)
|
|
}
|
|
case Stored:
|
|
if tp.Stored != tt.expected {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.Stored)
|
|
}
|
|
case ThresholdIDs:
|
|
if len(tp.ThresholdIDs) != len(tt.expected.([]string)) {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.ThresholdIDs)
|
|
} else {
|
|
for i := range tp.ThresholdIDs {
|
|
if tp.ThresholdIDs[i] != tt.expected.([]string)[i] {
|
|
t.Errorf("For path %v, expected %v, but got %v", tt.path, tt.expected, tp.ThresholdIDs)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTrendProfileMergeV2(t *testing.T) {
|
|
tp1 := &TrendProfile{
|
|
Tenant: "tenant1",
|
|
ID: "id1",
|
|
Schedule: "schedule1",
|
|
StatID: "stat1",
|
|
Metrics: []string{"metric1", "metric2"},
|
|
ThresholdIDs: []string{"threshold1"},
|
|
Stored: true,
|
|
TTL: 10,
|
|
QueueLength: 100,
|
|
MinItems: 5,
|
|
CorrelationType: "type1",
|
|
Tolerance: 0.5,
|
|
}
|
|
|
|
tp2 := &TrendProfile{
|
|
Tenant: "tenant2",
|
|
ID: "id2",
|
|
Schedule: "schedule2",
|
|
StatID: "stat2",
|
|
Metrics: []string{"metric3", "metric4"},
|
|
ThresholdIDs: []string{"threshold2"},
|
|
Stored: true,
|
|
TTL: 20,
|
|
QueueLength: 200,
|
|
MinItems: 10,
|
|
CorrelationType: "type2",
|
|
Tolerance: 1.5,
|
|
}
|
|
|
|
tp1.Merge(tp2)
|
|
|
|
if tp1.Tenant != "tenant2" {
|
|
t.Errorf("Expected Tenant to be 'tenant2', but got: %s", tp1.Tenant)
|
|
}
|
|
|
|
if tp1.ID != "id2" {
|
|
t.Errorf("Expected ID to be 'id2', but got: %s", tp1.ID)
|
|
}
|
|
|
|
if tp1.Schedule != "schedule2" {
|
|
t.Errorf("Expected Schedule to be 'schedule2', but got: %s", tp1.Schedule)
|
|
}
|
|
|
|
if tp1.StatID != "stat2" {
|
|
t.Errorf("Expected StatID to be 'stat2', but got: %s", tp1.StatID)
|
|
}
|
|
|
|
expectedMetrics := []string{"metric1", "metric2", "metric3", "metric4"}
|
|
if len(tp1.Metrics) != len(expectedMetrics) {
|
|
t.Errorf("Expected Metrics to be %v, but got: %v", expectedMetrics, tp1.Metrics)
|
|
}
|
|
|
|
expectedThresholdIDs := []string{"threshold1", "threshold2"}
|
|
if len(tp1.ThresholdIDs) != len(expectedThresholdIDs) {
|
|
t.Errorf("Expected ThresholdIDs to be %v, but got: %v", expectedThresholdIDs, tp1.ThresholdIDs)
|
|
}
|
|
|
|
if tp1.Stored != true {
|
|
t.Errorf("Expected Stored to be 'true', but got: %v", tp1.Stored)
|
|
}
|
|
|
|
if tp1.TTL != 20 {
|
|
t.Errorf("Expected TTL to be 20, but got: %d", tp1.TTL)
|
|
}
|
|
|
|
if tp1.QueueLength != 200 {
|
|
t.Errorf("Expected QueueLength to be 200, but got: %d", tp1.QueueLength)
|
|
}
|
|
|
|
if tp1.MinItems != 10 {
|
|
t.Errorf("Expected MinItems to be 10, but got: %d", tp1.MinItems)
|
|
}
|
|
|
|
if tp1.CorrelationType != "type2" {
|
|
t.Errorf("Expected CorrelationType to be 'type2', but got: %s", tp1.CorrelationType)
|
|
}
|
|
|
|
if tp1.Tolerance != 1.5 {
|
|
t.Errorf("Expected Tolerance to be 1.5, but got: %f", tp1.Tolerance)
|
|
}
|
|
}
|