/*
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 Affero 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 Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>
*/
package utils

import (
	"reflect"
	"strings"
	"testing"
	"time"
)

func TestTPDistinctIdsString(t *testing.T) {
	eIn1 := []string{"1", "2", "3", "4"}
	eIn2 := TPDistinctIds(eIn1)
	expected := strings.Join(eIn1, FIELDS_SEP)
	received := eIn2.String()

	if !reflect.DeepEqual(expected, received) {
		t.Errorf("Expecting: %+v, received: %+v", expected, received)
	}
}

func TestPaginatorPaginateStringSlice(t *testing.T) {
	//len(in)=0
	eOut := []string{}
	pgnt := new(Paginator)
	rcv := pgnt.PaginateStringSlice(eOut)
	if len(rcv) != 0 {
		t.Errorf("Expecting an empty slice, received: %+v", rcv)
	}
	//offset > len(in)
	eOut = []string{"1"}
	pgnt = &Paginator{Offset: IntPointer(2), Limit: IntPointer(0)}
	rcv = pgnt.PaginateStringSlice(eOut)

	if len(rcv) != 0 {
		t.Errorf("Expecting an empty slice, received: %+v", rcv)
	}
	//offset != 0 && limit != 0
	eOut = []string{"3", "4"}
	pgnt = &Paginator{Offset: IntPointer(2), Limit: IntPointer(0)}
	rcv = pgnt.PaginateStringSlice([]string{"1", "2", "3", "4"})

	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expecting an empty slice, received: %+v", rcv)
	}

	eOut = []string{"1", "2", "3", "4"}
	pgnt = new(Paginator)
	if rcv := pgnt.PaginateStringSlice([]string{"1", "2", "3", "4"}); !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expecting: %+v, received: %+v", eOut, rcv)
	}
	eOut = []string{"1", "2", "3"}
	pgnt.Limit = IntPointer(3)
	if rcv := pgnt.PaginateStringSlice([]string{"1", "2", "3", "4"}); !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expecting: %+v, received: %+v", eOut, rcv)
	}
	eOut = []string{"2", "3", "4"}
	pgnt.Offset = IntPointer(1)
	if rcv := pgnt.PaginateStringSlice([]string{"1", "2", "3", "4"}); !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expecting: %+v, received: %+v", eOut, rcv)
	}
	eOut = []string{}
	pgnt.Offset = IntPointer(4)
	if rcv := pgnt.PaginateStringSlice([]string{"1", "2", "3", "4"}); !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expecting: %+v, received: %+v", eOut, rcv)
	}
	eOut = []string{"3"}
	pgnt.Offset = IntPointer(2)
	pgnt.Limit = IntPointer(1)
	if rcv := pgnt.PaginateStringSlice([]string{"1", "2", "3", "4"}); !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expecting: %+v, received: %+v", eOut, rcv)
	}
}

func TestNewRateSlot(t *testing.T) {
	var err error
	eOut := &RateSlot{
		ConnectFee:            1,
		Rate:                  1.01,
		RateUnit:              "1",
		RateIncrement:         "1",
		GroupIntervalStart:    "1",
		rateUnitDur:           1,
		rateIncrementDur:      1,
		groupIntervalStartDur: 1,
		tag:                   "",
	}
	rcv, err := NewRateSlot(eOut.ConnectFee, eOut.Rate, eOut.RateUnit, eOut.RateIncrement, eOut.GroupIntervalStart)
	if err != nil {
		t.Error(err)
	}
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %+v ,received: %+v ", eOut, rcv)
	}
	eOut.RateUnit = "a"
	rcv, err = NewRateSlot(eOut.ConnectFee, eOut.Rate, eOut.RateUnit, eOut.RateIncrement, eOut.GroupIntervalStart)
	//must receive from time an error: "invalid duration a"
	if err == nil || err.Error() != "time: invalid duration \"a\"" {
		t.Error(err)
	}
}

func TestSetDurations(t *testing.T) {
	rs := &RateSlot{
		RateUnit:           "1",
		RateIncrement:      "1",
		GroupIntervalStart: "1",
	}
	//must receive "nil" with
	if err := rs.SetDurations(); err != nil {
		t.Error(err)
	}
	rs.RateUnit = "a"
	//at RateUnit if, must receive from time an error: "invalid duration a"
	if err := rs.SetDurations(); err == nil || err.Error() != "time: invalid duration \"a\"" {
		t.Error(err)
	}
	rs.RateUnit = "1"
	rs.RateIncrement = "a"
	//at RateIncrement, must receive from time an error: "invalid duration a"
	if err := rs.SetDurations(); err == nil || err.Error() != "time: invalid duration \"a\"" {
		t.Error(err)
	}
	rs.RateIncrement = "1"
	rs.GroupIntervalStart = "a"
	//at GroupIntervalStart, must receive from time an error: "invalid duration a"
	if err := rs.SetDurations(); err == nil || err.Error() != "time: invalid duration \"a\"" {
		t.Error(err)
	}
}

func TestRateUnitDuration(t *testing.T) {
	eOut := &RateSlot{
		rateUnitDur:           1,
		rateIncrementDur:      1,
		groupIntervalStartDur: 1,
	}
	rcv := eOut.RateUnitDuration()
	if rcv != eOut.rateUnitDur {
		t.Errorf("Expected %+v, received %+v", eOut.rateUnitDur, rcv)
	}
	rcv = eOut.RateIncrementDuration()
	if rcv != eOut.rateIncrementDur {
		t.Errorf("Expected %+v, received %+v", eOut.rateIncrementDur, rcv)
	}
	rcv = eOut.GroupIntervalStartDuration()
	if rcv != eOut.groupIntervalStartDur {
		t.Errorf("Expected %+v, received %+v", eOut.groupIntervalStartDur, rcv)
	}
}

