chore(updater): rename presolver to parallelResolver

internal/provider/ivpn/updater/servers.go

@@ -39,7 +39,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 	}
 
 	resolveSettings := parallelResolverSettings(hosts)
-	hostToIPs, warnings, err := u.presolver.Resolve(ctx, resolveSettings)
+	hostToIPs, warnings, err := u.parallelResolver.Resolve(ctx, resolveSettings)
 	for _, warning := range warnings {
 		u.warner.Warn(warning)
 	}

internal/provider/ivpn/updater/servers_test.go

@@ -150,18 +150,18 @@ func Test_Updater_GetServers(t *testing.T) {
 				}),
 			}
 
-			presolver := common.NewMockParallelResolver(ctrl)
+			parallelResolver := common.NewMockParallelResolver(ctrl)
 			if testCase.expectResolve {
-				presolver.EXPECT().Resolve(ctx, testCase.resolveSettings).
+				parallelResolver.EXPECT().Resolve(ctx, testCase.resolveSettings).
 					Return(testCase.hostToIPs, testCase.resolveWarnings, testCase.resolveErr)
 			}
 
 			warner := testCase.warnerBuilder(ctrl)
 
 			updater := &Updater{
-				client:    client,
-				presolver: presolver,
-				warner:    warner,
+				client:           client,
+				parallelResolver: parallelResolver,
+				warner:           warner,
 			}
 
 			servers, err := updater.FetchServers(ctx, testCase.minServers)

internal/provider/ivpn/updater/updater.go

@@ -7,16 +7,16 @@ import (
 )
 
 type Updater struct {
-	client    *http.Client
-	presolver common.ParallelResolver
-	warner    common.Warner
+	client           *http.Client
+	parallelResolver common.ParallelResolver
+	warner           common.Warner
 }
 
 func New(client *http.Client, warner common.Warner,
 	parallelResolver common.ParallelResolver) *Updater {
 	return &Updater{
-		client:    client,
-		presolver: parallelResolver,
-		warner:    warner,
+		client:           client,
+		parallelResolver: parallelResolver,
+		warner:           warner,
 	}
 }