diff --git a/internal/datasource/datasource.go b/internal/datasource/datasource.go
index 25181ca..34e684a 100644
--- a/internal/datasource/datasource.go
+++ b/internal/datasource/datasource.go
@@ -11,16 +11,19 @@
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 	"strings"
 	"time"
 
 	lru "github.com/hashicorp/golang-lru"
+	"golang.org/x/mod/semver"
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/derrors"
 	"golang.org/x/pkgsite/internal/fetch"
 	"golang.org/x/pkgsite/internal/log"
 	"golang.org/x/pkgsite/internal/proxy"
 	"golang.org/x/pkgsite/internal/source"
+	"golang.org/x/pkgsite/internal/version"
 )
 
 // dataSource implements the internal.DataSource interface, by trying a list of
@@ -201,3 +204,74 @@
 	}
 	return nil
 }
+
+// GetLatestInfo returns latest information for unitPath and modulePath.
+func (ds *dataSource) GetLatestInfo(ctx context.Context, unitPath, modulePath string, latestUnitMeta *internal.UnitMeta) (latest internal.LatestInfo, err error) {
+	defer derrors.Wrap(&err, "GetLatestInfo(ctx, %q, %q)", unitPath, modulePath)
+
+	if ds.prox == nil {
+		return internal.LatestInfo{}, nil
+	}
+
+	if latestUnitMeta == nil {
+		latestUnitMeta, err = ds.GetUnitMeta(ctx, unitPath, internal.UnknownModulePath, version.Latest)
+		if err != nil {
+			return latest, err
+		}
+	}
+	latest.MinorVersion = latestUnitMeta.Version
+	latest.MinorModulePath = latestUnitMeta.ModulePath
+
+	latest.MajorModulePath, latest.MajorUnitPath, err = ds.getLatestMajorVersion(ctx, unitPath, modulePath)
+	if err != nil {
+		return latest, err
+	}
+	// Do not try to discover whether the unit is in the latest minor version; assume it is.
+	latest.UnitExistsAtMinor = true
+	return latest, nil
+}
+
+// getLatestMajorVersion returns the latest module path and the full package path
+// of the latest version found in the proxy by iterating through vN versions.
+// This function does not attempt to find whether the full path exists
+// in the new major version.
+func (ds *dataSource) getLatestMajorVersion(ctx context.Context, fullPath, modulePath string) (_ string, _ string, err error) {
+	// We are checking if the full path is valid so that we can forward the error if not.
+	seriesPath := internal.SeriesPathForModule(modulePath)
+	info, err := ds.prox.Info(ctx, seriesPath, version.Latest)
+	if err != nil {
+		return "", "", err
+	}
+
+	// Converting version numbers to integers may cause an overflow, as version
+	// numbers need not fit into machine integers.
+	// While using Atoi is wrong, for it to fail, the version number must reach a
+	// value higher than at least 2^31, which is unlikely.
+	startVersion, err := strconv.Atoi(strings.TrimPrefix(semver.Major(info.Version), "v"))
+	if err != nil {
+		return "", "", err
+	}
+	startVersion++
+
+	// We start checking versions from "/v2" or higher, since v1 and v0 versions
+	// don't have a major version at the end of the modulepath.
+	if startVersion < 2 {
+		startVersion = 2
+	}
+
+	for v := startVersion; ; v++ {
+		query := fmt.Sprintf("%s/v%d", seriesPath, v)
+
+		_, err := ds.prox.Info(ctx, query, version.Latest)
+		if errors.Is(err, derrors.NotFound) {
+			if v == 2 {
+				return modulePath, fullPath, nil
+			}
+			latestModulePath := fmt.Sprintf("%s/v%d", seriesPath, v-1)
+			return latestModulePath, latestModulePath, nil
+		}
+		if err != nil {
+			return "", "", err
+		}
+	}
+}
diff --git a/internal/datasource/local.go b/internal/datasource/local.go
index 2315d33..feffa36 100644
--- a/internal/datasource/local.go
+++ b/internal/datasource/local.go
@@ -71,7 +71,7 @@
 
 // GetLatestInfo is not implemented.
 func (ds *LocalDataSource) GetLatestInfo(ctx context.Context, unitPath, modulePath string, latestUnitMeta *internal.UnitMeta) (internal.LatestInfo, error) {
-	return internal.LatestInfo{}, nil
+	return ds.ds.GetLatestInfo(ctx, unitPath, modulePath, latestUnitMeta)
 }
 
 // GetNestedModules is not implemented.