func TestNewTiming(t *testing.T) {
	eOut := &TPTiming{
		ID:        "1",
		Years:     Years{2020},
		Months:    []time.Month{time.April},
		MonthDays: MonthDays{18},
		WeekDays:  WeekDays{06},
		StartTime: "00:00:00",
		EndTime:   "11:11:11",
	}
	rcv := NewTiming("1", "2020", "04", "18", "06", "00:00:00;11:11:11")
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	//without endtime, check if .Split methong works (only one timestamp)
	rcv = NewTiming("1", "2020", "04", "18", "06", "00:00:00")
	eOut.EndTime = ""
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	//check if .Split methong works (ignoring the last timestamp)
	rcv = NewTiming("1", "2020", "04", "18", "06", "00:00:00;11:11:11;22:22:22")
	eOut.EndTime = "11:11:11"
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
}

func TestTPTimingSetTiming(t *testing.T) {
	tpTiming := &TPTiming{
		ID:        "1",
		Years:     Years{2020},
		Months:    []time.Month{time.April},
		MonthDays: MonthDays{18},
		WeekDays:  WeekDays{06},
		StartTime: "00:00:00",
		EndTime:   "11:11:11",
	}
	tpRatingPlanBinding := new(TPRatingPlanBinding)
	tpRatingPlanBinding.SetTiming(tpTiming)
	if !reflect.DeepEqual(tpTiming, tpRatingPlanBinding.timing) {
		t.Errorf("Expected %+v, received %+v", tpTiming, tpRatingPlanBinding.timing)
	}
	rcv := tpRatingPlanBinding.Timing()
	if !reflect.DeepEqual(tpTiming, rcv) {
		t.Errorf("Expected %+v, received %+v", tpTiming, rcv)
	}
}

func TestTPRatingProfileKeys(t *testing.T) {
	//empty check -> KeyId
	tpRatingProfile := new(TPRatingProfile)
	eOut := "*out:::"
	rcv := tpRatingProfile.KeyId()
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	//empty check -> GetId
	eOut = ":*out:::"
	rcv = tpRatingProfile.GetId()
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	// test check -> KeyId
	tpRatingProfile.Tenant = "test"
	tpRatingProfile.Category = "test"
	tpRatingProfile.Subject = "test"
	eOut = "*out:test:test:test"
	rcv = tpRatingProfile.KeyId()
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	//test check -> GetId
	eOut = "test:*out:test:test:test"
	tpRatingProfile.TPid = "test"
	tpRatingProfile.LoadId = "test"

	rcv = tpRatingProfile.GetId()
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
}

func TestTPRatingProfileSetRatingProfilesId(t *testing.T) {
	//empty check
	tpRatingProfile := new(TPRatingProfile)
	tpRatingProfile.SetRatingProfileID("")
	eOut := new(TPRatingProfile)
	if !reflect.DeepEqual(eOut, tpRatingProfile) {
		t.Errorf("Expected %+v, received %+v", eOut, tpRatingProfile)
	}
	//test check
	tpRatingProfile.SetRatingProfileID("1:3:4:5")
	eOut.LoadId = "1"
	eOut.Tenant = "3"
	eOut.Category = "4"
	eOut.Subject = "5"
	if !reflect.DeepEqual(eOut, tpRatingProfile) {
		t.Errorf("Expected %+v, received %+v", eOut, tpRatingProfile)
	}
	//wrong TPRatingProfile sent
	err := tpRatingProfile.SetRatingProfileID("1:2:3:4:5:6")
	if err == nil {
		t.Error("Wrong TPRatingProfileId sent and no error received")
	}

}

func TestAttrGetRatingProfileGetID(t *testing.T) {
	//empty check
	attrGetRatingProfile := &AttrGetRatingProfile{
		Tenant:   "",
		Category: "",
		Subject:  "",
	}
	rcv := attrGetRatingProfile.GetID()
	eOut := "*out:::"
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	//test check
	attrGetRatingProfile.Tenant = "cgrates"
	attrGetRatingProfile.Category = "cgrates"
	attrGetRatingProfile.Subject = "cgrates"
	rcv = attrGetRatingProfile.GetID()
	eOut = "*out:cgrates:cgrates:cgrates"
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
}

func TestFallbackSubjKeys(t *testing.T) {
	//call with empty slice -> expect an empty slice
	rcv := FallbackSubjKeys("", "", "")
	if rcv != nil {
		t.Errorf("Expected an empty slice")
	}
	//check with test vars
	eOut := []string{"*out:cgrates.org:*voice:1001", "*out:cgrates.org:*voice:1002", "*out:cgrates.org:*voice:1003"}
	rcv = FallbackSubjKeys("cgrates.org", VOICE, "1001;1003;1002")
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
}

