add windows platform tests

Signed-off-by: lstocchi <lstocchi@redhat.com>

Author: lstocchi

pkg/machine/provider/platform_windows.go

@@ -15,6 +15,12 @@ import (
 	"go.podman.io/common/pkg/config"
 )
 
+// Variables to hold permission check functions for testing purposes.
+var (
+	hasAdminRightsFunc       = windows.HasAdminRights
+	hasHyperVAdminRightsFunc = hyperv.HasHyperVAdminRights
+)
+
 func Get() (vmconfigs.VMProvider, error) {
 	cfg, err := config.Default()
 	if err != nil {
@@ -42,7 +48,7 @@ func GetByVMType(resolvedVMType define.VMType) (vmconfigs.VMProvider, error) {
 		// Check permissions before returning the Hyper-V provider.
 		// Working with Hyper-V requires users to be at least members of the Hyper-V admin group.
 		// Init and remove actions have custom use cases and they are checked on the stubber.
-		if !windows.HasAdminRights() && !hyperv.HasHyperVAdminRights() {
+		if !hasAdminRightsFunc() && !hasHyperVAdminRightsFunc() {
 			return nil, hyperv.ErrHypervUserNotInAdminGroup
 		}
 		return new(hyperv.HyperVStubber), nil
@@ -55,7 +61,7 @@ func GetAll() []vmconfigs.VMProvider {
 	providers := []vmconfigs.VMProvider{
 		new(wsl.WSLStubber),
 	}
-	if windows.HasAdminRights() || hyperv.HasHyperVAdminRights() {
+	if hasAdminRightsFunc() || hasHyperVAdminRightsFunc() {
 		providers = append(providers, new(hyperv.HyperVStubber))
 	}
 	return providers
@@ -92,7 +98,7 @@ func HasPermsForProvider(provider define.VMType) bool {
 	case define.AppleHvVirt:
 		return false
 	case define.HyperVVirt:
-		return windows.HasAdminRights()
+		return hasAdminRightsFunc()
 	}
 
 	return true

pkg/machine/provider/platform_windows_test.go

@@ -0,0 +1,132 @@
+//go:build windows
+
+package provider
+
+import (
+	"testing"
+
+	"github.com/containers/podman/v6/pkg/machine/define"
+	"github.com/containers/podman/v6/pkg/machine/hyperv"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// helper to setup mocks and ensure cleanup
+func mockPermissions(t *testing.T, admin, hyperV bool) {
+	origAdmin, origHyperV := hasAdminRightsFunc, hasHyperVAdminRightsFunc
+	t.Cleanup(func() {
+		hasAdminRightsFunc = origAdmin
+		hasHyperVAdminRightsFunc = origHyperV
+	})
+
+	hasAdminRightsFunc = func() bool { return admin }
+	hasHyperVAdminRightsFunc = func() bool { return hyperV }
+}
+
+func TestGetByVMType_HyperV(t *testing.T) {
+	tests := []struct {
+		name        string
+		isAdmin     bool
+		isHyperV    bool
+		expectError bool
+	}{
+		{
+			name:        "WithAdminRights",
+			isAdmin:     true,
+			isHyperV:    false,
+			expectError: false,
+		},
+		{
+			name:        "WithHyperVAdminRights",
+			isAdmin:     false,
+			isHyperV:    true,
+			expectError: false,
+		},
+		{
+			name:        "WithBothRights",
+			isAdmin:     true,
+			isHyperV:    true,
+			expectError: false,
+		},
+		{
+			name:        "WithoutPermissions",
+			isAdmin:     false,
+			isHyperV:    false,
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockPermissions(t, tt.isAdmin, tt.isHyperV)
+
+			provider, err := GetByVMType(define.HyperVVirt)
+
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.Equal(t, err.Error(), hyperv.ErrHypervUserNotInAdminGroup.Error())
+				assert.Nil(t, provider)
+			} else {
+				require.NoError(t, err)
+				assert.NotNil(t, provider)
+				assert.Equal(t, define.HyperVVirt, provider.VMType())
+			}
+		})
+	}
+}
+
+func TestGetAll_HyperV_Inclusion(t *testing.T) {
+	tests := []struct {
+		name         string
+		isAdmin      bool
+		isHyperV     bool
+		expectHyperV bool
+	}{
+		{"WithAdminRights", true, false, true},
+		{"WithHyperVRights", false, true, true},
+		{"NoRights", false, false, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockPermissions(t, tt.isAdmin, tt.isHyperV)
+
+			providers := GetAll()
+
+			// Check for HyperV presence
+			hasHyperV := false
+			for _, p := range providers {
+				if p.VMType() == define.HyperVVirt {
+					hasHyperV = true
+					break
+				}
+			}
+
+			assert.Equal(t, tt.expectHyperV, hasHyperV, "Hyper-V provider presence mismatch")
+
+			// WSL should always be present in these scenarios
+			hasWSL := false
+			for _, p := range providers {
+				if p.VMType() == define.WSLVirt {
+					hasWSL = true
+					break
+				}
+			}
+			assert.True(t, hasWSL, "GetAll should always include WSL provider")
+		})
+	}
+}
+
+func TestGetByVMType_WSL_AlwaysWorks(t *testing.T) {
+	provider, err := GetByVMType(define.WSLVirt)
+	require.NoError(t, err)
+	assert.NotNil(t, provider)
+	assert.Equal(t, define.WSLVirt, provider.VMType())
+}
+
+func TestGetByVMType_UnsupportedProvider(t *testing.T) {
+	provider, err := GetByVMType(define.QemuVirt)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "unsupported virtualization provider")
+	assert.Nil(t, provider)
+}