package eks

import (
	"context"
	"fmt"
	"testing"
	"time"

	xpv1 "github.com/crossplane/crossplane-runtime/apis/common/v1"
	"github.com/crossplane/crossplane-runtime/pkg/meta"
	"github.com/stretchr/testify/assert"
	"github.com/upbound/provider-aws/apis/ec2/v1beta1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/utils/pointer"
	"sigs.k8s.io/controller-runtime/pkg/client"

	"github.com/tidbcloud/infra-provider/regional-server/api/v1alpha1"
	"github.com/tidbcloud/infra-provider/regional-server/pkg/deploy"
	"github.com/tidbcloud/infra-provider/regional-server/pkg/namer"
)

func fakeRouteTask(t *testing.T) *Route {
	return NewRoute(fakeTaskContext(t))
}

func TestRoute_buildPrivateRouteTable(t *testing.T) {
	task := fakeRouteTask(t)
	zone := "az-1"
	tags := map[string]string{"key": "value"}
	nodeSubnet := &v1beta1.Subnet{
		ObjectMeta: metav1.ObjectMeta{
			Name: "node-subnet",
		},
	}
	privateSubnet := &v1beta1.Subnet{
		ObjectMeta: metav1.ObjectMeta{
			Name: "private-subnet",
		},
	}
	vpc := &v1beta1.VPC{
		ObjectMeta: metav1.ObjectMeta{
			Name: "vpc",
		},
	}
	nat := &v1beta1.NATGateway{
		ObjectMeta: metav1.ObjectMeta{
			Name: "nat",
		},
	}

	rt, rtas, r := task.buildPrivateRouteTable(zone, tags, privateSubnet, nodeSubnet, vpc, nat)
	assert.Equal(t, &xpv1.Reference{Name: vpc.Name}, rt.Spec.ForProvider.VPCIDRef)
	if assert.Equal(t, 2, len(rtas)) {
		assert.Equal(t, &xpv1.Reference{Name: rt.Name}, rtas[0].Spec.ForProvider.RouteTableIDRef)
		assert.Equal(t, &xpv1.Reference{Name: privateSubnet.Name}, rtas[0].Spec.ForProvider.SubnetIDRef)
		assert.Equal(t, &xpv1.Reference{Name: rt.Name}, rtas[1].Spec.ForProvider.RouteTableIDRef)
		assert.Equal(t, &xpv1.Reference{Name: nodeSubnet.Name}, rtas[1].Spec.ForProvider.SubnetIDRef)
	}
	assert.Equal(t, &xpv1.Reference{Name: nat.Name}, r.Spec.ForProvider.NATGatewayIDRef)
	assert.Equal(t, &xpv1.Reference{Name: rt.Name}, r.Spec.ForProvider.RouteTableIDRef)
	assert.Equal(t, pointer.String("0.0.0.0/0"), r.Spec.ForProvider.DestinationCidrBlock)
}

func TestRoute_buildPublicRouteTable(t *testing.T) {
	task := fakeRouteTask(t)
	zone := "az-1"
	tags := map[string]string{"key": "value"}
	publicSubnet := &v1beta1.Subnet{
		ObjectMeta: metav1.ObjectMeta{
			Name: "public-subnet",
		},
	}
	vpc := &v1beta1.VPC{
		ObjectMeta: metav1.ObjectMeta{
			Name: "vpc",
		},
	}

	rt, rta, r := task.buildPublicRouteTable(zone, tags, publicSubnet, vpc)
	assert.Equal(t, &xpv1.Reference{Name: vpc.Name}, rt.Spec.ForProvider.VPCIDRef)
	assert.Equal(t, &xpv1.Reference{Name: rt.Name}, rta.Spec.ForProvider.RouteTableIDRef)
	assert.Equal(t, &xpv1.Reference{Name: publicSubnet.Name}, rta.Spec.ForProvider.SubnetIDRef)
	assert.Equal(t, &xpv1.Reference{Name: task.Internet.Status.InternetGateway.Name}, r.Spec.ForProvider.GatewayIDRef)
	assert.Equal(t, &xpv1.Reference{Name: rt.Name}, r.Spec.ForProvider.RouteTableIDRef)
	assert.Equal(t, pointer.String("0.0.0.0/0"), r.Spec.ForProvider.DestinationCidrBlock)
}