func TestTPAccountActionsKeyId(t *testing.T) {
	//empty check KeyIs()
	tPAccountActions := new(TPAccountActions)
	rcv := tPAccountActions.KeyId()
	eOut := ":"
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	//empty check GetId()
	rcv = tPAccountActions.GetId()
	eOut = "::"
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	//empty check SetAccountActionsId()
	err := tPAccountActions.SetAccountActionsId("")
	if err == nil {
		t.Errorf("Wrong TP Account Action Id not received")
	}
	//test check SetAccountActionsId()
	err = tPAccountActions.SetAccountActionsId("loadID:cgrates.org:cgrates")
	if err != nil {
		t.Errorf("Expected nil")
	}
	expectedOut := &TPAccountActions{
		LoadId:  "loadID",
		Tenant:  "cgrates.org",
		Account: "cgrates",
	}
	if !reflect.DeepEqual(expectedOut, tPAccountActions) {
		t.Errorf("Expected %+v, received %+v", ToJSON(expectedOut), ToJSON(tPAccountActions))
	}
	//test check KeyIs() *Tenant, Account setted above via SetAccountActionsId
	rcv = tPAccountActions.KeyId()
	eOut = "cgrates.org:cgrates"
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}
	//tect check GetID() *LoadId, tenant, account setted above via SetAccountActionsId
	rcv = tPAccountActions.GetId()
	eOut = "loadID:cgrates.org:cgrates"
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected %+v, received %+v", eOut, rcv)
	}

}

func TestAttrExpFileCdrsAsCDRsFilter(t *testing.T) {
	attrExpFileCdrs := &AttrExpFileCdrs{
		TimeStart: "2020-04-04T11:45:26.371Z",
		TimeEnd:   "2020-04-04T11:46:26.371Z",
		SkipRated: true,
		CgrIds:    []string{"CGRID"},
		TORs:      []string{VOICE},
		Accounts:  []string{"1001"},
		Subjects:  []string{"1001"},
	}
	eOut := &CDRsFilter{
		CGRIDs:              attrExpFileCdrs.CgrIds,
		RunIDs:              attrExpFileCdrs.MediationRunIds,
		ToRs:                attrExpFileCdrs.TORs,
		OriginHosts:         attrExpFileCdrs.CdrHosts,
		Sources:             attrExpFileCdrs.CdrSources,
		RequestTypes:        attrExpFileCdrs.ReqTypes,
		Tenants:             attrExpFileCdrs.Tenants,
		Categories:          attrExpFileCdrs.Categories,
		Accounts:            attrExpFileCdrs.Accounts,
		Subjects:            attrExpFileCdrs.Subjects,
		DestinationPrefixes: attrExpFileCdrs.DestinationPrefixes,
		OrderIDStart:        attrExpFileCdrs.OrderIdStart,
		OrderIDEnd:          attrExpFileCdrs.OrderIdEnd,
		Paginator:           attrExpFileCdrs.Paginator,
		MaxCost:             Float64Pointer(-1.0),
	}
	//check with wrong time-zone
	rcv, err := attrExpFileCdrs.AsCDRsFilter("wrongtimezone")
	if err == nil {
		t.Errorf("ParseTimeDetectLayout error")
	}
	//check with wrong TimeStart
	attrExpFileCdrs.TimeStart = "wrongtimeStart"
	rcv, err = attrExpFileCdrs.AsCDRsFilter("")
	if err == nil {
		t.Errorf("Wrong AnswerTimeStart not processed")
	}
	//check with wrong TimeEnd
	attrExpFileCdrs.TimeStart = "2020-04-04T11:45:26.371Z"
	attrExpFileCdrs.TimeEnd = "wrongtimeEnd"
	rcv, err = attrExpFileCdrs.AsCDRsFilter("")
	if err == nil {
		t.Errorf("Wrong AnswerTimeEnd not processed")
	}

	//check with SkipRated = true & normal timeStar/timeEnd
	attrExpFileCdrs.TimeStart = "2020-04-04T11:45:26.371Z"
	attrExpFileCdrs.TimeEnd = "2020-04-04T11:46:26.371Z"

	TimeStart, _ := ParseTimeDetectLayout("2020-04-04T11:45:26.371Z", "")
	eOut.AnswerTimeStart = &TimeStart
	timeEnd, _ := ParseTimeDetectLayout("2020-04-04T11:46:26.371Z", "")
	eOut.AnswerTimeEnd = &timeEnd

	rcv, err = attrExpFileCdrs.AsCDRsFilter("")
	if err != nil {
		t.Errorf("ParseTimeDetectLayout error")
	}

	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(eOut), ToJSON(rcv))
	}

	//check with SkipRated = false
	attrExpFileCdrs.SkipRated = false
	attrExpFileCdrs.SkipErrors = true
	eOut.MinCost = Float64Pointer(0.0)
	rcv, err = attrExpFileCdrs.AsCDRsFilter("")

	if err != nil {
		t.Errorf("ParseTimeDetectLayout error")
	}

	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(eOut), ToJSON(rcv))
	}
}

