From f7807d26af3a87d93f0795d981b1de0cfb8c195d Mon Sep 17 00:00:00 2001 From: NikolasPetriti Date: Wed, 23 Aug 2023 16:58:50 +0200 Subject: [PATCH] Add coverage tests for engine --- engine/spls_test.go | 589 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 589 insertions(+) create mode 100644 engine/spls_test.go diff --git a/engine/spls_test.go b/engine/spls_test.go new file mode 100644 index 000000000..98fadc126 --- /dev/null +++ b/engine/spls_test.go @@ -0,0 +1,589 @@ +/* +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 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see +*/ + +package engine + +import ( + "testing" + + "github.com/cgrates/cgrates/utils" +) + +func TestSplsWeightSortSuppliers(t *testing.T) { + str := "test" + ws := &WeightSorter{ + sorting: str, + spS: &SupplierService{}, + } + slc := []string{str} + suppls := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + suplEv := &utils.CGREvent{ + Tenant: str, + ID: str, + Time: &tm, + Event: map[string]any{"AnswerTime": fl}, + } + extraOpts := &optsGetSuppliers{ + ignoreErrors: false, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + argDsp := &utils.ArgDispatcher{ + APIKey: &str, + RouteID: &str, + } + + rcv, err := ws.SortSuppliers(str, suppls, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [Account]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } +} + +func TestSplsWeightSortSuppliersResourceDescendentSorter(t *testing.T) { + str := "test" + ws := &ResourceDescendentSorter{ + sorting: str, + spS: &SupplierService{}, + } + slc := []string{str} + suppls := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + suplEv := &utils.CGREvent{ + Tenant: str, + ID: str, + Time: &tm, + Event: map[string]any{"AnswerTime": fl}, + } + extraOpts := &optsGetSuppliers{ + ignoreErrors: false, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + argDsp := &utils.ArgDispatcher{ + APIKey: &str, + RouteID: &str, + } + + rcv, err := ws.SortSuppliers(str, suppls, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [Account]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } + + slc2 := []string{} + suppls2 := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc2, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + rcv, err = ws.SortSuppliers(str, suppls2, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [ResourceIDs]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } +} + +func TestSplsWeightSortSuppliersResourceAscendentSorter(t *testing.T) { + str := "test" + ws := &ResourceAscendentSorter{ + sorting: str, + spS: &SupplierService{}, + } + slc := []string{str} + suppls := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + suplEv := &utils.CGREvent{ + Tenant: str, + ID: str, + Time: &tm, + Event: map[string]any{"AnswerTime": fl}, + } + extraOpts := &optsGetSuppliers{ + ignoreErrors: false, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + argDsp := &utils.ArgDispatcher{ + APIKey: &str, + RouteID: &str, + } + + rcv, err := ws.SortSuppliers(str, suppls, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [Account]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } + + slc2 := []string{} + suppls2 := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc2, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + rcv, err = ws.SortSuppliers(str, suppls2, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [ResourceIDs]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } +} + +func TestSplsWeightSortSuppliersQOSSupplierSorter(t *testing.T) { + str := "test" + ws := &QOSSupplierSorter{ + sorting: str, + spS: &SupplierService{}, + } + slc := []string{str} + suppls := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + suplEv := &utils.CGREvent{ + Tenant: str, + ID: str, + Time: &tm, + Event: map[string]any{"AnswerTime": fl}, + } + extraOpts := &optsGetSuppliers{ + ignoreErrors: false, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + argDsp := &utils.ArgDispatcher{ + APIKey: &str, + RouteID: &str, + } + + rcv, err := ws.SortSuppliers(str, suppls, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [Account]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } + + extraOpts2 := &optsGetSuppliers{ + ignoreErrors: true, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + rcv, err = ws.SortSuppliers(str, suppls, suplEv, extraOpts2, argDsp) + + if err != nil { + if err.Error() != "NOT_FOUND" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } +} + +func TestSplsWeightSortSuppliersLoadDistributionSorter(t *testing.T) { + str := "test" + ws := &LoadDistributionSorter{ + sorting: str, + spS: &SupplierService{}, + } + slc := []string{str} + suppls := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + suplEv := &utils.CGREvent{ + Tenant: str, + ID: str, + Time: &tm, + Event: map[string]any{"AnswerTime": fl}, + } + extraOpts := &optsGetSuppliers{ + ignoreErrors: false, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + argDsp := &utils.ArgDispatcher{ + APIKey: &str, + RouteID: &str, + } + + rcv, err := ws.SortSuppliers(str, suppls, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [Account]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } + + slc2 := []string{} + suppls2 := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc2, + StatIDs: slc2, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + rcv, err = ws.SortSuppliers(str, suppls2, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [StatIDs]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } +} + +func TestSplsWeightSortSuppliersLeastCostSorter(t *testing.T) { + str := "test" + ws := &LeastCostSorter{ + sorting: str, + spS: &SupplierService{}, + } + slc := []string{str} + suppls := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + suplEv := &utils.CGREvent{ + Tenant: str, + ID: str, + Time: &tm, + Event: map[string]any{"AnswerTime": fl}, + } + extraOpts := &optsGetSuppliers{ + ignoreErrors: false, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + argDsp := &utils.ArgDispatcher{ + APIKey: &str, + RouteID: &str, + } + + rcv, err := ws.SortSuppliers(str, suppls, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [Account]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } + + slc2 := []string{} + suppls2 := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc2, + ResourceIDs: slc2, + StatIDs: slc2, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + rcv, err = ws.SortSuppliers(str, suppls2, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [RatingPlanIDs]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } + + extraOpts2 := &optsGetSuppliers{ + ignoreErrors: true, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + rcv, err = ws.SortSuppliers(str, suppls, suplEv, extraOpts2, argDsp) + + if err != nil { + if err.Error() != "NOT_FOUND" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } +} + +func TestSplsWeightSortSuppliersHightCostSorter(t *testing.T) { + str := "test" + ws := &HightCostSorter{ + sorting: str, + spS: &SupplierService{}, + } + slc := []string{str} + suppls := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc, + ResourceIDs: slc, + StatIDs: slc, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + suplEv := &utils.CGREvent{ + Tenant: str, + ID: str, + Time: &tm, + Event: map[string]any{"AnswerTime": fl}, + } + extraOpts := &optsGetSuppliers{ + ignoreErrors: false, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + argDsp := &utils.ArgDispatcher{ + APIKey: &str, + RouteID: &str, + } + + rcv, err := ws.SortSuppliers(str, suppls, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [Account]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } + + slc2 := []string{} + suppls2 := []*Supplier{{ + ID: str, + FilterIDs: slc, + AccountIDs: slc, + RatingPlanIDs: slc2, + ResourceIDs: slc2, + StatIDs: slc2, + Weight: 1.2, + Blocker: true, + SupplierParameters: str, + + cacheSupplier: map[string]any{"test": 1}, + }} + rcv, err = ws.SortSuppliers(str, suppls2, suplEv, extraOpts, argDsp) + + if err != nil { + if err.Error() != "MANDATORY_IE_MISSING: [RatingPlanIDs]" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } + + extraOpts2 := &optsGetSuppliers{ + ignoreErrors: true, + maxCost: 1.2, + sortingParameters: slc, + sortingStragety: str, + } + rcv, err = ws.SortSuppliers(str, suppls, suplEv, extraOpts2, argDsp) + + if err != nil { + if err.Error() != "NOT_FOUND" { + t.Fatal(err) + } + } else { + t.Fatal("was expectng an error") + } + + if rcv != nil { + t.Error(rcv) + } +}