func TestRoute_createPrivateRouteTable(t *testing.T) {
	task := fakeRouteTask(t)
	vpcName := task.VPCName()
	vpcRes := &v1beta1.VPC{ObjectMeta: metav1.ObjectMeta{
		Name: vpcName,
	}}
	assert.NoError(t, task.Local.Create(context.Background(), vpcRes))
	task.VPC.Status.VPC.Name = vpcName
	zone := "az-1"
	tags := map[string]string{"key": "value"}
	name := task.InternetName()
	t.Run("private subnet not found", func(t *testing.T) {
		err := task.createPrivateRouteTable(context.Background(), name, zone, tags, vpcRes)
		assert.Error(t, err)
		assert.ErrorContains(t, err, "no private subnet found")
	})
	t.Run("node subnet not found", func(t *testing.T) {
		task.VPC.Status.PrivateSubnets = append(task.VPC.Status.PrivateSubnets, v1alpha1.Subnet{
			Name:               namer.PrivateSubnetName(name, zone),
			AvailabilityZone:   zone,
			AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
		})
		assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{
			ObjectMeta: metav1.ObjectMeta{
				Name: namer.PrivateSubnetName(name, zone),
				Annotations: map[string]string{
					meta.AnnotationKeyExternalName: fmt.Sprintf("id-private-%s", zone),
				},
			},
		}))
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.VPC))
		err := task.createPrivateRouteTable(context.Background(), name, zone, tags, vpcRes)
		assert.Error(t, err)
		assert.ErrorContains(t, err, "no node subnet found")
	})
	t.Run("nat not found", func(t *testing.T) {
		task.VPC.Status.NodeSubnets = append(task.VPC.Status.NodeSubnets, v1alpha1.Subnet{
			Name:               namer.NodesSubnetName(name, zone),
			AvailabilityZone:   zone,
			AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
		})
		assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{
			ObjectMeta: metav1.ObjectMeta{
				Name: namer.NodesSubnetName(name, zone),
				Annotations: map[string]string{
					meta.AnnotationKeyExternalName: fmt.Sprintf("id-node-%s", zone),
				},
			},
		}))
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.VPC))
		err := task.createPrivateRouteTable(context.Background(), name, zone, tags, vpcRes)
		assert.Error(t, err)
		assert.ErrorContains(t, err, "not found")
	})
	t.Run("nat gatway not found", func(t *testing.T) {
		task.Internet.Status.NATs = append(task.Internet.Status.NATs, v1alpha1.NAT{
			Name:         namer.PublicSubnetName(name, zone),
			NATGatewayID: fmt.Sprintf("gateway-id-%s", zone),
		})
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.Internet))
		err := task.createPrivateRouteTable(context.Background(), name, zone, tags, vpcRes)
		assert.Error(t, err)
		assert.ErrorContains(t, err, "not found")
	})
	t.Run("create success", func(t *testing.T) {
		assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.NATGateway{
			ObjectMeta: metav1.ObjectMeta{
				Name: namer.PublicSubnetName(name, zone),
			},
		}))
		task.Internet.Status.InternetGateway = v1alpha1.InternetGateway{
			Name: "internet-gateway",
		}
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.Internet))
		err := task.createPrivateRouteTable(context.Background(), name, zone, tags, vpcRes)
		assert.NoError(t, err)
		rts, rtas, rs, err := task.getRouteTables(context.Background())
		assert.NoError(t, err)
		assert.Len(t, rts, 1)
		assert.Len(t, rtas, 2)
		assert.Len(t, rs, 1)
	})
	t.Run("create fail without nat route", func(t *testing.T) {
		zoneNoNat := "az-2"
		task.VPC.Status.PrivateSubnets = append(task.VPC.Status.PrivateSubnets, v1alpha1.Subnet{
			Name:               namer.PrivateSubnetName(name, zoneNoNat),
			AvailabilityZone:   zoneNoNat,
			AvailabilityZoneID: fmt.Sprintf("%s-id", zoneNoNat),
		})
		assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{
			ObjectMeta: metav1.ObjectMeta{
				Name: namer.PrivateSubnetName(name, zoneNoNat),
				Annotations: map[string]string{
					meta.AnnotationKeyExternalName: fmt.Sprintf("id-private-%s", zoneNoNat),
				},
			},
		}))
		task.VPC.Status.NodeSubnets = append(task.VPC.Status.NodeSubnets, v1alpha1.Subnet{
			Name:               namer.NodesSubnetName(name, zoneNoNat),
			AvailabilityZone:   zoneNoNat,
			AvailabilityZoneID: fmt.Sprintf("%s-id", zoneNoNat),
		})
		assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{
			ObjectMeta: metav1.ObjectMeta{
				Name: namer.NodesSubnetName(name, zoneNoNat),
				Annotations: map[string]string{
					meta.AnnotationKeyExternalName: fmt.Sprintf("id-node-%s", zoneNoNat),
				},
			},
		}))
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.VPC))

		err := task.createPrivateRouteTable(context.Background(), name, zoneNoNat, tags, vpcRes)
		assert.Error(t, err)
		assert.ErrorContains(t, err, "NAT")
	})
}

func TestRoute_createPublicRouteTable(t *testing.T) {
	task := fakeRouteTask(t)
	vpcName := task.VPCName()
	vpcRes := &v1beta1.VPC{ObjectMeta: metav1.ObjectMeta{
		Name: vpcName,
	}}
	assert.NoError(t, task.Local.Create(context.Background(), vpcRes))
	task.VPC.Status.VPC.Name = vpcName
	zone := "az-1"
	tags := map[string]string{"key": "value"}
	name := task.InternetName()

	t.Run("public subnet not found", func(t *testing.T) {
		err := task.createPublicRouteTable(context.Background(), zone, tags, vpcRes)
		assert.Error(t, err)
		assert.ErrorContains(t, err, "no public subnet found")
	})
	t.Run("create success", func(t *testing.T) {
		task.VPC.Status.PublicSubnets = append(task.VPC.Status.PublicSubnets, v1alpha1.Subnet{
			Name:               namer.PublicSubnetName(name, zone),
			AvailabilityZone:   zone,
			AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
		})
		assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{
			ObjectMeta: metav1.ObjectMeta{
				Name: namer.PublicSubnetName(name, zone),
				Annotations: map[string]string{
					meta.AnnotationKeyExternalName: fmt.Sprintf("id-public-%s", zone),
				},
			},
		}))
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.VPC))
		err := task.createPublicRouteTable(context.Background(), zone, tags, vpcRes)
		assert.NoError(t, err)
		rts, rtas, rs, err := task.getRouteTables(context.Background())
		assert.NoError(t, err)
		assert.Len(t, rts, 1)
		assert.Len(t, rtas, 1)
		assert.Len(t, rs, 1)
	})
}

func TestRoute_Create(t *testing.T) {
	t.Run("vpc not found", func(t *testing.T) {
		task := fakeRouteTask(t)
		task.Config.ResourceNamePrefix = "tidbcloud"
		task.VPC.Name = "not-found"
		result := task.Create(context.Background())
		res, err, retriableErr := deploy.MinRequeue([]deploy.Result{result})
		assert.Nil(t, err)
		assert.ErrorContains(t, retriableErr, "not found")
		assert.Equal(t, time.Second*30, res.RequeueAfter)
	})
	t.Run("aws vpc not found", func(t *testing.T) {
		task := fakeRouteTask(t)
		task.Config.ResourceNamePrefix = "tidbcloud"
		result := task.Create(context.Background())
		res, err, retriableErr := deploy.MinRequeue([]deploy.Result{result})
		assert.Nil(t, err)
		assert.ErrorContains(t, retriableErr, "not found")
		assert.Equal(t, time.Second*30, res.RequeueAfter)
	})

	task := fakeRouteTask(t)
	vpcName := task.VPCName()
	vpcRes := &v1beta1.VPC{ObjectMeta: metav1.ObjectMeta{
		Name: vpcName,
	}}
	assert.Nil(t, task.Local.Create(context.Background(), vpcRes))
	task.VPC.Status.VPC.Name = vpcName
	zones := task.GetZones()
	nodeZones := task.GetNodeZones()
	name := task.InternetName()
	t.Run("create success", func(t *testing.T) {
		for _, zone := range zones {
			task.VPC.Status.PrivateSubnets = append(task.VPC.Status.PrivateSubnets, v1alpha1.Subnet{
				Name:               namer.PrivateSubnetName(name, zone),
				AvailabilityZone:   zone,
				AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
			})
			assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{
				ObjectMeta: metav1.ObjectMeta{
					Name: namer.PrivateSubnetName(name, zone),
					Annotations: map[string]string{
						meta.AnnotationKeyExternalName: fmt.Sprintf("id-private-%s", zone),
					},
				},
			}))
			task.VPC.Status.NodeSubnets = append(task.VPC.Status.NodeSubnets, v1alpha1.Subnet{
				Name:               namer.NodesSubnetName(name, zone),
				AvailabilityZone:   zone,
				AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
			})
			assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{
				ObjectMeta: metav1.ObjectMeta{
					Name: namer.NodesSubnetName(name, zone),
					Annotations: map[string]string{
						meta.AnnotationKeyExternalName: fmt.Sprintf("id-node-%s", zone),
					},
				},
			}))
			task.VPC.Status.PublicSubnets = append(task.VPC.Status.PublicSubnets, v1alpha1.Subnet{
				Name:               namer.PublicSubnetName(name, zone),
				AvailabilityZone:   zone,
				AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
			})
			assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{
				ObjectMeta: metav1.ObjectMeta{
					Name: namer.PublicSubnetName(name, zone),
					Annotations: map[string]string{
						meta.AnnotationKeyExternalName: fmt.Sprintf("id-public-%s", zone),
					},
				},
			}))

		}
		for _, zone := range nodeZones {
			task.Internet.Status.NATs = append(task.Internet.Status.NATs, v1alpha1.NAT{
				Name:         namer.PublicSubnetName(name, zone),
				NATGatewayID: fmt.Sprintf("gateway-id-%s", zone),
			})
			assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.NATGateway{
				ObjectMeta: metav1.ObjectMeta{
					Name: namer.PublicSubnetName(name, zone),
				},
			}))
		}
		task.Internet.Status.InternetGateway = v1alpha1.InternetGateway{
			Name: "internet-gateway",
		}
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.VPC))
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.Internet))

		result := task.Create(context.Background())
		assert.True(t, result.IsDoneState())

		rts, rtas, rs, err := task.getRouteTables(context.Background())
		assert.NoError(t, err)
		assert.Len(t, rts, len(nodeZones)*2)
		assert.Len(t, rtas, len(nodeZones)*3)
		assert.Len(t, rs, len(nodeZones)*2)
	})

	t.Run("create success with additional control-plane zone", func(t *testing.T) {
		task := fakeRouteTask(t)
		task.VPC.Spec.Zones = []string{"zone1", "zone2", "zone3"}
		task.VPC.Spec.NodeZones = []string{"zone1", "zone2"}

		vpcName := task.VPCName()
		vpcRes := &v1beta1.VPC{ObjectMeta: metav1.ObjectMeta{Name: vpcName}}
		assert.Nil(t, task.Local.Create(context.Background(), vpcRes))
		task.VPC.Status.VPC.Name = vpcName

		zones := task.GetZones()
		nodeZones := task.GetNodeZones()
		name := task.InternetName()

		for _, zone := range zones {
			task.VPC.Status.PrivateSubnets = append(task.VPC.Status.PrivateSubnets, v1alpha1.Subnet{
				Name:               namer.PrivateSubnetName(name, zone),
				AvailabilityZone:   zone,
				AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
			})
			assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{ObjectMeta: metav1.ObjectMeta{Name: namer.PrivateSubnetName(name, zone)}}))

			task.VPC.Status.NodeSubnets = append(task.VPC.Status.NodeSubnets, v1alpha1.Subnet{
				Name:               namer.NodesSubnetName(name, zone),
				AvailabilityZone:   zone,
				AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
			})
			assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{ObjectMeta: metav1.ObjectMeta{Name: namer.NodesSubnetName(name, zone)}}))

			task.VPC.Status.PublicSubnets = append(task.VPC.Status.PublicSubnets, v1alpha1.Subnet{
				Name:               namer.PublicSubnetName(name, zone),
				AvailabilityZone:   zone,
				AvailabilityZoneID: fmt.Sprintf("%s-id", zone),
			})
			assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.Subnet{ObjectMeta: metav1.ObjectMeta{Name: namer.PublicSubnetName(name, zone)}}))
		}

		for _, zone := range nodeZones {
			task.Internet.Status.NATs = append(task.Internet.Status.NATs, v1alpha1.NAT{
				Name:         namer.PublicSubnetName(name, zone),
				NATGatewayID: fmt.Sprintf("gateway-id-%s", zone),
			})
			assert.NoError(t, task.Local.Create(context.Background(), &v1beta1.NATGateway{ObjectMeta: metav1.ObjectMeta{Name: namer.PublicSubnetName(name, zone)}}))
		}

		task.Internet.Status.InternetGateway = v1alpha1.InternetGateway{Name: "internet-gateway"}
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.VPC))
		assert.NoError(t, task.Local.Status().Update(context.Background(), task.Internet))
		task.VPC.Spec.Zones = []string{"zone1", "zone2", "zone3"}
		task.VPC.Spec.NodeZones = []string{"zone1", "zone2"}

		result := task.Create(context.Background())
		assert.True(t, result.IsDoneState())

		rts, rtas, rs, err := task.getRouteTables(context.Background())
		assert.NoError(t, err)
		assert.Len(t, rts, len(nodeZones)*2)
		assert.Len(t, rtas, len(nodeZones)*3)
		assert.Len(t, rs, len(nodeZones)*2)
	})
}

