stackit-dev-tools/terraform-provider-stackitprivatepreview
2
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions
terraform-provider-stackitp.../stackit/internal/services/loadbalancer/loadbalancer_acc_test.go
Alexander Dahmen f0168cfed9
Ft/rework acceptance tests (#675) 
* Rework IaaS acceptance tests

Signed-off-by: Alexander Dahmen <alexander.dahmen@inovex.de>

* Rework mongodb acceptance tests

Signed-off-by: Alexander Dahmen <alexander.dahmen@inovex.de>

* Rework observability acceptance tests

Signed-off-by: Alexander Dahmen <alexander.dahmen@inovex.de>

* Rework secretsmanager acceptance tests

Signed-off-by: Alexander Dahmen <alexander.dahmen@inovex.de>

* Rework loadbalancer acceptance tests

Signed-off-by: Alexander Dahmen <alexander.dahmen@inovex.de>

* Rework ske acceptance tests

Signed-off-by: Alexander Dahmen <alexander.dahmen@inovex.de>

* Update documentation

Signed-off-by: Alexander Dahmen <alexander.dahmen@inovex.de>

---------

Signed-off-by: Alexander Dahmen <alexander.dahmen@inovex.de>
2025-02-14 08:44:11 +01:00

383 lines
15 KiB
Go
Raw Blame History

package loadbalancer_test
import (
"context"
"fmt"
"strings"
"testing"
"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
"github.com/hashicorp/terraform-plugin-testing/helper/resource"
"github.com/hashicorp/terraform-plugin-testing/terraform"
"github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/wait"
"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
"github.com/stackitcloud/stackit-sdk-go/core/config"
"github.com/stackitcloud/stackit-sdk-go/core/utils"
"github.com/stackitcloud/stackit-sdk-go/services/loadbalancer"
"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/testutil"
)
// Instance resource data
var loadBalancerResource = map[string]string{
"project_id": testutil.ProjectId,
"name": fmt.Sprintf("tf-acc-%s", acctest.RandStringFromCharSet(7, acctest.CharSetAlphaNum)),
"target_pool_name": "example-target-pool",
"target_port": "5432",
"target_port_updated": "5431",
"target_display_name": "example-target",
"healthy_threshold": "3",
"interval": "10s",
"interval_jitter": "5s",
"timeout": "10s",
"unhealthy_threshold": "3",
"use_source_ip_address": "true",
"listener_display_name": "example-listener",
"listener_port": "5432",
"listener_protocol": "PROTOCOL_TLS_PASSTHROUGH",
"network_role": "ROLE_LISTENERS_AND_TARGETS",
"private_network_only": "false",
}
// Network resource data
var networkResource = map[string]string{
"project_id": testutil.ProjectId,
"name": fmt.Sprintf("acc-test-%s", acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)),
"nameserver0": "8.8.8.8",
"ipv4_prefix": "192.168.0.0/25",
"routed": "true",
}
// Server resource data
var serverResource = map[string]string{
"project_id": testutil.ProjectId,
"availability_zone": "eu01-1",
"size": "32",
"source_type": "image",
"source_id": testutil.IaaSImageId,
"name": fmt.Sprintf("tf-acc-%s", acctest.RandStringFromCharSet(5, acctest.CharSetAlpha)),
"machine_type": "t1.1",
"user_data": "#!/bin/bash",
"delete_on_termination": "true",
}
// Public ip resource data
var publicIpResource = map[string]string{
"project_id": testutil.ProjectId,
"network_interface_id": "stackit_network_interface.network_interface.network_interface_id",
}
func publicIpResourceConfig() string {
return fmt.Sprintf(`
resource "stackit_public_ip" "public_ip" {
project_id = "%s"
network_interface_id = %s
lifecycle {
ignore_changes = [
network_interface_id
]
}
}
`,
publicIpResource["project_id"],
publicIpResource["network_interface_id"],
)
}
func networkResourceConfig() string {
return fmt.Sprintf(`
resource "stackit_network" "network" {
project_id = "%s"
name = "%s"
ipv4_nameservers = ["%s"]
ipv4_prefix = "%s"
routed = "%s"
}
`,
networkResource["project_id"],
networkResource["name"],
networkResource["nameserver0"],
networkResource["ipv4_prefix"],
networkResource["routed"],
)
}
func networkInterfaceResourceConfig() string {
return `
resource "stackit_network_interface" "network_interface" {
project_id = stackit_network.network.project_id
network_id = stackit_network.network.network_id
name = "name"
}
`
}
// server config
func serverResourceConfig() string {
return fmt.Sprintf(`
resource "stackit_server" "server" {
project_id = "%s"
availability_zone = "%s"
name = "%s"
machine_type = "%s"
boot_volume = {
size = %s
source_type = "%s"
source_id = "%s"
delete_on_termination = "%s"
}
network_interfaces = [stackit_network_interface.network_interface.network_interface_id]
user_data = "%s"
}
`,
serverResource["project_id"],
serverResource["availability_zone"],
serverResource["name"],
serverResource["machine_type"],
serverResource["size"],
serverResource["source_type"],
serverResource["source_id"],
serverResource["delete_on_termination"],
serverResource["user_data"],
)
}
// loadbalancer config
func loadbalancerResourceConfig(targetPort string) string {
return fmt.Sprintf(`
%s
%s
%s
%s
%s
resource "stackit_loadbalancer" "loadbalancer" {
project_id = "%s"
name = "%s"
target_pools = [
{
name = "%s"
target_port = %s
targets = [
{
display_name = "%s"
ip = stackit_network_interface.network_interface.ipv4
}
]
active_health_check = {
healthy_threshold = %s
interval = "%s"
interval_jitter = "%s"
timeout = "%s"
unhealthy_threshold = %s
}
}
]
listeners = [
{
display_name = "%s"
port = %s
protocol = "%s"
target_pool = "%s"
}
]
networks = [
{
network_id = stackit_network.network.network_id
role = "%s"
}
]
external_address = stackit_public_ip.public_ip.ip
options = {
private_network_only = %s
}
}
`,
testutil.LoadBalancerProviderConfig(),
networkResourceConfig(),
networkInterfaceResourceConfig(),
publicIpResourceConfig(),
serverResourceConfig(),
loadBalancerResource["project_id"],
loadBalancerResource["name"],
loadBalancerResource["target_pool_name"],
targetPort,
loadBalancerResource["target_display_name"],
loadBalancerResource["healthy_threshold"],
loadBalancerResource["interval"],
loadBalancerResource["interval_jitter"],
loadBalancerResource["timeout"],
loadBalancerResource["unhealthy_threshold"],
loadBalancerResource["listener_display_name"],
loadBalancerResource["listener_port"],
loadBalancerResource["listener_protocol"],
loadBalancerResource["target_pool_name"],
loadBalancerResource["network_role"],
loadBalancerResource["private_network_only"],
)
}
func TestAccLoadBalancerResource(t *testing.T) {
resource.Test(t, resource.TestCase{
ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
CheckDestroy: testAccCheckLoadBalancerDestroy,
Steps: []resource.TestStep{
// Creation
{
Config: loadbalancerResourceConfig(loadBalancerResource["target_port"]),
Check: resource.ComposeAggregateTestCheckFunc(
// Load balancer instance
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "project_id", loadBalancerResource["project_id"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "name", loadBalancerResource["name"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.name", loadBalancerResource["target_pool_name"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.target_port", loadBalancerResource["target_port"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.targets.0.display_name", loadBalancerResource["target_display_name"]),
resource.TestCheckResourceAttrSet("stackit_loadbalancer.loadbalancer", "target_pools.0.targets.0.ip"),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.healthy_threshold", loadBalancerResource["healthy_threshold"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.interval", loadBalancerResource["interval"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.interval_jitter", loadBalancerResource["interval_jitter"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.timeout", loadBalancerResource["timeout"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.unhealthy_threshold", loadBalancerResource["unhealthy_threshold"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "listeners.0.display_name", loadBalancerResource["listener_display_name"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "listeners.0.port", loadBalancerResource["listener_port"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "listeners.0.protocol", loadBalancerResource["listener_protocol"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "listeners.0.target_pool", loadBalancerResource["target_pool_name"]),
resource.TestCheckResourceAttrSet("stackit_loadbalancer.loadbalancer", "networks.0.network_id"),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "networks.0.role", loadBalancerResource["network_role"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "options.private_network_only", loadBalancerResource["private_network_only"]),
),
},
// Data source
{
Config: fmt.Sprintf(`
%s
data "stackit_loadbalancer" "loadbalancer" {
project_id = stackit_loadbalancer.loadbalancer.project_id
name = stackit_loadbalancer.loadbalancer.name
}
`,
loadbalancerResourceConfig(loadBalancerResource["target_port"]),
),
Check: resource.ComposeAggregateTestCheckFunc(
// Load balancer instance
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "project_id", loadBalancerResource["project_id"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "name", loadBalancerResource["name"]),
resource.TestCheckResourceAttrPair(
"data.stackit_loadbalancer.loadbalancer", "project_id",
"stackit_loadbalancer.loadbalancer", "project_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_loadbalancer.loadbalancer", "name",
"stackit_loadbalancer.loadbalancer", "name",
),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.name", loadBalancerResource["target_pool_name"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.target_port", loadBalancerResource["target_port"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.targets.0.display_name", loadBalancerResource["target_display_name"]),
resource.TestCheckResourceAttrSet("data.stackit_loadbalancer.loadbalancer", "target_pools.0.targets.0.ip"),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.healthy_threshold", loadBalancerResource["healthy_threshold"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.interval", loadBalancerResource["interval"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.interval_jitter", loadBalancerResource["interval_jitter"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.timeout", loadBalancerResource["timeout"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "target_pools.0.active_health_check.unhealthy_threshold", loadBalancerResource["unhealthy_threshold"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "listeners.0.display_name", loadBalancerResource["listener_display_name"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "listeners.0.port", loadBalancerResource["listener_port"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "listeners.0.protocol", loadBalancerResource["listener_protocol"]),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "listeners.0.target_pool", loadBalancerResource["target_pool_name"]),
resource.TestCheckResourceAttrSet("data.stackit_loadbalancer.loadbalancer", "networks.0.network_id"),
resource.TestCheckResourceAttr("data.stackit_loadbalancer.loadbalancer", "networks.0.role", loadBalancerResource["network_role"]),
),
},
// Import
{
ResourceName: "stackit_loadbalancer.loadbalancer",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_loadbalancer.loadbalancer"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_loadbalancer.loadbalancer")
}
name, ok := r.Primary.Attributes["name"]
if !ok {
return "", fmt.Errorf("couldn't find attribute name")
}
return fmt.Sprintf("%s,%s", testutil.ProjectId, name), nil
},
ImportState: true,
ImportStateVerify: true,
ImportStateVerifyIgnore: []string{"options.private_network_only"},
},
// Update
{
Config: loadbalancerResourceConfig(loadBalancerResource["target_port_updated"]),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "project_id", loadBalancerResource["project_id"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "name", loadBalancerResource["name"]),
resource.TestCheckResourceAttr("stackit_loadbalancer.loadbalancer", "target_pools.0.target_port", loadBalancerResource["target_port_updated"]),
),
},
// Deletion is done by the framework implicitly
},
})
}
func testAccCheckLoadBalancerDestroy(s *terraform.State) error {
ctx := context.Background()
var client *loadbalancer.APIClient
var err error
if testutil.LoadBalancerCustomEndpoint == "" {
client, err = loadbalancer.NewAPIClient(
config.WithRegion("eu01"),
)
} else {
client, err = loadbalancer.NewAPIClient(
config.WithEndpoint(testutil.LoadBalancerCustomEndpoint),
)
}
if err != nil {
return fmt.Errorf("creating client: %w", err)
}
loadbalancersToDestroy := []string{}
for _, rs := range s.RootModule().Resources {
if rs.Type != "stackit_loadbalancer" {
continue
}
// loadbalancer terraform ID: = "[project_id],[name]"
loadbalancerName := strings.Split(rs.Primary.ID, core.Separator)[1]
loadbalancersToDestroy = append(loadbalancersToDestroy, loadbalancerName)
}
loadbalancersResp, err := client.ListLoadBalancers(ctx, testutil.ProjectId).Execute()
if err != nil {
return fmt.Errorf("getting loadbalancersResp: %w", err)
}
if loadbalancersResp.LoadBalancers == nil || (loadbalancersResp.LoadBalancers != nil && len(*loadbalancersResp.LoadBalancers) == 0) {
fmt.Print("No load balancers found for project \n")
return nil
}
items := *loadbalancersResp.LoadBalancers
for i := range items {
if items[i].Name == nil {
continue
}
if utils.Contains(loadbalancersToDestroy, *items[i].Name) {
_, err := client.DeleteLoadBalancerExecute(ctx, testutil.ProjectId, *items[i].Name)
if err != nil {
return fmt.Errorf("destroying load balancer %s during CheckDestroy: %w", *items[i].Name, err)
}
_, err = wait.DeleteLoadBalancerWaitHandler(ctx, client, testutil.ProjectId, *items[i].Name).WaitWithContext(ctx)
if err != nil {
return fmt.Errorf("destroying load balancer %s during CheckDestroy: waiting for deletion %w", *items[i].Name, err)
}
}
}
return nil
}
Reference in a new issue View git blame Copy permalink