chore(filter): common filter for all providers

internal/provider/cyberghost/connection.go

@@ -15,7 +15,7 @@ func (c *Cyberghost) GetConnection(selection settings.ServerSelection) (
 		protocol = constants.TCP
 	}
 
-	servers, err := c.filterServers(selection)
+	servers, err := utils.FilterServers(c.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/cyberghost/filter.go

@@ -1,31 +0,0 @@
-package cyberghost
-
-import (
-	"errors"
-
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-var ErrGroupMismatchesProtocol = errors.New("server group does not match protocol")
-
-func (c *Cyberghost) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range c.servers {
-		switch {
-		case
-			utils.FilterByProtocol(selection, server.TCP, server.UDP),
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/cyberghost/filter_test.go

@@ -1,105 +0,0 @@
-package cyberghost
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/constants/providers"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func boolPtr(b bool) *bool { return &b }
-
-func Test_Cyberghost_filterServers(t *testing.T) {
-	t.Parallel()
-	testCases := map[string]struct {
-		servers         []models.Server
-		selection       settings.ServerSelection
-		filteredServers []models.Server
-		err             error
-	}{
-		"no server": {
-			selection: settings.ServerSelection{}.WithDefaults(providers.Cyberghost),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
-		},
-		"servers without filter defaults to UDP": {
-			servers: []models.Server{
-				{Country: "a", TCP: true},
-				{Country: "b", TCP: true},
-				{Country: "c", UDP: true},
-				{Country: "d", UDP: true},
-			},
-			selection: settings.ServerSelection{}.WithDefaults(providers.Cyberghost),
-			filteredServers: []models.Server{
-				{Country: "c", UDP: true},
-				{Country: "d", UDP: true},
-			},
-		},
-		"servers with TCP selection": {
-			servers: []models.Server{
-				{Country: "a", TCP: true},
-				{Country: "b", TCP: true},
-				{Country: "c", UDP: true},
-				{Country: "d", UDP: true},
-			},
-			selection: settings.ServerSelection{
-				OpenVPN: settings.OpenVPNSelection{
-					TCP: boolPtr(true),
-				},
-			}.WithDefaults(providers.Cyberghost),
-			filteredServers: []models.Server{
-				{Country: "a", TCP: true},
-				{Country: "b", TCP: true},
-			},
-		},
-		"servers with regions filter": {
-			servers: []models.Server{
-				{Country: "a", UDP: true},
-				{Country: "b", UDP: true},
-				{Country: "c", UDP: true},
-				{Country: "d", UDP: true},
-			},
-			selection: settings.ServerSelection{
-				Countries: []string{"a", "c"},
-			}.WithDefaults(providers.Cyberghost),
-			filteredServers: []models.Server{
-				{Country: "a", UDP: true},
-				{Country: "c", UDP: true},
-			},
-		},
-		"servers with hostnames filter": {
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-			selection: settings.ServerSelection{
-				Hostnames: []string{"a", "c"},
-			}.WithDefaults(providers.Cyberghost),
-			filteredServers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-		},
-	}
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-			c := &Cyberghost{servers: testCase.servers}
-			filteredServers, err := c.filterServers(testCase.selection)
-
-			if testCase.err != nil {
-				require.Error(t, err)
-				assert.Equal(t, testCase.err.Error(), err.Error())
-			} else {
-				assert.NoError(t, err)
-			}
-
-			assert.Equal(t, testCase.filteredServers, filteredServers)
-		})
-	}
-}