// now working here
func TestAttrGetCdrsAsCDRsFilter(t *testing.T) {
	attrGetCdrs := &AttrGetCdrs{
		TimeStart: "2019-04-04T11:45:26.371Z",
		TimeEnd:   "2019-04-04T11:46:26.371Z",
		SkipRated: true,
		CgrIds:    []string{"CGRID"},
		TORs:      []string{VOICE},
		Accounts:  []string{"1001"},
		Subjects:  []string{"1001"},
	}
	eOut := &CDRsFilter{
		CGRIDs:              attrGetCdrs.CgrIds,
		RunIDs:              attrGetCdrs.MediationRunIds,
		ToRs:                attrGetCdrs.TORs,
		OriginHosts:         attrGetCdrs.CdrHosts,
		Sources:             attrGetCdrs.CdrSources,
		RequestTypes:        attrGetCdrs.ReqTypes,
		Tenants:             attrGetCdrs.Tenants,
		Categories:          attrGetCdrs.Categories,
		Accounts:            attrGetCdrs.Accounts,
		Subjects:            attrGetCdrs.Subjects,
		DestinationPrefixes: attrGetCdrs.DestinationPrefixes,
		OrderIDStart:        attrGetCdrs.OrderIdStart,
		OrderIDEnd:          attrGetCdrs.OrderIdEnd,
		Paginator:           attrGetCdrs.Paginator,
		OrderBy:             attrGetCdrs.OrderBy,
		MaxCost:             Float64Pointer(-1.0),
	}
	//chekck with an empty struct
	var testStruct *AttrGetCdrs
	rcv, err := testStruct.AsCDRsFilter("")
	if err != nil {
		t.Error(err)
	}
	if rcv != nil {
		t.Errorf("Nil struct expected")
	}
	//check with wrong time-zone
	rcv, err = attrGetCdrs.AsCDRsFilter("wrongtimezone")
	if err == nil {
		t.Errorf("ParseTimeDetectLayout error")
	}
	//check with wrong TimeStart
	attrGetCdrs.TimeStart = "wrongtimeStart"
	rcv, err = attrGetCdrs.AsCDRsFilter("")
	if err == nil {
		t.Errorf("Wrong AnswerTimeStart not processed")
	}
	//check with wrong TimeEnd
	attrGetCdrs.TimeStart = "2020-04-04T11:45:26.371Z"
	attrGetCdrs.TimeEnd = "wrongtimeEnd"
	rcv, err = attrGetCdrs.AsCDRsFilter("")
	if err == nil {
		t.Errorf("Wrong AnswerTimeEnd not processed")
	}

	//check with SkipRated = true & normal timeStar/timeEnd
	attrGetCdrs.TimeStart = "2020-04-04T11:45:26.371Z"
	attrGetCdrs.TimeEnd = "2020-04-04T11:46:26.371Z"
	TimeStart, _ := ParseTimeDetectLayout("2020-04-04T11:45:26.371Z", "")
	eOut.AnswerTimeStart = &TimeStart
	timeEnd, _ := ParseTimeDetectLayout("2020-04-04T11:46:26.371Z", "")
	eOut.AnswerTimeEnd = &timeEnd

	rcv, err = attrGetCdrs.AsCDRsFilter("")
	if err != nil {
		t.Errorf("ParseTimeDetectLayout error")
	}
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(eOut), ToJSON(rcv))
	}

	//check with SkipRated = false
	attrGetCdrs.SkipRated = false
	attrGetCdrs.SkipErrors = true
	eOut.MinCost = Float64Pointer(0.0)
	rcv, err = attrGetCdrs.AsCDRsFilter("")
	if err != nil {
		t.Errorf("ParseTimeDetectLayout error")
	}
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(eOut), ToJSON(rcv))
	}
}

func TestNewTAFromAccountKey(t *testing.T) {
	//check with empty string
	eOut := &TenantAccount{
		Tenant:  "",
		Account: "",
	}
	rcv, err := NewTAFromAccountKey(":")
	if err != nil {
		t.Error(err)
	}
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(eOut), ToJSON(rcv))
	}
	//check with test string
	eOut = &TenantAccount{
		Tenant:  "cgrates.org",
		Account: "1001",
	}
	rcv, err = NewTAFromAccountKey("cgrates.org:1001")
	if err != nil {
		t.Error(err)
	}
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(eOut), ToJSON(rcv))
	}
	//check with wrong TenantAccount
	rcv, err = NewTAFromAccountKey("")
	if err == nil {
		t.Errorf("Unsupported format not processed")
	}
}

