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

Add cover tests in apis

Browse Source
This commit is contained in:
ionutboangiu
2022-03-15 18:28:54 +02:00
committed by Dan Christian Bogos
parent 5b92f15bb2
commit 193ecb5ef6
5 changed files with 914 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

493
apis/chargers_test.go
View File

@@ -29,158 +29,6 @@ import (
"github.com/cgrates/cgrates/utils"
)
func TestChargerSSetGetChargerProfile(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
connMgr := engine.NewConnManager(cfg)
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
ext := &ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "1001",
RunID: utils.MetaDefault,
FilterIDs: []string{"*string:~*req.Account:1001"},
AttributeIDs: []string{"*none"},
Weights: utils.DynamicWeights{
{
Weight: 20,
},
},
},
APIOpts: nil,
}
var setRply string
err := admS.SetChargerProfile(context.Background(), ext, &setRply)
if err != nil {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
}
if !reflect.DeepEqual(setRply, `OK`) {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", `OK`, utils.ToJSON(setRply))
}
var getRply engine.ChargerProfile
err = admS.GetChargerProfile(context.Background(),
&utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{
Tenant: "cgrates.org",
ID: "1001",
},
APIOpts: map[string]interface{}{},
}, &getRply)
if err != nil {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
}
expectedGet := engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "1001",
RunID: utils.MetaDefault,
FilterIDs: []string{"*string:~*req.Account:1001"},
AttributeIDs: []string{"*none"},
Weights: utils.DynamicWeights{
{
Weight: 20,
},
},
}
if !reflect.DeepEqual(getRply, expectedGet) {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(expectedGet), utils.ToJSON(getRply))
}
}
func TestChargerSSetGetChargerProfileErrMissingID(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
connMgr := engine.NewConnManager(cfg)
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
ext := &ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "1001",
RunID: utils.MetaDefault,
FilterIDs: []string{"*string:~*req.Account:1001"},
AttributeIDs: []string{"*none"},
Weights: utils.DynamicWeights{
{
Weight: 20,
},
},
},
APIOpts: nil,
}
var setRply string
err := admS.SetChargerProfile(context.Background(), ext, &setRply)
if err != nil {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
}
if !reflect.DeepEqual(setRply, `OK`) {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", `OK`, utils.ToJSON(setRply))
}
var getRply engine.ChargerProfile
err = admS.GetChargerProfile(context.Background(),
&utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{
Tenant: "cgrates.org",
ID: "1001",
},
APIOpts: map[string]interface{}{},
}, &getRply)
if err != nil {
t.Error(err)
}
}
func TestChargerSSetGetChargerProfileErrNotFound(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
connMgr := engine.NewConnManager(cfg)
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
ext := &ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
ID: "1001",
RunID: utils.MetaDefault,
FilterIDs: []string{"*string:~*req.Account:1001"},
AttributeIDs: []string{"*none"},
Weights: utils.DynamicWeights{
{
Weight: 20,
},
},
},
APIOpts: nil,
}
var setRply string
err := admS.SetChargerProfile(context.Background(), ext, &setRply)
if err != nil {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
}
if !reflect.DeepEqual(setRply, `OK`) {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", `OK`, utils.ToJSON(setRply))
}
var getRply engine.ChargerProfile
err = admS.GetChargerProfile(context.Background(),
&utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{
Tenant: "cgrates.org",
ID: "1001",
},
APIOpts: map[string]interface{}{},
}, &getRply)
if err != nil {
t.Error(err)
}
}
func TestChargerSSetChargerProfileErrMissingID(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
@@ -906,3 +754,344 @@ func TestChargersGetChargerProfilesOK(t *testing.T) {
}
}
}
func TestChargersGetChargerProfilesGetIDsErr(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
connMgr := engine.NewConnManager(cfg)
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
args := &ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "test_ID1",
Weights: utils.DynamicWeights{
{
Weight: 10,
},
},
},
APIOpts: nil,
}
var setReply string
if err := admS.SetChargerProfile(context.Background(), args, &setReply); err != nil {
t.Error(err)
} else if setReply != "OK" {
t.Error("Unexpected reply returned:", setReply)
}
argsGet := &utils.ArgsItemIDs{
Tenant: "cgrates.org",
ItemsPrefix: "test_ID",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: 2,
utils.PageOffsetOpt: 4,
utils.PageMaxItemsOpt: 5,
},
}
experr := `SERVER_ERROR: maximum number of items exceeded`
var getReply []*engine.ChargerProfile
if err := admS.GetChargerProfiles(context.Background(), argsGet, &getReply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
}
func TestChargersGetChargerProfilesGetProfileErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
SetChargerProfileDrvF: func(*context.Context, *engine.ChargerProfile) error {
return nil
},
RemoveChargerProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"chp_cgrates.org:TEST"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []*engine.ChargerProfile
experr := "SERVER_ERROR: NOT_IMPLEMENTED"
if err := adms.GetChargerProfiles(context.Background(),
&utils.ArgsItemIDs{
ItemsPrefix: "TEST",
}, &reply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestChargersGetChargerProfileIDsGetOptsErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
GetChargerProfileDrvF: func(*context.Context, string, string) (*engine.ChargerProfile, error) {
chrgPrf := &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "TEST",
}
return chrgPrf, nil
},
SetChargerProfileDrvF: func(*context.Context, *engine.ChargerProfile) error {
return nil
},
RemoveChargerProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"cpp_cgrates.org:key1", "cpp_cgrates.org:key2", "cpp_cgrates.org:key3"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []string
experr := "cannot convert field<bool>: true to int"
if err := adms.GetChargerProfileIDs(context.Background(),
&utils.ArgsItemIDs{
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: true,
},
}, &reply); err == nil || err.Error() != experr {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestChargersGetChargerProfileIDsPaginateErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
GetChargerProfileDrvF: func(*context.Context, string, string) (*engine.ChargerProfile, error) {
chrgPrf := &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "TEST",
}
return chrgPrf, nil
},
SetChargerProfileDrvF: func(*context.Context, *engine.ChargerProfile) error {
return nil
},
RemoveChargerProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"cpp_cgrates.org:key1", "cpp_cgrates.org:key2", "cpp_cgrates.org:key3"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []string
experr := `SERVER_ERROR: maximum number of items exceeded`
if err := adms.GetChargerProfileIDs(context.Background(),
&utils.ArgsItemIDs{
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: 2,
utils.PageOffsetOpt: 4,
utils.PageMaxItemsOpt: 5,
},
}, &reply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestChargersGetChargerProfilesCountErrMock(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
GetChargerProfileDrvF: func(*context.Context, string, string) (*engine.ChargerProfile, error) {
chrgPrf := &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "TEST",
}
return chrgPrf, nil
},
SetChargerProfileDrvF: func(*context.Context, *engine.ChargerProfile) error {
return nil
},
RemoveChargerProfileDrvF: func(*context.Context, string, string) error {
return nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply int
if err := adms.GetChargerProfilesCount(context.Background(),
&utils.ArgsItemIDs{
Tenant: "cgrates.org",
}, &reply); err == nil || err != utils.ErrNotImplemented {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotImplemented, err)
}
}
func TestChargersGetChargerProfilesCountErrKeys(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply int
if err := adms.GetChargerProfilesCount(context.Background(),
&utils.ArgsItemIDs{
Tenant: "cgrates.org",
}, &reply); err == nil || err != utils.ErrNotFound {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
}
}
func TestChargersSetGetRemChargerProfile(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
arg := &utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{
ID: "chrgPrf",
},
}
var result engine.ChargerProfile
var reply string
chrgPrf := &ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "chrgPrf",
FilterIDs: []string{"*string:~*req.Account:1001"},
Weights: utils.DynamicWeights{
{
Weight: 10,
},
},
},
}
if err := adms.SetChargerProfile(context.Background(), chrgPrf, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("expected: <%+v>, received: <%+v>", utils.OK, reply)
}
if err := adms.GetChargerProfile(context.Background(), arg, &result); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(result, *chrgPrf.ChargerProfile) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
utils.ToJSON(chrgPrf.ChargerProfile), utils.ToJSON(result))
}
var thPrfIDs []string
expThPrfIDs := []string{"chrgPrf"}
if err := adms.GetChargerProfileIDs(context.Background(), &utils.ArgsItemIDs{},
&thPrfIDs); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(thPrfIDs, expThPrfIDs) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", expThPrfIDs, thPrfIDs)
}
var rplyCount int
if err := adms.GetChargerProfilesCount(context.Background(), &utils.ArgsItemIDs{},
&rplyCount); err != nil {
t.Error(err)
} else if rplyCount != len(thPrfIDs) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", len(thPrfIDs), rplyCount)
}
if err := adms.RemoveChargerProfile(context.Background(), arg, &reply); err != nil {
t.Error(err)
}
engine.Cache.Clear(nil)
if err := adms.GetChargerProfile(context.Background(), arg, &result); err == nil ||
err != utils.ErrNotFound {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestChargersGetChargerProfileCheckErrors(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var rcv engine.ChargerProfile
experr := "MANDATORY_IE_MISSING: [ID]"
if err := adms.GetChargerProfile(context.Background(), &utils.TenantIDWithAPIOpts{}, &rcv); err == nil ||
err.Error() != experr {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err)
}
adms.dm = nil
experr = "SERVER_ERROR: NO_DATABASE_CONNECTION"
arg := &utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{
ID: "TestChargersGetChargerProfileCheckErrors",
},
}
if err := adms.GetChargerProfile(context.Background(), arg, &rcv); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}

