mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
355 lines
9.9 KiB
Go
355 lines
9.9 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, or56
|
|
(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 engine
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/cgrates/cgrates/utils"
|
|
)
|
|
|
|
func TestModelsTimingMdlTableName(t *testing.T) {
|
|
testStruct := TimingMdl{}
|
|
exp := utils.TBLTPTimings
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsDestinationMdlTableName(t *testing.T) {
|
|
testStruct := DestinationMdl{}
|
|
exp := utils.TBLTPDestinations
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsRateMdlTableName(t *testing.T) {
|
|
testStruct := RateMdl{}
|
|
exp := utils.TBLTPRates
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsDestinationRateMdlTableName(t *testing.T) {
|
|
testStruct := DestinationRateMdl{}
|
|
exp := utils.TBLTPDestinationRates
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsRatingPlanMdlTableName(t *testing.T) {
|
|
testStruct := RatingPlanMdl{}
|
|
exp := utils.TBLTPRatingPlans
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsRatingProfileMdlTableName(t *testing.T) {
|
|
testStruct := RatingProfileMdl{}
|
|
exp := utils.TBLTPRatingProfiles
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsActionMdlTableName(t *testing.T) {
|
|
testStruct := ActionMdl{}
|
|
exp := utils.TBLTPActions
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsActionPlanMdlTableName(t *testing.T) {
|
|
testStruct := ActionPlanMdl{}
|
|
exp := utils.TBLTPActionPlans
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsActionTriggerMdlTableName(t *testing.T) {
|
|
testStruct := ActionTriggerMdl{}
|
|
exp := utils.TBLTPActionTriggers
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsAccountActionMdlTableName(t *testing.T) {
|
|
testStruct := AccountActionMdl{}
|
|
exp := utils.TBLTPAccountActions
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsSetAccountActionId(t *testing.T) {
|
|
testStruct := &AccountActionMdl{
|
|
Id: 0,
|
|
Loadid: "",
|
|
Tenant: "",
|
|
Account: "",
|
|
}
|
|
|
|
err := testStruct.SetAccountActionId("id1:id2:id3")
|
|
if err != nil {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", nil, err)
|
|
}
|
|
if !reflect.DeepEqual("id1", testStruct.Loadid) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", "id1", testStruct.Loadid)
|
|
}
|
|
if !reflect.DeepEqual("id2", testStruct.Tenant) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", "id2", testStruct.Tenant)
|
|
}
|
|
if !reflect.DeepEqual("id3", testStruct.Account) {
|
|
t.Errorf("\nExpected <%+v>,\nreceived <%+v>", "id3", testStruct.Account)
|
|
}
|
|
|
|
}
|
|
|
|
func TestModelsSetAccountActionIdError(t *testing.T) {
|
|
testStruct := &AccountActionMdl{
|
|
Id: 0,
|
|
Loadid: "",
|
|
Tenant: "",
|
|
Account: "",
|
|
}
|
|
|
|
err := testStruct.SetAccountActionId("id1;id2;id3")
|
|
if err == nil || err.Error() != "Wrong TP Account Action Id: id1;id2;id3" {
|
|
t.Errorf("\nExpected <Wrong TP Account Action Id: id1;id2;id3>,\nreceived <%+v>", err)
|
|
}
|
|
|
|
}
|
|
|
|
func TestModelGetAccountActionId(t *testing.T) {
|
|
testStruct := &AccountActionMdl{
|
|
Id: 0,
|
|
Tpid: "",
|
|
Loadid: "",
|
|
Tenant: "id1",
|
|
Account: "id2",
|
|
}
|
|
result := testStruct.GetAccountActionId()
|
|
exp := utils.ConcatenatedKey(testStruct.Tenant, testStruct.Account)
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected <%+v> ,\nreceived <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestModelsAsMapStringInterface(t *testing.T) {
|
|
testCdrSql := CDRsql{
|
|
ID: 1,
|
|
Cgrid: "testCgrID1",
|
|
RunID: "testRunID",
|
|
OriginHost: "testOriginHost",
|
|
Source: "testSource",
|
|
OriginID: "testOriginId",
|
|
TOR: "testTOR",
|
|
RequestType: "testRequestType",
|
|
Tenant: "cgrates.org",
|
|
Category: "testCategory",
|
|
Account: "testAccount",
|
|
Subject: "testSubject",
|
|
Destination: "testDestination",
|
|
SetupTime: time.Date(2021, 3, 3, 3, 3, 3, 3, time.UTC),
|
|
AnswerTime: utils.TimePointer(time.Date(2021, 3, 3, 3, 3, 3, 3, time.UTC)),
|
|
Usage: 2,
|
|
ExtraFields: "extraFields",
|
|
CostSource: "testCostSource",
|
|
Cost: 2,
|
|
CostDetails: "testCostDetails",
|
|
ExtraInfo: "testExtraInfo",
|
|
CreatedAt: time.Date(2021, 3, 3, 3, 3, 3, 3, time.UTC),
|
|
UpdatedAt: time.Date(2021, 3, 3, 3, 3, 3, 3, time.UTC),
|
|
DeletedAt: utils.TimePointer(time.Date(2021, 3, 3, 3, 3, 3, 3, time.UTC)),
|
|
}
|
|
expected := map[string]any{
|
|
"cgrid": testCdrSql.Cgrid,
|
|
"run_id": testCdrSql.RunID,
|
|
"origin_host": testCdrSql.OriginHost,
|
|
"source": testCdrSql.Source,
|
|
"origin_id": testCdrSql.OriginID,
|
|
"tor": testCdrSql.TOR,
|
|
"request_type": testCdrSql.RequestType,
|
|
"tenant": testCdrSql.Tenant,
|
|
"category": testCdrSql.Category,
|
|
"account": testCdrSql.Account,
|
|
"subject": testCdrSql.Subject,
|
|
"destination": testCdrSql.Destination,
|
|
"setup_time": testCdrSql.SetupTime,
|
|
"answer_time": testCdrSql.AnswerTime,
|
|
"usage": testCdrSql.Usage,
|
|
"extra_fields": testCdrSql.ExtraFields,
|
|
"cost_source": testCdrSql.CostSource,
|
|
"cost": testCdrSql.Cost,
|
|
"cost_details": testCdrSql.CostDetails,
|
|
"extra_info": testCdrSql.ExtraInfo,
|
|
"created_at": testCdrSql.CreatedAt,
|
|
"updated_at": testCdrSql.UpdatedAt,
|
|
}
|
|
result := testCdrSql.AsMapStringInterface()
|
|
if !reflect.DeepEqual(expected, result) {
|
|
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expected, result)
|
|
}
|
|
}
|
|
|
|
func TestEngineSharedGroupMdlTableName(t *testing.T) {
|
|
testStruct := SharedGroupMdl{}
|
|
exp := utils.TBLTPSharedGroups
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected: <%+v>\nReceived: <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestEngineResourceMdlTableName(t *testing.T) {
|
|
testStruct := ResourceMdl{}
|
|
exp := utils.TBLTPResources
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected: <%+v>\nReceived: <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestEngineStatMdlTableName(t *testing.T) {
|
|
testStruct := StatMdl{}
|
|
exp := utils.TBLTPStats
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected: <%+v>\nReceived: <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestEngineThresholdMdlTableName(t *testing.T) {
|
|
testStruct := ThresholdMdl{}
|
|
exp := utils.TBLTPThresholds
|
|
result := testStruct.TableName()
|
|
if !reflect.DeepEqual(exp, result) {
|
|
t.Errorf("\nExpected: <%+v>\nReceived: <%+v>", exp, result)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameTPfilters(t *testing.T) {
|
|
want := "tp_filters"
|
|
got := FilterMdl{}.TableName()
|
|
if got != want {
|
|
t.Errorf("Expected TableName(): %s, got: %s", want, got)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameCdrs(t *testing.T) {
|
|
want := "cdrs"
|
|
got := CDRsql{}.TableName()
|
|
if got != want {
|
|
t.Errorf("Expected TableName(): %s, got: %s", want, got)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameSessionCosts(t *testing.T) {
|
|
want := "session_costs"
|
|
got := SessionCostsSQL{}.TableName()
|
|
if got != want {
|
|
t.Errorf("Expected TableName(): %s, got: %s", want, got)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameTBLVersions(t *testing.T) {
|
|
expected := "versions"
|
|
got := TBLVersion{}.TableName()
|
|
if got != expected {
|
|
t.Errorf("Expected TableName(): %s, got: %s", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameTbltpRoutes(t *testing.T) {
|
|
want := "tp_routes"
|
|
got := RouteMdl{}.TableName()
|
|
if got != want {
|
|
t.Errorf("Expected TableName(): %s, got: %s", want, got)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameTPAttributeMdl(t *testing.T) {
|
|
want := "tp_attributes"
|
|
got := AttributeMdl{}.TableName()
|
|
if got != want {
|
|
t.Errorf("Expected TableName(): %s, got: %s", want, got)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameChargerMdl(t *testing.T) {
|
|
want := "tp_chargers"
|
|
got := ChargerMdl{}.TableName()
|
|
if got != want {
|
|
t.Errorf("Expected TableName(): %s, got: %s", want, got)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameDispatcherProfileMdl(t *testing.T) {
|
|
want := "tp_dispatcher_profiles"
|
|
got := DispatcherProfileMdl{}.TableName()
|
|
if got != want {
|
|
t.Errorf("Expected TableName(): %s, got: %s", want, got)
|
|
}
|
|
}
|
|
|
|
func TestEngineTableNameDispatcherHostMdl(t *testing.T) {
|
|
want := "tp_dispatcher_hosts"
|
|
got := DispatcherHostMdl{}.TableName()
|
|
if got != want {
|
|
t.Errorf("Expected TableName(): %s, got: %s", got, got)
|
|
}
|
|
}
|
|
|
|
func TestTableName(t *testing.T) {
|
|
expectedTableName := utils.TBLTPRankings
|
|
rankingsMdl := &RankingsMdl{}
|
|
actualTableName := rankingsMdl.TableName()
|
|
if actualTableName != expectedTableName {
|
|
t.Errorf("expected %s, but got %s", expectedTableName, actualTableName)
|
|
}
|
|
}
|
|
|
|
func TestTrendsTableName(t *testing.T) {
|
|
expectedTableName := utils.TBLTPTrends
|
|
trendsMdl := &TrendsMdl{}
|
|
actualTableName := trendsMdl.TableName()
|
|
if actualTableName != expectedTableName {
|
|
t.Errorf("expected %s, but got %s", expectedTableName, actualTableName)
|
|
}
|
|
}
|