Merge pull request #627 from Edwardro22/master

Storage integration tests for DataDB

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) //<nil>
+	// }
+	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)//<nil>
+	// }
+	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)//<nil>
+	// }
+}
+
+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) //<nil>
+	// }
+	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)
+	}
+}

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 {

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)
 	}
 }

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)
 	}
 }

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)
 	}
 }

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)
 	}
 }