From 5944adcfd57a7dab21f265436ee9806b5b67cd95 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Tue, 21 Jan 2025 14:39:41 -0500
Subject: [PATCH 01/18] fix: ensure we set ports addresses while waiting for
 pod IPs

---
 pkg/gameservers/controller.go      | 16 +++++++++++-----
 pkg/gameservers/controller_test.go |  7 +++++--
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 67cd9f28f4..d9fe1ab144 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -888,11 +888,6 @@ func (c *Controller) syncGameServerStartingState(ctx context.Context, gs *agones
 		return gs, workerqueue.NewTraceError(errors.Errorf("node not yet populated for Pod %s", pod.ObjectMeta.Name))
 	}
 
-	// Ensure the pod IPs are populated
-	if len(pod.Status.PodIPs) == 0 {
-		return gs, workerqueue.NewTraceError(errors.Errorf("pod IPs not yet populated for Pod %s", pod.ObjectMeta.Name))
-	}
-
 	node, err := c.nodeLister.Get(pod.Spec.NodeName)
 	if err != nil {
 		return gs, errors.Wrapf(err, "error retrieving node %s for Pod %s", pod.Spec.NodeName, pod.ObjectMeta.Name)
@@ -903,6 +898,17 @@ func (c *Controller) syncGameServerStartingState(ctx context.Context, gs *agones
 		return gs, err
 	}
 
+	// Ensure the pod IPs are populated
+	if len(pod.Status.PodIPs) == 0 {
+		// Update ports and address even if there is no pod IPs populated yet
+		gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
+		if err != nil {
+			return gs, errors.Wrapf(err, "error updating GameServer %s address and port", gs.Name)
+		}
+	
+		return gs, workerqueue.NewTraceError(errors.Errorf("pod IPs not yet populated for Pod %s", pod.ObjectMeta.Name))
+	}
+
 	gsCopy.Status.State = agonesv1.GameServerStateScheduled
 	gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
 	if err != nil {
diff --git a/pkg/gameservers/controller_test.go b/pkg/gameservers/controller_test.go
index 79f8ccd054..343ac23fa2 100644
--- a/pkg/gameservers/controller_test.go
+++ b/pkg/gameservers/controller_test.go
@@ -1205,8 +1205,11 @@ func TestControllerSyncGameServerStartingState(t *testing.T) {
 		m.AgonesClient.AddReactor("update", "gameservers", func(action k8stesting.Action) (bool, runtime.Object, error) {
 			ua := action.(k8stesting.UpdateAction)
 			gs := ua.GetObject().(*agonesv1.GameServer)
-			assert.Equal(t, agonesv1.GameServerStateScheduled, gs.Status.State)
-			return true, gs, errors.New("update-err")
+			assert.Equal(t, agonesv1.GameServerStateStarting, gs.Status.State)
+			assert.NotEmpty(t, gs.Status.Ports)
+			assert.NotEmpty(t, gs.Status.Address)
+			assert.NotEmpty(t, gs.Status.Addresses)
+			return true, gs, nil
 		})
 		ctx, cancel := agtesting.StartInformers(m, c.gameServerSynced, c.podSynced, c.nodeSynced)
 		defer cancel()

From fc9b8d2fd45ed5480a9c9e34a5a7f78a66d43b68 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Tue, 21 Jan 2025 15:00:04 -0500
Subject: [PATCH 02/18] fix: update unit tests

---
 pkg/gameservers/controller_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pkg/gameservers/controller_test.go b/pkg/gameservers/controller_test.go
index 343ac23fa2..7fffd2d0e3 100644
--- a/pkg/gameservers/controller_test.go
+++ b/pkg/gameservers/controller_test.go
@@ -1195,6 +1195,7 @@ func TestControllerSyncGameServerStartingState(t *testing.T) {
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		require.NoError(t, err)
 		pod.Spec.NodeName = nodeFixtureName
+		pod.Status.PodIPs = nil
 
 		m.KubeClient.AddReactor("list", "nodes", func(_ k8stesting.Action) (bool, runtime.Object, error) {
 			return true, &corev1.NodeList{Items: []corev1.Node{node}}, nil

From 70cd30fa09458fdaaed87656a95253f2188b59e1 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Wed, 22 Jan 2025 12:01:53 -0500
Subject: [PATCH 03/18] fix: ensure podIPs are also set on ready if called
 before controller

---
 pkg/gameservers/controller.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index d9fe1ab144..2d3791db77 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -945,8 +945,14 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 	// if the address hasn't been populated, and the Ready request comes
 	// before the controller has had a chance to do it, then
 	// do it here instead
+	var hasPodIPAddress bool
+	for i, addr := range gs.Status.Addresses {
+		if addr.Type == agonesv1.NodePodIP {
+			hasPodIPAddress = true
+		}
+	}
 	addressPopulated := false
-	if gs.Status.NodeName == "" {
+	if gs.Status.NodeName == "" || !addressPopulated {
 		addressPopulated = true
 		if pod.Spec.NodeName == "" {
 			return gs, workerqueue.NewTraceError(errors.Errorf("node not yet populated for Pod %s", pod.ObjectMeta.Name))

From 3e1a602cda327911584510b3af2384a5890b05fa Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Wed, 22 Jan 2025 12:26:15 -0500
Subject: [PATCH 04/18] fix: ensure podIPs are also set on ready if called
 before controller

---
 pkg/gameservers/controller.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 2d3791db77..7ddfffa8d3 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -905,7 +905,6 @@ func (c *Controller) syncGameServerStartingState(ctx context.Context, gs *agones
 		if err != nil {
 			return gs, errors.Wrapf(err, "error updating GameServer %s address and port", gs.Name)
 		}
-	
 		return gs, workerqueue.NewTraceError(errors.Errorf("pod IPs not yet populated for Pod %s", pod.ObjectMeta.Name))
 	}
 
@@ -946,13 +945,13 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 	// before the controller has had a chance to do it, then
 	// do it here instead
 	var hasPodIPAddress bool
-	for i, addr := range gs.Status.Addresses {
+	for _, addr := range gs.Status.Addresses {
 		if addr.Type == agonesv1.NodePodIP {
 			hasPodIPAddress = true
 		}
 	}
 	addressPopulated := false
-	if gs.Status.NodeName == "" || !addressPopulated {
+	if gs.Status.NodeName == "" || !hasPodIPAddress {
 		addressPopulated = true
 		if pod.Spec.NodeName == "" {
 			return gs, workerqueue.NewTraceError(errors.Errorf("node not yet populated for Pod %s", pod.ObjectMeta.Name))

From 329bf8129655708d14d72515de7850d0b3f22fe5 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Wed, 22 Jan 2025 13:09:35 -0500
Subject: [PATCH 05/18] fix: ensure we set the new PodIPs if they are present

---
 pkg/gameservers/controller.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 7ddfffa8d3..15cd0953b0 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -951,7 +951,7 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 		}
 	}
 	addressPopulated := false
-	if gs.Status.NodeName == "" || !hasPodIPAddress {
+	if gs.Status.NodeName == "" || (!hasPodIPAddress && len(pod.Status.PodIPs) > 0) {
 		addressPopulated = true
 		if pod.Spec.NodeName == "" {
 			return gs, workerqueue.NewTraceError(errors.Errorf("node not yet populated for Pod %s", pod.ObjectMeta.Name))

From 359abf61537a9327e6fcfc4f8e01a4e24b4d4b1e Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Wed, 12 Mar 2025 14:06:45 -0400
Subject: [PATCH 06/18] feat: update comment

---
 pkg/gameservers/controller.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 15cd0953b0..94b868a7a4 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -898,9 +898,9 @@ func (c *Controller) syncGameServerStartingState(ctx context.Context, gs *agones
 		return gs, err
 	}
 
-	// Ensure the pod IPs are populated
+	// Update ports and address even if there is no pod IPs populated yet
+	// Keep the state as GameServerStateStarting until pod IPs populated
 	if len(pod.Status.PodIPs) == 0 {
-		// Update ports and address even if there is no pod IPs populated yet
 		gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
 		if err != nil {
 			return gs, errors.Wrapf(err, "error updating GameServer %s address and port", gs.Name)

From 2eeb51eccd3e4dfb93c59e2f52984bbab09c9ed0 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Tue, 1 Apr 2025 19:07:47 -0400
Subject: [PATCH 07/18] feat: WIP update following feedback

---
 pkg/gameservers/controller.go  | 22 +++++++++++++++++-----
 pkg/gameservers/gameservers.go | 22 +++++++++++++++-------
 2 files changed, 32 insertions(+), 12 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 94b868a7a4..3a5a7e2f03 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -562,9 +562,8 @@ func (c *Controller) syncGameServerCreatingState(ctx context.Context, gs *agones
 	loggerForGameServer(gs, c.baseLogger).Debug("Syncing Create State")
 
 	// Maybe something went wrong, and the pod was created, but the state was never moved to Starting, so let's check
-	_, err := c.gameServerPod(gs)
+	pod, err := c.gameServerPod(gs)
 	if k8serrors.IsNotFound(err) {
-
 		for i := range gs.Spec.Ports {
 			if gs.Spec.Ports[i].PortPolicy == agonesv1.Static && gs.Spec.Ports[i].Protocol == agonesv1.ProtocolTCPUDP {
 				name := gs.Spec.Ports[i].Name
@@ -593,6 +592,10 @@ func (c *Controller) syncGameServerCreatingState(ctx context.Context, gs *agones
 	}
 
 	gsCopy := gs.DeepCopy()
+
+	// Apply the pod IP if available
+	gsCopy, _ = applyAddressPodIP(gsCopy, pod)
+
 	gsCopy.Status.State = agonesv1.GameServerStateStarting
 	gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
 	if err != nil {
@@ -898,9 +901,10 @@ func (c *Controller) syncGameServerStartingState(ctx context.Context, gs *agones
 		return gs, err
 	}
 
+	gsCopy, podIPPopulated := applyAddressPodIP(gsCopy, pod)
 	// Update ports and address even if there is no pod IPs populated yet
-	// Keep the state as GameServerStateStarting until pod IPs populated
-	if len(pod.Status.PodIPs) == 0 {
+	// Don't update state to GameServerStateScheduled until pod IPs populated
+	if !podIPPopulated {
 		gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
 		if err != nil {
 			return gs, errors.Wrapf(err, "error updating GameServer %s address and port", gs.Name)
@@ -950,9 +954,11 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 			hasPodIPAddress = true
 		}
 	}
+
 	addressPopulated := false
-	if gs.Status.NodeName == "" || (!hasPodIPAddress && len(pod.Status.PodIPs) > 0) {
+	if gs.Status.NodeName == "" || !hasPodIPAddress {
 		addressPopulated = true
+
 		if pod.Spec.NodeName == "" {
 			return gs, workerqueue.NewTraceError(errors.Errorf("node not yet populated for Pod %s", pod.ObjectMeta.Name))
 		}
@@ -964,6 +970,12 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 		if err != nil {
 			return gs, err
 		}
+
+		var podIPPopulated bool
+		gsCopy, podIPPopulated = applyAddressPodIP(gsCopy, pod)
+		if !podIPPopulated {
+			addressPopulated = false
+		}
 	}
 
 	// track the ready gameserver container, so we can determine that after this point, we should move to Unhealthy
diff --git a/pkg/gameservers/gameservers.go b/pkg/gameservers/gameservers.go
index d56c7e0096..f2b72e6953 100644
--- a/pkg/gameservers/gameservers.go
+++ b/pkg/gameservers/gameservers.go
@@ -93,13 +93,6 @@ func applyGameServerAddressAndPort(gs *agonesv1.GameServer, node *corev1.Node, p
 	gs.Status.Addresses = addrs
 	gs.Status.NodeName = pod.Spec.NodeName
 
-	for _, ip := range pod.Status.PodIPs {
-		gs.Status.Addresses = append(gs.Status.Addresses, corev1.NodeAddress{
-			Type:    agonesv1.NodePodIP,
-			Address: ip.IP,
-		})
-	}
-
 	if err := syncPodPortsToGameServer(gs, pod); err != nil {
 		return gs, errors.Wrapf(err, "cloud product error syncing ports on GameServer %s", gs.ObjectMeta.Name)
 	}
@@ -114,6 +107,21 @@ func applyGameServerAddressAndPort(gs *agonesv1.GameServer, node *corev1.Node, p
 	return gs, nil
 }
 
+func applyAddressPodIP(gs *agonesv1.GameServer, pod *corev1.Pod) (*agonesv1.GameServer, bool) {
+	if pod == nil || len(pod.Status.PodIPs) < 1 {
+		return gs, false
+	}
+
+	for _, ip := range pod.Status.PodIPs {
+		gs.Status.Addresses = append(gs.Status.Addresses, corev1.NodeAddress{
+			Type:    agonesv1.NodePodIP,
+			Address: ip.IP,
+		})
+	}
+
+	return gs, true
+}
+
 // isBeforePodCreated checks to see if the GameServer is in a state in which the pod could not have been
 // created yet. This includes "Starting" in which a pod MAY exist, but may not yet be available, depending on when the
 // informer cache updates

From 095cd3c8fa259370b8e7c29fd33930013498a867 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Wed, 9 Apr 2025 18:50:22 -0400
Subject: [PATCH 08/18] feat: revert the applyGameServerAddressAndPort

---
 pkg/gameservers/controller.go       | 23 +++++++++--------------
 pkg/gameservers/controller_test.go  | 19 +++++++++++++++++++
 pkg/gameservers/gameservers.go      | 25 +++++++++++++++----------
 pkg/gameservers/gameservers_test.go |  1 +
 4 files changed, 44 insertions(+), 24 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 3a5a7e2f03..57c31064e5 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -591,10 +591,15 @@ func (c *Controller) syncGameServerCreatingState(ctx context.Context, gs *agones
 		return nil, errors.WithStack(err)
 	}
 
+	node, err := c.nodeLister.Get(pod.Spec.NodeName)
+	if err != nil {
+		return gs, errors.Wrapf(err, "error retrieving node %s for Pod %s", pod.Spec.NodeName, pod.ObjectMeta.Name)
+	}
+
 	gsCopy := gs.DeepCopy()
 
 	// Apply the pod IP if available
-	gsCopy, _ = applyAddressPodIP(gsCopy, pod)
+	gsCopy, _ = applyGameServerAddressAndPort(gsCopy, node, pod, c.controllerHooks.SyncPodPortsToGameServer)
 
 	gsCopy.Status.State = agonesv1.GameServerStateStarting
 	gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
@@ -901,10 +906,9 @@ func (c *Controller) syncGameServerStartingState(ctx context.Context, gs *agones
 		return gs, err
 	}
 
-	gsCopy, podIPPopulated := applyAddressPodIP(gsCopy, pod)
 	// Update ports and address even if there is no pod IPs populated yet
 	// Don't update state to GameServerStateScheduled until pod IPs populated
-	if !podIPPopulated {
+	if !hasPodIPAddress(gsCopy) {
 		gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
 		if err != nil {
 			return gs, errors.Wrapf(err, "error updating GameServer %s address and port", gs.Name)
@@ -948,15 +952,8 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 	// if the address hasn't been populated, and the Ready request comes
 	// before the controller has had a chance to do it, then
 	// do it here instead
-	var hasPodIPAddress bool
-	for _, addr := range gs.Status.Addresses {
-		if addr.Type == agonesv1.NodePodIP {
-			hasPodIPAddress = true
-		}
-	}
-
 	addressPopulated := false
-	if gs.Status.NodeName == "" || !hasPodIPAddress {
+	if gs.Status.NodeName == "" || !hasPodIPAddress(gs) {
 		addressPopulated = true
 
 		if pod.Spec.NodeName == "" {
@@ -971,9 +968,7 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 			return gs, err
 		}
 
-		var podIPPopulated bool
-		gsCopy, podIPPopulated = applyAddressPodIP(gsCopy, pod)
-		if !podIPPopulated {
+		if !hasPodIPAddress(gsCopy) {
 			addressPopulated = false
 		}
 	}
diff --git a/pkg/gameservers/controller_test.go b/pkg/gameservers/controller_test.go
index 7fffd2d0e3..686147e7a5 100644
--- a/pkg/gameservers/controller_test.go
+++ b/pkg/gameservers/controller_test.go
@@ -1435,6 +1435,9 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
+		gsFixture.Status.Addresses = []corev1.NodeAddress{
+			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		require.NoError(t, err)
 		pod.Status.ContainerStatuses = []corev1.ContainerStatus{
@@ -1485,6 +1488,9 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
+		gsFixture.Status.Addresses = []corev1.NodeAddress{
+			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		require.NoError(t, err)
 		pod.Status.ContainerStatuses = []corev1.ContainerStatus{
@@ -1529,6 +1535,9 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
+		gsFixture.Status.Addresses = []corev1.NodeAddress{
+			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		require.NoError(t, err)
 		pod.Status.ContainerStatuses = []corev1.ContainerStatus{
@@ -1572,6 +1581,9 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
+		gsFixture.Status.Addresses = []corev1.NodeAddress{
+			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		require.NoError(t, err)
 		pod.ObjectMeta.Annotations = map[string]string{agonesv1.GameServerReadyContainerIDAnnotation: containerID}
@@ -1619,6 +1631,9 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 		gsFixture := &agonesv1.GameServer{ObjectMeta: metav1.ObjectMeta{Name: "test", Namespace: "default"},
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
+		gsFixture.Status.Addresses = []corev1.NodeAddress{
+			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		assert.Nil(t, err)
 		pod.Spec.NodeName = nodeFixtureName
@@ -1682,6 +1697,9 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
+		gsFixture.Status.Addresses = []corev1.NodeAddress{
+			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		}
 		gsFixture.Annotations[agonesv1.GameServerReadyContainerIDAnnotation] = "4321"
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		pod.Status.ContainerStatuses = []corev1.ContainerStatus{
@@ -1778,6 +1796,7 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 		gsFixture.Status.NodeName = nodeName
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		assert.Nil(t, err)
+		pod.Spec.NodeName = nodeName
 		gsUpdated := false
 		podUpdated := false
 
diff --git a/pkg/gameservers/gameservers.go b/pkg/gameservers/gameservers.go
index f2b72e6953..a42dd0d8d1 100644
--- a/pkg/gameservers/gameservers.go
+++ b/pkg/gameservers/gameservers.go
@@ -93,6 +93,13 @@ func applyGameServerAddressAndPort(gs *agonesv1.GameServer, node *corev1.Node, p
 	gs.Status.Addresses = addrs
 	gs.Status.NodeName = pod.Spec.NodeName
 
+	for _, ip := range pod.Status.PodIPs {
+		gs.Status.Addresses = append(gs.Status.Addresses, corev1.NodeAddress{
+			Type:    agonesv1.NodePodIP,
+			Address: ip.IP,
+		})
+	}
+
 	if err := syncPodPortsToGameServer(gs, pod); err != nil {
 		return gs, errors.Wrapf(err, "cloud product error syncing ports on GameServer %s", gs.ObjectMeta.Name)
 	}
@@ -107,19 +114,17 @@ func applyGameServerAddressAndPort(gs *agonesv1.GameServer, node *corev1.Node, p
 	return gs, nil
 }
 
-func applyAddressPodIP(gs *agonesv1.GameServer, pod *corev1.Pod) (*agonesv1.GameServer, bool) {
-	if pod == nil || len(pod.Status.PodIPs) < 1 {
-		return gs, false
+func hasPodIPAddress(gs *agonesv1.GameServer) bool {
+	if gs == nil {
+		return false
 	}
 
-	for _, ip := range pod.Status.PodIPs {
-		gs.Status.Addresses = append(gs.Status.Addresses, corev1.NodeAddress{
-			Type:    agonesv1.NodePodIP,
-			Address: ip.IP,
-		})
+	for _, addr := range gs.Status.Addresses {
+		if addr.Type == agonesv1.NodePodIP {
+			return true
+		}
 	}
-
-	return gs, true
+	return false
 }
 
 // isBeforePodCreated checks to see if the GameServer is in a state in which the pod could not have been
diff --git a/pkg/gameservers/gameservers_test.go b/pkg/gameservers/gameservers_test.go
index 8dd2ce1bb0..59e6242a5c 100644
--- a/pkg/gameservers/gameservers_test.go
+++ b/pkg/gameservers/gameservers_test.go
@@ -150,6 +150,7 @@ func TestApplyGameServerAddressAndPort(t *testing.T) {
 					{IP: ipFixture},
 				}
 			},
+
 			podSyncer: noopSyncer,
 			wantPort:  9999,
 		},

From 3c4dc9a2f7baaa3b61d0c2c930dd5fbb465aa183 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Thu, 17 Apr 2025 15:03:38 -0400
Subject: [PATCH 09/18] feat: ensure pod exists to apply addressandport

---
 pkg/gameservers/controller.go | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 57c31064e5..b777af2418 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -591,15 +591,17 @@ func (c *Controller) syncGameServerCreatingState(ctx context.Context, gs *agones
 		return nil, errors.WithStack(err)
 	}
 
-	node, err := c.nodeLister.Get(pod.Spec.NodeName)
-	if err != nil {
-		return gs, errors.Wrapf(err, "error retrieving node %s for Pod %s", pod.Spec.NodeName, pod.ObjectMeta.Name)
-	}
-
 	gsCopy := gs.DeepCopy()
 
-	// Apply the pod IP if available
-	gsCopy, _ = applyGameServerAddressAndPort(gsCopy, node, pod, c.controllerHooks.SyncPodPortsToGameServer)
+	if pod != nil {
+		node, err := c.nodeLister.Get(pod.Spec.NodeName)
+		if err != nil {
+			return gs, errors.Wrapf(err, "error retrieving node %s for Pod %s", pod.Spec.NodeName, pod.ObjectMeta.Name)
+		}
+
+		// Apply the pod IP if available
+		gsCopy, _ = applyGameServerAddressAndPort(gsCopy, node, pod, c.controllerHooks.SyncPodPortsToGameServer)
+	}
 
 	gsCopy.Status.State = agonesv1.GameServerStateStarting
 	gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})

From 9312bcdaa34fdb8772ed8f9651197d7f57ea822e Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Wed, 23 Apr 2025 12:32:06 -0400
Subject: [PATCH 10/18] feat: ensure to not stop the process if node not yet
 set

---
 pkg/gameservers/controller.go      | 8 +++-----
 pkg/gameservers/controller_test.go | 3 +++
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index b777af2418..10d5883203 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -595,12 +595,10 @@ func (c *Controller) syncGameServerCreatingState(ctx context.Context, gs *agones
 
 	if pod != nil {
 		node, err := c.nodeLister.Get(pod.Spec.NodeName)
-		if err != nil {
-			return gs, errors.Wrapf(err, "error retrieving node %s for Pod %s", pod.Spec.NodeName, pod.ObjectMeta.Name)
+		if err == nil {
+			// Apply the pod IP if available
+			gsCopy, _ = applyGameServerAddressAndPort(gsCopy, node, pod, c.controllerHooks.SyncPodPortsToGameServer)
 		}
-
-		// Apply the pod IP if available
-		gsCopy, _ = applyGameServerAddressAndPort(gsCopy, node, pod, c.controllerHooks.SyncPodPortsToGameServer)
 	}
 
 	gsCopy.Status.State = agonesv1.GameServerStateStarting
diff --git a/pkg/gameservers/controller_test.go b/pkg/gameservers/controller_test.go
index 686147e7a5..2ff2580383 100644
--- a/pkg/gameservers/controller_test.go
+++ b/pkg/gameservers/controller_test.go
@@ -1794,6 +1794,9 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
+		gsFixture.Status.Addresses = []corev1.NodeAddress{
+			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		assert.Nil(t, err)
 		pod.Spec.NodeName = nodeName

From 0023936c6b0c239e00dfed2f1e416d6894955458 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Wed, 23 Apr 2025 13:00:58 -0400
Subject: [PATCH 11/18] feat: fix unit tests

---
 pkg/gameservers/controller_test.go | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/pkg/gameservers/controller_test.go b/pkg/gameservers/controller_test.go
index 2ff2580383..c93afe1dc5 100644
--- a/pkg/gameservers/controller_test.go
+++ b/pkg/gameservers/controller_test.go
@@ -1631,9 +1631,6 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 		gsFixture := &agonesv1.GameServer{ObjectMeta: metav1.ObjectMeta{Name: "test", Namespace: "default"},
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
-		gsFixture.Status.Addresses = []corev1.NodeAddress{
-			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
-		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		assert.Nil(t, err)
 		pod.Spec.NodeName = nodeFixtureName
@@ -1644,6 +1641,7 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 				ContainerID: containerID,
 			},
 		}
+		pod.Status.PodIPs = []corev1.PodIP{{IP: ipv6Fixture}}
 		gsUpdated := false
 		podUpdated := false
 
@@ -1684,7 +1682,10 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 
 		assert.Equal(t, gs.Status.NodeName, nodeFixture.ObjectMeta.Name)
 		assert.Equal(t, gs.Status.Address, ipFixture)
-		assert.Equal(t, []corev1.NodeAddress{{Address: ipFixture, Type: "ExternalIP"}}, gs.Status.Addresses)
+		assert.Equal(t, []corev1.NodeAddress{
+			{Address: ipFixture, Type: "ExternalIP"},
+			{Address: ipv6Fixture, Type: "PodIP"},
+		}, gs.Status.Addresses)
 
 		agtesting.AssertEventContains(t, m.FakeRecorder.Events, "Address and port populated")
 		agtesting.AssertEventContains(t, m.FakeRecorder.Events, "SDK.Ready() complete")
@@ -1760,6 +1761,9 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
+		gsFixture.Status.Addresses = []corev1.NodeAddress{
+			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		pod.Status.ContainerStatuses = []corev1.ContainerStatus{{Name: gsFixture.Spec.Container}}
 		assert.Nil(t, err)

From d83d0e2771be635582e8bdc695959bdf97286764 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Wed, 23 Apr 2025 15:30:59 -0400
Subject: [PATCH 12/18] feat: trigger pipeline


From 8971843aa659b90ad043e6c7d3fb3ce29e55e4a8 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Fri, 2 May 2025 09:31:42 -0400
Subject: [PATCH 13/18] feat: add comment

---
 pkg/gameservers/gameservers.go      | 1 +
 pkg/gameservers/gameservers_test.go | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/gameservers/gameservers.go b/pkg/gameservers/gameservers.go
index a42dd0d8d1..1e796fc505 100644
--- a/pkg/gameservers/gameservers.go
+++ b/pkg/gameservers/gameservers.go
@@ -114,6 +114,7 @@ func applyGameServerAddressAndPort(gs *agonesv1.GameServer, node *corev1.Node, p
 	return gs, nil
 }
 
+// hasPodIPAddress checks to see if the GameServer has a Pod IP address already set
 func hasPodIPAddress(gs *agonesv1.GameServer) bool {
 	if gs == nil {
 		return false
diff --git a/pkg/gameservers/gameservers_test.go b/pkg/gameservers/gameservers_test.go
index 59e6242a5c..8dd2ce1bb0 100644
--- a/pkg/gameservers/gameservers_test.go
+++ b/pkg/gameservers/gameservers_test.go
@@ -150,7 +150,6 @@ func TestApplyGameServerAddressAndPort(t *testing.T) {
 					{IP: ipFixture},
 				}
 			},
-
 			podSyncer: noopSyncer,
 			wantPort:  9999,
 		},

From 20b89a4990d66bed676530426d4b8e51d7e3f1fb Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Sat, 10 May 2025 18:54:51 -0400
Subject: [PATCH 14/18] feat: ensure pod ips are set on each gsSync func where
 pods are available

---
 pkg/gameservers/controller.go  | 38 +++++++++++++++-------------------
 pkg/gameservers/gameservers.go | 33 ++++++++++++++++++-----------
 2 files changed, 38 insertions(+), 33 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 802cc385b8..71765706e5 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -593,13 +593,7 @@ func (c *Controller) syncGameServerCreatingState(ctx context.Context, gs *agones
 
 	gsCopy := gs.DeepCopy()
 
-	if pod != nil {
-		node, err := c.nodeLister.Get(pod.Spec.NodeName)
-		if err == nil {
-			// Apply the pod IP if available
-			gsCopy, _ = applyGameServerAddressAndPort(gsCopy, node, pod, c.controllerHooks.SyncPodPortsToGameServer)
-		}
-	}
+	gsCopy, _ = applyGameServerPodIP(gsCopy, pod)
 
 	gsCopy.Status.State = agonesv1.GameServerStateStarting
 	gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
@@ -906,15 +900,7 @@ func (c *Controller) syncGameServerStartingState(ctx context.Context, gs *agones
 		return gs, err
 	}
 
-	// Update ports and address even if there is no pod IPs populated yet
-	// Don't update state to GameServerStateScheduled until pod IPs populated
-	if !hasPodIPAddress(gsCopy) {
-		gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
-		if err != nil {
-			return gs, errors.Wrapf(err, "error updating GameServer %s address and port", gs.Name)
-		}
-		return gs, workerqueue.NewTraceError(errors.Errorf("pod IPs not yet populated for Pod %s", pod.ObjectMeta.Name))
-	}
+	gsCopy, _ = applyGameServerPodIP(gsCopy, pod)
 
 	gsCopy.Status.State = agonesv1.GameServerStateScheduled
 	gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
@@ -949,32 +935,42 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 		return nil, err
 	}
 
+	gsCopy, podIPUpdated := applyGameServerPodIP(gsCopy, pod)
+	updateGSPodIP := func(gs *agonesv1.GameServer, forceUpdate bool) error {
+		if !forceUpdate {
+			return nil
+		}
+
+		_, err := c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gs, metav1.UpdateOptions{})
+		return err
+	}
+
 	// if the address hasn't been populated, and the Ready request comes
 	// before the controller has had a chance to do it, then
 	// do it here instead
 	addressPopulated := false
-	if gs.Status.NodeName == "" || !hasPodIPAddress(gs) {
+	if gsCopy.Status.NodeName == "" {
 		addressPopulated = true
 
 		if pod.Spec.NodeName == "" {
+			_ = updateGSPodIP(gsCopy, podIPUpdated)
 			return gs, workerqueue.NewTraceError(errors.Errorf("node not yet populated for Pod %s", pod.ObjectMeta.Name))
 		}
 		node, err := c.nodeLister.Get(pod.Spec.NodeName)
 		if err != nil {
+			_ = updateGSPodIP(gsCopy, podIPUpdated)
 			return gs, errors.Wrapf(err, "error retrieving node %s for Pod %s", pod.Spec.NodeName, pod.ObjectMeta.Name)
 		}
 		gsCopy, err = applyGameServerAddressAndPort(gsCopy, node, pod, c.controllerHooks.SyncPodPortsToGameServer)
 		if err != nil {
+			_ = updateGSPodIP(gsCopy, podIPUpdated)
 			return gs, err
 		}
-
-		if !hasPodIPAddress(gsCopy) {
-			addressPopulated = false
-		}
 	}
 
 	gsCopy, err = c.applyGameServerReadyContainerIDAnnotation(ctx, gsCopy, pod)
 	if err != nil {
+		_ = updateGSPodIP(gsCopy, podIPUpdated)
 		return gs, err
 	}
 
diff --git a/pkg/gameservers/gameservers.go b/pkg/gameservers/gameservers.go
index 1e796fc505..39dd7d312a 100644
--- a/pkg/gameservers/gameservers.go
+++ b/pkg/gameservers/gameservers.go
@@ -93,12 +93,7 @@ func applyGameServerAddressAndPort(gs *agonesv1.GameServer, node *corev1.Node, p
 	gs.Status.Addresses = addrs
 	gs.Status.NodeName = pod.Spec.NodeName
 
-	for _, ip := range pod.Status.PodIPs {
-		gs.Status.Addresses = append(gs.Status.Addresses, corev1.NodeAddress{
-			Type:    agonesv1.NodePodIP,
-			Address: ip.IP,
-		})
-	}
+	gs, _ = applyGameServerPodIP(gs, pod)
 
 	if err := syncPodPortsToGameServer(gs, pod); err != nil {
 		return gs, errors.Wrapf(err, "cloud product error syncing ports on GameServer %s", gs.ObjectMeta.Name)
@@ -114,18 +109,32 @@ func applyGameServerAddressAndPort(gs *agonesv1.GameServer, node *corev1.Node, p
 	return gs, nil
 }
 
-// hasPodIPAddress checks to see if the GameServer has a Pod IP address already set
-func hasPodIPAddress(gs *agonesv1.GameServer) bool {
-	if gs == nil {
-		return false
+// applyGameServerPodIP checks the pod IPs and adds them to the GameServer status if they are not already there.
+func applyGameServerPodIP(gs *agonesv1.GameServer, pod *corev1.Pod) (*agonesv1.GameServer, bool) {
+	var updated bool
+
+	if pod == nil {
+		return gs, false
 	}
 
+	gsPodIPs := make(map[string]interface{})
 	for _, addr := range gs.Status.Addresses {
 		if addr.Type == agonesv1.NodePodIP {
-			return true
+			gsPodIPs[addr.Address] = nil
 		}
 	}
-	return false
+
+	for _, ip := range pod.Status.PodIPs {
+		if _, ok := gsPodIPs[ip.IP]; !ok {
+			gs.Status.Addresses = append(gs.Status.Addresses, corev1.NodeAddress{
+				Type:    agonesv1.NodePodIP,
+				Address: ip.IP,
+			})
+			updated = true
+		}
+	}
+
+	return gs, updated
 }
 
 // isBeforePodCreated checks to see if the GameServer is in a state in which the pod could not have been

From ae72407257b4cbaca740590deac8dfd9254dd5b5 Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Tue, 13 May 2025 15:13:49 -0400
Subject: [PATCH 15/18] feat: use defer to update gs if needed

---
 pkg/gameservers/controller.go | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/pkg/gameservers/controller.go b/pkg/gameservers/controller.go
index 71765706e5..79618d40fd 100644
--- a/pkg/gameservers/controller.go
+++ b/pkg/gameservers/controller.go
@@ -935,14 +935,19 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 		return nil, err
 	}
 
-	gsCopy, podIPUpdated := applyGameServerPodIP(gsCopy, pod)
-	updateGSPodIP := func(gs *agonesv1.GameServer, forceUpdate bool) error {
-		if !forceUpdate {
-			return nil
-		}
+	var gsUpdated bool
 
-		_, err := c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gs, metav1.UpdateOptions{})
-		return err
+	gsCopy, podIPUpdated := applyGameServerPodIP(gsCopy, pod)
+	if podIPUpdated {
+		// defer the update of the GameServer until the end of this function
+		// in case there is no gs state update and the podIP is available and populated
+		defer func(gs *agonesv1.GameServer, alreadyUpdated *bool) {
+			// Only update if the GameServer is not already updated
+			if alreadyUpdated == nil || *alreadyUpdated {
+				return
+			}
+			_, _ = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gs, metav1.UpdateOptions{})
+		}(gsCopy, &gsUpdated)
 	}
 
 	// if the address hasn't been populated, and the Ready request comes
@@ -953,27 +958,26 @@ func (c *Controller) syncGameServerRequestReadyState(ctx context.Context, gs *ag
 		addressPopulated = true
 
 		if pod.Spec.NodeName == "" {
-			_ = updateGSPodIP(gsCopy, podIPUpdated)
 			return gs, workerqueue.NewTraceError(errors.Errorf("node not yet populated for Pod %s", pod.ObjectMeta.Name))
 		}
 		node, err := c.nodeLister.Get(pod.Spec.NodeName)
 		if err != nil {
-			_ = updateGSPodIP(gsCopy, podIPUpdated)
 			return gs, errors.Wrapf(err, "error retrieving node %s for Pod %s", pod.Spec.NodeName, pod.ObjectMeta.Name)
 		}
 		gsCopy, err = applyGameServerAddressAndPort(gsCopy, node, pod, c.controllerHooks.SyncPodPortsToGameServer)
 		if err != nil {
-			_ = updateGSPodIP(gsCopy, podIPUpdated)
 			return gs, err
 		}
 	}
 
 	gsCopy, err = c.applyGameServerReadyContainerIDAnnotation(ctx, gsCopy, pod)
 	if err != nil {
-		_ = updateGSPodIP(gsCopy, podIPUpdated)
 		return gs, err
 	}
 
+	// if the address is already populated, then we don't need to re-update for podIPs
+	gsUpdated = true
+
 	gsCopy.Status.State = agonesv1.GameServerStateReady
 	gs, err = c.gameServerGetter.GameServers(gs.ObjectMeta.Namespace).Update(ctx, gsCopy, metav1.UpdateOptions{})
 	if err != nil {

From 9730c944a10903fa52bbd7687e2be50832f63f8c Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Tue, 13 May 2025 16:26:49 -0400
Subject: [PATCH 16/18] feat: remove unit tests for syncGameServerStartingState

---
 pkg/gameservers/controller_test.go | 31 ------------------------------
 1 file changed, 31 deletions(-)

diff --git a/pkg/gameservers/controller_test.go b/pkg/gameservers/controller_test.go
index 9ad44387a5..f1d01e5034 100644
--- a/pkg/gameservers/controller_test.go
+++ b/pkg/gameservers/controller_test.go
@@ -1189,37 +1189,6 @@ func TestControllerSyncGameServerStartingState(t *testing.T) {
 		assert.NotEmpty(t, gs.Status.Ports)
 	})
 
-	t.Run("Error on podIPs not populated", func(t *testing.T) {
-		c, m := newFakeController()
-		gsFixture := newFixture()
-		gsFixture.ApplyDefaults()
-		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
-		require.NoError(t, err)
-		pod.Spec.NodeName = nodeFixtureName
-		pod.Status.PodIPs = nil
-
-		m.KubeClient.AddReactor("list", "nodes", func(_ k8stesting.Action) (bool, runtime.Object, error) {
-			return true, &corev1.NodeList{Items: []corev1.Node{node}}, nil
-		})
-		m.KubeClient.AddReactor("list", "pods", func(_ k8stesting.Action) (bool, runtime.Object, error) {
-			return true, &corev1.PodList{Items: []corev1.Pod{*pod}}, nil
-		})
-		m.AgonesClient.AddReactor("update", "gameservers", func(action k8stesting.Action) (bool, runtime.Object, error) {
-			ua := action.(k8stesting.UpdateAction)
-			gs := ua.GetObject().(*agonesv1.GameServer)
-			assert.Equal(t, agonesv1.GameServerStateStarting, gs.Status.State)
-			assert.NotEmpty(t, gs.Status.Ports)
-			assert.NotEmpty(t, gs.Status.Address)
-			assert.NotEmpty(t, gs.Status.Addresses)
-			return true, gs, nil
-		})
-		ctx, cancel := agtesting.StartInformers(m, c.gameServerSynced, c.podSynced, c.nodeSynced)
-		defer cancel()
-
-		_, err = c.syncGameServerStartingState(ctx, gsFixture)
-		assert.Error(t, err)
-	})
-
 	t.Run("Error on update", func(t *testing.T) {
 		c, m := newFakeController()
 		gsFixture := newFixture()

From 49c911f9d90569cb64a6f1a7120b2d23e588b21b Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Tue, 3 Jun 2025 19:52:13 -0400
Subject: [PATCH 17/18] feat: remove podIPs check from main tests and keep the
 one when available

---
 pkg/gameservers/controller_test.go | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/pkg/gameservers/controller_test.go b/pkg/gameservers/controller_test.go
index f1d01e5034..9846f4b961 100644
--- a/pkg/gameservers/controller_test.go
+++ b/pkg/gameservers/controller_test.go
@@ -1699,9 +1699,6 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
-		gsFixture.Status.Addresses = []corev1.NodeAddress{
-			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
-		}
 		gsFixture.Annotations[agonesv1.GameServerReadyContainerIDAnnotation] = "4321"
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		pod.Status.ContainerStatuses = []corev1.ContainerStatus{
@@ -1762,9 +1759,6 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
-		gsFixture.Status.Addresses = []corev1.NodeAddress{
-			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
-		}
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		pod.Status.ContainerStatuses = []corev1.ContainerStatus{{Name: gsFixture.Spec.Container}}
 		assert.Nil(t, err)
@@ -1799,12 +1793,12 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
-		gsFixture.Status.Addresses = []corev1.NodeAddress{
-			{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
-		}
+		// gsFixture.Status.Addresses = []corev1.NodeAddress{
+		// 	{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
+		// }
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		assert.Nil(t, err)
-		pod.Spec.NodeName = nodeName
+		// pod.Spec.NodeName = nodeName
 		gsUpdated := false
 		podUpdated := false
 

From 4b6d17d8b21bd8258b62ab19e2e3055e46fdb44a Mon Sep 17 00:00:00 2001
From: Thomas Lacroix <thomas.lacroix@ubisoft.com>
Date: Tue, 3 Jun 2025 20:02:18 -0400
Subject: [PATCH 18/18] feat: remove commented code

---
 pkg/gameservers/controller_test.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/pkg/gameservers/controller_test.go b/pkg/gameservers/controller_test.go
index 9846f4b961..349903ecb3 100644
--- a/pkg/gameservers/controller_test.go
+++ b/pkg/gameservers/controller_test.go
@@ -1793,12 +1793,8 @@ func TestControllerSyncGameServerRequestReadyState(t *testing.T) {
 			Spec: newSingleContainerSpec(), Status: agonesv1.GameServerStatus{State: agonesv1.GameServerStateRequestReady}}
 		gsFixture.ApplyDefaults()
 		gsFixture.Status.NodeName = nodeName
-		// gsFixture.Status.Addresses = []corev1.NodeAddress{
-		// 	{Type: agonesv1.NodePodIP, Address: "0.0.0.0"},
-		// }
 		pod, err := gsFixture.Pod(agtesting.FakeAPIHooks{})
 		assert.Nil(t, err)
-		// pod.Spec.NodeName = nodeName
 		gsUpdated := false
 		podUpdated := false