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

internal/provider/expressvpn/connection.go

@@ -11,7 +11,7 @@ func (p *Provider) GetConnection(selection settings.ServerSelection) (
 	port := getPort(selection)
 	protocol := utils.GetProtocol(selection)
 
-	servers, err := p.filterServers(selection)
+	servers, err := utils.FilterServers(p.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/expressvpn/connection_test.go

@@ -1,7 +1,6 @@
 package expressvpn
 
 import (
-	"errors"
 	"math/rand"
 	"net"
 	"testing"
@@ -11,8 +10,8 @@ import (
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/provider/utils"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func Test_Provider_GetConnection(t *testing.T) {
@@ -22,17 +21,19 @@ func Test_Provider_GetConnection(t *testing.T) {
 		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
-		err        error
+		errWrapped error
+		errMessage string
 	}{
 		"no server available": {
 			selection:  settings.ServerSelection{}.WithDefaults(providers.Expressvpn),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
+			errWrapped: utils.ErrNoServerFound,
+			errMessage: "no server found: for VPN openvpn; protocol udp",
 		},
 		"no filter": {
 			servers: []models.Server{
-				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Expressvpn),
 			connection: models.Connection{
@@ -47,9 +48,9 @@ func Test_Provider_GetConnection(t *testing.T) {
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Expressvpn),
 			servers: []models.Server{
-				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -63,9 +64,9 @@ func Test_Provider_GetConnection(t *testing.T) {
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Expressvpn),
 			servers: []models.Server{
-				{Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
+				{Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
+				{Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
+				{Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -88,11 +89,9 @@ func Test_Provider_GetConnection(t *testing.T) {
 
 			connection, err := m.GetConnection(testCase.selection)
 
-			if testCase.err != nil {
+			assert.ErrorIs(t, err, testCase.errWrapped)
-				require.Error(t, err)
+			if testCase.errWrapped != nil {
-				assert.Equal(t, testCase.err.Error(), err.Error())
+				assert.EqualError(t, err, testCase.errMessage)
-			} else {
-				assert.NoError(t, err)
 			}
 
 			assert.Equal(t, testCase.connection, connection)

internal/provider/expressvpn/filter.go

@@ -1,28 +0,0 @@
-package expressvpn
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (p *Provider) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range p.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/expressvpn/filter_test.go

@@ -1,120 +0,0 @@
-package expressvpn
-
-import (
-	"errors"
-	"math/rand"
-	"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_Expressvpn_filterServers(t *testing.T) {
-	t.Parallel()
-
-	testCases := map[string]struct {
-		servers   []models.Server
-		selection settings.ServerSelection
-		filtered  []models.Server
-		err       error
-	}{
-		"no server available": {
-			selection: settings.ServerSelection{}.WithDefaults(providers.Expressvpn),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
-		},
-		"no filter": {
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-			selection: settings.ServerSelection{}.WithDefaults(providers.Expressvpn),
-			filtered: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-		},
-		"filter by country": {
-			selection: settings.ServerSelection{
-				Countries: []string{"b"},
-			}.WithDefaults(providers.Expressvpn),
-			servers: []models.Server{
-				{Country: "a", UDP: true},
-				{Country: "b", UDP: true},
-				{Country: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Country: "b", UDP: true},
-			},
-		},
-		"filter by city": {
-			selection: settings.ServerSelection{
-				Cities: []string{"b"},
-			}.WithDefaults(providers.Expressvpn),
-			servers: []models.Server{
-				{City: "a", UDP: true},
-				{City: "b", UDP: true},
-				{City: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{City: "b", UDP: true},
-			},
-		},
-		"filter by hostname": {
-			selection: settings.ServerSelection{
-				Hostnames: []string{"b"},
-			}.WithDefaults(providers.Expressvpn),
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Hostname: "b", UDP: true},
-			},
-		},
-		"filter by protocol": {
-			selection: settings.ServerSelection{
-				OpenVPN: settings.OpenVPNSelection{
-					TCP: boolPtr(true),
-				},
-			}.WithDefaults(providers.Expressvpn),
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true, TCP: true},
-				{Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Hostname: "b", UDP: true, TCP: true},
-			},
-		},
-	}
-
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			randSource := rand.NewSource(0)
-
-			m := New(testCase.servers, randSource)
-
-			servers, err := m.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.filtered, servers)
-		})
-	}
-}

internal/provider/fastestvpn/connection.go

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

internal/provider/fastestvpn/filter.go

@@ -1,27 +0,0 @@
-package fastestvpn
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (f *Fastestvpn) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range f.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/hidemyass/connection.go

@@ -20,7 +20,7 @@ func (h *HideMyAss) GetConnection(selection settings.ServerSelection) (
 		port = *selection.OpenVPN.CustomPort
 	}
 
-	servers, err := h.filterServers(selection)
+	servers, err := utils.FilterServers(h.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/hidemyass/filter.go

@@ -1,28 +0,0 @@
-package hidemyass
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (h *HideMyAss) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range h.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/ipvanish/connection.go

@@ -12,7 +12,7 @@ func (i *Ipvanish) GetConnection(selection settings.ServerSelection) (
 	const port = 443
 	const protocol = constants.UDP
 
-	servers, err := i.filterServers(selection)
+	servers, err := utils.FilterServers(i.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/ipvanish/filter.go

@@ -1,28 +0,0 @@
-package ipvanish
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (i *Ipvanish) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range i.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/ivpn/connection.go

@@ -11,7 +11,7 @@ func (i *Ivpn) GetConnection(selection settings.ServerSelection) (
 	port := getPort(selection)
 	protocol := utils.GetProtocol(selection)
 
-	servers, err := i.filterServers(selection)
+	servers, err := utils.FilterServers(i.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/ivpn/connection_test.go

@@ -1,7 +1,6 @@
 package ivpn
 
 import (
-	"errors"
 	"math/rand"
 	"net"
 	"testing"
@@ -11,8 +10,8 @@ import (
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/provider/utils"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func Test_Ivpn_GetConnection(t *testing.T) {
@@ -22,17 +21,19 @@ func Test_Ivpn_GetConnection(t *testing.T) {
 		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
-		err        error
+		errWrapped error
+		errMessage string
 	}{
 		"no server available": {
 			selection:  settings.ServerSelection{}.WithDefaults(providers.Ivpn),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
+			errWrapped: utils.ErrNoServerFound,
+			errMessage: "no server found: for VPN openvpn; protocol udp",
 		},
 		"no filter": {
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Ivpn),
 			connection: models.Connection{
@@ -47,9 +48,9 @@ func Test_Ivpn_GetConnection(t *testing.T) {
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Ivpn),
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
+				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -63,9 +64,9 @@ func Test_Ivpn_GetConnection(t *testing.T) {
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Ivpn),
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
+				{Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
+				{Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
+				{Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -88,11 +89,9 @@ func Test_Ivpn_GetConnection(t *testing.T) {
 
 			connection, err := m.GetConnection(testCase.selection)
 
-			if testCase.err != nil {
+			assert.ErrorIs(t, err, testCase.errWrapped)
-				require.Error(t, err)
+			if testCase.errWrapped != nil {
-				assert.Equal(t, testCase.err.Error(), err.Error())
+				assert.EqualError(t, err, testCase.errMessage)
-			} else {
-				assert.NoError(t, err)
 			}
 
 			assert.Equal(t, testCase.connection, connection)

internal/provider/ivpn/filter.go

@@ -1,30 +0,0 @@
-package ivpn
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (i *Ivpn) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range i.servers {
-		switch {
-		case
-			server.VPN != selection.VPN,
-			utils.FilterByPossibilities(server.ISP, selection.ISPs),
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/ivpn/filter_test.go

@@ -1,134 +0,0 @@
-package ivpn
-
-import (
-	"errors"
-	"math/rand"
-	"testing"
-
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/constants/providers"
-	"github.com/qdm12/gluetun/internal/constants/vpn"
-	"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_Ivpn_filterServers(t *testing.T) {
-	t.Parallel()
-
-	testCases := map[string]struct {
-		servers   []models.Server
-		selection settings.ServerSelection
-		filtered  []models.Server
-		err       error
-	}{
-		"no server available": {
-			selection: settings.ServerSelection{}.WithDefaults(providers.Ivpn),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
-		},
-		"no filter": {
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a", UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "b", UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "c", UDP: true},
-			},
-			selection: settings.ServerSelection{}.WithDefaults(providers.Ivpn),
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a", UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "b", UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "c", UDP: true},
-			},
-		},
-		"filter by country": {
-			selection: settings.ServerSelection{
-				Countries: []string{"b"},
-			}.WithDefaults(providers.Ivpn),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Country: "a", UDP: true},
-				{VPN: vpn.OpenVPN, Country: "b", UDP: true},
-				{VPN: vpn.OpenVPN, Country: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Country: "b", UDP: true},
-			},
-		},
-		"filter by city": {
-			selection: settings.ServerSelection{
-				Cities: []string{"b"},
-			}.WithDefaults(providers.Ivpn),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, City: "a", UDP: true},
-				{VPN: vpn.OpenVPN, City: "b", UDP: true},
-				{VPN: vpn.OpenVPN, City: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, City: "b", UDP: true},
-			},
-		},
-		"filter by ISP": {
-			selection: settings.ServerSelection{
-				ISPs: []string{"b"},
-			}.WithDefaults(providers.Ivpn),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, ISP: "a", UDP: true},
-				{VPN: vpn.OpenVPN, ISP: "b", UDP: true},
-				{VPN: vpn.OpenVPN, ISP: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, ISP: "b", UDP: true},
-			},
-		},
-		"filter by hostname": {
-			selection: settings.ServerSelection{
-				Hostnames: []string{"b"},
-			}.WithDefaults(providers.Ivpn),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a", UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "b", UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "b", UDP: true},
-			},
-		},
-		"filter by protocol": {
-			selection: settings.ServerSelection{
-				OpenVPN: settings.OpenVPNSelection{
-					TCP: boolPtr(true),
-				},
-			}.WithDefaults(providers.Ivpn),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a", UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "b", UDP: true, TCP: true},
-				{VPN: vpn.OpenVPN, Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "b", UDP: true, TCP: true},
-			},
-		},
-	}
-
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			randSource := rand.NewSource(0)
-
-			m := New(testCase.servers, randSource)
-
-			servers, err := m.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.filtered, servers)
-		})
-	}
-}

internal/provider/mullvad/connection.go

@@ -11,7 +11,7 @@ func (m *Mullvad) GetConnection(selection settings.ServerSelection) (
 	port := getPort(selection)
 	protocol := utils.GetProtocol(selection)
 
-	servers, err := m.filterServers(selection)
+	servers, err := utils.FilterServers(m.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/mullvad/connection_test.go

@@ -1,7 +1,6 @@
 package mullvad
 
 import (
-	"errors"
 	"math/rand"
 	"net"
 	"testing"
@@ -11,8 +10,8 @@ import (
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/provider/utils"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func Test_Mullvad_GetConnection(t *testing.T) {
@@ -22,17 +21,19 @@ func Test_Mullvad_GetConnection(t *testing.T) {
 		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
-		err        error
+		errWrapped error
+		errMessage string
 	}{
 		"no server available": {
 			selection:  settings.ServerSelection{}.WithDefaults(providers.Mullvad),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
+			errWrapped: utils.ErrNoServerFound,
+			errMessage: "no server found: for VPN openvpn; protocol udp",
 		},
 		"no filter": {
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Mullvad),
 			connection: models.Connection{
@@ -47,9 +48,9 @@ func Test_Mullvad_GetConnection(t *testing.T) {
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Mullvad),
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -63,9 +64,9 @@ func Test_Mullvad_GetConnection(t *testing.T) {
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Mullvad),
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{VPN: vpn.OpenVPN, UDP: true, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
-				{VPN: vpn.OpenVPN, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{VPN: vpn.OpenVPN, UDP: true, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
-				{VPN: vpn.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{VPN: vpn.OpenVPN, UDP: true, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -87,11 +88,9 @@ func Test_Mullvad_GetConnection(t *testing.T) {
 
 			connection, err := m.GetConnection(testCase.selection)
 
-			if testCase.err != nil {
+			assert.ErrorIs(t, err, testCase.errWrapped)
-				require.Error(t, err)
+			if testCase.errWrapped != nil {
-				assert.Equal(t, testCase.err.Error(), err.Error())
+				assert.EqualError(t, err, testCase.errMessage)
-			} else {
-				assert.NoError(t, err)
 			}
 
 			assert.Equal(t, testCase.connection, connection)

internal/provider/mullvad/filter.go

@@ -1,30 +0,0 @@
-package mullvad
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (m *Mullvad) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range m.servers {
-		switch {
-		case
-			server.VPN != selection.VPN,
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.ISP, selection.ISPs),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			*selection.OwnedOnly && !server.Owned:
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/mullvad/filter_test.go

@@ -1,145 +0,0 @@
-package mullvad
-
-import (
-	"errors"
-	"math/rand"
-	"testing"
-
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/constants/providers"
-	"github.com/qdm12/gluetun/internal/constants/vpn"
-	"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_Mullvad_filterServers(t *testing.T) {
-	t.Parallel()
-
-	testCases := map[string]struct {
-		servers   []models.Server
-		selection settings.ServerSelection
-		filtered  []models.Server
-		err       error
-	}{
-		"no server available": {
-			selection: settings.ServerSelection{}.WithDefaults(providers.Mullvad),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
-		},
-		"no filter": {
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.OpenVPN, Hostname: "b"},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-			selection: settings.ServerSelection{}.WithDefaults(providers.Mullvad),
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.OpenVPN, Hostname: "b"},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-		},
-		"filter OpenVPN out": {
-			selection: settings.ServerSelection{
-				VPN: vpn.Wireguard,
-			}.WithDefaults(providers.Mullvad),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.Wireguard, Hostname: "b"},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.Wireguard, Hostname: "b"},
-			},
-		},
-		"filter by country": {
-			selection: settings.ServerSelection{
-				Countries: []string{"b"},
-			}.WithDefaults(providers.Mullvad),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Country: "a"},
-				{VPN: vpn.OpenVPN, Country: "b"},
-				{VPN: vpn.OpenVPN, Country: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Country: "b"},
-			},
-		},
-		"filter by city": {
-			selection: settings.ServerSelection{
-				Cities: []string{"b"},
-			}.WithDefaults(providers.Mullvad),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, City: "a"},
-				{VPN: vpn.OpenVPN, City: "b"},
-				{VPN: vpn.OpenVPN, City: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, City: "b"},
-			},
-		},
-		"filter by ISP": {
-			selection: settings.ServerSelection{
-				ISPs: []string{"b"},
-			}.WithDefaults(providers.Mullvad),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, ISP: "a"},
-				{VPN: vpn.OpenVPN, ISP: "b"},
-				{VPN: vpn.OpenVPN, ISP: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, ISP: "b"},
-			},
-		},
-		"filter by hostname": {
-			selection: settings.ServerSelection{
-				Hostnames: []string{"b"},
-			}.WithDefaults(providers.Mullvad),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.OpenVPN, Hostname: "b"},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "b"},
-			},
-		},
-		"filter by owned": {
-			selection: settings.ServerSelection{
-				OwnedOnly: boolPtr(true),
-			}.WithDefaults(providers.Mullvad),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.OpenVPN, Hostname: "b", Owned: true},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "b", Owned: true},
-			},
-		},
-	}
-
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			randSource := rand.NewSource(0)
-
-			m := New(testCase.servers, randSource)
-
-			servers, err := m.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.filtered, servers)
-		})
-	}
-}

internal/provider/nordvpn/connection.go

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

internal/provider/nordvpn/filter.go

@@ -1,36 +0,0 @@
-package nordvpn
-
-import (
-	"strconv"
-
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (n *Nordvpn) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	selectedNumbers := make([]string, len(selection.Numbers))
-	for i := range selection.Numbers {
-		selectedNumbers[i] = strconv.Itoa(int(selection.Numbers[i]))
-	}
-
-	for _, server := range n.servers {
-		serverNumber := strconv.Itoa(int(server.Number))
-		switch {
-		case
-			utils.FilterByPossibilities(server.Region, selection.Regions),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByPossibilities(serverNumber, selectedNumbers),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/perfectprivacy/connection.go

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

internal/provider/perfectprivacy/filter.go

@@ -1,26 +0,0 @@
-package perfectprivacy
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (p *Perfectprivacy) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range p.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/privado/connection.go

@@ -12,7 +12,7 @@ func (p *Privado) GetConnection(selection settings.ServerSelection) (
 	const port = 1194
 	const protocol = constants.UDP
 
-	servers, err := p.filterServers(selection)
+	servers, err := utils.FilterServers(p.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/privado/filter.go

@@ -1,28 +0,0 @@
-package privado
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (p *Privado) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range p.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.Region, selection.Regions),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			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/privateinternetaccess/connection.go

@@ -19,7 +19,7 @@ func (p *PIA) GetConnection(selection settings.ServerSelection) (
 		return connection, err
 	}
 
-	servers, err := p.filterServers(selection)
+	servers, err := utils.FilterServers(p.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/privateinternetaccess/filter.go

@@ -1,28 +0,0 @@
-package privateinternetaccess
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (p *PIA) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range p.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Region, selection.Regions),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByPossibilities(server.ServerName, selection.Names), // TODO remove in v4
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/privatevpn/connection.go

@@ -19,7 +19,7 @@ func (p *Privatevpn) GetConnection(selection settings.ServerSelection) (
 		port = *selection.OpenVPN.CustomPort
 	}
 
-	servers, err := p.filterServers(selection)
+	servers, err := utils.FilterServers(p.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/privatevpn/filter.go

@@ -1,27 +0,0 @@
-package privatevpn
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (p *Privatevpn) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range p.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			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/protonvpn/connection.go

@@ -19,7 +19,7 @@ func (p *Protonvpn) GetConnection(selection settings.ServerSelection) (
 		return connection, err
 	}
 
-	servers, err := p.filterServers(selection)
+	servers, err := utils.FilterServers(p.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/protonvpn/filter.go

@@ -1,32 +0,0 @@
-package protonvpn
-
-import (
-	"strings"
-
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (p *Protonvpn) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range p.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.Region, selection.Regions),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByPossibilities(server.ServerName, selection.Names), // TODO remove in v4
-			*selection.FreeOnly && !strings.Contains(strings.ToLower(server.ServerName), "free"):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/purevpn/connection.go

@@ -16,7 +16,7 @@ func (p *Purevpn) GetConnection(selection settings.ServerSelection) (
 		port = 80
 	}
 
-	servers, err := p.filterServers(selection)
+	servers, err := utils.FilterServers(p.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/purevpn/filter.go

@@ -1,29 +0,0 @@
-package purevpn
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (p *Purevpn) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range p.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Region, selection.Regions),
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/surfshark/connection.go

@@ -16,7 +16,7 @@ func (s *Surfshark) GetConnection(selection settings.ServerSelection) (
 		port = 1443
 	}
 
-	servers, err := s.filterServers(selection)
+	servers, err := utils.FilterServers(s.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/surfshark/filter.go

@@ -1,30 +0,0 @@
-package surfshark
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (s *Surfshark) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range s.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Region, selection.Regions),
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP),
-			*selection.MultiHopOnly && !server.MultiHop:
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/surfshark/filter_test.go

@@ -1,146 +0,0 @@
-package surfshark
-
-import (
-	"errors"
-	"math/rand"
-	"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_Surfshark_filterServers(t *testing.T) {
-	t.Parallel()
-
-	testCases := map[string]struct {
-		servers   []models.Server
-		selection settings.ServerSelection
-		filtered  []models.Server
-		err       error
-	}{
-		"no server available": {
-			selection: settings.ServerSelection{}.WithDefaults(providers.Surfshark),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
-		},
-		"no filter": {
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-			selection: settings.ServerSelection{}.WithDefaults(providers.Surfshark),
-			filtered: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-		},
-		"filter by region": {
-			selection: settings.ServerSelection{
-				Regions: []string{"b"},
-			}.WithDefaults(providers.Surfshark),
-			servers: []models.Server{
-				{Region: "a", UDP: true},
-				{Region: "b", UDP: true},
-				{Region: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Region: "b", UDP: true},
-			},
-		},
-		"filter by country": {
-			selection: settings.ServerSelection{
-				Countries: []string{"b"},
-			}.WithDefaults(providers.Surfshark),
-			servers: []models.Server{
-				{Country: "a", UDP: true},
-				{Country: "b", UDP: true},
-				{Country: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Country: "b", UDP: true},
-			},
-		},
-		"filter by city": {
-			selection: settings.ServerSelection{
-				Cities: []string{"b"},
-			}.WithDefaults(providers.Surfshark),
-			servers: []models.Server{
-				{City: "a", UDP: true},
-				{City: "b", UDP: true},
-				{City: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{City: "b", UDP: true},
-			},
-		},
-		"filter by hostname": {
-			selection: settings.ServerSelection{
-				Hostnames: []string{"b"},
-			}.WithDefaults(providers.Surfshark),
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Hostname: "b", UDP: true},
-			},
-		},
-		"filter by protocol": {
-			selection: settings.ServerSelection{
-				OpenVPN: settings.OpenVPNSelection{
-					TCP: boolPtr(true),
-				},
-			}.WithDefaults(providers.Surfshark),
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true, TCP: true},
-				{Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Hostname: "b", UDP: true, TCP: true},
-			},
-		},
-		"filter by multihop only": {
-			selection: settings.ServerSelection{
-				MultiHopOnly: boolPtr(true),
-			}.WithDefaults(providers.Surfshark),
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", MultiHop: true, UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Hostname: "b", MultiHop: true, UDP: true},
-			},
-		},
-	}
-
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			randSource := rand.NewSource(0)
-
-			s := New(testCase.servers, randSource)
-
-			servers, err := s.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.filtered, servers)
-		})
-	}
-}

