test(e2e): verify ProxmoxMachine status addresses are populated

Add an e2e test that creates a workload cluster and verifies that every
ProxmoxMachine has populated Status.Addresses with at least one
MachineHostName and one MachineInternalIP entry.

This would have caught the state machine bug fixed in c5fbf14 where
reconcilePowerState set the wrong condition reason, causing
reconcileMachineAddresses to be skipped entirely and leaving
ProxmoxMachine.Status.Addresses empty.

The helper verifyProxmoxMachineAddresses is added to common.go so it
can be reused by other e2e specs.

ref: 710, 714

https://claude.ai/code/session_01PEJQFPT9TvRGqFYJ1t3U1R

Author: claude

test/e2e/capmox_test.go

@@ -137,6 +137,33 @@ var _ = Describe("Workload cluster creation", func() {
 		})
 	})
 
+	Context("[Generic] Creating a cluster and verifying ProxmoxMachine status addresses", func() {
+		It("Should have populated addresses on ProxmoxMachine status", func() {
+			By("Creating a cluster with 1 control-plane and 1 worker node")
+			clusterctl.ApplyClusterTemplateAndWait(ctx, clusterctl.ApplyClusterTemplateAndWaitInput{
+				ClusterProxy: bootstrapClusterProxy,
+				ConfigCluster: clusterctl.ConfigClusterInput{
+					LogFolder:                clusterctlLogFolder,
+					ClusterctlConfigPath:     clusterctlConfigPath,
+					KubeconfigPath:           bootstrapClusterProxy.GetKubeconfigPath(),
+					InfrastructureProvider:   clusterctl.DefaultInfrastructureProvider,
+					Flavor:                   clusterctl.DefaultFlavor,
+					Namespace:                namespace.Name,
+					ClusterName:              clusterName,
+					KubernetesVersion:        e2eConfig.MustGetVariable(KubernetesVersion),
+					ControlPlaneMachineCount: pointer.Int64Ptr(1),
+					WorkerMachineCount:       pointer.Int64Ptr(1),
+				},
+				WaitForClusterIntervals:      e2eConfig.GetIntervals(specName, "wait-cluster"),
+				WaitForControlPlaneIntervals: e2eConfig.GetIntervals(specName, "wait-control-plane"),
+				WaitForMachineDeployments:    e2eConfig.GetIntervals(specName, "wait-worker-nodes"),
+			}, result)
+
+			By("Verifying ProxmoxMachine status addresses are populated")
+			verifyProxmoxMachineAddresses(ctx, bootstrapClusterProxy, namespace.Name, clusterName)
+		})
+	})
+
 	Context("[Flatcar] Creating a highly available control-plane cluster with flatcar", func() {
 		It("Should create a HA cluster with flatcar", func() {
 			By("Creating a flatcar high available cluster")

test/e2e/common.go

@@ -25,11 +25,15 @@ import (
 	"path/filepath"
 
 	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2"
 	"sigs.k8s.io/cluster-api/test/framework"
 	"sigs.k8s.io/cluster-api/util"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	infrav1 "github.com/ionos-cloud/cluster-api-provider-proxmox/api/v1alpha2"
 )
 
 func Byf(format string, a ...interface{}) {
@@ -122,3 +126,42 @@ func dumpSpecResourcesAndCleanup(ctx context.Context, input cleanupInput) {
 		input.AdditionalCleanup()
 	}
 }
+
+// verifyProxmoxMachineAddresses lists all ProxmoxMachine objects for a given cluster
+// and verifies that each machine has populated Status.Addresses with at least one
+// MachineHostName and one MachineInternalIP entry.
+// This catches state machine bugs where reconcileMachineAddresses is skipped.
+func verifyProxmoxMachineAddresses(ctx context.Context, clusterProxy framework.ClusterProxy, namespace, clusterName string) {
+	Byf("Listing ProxmoxMachine objects for cluster %q in namespace %q", clusterName, namespace)
+	machineList := &infrav1.ProxmoxMachineList{}
+	Expect(clusterProxy.GetClient().List(ctx, machineList,
+		client.InNamespace(namespace),
+		client.MatchingLabels{clusterv1.ClusterNameLabel: clusterName},
+	)).To(Succeed(), "Failed to list ProxmoxMachines")
+
+	Expect(machineList.Items).ToNot(BeEmpty(), "Expected at least one ProxmoxMachine for cluster %q", clusterName)
+
+	for i := range machineList.Items {
+		machine := &machineList.Items[i]
+		Byf("Verifying addresses for ProxmoxMachine %q", machine.Name)
+
+		Expect(machine.Status.Addresses).ToNot(BeEmpty(),
+			"ProxmoxMachine %q has no addresses in Status.Addresses", machine.Name)
+
+		hasHostName := false
+		hasInternalIP := false
+		for _, addr := range machine.Status.Addresses {
+			switch addr.Type {
+			case clusterv1.MachineHostName:
+				hasHostName = true
+			case clusterv1.MachineInternalIP:
+				hasInternalIP = true
+			}
+		}
+
+		Expect(hasHostName).To(BeTrue(),
+			"ProxmoxMachine %q has no MachineHostName address", machine.Name)
+		Expect(hasInternalIP).To(BeTrue(),
+			"ProxmoxMachine %q has no MachineInternalIP address", machine.Name)
+	}
+}