Preparing for v2.0.0 branch merge

This commit reverts changes from v1.4.5 to v1.4.7, to prepare for v2.0.0
branch codes.

Changes includes in these releases have been included in v2.0.0 branch
already.

Details:

Revert "feat: add --rfc1918 flag for explicit LAN client support"

This reverts commit 0e3f764299.

Revert "Upgrade quic-go to v0.54.0"

This reverts commit e52402eb0c.

Revert "docs: add known issues documentation for Darwin 15.5 upgrade issue"

This reverts commit 2133f31854.

Revert "start mobile library with provision id and custom hostname."

This reverts commit a198a5cd65.

Revert "Add OPNsense new lease file"

This reverts commit 7af29cfbc0.

Revert ".github/workflows: bump go version to 1.24.x"

This reverts commit ce1a165348.

Revert "fix: ensure upstream health checks can handle large DNS responses"

This reverts commit fd48e6d795.

Revert "refactor(prog): move network monitoring outside listener loop"

This reverts commit d71d1341b6.

Revert "fix: correct Windows API constants to fix domain join detection"

This reverts commit 21855df4af.

Revert "refactor: move network monitoring to separate goroutine"

This reverts commit 66e2d3a40a.

Revert "refactor: extract empty string filtering to reusable function"

This reverts commit 36a7423634.

Revert "cmd/cli: ignore empty positional argument for start command"

This reverts commit e616091249.

Revert "Avoiding Windows runners file locking issue"

This reverts commit 0948161529.

Revert "refactor: split selfUpgradeCheck into version check and upgrade execution"

This reverts commit ce29b5d217.

Revert "internal/router: support Ubios 4.3+"

This reverts commit de24fa293e.

Revert "internal/router: support Merlin Guest Network Pro VLAN"

This reverts commit 6663925c4d.

cmd/cli/cli.go

