Updated caches integration tests

apier/v1/cache_it_test.go

@@ -1,254 +0,0 @@
-// +build integration
-
-/*
-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 v1
-
-import (
-	"net/rpc"
-	"net/rpc/jsonrpc"
-	"path"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/cgrates/cgrates/config"
-	"github.com/cgrates/cgrates/engine"
-	"github.com/cgrates/cgrates/utils"
-	"github.com/cgrates/ltcache"
-)
-
-var (
-	chcCfg     *config.CGRConfig
-	chcRPC     *rpc.Client
-	chcCfgPath string
-	chcCfgDir  string
-)
-
-var sTestsCacheSV1 = []func(t *testing.T){
-	testCacheLoadConfig,
-	testCacheInitDataDb,
-	testCacheInitStorDb,
-	testCacheStartEngine,
-	testCacheRpcConn,
-	testCacheLoadTariffPlanFromFolder,
-	testCacheAfterLoadFromFolder,
-	testCacheFlush,
-	testCacheReload,
-	// testCacheReloadCache,
-	testCacheGetCacheKeys,
-
-	testCacheStopEngine,
-}
-
-// Test start here
-func TestCacheSv1ITMySQL(t *testing.T) {
-	chcCfgDir = "tutmysql"
-	for _, stest := range sTestsCacheSV1 {
-		t.Run(chcCfgDir, stest)
-	}
-}
-
-func TestCacheSv1ITMongo(t *testing.T) {
-	chcCfgDir = "tutmongo"
-	for _, stest := range sTestsCacheSV1 {
-		t.Run(chcCfgDir, stest)
-	}
-}
-
-func testCacheLoadConfig(t *testing.T) {
-	var err error
-	chcCfgPath = path.Join(*dataDir, "conf", "samples", chcCfgDir)
-	if chcCfg, err = config.NewCGRConfigFromPath(chcCfgPath); err != nil {
-		t.Error(err)
-	}
-}
-
-func testCacheInitDataDb(t *testing.T) {
-	if err := engine.InitDataDb(chcCfg); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Empty tables before using them
-func testCacheInitStorDb(t *testing.T) {
-	if err := engine.InitStorDb(chcCfg); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Start engine
-func testCacheStartEngine(t *testing.T) {
-	if _, err := engine.StopStartEngine(chcCfgPath, *waitRater); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func testCacheRpcConn(t *testing.T) {
-	var err error
-	chcRPC, err = jsonrpc.Dial("tcp", chcCfg.ListenCfg().RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed
-	if err != nil {
-		t.Fatal("Could not connect to RPC: ", err.Error())
-	}
-}
-
-func testCacheLoadTariffPlanFromFolder(t *testing.T) {
-	var reply string
-	attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testtp")}
-	if err := chcRPC.Call("ApierV1.LoadTariffPlanFromFolder", attrs, &reply); err != nil {
-		t.Error(err)
-	}
-	time.Sleep(time.Duration(*waitRater) * time.Millisecond)
-}
-
-func testCacheAfterLoadFromFolder(t *testing.T) {
-	var rcvStats map[string]*ltcache.CacheStats
-	expStats := engine.GetDefaultEmptyCacheStats()
-	expStats[utils.CacheAccountActionPlans].Items = 13
-	expStats[utils.CacheActionPlans].Items = 7
-	expStats[utils.CacheActions].Items = 6
-	expStats[utils.CacheDestinations].Items = 3
-	if err := chcRPC.Call("CacheSv1.GetCacheStats", nil, &rcvStats); err != nil {
-		t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
-	} else if !reflect.DeepEqual(expStats, rcvStats) {
-		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
-	}
-	reply := ""
-	// Simple test that command is executed without errors
-	if err := chcRPC.Call("CacheSv1.LoadCache", utils.AttrReloadCache{}, &reply); err != nil {
-		t.Error(err)
-	} else if reply != "OK" {
-		t.Error(reply)
-	}
-	expStats[utils.CacheActionTriggers].Items = 1
-	expStats[utils.CacheActions].Items = 13
-	expStats[utils.CacheAttributeProfiles].Items = 1
-	expStats[utils.CacheFilters].Items = 15
-	expStats[utils.CacheRatingPlans].Items = 5
-	expStats[utils.CacheRatingProfiles].Items = 5
-	expStats[utils.CacheResourceProfiles].Items = 3
-	expStats[utils.CacheResources].Items = 3
-	expStats[utils.CacheReverseDestinations].Items = 5
-	expStats[utils.CacheStatQueueProfiles].Items = 1
-	expStats[utils.CacheStatQueues].Items = 1
-	expStats[utils.CacheSupplierProfiles].Items = 2
-	expStats[utils.CacheThresholdProfiles].Items = 1
-	expStats[utils.CacheThresholds].Items = 1
-
-	if err := chcRPC.Call("CacheSv1.GetCacheStats", nil, &rcvStats); err != nil {
-		t.Error(err)
-	} else if !reflect.DeepEqual(expStats, rcvStats) {
-		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
-	}
-}
-
-func testCacheFlush(t *testing.T) {
-	reply := ""
-	if err := chcRPC.Call("CacheSv1.FlushCache", utils.AttrReloadCache{FlushAll: true}, &reply); err != nil {
-		t.Error("Got error on CacheSv1.ReloadCache: ", err.Error())
-	} else if reply != utils.OK {
-		t.Error("Calling CacheSv1.ReloadCache got reply: ", reply)
-	}
-	var rcvStats map[string]*ltcache.CacheStats
-	expStats := engine.GetDefaultEmptyCacheStats()
-	if err := chcRPC.Call("CacheSv1.GetCacheStats", nil, &rcvStats); err != nil {
-		t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
-	} else if !reflect.DeepEqual(expStats, rcvStats) {
-		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
-	}
-}
-
-func testCacheReloadCache(t *testing.T) {
-	reply := ""
-	arc := new(utils.AttrReloadCache)
-	if err := chcRPC.Call("CacheSv1.ReloadCache", arc, &reply); err != nil {
-		t.Error("Got error on CacheSv1.ReloadCache: ", err.Error())
-	} else if reply != "OK" {
-		t.Error("Calling CacheSv1.ReloadCache got reply: ", reply)
-	}
-	var rcvStats map[string]*ltcache.CacheStats
-	expectedStats := engine.GetDefaultEmptyCacheStats()
-
-	if err := chcRPC.Call("CacheSv1.GetCacheStats", nil, &rcvStats); err != nil {
-		t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
-	} else if !reflect.DeepEqual(expectedStats, rcvStats) {
-		t.Errorf("Calling CacheSv1.GetCacheStats expected: %+v, received: %+v", utils.ToJSON(expectedStats), utils.ToJSON(rcvStats))
-	}
-}
-
-func testCacheReload(t *testing.T) {
-	var rcvStats map[string]*ltcache.CacheStats
-	expStats := engine.GetDefaultEmptyCacheStats()
-	reply := ""
-	// Simple test that command is executed without errors
-	if err := chcRPC.Call("CacheSv1.LoadCache", utils.AttrReloadCache{}, &reply); err != nil {
-		t.Error(err)
-	} else if reply != "OK" {
-		t.Error(reply)
-	}
-	expStats[utils.CacheAccountActionPlans].Items = 13
-	expStats[utils.CacheActionPlans].Items = 7
-	expStats[utils.CacheActions].Items = 6
-	expStats[utils.CacheDestinations].Items = 3
-	expStats[utils.CacheActionTriggers].Items = 1
-	expStats[utils.CacheActions].Items = 13
-	expStats[utils.CacheAttributeProfiles].Items = 1
-	expStats[utils.CacheFilters].Items = 15
-	expStats[utils.CacheRatingPlans].Items = 5
-	expStats[utils.CacheRatingProfiles].Items = 5
-	expStats[utils.CacheResourceProfiles].Items = 3
-	expStats[utils.CacheResources].Items = 3
-	expStats[utils.CacheReverseDestinations].Items = 5
-	expStats[utils.CacheStatQueueProfiles].Items = 1
-	expStats[utils.CacheStatQueues].Items = 1
-	expStats[utils.CacheSupplierProfiles].Items = 2
-	expStats[utils.CacheThresholdProfiles].Items = 1
-	expStats[utils.CacheThresholds].Items = 1
-
-	if err := chcRPC.Call("CacheSv1.GetCacheStats", nil, &rcvStats); err != nil {
-		t.Error(err)
-	} else if !reflect.DeepEqual(expStats, rcvStats) {
-		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
-	}
-}
-
-func testCacheGetCacheKeys(t *testing.T) {
-
-	expKeys := utils.ArgsCache{
-		ThresholdProfileIDs: &[]string{"cgrates.org:Threshold1"},
-	}
-	var rcvKeys utils.ArgsCache
-	argsAPI := utils.ArgsCacheKeys{
-		ArgsCache: utils.ArgsCache{
-			ThresholdProfileIDs: &[]string{},
-			ResourceIDs:         &[]string{"NotExistent"},
-		},
-	}
-	if err := chcRPC.Call("CacheSv1.GetCacheKeys", argsAPI, &rcvKeys); err != nil {
-		t.Fatalf("Got error on ApierV1.GetCacheStats: %s ", err.Error())
-	}
-	if !reflect.DeepEqual(*expKeys.ThresholdProfileIDs, *rcvKeys.ThresholdProfileIDs) {
-		t.Errorf("Expected: %+v, received: %+v", expKeys.ThresholdProfileIDs, rcvKeys.ThresholdProfileIDs)
-	}
-}
-
-func testCacheStopEngine(t *testing.T) {
-	if err := engine.KillEngine(100); err != nil {
-		t.Error(err)
-	}
-}

apier/v1/caches.go

@@ -65,6 +65,11 @@ func (chSv1 *CacheSv1) Clear(cacheIDs []string,
 	return chSv1.cacheS.V1Clear(cacheIDs, reply)
 }
 
+// FlushCache wipes out cache for a prefix or completely
+func (chSv1 *CacheSv1) FlushCache(args utils.AttrReloadCache, reply *string) (err error) {
+	return chSv1.cacheS.V1FlushCache(args, reply)
+}
+
 // GetCacheStats returns CacheStats filtered by cacheIDs
 func (chSv1 *CacheSv1) GetCacheStats(cacheIDs []string,
 	rply *map[string]*ltcache.CacheStats) error {
@@ -104,17 +109,6 @@ func (chSv1 *CacheSv1) LoadCache(args utils.AttrReloadCache, reply *string) (err
 	return chSv1.cacheS.V1LoadCache(args, reply)
 }
 
-// FlushCache wipes out cache for a prefix or completely
-func (chSv1 *CacheSv1) FlushCache(args utils.AttrReloadCache, reply *string) (err error) {
-	return chSv1.cacheS.V1FlushCache(args, reply)
-}
-
-// GetCacheKeys returns a list of keys available in cache based on query arguments
-// If keys are provided in arguments, they will be checked for existence
-func (chSv1 *CacheSv1) GetCacheKeys(args utils.ArgsCacheKeys, reply *utils.ArgsCache) (err error) {
-	return chSv1.cacheS.V1GetCacheKeys(args, reply)
-}
-
 // Ping used to detreminate if component is active
 func (chSv1 *CacheSv1) Ping(ign *utils.CGREvent, reply *string) error {
 	*reply = utils.Pong

apier/v1/caches_it_test.go

@@ -0,0 +1,396 @@
+// +build integration
+
+/*
+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 v1
+
+import (
+	"net/rpc"
+	"net/rpc/jsonrpc"
+	"path"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+	"github.com/cgrates/ltcache"
+)
+
+var (
+	chcCfg     *config.CGRConfig
+	chcRPC     *rpc.Client
+	chcCfgPath string
+	chcCfgDir  string
+)
+
+var sTestsCacheSV1 = []func(t *testing.T){
+	testCacheSLoadConfig,
+	testCacheSInitDataDb,
+	testCacheSInitStorDb,
+	testCacheSStartEngine,
+	testCacheSRpcConn,
+	testCacheSLoadTariffPlanFromFolder,
+	testCacheSAfterLoadFromFolder,
+	testCacheSFlush,
+	testCacheSReload,
+	testCacheSGetItemIDs,
+	testCacheSHasItem,
+	testCacheSGetItemExpiryTime,
+	testCacheSReloadCache,
+	testCacheSRemoveItem,
+	testCacheSClear,
+	testCacheSReload,
+	testCacheSPrecacheStatus,
+	testCacheSPing,
+	testCacheSStopEngine,
+}
+
+// Test start here
+func TestCacheSv1ITMySQL(t *testing.T) {
+	chcCfgDir = "tutmysql"
+	for _, stest := range sTestsCacheSV1 {
+		t.Run(chcCfgDir, stest)
+	}
+}
+
+func TestCacheSv1ITMongo(t *testing.T) {
+	chcCfgDir = "tutmongo"
+	for _, stest := range sTestsCacheSV1 {
+		t.Run(chcCfgDir, stest)
+	}
+}
+
+func testCacheSLoadConfig(t *testing.T) {
+	var err error
+	chcCfgPath = path.Join(*dataDir, "conf", "samples", "precache", chcCfgDir)
+	if chcCfg, err = config.NewCGRConfigFromPath(chcCfgPath); err != nil {
+		t.Error(err)
+	}
+}
+
+func testCacheSInitDataDb(t *testing.T) {
+	if err := engine.InitDataDb(chcCfg); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// Empty tables before using them
+func testCacheSInitStorDb(t *testing.T) {
+	if err := engine.InitStorDb(chcCfg); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// Start engine
+func testCacheSStartEngine(t *testing.T) {
+	if _, err := engine.StopStartEngine(chcCfgPath, *waitRater); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func testCacheSRpcConn(t *testing.T) {
+	var err error
+	chcRPC, err = jsonrpc.Dial("tcp", chcCfg.ListenCfg().RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed
+	if err != nil {
+		t.Fatal("Could not connect to RPC: ", err.Error())
+	}
+}
+
+func testCacheSLoadTariffPlanFromFolder(t *testing.T) {
+	var reply string
+	attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testtp")}
+	if err := chcRPC.Call(utils.ApierV1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
+		t.Error(err)
+	}
+	time.Sleep(time.Duration(*waitRater) * time.Millisecond)
+}
+
+func testCacheSAfterLoadFromFolder(t *testing.T) {
+	var rcvStats map[string]*ltcache.CacheStats
+	expStats := engine.GetDefaultEmptyCacheStats()
+	expStats[utils.CacheAccountActionPlans].Items = 13
+	expStats[utils.CacheActionPlans].Items = 7
+	expStats[utils.CacheActions].Items = 6
+	expStats[utils.CacheDestinations].Items = 3
+	if err := chcRPC.Call(utils.CacheSv1GetCacheStats, nil, &rcvStats); err != nil {
+		t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
+	} else if !reflect.DeepEqual(expStats, rcvStats) {
+		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
+	}
+	reply := ""
+	// Simple test that command is executed without errors
+	if err := chcRPC.Call(utils.CacheSv1LoadCache, utils.AttrReloadCache{}, &reply); err != nil {
+		t.Error(err)
+	} else if reply != "OK" {
+		t.Error(reply)
+	}
+	expStats[utils.CacheActionTriggers].Items = 1
+	expStats[utils.CacheActions].Items = 13
+	expStats[utils.CacheAttributeProfiles].Items = 1
+	expStats[utils.CacheFilters].Items = 15
+	expStats[utils.CacheRatingPlans].Items = 5
+	expStats[utils.CacheRatingProfiles].Items = 5
+	expStats[utils.CacheResourceProfiles].Items = 3
+	expStats[utils.CacheResources].Items = 3
+	expStats[utils.CacheReverseDestinations].Items = 5
+	expStats[utils.CacheStatQueueProfiles].Items = 1
+	expStats[utils.CacheStatQueues].Items = 1
+	expStats[utils.CacheSupplierProfiles].Items = 2
+	expStats[utils.CacheThresholdProfiles].Items = 1
+	expStats[utils.CacheThresholds].Items = 1
+
+	if err := chcRPC.Call(utils.CacheSv1GetCacheStats, nil, &rcvStats); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expStats, rcvStats) {
+		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
+	}
+}
+
+func testCacheSFlush(t *testing.T) {
+	reply := ""
+	if err := chcRPC.Call(utils.CacheSv1FlushCache, utils.AttrReloadCache{FlushAll: true}, &reply); err != nil {
+		t.Error("Got error on CacheSv1.ReloadCache: ", err.Error())
+	} else if reply != utils.OK {
+		t.Error("Calling CacheSv1.ReloadCache got reply: ", reply)
+	}
+	var rcvStats map[string]*ltcache.CacheStats
+	expStats := engine.GetDefaultEmptyCacheStats()
+	if err := chcRPC.Call(utils.CacheSv1GetCacheStats, nil, &rcvStats); err != nil {
+		t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
+	} else if !reflect.DeepEqual(expStats, rcvStats) {
+		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
+	}
+}
+
+func testCacheSReload(t *testing.T) {
+	var rcvStats map[string]*ltcache.CacheStats
+	expStats := engine.GetDefaultEmptyCacheStats()
+	reply := ""
+	// Simple test that command is executed without errors
+	if err := chcRPC.Call(utils.CacheSv1LoadCache, utils.AttrReloadCache{}, &reply); err != nil {
+		t.Error(err)
+	} else if reply != "OK" {
+		t.Error(reply)
+	}
+	expStats[utils.CacheAccountActionPlans].Items = 13
+	expStats[utils.CacheActionPlans].Items = 7
+	expStats[utils.CacheActions].Items = 6
+	expStats[utils.CacheDestinations].Items = 3
+	expStats[utils.CacheActionTriggers].Items = 1
+	expStats[utils.CacheActions].Items = 13
+	expStats[utils.CacheAttributeProfiles].Items = 1
+	expStats[utils.CacheFilters].Items = 15
+	expStats[utils.CacheRatingPlans].Items = 5
+	expStats[utils.CacheRatingProfiles].Items = 5
+	expStats[utils.CacheResourceProfiles].Items = 3
+	expStats[utils.CacheResources].Items = 3
+	expStats[utils.CacheReverseDestinations].Items = 5
+	expStats[utils.CacheStatQueueProfiles].Items = 1
+	expStats[utils.CacheStatQueues].Items = 1
+	expStats[utils.CacheSupplierProfiles].Items = 2
+	expStats[utils.CacheThresholdProfiles].Items = 1
+	expStats[utils.CacheThresholds].Items = 1
+
+	if err := chcRPC.Call(utils.CacheSv1GetCacheStats, nil, &rcvStats); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expStats, rcvStats) {
+		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
+	}
+}
+
+func testCacheSGetItemIDs(t *testing.T) {
+	var rcvKeys []string
+	var expKeys []string
+	argsAPI := engine.ArgsGetCacheItemIDs{
+		CacheID:      utils.CacheThresholdProfiles,
+		ItemIDPrefix: "NotExistent",
+	}
+	if err := chcRPC.Call(utils.CacheSv1GetItemIDs, argsAPI, &rcvKeys); err == nil || err.Error() != utils.ErrNotFound.Error() {
+		t.Fatalf("Expected error: %s received error: %s and reply: %v ", utils.ErrNotFound, err.Error(), rcvKeys)
+	}
+
+	expKeys = []string{"cgrates.org:Threshold1"}
+	argsAPI = engine.ArgsGetCacheItemIDs{
+		CacheID: utils.CacheThresholdProfiles,
+	}
+	if err := chcRPC.Call(utils.CacheSv1GetItemIDs, argsAPI, &rcvKeys); err != nil {
+		t.Fatalf("Got error on ApierV1.GetCacheStats: %s ", err.Error())
+	}
+	if !reflect.DeepEqual(expKeys, rcvKeys) {
+		t.Errorf("Expected: %+v, received: %+v", expKeys, rcvKeys)
+	}
+}
+
+func testCacheSHasItem(t *testing.T) {
+	var reply bool
+	var expected bool
+	argsAPI := engine.ArgsGetCacheItem{
+		CacheID: utils.CacheThresholdProfiles,
+		ItemID:  "NotExistent",
+	}
+	if err := chcRPC.Call(utils.CacheSv1HasItem, argsAPI, &reply); err != nil {
+		t.Error(err)
+	} else if reply {
+		t.Errorf("Expected: %v , received:%v", expected, reply)
+	}
+
+	expected = true
+	argsAPI = engine.ArgsGetCacheItem{
+		CacheID: utils.CacheThresholdProfiles,
+		ItemID:  "cgrates.org:Threshold1",
+	}
+	if err := chcRPC.Call(utils.CacheSv1HasItem, argsAPI, &reply); err != nil {
+		t.Error(err)
+	} else if !reply {
+		t.Errorf("Expected: %v , received:%v", expected, reply)
+	}
+}
+
+func testCacheSGetItemExpiryTime(t *testing.T) {
+	var reply time.Time
+	var expected time.Time
+	argsAPI := engine.ArgsGetCacheItem{
+		CacheID: utils.CacheThresholdProfiles,
+		ItemID:  "NotExistent",
+	}
+	if err := chcRPC.Call(utils.CacheSv1GetItemExpiryTime, argsAPI, &reply); err == nil || err.Error() != utils.ErrNotFound.Error() {
+		t.Fatalf("Expected error: %s received error: %s and reply: %v ", utils.ErrNotFound, err.Error(), reply)
+	}
+
+	// expected = true
+	argsAPI = engine.ArgsGetCacheItem{
+		CacheID: utils.CacheThresholdProfiles,
+		ItemID:  "cgrates.org:Threshold1",
+	}
+	if err := chcRPC.Call(utils.CacheSv1GetItemExpiryTime, argsAPI, &reply); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, reply) {
+		t.Errorf("Expected: %v , received:%v", expected, reply)
+	}
+}
+
+func testCacheSReloadCache(t *testing.T) {
+	reply := ""
+	arc := new(utils.AttrReloadCache)
+	if err := chcRPC.Call(utils.CacheSv1ReloadCache, arc, &reply); err != nil {
+		t.Error("Got error on CacheSv1.ReloadCache: ", err.Error())
+	} else if reply != "OK" {
+		t.Error("Calling CacheSv1.ReloadCache got reply: ", reply)
+	}
+}
+
+func testCacheSRemoveItem(t *testing.T) {
+	var reply bool
+	argsAPI := engine.ArgsGetCacheItem{
+		CacheID: utils.CacheThresholdProfiles,
+		ItemID:  "cgrates.org:Threshold1",
+	}
+	if err := chcRPC.Call(utils.CacheSv1HasItem, argsAPI, &reply); err != nil {
+		t.Error(err)
+	} else if !reply {
+		t.Errorf("Expected: %v , received:%v", true, reply)
+	}
+	var remReply string
+	if err := chcRPC.Call(utils.CacheSv1RemoveItem, argsAPI, &remReply); err != nil {
+		t.Error(err)
+	} else if remReply != utils.OK {
+		t.Errorf("Expected: %v , received:%v", utils.OK, remReply)
+	}
+	if err := chcRPC.Call(utils.CacheSv1HasItem, argsAPI, &reply); err != nil {
+		t.Error(err)
+	} else if reply {
+		t.Errorf("Expected: %v , received:%v", false, reply)
+	}
+}
+
+func testCacheSClear(t *testing.T) {
+	reply := ""
+	if err := chcRPC.Call(utils.CacheSv1Clear, nil, &reply); err != nil {
+		t.Error(err)
+	} else if reply != utils.OK {
+		t.Error("Calling CacheSv1.ReloadCache got reply: ", reply)
+	}
+	var rcvStats map[string]*ltcache.CacheStats
+	expStats := engine.GetDefaultEmptyCacheStats()
+	if err := chcRPC.Call(utils.CacheSv1GetCacheStats, nil, &rcvStats); err != nil {
+		t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
+	} else if !reflect.DeepEqual(expStats, rcvStats) {
+		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(expStats), utils.ToJSON(rcvStats))
+	}
+}
+
+func testCacheSPrecacheStatus(t *testing.T) {
+	var reply map[string]string
+	expected := map[string]string{
+		utils.CacheDestinations:            utils.MetaReady,
+		utils.CacheReverseDestinations:     utils.MetaReady,
+		utils.CacheRatingPlans:             utils.MetaReady,
+		utils.CacheRatingProfiles:          utils.MetaReady,
+		utils.CacheActions:                 utils.MetaReady,
+		utils.CacheActionPlans:             utils.MetaReady,
+		utils.CacheAccountActionPlans:      utils.MetaReady,
+		utils.CacheActionTriggers:          utils.MetaReady,
+		utils.CacheSharedGroups:            utils.MetaReady,
+		utils.CacheResourceProfiles:        utils.MetaReady,
+		utils.CacheResources:               utils.MetaReady,
+		utils.CacheEventResources:          utils.MetaReady,
+		utils.CacheTimings:                 utils.MetaReady,
+		utils.CacheStatQueueProfiles:       utils.MetaReady,
+		utils.CacheStatQueues:              utils.MetaReady,
+		utils.CacheThresholdProfiles:       utils.MetaReady,
+		utils.CacheThresholds:              utils.MetaReady,
+		utils.CacheFilters:                 utils.MetaReady,
+		utils.CacheSupplierProfiles:        utils.MetaReady,
+		utils.CacheAttributeProfiles:       utils.MetaReady,
+		utils.CacheChargerProfiles:         utils.MetaReady,
+		utils.CacheDispatcherProfiles:      utils.MetaReady,
+		utils.CacheDiameterMessages:        utils.MetaReady,
+		utils.CacheAttributeFilterIndexes:  utils.MetaReady,
+		utils.CacheResourceFilterIndexes:   utils.MetaReady,
+		utils.CacheStatFilterIndexes:       utils.MetaReady,
+		utils.CacheThresholdFilterIndexes:  utils.MetaReady,
+		utils.CacheSupplierFilterIndexes:   utils.MetaReady,
+		utils.CacheChargerFilterIndexes:    utils.MetaReady,
+		utils.CacheDispatcherFilterIndexes: utils.MetaReady,
+	}
+
+	if err := chcRPC.Call(utils.CacheSv1PrecacheStatus, nil, &reply); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, reply) {
+		t.Errorf("Expected: %v , received:%v", utils.ToJSON(expected), utils.ToJSON(reply))
+	}
+}
+
+func testCacheSPing(t *testing.T) {
+	var reply string
+	expected := utils.Pong
+	if err := chcRPC.Call(utils.CacheSv1Ping, nil, &reply); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, reply) {
+		t.Errorf("Expected: %v , received:%v", utils.ToJSON(expected), utils.ToJSON(reply))
+	}
+
+}
+
+func testCacheSStopEngine(t *testing.T) {
+	if err := engine.KillEngine(100); err != nil {
+		t.Error(err)
+	}
+}

cmd/cgr-loader/cgr-loader.go

@@ -367,7 +367,7 @@ func main() {
 			if *verbose {
 				log.Print("Reloading cache")
 			}
-			if err = cacheS.Call(utils.ApierV1ReloadCache,
+			if err = cacheS.Call(utils.CacheSv1ReloadCache,
 				utils.AttrReloadCache{ArgsCache: utils.ArgsCache{
 					DestinationIDs:        &dstIds,
 					ReverseDestinationIDs: &revDstIDs,

console/cache_reload.go

@@ -23,7 +23,7 @@ import "github.com/cgrates/cgrates/utils"
 func init() {
 	c := &CmdReloadCache{
 		name:      "cache_reload",
-		rpcMethod: "ApierV1.ReloadCache",
+		rpcMethod: utils.CacheSv1ReloadCache,
 	}
 	commands[c.Name()] = c
 	c.CommandExecuter = &CommandExecuter{c}

engine/caches.go

@@ -125,11 +125,11 @@ type ArgsGetCacheItemIDs struct {
 
 func (chS *CacheS) V1GetItemIDs(args *ArgsGetCacheItemIDs,
 	reply *[]string) (err error) {
-	if itmIDs := Cache.GetItemIDs(args.CacheID, args.ItemIDPrefix); len(itmIDs) == 0 {
+	itmIDs := Cache.GetItemIDs(args.CacheID, args.ItemIDPrefix)
+	if len(itmIDs) == 0 {
 		return utils.ErrNotFound
-	} else {
-		*reply = itmIDs
 	}
+	*reply = itmIDs
 	return
 }
 
@@ -146,11 +146,11 @@ func (chS *CacheS) V1HasItem(args *ArgsGetCacheItem,
 
 func (chS *CacheS) V1GetItemExpiryTime(args *ArgsGetCacheItem,
 	reply *time.Time) (err error) {
-	if expTime, has := Cache.GetItemExpiryTime(args.CacheID, args.ItemID); !has {
+	expTime, has := Cache.GetItemExpiryTime(args.CacheID, args.ItemID)
+	if !has {
 		return utils.ErrNotFound
-	} else {
-		*reply = expTime
 	}
+	*reply = expTime
 	return
 }
 
@@ -401,153 +401,3 @@ func (chS *CacheS) V1FlushCache(args utils.AttrReloadCache, reply *string) (err
 	*reply = utils.OK
 	return
 }
-
-func getCacheKeys(chID string, IDs *[]string, paginator utils.Paginator) (ids []string) {
-	if len(*IDs) != 0 {
-		for _, id := range *IDs {
-			if _, hasIt := Cache.Get(chID, id); hasIt {
-				ids = append(ids, id)
-			}
-		}
-	} else {
-		for _, id := range Cache.GetItemIDs(chID, "") {
-			ids = append(ids, id)
-		}
-	}
-	return paginator.PaginateStringSlice(ids)
-}
-
-// GetCacheKeys returns a list of keys available in cache based on query arguments
-// If keys are provided in arguments, they will be checked for existence
-func (chS *CacheS) V1GetCacheKeys(args utils.ArgsCacheKeys, reply *utils.ArgsCache) (err error) {
-	if args.DestinationIDs != nil {
-		ids := getCacheKeys(utils.CacheDestinations, args.DestinationIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.DestinationIDs = &ids
-		}
-	}
-	if args.ReverseDestinationIDs != nil {
-		ids := getCacheKeys(utils.CacheReverseDestinations, args.ReverseDestinationIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ReverseDestinationIDs = &ids
-		}
-	}
-	if args.RatingPlanIDs != nil {
-		ids := getCacheKeys(utils.CacheRatingPlans, args.RatingPlanIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.RatingPlanIDs = &ids
-		}
-	}
-	if args.RatingProfileIDs != nil {
-		ids := getCacheKeys(utils.CacheRatingProfiles, args.RatingProfileIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.RatingProfileIDs = &ids
-		}
-	}
-	if args.ActionIDs != nil {
-		ids := getCacheKeys(utils.CacheActions, args.ActionIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ActionIDs = &ids
-		}
-	}
-	if args.ActionPlanIDs != nil {
-		ids := getCacheKeys(utils.CacheActionPlans, args.ActionPlanIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ActionPlanIDs = &ids
-		}
-	}
-	if args.AccountActionPlanIDs != nil {
-		ids := getCacheKeys(utils.CacheAccountActionPlans, args.AccountActionPlanIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.AccountActionPlanIDs = &ids
-		}
-	}
-	if args.ActionTriggerIDs != nil {
-		ids := getCacheKeys(utils.CacheActionTriggers, args.ActionTriggerIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ActionTriggerIDs = &ids
-		}
-	}
-	if args.SharedGroupIDs != nil {
-		ids := getCacheKeys(utils.CacheSharedGroups, args.SharedGroupIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.SharedGroupIDs = &ids
-		}
-	}
-	if args.ResourceProfileIDs != nil {
-		ids := getCacheKeys(utils.CacheResourceProfiles, args.ResourceProfileIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ResourceProfileIDs = &ids
-		}
-	}
-	if args.ResourceIDs != nil {
-		ids := getCacheKeys(utils.CacheResources, args.ResourceIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ResourceIDs = &ids
-		}
-	}
-	if args.StatsQueueIDs != nil {
-		ids := getCacheKeys(utils.CacheStatQueues, args.StatsQueueIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.StatsQueueIDs = &ids
-		}
-	}
-	if args.StatsQueueProfileIDs != nil {
-		ids := getCacheKeys(utils.CacheStatQueueProfiles, args.StatsQueueProfileIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.StatsQueueProfileIDs = &ids
-		}
-	}
-
-	if args.ThresholdIDs != nil {
-		ids := getCacheKeys(utils.CacheThresholds, args.ThresholdIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ThresholdIDs = &ids
-		}
-	}
-
-	if args.ThresholdProfileIDs != nil {
-		ids := getCacheKeys(utils.CacheThresholdProfiles, args.ThresholdProfileIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ThresholdProfileIDs = &ids
-		}
-	}
-	if args.FilterIDs != nil {
-		ids := getCacheKeys(utils.CacheFilters, args.FilterIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.FilterIDs = &ids
-		}
-	}
-	if args.SupplierProfileIDs != nil {
-		ids := getCacheKeys(utils.CacheSupplierProfiles, args.SupplierProfileIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.SupplierProfileIDs = &ids
-		}
-	}
-	if args.AttributeProfileIDs != nil {
-		ids := getCacheKeys(utils.CacheAttributeProfiles, args.AttributeProfileIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.AttributeProfileIDs = &ids
-		}
-	}
-	if args.ChargerProfileIDs != nil {
-		ids := getCacheKeys(utils.CacheChargerProfiles, args.ChargerProfileIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.ChargerProfileIDs = &ids
-		}
-	}
-	if args.DispatcherProfileIDs != nil {
-		ids := getCacheKeys(utils.CacheDispatcherProfiles, args.DispatcherProfileIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.DispatcherProfileIDs = &ids
-		}
-	}
-	if args.DispatcherRoutesIDs != nil {
-		ids := getCacheKeys(utils.CacheDispatcherRoutes, args.DispatcherRoutesIDs, args.Paginator)
-		if len(ids) != 0 {
-			reply.DispatcherRoutesIDs = &ids
-		}
-	}
-
-	return
-}

utils/consts.go

@@ -688,7 +688,6 @@ const (
 // ApierV1 APIs
 const (
 	ApierV1ComputeFilterIndexes     = "ApierV1.ComputeFilterIndexes"
-	ApierV1ReloadCache              = "ApierV1.ReloadCache"
 	ApierV1ReloadScheduler          = "ApierV1.ReloadScheduler"
 	ApierV1Ping                     = "ApierV1.Ping"
 	ApierV1SetDispatcherProfile     = "ApierV1.SetDispatcherProfile"
@@ -822,6 +821,10 @@ const (
 	CacheSv1GetGroupItemIDs   = "CacheSv1.GetGroupItemIDs"
 	CacheSv1RemoveGroup       = "CacheSv1.RemoveGroup"
 	CacheSv1Clear             = "CacheSv1.Clear"
+	CacheSv1ReloadCache       = "CacheSv1.ReloadCache"
+	CacheSv1LoadCache         = "CacheSv1.LoadCache"
+	CacheSv1FlushCache        = "CacheSv1.FlushCache"
+	CacheSv1Ping              = "CacheSv1.Ping"
 )
 
 // Cdrs APIs