mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
671 lines
16 KiB
Go
671 lines
16 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 (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/cgrates/birpc"
|
|
"github.com/cgrates/birpc/context"
|
|
"github.com/cgrates/cgrates/config"
|
|
"github.com/cgrates/cgrates/utils"
|
|
)
|
|
|
|
func TestBalanceSortPrecision(t *testing.T) {
|
|
mb1 := &Balance{Weight: 1, precision: 2}
|
|
mb2 := &Balance{Weight: 2, precision: 1}
|
|
var bs Balances
|
|
bs = append(bs, mb2, mb1)
|
|
bs.Sort()
|
|
if bs[0] != mb1 || bs[1] != mb2 {
|
|
t.Error("Buckets not sorted by weight!")
|
|
}
|
|
}
|
|
|
|
func TestBalanceSortPrecisionWeightEqual(t *testing.T) {
|
|
mb1 := &Balance{Weight: 1, precision: 2}
|
|
mb2 := &Balance{Weight: 1, precision: 1}
|
|
var bs Balances
|
|
bs = append(bs, mb2, mb1)
|
|
bs.Sort()
|
|
if bs[0] != mb1 || bs[1] != mb2 {
|
|
t.Error("Buckets not sorted by precision!")
|
|
}
|
|
}
|
|
|
|
func TestBalanceSortPrecisionWeightGreater(t *testing.T) {
|
|
mb1 := &Balance{Weight: 2, precision: 2}
|
|
mb2 := &Balance{Weight: 1, precision: 1}
|
|
var bs Balances
|
|
bs = append(bs, mb2, mb1)
|
|
bs.Sort()
|
|
if bs[0] != mb1 || bs[1] != mb2 {
|
|
t.Error("Buckets not sorted by precision!")
|
|
}
|
|
}
|
|
|
|
func TestBalanceSortWeight(t *testing.T) {
|
|
mb1 := &Balance{Weight: 2, precision: 1}
|
|
mb2 := &Balance{Weight: 1, precision: 1}
|
|
var bs Balances
|
|
bs = append(bs, mb2, mb1)
|
|
bs.Sort()
|
|
if bs[0] != mb1 || bs[1] != mb2 {
|
|
t.Error("Buckets not sorted by precision!")
|
|
}
|
|
}
|
|
|
|
func TestBalanceSortWeight2(t *testing.T) {
|
|
bs := Balances{
|
|
&Balance{ID: "B1", Weight: 2, precision: 1},
|
|
&Balance{ID: "B2", Weight: 1, precision: 1},
|
|
}
|
|
bs.Sort()
|
|
if bs[0].ID != "B1" && bs[1].ID != "B2" {
|
|
t.Error("Buckets not sorted by precision!")
|
|
}
|
|
}
|
|
|
|
func TestBalanceSortWeight3(t *testing.T) {
|
|
bs := Balances{
|
|
&Balance{ID: "B1", Weight: 2, Value: 10.0},
|
|
&Balance{ID: "B2", Weight: 4, Value: 10.0},
|
|
}
|
|
bs.Sort()
|
|
if bs[0].ID != "B2" && bs[1].ID != "B1" {
|
|
t.Error(utils.ToJSON(bs))
|
|
}
|
|
}
|
|
|
|
func TestBalanceSortWeightLess(t *testing.T) {
|
|
mb1 := &Balance{Weight: 1, precision: 1}
|
|
mb2 := &Balance{Weight: 2, precision: 1}
|
|
var bs Balances
|
|
bs = append(bs, mb2, mb1)
|
|
bs.Sort()
|
|
if bs[0] != mb2 || bs[1] != mb1 {
|
|
t.Error("Buckets not sorted by precision!")
|
|
}
|
|
}
|
|
|
|
func TestBalanceEqual(t *testing.T) {
|
|
mb1 := &Balance{Weight: 1, precision: 1, RatingSubject: "1", DestinationIDs: utils.StringMap{}}
|
|
mb2 := &Balance{Weight: 1, precision: 1, RatingSubject: "1", DestinationIDs: utils.StringMap{}}
|
|
mb3 := &Balance{Weight: 1, precision: 1, RatingSubject: "2", DestinationIDs: utils.StringMap{}}
|
|
if !mb1.Equal(mb2) || mb2.Equal(mb3) {
|
|
t.Error("Equal failure!", mb1 == mb2, mb3)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchFilter(t *testing.T) {
|
|
mb1 := &Balance{Weight: 1, precision: 1, RatingSubject: "1", DestinationIDs: utils.StringMap{}}
|
|
mb2 := &BalanceFilter{Weight: utils.Float64Pointer(1), RatingSubject: nil, DestinationIDs: nil}
|
|
if !mb1.MatchFilter(mb2, false, false) {
|
|
t.Errorf("Match filter failure: %+v == %+v", mb1, mb2)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchFilterEmpty(t *testing.T) {
|
|
mb1 := &Balance{Weight: 1, precision: 1, RatingSubject: "1", DestinationIDs: utils.StringMap{}}
|
|
mb2 := &BalanceFilter{}
|
|
if !mb1.MatchFilter(mb2, false, false) {
|
|
t.Errorf("Match filter failure: %+v == %+v", mb1, mb2)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchFilterId(t *testing.T) {
|
|
mb1 := &Balance{ID: "T1", Weight: 2, precision: 2, RatingSubject: "2", DestinationIDs: utils.NewStringMap("NAT")}
|
|
mb2 := &BalanceFilter{ID: utils.StringPointer("T1"), Weight: utils.Float64Pointer(1), RatingSubject: utils.StringPointer("1"), DestinationIDs: nil}
|
|
if !mb1.MatchFilter(mb2, false, false) {
|
|
t.Errorf("Match filter failure: %+v == %+v", mb1, mb2)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchFilterDiffId(t *testing.T) {
|
|
mb1 := &Balance{ID: "T1", Weight: 1, precision: 1, RatingSubject: "1", DestinationIDs: utils.StringMap{}}
|
|
mb2 := &BalanceFilter{ID: utils.StringPointer("T2"), Weight: utils.Float64Pointer(1), RatingSubject: utils.StringPointer("1"), DestinationIDs: nil}
|
|
if mb1.MatchFilter(mb2, false, false) {
|
|
t.Errorf("Match filter failure: %+v != %+v", mb1, mb2)
|
|
}
|
|
}
|
|
|
|
func TestBalanceClone(t *testing.T) {
|
|
mb1 := &Balance{Value: 1, Weight: 2, RatingSubject: "test", DestinationIDs: utils.NewStringMap("5")}
|
|
mb2 := mb1.Clone()
|
|
if mb1 == mb2 || !mb1.Equal(mb2) {
|
|
t.Errorf("Cloning failure: \n%+v\n%+v", mb1, mb2)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchActionTriggerId(t *testing.T) {
|
|
at := &ActionTrigger{Balance: &BalanceFilter{ID: utils.StringPointer("test")}}
|
|
b := &Balance{ID: "test"}
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.ID = "test1"
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.ID = ""
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.ID = "test"
|
|
at.Balance.ID = nil
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchActionTriggerDestination(t *testing.T) {
|
|
at := &ActionTrigger{Balance: &BalanceFilter{DestinationIDs: utils.StringMapPointer(utils.NewStringMap("test"))}}
|
|
b := &Balance{DestinationIDs: utils.NewStringMap("test")}
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.DestinationIDs = utils.NewStringMap("test1")
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.DestinationIDs = utils.NewStringMap("")
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.DestinationIDs = utils.NewStringMap("test")
|
|
at.Balance.DestinationIDs = nil
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchActionTriggerWeight(t *testing.T) {
|
|
at := &ActionTrigger{Balance: &BalanceFilter{Weight: utils.Float64Pointer(1)}}
|
|
b := &Balance{Weight: 1}
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.Weight = 2
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.Weight = 0
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.Weight = 1
|
|
at.Balance.Weight = nil
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchActionTriggerRatingSubject(t *testing.T) {
|
|
at := &ActionTrigger{Balance: &BalanceFilter{RatingSubject: utils.StringPointer("test")}}
|
|
b := &Balance{RatingSubject: "test"}
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.RatingSubject = "test1"
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.RatingSubject = ""
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.RatingSubject = "test"
|
|
at.Balance.RatingSubject = nil
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
}
|
|
|
|
func TestBalanceMatchActionTriggerSharedGroup(t *testing.T) {
|
|
at := &ActionTrigger{Balance: &BalanceFilter{SharedGroups: utils.StringMapPointer(utils.NewStringMap("test"))}}
|
|
b := &Balance{SharedGroups: utils.NewStringMap("test")}
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.SharedGroups = utils.NewStringMap("test1")
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.SharedGroups = utils.NewStringMap("")
|
|
if b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
b.SharedGroups = utils.NewStringMap("test")
|
|
at.Balance.SharedGroups = nil
|
|
if !b.MatchActionTrigger(at) {
|
|
t.Errorf("Error matching action trigger: %+v %+v", b, at)
|
|
}
|
|
}
|
|
|
|
func TestBalanceIsDefault(t *testing.T) {
|
|
b := &Balance{Weight: 0}
|
|
if b.IsDefault() {
|
|
t.Errorf("Balance should not be default: %+v", b)
|
|
}
|
|
b = &Balance{ID: utils.MetaDefault}
|
|
if !b.IsDefault() {
|
|
t.Errorf("Balance should be default: %+v", b)
|
|
}
|
|
}
|
|
|
|
func TestBalanceIsExpiredAt(t *testing.T) {
|
|
//expiration date is 0
|
|
balance := &Balance{}
|
|
var date2 time.Time
|
|
if rcv := balance.IsExpiredAt(date2); rcv {
|
|
t.Errorf("Expecting: false , received: %+v", rcv)
|
|
}
|
|
//expiration date before time t
|
|
balance.ExpirationDate = time.Date(2020, time.April, 18, 23, 0, 3, 0, time.UTC)
|
|
date2 = time.Date(2020, time.April, 18, 23, 0, 4, 0, time.UTC)
|
|
if rcv := balance.IsExpiredAt(date2); !rcv {
|
|
t.Errorf("Expecting: true , received: %+v", rcv)
|
|
}
|
|
//expiration date after time t
|
|
date2 = time.Date(2020, time.April, 18, 23, 0, 2, 0, time.UTC)
|
|
if rcv := balance.IsExpiredAt(date2); rcv {
|
|
t.Errorf("Expecting: false , received: %+v", rcv)
|
|
}
|
|
//time t = 0
|
|
var date3 time.Time
|
|
if rcv := balance.IsExpiredAt(date3); rcv {
|
|
t.Errorf("Expecting: false , received: %+v", rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalancesSaveDirtyBalances(t *testing.T) {
|
|
cfg, _ := config.NewDefaultCGRConfig()
|
|
tmpDm := dm
|
|
tmpConn := connMgr
|
|
defer func() {
|
|
cfg2, _ := config.NewDefaultCGRConfig()
|
|
config.SetCgrConfig(cfg2)
|
|
dm = tmpDm
|
|
connMgr = tmpConn
|
|
}()
|
|
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
|
|
dm := NewDataManager(db, cfg.CacheCfg(), nil)
|
|
|
|
cfg.RalsCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
|
|
clientConn := make(chan birpc.ClientConnector, 1)
|
|
clientConn <- &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.ThresholdSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
return nil
|
|
},
|
|
},
|
|
}
|
|
connMgr := NewConnManager(cfg, map[string]chan birpc.ClientConnector{
|
|
utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds): clientConn,
|
|
})
|
|
acc := &Account{
|
|
ID: "cgrates.org:cond",
|
|
BalanceMap: map[string]Balances{
|
|
utils.MONETARY: {
|
|
&Balance{
|
|
Uuid: utils.GenUUID(),
|
|
Value: 1,
|
|
Weight: 10,
|
|
},
|
|
&Balance{
|
|
Uuid: utils.GenUUID(),
|
|
Value: 6,
|
|
Weight: 20,
|
|
},
|
|
},
|
|
utils.VOICE: {
|
|
&Balance{
|
|
Uuid: utils.GenUUID(),
|
|
Value: 10,
|
|
Weight: 10,
|
|
},
|
|
&Balance{
|
|
Uuid: utils.GenUUID(),
|
|
Value: 100,
|
|
Weight: 20,
|
|
},
|
|
},
|
|
}}
|
|
bAcc := &Account{
|
|
ID: "cgrates.org:max",
|
|
BalanceMap: map[string]Balances{
|
|
utils.MONETARY: {
|
|
&Balance{Value: 11, Weight: 20},
|
|
}},
|
|
}
|
|
bc := Balances{
|
|
&Balance{Value: 200 * float64(time.Second),
|
|
DestinationIDs: utils.NewStringMap("NAT"), Weight: 10,
|
|
dirty: true,
|
|
account: bAcc,
|
|
},
|
|
}
|
|
config.SetCgrConfig(cfg)
|
|
SetDataStorage(dm)
|
|
SetConnManager(connMgr)
|
|
bc.SaveDirtyBalances(acc)
|
|
if _, err := dm.GetAccount("cgrates.org:max"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestBalancePublish(t *testing.T) {
|
|
cfg, _ := config.NewDefaultCGRConfig()
|
|
tmpDm := dm
|
|
tmpConn := connMgr
|
|
defer func() {
|
|
cfg2, _ := config.NewDefaultCGRConfig()
|
|
config.SetCgrConfig(cfg2)
|
|
SetDataStorage(tmpDm)
|
|
SetConnManager(tmpConn)
|
|
}()
|
|
cfg.RalsCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats)}
|
|
cfg.RalsCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
|
|
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
|
|
dm := NewDataManager(db, cfg.CacheCfg(), nil)
|
|
clientConn := make(chan birpc.ClientConnector, 1)
|
|
clientConn <- clMock(func(ctx *context.Context, serviceMethod string, _, _ any) error {
|
|
if serviceMethod == utils.StatSv1ProcessEvent {
|
|
|
|
return nil
|
|
} else if serviceMethod == utils.ThresholdSv1ProcessEvent {
|
|
|
|
return nil
|
|
}
|
|
return utils.ErrNotImplemented
|
|
})
|
|
connMgr := NewConnManager(cfg, map[string]chan birpc.ClientConnector{
|
|
utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats): clientConn,
|
|
utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds): clientConn,
|
|
})
|
|
SetConnManager(connMgr)
|
|
at := &ActionTrigger{
|
|
UniqueID: "TestTR5",
|
|
ThresholdType: utils.TRIGGER_MAX_BALANCE,
|
|
Balance: &BalanceFilter{
|
|
Type: utils.StringPointer(utils.VOICE),
|
|
Weight: utils.Float64Pointer(10),
|
|
},
|
|
ActionsID: "ACT_1",
|
|
}
|
|
ub := &Account{
|
|
ID: "cgrates.org:1001",
|
|
BalanceMap: map[string]Balances{
|
|
utils.VOICE: {
|
|
{
|
|
Value: 10,
|
|
DestinationIDs: utils.NewStringMap("DEST"),
|
|
},
|
|
},
|
|
},
|
|
}
|
|
dm.SetActions("ACT_1", Actions{
|
|
&Action{
|
|
ActionType: utils.MetaPublishBalance,
|
|
Balance: &BalanceFilter{
|
|
Type: utils.StringPointer(utils.VOICE),
|
|
Value: &utils.ValueFormula{Static: 15},
|
|
},
|
|
},
|
|
}, utils.NonTransactional)
|
|
config.SetCgrConfig(cfg)
|
|
SetDataStorage(dm)
|
|
if err := at.Execute(ub); err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
}
|
|
|
|
func TestBalancesMatchFilter(t *testing.T) {
|
|
b := Balance{
|
|
ID: "test",
|
|
}
|
|
|
|
rcv := b.MatchFilter(nil, false, false)
|
|
|
|
if rcv != true {
|
|
t.Error(rcv)
|
|
}
|
|
|
|
str := "test"
|
|
bf := BalanceFilter{
|
|
ID: &str,
|
|
Uuid: &str,
|
|
}
|
|
|
|
rcv = b.MatchFilter(&bf, false, false)
|
|
|
|
if rcv != false {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalancesHardMatchFilter(t *testing.T) {
|
|
b := Balance{
|
|
ID: "test",
|
|
}
|
|
|
|
rcv := b.HardMatchFilter(nil, false)
|
|
|
|
if rcv != true {
|
|
t.Error(rcv)
|
|
}
|
|
|
|
str := "test"
|
|
bf := BalanceFilter{
|
|
ID: &str,
|
|
Uuid: &str,
|
|
}
|
|
|
|
rcv = b.HardMatchFilter(&bf, false)
|
|
|
|
if rcv != false {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalancesIsActive(t *testing.T) {
|
|
b := Balance{
|
|
Disabled: true,
|
|
}
|
|
|
|
tm := time.Now()
|
|
rcv := b.IsActiveAt(tm)
|
|
|
|
if rcv != false {
|
|
t.Error(rcv)
|
|
}
|
|
|
|
b2 := Balance{
|
|
Disabled: false,
|
|
Timings: []*RITiming{
|
|
{
|
|
Years: utils.Years{2020, 2022},
|
|
Months: utils.Months{time.Now().Month()},
|
|
MonthDays: utils.MonthDays{time.Now().Day()},
|
|
WeekDays: utils.WeekDays{time.Now().Weekday()},
|
|
StartTime: "00:00:00",
|
|
EndTime: "00:00:01",
|
|
cronString: "test",
|
|
tag: "test",
|
|
},
|
|
},
|
|
}
|
|
|
|
tm2 := time.Now()
|
|
rcv = b2.IsActiveAt(tm2)
|
|
|
|
if rcv != false {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalancesHasDestination(t *testing.T) {
|
|
b := Balance{
|
|
DestinationIDs: utils.StringMap{"*any": false},
|
|
}
|
|
|
|
rcv := b.HasDestination()
|
|
|
|
if rcv != true {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalancesMatchDestination(t *testing.T) {
|
|
|
|
b := Balance{
|
|
DestinationIDs: utils.StringMap{
|
|
"*any": false,
|
|
"test": true,
|
|
},
|
|
}
|
|
|
|
rcv := b.MatchDestination("test")
|
|
|
|
if rcv != true {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalancegetMatchingPrefixAndDestID(t *testing.T) {
|
|
b := Balance{}
|
|
|
|
pre, dest := b.getMatchingPrefixAndDestID("")
|
|
|
|
if pre != "" && dest != "" {
|
|
t.Error(pre, dest)
|
|
}
|
|
}
|
|
|
|
func TestBalancesEqual(t *testing.T) {
|
|
b := Balances{}
|
|
|
|
o := Balances{{}, {}}
|
|
|
|
rcv := b.Equal(o)
|
|
|
|
if rcv != false {
|
|
t.Error(rcv)
|
|
}
|
|
|
|
b2 := Balances{{
|
|
Uuid: "test",
|
|
ID: "test",
|
|
}}
|
|
|
|
o2 := Balances{{
|
|
Uuid: "test2",
|
|
ID: "test2",
|
|
}}
|
|
|
|
rcv = b2.Equal(o2)
|
|
|
|
if rcv != false {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalanceHasBalance(t *testing.T) {
|
|
bc := Balances{}
|
|
b := Balance{}
|
|
|
|
rcv := bc.HasBalance(&b)
|
|
|
|
if rcv != false {
|
|
t.Error(rcv)
|
|
}
|
|
|
|
bc2 := Balances{&b}
|
|
|
|
rcv = bc2.HasBalance(&b)
|
|
|
|
if rcv != true {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalancesGetValue(t *testing.T) {
|
|
f := ValueFactor{}
|
|
|
|
rcv := f.GetValue("test")
|
|
|
|
if rcv != 1.0 {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalancesFieldAsInterface(t *testing.T) {
|
|
bl := BalanceSummary{}
|
|
flp := []string{}
|
|
|
|
rcv, err := bl.FieldAsInterface(flp)
|
|
|
|
if err != utils.ErrNotFound {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
|
|
bl2 := BalanceSummary{}
|
|
flp2 := []string{"test"}
|
|
|
|
rcv, err = bl2.FieldAsInterface(flp2)
|
|
|
|
if err.Error() != "unsupported field prefix: <test>" {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
|
|
bl3 := BalanceSummary{
|
|
Disabled: true,
|
|
}
|
|
flp3 := []string{"Disabled"}
|
|
|
|
rcv, err = bl3.FieldAsInterface(flp3)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if rcv != true {
|
|
t.Error(rcv)
|
|
}
|
|
}
|
|
|
|
func TestBalanceCloneNil(t *testing.T) {
|
|
var b *Balance
|
|
|
|
rcv := b.Clone()
|
|
|
|
if rcv != nil {
|
|
t.Error(rcv)
|
|
}
|
|
}
|