func TestRPCCDRsFilterAsCDRsFilter(t *testing.T) {
	var testStruct *RPCCDRsFilter
	rcv, err := testStruct.AsCDRsFilter("")
	if err != nil {
		t.Error(err)
	}
	if !reflect.DeepEqual(rcv, new(CDRsFilter)) {
		t.Errorf("Empty struct expected")
	}
	rpcCDRsFilter := &RPCCDRsFilter{
		CGRIDs:                 []string{"CGRIDs"},
		NotCGRIDs:              []string{"NotCGRIDs"},
		RunIDs:                 []string{"RunIDs"},
		NotRunIDs:              []string{"NotRunIDs"},
		OriginIDs:              []string{"OriginIDs"},
		NotOriginIDs:           []string{"NotOriginIDs"},
		OriginHosts:            []string{"OriginHosts"},
		NotOriginHosts:         []string{"NotOriginHosts"},
		Sources:                []string{"Sources"},
		NotSources:             []string{"NotSources"},
		ToRs:                   []string{"ToRs"},
		NotToRs:                []string{"NotToRs"},
		RequestTypes:           []string{"RequestTypes"},
		NotRequestTypes:        []string{"NotRequestTypes"},
		Tenants:                []string{"Tenants"},
		NotTenants:             []string{"NotTenants"},
		Categories:             []string{"Categories"},
		NotCategories:          []string{"NotCategories"},
		Accounts:               []string{"Accounts"},
		NotAccounts:            []string{"NotAccounts"},
		Subjects:               []string{"Subjects"},
		NotSubjects:            []string{"NotSubjects"},
		DestinationPrefixes:    []string{"DestinationPrefixes"},
		NotDestinationPrefixes: []string{"NotDestinationPrefixes"},
		Costs:                  []float64{0.1, 0.2},
		NotCosts:               []float64{0.3, 0.4},
		ExtraFields:            map[string]string{},
		NotExtraFields:         map[string]string{},
		SetupTimeStart:         "2020-04-18T11:46:26.371Z",
		SetupTimeEnd:           "2020-04-18T11:46:26.371Z",
		AnswerTimeStart:        "2020-04-18T11:46:26.371Z",
		AnswerTimeEnd:          "2020-04-18T11:46:26.371Z",
		CreatedAtStart:         "2020-04-18T11:46:26.371Z",
		CreatedAtEnd:           "2020-04-18T11:46:26.371Z",
		UpdatedAtStart:         "2020-04-18T11:46:26.371Z",
		UpdatedAtEnd:           "2020-04-18T11:46:26.371Z",
		MinUsage:               "MinUsage",
		MaxUsage:               "MaxUsage",
		OrderBy:                "OrderBy",
		ExtraArgs: map[string]any{
			OrderIDStart: 0,
			OrderIDEnd:   0,
			MinCost:      0.,
			MaxCost:      0.,
		},
	}
	eOut := &CDRsFilter{
		CGRIDs:                 rpcCDRsFilter.CGRIDs,
		NotCGRIDs:              rpcCDRsFilter.NotCGRIDs,
		RunIDs:                 rpcCDRsFilter.RunIDs,
		NotRunIDs:              rpcCDRsFilter.NotRunIDs,
		OriginIDs:              rpcCDRsFilter.OriginIDs,
		NotOriginIDs:           rpcCDRsFilter.NotOriginIDs,
		ToRs:                   rpcCDRsFilter.ToRs,
		NotToRs:                rpcCDRsFilter.NotToRs,
		OriginHosts:            rpcCDRsFilter.OriginHosts,
		NotOriginHosts:         rpcCDRsFilter.NotOriginHosts,
		Sources:                rpcCDRsFilter.Sources,
		NotSources:             rpcCDRsFilter.NotSources,
		RequestTypes:           rpcCDRsFilter.RequestTypes,
		NotRequestTypes:        rpcCDRsFilter.NotRequestTypes,
		Tenants:                rpcCDRsFilter.Tenants,
		NotTenants:             rpcCDRsFilter.NotTenants,
		Categories:             rpcCDRsFilter.Categories,
		NotCategories:          rpcCDRsFilter.NotCategories,
		Accounts:               rpcCDRsFilter.Accounts,
		NotAccounts:            rpcCDRsFilter.NotAccounts,
		Subjects:               rpcCDRsFilter.Subjects,
		NotSubjects:            rpcCDRsFilter.NotSubjects,
		DestinationPrefixes:    rpcCDRsFilter.DestinationPrefixes,
		NotDestinationPrefixes: rpcCDRsFilter.NotDestinationPrefixes,
		Costs:                  rpcCDRsFilter.Costs,
		NotCosts:               rpcCDRsFilter.NotCosts,
		ExtraFields:            rpcCDRsFilter.ExtraFields,
		NotExtraFields:         rpcCDRsFilter.NotExtraFields,
		OrderIDStart:           Int64Pointer(0),
		OrderIDEnd:             Int64Pointer(0),
		MinUsage:               rpcCDRsFilter.MinUsage,
		MaxUsage:               rpcCDRsFilter.MaxUsage,
		MinCost:                Float64Pointer(0.),
		MaxCost:                Float64Pointer(0.),
		Paginator:              rpcCDRsFilter.Paginator,
		OrderBy:                rpcCDRsFilter.OrderBy,
	}
	tTime, _ := ParseTimeDetectLayout("2020-04-18T11:46:26.371Z", "")
	eOut.AnswerTimeEnd = &tTime
	eOut.UpdatedAtEnd = &tTime
	eOut.UpdatedAtStart = &tTime
	eOut.CreatedAtEnd = &tTime
	eOut.CreatedAtStart = &tTime
	eOut.AnswerTimeEnd = &tTime
	eOut.AnswerTimeStart = &tTime
	eOut.SetupTimeEnd = &tTime
	eOut.SetupTimeStart = &tTime

	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err != nil {
		t.Errorf("ParseTimeDetectLayout error")
	} else if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(eOut), ToJSON(rcv))
	}

	rpcCDRsFilter.ExtraArgs[MaxCost] = "notFloat64"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("MaxCost should not be processed")
	}

	rpcCDRsFilter.ExtraArgs[MinCost] = "notFloat64"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("MinCost should not be processed")
	}
	rpcCDRsFilter.ExtraArgs[OrderIDEnd] = "notInt64"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("OrderIDEnd should not be processed")
	}
	rpcCDRsFilter.ExtraArgs[OrderIDStart] = "notInt64"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("OrderIDStart should not be processed")
	}

	rpcCDRsFilter.UpdatedAtEnd = "wrongUpdatedAtEnd"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("UpdatedAtEnd should not be processed")
	}
	rpcCDRsFilter.UpdatedAtStart = "wrongUpdatedAtStart"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("UpdatedAtStart should not be processed")
	}
	rpcCDRsFilter.CreatedAtEnd = "wrongCreatedAtEnd"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("CreatedAtEnd should not be processed")
	}
	rpcCDRsFilter.CreatedAtStart = "wrongCreatedAtStart"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("CreatedAtStart should not be processed")
	}
	rpcCDRsFilter.AnswerTimeEnd = "wrongAnswerTimeEnd"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("AnswerTimeEnd should not be processed")
	}
	rpcCDRsFilter.AnswerTimeStart = "wrongAnswerTimeStart"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("AnswerTimeStart should not be processed")
	}
	rpcCDRsFilter.SetupTimeEnd = "wrongSetupTimeEnd"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("SetupTimeEnd should not be processed")
	}
	rpcCDRsFilter.SetupTimeStart = "wrongSetupTimeStart"
	if rcv, err = rpcCDRsFilter.AsCDRsFilter(""); err == nil {
		t.Errorf("SetupTimeStart should not be processed")
	}
}

