From fcbd0f19fec66bce307e4ed9ae1a4ed27e2411ba Mon Sep 17 00:00:00 2001
From: andronache <andrei.andronache@itsyscom.com>
Date: Tue, 19 Jan 2021 16:59:13 +0200
Subject: [PATCH] Refactored tests in engine

---
 apier/v1/cache_replication_it_test.go |   4 +-
 apier/v1/rateprofiles_it_test.go      |  28 +-
 engine/chargers_test.go               | 369 ++++++++++++++++++++++----
 engine/model_helpers.go               |   4 +-
 engine/model_helpers_test.go          |   8 +-
 engine/rateprofile_test.go            |  32 +--
 general_tests/export_it_test.go       |   4 +-
 loaders/loader_test.go                |   8 +-
 migrator/rateprofiles_it_test.go      |   4 +-
 rates/librates_test.go                | 172 ++++++------
 rates/rates_test.go                   |  20 +-
 utils/decimal.go                      |   4 +-
 utils/decimal_test.go                 |   2 +-
 13 files changed, 465 insertions(+), 194 deletions(-)

diff --git a/apier/v1/cache_replication_it_test.go b/apier/v1/cache_replication_it_test.go
index 0c2735a29..2d781841f 100644
--- a/apier/v1/cache_replication_it_test.go
+++ b/apier/v1/cache_replication_it_test.go
@@ -183,11 +183,11 @@ func testCacheSReplicateProcessRateProfile(t *testing.T) {
 			},
 		},
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/apier/v1/rateprofiles_it_test.go b/apier/v1/rateprofiles_it_test.go
index 933e10f7b..004f32aea 100644
--- a/apier/v1/rateprofiles_it_test.go
+++ b/apier/v1/rateprofiles_it_test.go
@@ -148,11 +148,11 @@ func testV1RatePrfVerifyRateProfile(t *testing.T) {
 		utils.TenantIDWithOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "RP1"}}, &reply); err != nil {
 		t.Fatal(err)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -757,11 +757,11 @@ func testV1RatePrfRemoveRateProfileRatesWithoutTenant(t *testing.T) {
 }
 
 func testV1RateCostForEventWithDefault(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -855,11 +855,11 @@ func testV1RateCostForEventWithDefault(t *testing.T) {
 }
 
 func testV1RateCostForEventWithUsage(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -994,11 +994,11 @@ func testV1RateCostForEventWithWrongUsage(t *testing.T) {
 }
 
 func testV1RateCostForEventWithStartTime(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1100,11 +1100,11 @@ func testV1RateCostForEventWithWrongStartTime(t *testing.T) {
 }
 
 func testV1RateCostForEventWithOpts(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1222,11 +1222,11 @@ func testV1RateCostForEventWithOpts(t *testing.T) {
 
 /*
 func testV1RateCostForEventSpecial(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1357,11 +1357,11 @@ func testV1RateCostForEventSpecial(t *testing.T) {
 }
 
 func testV1RateCostForEventThreeRates(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/engine/chargers_test.go b/engine/chargers_test.go
index 651af7da5..ac5355b99 100755
--- a/engine/chargers_test.go
+++ b/engine/chargers_test.go
@@ -23,13 +23,13 @@ import (
 	"time"
 
 	"github.com/cgrates/cgrates/config"
+
 	"github.com/cgrates/cgrates/utils"
 )
 
-var (
-	chargerSrv *ChargerService
-	dmCharger  *DataManager
-	cPPs       = ChargerProfiles{
+func TestChargerSetChargerProfiles(t *testing.T) {
+	var dmCharger *DataManager
+	cPPs := ChargerProfiles{
 		&ChargerProfile{
 			Tenant:    "cgrates.org",
 			ID:        "CPP_1",
@@ -64,51 +64,9 @@ var (
 			Weight:       20,
 		},
 	}
-	chargerEvents = []*utils.CGREvent{
-		{
-			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-			ID:     utils.GenUUID(),
-			Event: map[string]interface{}{
-				"Charger":        "ChargerProfile1",
-				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-				"UsageInterval":  "1s",
-				utils.Weight:     "200.0",
-			},
-			Opts: map[string]interface{}{
-				utils.Subsys: utils.MetaChargers,
-			},
-		},
-		{
-			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-			ID:     utils.GenUUID(),
-			Event: map[string]interface{}{
-				"Charger":        "ChargerProfile2",
-				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-			},
-		},
-		{
-			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-			ID:     utils.GenUUID(),
-			Event: map[string]interface{}{
-				"Charger":        "DistinctMatch",
-				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-			},
-		},
-	}
-)
-
-func TestChargerPopulateChargerService(t *testing.T) {
-	defaultCfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, true)
 	dmCharger = NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
-	chargerSrv, err = NewChargerService(dmCharger,
-		&FilterS{dm: dmCharger, cfg: defaultCfg}, defaultCfg, nil)
-	if err != nil {
-		t.Errorf("Error: %+v", err)
-	}
-}
 
-func TestChargerAddFilter(t *testing.T) {
 	fltrCP1 := &Filter{
 		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
 		ID:     "FLTR_CP_1",
@@ -165,9 +123,6 @@ func TestChargerAddFilter(t *testing.T) {
 		},
 	}
 	dmCharger.SetFilter(fltrCP4, true)
-}
-
-func TestChargerSetChargerProfiles(t *testing.T) {
 	for _, cp := range cPPs {
 		if err = dmCharger.SetChargerProfile(cp, true); err != nil {
 			t.Errorf("Error: %+v", err)
@@ -185,6 +140,156 @@ func TestChargerSetChargerProfiles(t *testing.T) {
 }
 
 func TestChargerMatchingChargerProfilesForEvent(t *testing.T) {
+	var chargerSrv *ChargerService
+	var dmCharger *DataManager
+	cPPs := ChargerProfiles{
+		&ChargerProfile{
+			Tenant:    "cgrates.org",
+			ID:        "CPP_1",
+			FilterIDs: []string{"FLTR_CP_1", "FLTR_CP_4", "*string:~*opts.*subsys:*chargers"},
+			ActivationInterval: &utils.ActivationInterval{
+				ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+			},
+			RunID:        "TestRunID",
+			AttributeIDs: []string{"*none"},
+			Weight:       20,
+		},
+		&ChargerProfile{
+			Tenant:    "cgrates.org",
+			ID:        "CPP_2",
+			FilterIDs: []string{"FLTR_CP_2"},
+			ActivationInterval: &utils.ActivationInterval{
+				ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+			},
+			RunID:        "*rated",
+			AttributeIDs: []string{"ATTR_1"},
+			Weight:       20,
+		},
+		&ChargerProfile{
+			Tenant:    "cgrates.org",
+			ID:        "CPP_3",
+			FilterIDs: []string{"FLTR_CP_3"},
+			ActivationInterval: &utils.ActivationInterval{
+				ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+			},
+			RunID:        "*rated",
+			AttributeIDs: []string{"ATTR_1"},
+			Weight:       20,
+		},
+	}
+	chargerEvents := []*utils.CGREvent{
+		{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "ChargerProfile1",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+				"UsageInterval":  "1s",
+				utils.Weight:     "200.0",
+			},
+			Opts: map[string]interface{}{
+				utils.Subsys: utils.MetaChargers,
+			},
+		},
+		{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "ChargerProfile2",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+			},
+		},
+		{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "DistinctMatch",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+			},
+		},
+	}
+
+	defaultCfg := config.NewDefaultCGRConfig()
+	data := NewInternalDB(nil, nil, true)
+	dmCharger = NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
+	chargerSrv, err = NewChargerService(dmCharger,
+		&FilterS{dm: dmCharger, cfg: defaultCfg}, defaultCfg, nil)
+	if err != nil {
+		t.Errorf("Error: %+v", err)
+	}
+
+	fltrCP1 := &Filter{
+		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+		ID:     "FLTR_CP_1",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Charger",
+				Values:  []string{"ChargerProfile1"},
+			},
+			{
+				Type:    utils.MetaGreaterOrEqual,
+				Element: "~*req.UsageInterval",
+				Values:  []string{(time.Second).String()},
+			},
+		},
+	}
+	if err := fltrCP1.Compile(); err != nil {
+		t.Error(err)
+	}
+	dmCharger.SetFilter(fltrCP1, true)
+	fltrCP2 := &Filter{
+		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+		ID:     "FLTR_CP_2",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Charger",
+				Values:  []string{"ChargerProfile2"},
+			},
+		},
+	}
+	dmCharger.SetFilter(fltrCP2, true)
+	fltrCPPrefix := &Filter{
+		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+		ID:     "FLTR_CP_3",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaPrefix,
+				Element: "~*req.harger",
+				Values:  []string{"Charger"},
+			},
+		},
+	}
+	dmCharger.SetFilter(fltrCPPrefix, true)
+	fltrCP4 := &Filter{
+		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+		ID:     "FLTR_CP_4",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaGreaterOrEqual,
+				Element: utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.Weight,
+				Values:  []string{"200.00"},
+			},
+		},
+	}
+	dmCharger.SetFilter(fltrCP4, true)
+
+	for _, cp := range cPPs {
+		if err = dmCharger.SetChargerProfile(cp, true); err != nil {
+			t.Errorf("Error: %+v", err)
+		}
+	}
+	//verify each charger from cache
+	for _, cp := range cPPs {
+		if tempCp, err := dmCharger.GetChargerProfile(cp.Tenant, cp.ID,
+			true, false, utils.NonTransactional); err != nil {
+			t.Errorf("Error: %+v", err)
+		} else if !reflect.DeepEqual(cp, tempCp) {
+			t.Errorf("Expecting: %+v, received: %+v", cp, tempCp)
+		}
+	}
+
 	if _, err = chargerSrv.matchingChargerProfilesForEvent(chargerEvents[2].Tenant, chargerEvents[2]); err == nil ||
 		err.Error() != utils.ErrNotFound.Error() {
 		t.Errorf("Error: %+v", err)
@@ -205,6 +310,172 @@ func TestChargerMatchingChargerProfilesForEvent(t *testing.T) {
 }
 
 func TestChargerProcessEvent(t *testing.T) {
+	var chargerSrv *ChargerService
+	var dmCharger *DataManager
+	cPPs := ChargerProfiles{
+		&ChargerProfile{
+			Tenant:    "cgrates.org",
+			ID:        "CPP_1",
+			FilterIDs: []string{"FLTR_CP_1", "FLTR_CP_4", "*string:~*opts.*subsys:*chargers"},
+			ActivationInterval: &utils.ActivationInterval{
+				ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+			},
+			RunID:        "TestRunID",
+			AttributeIDs: []string{"*none"},
+			Weight:       20,
+		},
+		&ChargerProfile{
+			Tenant:    "cgrates.org",
+			ID:        "CPP_2",
+			FilterIDs: []string{"FLTR_CP_2"},
+			ActivationInterval: &utils.ActivationInterval{
+				ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+			},
+			RunID:        "*rated",
+			AttributeIDs: []string{"ATTR_1"},
+			Weight:       20,
+		},
+		&ChargerProfile{
+			Tenant:    "cgrates.org",
+			ID:        "CPP_3",
+			FilterIDs: []string{"FLTR_CP_3"},
+			ActivationInterval: &utils.ActivationInterval{
+				ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+			},
+			RunID:        "*rated",
+			AttributeIDs: []string{"ATTR_1"},
+			Weight:       20,
+		},
+	}
+	chargerEvents := []*utils.CGREvent{
+		{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "ChargerProfile1",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+				"UsageInterval":  "1s",
+				utils.Weight:     "200.0",
+			},
+			Opts: map[string]interface{}{
+				utils.Subsys: utils.MetaChargers,
+			},
+		},
+		{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "ChargerProfile2",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+			},
+		},
+		{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "DistinctMatch",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+			},
+		},
+	}
+
+	defaultCfg := config.NewDefaultCGRConfig()
+	data := NewInternalDB(nil, nil, true)
+	dmCharger = NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
+	chargerSrv, err = NewChargerService(dmCharger,
+		&FilterS{dm: dmCharger, cfg: defaultCfg}, defaultCfg, nil)
+	if err != nil {
+		t.Errorf("Error: %+v", err)
+	}
+
+	fltrCP1 := &Filter{
+		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+		ID:     "FLTR_CP_1",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Charger",
+				Values:  []string{"ChargerProfile1"},
+			},
+			{
+				Type:    utils.MetaGreaterOrEqual,
+				Element: "~*req.UsageInterval",
+				Values:  []string{(time.Second).String()},
+			},
+		},
+	}
+	if err := fltrCP1.Compile(); err != nil {
+		t.Error(err)
+	}
+	dmCharger.SetFilter(fltrCP1, true)
+	fltrCP2 := &Filter{
+		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+		ID:     "FLTR_CP_2",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Charger",
+				Values:  []string{"ChargerProfile2"},
+			},
+		},
+	}
+	dmCharger.SetFilter(fltrCP2, true)
+	fltrCPPrefix := &Filter{
+		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+		ID:     "FLTR_CP_3",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaPrefix,
+				Element: "~*req.harger",
+				Values:  []string{"Charger"},
+			},
+		},
+	}
+	dmCharger.SetFilter(fltrCPPrefix, true)
+	fltrCP4 := &Filter{
+		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+		ID:     "FLTR_CP_4",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaGreaterOrEqual,
+				Element: utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.Weight,
+				Values:  []string{"200.00"},
+			},
+		},
+	}
+	dmCharger.SetFilter(fltrCP4, true)
+
+	for _, cp := range cPPs {
+		if err = dmCharger.SetChargerProfile(cp, true); err != nil {
+			t.Errorf("Error: %+v", err)
+		}
+	}
+	//verify each charger from cache
+	for _, cp := range cPPs {
+		if tempCp, err := dmCharger.GetChargerProfile(cp.Tenant, cp.ID,
+			true, false, utils.NonTransactional); err != nil {
+			t.Errorf("Error: %+v", err)
+		} else if !reflect.DeepEqual(cp, tempCp) {
+			t.Errorf("Expecting: %+v, received: %+v", cp, tempCp)
+		}
+	}
+
+	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].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].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))
+	}
 	rpl := []*ChrgSProcessEventReply{
 		{
 			ChargerSProfile: "CPP_1",
diff --git a/engine/model_helpers.go b/engine/model_helpers.go
index 67c32bd8a..f0f296e5b 100644
--- a/engine/model_helpers.go
+++ b/engine/model_helpers.go
@@ -3089,10 +3089,10 @@ func APItoRateProfile(tpRp *utils.TPRateProfile, timezone string) (rp *RateProfi
 			}
 			rp.Rates[key].IntervalRates[i].FixedFee = utils.NewDecimalFromFloat64(iRate.FixedFee)
 			rp.Rates[key].IntervalRates[i].RecurrentFee = utils.NewDecimalFromFloat64(iRate.RecurrentFee)
-			if rp.Rates[key].IntervalRates[i].Unit, err = utils.NewDecimalFromUnit(iRate.Unit); err != nil {
+			if rp.Rates[key].IntervalRates[i].Unit, err = utils.NewDecimalFromUsage(iRate.Unit); err != nil {
 				return nil, err
 			}
-			if rp.Rates[key].IntervalRates[i].Increment, err = utils.NewDecimalFromUnit(iRate.Increment); err != nil {
+			if rp.Rates[key].IntervalRates[i].Increment, err = utils.NewDecimalFromUsage(iRate.Increment); err != nil {
 				return nil, err
 			}
 		}
diff --git a/engine/model_helpers_test.go b/engine/model_helpers_test.go
index a3fc0097c..8a20f6121 100644
--- a/engine/model_helpers_test.go
+++ b/engine/model_helpers_test.go
@@ -4292,11 +4292,11 @@ func TestTPRoutesAsTPRouteProfile2(t *testing.T) {
 }
 
 func TestRateProfileToAPI(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -4424,11 +4424,11 @@ func TestRateProfileToAPI(t *testing.T) {
 }
 
 func TestAPIToRateProfile(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/engine/rateprofile_test.go b/engine/rateprofile_test.go
index 7612ab48f..292c52aa1 100644
--- a/engine/rateprofile_test.go
+++ b/engine/rateprofile_test.go
@@ -31,11 +31,11 @@ import (
 )
 
 func TestRateProfileSort(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -474,11 +474,11 @@ func TestRateProfileRunTimesPassingActivationTIme(t *testing.T) {
 }
 
 func TestCostForIntervals(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -569,11 +569,11 @@ func TestCostForIntervals(t *testing.T) {
 }
 
 func TestCostForIntervalsWIthFixedFee(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -716,11 +716,11 @@ func TestRateProfileCostCorrectCostMaxCost(t *testing.T) {
 }
 
 func TestRateSIncrementCompressEquals(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -764,7 +764,7 @@ func TestRateSIncrementCompressEquals(t *testing.T) {
 }
 
 func TestRateSIncrementCompressEqualsCase1(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -816,7 +816,7 @@ func TestRateSIncrementCompressEqualsCase1(t *testing.T) {
 	}
 }
 func TestRateSIncrementCompressEqualsCase2(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -854,7 +854,7 @@ func TestRateSIncrementCompressEqualsCase2(t *testing.T) {
 }
 
 func TestRateSIncrementCompressEqualsCase3(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -892,11 +892,11 @@ func TestRateSIncrementCompressEqualsCase3(t *testing.T) {
 }
 
 func TestRateSIntervalCompressEqualsCase1(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -960,11 +960,11 @@ func TestRateSIntervalCompressEqualsCase1(t *testing.T) {
 }
 
 func TestRateSIntervalCompressEqualsCase2(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1054,7 +1054,7 @@ func TestRateSIntervalCompressEqualsCase2(t *testing.T) {
 }
 
 func TestRateSIntervalCompressEqualsCase3(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/general_tests/export_it_test.go b/general_tests/export_it_test.go
index 502f4cac5..5619abb42 100644
--- a/general_tests/export_it_test.go
+++ b/general_tests/export_it_test.go
@@ -366,11 +366,11 @@ func testExpVerifyRoutes(t *testing.T) {
 
 func testExpVerifyRateProfiles(t *testing.T) {
 	var reply *engine.RateProfile
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/loaders/loader_test.go b/loaders/loader_test.go
index aa0d90b04..a5c9a7d96 100644
--- a/loaders/loader_test.go
+++ b/loaders/loader_test.go
@@ -1615,11 +1615,11 @@ func TestLoaderProcessRateProfile(t *testing.T) {
 	if len(ldr.bufLoaderData) != 0 {
 		t.Errorf("wrong buffer content: %+v", ldr.bufLoaderData)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1821,11 +1821,11 @@ cgrates.org,RP1,,,,,,,RT_CHRISTMAS,,* * 24 12 *,30,false,0s,,0.06,1m,1s
 	if len(ldr.bufLoaderData) != 0 {
 		t.Errorf("wrong buffer content: %+v", ldr.bufLoaderData)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/migrator/rateprofiles_it_test.go b/migrator/rateprofiles_it_test.go
index faa46d40f..2731f7e82 100644
--- a/migrator/rateprofiles_it_test.go
+++ b/migrator/rateprofiles_it_test.go
@@ -177,11 +177,11 @@ func testRatePrfITFlush(t *testing.T) {
 }
 
 func testRatePrfITMigrateAndMove(t *testing.T) {
-	minDec, err := utils.NewDecimalFromUnit("1m")
+	minDec, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDec, err := utils.NewDecimalFromUnit("1s")
+	secDec, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/rates/librates_test.go b/rates/librates_test.go
index 9447d114b..d3690d664 100644
--- a/rates/librates_test.go
+++ b/rates/librates_test.go
@@ -1576,11 +1576,11 @@ func TestOrderRatesOnIntervalStartLowerThanEndIdx(t *testing.T) {
 }
 
 func TestComputeRateSIntervals(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1747,15 +1747,15 @@ func TestComputeRateSIntervals(t *testing.T) {
 }
 
 func TestComputeRateSIntervals1(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1861,15 +1861,15 @@ func TestComputeRateSIntervals1(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsWIthFixedFee(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1998,7 +1998,7 @@ func TestComputeRateSIntervalsWIthFixedFee(t *testing.T) {
 }
 
 func TestComputeRateSIntervals2(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -2113,11 +2113,11 @@ func TestComputeRateSIntervals2(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsEvery30Seconds(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -2296,7 +2296,7 @@ func TestComputeRateSIntervalsEvery30Seconds(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsStartHigherThanUsage(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -2350,11 +2350,11 @@ func TestComputeRateSIntervalsStartHigherThanUsage(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsZeroIncrement(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
-	zeroDecimal, err := utils.NewDecimalFromUnit("0s")
+	zeroDecimal, err := utils.NewDecimalFromUsage("0s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -2385,19 +2385,19 @@ func TestComputeRateSIntervalsZeroIncrement(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsCeilingCmpFactor(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	ssecDecimal, err := utils.NewDecimalFromUnit("7s")
+	ssecDecimal, err := utils.NewDecimalFromUsage("7s")
 	if err != nil {
 		t.Error(err)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -2456,27 +2456,27 @@ func TestComputeRateSIntervalsCeilingCmpFactor(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsSwitchingRates(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	ssecDecimal, err := utils.NewDecimalFromUnit("7s")
+	ssecDecimal, err := utils.NewDecimalFromUsage("7s")
 	if err != nil {
 		t.Error(err)
 	}
-	fsecDecimal, err := utils.NewDecimalFromUnit("5s")
+	fsecDecimal, err := utils.NewDecimalFromUsage("5s")
 	if err != nil {
 		t.Error(err)
 	}
-	fssecDecimal, err := utils.NewDecimalFromUnit("25s")
+	fssecDecimal, err := utils.NewDecimalFromUsage("25s")
 	if err != nil {
 		t.Error(err)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -2643,19 +2643,19 @@ func TestComputeRateSIntervalsSwitchingRates(t *testing.T) {
 }
 
 func TestComputeRatesIntervalsAllInOne(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	ssecDecimal, err := utils.NewDecimalFromUnit("7s")
+	ssecDecimal, err := utils.NewDecimalFromUsage("7s")
 	if err != nil {
 		t.Error(err)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -2822,11 +2822,11 @@ func TestComputeRatesIntervalsAllInOne(t *testing.T) {
 }
 
 func TestOrderRatesIntervalsFullDay(t *testing.T) {
-	hourDecimal, err := utils.NewDecimalFromUnit("1h")
+	hourDecimal, err := utils.NewDecimalFromUsage("1h")
 	if err != nil {
 		t.Error(err)
 	}
-	tminDecimal, err := utils.NewDecimalFromUnit("3m")
+	tminDecimal, err := utils.NewDecimalFromUsage("3m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -2865,15 +2865,15 @@ func TestOrderRatesIntervalsFullDay(t *testing.T) {
 			},
 		},
 	}
-	thourDecimal, err := utils.NewDecimalFromUnit("30h")
+	thourDecimal, err := utils.NewDecimalFromUsage("30h")
 	if err != nil {
 		t.Error(err)
 	}
-	dminDecimal, err := utils.NewDecimalFromUnit("2m")
+	dminDecimal, err := utils.NewDecimalFromUsage("2m")
 	if err != nil {
 		t.Error(err)
 	}
-	fminDecimal, err := utils.NewDecimalFromUnit("5m")
+	fminDecimal, err := utils.NewDecimalFromUsage("5m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3011,15 +3011,15 @@ func TestOrderRatesIntervalsFullDay(t *testing.T) {
 }
 
 func TestComputeRatesIntervalsEveryTwoSeconds(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("10s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("10s")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	twsecDecimal, err := utils.NewDecimalFromUnit("2s")
+	twsecDecimal, err := utils.NewDecimalFromUsage("2s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3199,15 +3199,15 @@ func TestComputeRatesIntervalsEveryTwoSeconds(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsOneHourRate(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("15m")
+	minDecimal, err := utils.NewDecimalFromUsage("15m")
 	if err != nil {
 		t.Error(err)
 	}
-	fminDeminal, err := utils.NewDecimalFromUnit("5m")
+	fminDeminal, err := utils.NewDecimalFromUsage("5m")
 	if err != nil {
 		t.Error(err)
 	}
-	cDecimal, err := utils.NewDecimalFromUnit("1m30s")
+	cDecimal, err := utils.NewDecimalFromUsage("1m30s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3228,11 +3228,11 @@ func TestComputeRateSIntervalsOneHourRate(t *testing.T) {
 			},
 		},
 	}
-	tminDeminal, err := utils.NewDecimalFromUnit("10m")
+	tminDeminal, err := utils.NewDecimalFromUsage("10m")
 	if err != nil {
 		t.Error(err)
 	}
-	ominDeminal, err := utils.NewDecimalFromUnit("1m")
+	ominDeminal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3351,11 +3351,11 @@ func TestComputeRateSIntervalsOneHourRate(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsCompressIncrements(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3463,24 +3463,24 @@ func TestComputeRateSIntervalsCompressIncrements(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsStartAfterIntervalStartDifferentRates(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
 
-	tminDecimal, err := utils.NewDecimalFromUnit("10m")
+	tminDecimal, err := utils.NewDecimalFromUsage("10m")
 	if err != nil {
 		t.Error(err)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	tensecDecimal, err := utils.NewDecimalFromUnit("10s")
+	tensecDecimal, err := utils.NewDecimalFromUsage("10s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3508,11 +3508,11 @@ func TestComputeRateSIntervalsStartAfterIntervalStartDifferentRates(t *testing.T
 			},
 		},
 	}
-	twminDecimal, err := utils.NewDecimalFromUnit("20m")
+	twminDecimal, err := utils.NewDecimalFromUsage("20m")
 	if err != nil {
 		t.Error(err)
 	}
-	twsecDecimal, err := utils.NewDecimalFromUnit("20s")
+	twsecDecimal, err := utils.NewDecimalFromUsage("20s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3528,7 +3528,7 @@ func TestComputeRateSIntervalsStartAfterIntervalStartDifferentRates(t *testing.T
 			},
 		},
 	}
-	trminDecimal, err := utils.NewDecimalFromUnit("30m")
+	trminDecimal, err := utils.NewDecimalFromUsage("30m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3641,35 +3641,35 @@ func TestComputeRateSIntervalsStartAfterIntervalStartDifferentRates(t *testing.T
 }
 
 func TestComputeRateSIntervalsStartAfterIntervalStartSameRate(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("30s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("30s")
 	if err != nil {
 		t.Error(err)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	twsecDecimal, err := utils.NewDecimalFromUnit("20s")
+	twsecDecimal, err := utils.NewDecimalFromUsage("20s")
 	if err != nil {
 		t.Error(err)
 	}
-	tssecDecimal, err := utils.NewDecimalFromUnit("10s")
+	tssecDecimal, err := utils.NewDecimalFromUsage("10s")
 	if err != nil {
 		t.Error(err)
 	}
-	tminDecimal, err := utils.NewDecimalFromUnit("10m")
+	tminDecimal, err := utils.NewDecimalFromUsage("10m")
 	if err != nil {
 		t.Error(err)
 	}
-	twminDecimal, err := utils.NewDecimalFromUnit("20m")
+	twminDecimal, err := utils.NewDecimalFromUsage("20m")
 	if err != nil {
 		t.Error(err)
 	}
-	thminDecimal, err := utils.NewDecimalFromUnit("30m")
+	thminDecimal, err := utils.NewDecimalFromUsage("30m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -3887,20 +3887,20 @@ func TestComputeRateSIntervalsStartAfterIntervalStartSameRate(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsHalfDayIntervals(t *testing.T) {
-	twminDecimal, err := utils.NewDecimalFromUnit("30m")
+	twminDecimal, err := utils.NewDecimalFromUsage("30m")
 	if err != nil {
 		t.Error(err)
 	}
 
-	nminDecimal, err := utils.NewDecimalFromUnit("9m")
+	nminDecimal, err := utils.NewDecimalFromUsage("9m")
 	if err != nil {
 		t.Error(err)
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
@@ -4097,23 +4097,23 @@ func TestComputeRateSIntervalsHalfDayIntervals(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsConsecutiveRates(t *testing.T) {
-	fminDecimal, err := utils.NewDecimalFromUnit("15m")
+	fminDecimal, err := utils.NewDecimalFromUsage("15m")
 	if err != nil {
 		t.Error(err)
 	}
-	eminDecimal, err := utils.NewDecimalFromUnit("11m")
+	eminDecimal, err := utils.NewDecimalFromUsage("11m")
 	if err != nil {
 		t.Error(err)
 	}
-	nminDecimal, err := utils.NewDecimalFromUnit("9m")
+	nminDecimal, err := utils.NewDecimalFromUsage("9m")
 	if err != nil {
 		t.Error(err)
 	}
-	sminDecimal, err := utils.NewDecimalFromUnit("7m")
+	sminDecimal, err := utils.NewDecimalFromUsage("7m")
 	if err != nil {
 		t.Error(err)
 	}
-	fvminDecimal, err := utils.NewDecimalFromUnit("5m")
+	fvminDecimal, err := utils.NewDecimalFromUsage("5m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -4228,27 +4228,27 @@ func TestComputeRateSIntervalsConsecutiveRates(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsRatesByMinutes(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("2s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("2s")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	tminDecimal, err := utils.NewDecimalFromUnit("2m")
+	tminDecimal, err := utils.NewDecimalFromUsage("2m")
 	if err != nil {
 		t.Error(err)
 	}
-	sminDecimal, err := utils.NewDecimalFromUnit("6m")
+	sminDecimal, err := utils.NewDecimalFromUsage("6m")
 	if err != nil {
 		t.Error(err)
 	}
-	nminDecimal, err := utils.NewDecimalFromUnit("9m")
+	nminDecimal, err := utils.NewDecimalFromUsage("9m")
 	if err != nil {
 		t.Error(err)
 	}
-	eminDecimal, err := utils.NewDecimalFromUnit("8m")
+	eminDecimal, err := utils.NewDecimalFromUsage("8m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -4362,23 +4362,23 @@ func TestComputeRateSIntervalsRatesByMinutes(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsSwitchingRates2(t *testing.T) {
-	tsecDecimal, err := utils.NewDecimalFromUnit("2s")
+	tsecDecimal, err := utils.NewDecimalFromUsage("2s")
 	if err != nil {
 		t.Error(err)
 	}
-	tminDecimal, err := utils.NewDecimalFromUnit("2m")
+	tminDecimal, err := utils.NewDecimalFromUsage("2m")
 	if err != nil {
 		t.Error(err)
 	}
-	ttminDecimal, err := utils.NewDecimalFromUnit("10m")
+	ttminDecimal, err := utils.NewDecimalFromUsage("10m")
 	if err != nil {
 		t.Error(err)
 	}
-	fsecDecimal, err := utils.NewDecimalFromUnit("4s")
+	fsecDecimal, err := utils.NewDecimalFromUsage("4s")
 	if err != nil {
 		t.Error(err)
 	}
-	fminDecimal, err := utils.NewDecimalFromUnit("4m")
+	fminDecimal, err := utils.NewDecimalFromUsage("4m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -4593,15 +4593,15 @@ func TestComputeRateSIntervalsSwitchingRates2(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsSOneWeekCall(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	hourDecimal, err := utils.NewDecimalFromUnit("1h")
+	hourDecimal, err := utils.NewDecimalFromUsage("1h")
 	if err != nil {
 		t.Error(err)
 	}
-	fminDecimal, err := utils.NewDecimalFromUnit("17m")
+	fminDecimal, err := utils.NewDecimalFromUsage("17m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -4679,19 +4679,19 @@ func TestComputeRateSIntervalsSOneWeekCall(t *testing.T) {
 }
 
 func TestComputeRateSIntervalsPauseBetweenRates(t *testing.T) {
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		t.Error(err)
 	}
-	fminDecimal, err := utils.NewDecimalFromUnit("5m")
+	fminDecimal, err := utils.NewDecimalFromUsage("5m")
 	if err != nil {
 		t.Error(err)
 	}
-	tminDecimal, err := utils.NewDecimalFromUnit("10m")
+	tminDecimal, err := utils.NewDecimalFromUsage("10m")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/rates/rates_test.go b/rates/rates_test.go
index 3032a6bc7..1ba5ae1b2 100644
--- a/rates/rates_test.go
+++ b/rates/rates_test.go
@@ -121,7 +121,7 @@ func TestRateProfileCostForEvent(t *testing.T) {
 	dm := engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
 	filters := engine.NewFilterS(defaultCfg, nil, dm)
 	rateS := NewRateS(defaultCfg, filters, dm)
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -217,7 +217,7 @@ func TestRateProfileCostForEventUnmatchEvent(t *testing.T) {
 	dm := engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
 	filters := engine.NewFilterS(defaultCfg, nil, dm)
 	rateS := NewRateS(defaultCfg, filters, dm)
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -447,7 +447,7 @@ func TestV1CostForEventError(t *testing.T) {
 	dm := engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
 	filters := engine.NewFilterS(defaultCfg, nil, dm)
 	rateS := NewRateS(defaultCfg, filters, dm)
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -531,11 +531,11 @@ func BenchmarkRateS_V1CostForEvent(b *testing.B) {
 		filterS: filters,
 		dm:      dm,
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		b.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		b.Error(err)
 	}
@@ -626,11 +626,11 @@ func BenchmarkRateS_V1CostForEventSingleRate(b *testing.B) {
 		filterS: filters,
 		dm:      dm,
 	}
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		b.Error(err)
 	}
-	secDecimal, err := utils.NewDecimalFromUnit("1s")
+	secDecimal, err := utils.NewDecimalFromUsage("1s")
 	if err != nil {
 		b.Error(err)
 	}
@@ -711,7 +711,7 @@ func TestRateProfileCostForEventInvalidUsage(t *testing.T) {
 	filters := engine.NewFilterS(defaultCfg, nil, dm)
 
 	rateS := NewRateS(defaultCfg, filters, dm)
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -782,7 +782,7 @@ func TestRateProfileCostForEventZeroIncrement(t *testing.T) {
 	filters := engine.NewFilterS(defaultCfg, nil, dm)
 
 	rateS := NewRateS(defaultCfg, filters, dm)
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
@@ -837,7 +837,7 @@ func TestRateProfileCostForEventMaximumIterations(t *testing.T) {
 	filters := engine.NewFilterS(defaultCfg, nil, dm)
 
 	rateS := NewRateS(defaultCfg, filters, dm)
-	minDecimal, err := utils.NewDecimalFromUnit("1m")
+	minDecimal, err := utils.NewDecimalFromUsage("1m")
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/utils/decimal.go b/utils/decimal.go
index 03ed26d57..e1353fbe4 100644
--- a/utils/decimal.go
+++ b/utils/decimal.go
@@ -59,8 +59,8 @@ func NewDecimalFromFloat64(f float64) *Decimal {
 	return &Decimal{d}
 }
 
-// NewDecimalFromUnit is a constructor for Decimal out of unit represents as string
-func NewDecimalFromUnit(u string) (d *Decimal, err error) {
+// NewDecimalFromUsage is a constructor for Decimal out of unit represents as string
+func NewDecimalFromUsage(u string) (d *Decimal, err error) {
 	switch {
 	//"ns", "us" (or "µs"), "ms", "s", "m", "h"
 	case strings.HasSuffix(u, NsSuffix), strings.HasSuffix(u, UsSuffix), strings.HasSuffix(u, µSuffix), strings.HasSuffix(u, MsSuffix),
diff --git a/utils/decimal_test.go b/utils/decimal_test.go
index 48b8982ae..7211d2002 100644
--- a/utils/decimal_test.go
+++ b/utils/decimal_test.go
@@ -56,7 +56,7 @@ func TestNewDecimalAdd(t *testing.T) {
 }
 
 func TestNewDecimalFromUnit(t *testing.T) {
-	if val, err := NewDecimalFromUnit("1ns"); err != nil {
+	if val, err := NewDecimalFromUsage("1ns"); err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(val, NewDecimal(1, 0)) {
 		t.Errorf("Expected %+v, received %+v", NewDecimal(1, 0), val)