157
apis/dispatchers_test.go
View File

@@ -1272,3 +1272,160 @@ func TestDispatchersGetDispatcherHostsCountErrKeys(t *testing.T) {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
}
}
func TestDispatchersGetDispatcherProfilesGetIDsErr(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
connMgr := engine.NewConnManager(cfg)
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
args := &DispatcherWithAPIOpts{
DispatcherProfile: &engine.DispatcherProfile{
Tenant: "cgrates.org",
ID: "test_ID1",
Hosts: engine.DispatcherHostProfiles{
{
ID: "Host1",
},
},
Weight: 10,
},
APIOpts: nil,
}
var setReply string
if err := admS.SetDispatcherProfile(context.Background(), args, &setReply); err != nil {
t.Error(err)
} else if setReply != "OK" {
t.Error("Unexpected reply returned:", setReply)
}
argsGet := &utils.ArgsItemIDs{
Tenant: "cgrates.org",
ItemsPrefix: "test_ID",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: 2,
utils.PageOffsetOpt: 4,
utils.PageMaxItemsOpt: 5,
},
}
experr := `SERVER_ERROR: maximum number of items exceeded`
var getReply []*engine.DispatcherProfile
if err := admS.GetDispatcherProfiles(context.Background(), argsGet, &getReply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
}
func TestDispatchersGetDispatcherProfilesGetProfileErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
SetDispatcherProfileDrvF: func(*context.Context, *engine.DispatcherProfile) error {
return nil
},
RemoveDispatcherProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"dpp_cgrates.org:TEST"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []*engine.DispatcherProfile
experr := "SERVER_ERROR: NOT_IMPLEMENTED"
if err := adms.GetDispatcherProfiles(context.Background(),
&utils.ArgsItemIDs{
ItemsPrefix: "TEST",
}, &reply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestDispatchersGetDispatcherHostsGetIDsErr(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
connMgr := engine.NewConnManager(cfg)
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
args := &engine.DispatcherHostWithAPIOpts{
DispatcherHost: &engine.DispatcherHost{
Tenant: "cgrates.org",
RemoteHost: &config.RemoteHost{
ID: "test_ID1",
Reconnects: -1,
},
},
APIOpts: nil,
}
var setReply string
if err := admS.SetDispatcherHost(context.Background(), args, &setReply); err != nil {
t.Error(err)
} else if setReply != "OK" {
t.Error("Unexpected reply returned:", setReply)
}
argsGet := &utils.ArgsItemIDs{
Tenant: "cgrates.org",
ItemsPrefix: "test_ID",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: 2,
utils.PageOffsetOpt: 4,
utils.PageMaxItemsOpt: 5,
},
}
experr := `SERVER_ERROR: maximum number of items exceeded`
var getReply []*engine.DispatcherHost
if err := admS.GetDispatcherHosts(context.Background(), argsGet, &getReply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
}
func TestDispatchersGetDispatcherHostsGetHostErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
SetDispatcherHostDrvF: func(*context.Context, *engine.DispatcherHost) error {
return nil
},
RemoveDispatcherHostDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"dph_cgrates.org:TEST"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []*engine.DispatcherHost
experr := "SERVER_ERROR: NOT_IMPLEMENTED"
if err := adms.GetDispatcherHosts(context.Background(),
&utils.ArgsItemIDs{
ItemsPrefix: "TEST",
}, &reply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}

197
apis/routes_test.go
View File

@@ -157,12 +157,25 @@ func TestRoutesSetRouteProfileCheckErrors(t *testing.T) {
rtPrf := &engine.RouteProfileWithAPIOpts{
RouteProfile: &engine.RouteProfile{
Routes: []*engine.Route{{}},
ID: "ROUTE1",
},
}
var reply string
experr := "MANDATORY_IE_MISSING: [ID]"
experr := "MANDATORY_IE_MISSING: [Routes]"
if err := adms.SetRouteProfile(context.Background(), rtPrf, &reply); err == nil ||
err.Error() != experr {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err)
}
rtPrf = &engine.RouteProfileWithAPIOpts{
RouteProfile: &engine.RouteProfile{
Routes: []*engine.Route{{}},
},
}
experr = "MANDATORY_IE_MISSING: [ID]"
if err := adms.SetRouteProfile(context.Background(), rtPrf, &reply); err == nil ||
err.Error() != experr {
@@ -313,6 +326,9 @@ func TestRoutesRemoveRouteProfileCheckErrors(t *testing.T) {
SetIndexesDrvF: func(ctx *context.Context, idxItmType, tntCtx string, indexes map[string]utils.StringSet, commit bool, transactionID string) (err error) {
return nil
},
GetIndexesDrvF: func(ctx *context.Context, idxItmType, tntCtx, idxKey, transactionID string) (indexes map[string]utils.StringSet, err error) {
return map[string]utils.StringSet{}, nil
},
}
engine.Cache.Clear(nil)
@@ -617,3 +633,180 @@ func TestRoutesGetRouteProfilesOK(t *testing.T) {
}
}
}
func TestRoutesGetRouteProfilesGetIDsErr(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
connMgr := engine.NewConnManager(cfg)
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
args := &engine.RouteProfileWithAPIOpts{
RouteProfile: &engine.RouteProfile{
Tenant: "cgrates.org",
ID: "test_ID1",
Sorting: utils.MetaWeight,
Routes: []*engine.Route{
{
ID: "ROUTE1",
},
},
Weights: utils.DynamicWeights{
{
Weight: 10,
},
},
},
APIOpts: nil,
}
var setReply string
if err := admS.SetRouteProfile(context.Background(), args, &setReply); err != nil {
t.Error(err)
} else if setReply != "OK" {
t.Error("Unexpected reply returned:", setReply)
}
argsGet := &utils.ArgsItemIDs{
Tenant: "cgrates.org",
ItemsPrefix: "test_ID",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: 2,
utils.PageOffsetOpt: 4,
utils.PageMaxItemsOpt: 5,
},
}
experr := `SERVER_ERROR: maximum number of items exceeded`
var getReply []*engine.RouteProfile
if err := admS.GetRouteProfiles(context.Background(), argsGet, &getReply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
}
func TestRoutesGetRouteProfilesGetProfileErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
SetRouteProfileDrvF: func(*context.Context, *engine.RouteProfile) error {
return nil
},
RemoveRouteProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"rpp_cgrates.org:TEST"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []*engine.RouteProfile
experr := "SERVER_ERROR: NOT_IMPLEMENTED"
if err := adms.GetRouteProfiles(context.Background(),
&utils.ArgsItemIDs{
ItemsPrefix: "TEST",
}, &reply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestRoutesGetRouteProfileIDsGetOptsErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
GetRouteProfileDrvF: func(*context.Context, string, string) (*engine.RouteProfile, error) {
routePrf := &engine.RouteProfile{
Tenant: "cgrates.org",
ID: "TEST",
}
return routePrf, nil
},
SetRouteProfileDrvF: func(*context.Context, *engine.RouteProfile) error {
return nil
},
RemoveRouteProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"rpp_cgrates.org:key1", "rpp_cgrates.org:key2", "rpp_cgrates.org:key3"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []string
experr := "cannot convert field<bool>: true to int"
if err := adms.GetRouteProfileIDs(context.Background(),
&utils.ArgsItemIDs{
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: true,
},
}, &reply); err == nil || err.Error() != experr {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestRoutesGetRouteProfileIDsPaginateErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
GetRouteProfileDrvF: func(*context.Context, string, string) (*engine.RouteProfile, error) {
routePrf := &engine.RouteProfile{
Tenant: "cgrates.org",
ID: "TEST",
}
return routePrf, nil
},
SetRouteProfileDrvF: func(*context.Context, *engine.RouteProfile) error {
return nil
},
RemoveRouteProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"rpp_cgrates.org:key1", "rpp_cgrates.org:key2", "rpp_cgrates.org:key3"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []string
experr := `SERVER_ERROR: maximum number of items exceeded`
if err := adms.GetRouteProfileIDs(context.Background(),
&utils.ArgsItemIDs{
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: 2,
utils.PageOffsetOpt: 4,
utils.PageMaxItemsOpt: 5,
},
}, &reply); err == nil || err.Error() != experr {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}