diff --git a/internal/datasource/proxy.go b/internal/datasource/proxy.go
index f3d08dc..bafd6d5 100644
--- a/internal/datasource/proxy.go
+++ b/internal/datasource/proxy.go
@@ -6,19 +6,12 @@
 
 import (
 	"context"
-	"errors"
-	"fmt"
-	"strconv"
-	"strings"
 	"time"
 
-	"golang.org/x/mod/semver"
 	"golang.org/x/pkgsite/internal"
-	"golang.org/x/pkgsite/internal/derrors"
 	"golang.org/x/pkgsite/internal/fetch"
 	"golang.org/x/pkgsite/internal/proxy"
 	"golang.org/x/pkgsite/internal/source"
-	"golang.org/x/pkgsite/internal/version"
 )
 
 var _ internal.DataSource = (*ProxyDataSource)(nil)
@@ -54,67 +47,5 @@
 
 // GetLatestInfo returns latest information for unitPath and modulePath.
 func (ds *ProxyDataSource) GetLatestInfo(ctx context.Context, unitPath, modulePath string, latestUnitMeta *internal.UnitMeta) (latest internal.LatestInfo, err error) {
-	defer derrors.Wrap(&err, "GetLatestInfo(ctx, %q, %q)", unitPath, modulePath)
-
-	if latestUnitMeta == nil {
-		latestUnitMeta, err = ds.GetUnitMeta(ctx, unitPath, internal.UnknownModulePath, version.Latest)
-		if err != nil {
-			return latest, err
-		}
-	}
-	latest.MinorVersion = latestUnitMeta.Version
-	latest.MinorModulePath = latestUnitMeta.ModulePath
-
-	latest.MajorModulePath, latest.MajorUnitPath, err = ds.getLatestMajorVersion(ctx, unitPath, modulePath)
-	if err != nil {
-		return latest, err
-	}
-	// Do not try to discover whether the unit is in the latest minor version; assume it is.
-	latest.UnitExistsAtMinor = true
-	return latest, nil
-}
-
-// getLatestMajorVersion returns the latest module path and the full package path
-// of the latest version found in the proxy by iterating through vN versions.
-// This function does not attempt to find whether the full path exists
-// in the new major version.
-func (ds *ProxyDataSource) getLatestMajorVersion(ctx context.Context, fullPath, modulePath string) (_ string, _ string, err error) {
-	// We are checking if the full path is valid so that we can forward the error if not.
-	seriesPath := internal.SeriesPathForModule(modulePath)
-	info, err := ds.ds.prox.Info(ctx, seriesPath, version.Latest)
-	if err != nil {
-		return "", "", err
-	}
-
-	// Converting version numbers to integers may cause an overflow, as version
-	// numbers need not fit into machine integers.
-	// While using Atoi is wrong, for it to fail, the version number must reach a
-	// value higher than at least 2^31, which is unlikely.
-	startVersion, err := strconv.Atoi(strings.TrimPrefix(semver.Major(info.Version), "v"))
-	if err != nil {
-		return "", "", err
-	}
-	startVersion++
-
-	// We start checking versions from "/v2" or higher, since v1 and v0 versions
-	// don't have a major version at the end of the modulepath.
-	if startVersion < 2 {
-		startVersion = 2
-	}
-
-	for v := startVersion; ; v++ {
-		query := fmt.Sprintf("%s/v%d", seriesPath, v)
-
-		_, err := ds.ds.prox.Info(ctx, query, version.Latest)
-		if errors.Is(err, derrors.NotFound) {
-			if v == 2 {
-				return modulePath, fullPath, nil
-			}
-			latestModulePath := fmt.Sprintf("%s/v%d", seriesPath, v-1)
-			return latestModulePath, latestModulePath, nil
-		}
-		if err != nil {
-			return "", "", err
-		}
-	}
+	return ds.ds.GetLatestInfo(ctx, unitPath, modulePath, latestUnitMeta)
 }