func TestTPActivationIntervalAsActivationInterval(t *testing.T) {
	tPActivationInterval := &TPActivationInterval{
		ActivationTime: "2019-04-04T11:45:26.371Z",
		ExpiryTime:     "2019-04-04T11:46:26.371Z",
	}
	eOut := new(ActivationInterval)

	tTime, _ := ParseTimeDetectLayout("2019-04-04T11:45:26.371Z", "")
	eOut.ActivationTime = tTime
	tTime, _ = ParseTimeDetectLayout("2019-04-04T11:46:26.371Z", "")
	eOut.ExpiryTime = tTime

	rcv, err := tPActivationInterval.AsActivationInterval("")
	if err != nil {
		t.Errorf("ParseTimeDetectLayout error")
	}
	if !reflect.DeepEqual(eOut, rcv) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(eOut), ToJSON(rcv))
	}
	//check with wrong time
	tPActivationInterval.ExpiryTime = "wrongExpiryTime"
	rcv, err = tPActivationInterval.AsActivationInterval("")
	if err == nil {
		t.Errorf("Wrong ExpiryTime not processed")
	}
	tPActivationInterval.ActivationTime = "wrongActivationTime"
	rcv, err = tPActivationInterval.AsActivationInterval("")
	if err == nil {
		t.Errorf("Wrong ActivationTime not processed")
	}
}

func TestActivationIntervalIsActiveAtTime(t *testing.T) {
	activationInterval := new(ActivationInterval)

	//case ActivationTime = Expiry = 0001-01-01 00:00:00 +0000 UTC
	activationInterval.ActivationTime = time.Time{}
	activationInterval.ExpiryTime = time.Time{}
	rcv := activationInterval.IsActiveAtTime(time.Time{})
	if !rcv {
		t.Errorf("ActivationTime = Expiry = time.Time{}, expecting 0 ")
	}
	activationInterval.ActivationTime = time.Date(2018, time.April, 18, 23, 0, 0, 0, time.UTC)
	activationInterval.ExpiryTime = time.Date(2020, time.April, 18, 23, 0, 0, 0, time.UTC)

	//atTime < ActivationTime
	atTime := time.Date(2017, time.April, 18, 23, 0, 0, 0, time.UTC)
	rcv = activationInterval.IsActiveAtTime(atTime)
	if rcv {
		t.Errorf("atTime < ActivationTime, expecting 0 ")
	}

	//atTime > ExpiryTime
	atTime = time.Date(2021, time.April, 18, 23, 0, 0, 0, time.UTC) //tTime
	rcv = activationInterval.IsActiveAtTime(atTime)
	if rcv {
		t.Errorf("atTime > Expiry, expecting 0 ")
	}

	//ideal case
	atTime = time.Date(2019, time.April, 18, 23, 0, 0, 0, time.UTC) //tTime
	rcv = activationInterval.IsActiveAtTime(atTime)
	if !rcv {
		t.Errorf("ActivationTime < atTime < ExpiryTime. Expecting 1 ")
	}
	//ActivationTime > ExpiryTime
	activationInterval.ActivationTime = time.Date(2020, time.April, 18, 23, 0, 0, 0, time.UTC) //tTime
	activationInterval.ExpiryTime = time.Date(2018, time.April, 18, 23, 0, 0, 0, time.UTC)     //tTime
	rcv = activationInterval.IsActiveAtTime(atTime)
	if rcv {
		t.Errorf("ActivationTime > ExpiryTime. Expecting 0 ")
	}
}