internal/provider/torguard/connection.go

@@ -19,7 +19,7 @@ func (t *Torguard) GetConnection(selection settings.ServerSelection) (
 		port = *selection.OpenVPN.CustomPort
 	}
 
-	servers, err := t.filterServers(selection)
+	servers, err := utils.FilterServers(t.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/torguard/filter.go

@@ -1,28 +0,0 @@
-package torguard
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (t *Torguard) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range t.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/utils/filtering.go

@@ -1,8 +1,93 @@
 package utils
 
-import "strings"
+import (
+	"strings"
 
-func FilterByPossibilities(value string, possibilities []string) (filtered bool) {
+	"github.com/qdm12/gluetun/internal/configuration/settings"
+	"github.com/qdm12/gluetun/internal/models"
+)
+
+func FilterServers(servers []models.Server,
+	selection settings.ServerSelection) (
+	filtered []models.Server, err error,
+) {
+	for _, server := range servers {
+		if filterServer(server, selection) {
+			continue
+		}
+
+		filtered = append(filtered, server)
+	}
+
+	if len(filtered) == 0 {
+		return nil, NoServerFoundError(selection)
+	}
+
+	return filtered, nil
+}
+
+func filterServer(server models.Server,
+	selection settings.ServerSelection) (filtered bool) {
+	// Note each condition is split to make sure
+	// we have full testing coverage.
+	if server.VPN != selection.VPN {
+		return true
+	}
+
+	if FilterByProtocol(selection, server.TCP, server.UDP) {
+		return true
+	}
+
+	if *selection.MultiHopOnly && !server.MultiHop {
+		return true
+	}
+
+	if *selection.FreeOnly && !server.Free {
+		return true
+	}
+
+	if *selection.StreamOnly && !server.Stream {
+		return true
+	}
+
+	if *selection.OwnedOnly && !server.Owned {
+		return true
+	}
+
+	if filterByPossibilities(server.Country, selection.Countries) {
+		return true
+	}
+
+	if filterByPossibilities(server.Region, selection.Regions) {
+		return true
+	}
+
+	if filterByPossibilities(server.City, selection.Cities) {
+		return true
+	}
+
+	if filterByPossibilities(server.ISP, selection.ISPs) {
+		return true
+	}
+
+	if filterByPossibilitiesUint16(server.Number, selection.Numbers) {
+		return true
+	}
+
+	if filterByPossibilities(server.ServerName, selection.Names) {
+		return true
+	}
+
+	if filterByPossibilities(server.Hostname, selection.Hostnames) {
+		return true
+	}
+
+	// TODO filter port forward server for PIA
+
+	return false
+}
+
+func filterByPossibilities(value string, possibilities []string) (filtered bool) {
 	if len(possibilities) == 0 {
 		return false
 	}
@@ -13,3 +98,16 @@ func FilterByPossibilities(value string, possibilities []string) (filtered bool)
 	}
 	return true
 }
+
+// TODO merge with filterByPossibilities with generics in Go 1.18.
+func filterByPossibilitiesUint16(value uint16, possibilities []uint16) (filtered bool) {
+	if len(possibilities) == 0 {
+		return false
+	}
+	for _, possibility := range possibilities {
+		if value == possibility {
+			return false
+		}
+	}
+	return true
+}

internal/provider/utils/filtering_test.go

@@ -3,10 +3,232 @@ package utils
 import (
 	"testing"
 
+	"github.com/qdm12/gluetun/internal/configuration/settings"
+	"github.com/qdm12/gluetun/internal/constants/providers"
+	"github.com/qdm12/gluetun/internal/constants/vpn"
+	"github.com/qdm12/gluetun/internal/models"
 	"github.com/stretchr/testify/assert"
 )
 
-func Test_FilterByPossibilities(t *testing.T) {
+func Test_FilterServers(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		servers    []models.Server
+		selection  settings.ServerSelection
+		filtered   []models.Server
+		errMessage string
+		errWrapped error
+	}{
+		"no server available": {
+			selection:  settings.ServerSelection{}.WithDefaults(providers.Mullvad),
+			errMessage: "no server found: for VPN openvpn; protocol udp",
+			errWrapped: ErrNoServerFound,
+		},
+		"no filter": {
+			servers: []models.Server{
+				{VPN: vpn.OpenVPN, Hostname: "a", UDP: true},
+				{VPN: vpn.OpenVPN, Hostname: "b", UDP: true},
+				{VPN: vpn.OpenVPN, Hostname: "c", UDP: true},
+			},
+			selection: settings.ServerSelection{}.WithDefaults(providers.Mullvad),
+			filtered: []models.Server{
+				{VPN: vpn.OpenVPN, Hostname: "a", UDP: true},
+				{VPN: vpn.OpenVPN, Hostname: "b", UDP: true},
+				{VPN: vpn.OpenVPN, Hostname: "c", UDP: true},
+			},
+		},
+		"filter by VPN protocol": {
+			selection: settings.ServerSelection{
+				VPN: vpn.Wireguard,
+			}.WithDefaults(providers.Mullvad),
+			servers: []models.Server{
+				{VPN: vpn.OpenVPN, Hostname: "a", UDP: true},
+				{VPN: vpn.Wireguard, Hostname: "b", UDP: true},
+				{VPN: vpn.OpenVPN, Hostname: "c", UDP: true},
+			},
+			filtered: []models.Server{
+				{VPN: vpn.Wireguard, Hostname: "b", UDP: true},
+			},
+		},
+		"filter by network protocol": {
+			selection: settings.ServerSelection{
+				OpenVPN: settings.OpenVPNSelection{
+					TCP: boolPtr(true),
+				},
+			}.WithDefaults(providers.Ivpn),
+			servers: []models.Server{
+				{UDP: true, Hostname: "a", VPN: vpn.OpenVPN},
+				{UDP: true, TCP: true, Hostname: "b", VPN: vpn.OpenVPN},
+				{UDP: true, Hostname: "c", VPN: vpn.OpenVPN},
+			},
+			filtered: []models.Server{
+				{UDP: true, TCP: true, Hostname: "b", VPN: vpn.OpenVPN},
+			},
+		},
+		"filter by multihop only": {
+			selection: settings.ServerSelection{
+				MultiHopOnly: boolPtr(true),
+			}.WithDefaults(providers.Surfshark),
+			servers: []models.Server{
+				{MultiHop: false, VPN: vpn.OpenVPN, UDP: true},
+				{MultiHop: true, VPN: vpn.OpenVPN, UDP: true},
+				{MultiHop: false, VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{MultiHop: true, VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by free only": {
+			selection: settings.ServerSelection{
+				FreeOnly: boolPtr(true),
+			}.WithDefaults(providers.Surfshark),
+			servers: []models.Server{
+				{Free: false, VPN: vpn.OpenVPN, UDP: true},
+				{Free: true, VPN: vpn.OpenVPN, UDP: true},
+				{Free: false, VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{Free: true, VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by stream only": {
+			selection: settings.ServerSelection{
+				StreamOnly: boolPtr(true),
+			}.WithDefaults(providers.Surfshark),
+			servers: []models.Server{
+				{Stream: false, VPN: vpn.OpenVPN, UDP: true},
+				{Stream: true, VPN: vpn.OpenVPN, UDP: true},
+				{Stream: false, VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{Stream: true, VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by owned": {
+			selection: settings.ServerSelection{
+				OwnedOnly: boolPtr(true),
+			}.WithDefaults(providers.Mullvad),
+			servers: []models.Server{
+				{Owned: false, VPN: vpn.OpenVPN, UDP: true},
+				{Owned: true, VPN: vpn.OpenVPN, UDP: true},
+				{Owned: false, VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{Owned: true, VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by country": {
+			selection: settings.ServerSelection{
+				Countries: []string{"b"},
+			}.WithDefaults(providers.Mullvad),
+			servers: []models.Server{
+				{Country: "a", VPN: vpn.OpenVPN, UDP: true},
+				{Country: "b", VPN: vpn.OpenVPN, UDP: true},
+				{Country: "c", VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{Country: "b", VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by region": {
+			selection: settings.ServerSelection{
+				Regions: []string{"b"},
+			}.WithDefaults(providers.Surfshark),
+			servers: []models.Server{
+				{Region: "a", VPN: vpn.OpenVPN, UDP: true},
+				{Region: "b", VPN: vpn.OpenVPN, UDP: true},
+				{Region: "c", VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{Region: "b", VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by city": {
+			selection: settings.ServerSelection{
+				Cities: []string{"b"},
+			}.WithDefaults(providers.Mullvad),
+			servers: []models.Server{
+				{City: "a", VPN: vpn.OpenVPN, UDP: true},
+				{City: "b", VPN: vpn.OpenVPN, UDP: true},
+				{City: "c", VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{City: "b", VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by ISP": {
+			selection: settings.ServerSelection{
+				ISPs: []string{"b"},
+			}.WithDefaults(providers.Mullvad),
+			servers: []models.Server{
+				{ISP: "a", VPN: vpn.OpenVPN, UDP: true},
+				{ISP: "b", VPN: vpn.OpenVPN, UDP: true},
+				{ISP: "c", VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{ISP: "b", VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by number": {
+			selection: settings.ServerSelection{
+				Numbers: []uint16{1},
+			}.WithDefaults(providers.Mullvad),
+			servers: []models.Server{
+				{Number: 0, VPN: vpn.OpenVPN, UDP: true},
+				{Number: 1, VPN: vpn.OpenVPN, UDP: true},
+				{Number: 2, VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{Number: 1, VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by server name": {
+			selection: settings.ServerSelection{
+				Names: []string{"b"},
+			}.WithDefaults(providers.Mullvad),
+			servers: []models.Server{
+				{ServerName: "a", VPN: vpn.OpenVPN, UDP: true},
+				{ServerName: "b", VPN: vpn.OpenVPN, UDP: true},
+				{ServerName: "c", VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{ServerName: "b", VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+		"filter by hostname": {
+			selection: settings.ServerSelection{
+				Hostnames: []string{"b"},
+			}.WithDefaults(providers.Mullvad),
+			servers: []models.Server{
+				{Hostname: "a", VPN: vpn.OpenVPN, UDP: true},
+				{Hostname: "b", VPN: vpn.OpenVPN, UDP: true},
+				{Hostname: "c", VPN: vpn.OpenVPN, UDP: true},
+			},
+			filtered: []models.Server{
+				{Hostname: "b", VPN: vpn.OpenVPN, UDP: true},
+			},
+		},
+	}
+
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			filtered, err := FilterServers(testCase.servers, testCase.selection)
+
+			assert.ErrorIs(t, err, testCase.errWrapped)
+			if testCase.errWrapped != nil {
+				assert.EqualError(t, err, testCase.errMessage)
+			}
+
+			assert.Equal(t, testCase.filtered, filtered)
+		})
+	}
+}
+
+func Test_filterByPossibilities(t *testing.T) {
 	t.Parallel()
 	testCases := map[string]struct {
 		value         string
@@ -29,7 +251,7 @@ func Test_FilterByPossibilities(t *testing.T) {
 		testCase := testCase
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
-			filtered := FilterByPossibilities(testCase.value, testCase.possibilities)
+			filtered := filterByPossibilities(testCase.value, testCase.possibilities)
 			assert.Equal(t, testCase.filtered, filtered)
 		})
 	}

internal/provider/vpnunlimited/connection.go

@@ -12,7 +12,7 @@ func (p *Provider) GetConnection(selection settings.ServerSelection) (
 	const port = 1194
 	const protocol = constants.UDP
 
-	servers, err := p.filterServers(selection)
+	servers, err := utils.FilterServers(p.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/vpnunlimited/filter.go

@@ -1,30 +0,0 @@
-package vpnunlimited
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (p *Provider) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range p.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Country, selection.Countries),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			*selection.FreeOnly && !server.Free,
-			*selection.StreamOnly && !server.Stream,
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/vyprvpn/connection.go

@@ -12,7 +12,7 @@ func (v *Vyprvpn) GetConnection(selection settings.ServerSelection) (
 	const port = 443
 	const protocol = constants.UDP
 
-	servers, err := v.filterServers(selection)
+	servers, err := utils.FilterServers(v.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/vyprvpn/filter.go

@@ -1,27 +0,0 @@
-package vyprvpn
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (v *Vyprvpn) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range v.servers {
-		switch {
-		case
-			utils.FilterByPossibilities(server.Region, selection.Regions),
-			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByProtocol(selection, server.TCP, server.UDP):
-		default:
-			servers = append(servers, server)
-		}
-	}
-
-	if len(servers) == 0 {
-		return nil, utils.NoServerFoundError(selection)
-	}
-
-	return servers, nil
-}

internal/provider/wevpn/connection.go

@@ -11,7 +11,7 @@ func (w *Wevpn) GetConnection(selection settings.ServerSelection) (
 	port := getPort(selection)
 	protocol := utils.GetProtocol(selection)
 
-	servers, err := w.filterServers(selection)
+	servers, err := utils.FilterServers(w.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/wevpn/connection_test.go

@@ -1,7 +1,6 @@
 package wevpn
 
 import (
-	"errors"
 	"math/rand"
 	"net"
 	"testing"
@@ -11,8 +10,8 @@ import (
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/provider/utils"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func Test_Wevpn_GetConnection(t *testing.T) {
@@ -22,19 +21,21 @@ func Test_Wevpn_GetConnection(t *testing.T) {
 		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
-		err        error
+		errWrapped error
+		errMessage string
 	}{
 		"no server available": {
 			selection: settings.ServerSelection{
 				VPN: vpn.OpenVPN,
 			}.WithDefaults(providers.Wevpn),
-			err: errors.New("no server found: for VPN openvpn; protocol udp"),
+			errWrapped: utils.ErrNoServerFound,
+			errMessage: "no server found: for VPN openvpn; protocol udp",
 		},
 		"no filter": {
 			servers: []models.Server{
-				{UDP: true, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{UDP: true, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{UDP: true, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Wevpn),
 			connection: models.Connection{
@@ -49,9 +50,9 @@ func Test_Wevpn_GetConnection(t *testing.T) {
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Wevpn),
 			servers: []models.Server{
-				{UDP: true, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{UDP: true, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{UDP: true, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -65,9 +66,9 @@ func Test_Wevpn_GetConnection(t *testing.T) {
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Wevpn),
 			servers: []models.Server{
-				{UDP: true, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{UDP: true, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{UDP: true, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -89,11 +90,9 @@ func Test_Wevpn_GetConnection(t *testing.T) {
 
 			connection, err := m.GetConnection(testCase.selection)
 
-			if testCase.err != nil {
+			assert.ErrorIs(t, err, testCase.errWrapped)
-				require.Error(t, err)
+			if testCase.errWrapped != nil {
-				assert.Equal(t, testCase.err.Error(), err.Error())
+				assert.EqualError(t, err, testCase.errMessage)
-			} else {
-				assert.NoError(t, err)
 			}
 
 			assert.Equal(t, testCase.connection, connection)

internal/provider/wevpn/filter.go

@@ -1,27 +0,0 @@
-package wevpn
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (w *Wevpn) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range w.servers {
-		switch {
-		case
-			utils.FilterByProtocol(selection, server.TCP, server.UDP),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			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/wevpn/filter_test.go

@@ -1,105 +0,0 @@
-package wevpn
-
-import (
-	"errors"
-	"math/rand"
-	"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_Wevpn_filterServers(t *testing.T) {
-	t.Parallel()
-
-	testCases := map[string]struct {
-		servers   []models.Server
-		selection settings.ServerSelection
-		filtered  []models.Server
-		err       error
-	}{
-		"no server available": {
-			selection: settings.ServerSelection{}.WithDefaults(providers.Wevpn),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
-		},
-		"no filter": {
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-			selection: settings.ServerSelection{}.WithDefaults(providers.Wevpn),
-			filtered: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-		},
-		"filter by protocol": {
-			selection: settings.ServerSelection{
-				OpenVPN: settings.OpenVPNSelection{TCP: boolPtr(true)},
-			}.WithDefaults(providers.Wevpn),
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", TCP: true},
-				{Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Hostname: "b", TCP: true},
-			},
-		},
-		"filter by city": {
-			selection: settings.ServerSelection{
-				Cities: []string{"b"},
-			}.WithDefaults(providers.Wevpn),
-			servers: []models.Server{
-				{City: "a", UDP: true},
-				{City: "b", UDP: true},
-				{City: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{City: "b", UDP: true},
-			},
-		},
-		"filter by hostname": {
-			selection: settings.ServerSelection{
-				Hostnames: []string{"b"},
-			}.WithDefaults(providers.Wevpn),
-			servers: []models.Server{
-				{Hostname: "a", UDP: true},
-				{Hostname: "b", UDP: true},
-				{Hostname: "c", UDP: true},
-			},
-			filtered: []models.Server{
-				{Hostname: "b", UDP: true},
-			},
-		},
-	}
-
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			randSource := rand.NewSource(0)
-
-			w := New(testCase.servers, randSource)
-
-			servers, err := w.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.filtered, servers)
-		})
-	}
-}

internal/provider/windscribe/connection.go

@@ -11,7 +11,7 @@ func (w *Windscribe) GetConnection(selection settings.ServerSelection) (
 	port := getPort(selection)
 	protocol := utils.GetProtocol(selection)
 
-	servers, err := w.filterServers(selection)
+	servers, err := utils.FilterServers(w.servers, selection)
 	if err != nil {
 		return connection, err
 	}

internal/provider/windscribe/connection_test.go

@@ -1,7 +1,6 @@
 package windscribe
 
 import (
-	"errors"
 	"math/rand"
 	"net"
 	"testing"
@@ -11,8 +10,8 @@ import (
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/provider/utils"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func Test_Windscribe_GetConnection(t *testing.T) {
@@ -22,17 +21,19 @@ func Test_Windscribe_GetConnection(t *testing.T) {
 		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
-		err        error
+		errWrapped error
+		errMessage string
 	}{
 		"no server available": {
 			selection:  settings.ServerSelection{}.WithDefaults(providers.Windscribe),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
+			errWrapped: utils.ErrNoServerFound,
+			errMessage: "no server found: for VPN openvpn; protocol udp",
 		},
 		"no filter": {
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{VPN: vpn.OpenVPN, UDP: true, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Windscribe),
 			connection: models.Connection{
@@ -47,9 +48,9 @@ func Test_Windscribe_GetConnection(t *testing.T) {
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Windscribe),
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -63,9 +64,9 @@ func Test_Windscribe_GetConnection(t *testing.T) {
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Windscribe),
 			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
+				{Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
+				{Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, VPN: vpn.OpenVPN, UDP: true},
-				{VPN: vpn.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
+				{Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, VPN: vpn.OpenVPN, UDP: true},
 			},
 			connection: models.Connection{
 				Type:     vpn.OpenVPN,
@@ -83,17 +84,14 @@ func Test_Windscribe_GetConnection(t *testing.T) {
 
 			randSource := rand.NewSource(0)
 
-			m := New(testCase.servers, randSource)
+			provider := New(testCase.servers, randSource)
 
-			connection, err := m.GetConnection(testCase.selection)
+			connection, err := provider.GetConnection(testCase.selection)
 
-			if testCase.err != nil {
+			assert.ErrorIs(t, err, testCase.errWrapped)
-				require.Error(t, err)
+			if testCase.errWrapped != nil {
-				assert.Equal(t, testCase.err.Error(), err.Error())
+				assert.EqualError(t, err, testCase.errMessage)
-			} else {
-				assert.NoError(t, err)
 			}
-
 			assert.Equal(t, testCase.connection, connection)
 		})
 	}

internal/provider/windscribe/filter.go

@@ -1,28 +0,0 @@
-package windscribe
-
-import (
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/utils"
-)
-
-func (w *Windscribe) filterServers(selection settings.ServerSelection) (
-	servers []models.Server, err error) {
-	for _, server := range w.servers {
-		switch {
-		case
-			server.VPN != selection.VPN,
-			utils.FilterByPossibilities(server.Region, selection.Regions),
-			utils.FilterByPossibilities(server.City, selection.Cities),
-			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/windscribe/filter_test.go

@@ -1,117 +0,0 @@
-package windscribe
-
-import (
-	"errors"
-	"math/rand"
-	"testing"
-
-	"github.com/qdm12/gluetun/internal/configuration/settings"
-	"github.com/qdm12/gluetun/internal/constants/providers"
-	"github.com/qdm12/gluetun/internal/constants/vpn"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func Test_Windscribe_filterServers(t *testing.T) {
-	t.Parallel()
-
-	testCases := map[string]struct {
-		servers   []models.Server
-		selection settings.ServerSelection
-		filtered  []models.Server
-		err       error
-	}{
-		"no server available": {
-			selection: settings.ServerSelection{}.WithDefaults(providers.Windscribe),
-			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
-		},
-		"no filter": {
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.OpenVPN, Hostname: "b"},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-			selection: settings.ServerSelection{}.WithDefaults(providers.Windscribe),
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.OpenVPN, Hostname: "b"},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-		},
-		"filter OpenVPN out": {
-			selection: settings.ServerSelection{
-				VPN: vpn.Wireguard,
-			}.WithDefaults(providers.Windscribe),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.Wireguard, Hostname: "b"},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.Wireguard, Hostname: "b"},
-			},
-		},
-		"filter by region": {
-			selection: settings.ServerSelection{
-				Regions: []string{"b"},
-			}.WithDefaults(providers.Windscribe),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Region: "a"},
-				{VPN: vpn.OpenVPN, Region: "b"},
-				{VPN: vpn.OpenVPN, Region: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Region: "b"},
-			},
-		},
-		"filter by city": {
-			selection: settings.ServerSelection{
-				Cities: []string{"b"},
-			}.WithDefaults(providers.Windscribe),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, City: "a"},
-				{VPN: vpn.OpenVPN, City: "b"},
-				{VPN: vpn.OpenVPN, City: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, City: "b"},
-			},
-		},
-		"filter by hostname": {
-			selection: settings.ServerSelection{
-				Hostnames: []string{"b"},
-			}.WithDefaults(providers.Windscribe),
-			servers: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "a"},
-				{VPN: vpn.OpenVPN, Hostname: "b"},
-				{VPN: vpn.OpenVPN, Hostname: "c"},
-			},
-			filtered: []models.Server{
-				{VPN: vpn.OpenVPN, Hostname: "b"},
-			},
-		},
-	}
-
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			randSource := rand.NewSource(0)
-
-			m := New(testCase.servers, randSource)
-
-			servers, err := m.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.filtered, servers)
-		})
-	}
-}