func TestLoadIndividualProfiles(t *testing.T) {
if !*testLocal {
return
}
loader := NewDbReader(storDb, ratingDbApier, accountDbApier, TEST_SQL)
// Load ratingPlans. This will also set destination keys
if ratingPlans, err := storDb.GetTpRatingPlans(TEST_SQL, ""); err != nil {
t.Fatal("Could not retrieve rating plans")
} else {
for tag := range ratingPlans {
if loaded, err := loader.LoadRatingPlanByTag(tag); err != nil {
t.Fatalf("Could not load ratingPlan for tag: %s, error: %s", tag, err.Error())
} else if !loaded {
t.Fatal("Cound not find ratingPLan with id:", tag)
}
}
}
// Load rating profiles
loadId := utils.CSV_LOAD + "_" + TEST_SQL
if ratingProfiles, err := storDb.GetTpRatingProfiles(&utils.TPRatingProfile{TPid: TEST_SQL, LoadId: loadId}); err != nil {
t.Fatal("Could not retrieve rating profiles, error: ", err.Error())
} else if len(ratingProfiles) == 0 {
t.Fatal("Could not retrieve rating profiles")
} else {
for rpId := range ratingProfiles {
rp, _ := utils.NewTPRatingProfileFromKeyId(TEST_SQL, loadId, rpId)
if err := loader.LoadRatingProfileFiltered(rp); err != nil {
t.Fatalf("Could not load ratingProfile with id: %s, error: %s", rpId, err.Error())
}
}
}
// Load account actions
if aas, err := storDb.GetTpAccountActions(&utils.TPAccountActions{TPid: TEST_SQL, LoadId: loadId}); err != nil {
t.Fatal("Could not retrieve account action profiles, error: ", err.Error())
} else if len(aas) == 0 {
t.Error("No account actions")
} else {
for aaId := range aas {
aa, _ := utils.NewTPAccountActionsFromKeyId(TEST_SQL, loadId, aaId)
if err := loader.LoadAccountActionsFiltered(aa); err != nil {
t.Fatalf("Could not load account actions with id: %s, error: %s", aaId, err.Error())
}
}
}
}
func TestLoadIndividualProfiles(t *testing.T) {
if !*testLocal {
return
}
loader := NewTpReader(ratingDbApier, accountDbApier, storDb, utils.TEST_SQL, "")
// Load ratingPlans. This will also set destination keys
if ratingPlans, err := storDb.GetTpRatingPlans(utils.TEST_SQL, "", nil); err != nil {
t.Fatal("Could not retrieve rating plans")
} else {
rpls, err := TpRatingPlans(ratingPlans).GetRatingPlans()
if err != nil {
t.Fatal("Could not convert rating plans")
}
for tag := range rpls {
if loaded, err := loader.LoadRatingPlansFiltered(tag); err != nil {
t.Fatalf("Could not load ratingPlan for tag: %s, error: %s", tag, err.Error())
} else if !loaded {
t.Fatal("Cound not find ratingPLan with id:", tag)
}
}
}
// Load rating profiles
loadId := utils.CSV_LOAD + "_" + utils.TEST_SQL
if ratingProfiles, err := storDb.GetTpRatingProfiles(&TpRatingProfile{Tpid: utils.TEST_SQL, Loadid: loadId}); err != nil {
t.Fatal("Could not retrieve rating profiles, error: ", err.Error())
} else if len(ratingProfiles) == 0 {
t.Fatal("Could not retrieve rating profiles")
} else {
rpfs, err := TpRatingProfiles(ratingProfiles).GetRatingProfiles()
if err != nil {
t.Fatal("Could not convert rating profiles")
}
for rpId := range rpfs {
rp, _ := utils.NewTPRatingProfileFromKeyId(utils.TEST_SQL, loadId, rpId)
mrp := APItoModelRatingProfile(rp)
if err := loader.LoadRatingProfilesFiltered(&mrp[0]); err != nil {
t.Fatalf("Could not load ratingProfile with id: %s, error: %s", rpId, err.Error())
}
}
}
// Load derived chargers
loadId = utils.CSV_LOAD + "_" + utils.TEST_SQL
if derivedChargers, err := storDb.GetTpDerivedChargers(&TpDerivedCharger{Tpid: utils.TEST_SQL, Loadid: loadId}); err != nil {
t.Fatal("Could not retrieve derived chargers, error: ", err.Error())
} else if len(derivedChargers) == 0 {
t.Fatal("Could not retrieve derived chargers")
} else {
dcs, err := TpDerivedChargers(derivedChargers).GetDerivedChargers()
if err != nil {
t.Fatal("Could not convert derived chargers")
}
for dcId := range dcs {
mdc := &TpDerivedCharger{Tpid: utils.TEST_SQL, Loadid: loadId}
mdc.SetDerivedChargersId(dcId)
if err := loader.LoadDerivedChargersFiltered(mdc, true); err != nil {
t.Fatalf("Could not load derived charger with id: %s, error: %s", dcId, err.Error())
}
}
}
// Load cdr stats
//loadId = utils.CSV_LOAD + "_" + utils.TEST_SQL
if cdrStats, err := storDb.GetTpCdrStats(utils.TEST_SQL, ""); err != nil {
t.Fatal("Could not retrieve cdr stats, error: ", err.Error())
} else if len(cdrStats) == 0 {
t.Fatal("Could not retrieve cdr stats")
} else {
cds, err := TpCdrStats(cdrStats).GetCdrStats()
if err != nil {
t.Fatal("Could not convert cdr stats")
}
for id := range cds {
if err := loader.LoadCdrStatsFiltered(id, true); err != nil {
t.Fatalf("Could not load cdr stats with id: %s, error: %s", id, err.Error())
}
}
}
// Load users
if users, err := storDb.GetTpUsers(&TpUser{Tpid: utils.TEST_SQL}); err != nil {
t.Fatal("Could not retrieve users, error: ", err.Error())
} else if len(users) == 0 {
t.Fatal("Could not retrieve users")
} else {
for _, usr := range users {
if found, err := loader.LoadUsersFiltered(&usr); found && err != nil {
t.Fatalf("Could not user with id: %s, error: %s", usr.GetId(), err.Error())
}
}
}
// Load aliases
if aliases, err := storDb.GetTpAliases(&TpAlias{Tpid: utils.TEST_SQL}); err != nil {
t.Fatal("Could not retrieve aliases, error: ", err.Error())
} else if len(aliases) == 0 {
t.Fatal("Could not retrieve aliases")
} else {
for _, al := range aliases {
if found, err := loader.LoadAliasesFiltered(&al); found && err != nil {
t.Fatalf("Could not load aliase with id: %s, error: %s", al.GetId(), err.Error())
}
}
}
// Load account actions
if accountActions, err := storDb.GetTpAccountActions(&TpAccountAction{Tpid: utils.TEST_SQL, Loadid: loadId}); err != nil {
t.Fatal("Could not retrieve account action profiles, error: ", err.Error())
} else if len(accountActions) == 0 {
t.Error("No account actions")
} else {
aas, err := TpAccountActions(accountActions).GetAccountActions()
if err != nil {
t.Fatal("Could not convert account actions")
}
for aaId := range aas {
aa, _ := utils.NewTPAccountActionsFromKeyId(utils.TEST_SQL, loadId, aaId)
maa := APItoModelAccountAction(aa)
if err := loader.LoadAccountActionsFiltered(maa); err != nil {
t.Fatalf("Could not load account actions with id: %s, error: %s", aaId, err.Error())
}
}
}
}
