add symetric transport locations filter

Makefile

@@ -15,7 +15,7 @@ lint:  go-lint              # Check Go code
 go-test: # Run unit tests and generate coverage report
 	$(title)
 	@mkdir -p $(BUILD_DIR)
-	@go test -coverprofile $(BUILD_DIR)/coverage-unit.out $(GOPACKAGE) || (echo "$(RED)ERROR$(END) unit tests failed"; exit 1)
+	@go test ./... -coverprofile $(BUILD_DIR)/coverage-unit.out $(GOPACKAGE) || (echo "$(RED)ERROR$(END) unit tests failed"; exit 1)
 	@go tool cover -html=$(BUILD_DIR)/coverage-unit.out -o $(BUILD_DIR)/coverage-unit.html
 	@echo "Unit test coverage report in $$(pwd)/$(BUILD_DIR)/coverage-unit.html"
 	@echo "$(GRE)OK$(END) unit tests passed"

internal/data_sources/common.go

@@ -7,13 +7,30 @@ import (
 
 	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
 	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
 )
 
 var int64MapAttr = schema.MapAttribute{
 	ElementType: types.Int64Type,
 	Computed:    true,
 }
 
+// combineLocationPairs builds all locations symetrics combinations to be used as Meilisearch filter.
+func combineLocationPairs(locations, locationsTo []string) string {
+	var result []string
+
+	for _, location := range locations {
+		for _, locationTo := range locationsTo {
+			result = append(result, fmt.Sprintf("(location = %s && locationTo = %s)", location, locationTo))
+			if location != locationTo {
+				result = append(result, fmt.Sprintf("(locationTo = %s && location = %s)", location, locationTo))
+			}
+		}
+	}
+
+	return strings.Join(result, " or ")
+}
+
 type filter struct {
 	Name     types.String `tfsdk:"name"`
 	Operator types.String `tfsdk:"operator"`
@@ -31,6 +48,10 @@ func (ft FilterType) String() string {
 	return string(ft)
 }
 
+func operatorIntoFilterType(op basetypes.StringValue) FilterType {
+	return FilterType(op.ValueString())
+}
+
 const (
 	EqualFilterType        FilterType = "="
 	NotEqualFilterType     FilterType = "!="
@@ -47,38 +68,121 @@ var (
 		"wrong operator, try: \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\"",
 		EqualFilterType, NotEqualFilterType, AboveFilterType, AboveOrEqualFilterType, LessFilterType, LessOrEqualFilterType, InFilterType, ToFilterType,
 	)
+	ErrOnlyOneValue  = errors.New("errors values: must contain one value")
+	ErrOnlyTwoValues = errors.New("errors values: must contain two values")
 )
 
-func getFiltersString(filters []filter) ([]string, error) {
-	filterStrings := []string{}
-	for _, filter := range filters {
-		switch filter.Operator.ValueString() {
-		case ToFilterType.String():
-			if len(filter.Values.Elements()) == 2 {
-				value1 := filter.Values.Elements()[0].String()
-				value2 := filter.Values.Elements()[1].String()
-				filterStrings = append(filterStrings, fmt.Sprintf("%s %s %s %s", filter.Name.ValueString(), value1, filter.Operator.ValueString(), value2))
-			} else {
-				return nil, errors.New("errors values: must contain two values")
-			}
-		case InFilterType.String():
-			values := []string{}
-			for _, v := range filter.Values.Elements() {
-				values = append(values, v.String())
-			}
-			filterStrings = append(filterStrings, fmt.Sprintf("%s %s [%s]", filter.Name.ValueString(), filter.Operator.ValueString(), strings.Join(values[:], ",")))
-		case EqualFilterType.String(), NotEqualFilterType.String(), AboveFilterType.String(), AboveOrEqualFilterType.String(), LessFilterType.String(), LessOrEqualFilterType.String():
-			if len(filter.Values.Elements()) == 1 {
-				value := filter.Values.Elements()[0].String()
-				filterStrings = append(filterStrings, fmt.Sprintf("%s %s %s", filter.Name.ValueString(), filter.Operator.ValueString(), value))
-			} else {
-				return nil, errors.New("errors values: must contain one value")
-			}
-		default:
-			return nil, ErrWrongOperator
+// filterTypeValue handles all data to build a Meilisearch filter.
+//
+// `value`: can be used to store the filter value.
+type filterTypeValue struct {
+	Name   string
+	Type   FilterType
+	Values []string
+	value  string
+}
+
+// build validates and builds the Meilisearch filter.
+func (fv *filterTypeValue) build() (string, error) {
+	// if the value is already built, skip the build and return the value
+	if fv.value != "" {
+		return fv.value, nil
+	}
+
+	switch fv.Type {
+	case ToFilterType:
+		if vals := fv.Values; len(vals) == 2 {
+			return fmt.Sprintf("%s %s %s %s", fv.Name, vals[0], fv.Type.String(), vals[1]), nil
 		}
+		return "", ErrOnlyTwoValues
+	case InFilterType:
+		return fmt.Sprintf("%s %s [%s]", fv.Name, fv.Type.String(), strings.Join(fv.Values[:], ",")), nil
+	case EqualFilterType, NotEqualFilterType, AboveFilterType, AboveOrEqualFilterType, LessFilterType, LessOrEqualFilterType:
+		if vals := fv.Values; len(vals) == 1 {
+			return fmt.Sprintf("%s %s %s", fv.Name, fv.Type.String(), vals[0]), nil
+		}
+		return "", ErrOnlyOneValue
+	default:
+		return "", ErrWrongOperator
+	}
+}
+
+// filters groups all filters data.
+type filters map[string]filterTypeValue
+
+func (f filters) addFilter(name string, values []string, type_ FilterType) {
+	name = strings.Replace(name, "\"", "", -1)
+	f[name] = filterTypeValue{Name: name, Values: values, Type: type_}
+}
+
+// setLocationsJunction aims to build a specific locations filter for Transport product.
+// If the `location` & `locationTo` are sets, it combines all the location and locationTo pair of values
+// to search for symetric locations.
+func (f filters) setLocationsJunction() error {
+	locationFilter, ok := f["location"]
+	if !ok {
+		return nil
+	}
+
+	locationToFilter, ok := f["locationTo"]
+	if !ok {
+		return nil
+	}
+
+	// validates the filters
+	if _, err := locationFilter.build(); err != nil {
+		return err
+	}
+
+	if _, err := locationToFilter.build(); err != nil {
+		return err
+	}
+
+	filter := combineLocationPairs(locationFilter.Values, locationToFilter.Values)
+
+	delete(f, "locationTo")
+	delete(f, "location")
+
+	f["location"] = filterTypeValue{
+		Name:  "locations",
+		Type:  EqualFilterType,
+		value: filter,
+	}
+
+	return nil
+}
+
+func (f filters) getFilterList() ([]string, error) {
+	var filterValues []string
+
+	if err := f.setLocationsJunction(); err != nil {
+		return nil, err
+	}
+
+	for _, v := range f {
+		filterValue, err := v.build()
+
+		if err != nil {
+			return nil, err
+		}
+
+		filterValues = append(filterValues, filterValue)
+	}
+
+	return filterValues, nil
+}
+
+func getFiltersString(fs []filter) ([]string, error) {
+	filterStrings := filters{}
+	for _, filter := range fs {
+		values := []string{}
+		for _, v := range filter.Values.Elements() {
+			values = append(values, v.String())
+		}
+
+		filterStrings.addFilter(filter.Name.String(), values, operatorIntoFilterType(filter.Operator))
 	}
-	return filterStrings, nil
+	return filterStrings.getFilterList()
 }
 
 func getSortString(sorts []sortFacet) []string {

internal/data_sources/common_test.go

@@ -1,7 +1,6 @@
 package datasources
 
 import (
-	"errors"
 	"testing"
 
 	"github.com/hashicorp/terraform-plugin-framework/attr"
@@ -54,7 +53,7 @@ func TestGetFiltersString(t *testing.T) {
 				},
 			},
 			expect: nil,
-			err:    errors.New("errors values: must contain one value"),
+			err:    ErrOnlyOneValue,
 		},
 		{
 			name: EqualFilterType.String() + " must fail len(values) < 1",
@@ -66,7 +65,7 @@ func TestGetFiltersString(t *testing.T) {
 				},
 			},
 			expect: nil,
-			err:    errors.New("errors values: must contain one value"),
+			err:    ErrOnlyOneValue,
 		},
 		{
 			name: ToFilterType.String(),
@@ -90,7 +89,7 @@ func TestGetFiltersString(t *testing.T) {
 				},
 			},
 			expect: nil,
-			err:    errors.New("errors values: must contain two values"),
+			err:    ErrOnlyTwoValues,
 		},
 		{
 			name: InFilterType.String(),
@@ -104,6 +103,74 @@ func TestGetFiltersString(t *testing.T) {
 			expect: []string{"location IN [\"EQUINIX FR5\",\"EQUINIX LD5\"]"},
 			err:    nil,
 		},
+		{
+			name: "transport junction",
+			filters: []filter{
+				{
+					Name:     types.StringValue("location"),
+					Operator: types.StringValue(EqualFilterType.String()),
+					Values:   getValues([]string{"EQUINIX FR5"}),
+				},
+				{
+					Name:     types.StringValue("locationTo"),
+					Operator: types.StringValue(EqualFilterType.String()),
+					Values:   getValues([]string{"EQUINIX LD5"}),
+				},
+			},
+			expect: []string{"(location = \"EQUINIX FR5\" && locationTo = \"EQUINIX LD5\") or (locationTo = \"EQUINIX FR5\" && location = \"EQUINIX LD5\")"},
+			err:    nil,
+		},
+		{
+			name: "transport junction different filter type",
+			filters: []filter{
+				{
+					Name:     types.StringValue("location"),
+					Operator: types.StringValue(InFilterType.String()),
+					Values:   getValues([]string{"EQUINIX FR5"}),
+				},
+				{
+					Name:     types.StringValue("locationTo"),
+					Operator: types.StringValue(EqualFilterType.String()),
+					Values:   getValues([]string{"EQUINIX LD5"}),
+				},
+			},
+			expect: []string{"(location = \"EQUINIX FR5\" && locationTo = \"EQUINIX LD5\") or (locationTo = \"EQUINIX FR5\" && location = \"EQUINIX LD5\")"},
+			err:    nil,
+		},
+		{
+			name: "transport junction with multiple locations bad operator",
+			filters: []filter{
+				{
+					Name:     types.StringValue("location"),
+					Operator: types.StringValue(InFilterType.String()),
+					Values:   getValues([]string{"EQUINIX FR5", "EQUINIX AM2", "EQUINIX SG1"}),
+				},
+				{
+					Name:     types.StringValue("locationTo"),
+					Operator: types.StringValue(EqualFilterType.String()),
+					Values:   getValues([]string{"EQUINIX AM2", "EQUINIX PA3"}),
+				},
+			},
+			expect: nil,
+			err:    ErrOnlyOneValue,
+		},
+		{
+			name: "transport junction with multiple locations",
+			filters: []filter{
+				{
+					Name:     types.StringValue("location"),
+					Operator: types.StringValue(InFilterType.String()),
+					Values:   getValues([]string{"EQUINIX FR5", "EQUINIX AM2", "EQUINIX SG1"}),
+				},
+				{
+					Name:     types.StringValue("locationTo"),
+					Operator: types.StringValue(InFilterType.String()),
+					Values:   getValues([]string{"EQUINIX AM2", "EQUINIX PA3"}),
+				},
+			},
+			expect: []string{"(location = \"EQUINIX FR5\" && locationTo = \"EQUINIX AM2\") or (locationTo = \"EQUINIX FR5\" && location = \"EQUINIX AM2\") or (location = \"EQUINIX FR5\" && locationTo = \"EQUINIX PA3\") or (locationTo = \"EQUINIX FR5\" && location = \"EQUINIX PA3\") or (location = \"EQUINIX AM2\" && locationTo = \"EQUINIX AM2\") or (location = \"EQUINIX AM2\" && locationTo = \"EQUINIX PA3\") or (locationTo = \"EQUINIX AM2\" && location = \"EQUINIX PA3\") or (location = \"EQUINIX SG1\" && locationTo = \"EQUINIX AM2\") or (locationTo = \"EQUINIX SG1\" && location = \"EQUINIX AM2\") or (location = \"EQUINIX SG1\" && locationTo = \"EQUINIX PA3\") or (locationTo = \"EQUINIX SG1\" && location = \"EQUINIX PA3\")"},
+			err:    nil,
+		},
 		{
 			name: InFilterType.String() + " empty list",
 			filters: []filter{