admin/gluetun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(filter): common filter for all providers

Browse Source
This commit is contained in:
Quentin McGaw
2022-04-18 17:06:57 +00:00
parent ac9571c6b2
commit f5c00c3e2d
54 changed files with 435 additions and 1571 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
internal/provider/windscribe/connection.go
View File

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

42
internal/provider/windscribe/connection_test.go
View File

@@ -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"),
selection: settings.ServerSelection{}.WithDefaults(providers.Windscribe),
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, 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(1, 1, 1, 1)}},
{VPN: vpn.OpenVPN, 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)}},
},
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)}},
{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
{VPN: vpn.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, VPN: vpn.OpenVPN, 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)}, 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)}},
{VPN: vpn.OpenVPN, 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)}},
{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)}, VPN: vpn.OpenVPN, UDP: true},
{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 {
require.Error(t, err)
assert.Equal(t, testCase.err.Error(), err.Error())
} else {
assert.NoError(t, err)
assert.ErrorIs(t, err, testCase.errWrapped)
if testCase.errWrapped != nil {
assert.EqualError(t, err, testCase.errMessage)
}
assert.Equal(t, testCase.connection, connection)
})
}

28
internal/provider/windscribe/filter.go
View File

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

117
internal/provider/windscribe/filter_test.go
View File

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