uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 10:06:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

add coverage tests on engine

Browse Source
This commit is contained in:
armirveliaj
2025-04-24 10:56:28 -04:00
committed by Dan Christian Bogos
parent 9b9bbb819d
commit 01a435b21c
2 changed files with 250 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
engine/libeventcost_test.go
View File

@@ -1709,3 +1709,63 @@ func TestFieldsAsInterfaces(t *testing.T) {
})
}
}
func TestChargingIntervalTotalUsages(t *testing.T) {
cIl := &ChargingInterval{
RatingID: "RtID1",
Increments: []*ChargingIncrement{
{
Usage: 2 * time.Second,
Cost: 0.2,
AccountingID: "AccID1",
CompressFactor: 1,
},
{
Usage: 3 * time.Second,
Cost: 0.3,
AccountingID: "AccID2",
CompressFactor: 1,
},
},
CompressFactor: 2,
usage: nil,
}
expected := 10 * time.Second
result := cIl.TotalUsage()
if result == nil {
t.Errorf("Expected %v, but got nil", expected)
} else if *result != expected {
t.Errorf("Expected %v, but got %v", expected, *result)
}
manualUsage := 7 * time.Second
cIl.usage = &manualUsage
expected2 := 14 * time.Second
result2 := cIl.TotalUsage()
if result2 == nil {
t.Errorf("Expected %v, but got nil", expected2)
} else if *result2 != expected2 {
t.Errorf("Expected %v, but got %v", expected2, *result2)
}
zeroUsage := time.Duration(0)
cIl4 := &ChargingInterval{
RatingID: "RtID3",
CompressFactor: 5,
usage: &zeroUsage,
}
expected4 := time.Duration(0)
result3 := cIl4.TotalUsage()
if result3 == nil {
t.Errorf("Expected %v, but got nil", expected4)
} else if *result3 != expected4 {
t.Errorf("Expected %v, but got %v", expected4, *result3)
}
}

190
engine/libstats_test.go
View File

@@ -1523,3 +1523,193 @@ func TestSortQOS(t *testing.T) {
t.Errorf("Expected route2 at position 2, got %s", sortedRoutes.Routes[2].RouteID)
}
}
func TestSortLeastCosts(t *testing.T) {
sRoutes := &SortedRoutes{
ProfileID: "TestProfile",
Sorting: "LeastCost",
Routes: []*SortedRoute{
{
RouteID: "route1",
sortingDataF64: map[string]float64{
utils.Cost: 0.1,
utils.Weight: 10.0,
},
SortingData: map[string]any{
utils.Cost: 0.1,
utils.Weight: 10.0,
},
RouteParameters: "param1",
},
{
RouteID: "route2",
sortingDataF64: map[string]float64{
utils.Cost: 0.1,
utils.Weight: 20.0,
},
SortingData: map[string]any{
utils.Cost: 0.1,
utils.Weight: 20.0,
},
RouteParameters: "param2",
},
{
RouteID: "route3",
sortingDataF64: map[string]float64{
utils.Cost: 0.05,
utils.Weight: 10.0,
},
SortingData: map[string]any{
utils.Cost: 0.05,
utils.Weight: 10.0,
},
RouteParameters: "param3",
},
},
}
sRoutes.SortLeastCost()
expectedRoutes := &SortedRoutes{
ProfileID: "TestProfile",
Sorting: "LeastCost",
Routes: []*SortedRoute{
{
RouteID: "route3",
sortingDataF64: map[string]float64{
utils.Cost: 0.05,
utils.Weight: 10.0,
},
SortingData: map[string]any{
utils.Cost: 0.05,
utils.Weight: 10.0,
},
RouteParameters: "param3",
},
{
RouteID: "route2",
sortingDataF64: map[string]float64{
utils.Cost: 0.1,
utils.Weight: 20.0,
},
SortingData: map[string]any{
utils.Cost: 0.1,
utils.Weight: 20.0,
},
RouteParameters: "param2",
},
{
RouteID: "route1",
sortingDataF64: map[string]float64{
utils.Cost: 0.1,
utils.Weight: 10.0,
},
SortingData: map[string]any{
utils.Cost: 0.1,
utils.Weight: 10.0,
},
RouteParameters: "param1",
},
},
}
if !reflect.DeepEqual(expectedRoutes, sRoutes) {
t.Errorf("Expected: %+v, received: %+v", expectedRoutes, sRoutes)
}
}
func TestSortResourceDescendent(t *testing.T) {
sRoutes := &SortedRoutes{
ProfileID: "TestProfile",
Sorting: "ResourceDescendent",
Routes: []*SortedRoute{
{
RouteID: "route1",
sortingDataF64: map[string]float64{
utils.ResourceUsage: 0.5,
utils.Weight: 10.0,
},
SortingData: map[string]any{
utils.ResourceUsage: 0.5,
utils.Weight: 10.0,
},
RouteParameters: "param1",
},
{
RouteID: "route2",
sortingDataF64: map[string]float64{
utils.ResourceUsage: 0.5,
utils.Weight: 20.0,
},
SortingData: map[string]any{
utils.ResourceUsage: 0.5,
utils.Weight: 20.0,
},
RouteParameters: "param2",
},
{
RouteID: "route3",
sortingDataF64: map[string]float64{
utils.ResourceUsage: 0.8,
utils.Weight: 10.0,
},
SortingData: map[string]any{
utils.ResourceUsage: 0.8,
utils.Weight: 10.0,
},
RouteParameters: "param3",
},
},
}
sRoutes.SortResourceDescendent()
expectedRoutes := &SortedRoutes{
ProfileID: "TestProfile",
Sorting: "ResourceDescendent",
Routes: []*SortedRoute{
{
RouteID: "route3",
sortingDataF64: map[string]float64{
utils.ResourceUsage: 0.8,
utils.Weight: 10.0,
},
SortingData: map[string]any{
utils.ResourceUsage: 0.8,
utils.Weight: 10.0,
},
RouteParameters: "param3",
},
{
RouteID: "route2",
sortingDataF64: map[string]float64{
utils.ResourceUsage: 0.5,
utils.Weight: 20.0,
},
SortingData: map[string]any{
utils.ResourceUsage: 0.5,
utils.Weight: 20.0,
},
RouteParameters: "param2",
},
{
RouteID: "route1",
sortingDataF64: map[string]float64{
utils.ResourceUsage: 0.5,
utils.Weight: 10.0,
},
SortingData: map[string]any{
utils.ResourceUsage: 0.5,
utils.Weight: 10.0,
},
RouteParameters: "param1",
},
},
}
if !reflect.DeepEqual(expectedRoutes, sRoutes) {
t.Errorf("Expected: %+v, received: %+v", expectedRoutes, sRoutes)
}
}