183
apis/stats_test.go
View File

@@ -313,6 +313,9 @@ func TestStatsRemoveStatQueueProfileCheckErrors(t *testing.T) {
RemStatQueueDrvF: func(ctx *context.Context, tenant, id string) (err error) {
return nil
},
GetIndexesDrvF: func(ctx *context.Context, idxItmType, tntCtx, idxKey, transactionID string) (indexes map[string]utils.StringSet, err error) {
return map[string]utils.StringSet{}, nil
},
}
adms.dm = engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
@@ -395,6 +398,98 @@ func TestStatsGetStatQueueProfileIDsErrKeys(t *testing.T) {
dm.DataDB().Flush(utils.EmptyString)
}
func TestStatQueuesGetStatQueueProfileIDsGetOptsErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
GetStatQueueProfileDrvF: func(*context.Context, string, string) (*engine.StatQueueProfile, error) {
sqPrf := &engine.StatQueueProfile{
Tenant: "cgrates.org",
ID: "TEST",
}
return sqPrf, nil
},
SetStatQueueProfileDrvF: func(*context.Context, *engine.StatQueueProfile) error {
return nil
},
RemStatQueueProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"thp_cgrates.org:key1", "thp_cgrates.org:key2", "thp_cgrates.org:key3"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []string
experr := "cannot convert field<bool>: true to int"
if err := adms.GetStatQueueProfileIDs(context.Background(),
&utils.ArgsItemIDs{
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: true,
},
}, &reply); err == nil || err.Error() != experr {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestStatQueuesGetStatQueueProfileIDsPaginateErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
GetStatQueueProfileDrvF: func(*context.Context, string, string) (*engine.StatQueueProfile, error) {
sqPrf := &engine.StatQueueProfile{
Tenant: "cgrates.org",
ID: "TEST",
}
return sqPrf, nil
},
SetStatQueueProfileDrvF: func(*context.Context, *engine.StatQueueProfile) error {
return nil
},
RemStatQueueProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"dpp_cgrates.org:key1", "dpp_cgrates.org:key2", "dpp_cgrates.org:key3"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []string
experr := `SERVER_ERROR: maximum number of items exceeded`
if err := adms.GetStatQueueProfileIDs(context.Background(),
&utils.ArgsItemIDs{
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: 2,
utils.PageOffsetOpt: 4,
utils.PageMaxItemsOpt: 5,
},
}, &reply); err == nil || err.Error() != experr {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}
func TestStatsGetStatQueueProfilesCountErrMock(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
@@ -905,3 +1000,91 @@ func TestStatQueuesGetStatQueueProfilesOK(t *testing.T) {
}
}
}
func TestStatQueuesGetStatQueueProfilesGetIDsErr(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
connMgr := engine.NewConnManager(cfg)
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
args := &engine.StatQueueProfileWithAPIOpts{
StatQueueProfile: &engine.StatQueueProfile{
Tenant: "cgrates.org",
ID: "test_ID1",
QueueLength: 10,
MinItems: 2,
ThresholdIDs: []string{utils.MetaNone},
Metrics: []*engine.MetricWithFilters{
{
MetricID: utils.MetaACD,
},
},
Stored: true,
Weights: utils.DynamicWeights{
{
Weight: 10,
},
},
},
APIOpts: nil,
}
var setReply string
if err := admS.SetStatQueueProfile(context.Background(), args, &setReply); err != nil {
t.Error(err)
} else if setReply != "OK" {
t.Error("Unexpected reply returned:", setReply)
}
argsGet := &utils.ArgsItemIDs{
Tenant: "cgrates.org",
ItemsPrefix: "test_ID",
APIOpts: map[string]interface{}{
utils.PageLimitOpt: 2,
utils.PageOffsetOpt: 4,
utils.PageMaxItemsOpt: 5,
},
}
experr := `SERVER_ERROR: maximum number of items exceeded`
var getReply []*engine.StatQueueProfile
if err := admS.GetStatQueueProfiles(context.Background(), argsGet, &getReply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
}
func TestStatQueuesGetStatQueueProfilesGetProfileErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
SetStatQueueProfileDrvF: func(*context.Context, *engine.StatQueueProfile) error {
return nil
},
RemStatQueueProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"thp_cgrates.org:TEST"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []*engine.StatQueueProfile
experr := "SERVER_ERROR: NOT_IMPLEMENTED"
if err := adms.GetStatQueueProfiles(context.Background(),
&utils.ArgsItemIDs{
ItemsPrefix: "TEST",
}, &reply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}

41
apis/thresholds_test.go
View File

@@ -464,7 +464,7 @@ func TestThresholdsGetThresholdProfileIDsPaginateErr(t *testing.T) {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"dpp_cgrates.org:key1", "dpp_cgrates.org:key2", "dpp_cgrates.org:key3"}, nil
return []string{"rpp_cgrates.org:key1", "rpp_cgrates.org:key2", "rpp_cgrates.org:key3"}, nil
},
}
@@ -894,7 +894,7 @@ func TestThresholdsGetThresholdProfilesGetIDsErr(t *testing.T) {
dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(dataDB, nil, connMgr)
admS := NewAdminSv1(cfg, dm, connMgr)
args1 := &engine.ThresholdProfileWithAPIOpts{
args := &engine.ThresholdProfileWithAPIOpts{
ThresholdProfile: &engine.ThresholdProfile{
Tenant: "cgrates.org",
ID: "test_ID1",
@@ -911,7 +911,7 @@ func TestThresholdsGetThresholdProfilesGetIDsErr(t *testing.T) {
}
var setReply string
if err := admS.SetThresholdProfile(context.Background(), args1, &setReply); err != nil {
if err := admS.SetThresholdProfile(context.Background(), args, &setReply); err != nil {
t.Error(err)
} else if setReply != "OK" {
t.Error("Unexpected reply returned:", setReply)
@@ -933,3 +933,38 @@ func TestThresholdsGetThresholdProfilesGetIDsErr(t *testing.T) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
}
func TestThresholdsGetThresholdProfilesGetProfileErr(t *testing.T) {
engine.Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.GeneralCfg().DefaultCaching = utils.MetaNone
dbMock := &engine.DataDBMock{
SetThresholdProfileDrvF: func(*context.Context, *engine.ThresholdProfile) error {
return nil
},
RemThresholdProfileDrvF: func(*context.Context, string, string) error {
return nil
},
GetKeysForPrefixF: func(c *context.Context, s string) ([]string, error) {
return []string{"thp_cgrates.org:TEST"}, nil
},
}
dm := engine.NewDataManager(dbMock, cfg.CacheCfg(), nil)
adms := &AdminSv1{
cfg: cfg,
dm: dm,
}
var reply []*engine.ThresholdProfile
experr := "SERVER_ERROR: NOT_IMPLEMENTED"
if err := adms.GetThresholdProfiles(context.Background(),
&utils.ArgsItemIDs{
ItemsPrefix: "TEST",
}, &reply); err == nil || err.Error() != experr {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
}
dm.DataDB().Flush(utils.EmptyString)
}