mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
764 lines
15 KiB
Go
764 lines
15 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 (
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/cgrates/cgrates/utils"
|
|
)
|
|
|
|
func TestActionErrors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
rcv string
|
|
exp string
|
|
}{
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: resetTriggersAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: setRecurrentAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: unsetRecurrentAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: allowNegativeAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: denyNegativeAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: resetAccountAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: topupResetAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: debitResetAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: debitAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: resetCountersAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: genericDebit(nil, nil, false).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: enableAccountAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: disableAccountAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: topupZeroNegativeAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: setExpiryAction(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: publishAccount(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
{
|
|
name: "resetTriggersAction",
|
|
rcv: publishBalance(nil, nil, nil, nil).Error(),
|
|
exp: "nil account",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if tt.rcv != tt.exp {
|
|
t.Errorf("expected %s, receives %s", tt.exp, tt.rcv)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
var sm utils.StringMap = utils.StringMap{str: bl}
|
|
var rtm RITiming = RITiming{
|
|
Years: utils.Years{2021},
|
|
Months: utils.Months{8},
|
|
MonthDays: utils.MonthDays{28},
|
|
WeekDays: utils.WeekDays{5},
|
|
StartTime: str2,
|
|
EndTime: str2,
|
|
cronString: str2,
|
|
tag: str2,
|
|
}
|
|
var vf ValueFactor = ValueFactor{str2: fl2}
|
|
var vfr utils.ValueFormula = utils.ValueFormula{
|
|
Method: str2,
|
|
Params: map[string]any{str2: str2},
|
|
Static: fl2,
|
|
}
|
|
var bf BalanceFilter = BalanceFilter{
|
|
Uuid: &str2,
|
|
ID: &str2,
|
|
Type: &str2,
|
|
Value: &vfr,
|
|
ExpirationDate: &tm2,
|
|
Weight: &fl2,
|
|
DestinationIDs: &sm,
|
|
RatingSubject: &str2,
|
|
Categories: &sm,
|
|
SharedGroups: &sm,
|
|
TimingIDs: &sm,
|
|
Timings: []*RITiming{&rtm},
|
|
Disabled: &bl,
|
|
Factor: &vf,
|
|
Blocker: &bl,
|
|
}
|
|
var cf CounterFilter = CounterFilter{
|
|
Value: fl,
|
|
Filter: &bf,
|
|
}
|
|
var uc UnitCounter = UnitCounter{
|
|
CounterType: "*balance",
|
|
Counters: CounterFilters{&cf},
|
|
}
|
|
var at ActionTrigger = ActionTrigger{
|
|
ID: str2,
|
|
UniqueID: str2,
|
|
ThresholdType: str2,
|
|
Recurrent: bl,
|
|
MinSleep: 1 * time.Millisecond,
|
|
ExpirationDate: tm2,
|
|
ActivationDate: tm2,
|
|
Balance: &bf,
|
|
Weight: fl2,
|
|
ActionsID: str2,
|
|
MinQueuedItems: nm2,
|
|
Executed: bl,
|
|
LastExecutionTime: tm2,
|
|
}
|
|
|
|
var ac Account = Account{
|
|
ID: "test:test",
|
|
UnitCounters: UnitCounters{str: {&uc}},
|
|
ActionTriggers: ActionTriggers{&at},
|
|
AllowNegative: bl,
|
|
Disabled: bl,
|
|
UpdateTime: tm2,
|
|
executingTriggers: bl,
|
|
}
|
|
var a *Action = &Action{
|
|
Id: str2,
|
|
ActionType: str2,
|
|
ExtraParameters: str2,
|
|
Filter: str2,
|
|
ExpirationString: str2,
|
|
Weight: fl2,
|
|
Balance: &bf,
|
|
balanceValue: fl2,
|
|
}
|
|
|
|
func TestActionClone(t *testing.T) {
|
|
var a *Action
|
|
|
|
rcv := a.Clone()
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestActionlogAction(t *testing.T) {
|
|
ub := Account{}
|
|
a := Action{}
|
|
acs := Actions{}
|
|
|
|
err := logAction(&ub, &a, acs, nil)
|
|
if err != nil {
|
|
if err.Error() != "" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
err = logAction(nil, &a, acs, &ub)
|
|
if err != nil {
|
|
if err.Error() != "" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestActionresetAction(t *testing.T) {
|
|
|
|
acs := Actions{}
|
|
|
|
err := debitResetAction(&ac, a, acs, nil)
|
|
if err != nil {
|
|
if err.Error() != "" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
if ac.BalanceMap == nil {
|
|
t.Error("didn't reset action")
|
|
}
|
|
}
|
|
|
|
func TestActiongetOneData(t *testing.T) {
|
|
ub := Account{}
|
|
|
|
rcv, err := getOneData(&ub, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
exp, _ := json.Marshal(&ub)
|
|
|
|
if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected %v, received %v", exp, rcv)
|
|
}
|
|
|
|
rcv, err = getOneData(nil, &ub)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
exp, _ = json.Marshal(&ub)
|
|
|
|
if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected %v, received %v", exp, rcv)
|
|
}
|
|
|
|
rcv, err = getOneData(nil, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestAccountsendErrors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
rcv error
|
|
exp string
|
|
}{
|
|
{
|
|
name: "sendAMQP error check",
|
|
rcv: sendAMQP(nil, nil, nil, make(chan int)),
|
|
exp: "json: unsupported type: chan int",
|
|
},
|
|
{
|
|
name: "sendAWS error check",
|
|
rcv: sendAWS(nil, nil, nil, make(chan int)),
|
|
exp: "json: unsupported type: chan int",
|
|
},
|
|
{
|
|
name: "sendSQS error check",
|
|
rcv: sendSQS(nil, nil, nil, make(chan int)),
|
|
exp: "json: unsupported type: chan int",
|
|
},
|
|
{
|
|
name: "sendKafka error check",
|
|
rcv: sendKafka(nil, nil, nil, make(chan int)),
|
|
exp: "json: unsupported type: chan int",
|
|
},
|
|
{
|
|
name: "sendS3 error check",
|
|
rcv: sendS3(nil, nil, nil, make(chan int)),
|
|
exp: "json: unsupported type: chan int",
|
|
},
|
|
{
|
|
name: "callURL error check",
|
|
rcv: callURL(nil, nil, nil, make(chan int)),
|
|
exp: "json: unsupported type: chan int",
|
|
},
|
|
{
|
|
name: "callURLAsync error check",
|
|
rcv: callURLAsync(nil, nil, nil, make(chan int)),
|
|
exp: "json: unsupported type: chan int",
|
|
},
|
|
{
|
|
name: "postEvent error check",
|
|
rcv: postEvent(nil, nil, nil, make(chan int)),
|
|
exp: "json: unsupported type: chan int",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if tt.rcv != nil {
|
|
if tt.rcv.Error() != tt.exp {
|
|
t.Errorf("expected %s, received %s", tt.exp, tt.rcv)
|
|
}
|
|
} else {
|
|
t.Error("was expecting an error")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestActionsetBalanceAction(t *testing.T) {
|
|
err := setBalanceAction(nil, nil, nil, nil)
|
|
|
|
if err != nil {
|
|
if err.Error() != `nil account for null action` {
|
|
t.Error(err)
|
|
}
|
|
} else {
|
|
t.Error("was expecting an error")
|
|
}
|
|
}
|
|
|
|
func TestActiontransferMonetaryDefaultAction(t *testing.T) {
|
|
err := transferMonetaryDefaultAction(nil, nil, nil, nil)
|
|
|
|
if err != nil {
|
|
if err.Error() != "ACCOUNT_NOT_FOUND" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
blc := Balance{
|
|
Uuid: str2,
|
|
ID: str2,
|
|
Value: fl2,
|
|
ExpirationDate: tm2,
|
|
Weight: fl2,
|
|
DestinationIDs: sm,
|
|
RatingSubject: str2,
|
|
Categories: sm,
|
|
SharedGroups: sm,
|
|
Timings: []*RITiming{&rtm},
|
|
TimingIDs: sm,
|
|
Disabled: bl,
|
|
Factor: ValueFactor{str2: fl2},
|
|
Blocker: bl,
|
|
precision: nm2,
|
|
dirty: bl,
|
|
}
|
|
ac := Account{
|
|
BalanceMap: map[string]Balances{str: {&blc}},
|
|
}
|
|
|
|
err = transferMonetaryDefaultAction(&ac, nil, nil, nil)
|
|
|
|
if err != nil {
|
|
if err.Error() != "NOT_FOUND" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestActionpublishAccount(t *testing.T) {
|
|
sm := utils.StringMap{
|
|
"test1": bl,
|
|
}
|
|
rtm := RITiming{
|
|
Years: utils.Years{2021},
|
|
Months: utils.Months{8},
|
|
MonthDays: utils.MonthDays{28},
|
|
WeekDays: utils.WeekDays{5},
|
|
StartTime: str,
|
|
EndTime: str,
|
|
cronString: str,
|
|
tag: str,
|
|
}
|
|
blc := Balance{
|
|
Uuid: str2,
|
|
ID: str2,
|
|
Value: fl2,
|
|
ExpirationDate: tm2,
|
|
Weight: fl2,
|
|
DestinationIDs: sm,
|
|
RatingSubject: str2,
|
|
Categories: sm,
|
|
SharedGroups: sm,
|
|
Timings: []*RITiming{&rtm},
|
|
TimingIDs: sm,
|
|
Disabled: bl,
|
|
Factor: ValueFactor{str2: fl2},
|
|
Blocker: bl,
|
|
precision: nm2,
|
|
dirty: bl,
|
|
}
|
|
ac := Account{
|
|
BalanceMap: map[string]Balances{str: {&blc}},
|
|
}
|
|
|
|
err := publishAccount(&ac, nil, nil, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestActionCloneNil(t *testing.T) {
|
|
var apl Actions
|
|
|
|
rcv, err := apl.Clone()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if rcv != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
var cdrP cdrLogProvider = cdrLogProvider{
|
|
acnt: &ac,
|
|
action: a,
|
|
cache: utils.MapStorage{},
|
|
}
|
|
|
|
func TestActionString(t *testing.T) {
|
|
rcv := cdrP.String()
|
|
exp := utils.ToJSON(cdrP)
|
|
|
|
if rcv != exp {
|
|
t.Errorf("expected %s, received %s", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestActionFieldAsInterface(t *testing.T) {
|
|
cdrP := cdrLogProvider{
|
|
acnt: &ac,
|
|
action: a,
|
|
cache: utils.MapStorage{},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
arg []string
|
|
exp any
|
|
err string
|
|
}{
|
|
{
|
|
name: "empty field path",
|
|
arg: []string{},
|
|
exp: nil,
|
|
err: "NOT_FOUND",
|
|
},
|
|
{
|
|
name: "AccountID case",
|
|
arg: []string{"AccountID"},
|
|
exp: "test:test",
|
|
err: "",
|
|
},
|
|
{
|
|
name: "ActionID case",
|
|
arg: []string{"ActionID"},
|
|
exp: "test",
|
|
err: "",
|
|
},
|
|
{
|
|
name: "ActionType case",
|
|
arg: []string{"ActionType"},
|
|
exp: "test",
|
|
err: "",
|
|
},
|
|
{
|
|
name: "BalanceUUID case",
|
|
arg: []string{"BalanceUUID"},
|
|
exp: "test",
|
|
err: "",
|
|
},
|
|
{
|
|
name: "BalanceID case",
|
|
arg: []string{"BalanceID"},
|
|
exp: "test",
|
|
err: "",
|
|
},
|
|
{
|
|
name: "BalanceValue case",
|
|
arg: []string{"BalanceValue"},
|
|
exp: "0",
|
|
err: "",
|
|
},
|
|
{
|
|
name: "DestinationIDs case",
|
|
arg: []string{"DestinationIDs"},
|
|
exp: cdrP.action.Balance.DestinationIDs.String(),
|
|
err: "",
|
|
},
|
|
{
|
|
name: "ExtraParameters case",
|
|
arg: []string{"ExtraParameters"},
|
|
exp: cdrP.action.ExtraParameters,
|
|
err: "",
|
|
},
|
|
{
|
|
name: "RatingSubject case",
|
|
arg: []string{"RatingSubject"},
|
|
exp: "test",
|
|
err: "",
|
|
},
|
|
{
|
|
name: "Category case",
|
|
arg: []string{"Category"},
|
|
exp: cdrP.action.Balance.Categories.String(),
|
|
err: "",
|
|
},
|
|
{
|
|
name: "SharedGroups case",
|
|
arg: []string{"SharedGroups"},
|
|
exp: cdrP.action.Balance.SharedGroups.String(),
|
|
err: "",
|
|
},
|
|
{
|
|
name: "default case",
|
|
arg: []string{"test"},
|
|
exp: "test",
|
|
err: "",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
rcv, err := cdrP.FieldAsInterface(tt.arg)
|
|
|
|
if err != nil {
|
|
if err.Error() != tt.err {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
if !reflect.DeepEqual(rcv, tt.exp) {
|
|
t.Errorf("expected %v, received %v", tt.exp, rcv)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestActionFieldAsString(t *testing.T) {
|
|
cdrP.acnt.ID = "test"
|
|
|
|
_, err := cdrP.FieldAsString([]string{"AccountID"})
|
|
|
|
if err != nil {
|
|
if err.Error() != "Unsupported format for TenantAccount: test" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestActionRemoteHost(t *testing.T) {
|
|
rcv := cdrP.RemoteHost()
|
|
|
|
if rcv.String() != "local" {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestActionresetAccountErrors(t *testing.T) {
|
|
type args struct {
|
|
ub *Account
|
|
action *Action
|
|
acts Actions
|
|
}
|
|
tests := []struct{
|
|
name string
|
|
args args
|
|
err string
|
|
}{
|
|
{
|
|
name: "nil account",
|
|
args: args{ub: nil, action: nil, acts: nil},
|
|
err: "nil account",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := resetAccount(tt.args.ub, tt.args.action, tt.args.acts, nil)
|
|
|
|
if err != nil {
|
|
if err.Error() != tt.err {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestActionremoveExpired(t *testing.T) {
|
|
sm := utils.StringMap{
|
|
"test1": bl,
|
|
}
|
|
rtm := RITiming{
|
|
Years: utils.Years{2021},
|
|
Months: utils.Months{8},
|
|
MonthDays: utils.MonthDays{28},
|
|
WeekDays: utils.WeekDays{5},
|
|
StartTime: str,
|
|
EndTime: str,
|
|
cronString: str,
|
|
tag: str,
|
|
}
|
|
blc := Balance{
|
|
Uuid: str2,
|
|
ID: str2,
|
|
Value: fl2,
|
|
ExpirationDate: tm2,
|
|
Weight: fl2,
|
|
DestinationIDs: sm,
|
|
RatingSubject: str2,
|
|
Categories: sm,
|
|
SharedGroups: sm,
|
|
Timings: []*RITiming{&rtm},
|
|
TimingIDs: sm,
|
|
Disabled: bl,
|
|
Factor: ValueFactor{str2: fl2},
|
|
Blocker: bl,
|
|
precision: nm2,
|
|
dirty: bl,
|
|
}
|
|
acc := &Account{
|
|
BalanceMap: map[string]Balances{"test1": {&blc}},
|
|
}
|
|
|
|
type args struct {
|
|
ub *Account
|
|
action *Action
|
|
acts Actions
|
|
extra any
|
|
}
|
|
tests := []struct{
|
|
name string
|
|
args args
|
|
err string
|
|
}{
|
|
{
|
|
name: "nil account",
|
|
args: args{nil, nil, nil, nil},
|
|
err: "nil account for null action",
|
|
},
|
|
{
|
|
name: "nil account",
|
|
args: args{acc, a, nil, nil},
|
|
err: "NOT_FOUND",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := removeExpired(tt.args.ub, tt.args.action, tt.args.acts, nil)
|
|
|
|
if err != nil {
|
|
if err.Error() != tt.err {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestActiontopupZeroNegativeAction(t *testing.T) {
|
|
ub := &Account{}
|
|
|
|
topupZeroNegativeAction(ub, nil, nil, nil)
|
|
|
|
if ub.BalanceMap == nil {
|
|
t.Error("didn't update")
|
|
}
|
|
}
|
|
|
|
func TestActionremoveAccountAction(t *testing.T) {
|
|
ub := &Account{
|
|
ID: "",
|
|
}
|
|
actn := &Action{
|
|
ExtraParameters: str2,
|
|
}
|
|
actn2 := &Action{
|
|
ExtraParameters: "",
|
|
}
|
|
type args struct {
|
|
ub *Account
|
|
action *Action
|
|
acts Actions
|
|
extra any
|
|
}
|
|
tests := []struct{
|
|
name string
|
|
args args
|
|
err string
|
|
}{
|
|
{
|
|
name: "error json unmarshal",
|
|
args: args{nil, actn, nil, nil},
|
|
err: "invalid character 'e' in literal true (expecting 'r')",
|
|
},
|
|
{
|
|
name: "concatenate key",
|
|
args: args{nil, actn2, nil, nil},
|
|
err: "",
|
|
},
|
|
{
|
|
name: "accID empty string",
|
|
args: args{ub, actn2, nil, nil},
|
|
err: "INVALID_KEY",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := removeAccountAction(tt.args.ub, tt.args.action, tt.args.acts, tt.args.extra)
|
|
|
|
if err != nil {
|
|
if err.Error() != tt.err {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
} |