From cb81280b3a96621e745bf50e370063b5dc284731 Mon Sep 17 00:00:00 2001 From: porosnicuadrian Date: Fri, 18 Dec 2020 11:56:41 +0200 Subject: [PATCH] Test for loaders by adding caching apiers --- loaders/lib_test.go | 794 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 790 insertions(+), 4 deletions(-) diff --git a/loaders/lib_test.go b/loaders/lib_test.go index b154f8dda..7b373a9ab 100644 --- a/loaders/lib_test.go +++ b/loaders/lib_test.go @@ -69,8 +69,104 @@ func (s *testMockCacheConn) Call(method string, arg interface{}, rply interface{ } } -func TestProcessContentCalls(t *testing.T) { +func TestProcessContentCallsLoadCache(t *testing.T) { sMock := &testMockCacheConn{ + calls: map[string]func(arg interface{}, rply interface{}) error{ + utils.CacheSv1LoadCache: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type: %T", rply) + } + *prply = utils.OK + return nil + }, + utils.CacheSv1Clear: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + }, + } + internalCacheSChann := make(chan rpcclient.ClientConnector, 1) + internalCacheSChann <- sMock + data := engine.NewInternalDB(nil, nil, true) + ldr := &Loader{ + ldrID: "TestProcessContentCallsLoadCache", + bufLoaderData: make(map[string][]LoaderData), + dm: engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil), + connMgr: engine.NewConnManager(config.CgrConfig(), map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): internalCacheSChann, + }), + cacheConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, + timezone: "UTC", + } + ldr.dataTpls = map[string][]*config.FCTemplate{ + utils.MetaRateProfiles: { + {Tag: "TenantID", + Path: "Tenant", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.0", utils.INFIELD_SEP), + Mandatory: true}, + {Tag: "ProfileID", + Path: "ID", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.1", utils.INFIELD_SEP), + Mandatory: true}, + {Tag: "Weight", + Path: "Weight", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.2", utils.INFIELD_SEP)}, + }, + } + ratePrfCsv := ` +#Tenant[0],ID[1],Weight[2] +cgrates.org,MOCK_RELOAD_ID,20 +` + rdr := ioutil.NopCloser(strings.NewReader(ratePrfCsv)) + rdrCsv := csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaRateProfiles: { + utils.RateProfilesCsv: &openedCSVFile{ + fileName: utils.RateProfilesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + if err := ldr.processContent(utils.MetaRateProfiles, utils.MetaLoad); err != nil { + t.Error(err) + } + + // Calling the method again while cacheConnsID is not valid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(ratePrfCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaRateProfiles: { + utils.RateProfilesCsv: &openedCSVFile{ + fileName: utils.RateProfilesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + expected := "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.processContent(utils.MetaRateProfiles, utils.MetaLoad); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } +} + +func TestProcessContentCallsReloadCache(t *testing.T) { + // Clear cache because connManager sets the internal connection in cache + engine.Cache.Clear([]string{utils.CacheRPCConnections}) + + sMock2 := &testMockCacheConn{ calls: map[string]func(arg interface{}, rply interface{}) error{ utils.CacheSv1ReloadCache: func(arg interface{}, rply interface{}) error { prply, can := rply.(*string) @@ -95,7 +191,7 @@ func TestProcessContentCalls(t *testing.T) { data := engine.NewInternalDB(nil, nil, true) internalCacheSChan := make(chan rpcclient.ClientConnector, 1) - internalCacheSChan <- sMock + internalCacheSChan <- sMock2 ldr := &Loader{ ldrID: "TestProcessContentCalls", bufLoaderData: make(map[string][]LoaderData), @@ -124,11 +220,11 @@ func TestProcessContentCalls(t *testing.T) { Value: config.NewRSRParsersMustCompile("~*req.2", utils.INFIELD_SEP)}, }, } - thresholdsCsv := ` + ratePrfCsv := ` #Tenant[0],ID[1],Weight[2] cgrates.org,MOCK_RELOAD_ID,20 ` - rdr := ioutil.NopCloser(strings.NewReader(thresholdsCsv)) + rdr := ioutil.NopCloser(strings.NewReader(ratePrfCsv)) rdrCsv := csv.NewReader(rdr) rdrCsv.Comment = '#' ldr.rdrs = map[string]map[string]*openedCSVFile{ @@ -143,4 +239,694 @@ cgrates.org,MOCK_RELOAD_ID,20 if err := ldr.processContent(utils.MetaRateProfiles, utils.MetaReload); err != nil { t.Error(err) } + + // Calling the method again while cacheConnsID is not valid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(ratePrfCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaRateProfiles: { + utils.RateProfilesCsv: &openedCSVFile{ + fileName: utils.RateProfilesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + expected := "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.processContent(utils.MetaRateProfiles, utils.MetaReload); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } +} + +func TestProcessContentCallsRemoveItems(t *testing.T) { + // Clear cache because connManager sets the internal connection in cache + engine.Cache.Clear([]string{utils.CacheRPCConnections}) + + sMock := &testMockCacheConn{ + calls: map[string]func(arg interface{}, rply interface{}) error{ + utils.CacheSv1RemoveItems: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + utils.CacheSv1Clear: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + }, + } + data := engine.NewInternalDB(nil, nil, true) + + internalCacheSChan := make(chan rpcclient.ClientConnector, 1) + internalCacheSChan <- sMock + ldr := &Loader{ + ldrID: "TestProcessContentCallsRemoveItems", + bufLoaderData: make(map[string][]LoaderData), + connMgr: engine.NewConnManager(config.CgrConfig(), map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): internalCacheSChan, + }), + dm: engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil), + cacheConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, + timezone: "UTC", + } + ldr.dataTpls = map[string][]*config.FCTemplate{ + utils.MetaAttributes: { + {Tag: "TenantID", + Path: "Tenant", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.0", utils.INFIELD_SEP), + Mandatory: true}, + {Tag: "ProfileID", + Path: "ID", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.1", utils.INFIELD_SEP), + Mandatory: true}, + }, + } + attributeCsv := ` +#Tenant[0],ID[1] +cgrates.org,MOCK_RELOAD_ID +` + rdr := ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv := csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + if err := ldr.processContent(utils.MetaAttributes, utils.MetaRemove); err != nil { + t.Error(err) + } + + // Calling the method again while cacheConnsID is not valid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + expected := "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.processContent(utils.MetaAttributes, utils.MetaRemove); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + + // Calling the method again while caching method is invalid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + expected = "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.processContent(utils.MetaAttributes, "invalid_caching_api"); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } +} + +func TestProcessContentCallsClear(t *testing.T) { + // Clear cache because connManager sets the internal connection in cache + engine.Cache.Clear([]string{utils.CacheRPCConnections}) + + sMock := &testMockCacheConn{ + calls: map[string]func(arg interface{}, rply interface{}) error{ + utils.CacheSv1Clear: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + }, + } + data := engine.NewInternalDB(nil, nil, true) + + internalCacheSChan := make(chan rpcclient.ClientConnector, 1) + internalCacheSChan <- sMock + ldr := &Loader{ + ldrID: "TestProcessContentCallsClear", + bufLoaderData: make(map[string][]LoaderData), + connMgr: engine.NewConnManager(config.CgrConfig(), map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): internalCacheSChan, + }), + dm: engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil), + cacheConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, + timezone: "UTC", + } + ldr.dataTpls = map[string][]*config.FCTemplate{ + utils.MetaAttributes: { + {Tag: "TenantID", + Path: "Tenant", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.0", utils.INFIELD_SEP), + Mandatory: true}, + {Tag: "ProfileID", + Path: "ID", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.1", utils.INFIELD_SEP), + Mandatory: true}, + }, + } + attributeCsv := ` +#Tenant[0],ID[1] +cgrates.org,MOCK_RELOAD_ID +` + rdr := ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv := csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + if err := ldr.processContent(utils.MetaAttributes, utils.MetaClear); err != nil { + t.Error(err) + } + + //inexisting method(*none) of cache and reinitialized the reader will do nothing + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + if err := ldr.processContent(utils.MetaAttributes, utils.META_NONE); err != nil { + t.Error(err) + } + + // Calling the method again while cacheConnsID is not valid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + expected := "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.processContent(utils.MetaAttributes, utils.MetaClear); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } +} + +func TestRemoveContentCallsReload(t *testing.T) { + // Clear cache because connManager sets the internal connection in cache + engine.Cache.Clear([]string{utils.CacheRPCConnections}) + + sMock := &testMockCacheConn{ + calls: map[string]func(arg interface{}, rply interface{}) error{ + utils.CacheSv1ReloadCache: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + utils.CacheSv1Clear: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + }, + } + data := engine.NewInternalDB(nil, nil, true) + + internalCacheSChan := make(chan rpcclient.ClientConnector, 1) + internalCacheSChan <- sMock + ldr := &Loader{ + ldrID: "TestRemoveContentCallsReload", + bufLoaderData: make(map[string][]LoaderData), + connMgr: engine.NewConnManager(config.CgrConfig(), map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): internalCacheSChan, + }), + cacheConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, + dm: engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil), + timezone: "UTC", + } + ldr.dataTpls = map[string][]*config.FCTemplate{ + utils.MetaAttributes: { + {Tag: "TenantID", + Path: "Tenant", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.0", utils.INFIELD_SEP), + Mandatory: true}, + {Tag: "ProfileID", + Path: "ID", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.1", utils.INFIELD_SEP), + Mandatory: true}, + }, + } + attributeCsv := ` +#Tenant[0],ID[1] +cgrates.org,MOCK_RELOAD_2 +` + rdr := ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv := csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + attrPrf := &engine.AttributeProfile{ + Tenant: "cgrates.org", + ID: "MOCK_RELOAD_2", + } + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + if err := ldr.removeContent(utils.MetaAttributes, utils.MetaReload); err != nil { + t.Error(err) + } + + //Calling the method again while cacheConnsID is not valid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + + //set and remove again from database + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + expected := "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.removeContent(utils.MetaAttributes, utils.MetaReload); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } +} + +func TestRemoveContentCallsLoad(t *testing.T) { + // Clear cache because connManager sets the internal connection in cache + engine.Cache.Clear([]string{utils.CacheRPCConnections}) + + sMock := &testMockCacheConn{ + calls: map[string]func(arg interface{}, rply interface{}) error{ + utils.CacheSv1LoadCache: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + utils.CacheSv1Clear: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + }, + } + data := engine.NewInternalDB(nil, nil, true) + + internalCacheSChan := make(chan rpcclient.ClientConnector, 1) + internalCacheSChan <- sMock + ldr := &Loader{ + ldrID: "TestRemoveContentCallsReload", + bufLoaderData: make(map[string][]LoaderData), + connMgr: engine.NewConnManager(config.CgrConfig(), map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): internalCacheSChan, + }), + cacheConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, + dm: engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil), + timezone: "UTC", + } + ldr.dataTpls = map[string][]*config.FCTemplate{ + utils.MetaAttributes: { + {Tag: "TenantID", + Path: "Tenant", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.0", utils.INFIELD_SEP), + Mandatory: true}, + {Tag: "ProfileID", + Path: "ID", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.1", utils.INFIELD_SEP), + Mandatory: true}, + }, + } + attributeCsv := ` +#Tenant[0],ID[1] +cgrates.org,MOCK_RELOAD_3 +` + rdr := ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv := csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + attrPrf := &engine.AttributeProfile{ + Tenant: "cgrates.org", + ID: "MOCK_RELOAD_3", + } + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + if err := ldr.removeContent(utils.MetaAttributes, utils.MetaLoad); err != nil { + t.Error(err) + } + + //Calling the method again while cacheConnsID is not valid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + + //set and remove again from database + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + expected := "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.removeContent(utils.MetaAttributes, utils.MetaLoad); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } +} + +func TestRemoveContentCallsRemove(t *testing.T) { + // Clear cache because connManager sets the internal connection in cache + engine.Cache.Clear([]string{utils.CacheRPCConnections}) + + sMock := &testMockCacheConn{ + calls: map[string]func(arg interface{}, rply interface{}) error{ + utils.CacheSv1RemoveItems: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + utils.CacheSv1Clear: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + }, + } + data := engine.NewInternalDB(nil, nil, true) + + internalCacheSChan := make(chan rpcclient.ClientConnector, 1) + internalCacheSChan <- sMock + ldr := &Loader{ + ldrID: "TestRemoveContentCallsReload", + bufLoaderData: make(map[string][]LoaderData), + connMgr: engine.NewConnManager(config.CgrConfig(), map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): internalCacheSChan, + }), + cacheConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, + dm: engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil), + timezone: "UTC", + } + ldr.dataTpls = map[string][]*config.FCTemplate{ + utils.MetaAttributes: { + {Tag: "TenantID", + Path: "Tenant", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.0", utils.INFIELD_SEP), + Mandatory: true}, + {Tag: "ProfileID", + Path: "ID", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.1", utils.INFIELD_SEP), + Mandatory: true}, + }, + } + attributeCsv := ` +#Tenant[0],ID[1] +cgrates.org,MOCK_RELOAD_4 +` + rdr := ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv := csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + attrPrf := &engine.AttributeProfile{ + Tenant: "cgrates.org", + ID: "MOCK_RELOAD_4", + } + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + if err := ldr.removeContent(utils.MetaAttributes, utils.MetaRemove); err != nil { + t.Error(err) + } + + //Calling the method again while cacheConnsID is not valid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + + //set and remove again from database + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + expected := "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.removeContent(utils.MetaAttributes, utils.MetaRemove); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + + //inexisting method(*none) of cache and reinitialized the reader will do nothing + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + if err := ldr.removeContent(utils.MetaAttributes, utils.META_NONE); err != nil { + t.Error(err) + } +} + +func TestRemoveContentCallsClear(t *testing.T) { + // Clear cache because connManager sets the internal connection in cache + engine.Cache.Clear([]string{utils.CacheRPCConnections}) + + sMock := &testMockCacheConn{ + calls: map[string]func(arg interface{}, rply interface{}) error{ + utils.CacheSv1Clear: func(arg interface{}, rply interface{}) error { + prply, can := rply.(*string) + if !can { + t.Errorf("Wrong argument type : %T", rply) + return nil + } + *prply = utils.OK + return nil + }, + }, + } + data := engine.NewInternalDB(nil, nil, true) + + internalCacheSChan := make(chan rpcclient.ClientConnector, 1) + internalCacheSChan <- sMock + ldr := &Loader{ + ldrID: "TestRemoveContentCallsReload", + bufLoaderData: make(map[string][]LoaderData), + connMgr: engine.NewConnManager(config.CgrConfig(), map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): internalCacheSChan, + }), + cacheConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, + dm: engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil), + timezone: "UTC", + } + ldr.dataTpls = map[string][]*config.FCTemplate{ + utils.MetaAttributes: { + {Tag: "TenantID", + Path: "Tenant", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.0", utils.INFIELD_SEP), + Mandatory: true}, + {Tag: "ProfileID", + Path: "ID", + Type: utils.META_COMPOSED, + Value: config.NewRSRParsersMustCompile("~*req.1", utils.INFIELD_SEP), + Mandatory: true}, + }, + } + attributeCsv := ` +#Tenant[0],ID[1] +cgrates.org,MOCK_RELOAD_3 +` + rdr := ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv := csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + attrPrf := &engine.AttributeProfile{ + Tenant: "cgrates.org", + ID: "MOCK_RELOAD_3", + } + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + if err := ldr.removeContent(utils.MetaAttributes, utils.MetaClear); err != nil { + t.Error(err) + } + + //Calling the method again while cacheConnsID is not valid + ldr.cacheConns = []string{utils.MetaInternal} + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + + //set and remove again from database + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + expected := "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.removeContent(utils.MetaAttributes, utils.MetaClear); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + + // Calling the method again while caching method is invalid + rdr = ioutil.NopCloser(strings.NewReader(attributeCsv)) + rdrCsv = csv.NewReader(rdr) + rdrCsv.Comment = '#' + ldr.rdrs = map[string]map[string]*openedCSVFile{ + utils.MetaAttributes: { + utils.AttributesCsv: &openedCSVFile{ + fileName: utils.AttributesCsv, + rdr: rdr, + csvRdr: rdrCsv, + }, + }, + } + if err := ldr.dm.SetAttributeProfile(attrPrf, true); err != nil { + t.Error(err) + } + expected = "UNSUPPORTED_SERVICE_METHOD" + if err := ldr.removeContent(utils.MetaAttributes, "invalid_caching_api"); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } }