kubernetes · k8s-ci-robot · May 13, 2026 · Feb 20, 2026 · Apr 2, 2026
diff --git a/cloudmock/gce/mock_gce_cloud.go b/cloudmock/gce/mock_gce_cloud.go
@@ -23,7 +23,6 @@ import (
 	compute "google.golang.org/api/compute/v1"
 	"google.golang.org/api/storage/v1"
 	v1 "k8s.io/api/core/v1"
-	"k8s.io/klog/v2"
 	"k8s.io/kops/cloudmock/gce/mockcloudresourcemanager"
 	mockcompute "k8s.io/kops/cloudmock/gce/mockcompute"
 	"k8s.io/kops/cloudmock/gce/mockdns"
@@ -73,13 +72,12 @@ func (c *MockGCECloud) AllResources() map[string]interface{} {
 
 // GetCloudGroups is not implemented yet
 func (c *MockGCECloud) GetCloudGroups(cluster *kops.Cluster, instancegroups []*kops.InstanceGroup, warnUnmatched bool, nodes []v1.Node) (map[string]*cloudinstances.CloudInstanceGroup, error) {
-	klog.V(8).Infof("MockGCECloud cloud provider GetCloudGroups not implemented yet")
-	return nil, fmt.Errorf("MockGCECloud cloud provider does not support getting cloud groups at this time")
+	return gce.GetCloudGroups(c, cluster, instancegroups, warnUnmatched, nodes)
 }
 
 // Zones is not implemented yet
 func (c *MockGCECloud) Zones() ([]string, error) {
-	return nil, fmt.Errorf("not yet implemented")
+	return gce.GetZones(c)
 }
 
 // WithLabels returns a copy of the MockGCECloud bound to the specified labels
@@ -170,8 +168,7 @@ func (c *MockGCECloud) Labels() map[string]string {
 
 // DeleteGroup implements fi.Cloud::DeleteGroup
 func (c *MockGCECloud) DeleteGroup(g *cloudinstances.CloudInstanceGroup) error {
-	return nil
-	//	return deleteCloudInstanceGroup(c, g)
+	return gce.DeleteCloudInstanceGroup(c, g)
 }
 
 // DeleteInstance deletes a GCE instance

diff --git a/cloudmock/gce/mockcompute/api.go b/cloudmock/gce/mockcompute/api.go
@@ -37,6 +37,7 @@ type MockClient struct {
 	addressClient          *addressClient
 	firewallClient         *firewallClient
 	routerClient           *routerClient
+	instanceClient         *instanceClient
 
 	instanceTemplateClient     *instanceTemplateClient
 	instanceGroupManagerClient *instanceGroupManagerClient
@@ -49,6 +50,8 @@ var _ gce.ComputeClient = &MockClient{}
 
 // NewMockClient creates a new mock client.
 func NewMockClient(project string) *MockClient {
+	instanceClient := newInstanceClient()
+
 	return &MockClient{
 		projectClient: newProjectClient(project),
 		zoneClient:    newZoneClient(project),
@@ -63,9 +66,10 @@ func NewMockClient(project string) *MockClient {
 		addressClient:          newAddressClient(),
 		firewallClient:         newFirewallClient(),
 		routerClient:           newRouterClient(),
+		instanceClient:         instanceClient,
 
 		instanceTemplateClient:     newInstanceTemplateClient(),
-		instanceGroupManagerClient: newInstanceGroupManagerClient(),
+		instanceGroupManagerClient: newInstanceGroupManagerClient(instanceClient),
 		targetPoolClient:           newTargetPoolClient(),
 
 		diskClient: newDiskClient(),
@@ -158,8 +162,7 @@ func (c *MockClient) Routers() gce.RouterClient {
 }
 
 func (c *MockClient) Instances() gce.InstanceClient {
-	// Not implemented.
-	return nil
+	return c.instanceClient
 }
 
 func (c *MockClient) InstanceTemplates() gce.InstanceTemplateClient {

diff --git a/cloudmock/gce/mockcompute/instance.go b/cloudmock/gce/mockcompute/instance.go
@@ -0,0 +1,124 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mockcompute
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	compute "google.golang.org/api/compute/v1"
+	"k8s.io/kops/upup/pkg/fi/cloudup/gce"
+)
+
+type instanceClient struct {
+	// instances are instances keyed by project, zone, and name.
+	instances map[string]map[string]map[string]*compute.Instance
+	sync.Mutex
+}
+
+var _ gce.InstanceClient = &instanceClient{}
+
+func newInstanceClient() *instanceClient {
+	return &instanceClient{
+		instances: map[string]map[string]map[string]*compute.Instance{},
+	}
+}
+
+func (c *instanceClient) All() map[string]interface{} {
+	return nil
+}
+
+func (c *instanceClient) Insert(project, zone string, instance *compute.Instance) (*compute.Operation, error) {
+	c.Lock()
+	defer c.Unlock()
+	zones, ok := c.instances[project]
+	if !ok {
+		zones = map[string]map[string]*compute.Instance{}
+		c.instances[project] = zones
+	}
+	instances, ok := zones[zone]
+	if !ok {
+		instances = map[string]*compute.Instance{}
+		zones[zone] = instances
+	}
+	instance.SelfLink = instance.Name
+	instances[instance.Name] = instance
+
+	return doneOperation(), nil
+}
+
+func (c *instanceClient) Delete(project, zone, name string) (*compute.Operation, error) {
+	c.Lock()
+	defer c.Unlock()
+
+	zones, ok := c.instances[project]
+	if !ok {
+		return nil, notFoundError()
+	}
+	instances, ok := zones[zone]
+	if !ok {
+		return nil, notFoundError()
+	}
+	if _, ok := instances[name]; !ok {
+		return nil, notFoundError()
+	}
+	delete(instances, name)
+	return doneOperation(), nil
+}
+
+func (c *instanceClient) Get(project, zone, name string) (*compute.Instance, error) {
+	c.Lock()
+	defer c.Unlock()
+	zones, ok := c.instances[project]
+	if !ok {
+		return nil, notFoundError()
+	}
+	res, ok := zones[zone]
+	if !ok {
+		return nil, notFoundError()
+	}
+	igm, ok := res[name]
+	if !ok {
+		return nil, notFoundError()
+	}
+	return igm, nil
+}
+
+func (c *instanceClient) List(ctx context.Context, project, zone string) ([]*compute.Instance, error) {
+	c.Lock()
+	defer c.Unlock()
+
+	zones, ok := c.instances[project]
+	if !ok {
+		return nil, nil
+	}
+	instances, ok := zones[zone]
+	if !ok {
+		return nil, nil
+	}
+
+	var l []*compute.Instance
+	for _, instance := range instances {
+		l = append(l, instance)
+	}
+	return l, nil
+}
+
+func (c *instanceClient) SetMetadata(project, zone, name string, metadata *compute.Metadata) (*compute.Operation, error) {
+	return nil, fmt.Errorf("setmetadata unimplemented")
+}
diff --git a/cloudmock/gce/mockcompute/instance_group_manager.go b/cloudmock/gce/mockcompute/instance_group_manager.go
@@ -20,6 +20,7 @@ import (
 	"context"
 	"fmt"
 	"sync"
+	"time"
 
 	compute "google.golang.org/api/compute/v1"
 	"k8s.io/kops/upup/pkg/fi/cloudup/gce"
@@ -28,14 +29,20 @@ import (
 type instanceGroupManagerClient struct {
 	// instanceGroupManagers are instanceGroupManagers keyed by project, zone, and name.
 	instanceGroupManagers map[string]map[string]map[string]*compute.InstanceGroupManager
+	// managedInstances are managedInstances keyed by project, zone, and name.
+	managedInstances map[string]map[string]map[string]*compute.ManagedInstance
+	// instanceClient is the client for instances.
+	instanceClient gce.InstanceClient
 	sync.Mutex
 }
 
 var _ gce.InstanceGroupManagerClient = &instanceGroupManagerClient{}
 
-func newInstanceGroupManagerClient() *instanceGroupManagerClient {
+func newInstanceGroupManagerClient(instanceClient gce.InstanceClient) *instanceGroupManagerClient {
 	return &instanceGroupManagerClient{
 		instanceGroupManagers: map[string]map[string]map[string]*compute.InstanceGroupManager{},
+		managedInstances:      map[string]map[string]map[string]*compute.ManagedInstance{},
+		instanceClient:        instanceClient,
 	}
 }
 
@@ -56,18 +63,40 @@ func (c *instanceGroupManagerClient) All() map[string]interface{} {
 func (c *instanceGroupManagerClient) Insert(project, zone string, igm *compute.InstanceGroupManager) (*compute.Operation, error) {
 	c.Lock()
 	defer c.Unlock()
-	zones, ok := c.instanceGroupManagers[project]
+	igmZones, ok := c.instanceGroupManagers[project]
 	if !ok {
-		zones = map[string]map[string]*compute.InstanceGroupManager{}
-		c.instanceGroupManagers[project] = zones
+		igmZones = map[string]map[string]*compute.InstanceGroupManager{}
+		c.instanceGroupManagers[project] = igmZones
 	}
-	igms, ok := zones[zone]
+	igms, ok := igmZones[zone]
 	if !ok {
 		igms = map[string]*compute.InstanceGroupManager{}
-		zones[zone] = igms
+		igmZones[zone] = igms
 	}
 	igm.SelfLink = fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/%s/zones/%s/instanceGroupManagers/%s", project, zone, igm.Name)
 	igms[igm.Name] = igm
+
+	newInstance := &compute.Instance{
+		Name: igm.Name,
+	}
+
+	c.instanceClient.Insert(project, zone, newInstance)
+
+	instanceZones, ok := c.managedInstances[project]
+	if !ok {
+		instanceZones = map[string]map[string]*compute.ManagedInstance{}
+		c.managedInstances[project] = instanceZones
+	}
+	_, ok = instanceZones[zone]
+	if !ok {
+		instanceZones[zone] = map[string]*compute.ManagedInstance{}
+	}
+
+	c.managedInstances[project][zone][igm.Name] = &compute.ManagedInstance{
+		Name:     igm.Name,
+		Instance: fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/%s/zones/%s/instances/%s", project, zone, igm.Name),
+	}
+
 	return doneOperation(), nil
 }
 
@@ -126,8 +155,23 @@ func (c *instanceGroupManagerClient) List(ctx context.Context, project, zone str
 }
 
 func (c *instanceGroupManagerClient) ListManagedInstances(ctx context.Context, project, zone, name string) ([]*compute.ManagedInstance, error) {
-	var instances []*compute.ManagedInstance
-	return instances, nil
+	c.Lock()
+	defer c.Unlock()
+
+	zones, ok := c.managedInstances[project]
+	if !ok {
+		return nil, nil
+	}
+	instances, ok := zones[zone]
+	if !ok {
+		return nil, nil
+	}
+
+	var l []*compute.ManagedInstance
+	for _, instance := range instances {
+		l = append(l, instance)
+	}
+	return l, nil
 }
 
 func (c *instanceGroupManagerClient) RecreateInstances(project, zone, name, id string) (*compute.Operation, error) {
@@ -143,5 +187,28 @@ func (c *instanceGroupManagerClient) SetInstanceTemplate(project, zone, name, in
 }
 
 func (c *instanceGroupManagerClient) Resize(project, zone, name string, newSize int64) (*compute.Operation, error) {
+	go func() {
+		if newSize == 0 {
+			// Simulates a Long Operation when resizing
+			time.Sleep(20 * time.Millisecond)
+
+			c.Lock()
+			defer c.Unlock()
+
+			// Delete all Instances from GCE
+			for _, zones := range c.managedInstances[project] {
+				for _, instance := range zones {
+					c.instanceClient.Delete(project, zone, instance.Name)
+				}
+			}
+
+			zones, ok := c.managedInstances[project]
+			if !ok {
+				return
+			}
+
+			zones[zone] = nil
+		}
+	}()
 	return doneOperation(), nil
 }