Updated methods and tests for chargers.go with default tenant value

2026-02-11 18:16:24 +05:00 · 2020-10-12 16:32:41 +03:00
parent 583e9dbd67
commit a502ca013d
4 changed files with 125 additions and 22 deletions
--- a/apier/v1/chargers.go
+++ b/apier/v1/chargers.go
@@ -72,9 +72,12 @@ type ChargerWithCache struct {

 //SetChargerProfile add/update a new Charger Profile
 func (apierSv1 *APIerSv1) SetChargerProfile(arg *ChargerWithCache, reply *string) error {
-	if missing := utils.MissingStructFields(arg.ChargerProfile, []string{"Tenant", "ID"}); len(missing) != 0 {
+	if missing := utils.MissingStructFields(arg.ChargerProfile, []string{utils.ID}); len(missing) != 0 {
 		return utils.NewErrMandatoryIeMissing(missing...)
 	}
+	if arg.Tenant == utils.EmptyString {
+		arg.Tenant = apierSv1.Config.GeneralCfg().DefaultTenant
+	}
 	if err := apierSv1.DataManager.SetChargerProfile(arg.ChargerProfile, true); err != nil {
 		return utils.APIErrorHandler(err)
 	}
@@ -93,10 +96,14 @@ func (apierSv1 *APIerSv1) SetChargerProfile(arg *ChargerWithCache, reply *string

 //RemoveChargerProfile remove a specific Charger Profile
 func (apierSv1 *APIerSv1) RemoveChargerProfile(arg *utils.TenantIDWithCache, reply *string) error {
-	if missing := utils.MissingStructFields(arg, []string{"Tenant", "ID"}); len(missing) != 0 { //Params missing
+	if missing := utils.MissingStructFields(arg, []string{utils.ID}); len(missing) != 0 { //Params missing
 		return utils.NewErrMandatoryIeMissing(missing...)
 	}
-	if err := apierSv1.DataManager.RemoveChargerProfile(arg.Tenant,
+	tnt := arg.Tenant
+	if tnt == utils.EmptyString {
+		tnt = apierSv1.Config.GeneralCfg().DefaultTenant
+	}
+	if err := apierSv1.DataManager.RemoveChargerProfile(tnt,
 		arg.ID, utils.NonTransactional, true); err != nil {
 		return utils.APIErrorHandler(err)
 	}
@@ -105,8 +112,8 @@ func (apierSv1 *APIerSv1) RemoveChargerProfile(arg *utils.TenantIDWithCache, rep
 		return utils.APIErrorHandler(err)
 	}
 	//handle caching for ChargerProfile
-	if err := apierSv1.CallCache(arg.Cache, arg.Tenant, utils.CacheChargerProfiles,
-		arg.TenantID(), nil, nil, arg.Opts); err != nil {
+	if err := apierSv1.CallCache(arg.Cache, tnt, utils.CacheChargerProfiles,
+		utils.ConcatenatedKey(tnt, arg.ID), nil, nil, arg.Opts); err != nil {
 		return utils.APIErrorHandler(err)
 	}
 	*reply = utils.OK
--- a/apier/v1/chargers_it_test.go
+++ b/apier/v1/chargers_it_test.go
@@ -90,6 +90,8 @@ var (
 		testChargerSPing,
 		testChargerSProcessWithNotFoundAttribute,
 		testChargerSProccessEventWithProcceSRunS,
+		testChargerSSetChargerProfileWithoutTenant,
+		testChargerSRemChargerProfileWithoutTenant,
 		testChargerSKillEngine,
 	}
 )
@@ -272,6 +274,30 @@ func testChargerSGetChargersForEvent(t *testing.T) {
 	} else if !reflect.DeepEqual(result, chargerProfiles) {
 		t.Errorf("Expecting : %+v, received: %+v", utils.ToJSON(chargerProfiles), utils.ToJSON(result))
 	}
+
+	chargerProfiles = &engine.ChargerProfiles{
+		&engine.ChargerProfile{
+			Tenant:    "cgrates.org",
+			ID:        "Charger1",
+			FilterIDs: []string{"*string:~*req.Account:1001"},
+			ActivationInterval: &utils.ActivationInterval{
+				ActivationTime: time.Date(2014, 7, 29, 15, 0, 0, 0, time.UTC),
+			},
+			RunID:        utils.MetaDefault,
+			AttributeIDs: []string{"ATTR_1001_SIMPLEAUTH"},
+			Weight:       20,
+		},
+	}
+	chargerEvent[0].CGREvent.Tenant = utils.EmptyString
+	if err := chargerRPC.Call(utils.ChargerSv1GetChargersForEvent,
+		&utils.CGREventWithOpts{
+			CGREvent: chargerEvent[0].CGREvent,
+			Opts:     chargerEvent[0].Opts,
+		}, &result); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(result, chargerProfiles) {
+		t.Errorf("Expecting : %+v, received: %+v", utils.ToJSON(chargerProfiles), utils.ToJSON(result))
+	}
 }

 func testChargerSGetChargersForEvent2(t *testing.T) {
@@ -279,7 +305,7 @@ func testChargerSGetChargersForEvent2(t *testing.T) {
 	if err := chargerRPC.Call(utils.ChargerSv1GetChargersForEvent,
 		&utils.CGREventWithOpts{
 			CGREvent: &utils.CGREvent{ // matching Charger1
-				Tenant: "cgrates.org",
+				Tenant: utils.EmptyString,
 				ID:     "event1",
 				Event: map[string]interface{}{
 					utils.Account: "1015",
@@ -347,6 +373,15 @@ func testChargerSProcessEvent(t *testing.T) {
 	if !reflect.DeepEqual(result, processedEv) {
 		t.Errorf("Expecting : %s, received: %s", utils.ToJSON(processedEv), utils.ToJSON(result))
 	}
+
+	chargerEvent[2].Tenant = utils.EmptyString
+	if err := chargerRPC.Call(utils.ChargerSv1ProcessEvent, chargerEvent[2], &result); err != nil {
+		t.Fatal(err)
+	}
+	sort.Strings(result[0].AlteredFields)
+	if !reflect.DeepEqual(result, processedEv) {
+		t.Errorf("Expecting : %s, received: %s", utils.ToJSON(processedEv), utils.ToJSON(result))
+	}
 }

 func testChargerSSetChargerProfile(t *testing.T) {
@@ -393,6 +428,11 @@ func testChargerSSetChargerProfile(t *testing.T) {
 func testChargerSGetChargerProfileIDs(t *testing.T) {
 	expected := []string{"Charger1", "Charger2", "ApierTest", "ChargerNotMatching"}
 	var result []string
+	if err := chargerRPC.Call(utils.APIerSv1GetChargerProfileIDs, utils.PaginatorWithTenant{}, &result); err != nil {
+		t.Error(err)
+	} else if len(expected) != len(result) {
+		t.Errorf("Expecting : %+v, received: %+v", expected, result)
+	}
 	if err := chargerRPC.Call(utils.APIerSv1GetChargerProfileIDs, utils.PaginatorWithTenant{Tenant: "cgrates.org"}, &result); err != nil {
 		t.Error(err)
 	} else if len(expected) != len(result) {
@@ -584,3 +624,51 @@ func testChargerSProccessEventWithProcceSRunS(t *testing.T) {
 		t.Errorf("Expecting : %s, received: %s", utils.ToJSON(processedEv), utils.ToJSON(result2))
 	}
 }
+
+func testChargerSSetChargerProfileWithoutTenant(t *testing.T) {
+	chargerProfile = &ChargerWithCache{
+		ChargerProfile: &engine.ChargerProfile{
+			ID:        "randomID",
+			FilterIDs: []string{"*string:~*req.Account:1010"},
+			ActivationInterval: &utils.ActivationInterval{
+				ActivationTime: time.Date(2014, 7, 14, 14, 35, 0, 0, time.UTC),
+				ExpiryTime:     time.Date(2014, 7, 14, 14, 35, 0, 0, time.UTC),
+			},
+			RunID:        utils.MetaDefault,
+			AttributeIDs: []string{"Attr1", "Attr2"},
+			Weight:       20,
+		},
+	}
+	var reply string
+	if err := chargerRPC.Call(utils.APIerSv1SetChargerProfile, chargerProfile, &reply); err != nil {
+		t.Error(err)
+	} else if reply != utils.OK {
+		t.Error("Unexpected reply returned", reply)
+	}
+	chargerProfile.ChargerProfile.Tenant = "cgrates.org"
+	var result *engine.ChargerProfile
+	if err := chargerRPC.Call(utils.APIerSv1GetChargerProfile,
+		&utils.TenantID{ID: "randomID"},
+		&result); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(chargerProfile.ChargerProfile, result) {
+		t.Errorf("Expected %+v, received %+v", utils.ToJSON(chargerProfile.ChargerProfile), utils.ToJSON(result))
+	}
+}
+
+func testChargerSRemChargerProfileWithoutTenant(t *testing.T) {
+	var reply string
+	if err := chargerRPC.Call(utils.APIerSv1RemoveChargerProfile,
+		&utils.TenantIDWithCache{ID: "randomID"},
+		&reply); err != nil {
+		t.Error(err)
+	} else if reply != utils.OK {
+		t.Error("Unexpected reply returned", reply)
+	}
+	var result *engine.ChargerProfile
+	if err := chargerRPC.Call(utils.APIerSv1GetChargerProfile,
+		&utils.TenantID{ID: "randomID"},
+		&result); err == nil || err.Error() != utils.ErrNotFound.Error() {
+		t.Error(err)
+	}
+}
--- a/engine/chargers.go
+++ b/engine/chargers.go
@@ -56,7 +56,7 @@ func (cS *ChargerService) Shutdown() (err error) {
 }

 // matchingChargingProfilesForEvent returns ordered list of matching chargers which are active by the time of the function call
-func (cS *ChargerService) matchingChargerProfilesForEvent(cgrEv *utils.CGREventWithOpts) (cPs ChargerProfiles, err error) {
+func (cS *ChargerService) matchingChargerProfilesForEvent(tnt string, cgrEv *utils.CGREventWithOpts) (cPs ChargerProfiles, err error) {
 	evNm := utils.MapStorage{
 		utils.MetaReq:  cgrEv.Event,
 		utils.MetaOpts: cgrEv.Opts,
@@ -65,7 +65,7 @@ func (cS *ChargerService) matchingChargerProfilesForEvent(cgrEv *utils.CGREventW
 		cS.cfg.ChargerSCfg().StringIndexedFields,
 		cS.cfg.ChargerSCfg().PrefixIndexedFields,
 		cS.cfg.ChargerSCfg().SuffixIndexedFields,
-		cS.dm, utils.CacheChargerFilterIndexes, cgrEv.Tenant,
+		cS.dm, utils.CacheChargerFilterIndexes, tnt,
 		cS.cfg.ChargerSCfg().IndexedSelects,
 		cS.cfg.ChargerSCfg().NestedFields,
 	)
@@ -74,7 +74,7 @@ func (cS *ChargerService) matchingChargerProfilesForEvent(cgrEv *utils.CGREventW
 	}
 	matchingCPs := make(map[string]*ChargerProfile)
 	for cpID := range cpIDs {
-		cP, err := cS.dm.GetChargerProfile(cgrEv.Tenant, cpID, true, true, utils.NonTransactional)
+		cP, err := cS.dm.GetChargerProfile(tnt, cpID, true, true, utils.NonTransactional)
 		if err != nil {
 			if err == utils.ErrNotFound {
 				continue
@@ -85,7 +85,7 @@ func (cS *ChargerService) matchingChargerProfilesForEvent(cgrEv *utils.CGREventW
 			!cP.ActivationInterval.IsActiveAtTime(*cgrEv.Time) { // not active
 			continue
 		}
-		if pass, err := cS.filterS.Pass(cgrEv.Tenant, cP.FilterIDs,
+		if pass, err := cS.filterS.Pass(tnt, cP.FilterIDs,
 			evNm); err != nil {
 			return nil, err
 		} else if !pass {
@@ -115,7 +115,7 @@ type ChrgSProcessEventReply struct {
 	Opts               map[string]interface{}
 }

-func (cS *ChargerService) processEvent(cgrEv *utils.CGREventWithOpts) (rply []*ChrgSProcessEventReply, err error) {
+func (cS *ChargerService) processEvent(tnt string, cgrEv *utils.CGREventWithOpts) (rply []*ChrgSProcessEventReply, err error) {
 	var cPs ChargerProfiles
 	cgrEv.Opts = MapEvent(cgrEv.Opts).Clone()
 	if cgrEv.Opts == nil {
@@ -128,19 +128,19 @@ func (cS *ChargerService) processEvent(cgrEv *utils.CGREventWithOpts) (rply []*C
 			processRuns = utils.IntPointer(int(v))
 		}
 	}
-	if cPs, err = cS.matchingChargerProfilesForEvent(cgrEv); err != nil {
+	if cPs, err = cS.matchingChargerProfilesForEvent(tnt, cgrEv); err != nil {
 		return nil, err
 	}
 	rply = make([]*ChrgSProcessEventReply, len(cPs))
 	for i, cP := range cPs {
 		clonedEv := cgrEv.Clone()
-		opts := MapEvent(cgrEv.Opts).Clone()
+		clonedEv.Tenant = tnt
 		clonedEv.Event[utils.RunID] = cP.RunID
 		rply[i] = &ChrgSProcessEventReply{
 			ChargerSProfile: cP.ID,
 			CGREvent:        clonedEv.CGREvent,
 			AlteredFields:   []string{utils.MetaReqRunID},
-			Opts:            opts,
+			Opts:            clonedEv.Opts,
 		}
 		if len(cP.AttributeIDs) == 1 && cP.AttributeIDs[0] == utils.META_NONE {
 			continue // AttributeS disabled
@@ -149,12 +149,12 @@ func (cS *ChargerService) processEvent(cgrEv *utils.CGREventWithOpts) (rply []*C
 		args := &AttrArgsProcessEvent{
 			AttributeIDs: cP.AttributeIDs,
 			Context: utils.StringPointer(utils.FirstNonEmpty(
-				utils.IfaceAsString(opts[utils.OptsContext]),
+				utils.IfaceAsString(clonedEv.Opts[utils.OptsContext]),
 				utils.MetaChargers)),
 			ProcessRuns: processRuns,
 			CGREventWithOpts: &utils.CGREventWithOpts{
 				CGREvent: clonedEv.CGREvent,
-				Opts:     opts,
+				Opts:     clonedEv.Opts,
 			},
 		}
 		var evReply AttrSProcessEventReply
@@ -182,7 +182,11 @@ func (cS *ChargerService) V1ProcessEvent(args *utils.CGREventWithOpts,
 		args.Event == nil {
 		return utils.NewErrMandatoryIeMissing("Event")
 	}
-	rply, err := cS.processEvent(args)
+	tnt := args.Tenant
+	if tnt == utils.EmptyString {
+		tnt = cS.cfg.GeneralCfg().DefaultTenant
+	}
+	rply, err := cS.processEvent(tnt, args)
 	if err != nil {
 		if err != utils.ErrNotFound {
 			err = utils.NewErrServerError(err)
@@ -196,7 +200,11 @@ func (cS *ChargerService) V1ProcessEvent(args *utils.CGREventWithOpts,
 // V1GetChargersForEvent exposes the list of ordered matching ChargingProfiles for an event
 func (cS *ChargerService) V1GetChargersForEvent(args *utils.CGREventWithOpts,
 	rply *ChargerProfiles) (err error) {
-	cPs, err := cS.matchingChargerProfilesForEvent(args)
+	tnt := args.Tenant
+	if tnt == utils.EmptyString {
+		tnt = cS.cfg.GeneralCfg().DefaultTenant
+	}
+	cPs, err := cS.matchingChargerProfilesForEvent(tnt, args)
 	if err != nil {
 		if err != utils.ErrNotFound {
 			err = utils.NewErrServerError(err)
--- a/engine/chargers_test.go
+++ b/engine/chargers_test.go
@@ -191,18 +191,18 @@ func TestChargerSetChargerProfiles(t *testing.T) {
 }

 func TestChargerMatchingChargerProfilesForEvent(t *testing.T) {
-	if _, err = chargerSrv.matchingChargerProfilesForEvent(chargerEvents[2]); err == nil ||
+	if _, err = chargerSrv.matchingChargerProfilesForEvent(chargerEvents[2].Tenant, chargerEvents[2]); err == nil ||
 		err.Error() != utils.ErrNotFound.Error() {
 		t.Errorf("Error: %+v", err)
 	}

-	if rcv, err := chargerSrv.matchingChargerProfilesForEvent(chargerEvents[0]); err != nil {
+	if rcv, err := chargerSrv.matchingChargerProfilesForEvent(chargerEvents[0].Tenant, chargerEvents[0]); err != nil {
 		t.Errorf("Error: %+v", err)
 	} else if !reflect.DeepEqual(cPPs[0], rcv[0]) {
 		t.Errorf("Expecting: %+v, received: %+v ", cPPs[0], rcv[0])
 	}

-	if rcv, err := chargerSrv.matchingChargerProfilesForEvent(chargerEvents[1]); err != nil {
+	if rcv, err := chargerSrv.matchingChargerProfilesForEvent(chargerEvents[1].Tenant, chargerEvents[1]); err != nil {
 		t.Errorf("Error: %+v", err)
 	} else if !reflect.DeepEqual(cPPs[1], rcv[0]) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(cPPs[1]), utils.ToJSON(rcv))
@@ -220,7 +220,7 @@ func TestChargerProcessEvent(t *testing.T) {
 		},
 	}
 	rpl[0].CGREvent.Event[utils.RunID] = cPPs[0].RunID
-	rcv, err := chargerSrv.processEvent(&utils.CGREventWithOpts{
+	rcv, err := chargerSrv.processEvent(rpl[0].CGREvent.Tenant, &utils.CGREventWithOpts{
 		CGREvent: chargerEvents[0].CGREvent,
 		Opts:     chargerEvents[0].Opts,
 	})