diff --git a/internal/datasource/proxy_details.go b/internal/datasource/proxy_details.go
index 3d01727..77f29fa 100644
--- a/internal/datasource/proxy_details.go
+++ b/internal/datasource/proxy_details.go
@@ -17,17 +17,6 @@
 	return ds.ds.GetUnit(ctx, um, field, bc)
 }
 
-// GetModuleInfo returns the ModuleInfo as fetched from the proxy for module
-// version specified by modulePath and version.
-func (ds *ProxyDataSource) GetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "GetModuleInfo(%q, %q)", modulePath, version)
-	m, err := ds.ds.getModule(ctx, modulePath, version)
-	if err != nil {
-		return nil, err
-	}
-	return &m.ModuleInfo, nil
-}
-
 func (ds *ProxyDataSource) GetUnitMeta(ctx context.Context, path, requestedModulePath, requestedVersion string) (_ *internal.UnitMeta, err error) {
 	return ds.ds.GetUnitMeta(ctx, path, requestedModulePath, requestedVersion)
 }
diff --git a/internal/datasource/proxy_test.go b/internal/datasource/proxy_test.go
index 4fcd767..9730c66 100644
--- a/internal/datasource/proxy_test.go
+++ b/internal/datasource/proxy_test.go
@@ -66,64 +66,8 @@
 			GOARCH:   "amd64",
 		}},
 	}
-	cmpOpts = append([]cmp.Option{
-		cmpopts.IgnoreFields(licenses.License{}, "Contents"),
-		cmpopts.IgnoreFields(internal.ModuleInfo{}, "SourceInfo"),
-	}, sample.LicenseCmpOpts...)
 )
 
-func TestGetModuleInfo(t *testing.T) {
-	ctx, ds, teardown := setup(t, false)
-	defer teardown()
-
-	modinfo := func(m, v string) *internal.ModuleInfo {
-		t.Helper()
-		mi, err := ds.GetModuleInfo(ctx, m, v)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return mi
-	}
-
-	wantModuleInfo := internal.ModuleInfo{
-		ModulePath:        "example.com/basic",
-		Version:           "v1.1.0",
-		CommitTime:        time.Date(2019, 1, 30, 0, 0, 0, 0, time.UTC),
-		IsRedistributable: true,
-		HasGoMod:          true,
-	}
-	got := modinfo("example.com/basic", "v1.1.0")
-	if diff := cmp.Diff(&wantModuleInfo, got, cmpOpts...); diff != "" {
-		t.Errorf("GetModuleInfo diff (-want +got):\n%s", diff)
-	}
-
-	// Get v1.0.0 of a deprecated module. The deprecation comment is in
-	// the latest version, v1.1.0.
-	got = modinfo("example.com/deprecated", "v1.0.0")
-	if !got.Deprecated {
-		t.Fatal("got not deprecated, want deprecated")
-	}
-	if want := "use something else"; got.DeprecationComment != want {
-		t.Errorf("got %q, want %q", got.DeprecationComment, want)
-	}
-
-	// Get v1.0.0 of a module with retractions. It should not be marked
-	// retracted, even though its own go.mod says it should be, because
-	// the latest go.mod does not retract it.
-	if modinfo("example.com/retractions", "v1.0.0").Retracted {
-		t.Fatal("got retracted, wanted false")
-	}
-	// v1.1.0 of the module is retracted.
-	got = modinfo("example.com/retractions", "v1.1.0")
-	if !got.Retracted {
-		t.Fatal("got retracted false, wanted true")
-	}
-	if want := "worse"; got.RetractionRationale != want {
-		t.Errorf("got rationale %q, want %q", got.RetractionRationale, want)
-	}
-
-}
-
 func TestProxyGetUnitMeta(t *testing.T) {
 	ctx, ds, teardown := setup(t, false)
 	defer teardown()