func TestAppendToSMCostFilter(t *testing.T) {
	var err error
	smfltr := new(SMCostFilter)
	expected := &SMCostFilter{
		CGRIDs: []string{"CGRID1", "CGRID2"},
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, MetaString, DynamicDataPrefix+CGRID, []string{"CGRID1", "CGRID2"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	expected.NotCGRIDs = []string{"CGRID3", "CGRID4"}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*notstring", DynamicDataPrefix+CGRID, []string{"CGRID3", "CGRID4"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	expected.RunIDs = []string{"RunID1", "RunID2"}
	if smfltr, err = AppendToSMCostFilter(smfltr, MetaString, DynamicDataPrefix+RunID, []string{"RunID1", "RunID2"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	expected.NotRunIDs = []string{"RunID3", "RunID4"}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*notstring", DynamicDataPrefix+RunID, []string{"RunID3", "RunID4"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	expected.OriginHosts = []string{"OriginHost1", "OriginHost2"}
	if smfltr, err = AppendToSMCostFilter(smfltr, MetaString, DynamicDataPrefix+OriginHost, []string{"OriginHost1", "OriginHost2"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	expected.NotOriginHosts = []string{"OriginHost3", "OriginHost4"}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*notstring", DynamicDataPrefix+OriginHost, []string{"OriginHost3", "OriginHost4"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	expected.OriginIDs = []string{"OriginID1", "OriginID2"}
	if smfltr, err = AppendToSMCostFilter(smfltr, MetaString, DynamicDataPrefix+OriginID, []string{"OriginID1", "OriginID2"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	expected.NotOriginIDs = []string{"OriginID3", "OriginID4"}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*notstring", DynamicDataPrefix+OriginID, []string{"OriginID3", "OriginID4"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	expected.CostSources = []string{"CostSource1", "CostSource2"}
	if smfltr, err = AppendToSMCostFilter(smfltr, MetaString, DynamicDataPrefix+CostSource, []string{"CostSource1", "CostSource2"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	expected.NotCostSources = []string{"CostSource3", "CostSource4"}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*notstring", DynamicDataPrefix+CostSource, []string{"CostSource3", "CostSource4"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	if smfltr, err = AppendToSMCostFilter(smfltr, "*prefix", DynamicDataPrefix+CGRID, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FilterType: \"*prefix\" not supported for FieldName: \"~CGRID\"" {
		t.Errorf("Expected error: FilterType: \"*prefix\" not supported for FieldName: \"~CGRID\" ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*prefix", DynamicDataPrefix+RunID, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FilterType: \"*prefix\" not supported for FieldName: \"~RunID\"" {
		t.Errorf("Expected error: FilterType: \"*prefix\" not supported for FieldName: \"~RunID\" ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*prefix", DynamicDataPrefix+OriginHost, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FilterType: \"*prefix\" not supported for FieldName: \"~OriginHost\"" {
		t.Errorf("Expected error: FilterType: \"*prefix\" not supported for FieldName: \"~OriginHost\" ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*prefix", DynamicDataPrefix+OriginID, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FilterType: \"*prefix\" not supported for FieldName: \"~OriginID\"" {
		t.Errorf("Expected error: FilterType: \"*prefix\" not supported for FieldName: \"~OriginID\" ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*prefix", DynamicDataPrefix+CostSource, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FilterType: \"*prefix\" not supported for FieldName: \"~CostSource\"" {
		t.Errorf("Expected error: FilterType: \"*prefix\" not supported for FieldName: \"~CostSource\" ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, MetaString, CGRID, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FieldName: \"CGRID\" not supported" {
		t.Errorf("Expected error: FieldName: \"CGRID\" not supported ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*prefix", CGRID, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FieldName: \"CGRID\" not supported" {
		t.Errorf("Expected error: FieldName: \"CGRID\" not supported ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))

	}
	expected.Usage.Min = DurationPointer(time.Second)
	if smfltr, err = AppendToSMCostFilter(smfltr, "*gte", DynamicDataPrefix+Usage, []string{"1s", "2s"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	expected.Usage.Max = DurationPointer(3 * time.Second)
	if smfltr, err = AppendToSMCostFilter(smfltr, "*lt", DynamicDataPrefix+Usage, []string{"3s", "4s"}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	if smfltr, err = AppendToSMCostFilter(smfltr, "*gte", DynamicDataPrefix+Usage, []string{"one second"}, ""); err == nil || err.Error() != "Error when converting field: \"*gte\"  value: \"~Usage\" in time.Duration " {
		t.Errorf("Expected error: Error when converting field: \"*gte\"  value: \"~Usage\" in time.Duration ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	if smfltr, err = AppendToSMCostFilter(smfltr, "*lt", DynamicDataPrefix+Usage, []string{"one second"}, ""); err == nil || err.Error() != "Error when converting field: \"*lt\"  value: \"~Usage\" in time.Duration " {
		t.Errorf("Expected error: Error when converting field: \"*lt\"  value: \"~Usage\" in time.Duration ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*prefix", DynamicDataPrefix+Usage, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FilterType: \"*prefix\" not supported for FieldName: \"~Usage\"" {
		t.Errorf("Expected error: FilterType: \"*prefix\" not supported for FieldName: \"~Usage\" ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	now := time.Now().UTC().Round(time.Second)
	strNow := now.Format("2006-01-02T15:04:05")

	expected.CreatedAt.Begin = &now
	if smfltr, err = AppendToSMCostFilter(smfltr, "*gte", DynamicDataPrefix+CreatedAt, []string{strNow}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	expected.CreatedAt.End = &now
	if smfltr, err = AppendToSMCostFilter(smfltr, "*lt", DynamicDataPrefix+CreatedAt, []string{strNow}, ""); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}

	if smfltr, err = AppendToSMCostFilter(smfltr, "*gte", DynamicDataPrefix+CreatedAt, []string{time.Now().String()}, ""); err == nil || err.Error() != "Error when converting field: \"*gte\"  value: \"~CreatedAt\" in time.Time " {
		t.Errorf("Expected error: Error when converting field: \"*gte\"  value: \"~CreatedAt\" in time.Time ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*lt", DynamicDataPrefix+CreatedAt, []string{time.Now().String()}, ""); err == nil || err.Error() != "Error when converting field: \"*lt\"  value: \"~CreatedAt\" in time.Time " {
		t.Errorf("Expected error: Error when converting field: \"*lt\"  value: \"~CreatedAt\" in time.Time ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
	if smfltr, err = AppendToSMCostFilter(smfltr, "*prefix", DynamicDataPrefix+CreatedAt, []string{"CGRID1", "CGRID2"}, ""); err == nil || err.Error() != "FilterType: \"*prefix\" not supported for FieldName: \"~CreatedAt\"" {
		t.Errorf("Expected error: FilterType: \"*prefix\" not supported for FieldName: \"~CreatedAt\" ,received %v", err)
	}
	if !reflect.DeepEqual(smfltr, expected) {
		t.Errorf("Expected: %s ,received: %s ", ToJSON(expected), ToJSON(smfltr))
	}
}

func TestInitAttrReloadCache(t *testing.T) {
	var expected AttrReloadCache
	expected.DestinationIDs = []string{}
	expected.ReverseDestinationIDs = []string{}
	expected.RatingPlanIDs = []string{}
	expected.RatingProfileIDs = []string{}
	expected.ActionIDs = []string{}
	expected.ActionPlanIDs = []string{}
	expected.AccountActionPlanIDs = []string{}
	expected.ActionTriggerIDs = []string{}
	expected.SharedGroupIDs = []string{}
	expected.ResourceProfileIDs = []string{}
	expected.ResourceIDs = []string{}
	expected.StatsQueueIDs = []string{}
	expected.StatsQueueProfileIDs = []string{}
	expected.ThresholdIDs = []string{}
	expected.ThresholdProfileIDs = []string{}
	expected.FilterIDs = []string{}
	expected.SupplierProfileIDs = []string{}
	expected.AttributeProfileIDs = []string{}
	expected.ChargerProfileIDs = []string{}
	expected.DispatcherProfileIDs = []string{}
	expected.DispatcherHostIDs = []string{}
	expected.DispatcherRoutesIDs = []string{}

	if rcv := InitAttrReloadCache(); !reflect.DeepEqual(rcv, expected) {
		t.Errorf("Expecting: %+v, received: %+v", expected, rcv)
	}
}
func TestCDRsFilterPrepare(t *testing.T) {
	fltr := &CDRsFilter{
		CGRIDs:          []string{"5", "6", "1", "3", "2", "4"},
		NotCGRIDs:       []string{"5", "6", "1", "3", "2", "4"},
		RunIDs:          []string{"5", "6", "1", "3", "2", "4"},
		NotRunIDs:       []string{"5", "6", "1", "3", "2", "4"},
		OriginIDs:       []string{"5", "6", "1", "3", "2", "4"},
		NotOriginIDs:    []string{"5", "6", "1", "3", "2", "4"},
		OriginHosts:     []string{"5", "6", "1", "3", "2", "4"},
		NotOriginHosts:  []string{"5", "6", "1", "3", "2", "4"},
		Sources:         []string{"5", "6", "1", "3", "2", "4"},
		NotSources:      []string{"5", "6", "1", "3", "2", "4"},
		ToRs:            []string{"5", "6", "1", "3", "2", "4"},
		NotToRs:         []string{"5", "6", "1", "3", "2", "4"},
		RequestTypes:    []string{"5", "6", "1", "3", "2", "4"},
		NotRequestTypes: []string{"5", "6", "1", "3", "2", "4"},
		Tenants:         []string{"5", "6", "1", "3", "2", "4"},
		NotTenants:      []string{"5", "6", "1", "3", "2", "4"},
		Categories:      []string{"5", "6", "1", "3", "2", "4"},
		NotCategories:   []string{"5", "6", "1", "3", "2", "4"},
		Accounts:        []string{"5", "6", "1", "3", "2", "4"},
		NotAccounts:     []string{"5", "6", "1", "3", "2", "4"},
		Subjects:        []string{"5", "6", "1", "3", "2", "4"},
		NotSubjects:     []string{"5", "6", "1", "3", "2", "4"},
		Costs:           []float64{5, 6, 1, 3, 2, 4},
		NotCosts:        []float64{5, 6, 1, 3, 2, 4},
	}
	exp := &CDRsFilter{
		CGRIDs:          []string{"1", "2", "3", "4", "5", "6"},
		NotCGRIDs:       []string{"1", "2", "3", "4", "5", "6"},
		RunIDs:          []string{"1", "2", "3", "4", "5", "6"},
		NotRunIDs:       []string{"1", "2", "3", "4", "5", "6"},
		OriginIDs:       []string{"1", "2", "3", "4", "5", "6"},
		NotOriginIDs:    []string{"1", "2", "3", "4", "5", "6"},
		OriginHosts:     []string{"1", "2", "3", "4", "5", "6"},
		NotOriginHosts:  []string{"1", "2", "3", "4", "5", "6"},
		Sources:         []string{"1", "2", "3", "4", "5", "6"},
		NotSources:      []string{"1", "2", "3", "4", "5", "6"},
		ToRs:            []string{"1", "2", "3", "4", "5", "6"},
		NotToRs:         []string{"1", "2", "3", "4", "5", "6"},
		RequestTypes:    []string{"1", "2", "3", "4", "5", "6"},
		NotRequestTypes: []string{"1", "2", "3", "4", "5", "6"},
		Tenants:         []string{"1", "2", "3", "4", "5", "6"},
		NotTenants:      []string{"1", "2", "3", "4", "5", "6"},
		Categories:      []string{"1", "2", "3", "4", "5", "6"},
		NotCategories:   []string{"1", "2", "3", "4", "5", "6"},
		Accounts:        []string{"1", "2", "3", "4", "5", "6"},
		NotAccounts:     []string{"1", "2", "3", "4", "5", "6"},
		Subjects:        []string{"1", "2", "3", "4", "5", "6"},
		NotSubjects:     []string{"1", "2", "3", "4", "5", "6"},
		Costs:           []float64{1, 2, 3, 4, 5, 6},
		NotCosts:        []float64{1, 2, 3, 4, 5, 6},
	}
	if fltr.Prepare(); !reflect.DeepEqual(exp, fltr) {
		t.Errorf("Expected %s,received %s", ToJSON(exp), ToJSON(fltr))
	}
}