Coverage tests

This commit is contained in:
nickolasdaniel
2022-03-30 17:07:38 +03:00
committed by Dan Christian Bogos
parent 437db2bccb
commit fb372f4e02
2 changed files with 383 additions and 0 deletions

85
apis/cdrs_test.go Normal file
View File

@@ -0,0 +1,85 @@
/*
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 apis
import (
"reflect"
"testing"
"github.com/cgrates/birpc/context"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
func TestCDRsProcessEvent(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cdrS := engine.NewCDRServer(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr)
cdr := NewCDRsV1(cdrS)
var reply string
args := &utils.CGREvent{
ID: "TestMatchingAccountsForEvent",
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.AccountField: "1001",
},
}
if err := cdr.ProcessEvent(context.Background(), args, &reply); err != nil {
t.Error(err)
}
if reply != utils.OK {
t.Errorf("Expected %v\n but received %v", utils.OK, reply)
}
}
func TestCDRsProcessEventWithGet(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cdrS := engine.NewCDRServer(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr)
cdr := NewCDRsV1(cdrS)
var reply []*utils.EventsWithOpts
args := &utils.CGREvent{
ID: "TestMatchingAccountsForEvent",
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.AccountField: "1001",
},
}
if err := cdr.ProcessEventWithGet(context.Background(), args, &reply); err != nil {
t.Error(err)
}
exp := []utils.EventsWithOpts{
{
Event: map[string]interface{}{
utils.AccountField: "1001",
},
Opts: map[string]interface{}{},
},
}
if !reflect.DeepEqual(exp[0].Event, reply[0].Event) {
t.Errorf("Expected %v \n but received %v", exp, reply)
}
}

View File

@@ -258,3 +258,301 @@ func TestProcessEvent(t *testing.T) {
t.Error(err)
}
}
func TestGetActiveSessions(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply []*sessions.ExternalSession
args := &utils.SessionFilter{
Limit: utils.IntPointer(2),
Filters: []string{},
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{},
}
if err := ssv1.GetActiveSessions(context.Background(), args, &reply); err != utils.ErrNotFound {
t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
}
}
func TestGetActiveSessionsCount(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply int
args := &utils.SessionFilter{
Limit: utils.IntPointer(2),
Filters: []string{},
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{},
}
if err := ssv1.GetActiveSessionsCount(context.Background(), args, &reply); err != nil {
t.Error(err)
}
if reply != 0 {
t.Errorf("Expected 0")
}
}
func TestForceDisconnect(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := &utils.SessionFilter{
Limit: utils.IntPointer(2),
Filters: []string{},
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{},
}
if err := ssv1.ForceDisconnect(context.Background(), args, &reply); err != utils.ErrNotFound {
t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
}
}
func TestGetPassiveSessions(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply []*sessions.ExternalSession
args := &utils.SessionFilter{
Limit: utils.IntPointer(2),
Filters: []string{},
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{},
}
if err := ssv1.GetPassiveSessions(context.Background(), args, &reply); err != utils.ErrNotFound {
t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
}
}
func TestGetPassiveSessionsCount(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply int
args := &utils.SessionFilter{
Limit: utils.IntPointer(2),
Filters: []string{},
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{},
}
if err := ssv1.GetPassiveSessionsCount(context.Background(), args, &reply); err != nil {
t.Error(err)
}
if reply != 0 {
t.Errorf("Expected 0")
}
}
func TestSetPassiveSession(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := &sessions.Session{
Tenant: "cgrates.org",
}
if err := ssv1.SetPassiveSession(context.Background(), args, &reply); err != utils.ErrNotFound {
t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
}
}
func TestActivateSessions(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := &utils.SessionIDsWithAPIOpts{
IDs: []string{"TestMatchingAccountsForEvent"},
}
if err := ssv1.ActivateSessions(context.Background(), args, &reply); err != utils.ErrPartiallyExecuted {
t.Errorf("Expected %v\n but received %v", utils.ErrPartiallyExecuted, err)
}
}
func TestDeactivateSessions(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := &utils.SessionIDsWithAPIOpts{
IDs: []string{"TestMatchingAccountsForEvent"},
}
if err := ssv1.DeactivateSessions(context.Background(), args, &reply); err != utils.ErrPartiallyExecuted {
t.Errorf("Expected %v\n but received %v", utils.ErrPartiallyExecuted, err)
}
}
func TestReAuthorize(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := &utils.SessionFilter{
Limit: utils.IntPointer(2),
Filters: []string{},
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{},
}
if err := ssv1.ReAuthorize(context.Background(), args, &reply); err != utils.ErrNotFound {
t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
}
}
func TestDisconnectPeer(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := &utils.DPRArgs{
OriginHost: "origin_host",
OriginRealm: "origin_realm",
DisconnectCause: 2,
}
if err := ssv1.DisconnectPeer(context.Background(), args, &reply); err != nil {
t.Error(err)
}
}
func TestSTIRAuthenticate(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := &sessions.V1STIRAuthenticateArgs{
DestinationTn: "dest_tn",
Identity: "identity",
}
errExpect := "*stir_authenticate: missing parts of the message header"
if err := ssv1.STIRAuthenticate(context.Background(), args, &reply); err.Error() != errExpect {
t.Errorf("Expected %v\n but received %v", errExpect, err)
}
}
func TestSTIRIdentity(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := &sessions.V1STIRIdentityArgs{
PublicKeyPath: "PKP",
PrivateKeyPath: "PKP_PRIVATE",
Payload: &utils.PASSporTPayload{
ATTest: "at_Test",
},
}
errExpect := "*stir_authenticate: open PKP_PRIVATE: no such file or directory"
if err := ssv1.STIRIdentity(context.Background(), args, &reply); err.Error() != errExpect {
t.Errorf("Expected %v\n but received %v", errExpect, err)
}
}
func TestRegisterInternalBiJSONConn(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
connMgr := engine.NewConnManager(cfg)
data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
cfg.SessionSCfg().CDRsConns = []string{"*internal"}
ssv1 := &SessionSv1{
ping: struct{}{},
sS: sessions.NewSessionS(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr),
}
var reply string
args := "*internal"
if err := ssv1.RegisterInternalBiJSONConn(context.Background(), args, &reply); err != nil {
t.Error(err)
}
}