func TestRoute_PostCreate(t *testing.T) {
	t.Run("route table not found", func(t *testing.T) {
		task := fakeRouteTask(t)
		result := task.PostCreate(context.Background())
		res, err, retriableErr := deploy.MinRequeue([]deploy.Result{result})
		assert.Nil(t, err)
		assert.ErrorContains(t, retriableErr, "not found")
		assert.Equal(t, time.Second*30, res.RequeueAfter)
	})

	task := fakeRouteTask(t)
	rt := &v1beta1.RouteTable{
		ObjectMeta: metav1.ObjectMeta{
			Name:   "rt-1",
			Labels: map[string]string{v1alpha1.InternetNameKey: task.Internet.Name},
		},
	}
	rta := &v1beta1.RouteTableAssociation{
		ObjectMeta: metav1.ObjectMeta{
			Name:   "rta-1",
			Labels: map[string]string{v1alpha1.InternetNameKey: task.Internet.Name},
		},
	}
	r := &v1beta1.Route{
		ObjectMeta: metav1.ObjectMeta{
			Name:   "r-1",
			Labels: map[string]string{v1alpha1.InternetNameKey: task.Internet.Name},
		},
		Spec: v1beta1.RouteSpec{
			ForProvider: v1beta1.RouteParameters_2{
				RouteTableIDRef: &xpv1.Reference{Name: "rt-1"},
			},
		},
	}
	assert.NoError(t, task.Local.Create(context.Background(), rt))
	assert.NoError(t, task.Local.Create(context.Background(), rta))
	assert.NoError(t, task.Local.Create(context.Background(), r))

	t.Run("route table not ready", func(t *testing.T) {
		result := task.PostCreate(context.Background())
		res, err, retriableErr := deploy.MinRequeue([]deploy.Result{result})
		assert.Nil(t, err)
		assert.ErrorContains(t, retriableErr, "not ready")
		assert.Equal(t, time.Second*30, res.RequeueAfter)
	})
	t.Run("route table association not ready", func(t *testing.T) {
		assert.NoError(t, task.Local.Get(context.Background(), client.ObjectKey{Name: rt.Name}, rt))
		rt.Status.AtProvider.ID = pointer.String("rt-1-id")
		rt.Status.SetConditions(xpv1.Available())
		assert.NoError(t, task.Local.Update(context.Background(), rt))

		result := task.PostCreate(context.Background())
		res, err, retriableErr := deploy.MinRequeue([]deploy.Result{result})
		assert.Nil(t, err)
		assert.ErrorContains(t, retriableErr, "not ready")
		assert.Equal(t, time.Second*30, res.RequeueAfter)
	})
	t.Run("route table not ready", func(t *testing.T) {
		assert.NoError(t, task.Local.Get(context.Background(), client.ObjectKey{Name: rta.Name}, rta))
		rta.Status.SetConditions(xpv1.Available())
		assert.NoError(t, task.Local.Update(context.Background(), rta))

		result := task.PostCreate(context.Background())
		res, err, retriableErr := deploy.MinRequeue([]deploy.Result{result})
		assert.Nil(t, err)
		assert.ErrorContains(t, retriableErr, "not ready")
		assert.Equal(t, time.Second*30, res.RequeueAfter)
	})
	t.Run("create success", func(t *testing.T) {
		assert.NoError(t, task.Local.Get(context.Background(), client.ObjectKey{Name: r.Name}, r))
		r.Status.AtProvider.ID = pointer.String("r-1-id")
		r.Status.SetConditions(xpv1.Available())
		assert.NoError(t, task.Local.Update(context.Background(), r))

		result := task.PostCreate(context.Background())
		assert.True(t, result.IsDoneState())
		assert.Equal(t, []v1alpha1.Route{{Name: "r-1", RouteTableRef: "rt-1"}}, task.Internet.Status.Routes)
		assert.Equal(t, []v1alpha1.RouteTable{{Name: "rt-1", RouteTableID: "rt-1-id"}}, task.Internet.Status.RouteTables)
	})
}

