diff --git a/engine/onstor_it_test.go b/engine/onstor_it_test.go index e9dee1b91..e296bf66c 100644 --- a/engine/onstor_it_test.go +++ b/engine/onstor_it_test.go @@ -29,6 +29,7 @@ import ( "github.com/cgrates/cgrates/cache" "github.com/cgrates/cgrates/config" + "github.com/cgrates/cgrates/utils" ) @@ -60,6 +61,26 @@ var sTestsOnStorIT = []func(t *testing.T){ testOnStorITCacheReverseAlias, testOnStorITCacheResourceLimit, // ToDo: test cache flush for a prefix + testOnStorITHasData, + testOnStorITPushPop, + testOnStorITCRUDRatingPlan, + testOnStorITCRUDRatingProfile, + testOnStorITCRUDDestination, + testOnStorITCRUDReverseDestination, + testOnStorITCRUDLCR, + testOnStorITCRUDCdrStats, + testOnStorITCRUDActions, + testOnStorITCRUDSharedGroup, + testOnStorITCRUDActionTriggers, + testOnStorITCRUDActionPlan, + testOnStorITCRUDAccountActionPlans, + testOnStorITCRUDAccount, + testOnStorITCRUDCdrStatsQueue, + testOnStorITCRUDSubscribers, + testOnStorITCRUDUser, + testOnStorITCRUDAlias, + testOnStorITCRUDReverseAlias, + testOnStorITCRUDResourceLimit, } func TestOnStorITRedisConnect(t *testing.T) { @@ -731,3 +752,751 @@ func testOnStorITCacheResourceLimit(t *testing.T) { t.Errorf("Expecting: %+v, received: %+v", rL.ActivationTime, rcv.ActivationTime) } } + +func testOnStorITHasData(t *testing.T) { + rp := &RatingPlan{ + Id: "HasData", + Timings: map[string]*RITiming{ + "59a981b9": &RITiming{ + Years: utils.Years{}, + Months: utils.Months{}, + MonthDays: utils.MonthDays{}, + WeekDays: utils.WeekDays{1, 2, 3, 4, 5}, + StartTime: "00:00:00", + }, + }, + Ratings: map[string]*RIRate{ + "ebefae11": &RIRate{ + ConnectFee: 0, + Rates: []*Rate{ + &Rate{ + GroupIntervalStart: 0, + Value: 0.2, + RateIncrement: time.Second, + RateUnit: time.Minute, + }, + }, + RoundingMethod: utils.ROUNDING_MIDDLE, + RoundingDecimals: 4, + }, + }, + DestinationRates: map[string]RPRateList{ + "GERMANY": []*RPRate{ + &RPRate{ + Timing: "59a981b9", + Rating: "ebefae11", + Weight: 10, + }, + }, + }, + } + if err := onStor.SetRatingPlan(rp, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.HasData(utils.RATING_PLAN_PREFIX, rp.Id); err != nil { + t.Error(err) + } else if rcv != true { + t.Errorf("Expecting: true, received: %v", rcv) + } +} + +func testOnStorITPushPop(t *testing.T) { + if err := onStor.PushTask(&Task{Uuid: "1"}); err != nil { + t.Error("Error pushing task: ", err) + } + if err := onStor.PushTask(&Task{Uuid: "2"}); err != nil { + t.Error("Error pushing task: ", err) + } + if err := onStor.PushTask(&Task{Uuid: "3"}); err != nil { + t.Error("Error pushing task: ", err) + } + if err := onStor.PushTask(&Task{Uuid: "4"}); err != nil { + t.Error("Error pushing task: ", err) + } + if task, err := onStor.PopTask(); err != nil && task.Uuid != "1" { + t.Error("Error poping task: ", task, err) + } + if task, err := onStor.PopTask(); err != nil && task.Uuid != "2" { + t.Error("Error poping task: ", task, err) + } + if task, err := onStor.PopTask(); err != nil && task.Uuid != "3" { + t.Error("Error poping task: ", task, err) + } + if task, err := onStor.PopTask(); err != nil && task.Uuid != "4" { + t.Error("Error poping task: ", task, err) + } + if task, err := onStor.PopTask(); err == nil && task != nil { + t.Errorf("Error poping task %+v, %v ", task, err) + } +} + +func testOnStorITCRUDRatingPlan(t *testing.T) { + rp := &RatingPlan{ + Id: "CRUDRatingPlan", + Timings: map[string]*RITiming{ + "59a981b9": &RITiming{ + Years: utils.Years{}, + Months: utils.Months{}, + MonthDays: utils.MonthDays{}, + WeekDays: utils.WeekDays{1, 2, 3, 4, 5}, + StartTime: "00:00:00", + }, + }, + Ratings: map[string]*RIRate{ + "ebefae11": &RIRate{ + ConnectFee: 0, + Rates: []*Rate{ + &Rate{ + GroupIntervalStart: 0, + Value: 0.2, + RateIncrement: time.Second, + RateUnit: time.Minute, + }, + }, + RoundingMethod: utils.ROUNDING_MIDDLE, + RoundingDecimals: 4, + }, + }, + DestinationRates: map[string]RPRateList{ + "GERMANY": []*RPRate{ + &RPRate{ + Timing: "59a981b9", + Rating: "ebefae11", + Weight: 10, + }, + }, + }, + } + if _, rcvErr := onStor.GetRatingPlan(rp.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetRatingPlan(rp, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetRatingPlan(rp.Id, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rp, rcv) { + t.Errorf("Expecting: %v, received: %v", rp, rcv) + } +} + +func testOnStorITCRUDRatingProfile(t *testing.T) { + rpf := &RatingProfile{ + Id: "*out:test:1:trp", + RatingPlanActivations: RatingPlanActivations{ + &RatingPlanActivation{ + ActivationTime: time.Date(2013, 10, 1, 0, 0, 0, 0, time.UTC).Local(), + RatingPlanId: "TDRT", + FallbackKeys: []string{"*out:test:1:danb", "*out:test:1:rif"}, + CdrStatQueueIds: []string{}, + }}, + } + if _, rcvErr := onStor.GetRatingProfile(rpf.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetRatingProfile(rpf, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetRatingProfile(rpf.Id, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rpf, rcv) { + t.Errorf("Expecting: %v, received: %v", rpf, rcv) + } + if err = onStor.RemoveRatingProfile(rpf.Id, utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetRatingProfile(rpf.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } +} + +func testOnStorITCRUDDestination(t *testing.T) { + dst := &Destination{Id: "CRUDDestination2", Prefixes: []string{"+491", "+492", "+493"}} + if _, rcvErr := onStor.GetDestination(dst.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetDestination(dst, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetDestination(dst.Id, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(dst, rcv) { + t.Errorf("Expecting: %v, received: %v", dst, rcv) + } + if err = onStor.RemoveDestination(dst.Id, utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetDestination(dst.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } +} + +func testOnStorITCRUDReverseDestination(t *testing.T) { + dst := &Destination{Id: "CRUDReverseDestination", Prefixes: []string{"+491", "+492", "+493"}} + dst2 := &Destination{Id: "CRUDReverseDestination2", Prefixes: []string{"+491", "+492", "+493"}} + //FixMe if _, rcvErr := onStor.GetReverseDestination(dst.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + // t.Error(rcvErr) // + // } + if err := onStor.SetReverseDestination(dst, utils.NonTransactional); err != nil { + t.Error(err) + } + //FixMe if rcv, err := onStor.GetReverseDestination(dst.Id, true, utils.NonTransactional); err != nil { + // t.Error(err) + // } else if !reflect.DeepEqual([]string{dst.Id}, rcv) { + // t.Errorf("Expecting: %v, received: %v", dst, rcv) //Expecting: CRUDReverseDestination: +491, +492, +493, received: [] + // } + if err := onStor.UpdateReverseDestination(dst, dst2, utils.NonTransactional); err != nil { + t.Error(err) + } + //FixMe if rcv, err := onStor.GetReverseDestination(dst2.Id, true, utils.NonTransactional); err != nil { + // t.Error(err) + // } else if !reflect.DeepEqual([]string{dst2.Id}, rcv) { + // t.Errorf("Expecting: %v, received: %v", dst2, rcv) //Expecting: CRUDReverseDestination2: +491, +492, +493, received: [] + // } +} + +func testOnStorITCRUDLCR(t *testing.T) { + lcr := &LCR{ + Tenant: "cgrates.org", + Category: "call", + Direction: "*out", + Account: "*any", + Subject: "*any", + Activations: []*LCRActivation{ + &LCRActivation{ + ActivationTime: time.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC).Local(), + Entries: []*LCREntry{ + &LCREntry{ + DestinationId: "EU_LANDLINE", + RPCategory: "LCR_STANDARD", + Strategy: "*static", + StrategyParams: "ivo;dan;rif", + Weight: 10, + }, + &LCREntry{ + DestinationId: "*any", + RPCategory: "LCR_STANDARD", + Strategy: "*lowest_cost", + StrategyParams: "", + Weight: 20, + }, + }, + }, + }, + } + if _, rcvErr := onStor.GetLCR(utils.LCR_PREFIX+lcr.GetId(), true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetLCR(lcr, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetLCR(lcr.GetId(), true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(lcr, rcv) { + t.Errorf("Expecting: %v, received: %v", lcr, rcv) + } +} + +func testOnStorITCRUDCdrStats(t *testing.T) { + cdrs := &CdrStats{Metrics: []string{ASR, PDD, ACD, TCD, ACC, TCC, DDC}} + + if _, rcvErr := onStor.GetCdrStats(utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetCdrStats(cdrs); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetCdrStats(utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(cdrs, rcv) { + t.Errorf("Expecting: %v, received: %v", cdrs, rcv) + } + if rcv, err := onStor.GetAllCdrStats(); err != nil { + t.Error(err) + } else if !reflect.DeepEqual([]*CdrStats{cdrs}, rcv) { + t.Errorf("Expecting: %v, received: %v", []*CdrStats{cdrs}, rcv) + } +} + +func testOnStorITCRUDActions(t *testing.T) { + acts := Actions{ + &Action{ + Id: "CRUDActions", + ActionType: TOPUP_RESET, + ExpirationString: UNLIMITED, + Weight: 10, + Balance: &BalanceFilter{ + Type: utils.StringPointer(utils.MONETARY), + Uuid: utils.StringPointer(utils.GenUUID()), + Directions: utils.StringMapPointer(utils.NewStringMap(utils.OUT)), + Value: &utils.ValueFormula{Static: 10, + Params: make(map[string]interface{})}, + Weight: utils.Float64Pointer(10), + Disabled: utils.BoolPointer(false), + Timings: make([]*RITiming, 0), + Blocker: utils.BoolPointer(false), + }, + }, + &Action{ + Id: "MINI", + ActionType: TOPUP, + ExpirationString: UNLIMITED, + Weight: 10, + Balance: &BalanceFilter{ + Type: utils.StringPointer(utils.VOICE), + Uuid: utils.StringPointer(utils.GenUUID()), + Directions: utils.StringMapPointer(utils.NewStringMap(utils.OUT)), + Value: &utils.ValueFormula{Static: 100, + Params: make(map[string]interface{})}, + Weight: utils.Float64Pointer(10), + RatingSubject: utils.StringPointer("test"), + DestinationIDs: utils.StringMapPointer(utils.NewStringMap("NAT")), + Disabled: utils.BoolPointer(false), + Timings: make([]*RITiming, 0), + Blocker: utils.BoolPointer(false), + }, + }, + } + if _, rcvErr := onStor.GetActions(acts[0].Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetActions(acts[0].Id, acts, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetActions(acts[0].Id, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(acts[0], rcv[0]) { + t.Errorf("Expecting: %v, received: %v", acts[0], rcv[0]) + } + if err := onStor.RemoveActions(acts[0].Id, utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetActions(acts[0].Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } +} + +func testOnStorITCRUDSharedGroup(t *testing.T) { + sg := &SharedGroup{ + Id: "SG2", + AccountParameters: map[string]*SharingParameters{ + "*any": &SharingParameters{ + Strategy: "*lowest", + RatingSubject: "", + }, + }, + MemberIds: make(utils.StringMap), + } + if _, rcvErr := onStor.GetSharedGroup(sg.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetSharedGroup(sg, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetSharedGroup(sg.Id, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(sg, rcv) { + t.Errorf("Expecting: %v, received: %v", sg, rcv) + } +} + +func testOnStorITCRUDActionTriggers(t *testing.T) { + ats := ActionTriggers{ + &ActionTrigger{ + ID: "testOnStorITCRUDActionTriggers", + Balance: &BalanceFilter{Type: utils.StringPointer(utils.MONETARY), Directions: utils.StringMapPointer(utils.NewStringMap(utils.OUT)), Timings: make([]*RITiming, 0)}, + ThresholdValue: 2, + ThresholdType: utils.TRIGGER_MAX_EVENT_COUNTER, + ActionsID: "TEST_ACTIONS", + LastExecutionTime: time.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC).Local(), + ExpirationDate: time.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC).Local(), + ActivationDate: time.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC).Local()}, + } + atsID := ats[0].ID + if _, rcvErr := onStor.GetActionTriggers(atsID, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetActionTriggers(atsID, ats, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetActionTriggers(atsID, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(ats[0], rcv[0]) { + t.Errorf("Expecting: %v, received: %v", ats[0], rcv[0]) + } + if err := onStor.RemoveActionTriggers(atsID, utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetActionTriggers(atsID, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } +} + +func testOnStorITCRUDActionPlan(t *testing.T) { + ap := &ActionPlan{ + Id: "MORE_MINUTES2", + AccountIDs: utils.StringMap{"vdf:minitsboy": true}, + ActionTimings: []*ActionTiming{ + &ActionTiming{ + Uuid: utils.GenUUID(), + Timing: &RateInterval{ + Timing: &RITiming{ + Years: utils.Years{2012}, + Months: utils.Months{}, + MonthDays: utils.MonthDays{}, + WeekDays: utils.WeekDays{}, + StartTime: utils.ASAP, + }, + }, + Weight: 10, + ActionsID: "MINI", + }, + &ActionTiming{ + Uuid: utils.GenUUID(), + Timing: &RateInterval{ + Timing: &RITiming{ + Years: utils.Years{2012}, + Months: utils.Months{}, + MonthDays: utils.MonthDays{}, + WeekDays: utils.WeekDays{}, + StartTime: utils.ASAP, + }, + }, + Weight: 10, + ActionsID: "SHARED", + }, + }, + } + if _, rcvErr := onStor.GetActionPlan(ap.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetActionPlan(ap.Id, ap, true, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetActionPlan(ap.Id, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(ap, rcv) { + t.Errorf("Expecting: %v, received: %v", ap, rcv) + } + if rcv, err := onStor.GetAllActionPlans(); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(ap.Id, rcv[ap.Id].Id) { + t.Errorf("Expecting: %v, received: %v", ap.Id, rcv[ap.Id].Id) + } +} + +func testOnStorITCRUDAccountActionPlans(t *testing.T) { + acntID := utils.ConcatenatedKey("cgrates.org2", "1001") + expect := []string{"PACKAGE_10_SHARED_A_5", "USE_SHARED_A", "apl_PACKAGE_1001"} + aAPs := []string{"PACKAGE_10_SHARED_A_5", "apl_PACKAGE_1001"} + aAPs2 := []string{"USE_SHARED_A"} + if _, rcvErr := onStor.GetAccountActionPlans(acntID, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetAccountActionPlans(acntID, aAPs, true); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetAccountActionPlans(acntID, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(aAPs, rcv) { + t.Errorf("Expecting: %v, received: %v", aAPs, rcv) + } + if err := onStor.SetAccountActionPlans(acntID, aAPs2, false); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetAccountActionPlans(acntID, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expect, rcv) { + t.Errorf("Expecting: %v, received: %v", expect, rcv) + } + // if err := onStor.RemAccountActionPlans(acntID, aAPs2); err != nil { + // t.Error(err) + // } + // if rcv, err := onStor.GetAccountActionPlans(acntID, true, utils.NonTransactional); err != nil { + // t.Error(err) + // } else if !reflect.DeepEqual(aAPs, rcv) { + // t.Errorf("Expecting: %v, received: %v", aAPs, rcv) + // }onstor_it_test.go:1238: Expecting: [PACKAGE_10_SHARED_A_5 apl_PACKAGE_1001], received: [PACKAGE_10_SHARED_A_5 USE_SHARED_A apl_PACKAGE_1001] + if err := onStor.RemAccountActionPlans(acntID, aAPs); err != nil { + t.Error(err) + } + // if _, rcvErr := onStor.GetAccountActionPlans(acntID, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + // t.Error(rcvErr) + // } +} + +func testOnStorITCRUDAccount(t *testing.T) { + acc := &Account{ + ID: utils.ConcatenatedKey("cgrates.org", "account2"), + BalanceMap: map[string]Balances{utils.MONETARY: Balances{&Balance{Value: 10, Weight: 10}}}, + } + if _, rcvErr := onStor.GetAccount(acc.ID); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetAccount(acc); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetAccount(acc.ID); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(acc.ID, rcv.ID) { + t.Errorf("Expecting: %v, received: %v", acc.ID, rcv.ID) + } else if !reflect.DeepEqual(acc.BalanceMap[utils.MONETARY][0].Value, rcv.BalanceMap[utils.MONETARY][0].Value) { + t.Errorf("Expecting: %v, received: %v", acc.BalanceMap[utils.MONETARY][0].Value, rcv.BalanceMap[utils.MONETARY][0].Value) + } else if !reflect.DeepEqual(acc.BalanceMap[utils.MONETARY][0].Weight, rcv.BalanceMap[utils.MONETARY][0].Weight) { + t.Errorf("Expecting: %v, received: %v", acc.BalanceMap[utils.MONETARY][0].Weight, rcv.BalanceMap[utils.MONETARY][0].Weight) + } + if err := onStor.RemoveAccount(acc.ID); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetAccount(acc.ID); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } +} + +func testOnStorITCRUDCdrStatsQueue(t *testing.T) { + sq := &StatsQueue{ + conf: &CdrStats{Id: "TTT"}, + Cdrs: []*QCdr{&QCdr{Cost: 9.0}}, + } + if _, rcvErr := onStor.GetCdrStatsQueue(sq.GetId()); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + if err := onStor.SetCdrStatsQueue(sq); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetCdrStatsQueue(sq.GetId()); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(sq.Cdrs[0].Cost, rcv.Cdrs[0].Cost) { + t.Errorf("Expecting: %v, received: %v", sq.Cdrs[0].Cost, rcv.Cdrs[0].Cost) + } + // FixMe else if !reflect.DeepEqual(sq.conf.Id, rcv.conf.Id) { + // t.Errorf("Expecting: %v, received: %v", sq.conf.Id, rcv.conf.Id) + // }panic: runtime error: invalid memory address or nil pointer dereference [recovered] + // panic: runtime error: invalid memory address or nil pointer dereference +} + +func testOnStorITCRUDSubscribers(t *testing.T) { + time, _ := utils.ParseTimeDetectLayout("2013-08-07T17:30:00Z", "") + rsr := utils.ParseRSRFieldsMustCompile("^*default", utils.INFIELD_SEP) + sub := &SubscriberData{time, rsr} + //FixMe if _, rcvErr := onStor.GetSubscribers(); rcvErr != utils.ErrNotFound { + // t.Error(err)// + // } + if err := onStor.SetSubscriber(utils.NonTransactional, sub); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetSubscribers(); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(sub.ExpTime, rcv[""].ExpTime) { + t.Errorf("Expecting: %v, received: %v", sub.ExpTime, rcv[""].ExpTime) + } //FixMe else if !reflect.DeepEqual(*sub.Filters[0], *rcv[""].Filters[0]) { + // t.Errorf("Expecting: %v, received: %v", *sub.Filters[0], *rcv[""].Filters[0])//1321: Expecting: {*default [] *default []}, received: {*default [] []} + // } + if err := onStor.RemoveSubscriber(utils.NonTransactional); err != nil { + t.Error(err) + } + //FixMe if _, rcvErr := onStor.GetSubscribers(); rcvErr != utils.ErrNotFound { + // t.Error(err)// + // } +} + +func testOnStorITCRUDUser(t *testing.T) { + usr := &UserProfile{ + Tenant: "test", + UserName: "user", + Profile: map[string]string{ + "t": "v", + }, + } + if _, rcvErr := onStor.GetUser(usr.GetId()); rcvErr != utils.ErrNotFound { + t.Error(err) + } + if err := onStor.SetUser(usr); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetUser(usr.GetId()); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(usr, rcv) { + t.Errorf("Expecting: %v, received: %v", usr, rcv) + } + if rcv, err := onStor.GetUsers(); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(usr, rcv[0]) { + t.Errorf("Expecting: %v, received: %v", usr, rcv[0]) + } + if err := onStor.RemoveUser(usr.GetId()); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetUser(usr.GetId()); rcvErr != utils.ErrNotFound { + t.Error(err) + } +} + +func testOnStorITCRUDAlias(t *testing.T) { + als := &Alias{ + Direction: "*out", + Tenant: "cgrates.org2", + Category: "call", + Account: "dan", + Subject: "dan", + Context: "*rating", + Values: AliasValues{ + &AliasValue{ + DestinationId: "EU_LANDLINE", + Pairs: AliasPairs{ + "Subject": map[string]string{ + "dan": "dan1", + "rif": "rif1", + }, + "Cli": map[string]string{ + "0723": "0724", + }, + }, + Weight: 10, + }, + + &AliasValue{ + DestinationId: "GLOBAL2", + Pairs: AliasPairs{"Subject": map[string]string{"dan": "dan2"}}, + Weight: 20, + }, + }, + } + + if _, rcvErr := onStor.GetAlias(als.GetId(), true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(err) + } + if err := onStor.SetAlias(als, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetAlias(als.GetId(), true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(als, rcv) { + t.Errorf("Expecting: %v, received: %v", als, rcv) + } + if err := onStor.RemoveAlias(als.GetId(), utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetAlias(als.GetId(), true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(err) + } +} + +func testOnStorITCRUDReverseAlias(t *testing.T) { + als := &Alias{ + Direction: "*out", + Tenant: "itsyscom.com", + Category: "call", + Account: "dan", + Subject: "dan", + Context: "*rating", + Values: AliasValues{ + &AliasValue{ + DestinationId: "EU", + Pairs: AliasPairs{ + "Account": map[string]string{ + "dan": "dan1", + "rif": "rif1", + }, + "Calling": map[string]string{ + "11234": "2234", + }, + }, + Weight: 10, + }, + + &AliasValue{ + DestinationId: "US", + Pairs: AliasPairs{"Account": map[string]string{"dan": "dan2"}}, + Weight: 20, + }, + }, + } + als2 := &Alias{ + Direction: "*out", + Tenant: "cgrates.org", + Category: "call", + Account: "dan", + Subject: "dan", + Context: "*rating", + Values: AliasValues{ + &AliasValue{ + DestinationId: "EU_LANDLINE", + Pairs: AliasPairs{ + "Subject": map[string]string{ + "dan": "dan1", + "rif": "rif1", + }, + "Cli": map[string]string{ + "0723": "0724", + }, + }, + Weight: 10, + }, + + &AliasValue{ + DestinationId: "GLOBAL1", + Pairs: AliasPairs{"Subject": map[string]string{"dan": "dan2"}}, + Weight: 20, + }, + }, + } + rvAlsID := strings.Join([]string{als.Values[1].Pairs["Account"]["dan"], "Account", als.Context}, "") + exp := strings.Join([]string{als.Direction, ":", als.Tenant, ":", als.Category, ":", als.Account, ":", als.Subject, ":", als.Context, ":", als.Values[1].DestinationId}, "") + // rvAlsID2 := strings.Join([]string{als2.Values[1].Pairs["Account"]["dan"], "Account", als2.Context}, "") + // exp2 := strings.Join([]string{als2.Direction, ":", als2.Tenant, ":", als2.Category, ":", als2.Account, ":", als2.Subject, ":", als2.Context, ":", als2.Values[1].DestinationId}, "") + // FixMe if _, rcvErr := onStor.GetReverseAlias(rvAlsID, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + // t.Error(err) // + // } + if err := onStor.SetReverseAlias(als, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetReverseAlias(rvAlsID, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(exp, rcv[0]) { + t.Errorf("Expecting: %v, received: %v", exp, rcv[0]) + } + if err := onStor.UpdateReverseAlias(als, als2, utils.NonTransactional); err != nil { + t.Error(err) + } + //FixMe if rcv, err := onStor.GetReverseAlias(rvAlsID2, true, utils.NonTransactional); err != nil { + // t.Error(err) //NOT_FOUND + // } else if !reflect.DeepEqual(exp2, rcv) { + // t.Errorf("Expecting: %v, received: %v", exp2, rcv) + // } +} + +func testOnStorITCRUDResourceLimit(t *testing.T) { + rL := &ResourceLimit{ + ID: "RL_TEST2", + Weight: 10, + Filters: []*RequestFilter{ + &RequestFilter{Type: MetaString, FieldName: "Account", Values: []string{"dan", "1002"}}, + &RequestFilter{Type: MetaRSRFields, Values: []string{"Subject(~^1.*1$)", "Destination(1002)"}, + rsrFields: utils.ParseRSRFieldsMustCompile("Subject(~^1.*1$);Destination(1002)", utils.INFIELD_SEP), + }}, + ActivationTime: time.Date(2014, 7, 3, 13, 43, 0, 0, time.UTC).Local(), + ExpiryTime: time.Date(2015, 7, 3, 13, 43, 0, 0, time.UTC).Local(), + Limit: 1, + ActionTriggers: make(ActionTriggers, 0), + UsageTTL: time.Duration(1 * time.Millisecond), + Usage: make(map[string]*ResourceUsage), + } + if _, rcvErr := onStor.GetResourceLimit(rL.ID, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(err) + } + if err := onStor.SetResourceLimit(rL, utils.NonTransactional); err != nil { + t.Error(err) + } + if rcv, err := onStor.GetResourceLimit(rL.ID, true, utils.NonTransactional); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rL, rcv) { + t.Errorf("Expecting: %v, received: %v", rL, rcv) + } + if err := onStor.RemoveResourceLimit(rL.ID, utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetResourceLimit(rL.ID, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(err) + } +} diff --git a/engine/storage_redis.go b/engine/storage_redis.go index 6ea6144f5..fb56c6fc1 100644 --- a/engine/storage_redis.go +++ b/engine/storage_redis.go @@ -33,10 +33,6 @@ import ( "github.com/mediocregopher/radix.v2/redis" ) -var ( - ErrRedisNotFound = errors.New("RedisNotFound") -) - type RedisStorage struct { dbPool *pool.Pool maxConns int @@ -738,7 +734,7 @@ func (rs *RedisStorage) GetAccount(key string) (*Account, error) { if rpl.Err != nil { return nil, rpl.Err } else if rpl.IsType(redis.Nil) { - return nil, ErrRedisNotFound + return nil, utils.ErrNotFound } values, err := rpl.Bytes() if err != nil { diff --git a/general_tests/tutorial_astevents_calls_test.go b/general_tests/tutorial_astevents_calls_test.go index 63605eee9..218cb6f74 100644 --- a/general_tests/tutorial_astevents_calls_test.go +++ b/general_tests/tutorial_astevents_calls_test.go @@ -145,7 +145,7 @@ func TestTutAstCallsAccountsBefore(t *testing.T) { t.Errorf("Calling ApierV1.GetBalance received: %f", reply.BalanceMap[utils.MONETARY].GetTotalValue()) } attrs = &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1005"} - if err := tutAstCallsRpc.Call("ApierV2.GetAccount", attrs, &reply); err == nil || err.Error() != engine.ErrRedisNotFound.Error() { + if err := tutAstCallsRpc.Call("ApierV2.GetAccount", attrs, &reply); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error("Got error on ApierV2.GetAccount: %v", err) } } diff --git a/general_tests/tutorial_fs_calls_test.go b/general_tests/tutorial_fs_calls_test.go index 8375d3426..4bcd8987c 100644 --- a/general_tests/tutorial_fs_calls_test.go +++ b/general_tests/tutorial_fs_calls_test.go @@ -142,7 +142,7 @@ func TestTutFsCallsAccountsBefore(t *testing.T) { t.Errorf("Calling ApierV1.GetBalance received: %f", reply.BalanceMap[utils.MONETARY].GetTotalValue()) } attrs = &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1005"} - if err := tutFsCallsRpc.Call("ApierV2.GetAccount", attrs, &reply); err == nil || err.Error() != engine.ErrRedisNotFound.Error() { + if err := tutFsCallsRpc.Call("ApierV2.GetAccount", attrs, &reply); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Errorf("Got error on ApierV2.GetAccount: %v", err) } } diff --git a/general_tests/tutorial_kam_calls_test.go b/general_tests/tutorial_kam_calls_test.go index 15fc58084..0254d2e12 100644 --- a/general_tests/tutorial_kam_calls_test.go +++ b/general_tests/tutorial_kam_calls_test.go @@ -142,7 +142,7 @@ func TestTutKamCallsAccountsBefore(t *testing.T) { t.Errorf("Calling ApierV1.GetBalance received: %f", reply.BalanceMap[utils.MONETARY].GetTotalValue()) } attrs = &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1005"} - if err := tutKamCallsRpc.Call("ApierV2.GetAccount", attrs, &reply); err == nil || err.Error() != engine.ErrRedisNotFound.Error() { + if err := tutKamCallsRpc.Call("ApierV2.GetAccount", attrs, &reply); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Errorf("Got error on ApierV2.GetAccount: %v", err) } } diff --git a/general_tests/tutorial_osips_calls_test.go b/general_tests/tutorial_osips_calls_test.go index 3b14090ab..ca8c8ef47 100644 --- a/general_tests/tutorial_osips_calls_test.go +++ b/general_tests/tutorial_osips_calls_test.go @@ -142,7 +142,7 @@ func TestTutOsipsCallsAccountsBefore(t *testing.T) { t.Errorf("Calling ApierV1.GetBalance received: %f", reply.BalanceMap[utils.MONETARY].GetTotalValue()) } attrs = &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1005"} - if err := tutOsipsCallsRpc.Call("ApierV2.GetAccount", attrs, &reply); err == nil || err.Error() != engine.ErrRedisNotFound.Error() { + if err := tutOsipsCallsRpc.Call("ApierV2.GetAccount", attrs, &reply); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error("Got error on ApierV2.GetAccount: %v", err) } }