@@ -178,15 +178,7 @@ func RunMobile(appConfig *AppConfig, appCallback *AppCallback, stopCh chan struc
 	noConfigStart = false
 	homedir = appConfig.HomeDir
 	verbose = appConfig.Verbose
-	if appConfig.ProvisionID != "" {
-		cdOrg = appConfig.ProvisionID
-	}
-	if appConfig.CustomHostname != "" {
-		customHostname = appConfig.CustomHostname
-	}
-	if appConfig.CdUID != "" {
-		cdUID = appConfig.CdUID
-	}
+	cdUID = appConfig.CdUID
 	cdUpstreamProto = appConfig.UpstreamProto
 	logPath = appConfig.LogPath
 	run(appCallback, stopCh)

cmd/cli/commands.go

@@ -13,7 +13,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
-	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -189,7 +188,6 @@ func initRunCmd() *cobra.Command {
 	runCmd.Flags().StringVarP(&iface, "iface", "", "", `Update DNS setting for iface, "auto" means the default interface gateway`)
 	_ = runCmd.Flags().MarkHidden("iface")
 	runCmd.Flags().StringVarP(&cdUpstreamProto, "proto", "", ctrld.ResolverTypeDOH, `Control D upstream type, either "doh" or "doh3"`)
-	runCmd.Flags().BoolVarP(&rfc1918, "rfc1918", "", false, "Listen on RFC1918 addresses when 127.0.0.1 is the only listener")
 
 	runCmd.FParseErrWhitelist = cobra.FParseErrWhitelist{UnknownFlags: true}
 	rootCmd.AddCommand(runCmd)
@@ -208,7 +206,6 @@ func initStartCmd() *cobra.Command {
 
 NOTE: running "ctrld start" without any arguments will start already installed ctrld service.`,
 		Args: func(cmd *cobra.Command, args []string) error {
-			args = filterEmptyStrings(args)
 			if len(args) > 0 {
 				return fmt.Errorf("'ctrld start' doesn't accept positional arguments\n" +
 					"Use flags instead (e.g. --cd, --iface) or see 'ctrld start --help' for all options")
@@ -222,7 +219,6 @@ NOTE: running "ctrld start" without any arguments will start already installed c
 			sc := &service.Config{}
 			*sc = *svcConfig
 			osArgs := os.Args[2:]
-			osArgs = filterEmptyStrings(osArgs)
 			if os.Args[1] == "service" {
 				osArgs = os.Args[3:]
 			}
@@ -532,7 +528,6 @@ NOTE: running "ctrld start" without any arguments will start already installed c
 	startCmd.Flags().BoolVarP(&skipSelfChecks, "skip_self_checks", "", false, `Skip self checks after installing ctrld service`)
 	startCmd.Flags().BoolVarP(&startOnly, "start_only", "", false, "Do not install new service")
 	_ = startCmd.Flags().MarkHidden("start_only")
-	startCmd.Flags().BoolVarP(&rfc1918, "rfc1918", "", false, "Listen on RFC1918 addresses when 127.0.0.1 is the only listener")
 
 	routerCmd := &cobra.Command{
 		Use: "setup",
@@ -571,7 +566,6 @@ NOTE: running "ctrld start" without any arguments will start already installed c
 
 NOTE: running "ctrld start" without any arguments will start already installed ctrld service.`,
 		Args: func(cmd *cobra.Command, args []string) error {
-			args = filterEmptyStrings(args)
 			if len(args) > 0 {
 				return fmt.Errorf("'ctrld start' doesn't accept positional arguments\n" +
 					"Use flags instead (e.g. --cd, --iface) or see 'ctrld start --help' for all options")
@@ -1387,11 +1381,3 @@ func initServicesCmd(commands ...*cobra.Command) *cobra.Command {
 
 	return serviceCmd
 }
-
-// filterEmptyStrings removes empty strings from a slice of strings.
-// It returns a new slice containing only non-empty strings.
-func filterEmptyStrings(slice []string) []string {
-	return slices.DeleteFunc(slice, func(s string) bool {
-		return s == ""
-	})
-}

cmd/cli/dns_proxy.go

@@ -84,7 +84,13 @@ type upstreamForResult struct {
 	srcAddr        string
 }
 
-func (p *prog) serveDNS(listenerNum string) error {
+func (p *prog) serveDNS(mainCtx context.Context, listenerNum string) error {
+	// Start network monitoring
+	if err := p.monitorNetworkChanges(mainCtx); err != nil {
+		mainLog.Load().Error().Err(err).Msg("Failed to start network monitoring")
+		// Don't return here as we still want DNS service to run
+	}
+
 	listenerConfig := p.cfg.Listener[listenerNum]
 	// make sure ip is allocated
 	if allocErr := p.allocateIP(listenerConfig.IP); allocErr != nil {
@@ -207,8 +213,8 @@ func (p *prog) serveDNS(listenerNum string) error {
 				return nil
 			})
 		}
-		// When we spawn a listener on 127.0.0.1, also spawn listeners on the RFC1918 addresses of the machine
-		// if explicitly set via setting rfc1918 flag, so ctrld could receive queries from LAN clients.
+		// When we spawn a listener on 127.0.0.1, also spawn listeners on the RFC1918
+		// addresses of the machine. So ctrld could receive queries from LAN clients.
 		if needRFC1918Listeners(listenerConfig) {
 			g.Go(func() error {
 				for _, addr := range ctrld.Rfc1918Addresses() {
@@ -1039,7 +1045,7 @@ func (p *prog) queryFromSelf(ip string) bool {
 // needRFC1918Listeners reports whether ctrld need to spawn listener for RFC 1918 addresses.
 // This is helpful for non-desktop platforms to receive queries from LAN clients.
 func needRFC1918Listeners(lc *ctrld.ListenerConfig) bool {
-	return rfc1918 && lc.IP == "127.0.0.1" && lc.Port == 53
+	return lc.IP == "127.0.0.1" && lc.Port == 53 && !ctrld.IsDesktopPlatform()
 }
 
 // ipFromARPA parses a FQDN arpa domain and return the IP address if valid.
@@ -1181,7 +1187,7 @@ func FlushDNSCache() error {
 }
 
 // monitorNetworkChanges starts monitoring for network interface changes
-func (p *prog) monitorNetworkChanges() error {
+func (p *prog) monitorNetworkChanges(ctx context.Context) error {
 	mon, err := netmon.New(func(format string, args ...any) {
 		// Always fetch the latest logger (and inject the prefix)
 		mainLog.Load().Printf("netmon: "+format, args...)
@@ -1400,6 +1406,9 @@ func (p *prog) checkUpstreamOnce(upstream string, uc *ctrld.UpstreamConfig) erro
 		return err
 	}
 
+	msg := new(dns.Msg)
+	msg.SetQuestion(".", dns.TypeNS)
+
 	timeout := 1000 * time.Millisecond
 	if uc.Timeout > 0 {
 		timeout = time.Millisecond * time.Duration(uc.Timeout)
@@ -1413,7 +1422,6 @@ func (p *prog) checkUpstreamOnce(upstream string, uc *ctrld.UpstreamConfig) erro
 	mainLog.Load().Debug().Msgf("Rebootstrapping resolver for upstream: %s", upstream)
 
 	start := time.Now()
-	msg := uc.VerifyMsg()
 	_, err = resolver.Resolve(ctx, msg)
 	duration := time.Since(start)
 

cmd/cli/library.go

@@ -18,13 +18,11 @@ type AppCallback struct {
 
 // AppConfig allows overwriting ctrld cli flags from mobile platforms.
 type AppConfig struct {
-	CdUID          string
-	ProvisionID    string
-	CustomHostname string
-	HomeDir        string
-	UpstreamProto  string
-	Verbose        int
-	LogPath        string
+	CdUID         string
+	HomeDir       string
+	UpstreamProto string
+	Verbose       int
+	LogPath       string
 }
 
 const (

cmd/cli/main.go

@@ -39,7 +39,6 @@ var (
 	skipSelfChecks    bool
 	cleanup           bool
 	startOnly         bool
-	rfc1918           bool
 
 	mainLog       atomic.Pointer[zerolog.Logger]
 	consoleWriter zerolog.ConsoleWriter

cmd/cli/net_darwin_test.go

@@ -0,0 +1,104 @@
+package cli
+
+import (
+	"maps"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const listnetworkserviceorderOutput = `
+(1) USB 10/100/1000 LAN 2
+(Hardware Port: USB 10/100/1000 LAN, Device: en7)
+
+(2) Ethernet
+(Hardware Port: Ethernet, Device: en0)
+
+(3) Wi-Fi
+(Hardware Port: Wi-Fi, Device: en1)
+
+(4) Bluetooth PAN
+(Hardware Port: Bluetooth PAN, Device: en4)
+
+(5) Thunderbolt Bridge
+(Hardware Port: Thunderbolt Bridge, Device: bridge0)
+
+(6) kernal
+(Hardware Port: com.wireguard.macos, Device: )
+
+(7) WS BT
+(Hardware Port: com.wireguard.macos, Device: )
+
+(8) ca-001-stg
+(Hardware Port: com.wireguard.macos, Device: )
+
+(9) ca-001-stg-2
+(Hardware Port: com.wireguard.macos, Device: )
+
+`
+
+func Test_networkServiceName(t *testing.T) {
+	tests := []struct {
+		ifaceName          string
+		networkServiceName string
+	}{
+		{"en7", "USB 10/100/1000 LAN 2"},
+		{"en0", "Ethernet"},
+		{"en1", "Wi-Fi"},
+		{"en4", "Bluetooth PAN"},
+		{"bridge0", "Thunderbolt Bridge"},
+	}
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.ifaceName, func(t *testing.T) {
+			t.Parallel()
+			name := networkServiceName(tc.ifaceName, strings.NewReader(listnetworkserviceorderOutput))
+			assert.Equal(t, tc.networkServiceName, name)
+		})
+	}
+}
+
+const listallhardwareportsOutput = `
+Hardware Port: Ethernet Adapter (en6)
+Device: en6
+Ethernet Address: 3a:3e:fc:1e:ab:41
+
+Hardware Port: Ethernet Adapter (en7)
+Device: en7
+Ethernet Address: 3a:3e:fc:1e:ab:42
+
+Hardware Port: Thunderbolt Bridge
+Device: bridge0
+Ethernet Address: 36:21:bb:3a:7a:40
+
+Hardware Port: Wi-Fi
+Device: en0
+Ethernet Address: a0:78:17:68:56:3f
+
+Hardware Port: Thunderbolt 1
+Device: en1
+Ethernet Address: 36:21:bb:3a:7a:40
+
+Hardware Port: Thunderbolt 2
+Device: en2
+Ethernet Address: 36:21:bb:3a:7a:44
+
+VLAN Configurations
+===================
+`
+
+func Test_parseListAllHardwarePorts(t *testing.T) {
+	expected := map[string]struct{}{
+		"en0":     {},
+		"en1":     {},
+		"en2":     {},
+		"en6":     {},
+		"en7":     {},
+		"bridge0": {},
+	}
+	m := parseListAllHardwarePorts(strings.NewReader(listallhardwareportsOutput))
+	if !maps.Equal(m, expected) {
+		t.Errorf("unexpected output, want: %v, got: %v", expected, m)
+	}
+}

cmd/cli/prog.go

@@ -35,7 +35,6 @@ import (
 	"github.com/Control-D-Inc/ctrld/internal/controld"
 	"github.com/Control-D-Inc/ctrld/internal/dnscache"
 	"github.com/Control-D-Inc/ctrld/internal/router"
-	"github.com/Control-D-Inc/ctrld/internal/router/dnsmasq"
 )
 
 const (
@@ -329,7 +328,7 @@ func (p *prog) apiConfigReload() {
 
 		// Performing self-upgrade check for production version.
 		if isStable {
-			_ = selfUpgradeCheck(resolverConfig.Ctrld.VersionTarget, curVer, &logger)
+			selfUpgradeCheck(resolverConfig.Ctrld.VersionTarget, curVer, &logger)
 		}
 
 		if resolverConfig.DeactivationPin != nil {
@@ -530,15 +529,6 @@ func (p *prog) run(reload bool, reloadCh chan struct{}) {
 		go p.watchLinkState(ctx)
 	}
 
-	if !reload {
-		go func() {
-			// Start network monitoring
-			if err := p.monitorNetworkChanges(); err != nil {
-				mainLog.Load().Error().Err(err).Msg("Failed to start network monitoring")
-			}
-		}()
-	}
-
 	for listenerNum := range p.cfg.Listener {
 		p.cfg.Listener[listenerNum].Init()
 		if !reload {
@@ -550,7 +540,7 @@ func (p *prog) run(reload bool, reloadCh chan struct{}) {
 				}
 				addr := net.JoinHostPort(listenerConfig.IP, strconv.Itoa(listenerConfig.Port))
 				mainLog.Load().Info().Msgf("starting DNS server on listener.%s: %s", listenerNum, addr)
-				if err := p.serveDNS(listenerNum); err != nil {
+				if err := p.serveDNS(ctx, listenerNum); err != nil {
 					mainLog.Load().Fatal().Err(err).Msgf("unable to start dns proxy on listener.%s", listenerNum)
 				}
 				mainLog.Load().Debug().Msgf("end of serveDNS listener.%s: %s", listenerNum, addr)
@@ -617,12 +607,6 @@ func (p *prog) setupClientInfoDiscover(selfIP string) {
 		format := ctrld.LeaseFileFormat(p.cfg.Service.DHCPLeaseFileFormat)
 		p.ciTable.AddLeaseFile(leaseFile, format)
 	}
-	if leaseFiles := dnsmasq.AdditionalLeaseFiles(); len(leaseFiles) > 0 {
-		mainLog.Load().Debug().Msgf("watching additional lease files: %v", leaseFiles)
-		for _, leaseFile := range leaseFiles {
-			p.ciTable.AddLeaseFile(leaseFile, ctrld.Dnsmasq)
-		}
-	}
 }
 
 // runClientInfoDiscover runs the client info discover.
@@ -1483,15 +1467,14 @@ func selfUninstallCheck(uninstallErr error, p *prog, logger zerolog.Logger) {
 	}
 }
 
-// shouldUpgrade checks if the version target vt is greater than the current one cv.
-// Major version upgrades are not allowed to prevent breaking changes.
+// selfUpgradeCheck checks if the version target vt is greater
+// than the current one cv, perform self-upgrade then.
 //
 // The callers must ensure curVer and logger are non-nil.
-// Returns true if upgrade is allowed, false otherwise.
-func shouldUpgrade(vt string, cv *semver.Version, logger *zerolog.Logger) bool {
+func selfUpgradeCheck(vt string, cv *semver.Version, logger *zerolog.Logger) {
 	if vt == "" {
 		logger.Debug().Msg("no version target set, skipped checking self-upgrade")
-		return false
+		return
 	}
 	vts := vt
 	if !strings.HasPrefix(vts, "v") {
@@ -1500,58 +1483,28 @@ func shouldUpgrade(vt string, cv *semver.Version, logger *zerolog.Logger) bool {
 	targetVer, err := semver.NewVersion(vts)
 	if err != nil {
 		logger.Warn().Err(err).Msgf("invalid target version, skipped self-upgrade: %s", vt)
-		return false
+		return
 	}
-
-	// Prevent major version upgrades to avoid breaking changes
-	if targetVer.Major() != cv.Major() {
-		logger.Warn().
-			Str("target", vt).
-			Str("current", cv.String()).
-			Msgf("major version upgrade not allowed (target: %d, current: %d), skipped self-upgrade", targetVer.Major(), cv.Major())
-		return false
-	}
-
 	if !targetVer.GreaterThan(cv) {
 		logger.Debug().
 			Str("target", vt).
 			Str("current", cv.String()).
 			Msgf("target version is not greater than current one, skipped self-upgrade")
-		return false
+		return
 	}
 
-	return true
-}
-
-// performUpgrade executes the self-upgrade command.
-// Returns true if upgrade was initiated successfully, false otherwise.
-func performUpgrade(vt string) bool {
 	exe, err := os.Executable()
 	if err != nil {
 		mainLog.Load().Error().Err(err).Msg("failed to get executable path, skipped self-upgrade")
-		return false
+		return
 	}
 	cmd := exec.Command(exe, "upgrade", "prod", "-vv")
 	cmd.SysProcAttr = sysProcAttrForDetachedChildProcess()
 	if err := cmd.Start(); err != nil {
 		mainLog.Load().Error().Err(err).Msg("failed to start self-upgrade")
-		return false
+		return
 	}
-	mainLog.Load().Debug().Msgf("self-upgrade triggered, version target: %s", vt)
-	return true
-}
-
-// selfUpgradeCheck checks if the version target vt is greater
-// than the current one cv, perform self-upgrade then.
-// Major version upgrades are not allowed to prevent breaking changes.
-//
-// The callers must ensure curVer and logger are non-nil.
-// Returns true if upgrade is allowed and should proceed, false otherwise.
-func selfUpgradeCheck(vt string, cv *semver.Version, logger *zerolog.Logger) bool {
-	if shouldUpgrade(vt, cv, logger) {
-		return performUpgrade(vt)
-	}
-	return false
+	mainLog.Load().Debug().Msgf("self-upgrade triggered, version target: %s", vts)
 }
 
 // leakOnUpstreamFailure reports whether ctrld should initiate a recovery flow

cmd/cli/prog_test.go

@@ -1,15 +1,11 @@
 package cli
 
 import (
-	"runtime"
 	"testing"
 	"time"
 
-	"github.com/Masterminds/semver/v3"
-	"github.com/rs/zerolog"
-	"github.com/stretchr/testify/assert"
-
 	"github.com/Control-D-Inc/ctrld"
+	"github.com/stretchr/testify/assert"
 )
 
 func Test_prog_dnsWatchdogEnabled(t *testing.T) {
@@ -59,215 +55,3 @@ func Test_prog_dnsWatchdogInterval(t *testing.T) {
 		})
 	}
 }
-
-func Test_shouldUpgrade(t *testing.T) {
-	// Helper function to create a version
-	makeVersion := func(v string) *semver.Version {
-		ver, err := semver.NewVersion(v)
-		if err != nil {
-			t.Fatalf("failed to create version %s: %v", v, err)
-		}
-		return ver
-	}
-
-	tests := []struct {
-		name           string
-		versionTarget  string
-		currentVersion *semver.Version
-		shouldUpgrade  bool
-		description    string
-	}{
-		{
-			name:           "empty version target",
-			versionTarget:  "",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  false,
-			description:    "should skip upgrade when version target is empty",
-		},
-		{
-			name:           "invalid version target",
-			versionTarget:  "invalid-version",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  false,
-			description:    "should skip upgrade when version target is invalid",
-		},
-		{
-			name:           "same version",
-			versionTarget:  "v1.0.0",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  false,
-			description:    "should skip upgrade when target version equals current version",
-		},
-		{
-			name:           "older version",
-			versionTarget:  "v1.0.0",
-			currentVersion: makeVersion("v1.1.0"),
-			shouldUpgrade:  false,
-			description:    "should skip upgrade when target version is older than current version",
-		},
-		{
-			name:           "patch upgrade allowed",
-			versionTarget:  "v1.0.1",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  true,
-			description:    "should allow patch version upgrade within same major version",
-		},
-		{
-			name:           "minor upgrade allowed",
-			versionTarget:  "v1.1.0",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  true,
-			description:    "should allow minor version upgrade within same major version",
-		},
-		{
-			name:           "major upgrade blocked",
-			versionTarget:  "v2.0.0",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  false,
-			description:    "should block major version upgrade",
-		},
-		{
-			name:           "major downgrade blocked",
-			versionTarget:  "v1.0.0",
-			currentVersion: makeVersion("v2.0.0"),
-			shouldUpgrade:  false,
-			description:    "should block major version downgrade",
-		},
-		{
-			name:           "version without v prefix",
-			versionTarget:  "1.0.1",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  true,
-			description:    "should handle version target without v prefix",
-		},
-		{
-			name:           "complex version upgrade allowed",
-			versionTarget:  "v1.5.3",
-			currentVersion: makeVersion("v1.4.2"),
-			shouldUpgrade:  true,
-			description:    "should allow complex version upgrade within same major version",
-		},
-		{
-			name:           "complex major upgrade blocked",
-			versionTarget:  "v3.1.0",
-			currentVersion: makeVersion("v2.5.3"),
-			shouldUpgrade:  false,
-			description:    "should block complex major version upgrade",
-		},
-		{
-			name:           "pre-release version upgrade allowed",
-			versionTarget:  "v1.0.1-beta.1",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  true,
-			description:    "should allow pre-release version upgrade within same major version",
-		},
-		{
-			name:           "pre-release major upgrade blocked",
-			versionTarget:  "v2.0.0-alpha.1",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  false,
-			description:    "should block pre-release major version upgrade",
-		},
-	}
-
-	for _, tc := range tests {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			// Create test logger
-			testLogger := zerolog.New(zerolog.NewTestWriter(t)).With().Logger()
-
-			// Call the function and capture the result
-			result := shouldUpgrade(tc.versionTarget, tc.currentVersion, &testLogger)
-
-			// Assert the expected result
-			assert.Equal(t, tc.shouldUpgrade, result, tc.description)
-		})
-	}
-}
-
-func Test_selfUpgradeCheck(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("skipped due to Windows file locking issue on Github Action runners")
-	}
-
-	// Helper function to create a version
-	makeVersion := func(v string) *semver.Version {
-		ver, err := semver.NewVersion(v)
-		if err != nil {
-			t.Fatalf("failed to create version %s: %v", v, err)
-		}
-		return ver
-	}
-
-	tests := []struct {
-		name           string
-		versionTarget  string
-		currentVersion *semver.Version
-		shouldUpgrade  bool
-		description    string
-	}{
-		{
-			name:           "upgrade allowed",
-			versionTarget:  "v1.0.1",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  true,
-			description:    "should allow upgrade and attempt to perform it",
-		},
-		{
-			name:           "upgrade blocked",
-			versionTarget:  "v2.0.0",
-			currentVersion: makeVersion("v1.0.0"),
-			shouldUpgrade:  false,
-			description:    "should block upgrade and not attempt to perform it",
-		},
-	}
-
-	for _, tc := range tests {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			// Create test logger
-			testLogger := zerolog.New(zerolog.NewTestWriter(t)).With().Logger()
-
-			// Call the function and capture the result
-			result := selfUpgradeCheck(tc.versionTarget, tc.currentVersion, &testLogger)
-
-			// Assert the expected result
-			assert.Equal(t, tc.shouldUpgrade, result, tc.description)
-		})
-	}
-}
-
-func Test_performUpgrade(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("skipped due to Windows file locking issue on Github Action runners")
-	}
-
-	tests := []struct {
-		name           string
-		versionTarget  string
-		expectedResult bool
-		description    string
-	}{
-		{
-			name:           "valid version target",
-			versionTarget:  "v1.0.1",
-			expectedResult: true,
-			description:    "should attempt to perform upgrade with valid version target",
-		},
-		{
-			name:           "empty version target",
-			versionTarget:  "",
-			expectedResult: true,
-			description:    "should attempt to perform upgrade even with empty version target",
-		},
-	}
-
-	for _, tc := range tests {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			// Call the function and capture the result
-			result := performUpgrade(tc.versionTarget)
-			assert.Equal(t, tc.expectedResult, result, tc.description)
-		})
-	}
-}