func TestRoute_Delete(t *testing.T) {
	t.Run("delete success", func(t *testing.T) {
		task := fakeRouteTask(t)
		rt := &v1beta1.RouteTable{
			ObjectMeta: metav1.ObjectMeta{
				Name: "rt-1",
				Labels: map[string]string{
					v1alpha1.InternetNameKey: task.Internet.Name,
				},
			},
		}
		rta := &v1beta1.RouteTableAssociation{
			ObjectMeta: metav1.ObjectMeta{
				Name: "rta-1",
				Labels: map[string]string{
					v1alpha1.InternetNameKey: task.Internet.Name,
				},
			},
		}
		r := &v1beta1.Route{
			ObjectMeta: metav1.ObjectMeta{
				Name: "r-1",
				Labels: map[string]string{
					v1alpha1.InternetNameKey: task.Internet.Name,
				},
			},
		}
		assert.NoError(t, task.Local.Create(context.Background(), rt))
		assert.NoError(t, task.Local.Create(context.Background(), rta))
		assert.NoError(t, task.Local.Create(context.Background(), r))

		result := task.Delete(context.Background())
		assert.True(t, result.IsDoneState())

		rts, rtas, rs, err := task.getRouteTables(context.Background())
		assert.Nil(t, err)
		assert.Empty(t, rts)
		assert.Empty(t, rtas)
		assert.Empty(t, rs)
	})
}