stackit-dev-tools/terraform-provider-stackitprivatepreview
3
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

Initial commit

Browse source
This commit is contained in:
vicentepinto98 2023-09-07 11:34:45 +01:00
commit e4c8a6fbf4
186 changed files with 29501 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

557
stackit/services/dns/dns_acc_test.go Normal file
View file

@ -0,0 +1,557 @@
package dns_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/core/config"
"github.com/stackitcloud/stackit-sdk-go/core/utils"
"github.com/stackitcloud/stackit-sdk-go/services/dns"
"github.com/stackitcloud/terraform-provider-stackit/stackit/core"
"github.com/stackitcloud/terraform-provider-stackit/stackit/testutil"
)
// Zone resource data
var zoneResource = map[string]string{
"project_id": testutil.ProjectId,
"name": testutil.ResourceNameWithDateTime("zone"),
"dns_name": fmt.Sprintf("www.%s.com", acctest.RandStringFromCharSet(20, acctest.CharSetAlpha)),
"dns_name_min": fmt.Sprintf("www.%s.com", acctest.RandStringFromCharSet(20, acctest.CharSetAlpha)),
"description": "my description",
"acl": "192.168.0.0/24",
"active": "true",
"contact_email": "aa@bb.cc",
"ttl": "12",
"ttl_updated": "4440",
"expire_time": "123456",
"is_reverse_zone": "false",
"negative_cache": "60",
"primaries": "1.2.3.4",
"refresh_time": "500",
"retry_time": "700",
"type": "primary",
}
// Record set resource data
var recordSetResource = map[string]string{
"name": fmt.Sprintf("tf-acc-%s.%s.", acctest.RandStringFromCharSet(5, acctest.CharSetAlpha), zoneResource["dns_name"]),
"name_min": fmt.Sprintf("tf-acc-%s.%s.", acctest.RandStringFromCharSet(5, acctest.CharSetAlpha), zoneResource["dns_name_min"]),
"records": `"1.2.3.4"`,
"records_updated": `"5.6.7.8", "9.10.11.12"`,
"ttl": "3700",
"type": "A",
"active": "true",
"comment": "a comment",
}
func inputConfig(zoneName, ttl, records string) string {
return fmt.Sprintf(`
%s
resource "stackit_dns_zone" "zone" {
project_id = "%s"
name = "%s"
dns_name = "%s"
description = "%s"
acl = "%s"
active = %s
contact_email = "%s"
default_ttl = %s
expire_time = %s
is_reverse_zone = %s
negative_cache = %s
primaries = ["%s"]
refresh_time = %s
retry_time = %s
type = "%s"
}
resource "stackit_dns_record_set" "record_set" {
project_id = stackit_dns_zone.zone.project_id
zone_id = stackit_dns_zone.zone.zone_id
name = "%s"
records = [%s]
type = "%s"
ttl = %s
comment = "%s"
active = %s
}
`,
testutil.DnsProviderConfig(),
zoneResource["project_id"],
zoneName,
zoneResource["dns_name"],
zoneResource["description"],
zoneResource["acl"],
zoneResource["active"],
zoneResource["contact_email"],
ttl,
zoneResource["expire_time"],
zoneResource["is_reverse_zone"],
zoneResource["negative_cache"],
zoneResource["primaries"],
zoneResource["refresh_time"],
zoneResource["retry_time"],
zoneResource["type"],
recordSetResource["name"],
records,
recordSetResource["type"],
recordSetResource["ttl"],
recordSetResource["comment"],
recordSetResource["active"],
)
}
func TestAccDnsResource(t *testing.T) {
resource.ParallelTest(t, resource.TestCase{
ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
CheckDestroy: testAccCheckDnsDestroy,
Steps: []resource.TestStep{
// Creation
{
Config: inputConfig(zoneResource["name"], zoneResource["ttl"], recordSetResource["records"]),
Check: resource.ComposeAggregateTestCheckFunc(
// Zone data
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "project_id", zoneResource["project_id"]),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "zone_id"),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "name", zoneResource["name"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "dns_name", zoneResource["dns_name"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "description", zoneResource["description"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "acl", zoneResource["acl"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "active", zoneResource["active"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "contact_email", zoneResource["contact_email"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "default_ttl", zoneResource["ttl"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "expire_time", zoneResource["expire_time"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "is_reverse_zone", zoneResource["is_reverse_zone"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "negative_cache", zoneResource["negative_cache"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "primaries.#", "1"),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "primaries.0", zoneResource["primaries"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "refresh_time", zoneResource["refresh_time"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "retry_time", zoneResource["retry_time"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "type", zoneResource["type"]),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "primary_name_server"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "serial_number"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "visibility"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "state"),
// Record set data
resource.TestCheckResourceAttrPair(
"stackit_dns_record_set.record_set", "project_id",
"stackit_dns_zone.zone", "project_id",
),
resource.TestCheckResourceAttrPair(
"stackit_dns_record_set.record_set", "zone_id",
"stackit_dns_zone.zone", "zone_id",
),
resource.TestCheckResourceAttrSet("stackit_dns_record_set.record_set", "record_set_id"),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "name", recordSetResource["name"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "records.#", "1"),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "records.0", strings.ReplaceAll(recordSetResource["records"], "\"", "")),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "type", recordSetResource["type"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "ttl", recordSetResource["ttl"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "comment", recordSetResource["comment"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "active", recordSetResource["active"]),
),
},
// Data sources
{
Config: fmt.Sprintf(`
%s
data "stackit_dns_zone" "zone" {
project_id = stackit_dns_zone.zone.project_id
zone_id = stackit_dns_zone.zone.zone_id
}
data "stackit_dns_record_set" "record_set" {
project_id = stackit_dns_zone.zone.project_id
zone_id = stackit_dns_zone.zone.zone_id
record_set_id = stackit_dns_record_set.record_set.record_set_id
}`,
inputConfig(zoneResource["name"], zoneResource["ttl"], recordSetResource["records"]),
),
Check: resource.ComposeAggregateTestCheckFunc(
// Zone data
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "project_id", zoneResource["project_id"]),
resource.TestCheckResourceAttrPair(
"stackit_dns_zone.zone", "zone_id",
"data.stackit_dns_zone.zone", "zone_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_dns_record_set.record_set", "zone_id",
"data.stackit_dns_zone.zone", "zone_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_dns_record_set.record_set", "project_id",
"data.stackit_dns_zone.zone", "project_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_dns_record_set.record_set", "project_id",
"stackit_dns_record_set.record_set", "project_id",
),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "name", zoneResource["name"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "default_ttl", zoneResource["ttl"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "dns_name", zoneResource["dns_name"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "description", zoneResource["description"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "acl", zoneResource["acl"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "active", zoneResource["active"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "contact_email", zoneResource["contact_email"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "default_ttl", zoneResource["ttl"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "expire_time", zoneResource["expire_time"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "is_reverse_zone", zoneResource["is_reverse_zone"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "negative_cache", zoneResource["negative_cache"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "primaries.#", "1"),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "primaries.0", zoneResource["primaries"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "refresh_time", zoneResource["refresh_time"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "retry_time", zoneResource["retry_time"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "type", zoneResource["type"]),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone", "primary_name_server"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone", "serial_number"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone", "visibility"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone", "state"),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone", "record_count", "4"),
// Record set data
resource.TestCheckResourceAttrSet("data.stackit_dns_record_set.record_set", "record_set_id"),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set", "name", recordSetResource["name"]),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set", "records.#", "1"),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set", "type", recordSetResource["type"]),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set", "ttl", recordSetResource["ttl"]),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set", "comment", recordSetResource["comment"]),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set", "active", recordSetResource["active"]),
),
},
// Import
{
ResourceName: "stackit_dns_zone.zone",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_dns_zone.zone"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_dns_zone.recozonerd_set")
}
zoneId, ok := r.Primary.Attributes["zone_id"]
if !ok {
return "", fmt.Errorf("couldn't find attribute zone_id")
}
return fmt.Sprintf("%s,%s", testutil.ProjectId, zoneId), nil
},
ImportState: true,
ImportStateVerify: true,
},
{
ResourceName: "stackit_dns_record_set.record_set",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_dns_record_set.record_set"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_dns_record_set.record_set")
}
zoneId, ok := r.Primary.Attributes["zone_id"]
if !ok {
return "", fmt.Errorf("couldn't find attribute zone_id")
}
recordSetId, ok := r.Primary.Attributes["record_set_id"]
if !ok {
return "", fmt.Errorf("couldn't find attribute record_set_id")
}
return fmt.Sprintf("%s,%s,%s", testutil.ProjectId, zoneId, recordSetId), nil
},
ImportState: true,
ImportStateVerify: true,
},
// Update. The zone ttl should not be updated according to the DNS API.
{
Config: inputConfig(zoneResource["name"], zoneResource["ttl"], recordSetResource["records_updated"]),
Check: resource.ComposeAggregateTestCheckFunc(
// Zone data
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "project_id", zoneResource["project_id"]),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "zone_id"),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "name", zoneResource["name"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "dns_name", zoneResource["dns_name"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "description", zoneResource["description"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "acl", zoneResource["acl"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "active", zoneResource["active"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "contact_email", zoneResource["contact_email"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "default_ttl", zoneResource["ttl"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "expire_time", zoneResource["expire_time"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "is_reverse_zone", zoneResource["is_reverse_zone"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "negative_cache", zoneResource["negative_cache"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "primaries.#", "1"),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "primaries.0", zoneResource["primaries"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "refresh_time", zoneResource["refresh_time"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "retry_time", zoneResource["retry_time"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone", "type", zoneResource["type"]),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "primary_name_server"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "serial_number"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "visibility"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone", "state"),
// Record set data
resource.TestCheckResourceAttrPair(
"stackit_dns_record_set.record_set", "project_id",
"stackit_dns_zone.zone", "project_id",
),
resource.TestCheckResourceAttrPair(
"stackit_dns_record_set.record_set", "zone_id",
"stackit_dns_zone.zone", "zone_id",
),
resource.TestCheckResourceAttrSet("stackit_dns_record_set.record_set", "record_set_id"),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "name", recordSetResource["name"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "records.#", "2"),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "type", recordSetResource["type"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "ttl", recordSetResource["ttl"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "comment", recordSetResource["comment"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set", "active", recordSetResource["active"]),
),
},
// Deletion is done by the framework implicitly
},
})
}
func inputConfigMinimal() string {
return fmt.Sprintf(`
%s
resource "stackit_dns_zone" "zone_min" {
project_id = "%s"
name = "%s"
dns_name = "%s"
contact_email = "%s"
type = "%s"
acl = "%s"
}
resource "stackit_dns_record_set" "record_set_min" {
project_id = stackit_dns_zone.zone_min.project_id
zone_id = stackit_dns_zone.zone_min.zone_id
name = "%s"
records = [%s]
type = "%s"
}
`,
testutil.DnsProviderConfig(),
zoneResource["project_id"],
zoneResource["name"],
zoneResource["dns_name_min"],
zoneResource["contact_email"],
zoneResource["type"],
zoneResource["acl"],
recordSetResource["name_min"],
recordSetResource["records"],
recordSetResource["type"],
)
}
func TestAccDnsMinimalResource(t *testing.T) {
resource.ParallelTest(t, resource.TestCase{
ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
CheckDestroy: testAccCheckDnsDestroy,
Steps: []resource.TestStep{
// Creation
{
Config: inputConfigMinimal(),
Check: resource.ComposeAggregateTestCheckFunc(
// Zone
resource.TestCheckResourceAttr("stackit_dns_zone.zone_min", "project_id", zoneResource["project_id"]),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "zone_id"),
resource.TestCheckResourceAttr("stackit_dns_zone.zone_min", "name", zoneResource["name"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone_min", "dns_name", zoneResource["dns_name_min"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone_min", "contact_email", zoneResource["contact_email"]),
resource.TestCheckResourceAttr("stackit_dns_zone.zone_min", "type", zoneResource["type"]),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "acl"),
resource.TestCheckResourceAttr("stackit_dns_zone.zone_min", "active", "true"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "default_ttl"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "expire_time"),
resource.TestCheckResourceAttr("stackit_dns_zone.zone_min", "is_reverse_zone", "false"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "negative_cache"),
resource.TestCheckResourceAttr("stackit_dns_zone.zone_min", "primaries.#", "1"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "refresh_time"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "retry_time"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "primary_name_server"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "serial_number"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "visibility"),
resource.TestCheckResourceAttrSet("stackit_dns_zone.zone_min", "state"),
// Record set
resource.TestCheckResourceAttrPair(
"stackit_dns_record_set.record_set_min", "project_id",
"stackit_dns_zone.zone_min", "project_id",
),
resource.TestCheckResourceAttrPair(
"stackit_dns_record_set.record_set_min", "zone_id",
"stackit_dns_zone.zone_min", "zone_id",
),
resource.TestCheckResourceAttrSet("stackit_dns_record_set.record_set_min", "record_set_id"),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set_min", "name", recordSetResource["name_min"]),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set_min", "records.#", "1"),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set_min", "records.0", strings.ReplaceAll(recordSetResource["records"], "\"", "")),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set_min", "type", recordSetResource["type"]),
resource.TestCheckResourceAttrSet("stackit_dns_record_set.record_set_min", "ttl"),
resource.TestCheckNoResourceAttr("stackit_dns_record_set.record_set_min", "comment"),
resource.TestCheckResourceAttr("stackit_dns_record_set.record_set_min", "active", "true"),
),
},
// Data sources
{
Config: fmt.Sprintf(`
%s
data "stackit_dns_zone" "zone_min" {
project_id = stackit_dns_zone.zone_min.project_id
zone_id = stackit_dns_zone.zone_min.zone_id
}
data "stackit_dns_record_set" "record_set_min" {
project_id = stackit_dns_zone.zone_min.project_id
zone_id = stackit_dns_zone.zone_min.zone_id
record_set_id = stackit_dns_record_set.record_set_min.record_set_id
}`,
inputConfigMinimal(),
),
Check: resource.ComposeAggregateTestCheckFunc(
// Zone data
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "project_id", zoneResource["project_id"]),
resource.TestCheckResourceAttrPair(
"stackit_dns_zone.zone_min", "zone_id",
"data.stackit_dns_zone.zone_min", "zone_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_dns_record_set.record_set_min", "zone_id",
"data.stackit_dns_zone.zone_min", "zone_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_dns_record_set.record_set_min", "project_id",
"data.stackit_dns_zone.zone_min", "project_id",
),
resource.TestCheckResourceAttrPair(
"data.stackit_dns_record_set.record_set_min", "project_id",
"stackit_dns_record_set.record_set_min", "project_id",
),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "project_id", zoneResource["project_id"]),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone_min", "zone_id"),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "name", zoneResource["name"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "dns_name", zoneResource["dns_name_min"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "contact_email", zoneResource["contact_email"]),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "type", zoneResource["type"]),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone_min", "acl"),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "active", "true"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone_min", "default_ttl"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone_min", "expire_time"),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "is_reverse_zone", "false"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone_min", "negative_cache"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone_min", "primary_name_server"),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "primaries.#", "1"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone_min", "refresh_time"),
resource.TestCheckResourceAttrSet("data.stackit_dns_zone.zone_min", "retry_time"),
resource.TestCheckResourceAttr("data.stackit_dns_zone.zone_min", "record_count", "4"),
// Record set data
resource.TestCheckResourceAttrSet("data.stackit_dns_record_set.record_set_min", "record_set_id"),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set_min", "name", recordSetResource["name_min"]),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set_min", "records.#", "1"),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set_min", "records.0", strings.ReplaceAll(recordSetResource["records"], "\"", "")),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set_min", "type", recordSetResource["type"]),
resource.TestCheckResourceAttrSet("data.stackit_dns_record_set.record_set_min", "ttl"),
resource.TestCheckNoResourceAttr("data.stackit_dns_record_set.record_set_min", "comment"),
resource.TestCheckResourceAttr("data.stackit_dns_record_set.record_set_min", "active", "true"),
),
},
// Import
{
ResourceName: "stackit_dns_zone.zone_min",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_dns_zone.zone_min"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_dns_zone.zone_min")
}
zoneId, ok := r.Primary.Attributes["zone_id"]
if !ok {
return "", fmt.Errorf("couldn't find attribute zone_id")
}
return fmt.Sprintf("%s,%s", testutil.ProjectId, zoneId), nil
},
ImportState: true,
ImportStateVerify: true,
},
{
ResourceName: "stackit_dns_record_set.record_set_min",
ImportStateIdFunc: func(s *terraform.State) (string, error) {
r, ok := s.RootModule().Resources["stackit_dns_record_set.record_set_min"]
if !ok {
return "", fmt.Errorf("couldn't find resource stackit_dns_record_set.record_set_min")
}
zoneId, ok := r.Primary.Attributes["zone_id"]
if !ok {
return "", fmt.Errorf("couldn't find attribute zone_id")
}
recordSetId, ok := r.Primary.Attributes["record_set_id"]
if !ok {
return "", fmt.Errorf("couldn't find attribute record_set_id")
}
return fmt.Sprintf("%s,%s,%s", testutil.ProjectId, zoneId, recordSetId), nil
},
ImportState: true,
ImportStateVerify: true,
},
// Deletion is done by the framework implicitly
},
})
}
func testAccCheckDnsDestroy(s *terraform.State) error {
ctx := context.Background()
var client *dns.APIClient
var err error
if testutil.DnsCustomEndpoint == "" {
client, err = dns.NewAPIClient()
} else {
client, err = dns.NewAPIClient(
config.WithEndpoint(testutil.DnsCustomEndpoint),
)
}
if err != nil {
return fmt.Errorf("creating client: %w", err)
}
zonesToDestroy := []string{}
for _, rs := range s.RootModule().Resources {
if rs.Type != "stackit_dns_zone" {
continue
}
// zone terraform ID: "[projectId],[zoneId]"
zoneId := strings.Split(rs.Primary.ID, core.Separator)[1]
zonesToDestroy = append(zonesToDestroy, zoneId)
}
zonesResp, err := client.GetZones(ctx, testutil.ProjectId).ActiveEq(true).Execute()
if err != nil {
return fmt.Errorf("getting zonesResp: %w", err)
}
zones := *zonesResp.Zones
for i := range zones {
id := *zones[i].Id
if utils.Contains(zonesToDestroy, id) {
_, err := client.DeleteZoneExecute(ctx, testutil.ProjectId, id)
if err != nil {
return fmt.Errorf("destroying zone %s during CheckDestroy: %w", *zones[i].Id, err)
}
_, err = dns.DeleteZoneWaitHandler(ctx, client, testutil.ProjectId, id).WaitWithContext(ctx)
if err != nil {
return fmt.Errorf("destroying zone %s during CheckDestroy: waiting for deletion %w", *zones[i].Id, err)
}
}
}
return nil
}

174
stackit/services/dns/recordset/datasource.go Normal file
View file

@ -0,0 +1,174 @@
package dns
import (
"context"
"fmt"
"github.com/hashicorp/terraform-plugin-framework/datasource"
"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
"github.com/hashicorp/terraform-plugin-framework/schema/validator"
"github.com/hashicorp/terraform-plugin-framework/types"
"github.com/hashicorp/terraform-plugin-log/tflog"
"github.com/stackitcloud/stackit-sdk-go/core/config"
"github.com/stackitcloud/stackit-sdk-go/services/dns"
"github.com/stackitcloud/terraform-provider-stackit/stackit/core"
"github.com/stackitcloud/terraform-provider-stackit/stackit/validate"
)
// Ensure the implementation satisfies the expected interfaces.
var (
_ datasource.DataSource = &recordSetDataSource{}
)
// NewRecordSetDataSource NewZoneDataSource is a helper function to simplify the provider implementation.
func NewRecordSetDataSource() datasource.DataSource {
return &recordSetDataSource{}
}
// recordSetDataSource is the data source implementation.
type recordSetDataSource struct {
client *dns.APIClient
}
// Metadata returns the data source type name.
func (d *recordSetDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
resp.TypeName = req.ProviderTypeName + "_dns_record_set"
}
// Configure adds the provider configured client to the resource.
func (d *recordSetDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
// Prevent panic if the provider has not been configured.
if req.ProviderData == nil {
return
}
providerData, ok := req.ProviderData.(core.ProviderData)
if !ok {
resp.Diagnostics.AddError("Unexpected Data Source Configure Type", fmt.Sprintf("Expected stackit.ProviderData, got %T. Please report this issue to the provider developers.", req.ProviderData))
return
}
var apiClient *dns.APIClient
var err error
if providerData.DnsCustomEndpoint != "" {
apiClient, err = dns.NewAPIClient(
config.WithCustomAuth(providerData.RoundTripper),
config.WithEndpoint(providerData.DnsCustomEndpoint),
)
} else {
apiClient, err = dns.NewAPIClient(
config.WithCustomAuth(providerData.RoundTripper),
)
}
if err != nil {
resp.Diagnostics.AddError("Could not Configure API Client", err.Error())
return
}
tflog.Info(ctx, "DNS record set client configured")
d.client = apiClient
}
// Schema defines the schema for the data source.
func (d *recordSetDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
resp.Schema = schema.Schema{
Description: "DNS Record Set Resource schema.",
Attributes: map[string]schema.Attribute{
"id": schema.StringAttribute{
Description: "Terraform's internal resource ID.",
Computed: true,
},
"project_id": schema.StringAttribute{
Description: "STACKIT project ID to which the dns record set is associated.",
Required: true,
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"zone_id": schema.StringAttribute{
Description: "The zone ID to which is dns record set is associated.",
Required: true,
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"record_set_id": schema.StringAttribute{
Description: "The rr set id.",
Required: true,
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"name": schema.StringAttribute{
Description: "Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com`",
Computed: true,
},
"records": schema.ListAttribute{
Description: "Records.",
Computed: true,
ElementType: types.StringType,
},
"ttl": schema.Int64Attribute{
Description: "Time to live. E.g. 3600",
Computed: true,
},
"type": schema.StringAttribute{
Description: "The record set type. E.g. `A` or `CNAME`",
Computed: true,
},
"active": schema.BoolAttribute{
Description: "Specifies if the record set is active or not.",
Computed: true,
},
"comment": schema.StringAttribute{
Description: "Comment.",
Computed: true,
},
"error": schema.StringAttribute{
Description: "Error shows error in case create/update/delete failed.",
Computed: true,
},
"state": schema.StringAttribute{
Description: "Record set state.",
Computed: true,
},
},
}
}
// Read refreshes the Terraform state with the latest data.
func (d *recordSetDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
var state Model
diags := req.Config.Get(ctx, &state)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := state.ProjectId.ValueString()
zoneId := state.ZoneId.ValueString()
recordSetId := state.RecordSetId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
ctx = tflog.SetField(ctx, "record_set_id", recordSetId)
zoneResp, err := d.client.GetRecordSet(ctx, projectId, zoneId, recordSetId).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Unable to Read record set", err.Error())
return
}
err = mapFields(zoneResp, &state)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Mapping fields", err.Error())
return
}
diags = resp.State.Set(ctx, state)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
tflog.Info(ctx, "DNS record set created")
}

497
stackit/services/dns/recordset/resource.go Normal file
View file

@ -0,0 +1,497 @@
package dns
import (
"context"
"fmt"
"strings"
"time"
"github.com/hashicorp/terraform-plugin-framework-validators/int64validator"
"github.com/hashicorp/terraform-plugin-framework-validators/listvalidator"
"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
"github.com/hashicorp/terraform-plugin-framework/attr"
"github.com/hashicorp/terraform-plugin-framework/path"
"github.com/hashicorp/terraform-plugin-framework/resource"
"github.com/hashicorp/terraform-plugin-framework/resource/schema"
"github.com/hashicorp/terraform-plugin-framework/resource/schema/booldefault"
"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
"github.com/hashicorp/terraform-plugin-framework/schema/validator"
"github.com/hashicorp/terraform-plugin-framework/types"
"github.com/hashicorp/terraform-plugin-log/tflog"
"github.com/stackitcloud/stackit-sdk-go/core/config"
"github.com/stackitcloud/stackit-sdk-go/services/dns"
"github.com/stackitcloud/terraform-provider-stackit/stackit/conversion"
"github.com/stackitcloud/terraform-provider-stackit/stackit/core"
"github.com/stackitcloud/terraform-provider-stackit/stackit/validate"
)
// Ensure the implementation satisfies the expected interfaces.
var (
_ resource.Resource = &recordSetResource{}
_ resource.ResourceWithConfigure = &recordSetResource{}
_ resource.ResourceWithImportState = &recordSetResource{}
)
type Model struct {
Id types.String `tfsdk:"id"` // needed by TF
RecordSetId types.String `tfsdk:"record_set_id"`
ZoneId types.String `tfsdk:"zone_id"`
ProjectId types.String `tfsdk:"project_id"`
Active types.Bool `tfsdk:"active"`
Comment types.String `tfsdk:"comment"`
Name types.String `tfsdk:"name"`
Records types.List `tfsdk:"records"`
TTL types.Int64 `tfsdk:"ttl"`
Type types.String `tfsdk:"type"`
Error types.String `tfsdk:"error"`
State types.String `tfsdk:"state"`
}
// NewRecordSetResource is a helper function to simplify the provider implementation.
func NewRecordSetResource() resource.Resource {
return &recordSetResource{}
}
// recordSetResource is the resource implementation.
type recordSetResource struct {
client *dns.APIClient
}
// Metadata returns the resource type name.
func (r *recordSetResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
resp.TypeName = req.ProviderTypeName + "_dns_record_set"
}
// Configure adds the provider configured client to the resource.
func (r *recordSetResource) Configure(ctx context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
// Prevent panic if the provider has not been configured.
if req.ProviderData == nil {
return
}
providerData, ok := req.ProviderData.(core.ProviderData)
if !ok {
resp.Diagnostics.AddError("Unexpected Resource Configure Type", fmt.Sprintf("Expected stackit.ProviderData, got %T. Please report this issue to the provider developers.", req.ProviderData))
return
}
var apiClient *dns.APIClient
var err error
if providerData.DnsCustomEndpoint != "" {
apiClient, err = dns.NewAPIClient(
config.WithCustomAuth(providerData.RoundTripper),
config.WithEndpoint(providerData.DnsCustomEndpoint),
)
} else {
apiClient, err = dns.NewAPIClient(
config.WithCustomAuth(providerData.RoundTripper),
)
}
if err != nil {
resp.Diagnostics.AddError("Could not Configure API Client", err.Error())
return
}
tflog.Debug(ctx, "DNS record set client configured")
r.client = apiClient
}
// Schema defines the schema for the resource.
func (r *recordSetResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
resp.Schema = schema.Schema{
Description: "DNS Record Set Resource schema.",
Attributes: map[string]schema.Attribute{
"id": schema.StringAttribute{
Description: "Terraform's internal resource ID.",
Computed: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.UseStateForUnknown(),
},
},
"project_id": schema.StringAttribute{
Description: "STACKIT project ID to which the dns record set is associated.",
Required: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.RequiresReplace(),
},
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"zone_id": schema.StringAttribute{
Description: "The zone ID to which is dns record set is associated.",
Required: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.RequiresReplace(),
},
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"record_set_id": schema.StringAttribute{
Description: "The rr set id.",
Computed: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.UseStateForUnknown(),
},
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"name": schema.StringAttribute{
Description: "Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com`",
Required: true,
Validators: []validator.String{
stringvalidator.LengthAtLeast(1),
stringvalidator.LengthAtMost(63),
},
},
"records": schema.ListAttribute{
Description: "Records.",
ElementType: types.StringType,
Required: true,
Validators: []validator.List{
listvalidator.SizeAtLeast(1),
listvalidator.UniqueValues(),
listvalidator.ValueStringsAre(validate.IP()),
},
},
"ttl": schema.Int64Attribute{
Description: "Time to live. E.g. 3600",
Optional: true,
Computed: true,
Validators: []validator.Int64{
int64validator.AtLeast(30),
int64validator.AtMost(99999999),
},
},
"type": schema.StringAttribute{
Description: "The record set type. E.g. `A` or `CNAME`",
Optional: true,
Computed: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.UseStateForUnknown(),
},
},
"active": schema.BoolAttribute{
Description: "Specifies if the record set is active or not.",
Optional: true,
Computed: true,
Default: booldefault.StaticBool(true),
},
"comment": schema.StringAttribute{
Description: "Comment.",
Optional: true,
Computed: true,
Validators: []validator.String{
stringvalidator.LengthAtMost(255),
},
},
"error": schema.StringAttribute{
Description: "Error shows error in case create/update/delete failed.",
Computed: true,
Validators: []validator.String{
stringvalidator.LengthAtMost(2000),
},
},
"state": schema.StringAttribute{
Description: "Record set state.",
Computed: true,
},
},
}
}
// Create creates the resource and sets the initial Terraform state.
func (r *recordSetResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) { // nolint:gocritic // function signature required by Terraform
// Retrieve values from plan
var model Model
diags := req.Plan.Get(ctx, &model)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := model.ProjectId.ValueString()
zoneId := model.ZoneId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
// Generate API request body from model
payload, err := toCreatePayload(&model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating recordset", fmt.Sprintf("Creating API payload: %v", err))
return
}
// Create new recordset
recordSetResp, err := r.client.CreateRecordSet(ctx, projectId, zoneId).CreateRecordSetPayload(*payload).Execute()
if err != nil || recordSetResp.Rrset == nil || recordSetResp.Rrset.Id == nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating recordset", fmt.Sprintf("Calling API: %v", err))
return
}
ctx = tflog.SetField(ctx, "record_set_id", *recordSetResp.Rrset.Id)
wr, err := dns.CreateRecordSetWaitHandler(ctx, r.client, projectId, zoneId, *recordSetResp.Rrset.Id).SetTimeout(1 * time.Minute).WaitWithContext(ctx)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating recordset", fmt.Sprintf("Instance creation waiting: %v", err))
return
}
got, ok := wr.(*dns.RecordSetResponse)
if !ok {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating recordset", fmt.Sprintf("Wait result conversion, got %+v", got))
return
}
// Map response body to schema and populate Computed attribute values
err = mapFields(got, &model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error mapping fields", err.Error())
return
}
// Set state to fully populated data
diags = resp.State.Set(ctx, model)
resp.Diagnostics.Append(diags...)
tflog.Info(ctx, "DNS record set created")
}
// Read refreshes the Terraform state with the latest data.
func (r *recordSetResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
var model Model
diags := req.State.Get(ctx, &model)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := model.ProjectId.ValueString()
zoneId := model.ZoneId.ValueString()
recordSetId := model.RecordSetId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
ctx = tflog.SetField(ctx, "record_set_id", recordSetId)
recordSetResp, err := r.client.GetRecordSet(ctx, projectId, zoneId, recordSetId).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading zones", err.Error())
return
}
// Map response body to schema and populate Computed attribute values
err = mapFields(recordSetResp, &model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error mapping fields", err.Error())
return
}
// Set refreshed state
diags = resp.State.Set(ctx, model)
resp.Diagnostics.Append(diags...)
tflog.Info(ctx, "DNS record set read")
}
// Update updates the resource and sets the updated Terraform state on success.
func (r *recordSetResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) { // nolint:gocritic // function signature required by Terraform
// Retrieve values from plan
var model Model
diags := req.Plan.Get(ctx, &model)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := model.ProjectId.ValueString()
zoneId := model.ZoneId.ValueString()
recordSetId := model.RecordSetId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
ctx = tflog.SetField(ctx, "record_set_id", recordSetId)
// Generate API request body from model
payload, err := toUpdatePayload(&model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating recordset", fmt.Sprintf("Could not create API payload: %v", err))
return
}
// Update recordset
_, err = r.client.UpdateRecordSet(ctx, projectId, zoneId, recordSetId).UpdateRecordSetPayload(*payload).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating recordset", err.Error())
return
}
wr, err := dns.UpdateRecordSetWaitHandler(ctx, r.client, projectId, zoneId, recordSetId).SetTimeout(1 * time.Minute).WaitWithContext(ctx)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating recordset", fmt.Sprintf("Instance update waiting: %v", err))
return
}
got, ok := wr.(*dns.RecordSetResponse)
if !ok {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating recordset", fmt.Sprintf("Wait result conversion, got %+v", got))
return
}
// Fetch updated record set
recordSetResp, err := r.client.GetRecordSet(ctx, projectId, zoneId, recordSetId).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading updated data", err.Error())
return
}
err = mapFields(recordSetResp, &model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error mapping fields in update", err.Error())
return
}
diags = resp.State.Set(ctx, model)
resp.Diagnostics.Append(diags...)
tflog.Info(ctx, "DNS record set updated")
}
// Delete deletes the resource and removes the Terraform state on success.
func (r *recordSetResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) { // nolint:gocritic // function signature required by Terraform
// Retrieve values from plan
var model Model
diags := req.State.Get(ctx, &model)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := model.ProjectId.ValueString()
zoneId := model.ZoneId.ValueString()
recordSetId := model.RecordSetId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
ctx = tflog.SetField(ctx, "record_set_id", recordSetId)
// Delete existing record set
_, err := r.client.DeleteRecordSet(ctx, projectId, zoneId, recordSetId).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting recordset", err.Error())
}
_, err = dns.DeleteRecordSetWaitHandler(ctx, r.client, projectId, zoneId, recordSetId).SetTimeout(1 * time.Minute).WaitWithContext(ctx)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting record set", fmt.Sprintf("Instance deletion waiting: %v", err))
return
}
tflog.Info(ctx, "DNS record set deleted")
}
// ImportState imports a resource into the Terraform state on success.
// The expected format of the resource import identifier is: project_id,zone_id,record_set_id
func (r *recordSetResource) ImportState(ctx context.Context, req resource.ImportStateRequest, resp *resource.ImportStateResponse) {
idParts := strings.Split(req.ID, core.Separator)
if len(idParts) != 3 || idParts[0] == "" || idParts[1] == "" || idParts[2] == "" {
resp.Diagnostics.AddError(
"Unexpected Import Identifier",
fmt.Sprintf("Expected import identifier with format [project_id],[zone_id],[record_set_id], got %q", req.ID),
)
return
}
resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("project_id"), idParts[0])...)
resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("zone_id"), idParts[1])...)
resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("record_set_id"), idParts[2])...)
tflog.Info(ctx, "DNS record set state imported")
}
func mapFields(recordSetResp *dns.RecordSetResponse, model *Model) error {
if recordSetResp == nil || recordSetResp.Rrset == nil {
return fmt.Errorf("response input is nil")
}
if model == nil {
return fmt.Errorf("model input is nil")
}
recordSet := recordSetResp.Rrset
var recordSetId string
if model.RecordSetId.ValueString() != "" {
recordSetId = model.RecordSetId.ValueString()
} else if recordSet.Id != nil {
recordSetId = *recordSet.Id
} else {
return fmt.Errorf("record set id not present")
}
if recordSet.Records == nil {
model.Records = types.ListNull(types.StringType)
} else {
records := []attr.Value{}
for _, record := range *recordSet.Records {
records = append(records, types.StringPointerValue(record.Content))
}
recordsList, diags := types.ListValue(types.StringType, records)
if diags.HasError() {
return fmt.Errorf("failed to map records: %w", core.DiagsToError(diags))
}
model.Records = recordsList
}
idParts := []string{
model.ProjectId.ValueString(),
model.ZoneId.ValueString(),
recordSetId,
}
model.Id = types.StringValue(
strings.Join(idParts, core.Separator),
)
model.RecordSetId = types.StringPointerValue(recordSet.Id)
model.Active = types.BoolPointerValue(recordSet.Active)
model.Comment = types.StringPointerValue(recordSet.Comment)
model.Error = types.StringPointerValue(recordSet.Error)
model.Name = types.StringPointerValue(recordSet.Name)
model.State = types.StringPointerValue(recordSet.State)
model.TTL = conversion.ToTypeInt64(recordSet.Ttl)
model.Type = types.StringPointerValue(recordSet.Type)
return nil
}
func toCreatePayload(model *Model) (*dns.CreateRecordSetPayload, error) {
if model == nil {
return nil, fmt.Errorf("nil model")
}
records := []dns.RecordPayload{}
for i, record := range model.Records.Elements() {
recordString, ok := record.(types.String)
if !ok {
return nil, fmt.Errorf("expected record at index %d to be of type %T, got %T", i, types.String{}, record)
}
records = append(records, dns.RecordPayload{
Content: recordString.ValueStringPointer(),
})
}
return &dns.CreateRecordSetPayload{
Comment: model.Comment.ValueStringPointer(),
Name: model.Name.ValueStringPointer(),
Records: &records,
Ttl: conversion.ToPtrInt32(model.TTL),
Type: model.Type.ValueStringPointer(),
}, nil
}
func toUpdatePayload(model *Model) (*dns.UpdateRecordSetPayload, error) {
if model == nil {
return nil, fmt.Errorf("nil model")
}
records := []dns.RecordPayload{}
for i, record := range model.Records.Elements() {
recordString, ok := record.(types.String)
if !ok {
return nil, fmt.Errorf("expected record at index %d to be of type %T, got %T", i, types.String{}, record)
}
records = append(records, dns.RecordPayload{
Content: recordString.ValueStringPointer(),
})
}
return &dns.UpdateRecordSetPayload{
Comment: model.Comment.ValueStringPointer(),
Name: model.Name.ValueStringPointer(),
Records: &records,
Ttl: conversion.ToPtrInt32(model.TTL),
}, nil
}

307
stackit/services/dns/recordset/resource_test.go Normal file
View file

@ -0,0 +1,307 @@
package dns
import (
"testing"
"github.com/google/go-cmp/cmp"
"github.com/hashicorp/terraform-plugin-framework/attr"
"github.com/hashicorp/terraform-plugin-framework/types"
"github.com/stackitcloud/stackit-sdk-go/core/utils"
"github.com/stackitcloud/stackit-sdk-go/services/dns"
)
func TestMapFields(t *testing.T) {
tests := []struct {
description string
input *dns.RecordSetResponse
expected Model
isValid bool
}{
{
"default_values",
&dns.RecordSetResponse{
Rrset: &dns.RecordSet{
Id: utils.Ptr("rid"),
},
},
Model{
Id: types.StringValue("pid,zid,rid"),
RecordSetId: types.StringValue("rid"),
ZoneId: types.StringValue("zid"),
ProjectId: types.StringValue("pid"),
Active: types.BoolNull(),
Comment: types.StringNull(),
Error: types.StringNull(),
Name: types.StringNull(),
Records: types.ListNull(types.StringType),
State: types.StringNull(),
TTL: types.Int64Null(),
Type: types.StringNull(),
},
true,
},
{
"simple_values",
&dns.RecordSetResponse{
Rrset: &dns.RecordSet{
Id: utils.Ptr("rid"),
Active: utils.Ptr(true),
Comment: utils.Ptr("comment"),
Error: utils.Ptr("error"),
Name: utils.Ptr("name"),
Records: &[]dns.Record{
{Content: utils.Ptr("record_1")},
{Content: utils.Ptr("record_2")},
},
State: utils.Ptr("state"),
Ttl: utils.Ptr(int32(1)),
Type: utils.Ptr("type"),
},
},
Model{
Id: types.StringValue("pid,zid,rid"),
RecordSetId: types.StringValue("rid"),
ZoneId: types.StringValue("zid"),
ProjectId: types.StringValue("pid"),
Active: types.BoolValue(true),
Comment: types.StringValue("comment"),
Error: types.StringValue("error"),
Name: types.StringValue("name"),
Records: types.ListValueMust(types.StringType, []attr.Value{
types.StringValue("record_1"),
types.StringValue("record_2"),
}),
State: types.StringValue("state"),
TTL: types.Int64Value(1),
Type: types.StringValue("type"),
},
true,
},
{
"null_fields_and_int_conversions",
&dns.RecordSetResponse{
Rrset: &dns.RecordSet{
Id: utils.Ptr("rid"),
Active: nil,
Comment: nil,
Error: nil,
Name: utils.Ptr("name"),
Records: nil,
State: utils.Ptr("state"),
Ttl: utils.Ptr(int32(2123456789)),
Type: utils.Ptr("type"),
},
},
Model{
Id: types.StringValue("pid,zid,rid"),
RecordSetId: types.StringValue("rid"),
ZoneId: types.StringValue("zid"),
ProjectId: types.StringValue("pid"),
Active: types.BoolNull(),
Comment: types.StringNull(),
Error: types.StringNull(),
Name: types.StringValue("name"),
Records: types.ListNull(types.StringType),
State: types.StringValue("state"),
TTL: types.Int64Value(2123456789),
Type: types.StringValue("type"),
},
true,
},
{
"nil_response",
nil,
Model{},
false,
},
{
"no_resource_id",
&dns.RecordSetResponse{},
Model{},
false,
},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
state := &Model{
ProjectId: tt.expected.ProjectId,
ZoneId: tt.expected.ZoneId,
}
err := mapFields(tt.input, state)
if !tt.isValid && err == nil {
t.Fatalf("Should have failed")
}
if tt.isValid && err != nil {
t.Fatalf("Should not have failed: %v", err)
}
if tt.isValid {
diff := cmp.Diff(state, &tt.expected)
if diff != "" {
t.Fatalf("Data does not match: %s", diff)
}
}
})
}
}
func TestToCreatePayload(t *testing.T) {
tests := []struct {
description string
input *Model
expected *dns.CreateRecordSetPayload
isValid bool
}{
{
"default values",
&Model{},
&dns.CreateRecordSetPayload{
Records: &[]dns.RecordPayload{},
},
true,
},
{
"simple_values",
&Model{
Comment: types.StringValue("comment"),
Name: types.StringValue("name"),
Records: types.ListValueMust(types.StringType, []attr.Value{
types.StringValue("record_1"),
types.StringValue("record_2"),
}),
TTL: types.Int64Value(1),
Type: types.StringValue("type"),
},
&dns.CreateRecordSetPayload{
Comment: utils.Ptr("comment"),
Name: utils.Ptr("name"),
Records: &[]dns.RecordPayload{
{Content: utils.Ptr("record_1")},
{Content: utils.Ptr("record_2")},
},
Ttl: utils.Ptr(int32(1)),
Type: utils.Ptr("type"),
},
true,
},
{
"null_fields_and_int_conversions",
&Model{
Comment: types.StringNull(),
Name: types.StringValue(""),
Records: types.ListValueMust(types.StringType, nil),
TTL: types.Int64Value(2123456789),
Type: types.StringValue(""),
},
&dns.CreateRecordSetPayload{
Comment: nil,
Name: utils.Ptr(""),
Records: &[]dns.RecordPayload{},
Ttl: utils.Ptr(int32(2123456789)),
Type: utils.Ptr(""),
},
true,
},
{
"nil_model",
nil,
nil,
false,
},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
output, err := toCreatePayload(tt.input)
if !tt.isValid && err == nil {
t.Fatalf("Should have failed")
}
if tt.isValid && err != nil {
t.Fatalf("Should not have failed: %v", err)
}
if tt.isValid {
diff := cmp.Diff(output, tt.expected)
if diff != "" {
t.Fatalf("Data does not match: %s", diff)
}
}
})
}
}
func TestToUpdatePayload(t *testing.T) {
tests := []struct {
description string
input *Model
expected *dns.UpdateRecordSetPayload
isValid bool
}{
{
"default_values",
&Model{},
&dns.UpdateRecordSetPayload{
Records: &[]dns.RecordPayload{},
},
true,
},
{
"simple_values",
&Model{
Comment: types.StringValue("comment"),
Name: types.StringValue("name"),
Records: types.ListValueMust(types.StringType, []attr.Value{
types.StringValue("record_1"),
types.StringValue("record_2"),
}),
TTL: types.Int64Value(1),
},
&dns.UpdateRecordSetPayload{
Comment: utils.Ptr("comment"),
Name: utils.Ptr("name"),
Records: &[]dns.RecordPayload{
{Content: utils.Ptr("record_1")},
{Content: utils.Ptr("record_2")},
},
Ttl: utils.Ptr(int32(1)),
},
true,
},
{
"null_fields_and_int_conversions",
&Model{
Comment: types.StringNull(),
Name: types.StringValue(""),
Records: types.ListValueMust(types.StringType, nil),
TTL: types.Int64Value(2123456789),
},
&dns.UpdateRecordSetPayload{
Comment: nil,
Name: utils.Ptr(""),
Records: &[]dns.RecordPayload{},
Ttl: utils.Ptr(int32(2123456789)),
},
true,
},
{
"nil_model",
nil,
nil,
false,
},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
output, err := toUpdatePayload(tt.input)
if !tt.isValid && err == nil {
t.Fatalf("Should have failed")
}
if tt.isValid && err != nil {
t.Fatalf("Should not have failed: %v", err)
}
if tt.isValid {
diff := cmp.Diff(output, tt.expected)
if diff != "" {
t.Fatalf("Data does not match: %s", diff)
}
}
})
}
}

211
stackit/services/dns/zone/datasource.go Normal file
View file

@ -0,0 +1,211 @@
package dns
import (
"context"
"fmt"
"github.com/hashicorp/terraform-plugin-framework/datasource"
"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
"github.com/hashicorp/terraform-plugin-framework/schema/validator"
"github.com/hashicorp/terraform-plugin-framework/types"
"github.com/hashicorp/terraform-plugin-log/tflog"
"github.com/stackitcloud/stackit-sdk-go/core/config"
"github.com/stackitcloud/stackit-sdk-go/services/dns"
"github.com/stackitcloud/terraform-provider-stackit/stackit/core"
"github.com/stackitcloud/terraform-provider-stackit/stackit/validate"
)
// Ensure the implementation satisfies the expected interfaces.
var (
_ datasource.DataSource = &zoneDataSource{}
)
// NewZoneDataSource is a helper function to simplify the provider implementation.
func NewZoneDataSource() datasource.DataSource {
return &zoneDataSource{}
}
// zoneDataSource is the data source implementation.
type zoneDataSource struct {
client *dns.APIClient
}
// Metadata returns the data source type name.
func (d *zoneDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
resp.TypeName = req.ProviderTypeName + "_dns_zone"
}
func (d *zoneDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
// Prevent panic if the provider has not been configured.
if req.ProviderData == nil {
return
}
var apiClient *dns.APIClient
var err error
providerData, ok := req.ProviderData.(core.ProviderData)
if !ok {
resp.Diagnostics.AddError("Unexpected Data Source Configure Type", fmt.Sprintf("Expected stackit.ProviderData, got %T. Please report this issue to the provider developers.", req.ProviderData))
return
}
if providerData.DnsCustomEndpoint != "" {
apiClient, err = dns.NewAPIClient(
config.WithCustomAuth(providerData.RoundTripper),
config.WithEndpoint(providerData.DnsCustomEndpoint),
)
} else {
apiClient, err = dns.NewAPIClient(
config.WithCustomAuth(providerData.RoundTripper),
)
}
if err != nil {
resp.Diagnostics.AddError(
"Could not Configure API Client",
err.Error(),
)
return
}
tflog.Info(ctx, "DNS zone client configured")
d.client = apiClient
}
// Schema defines the schema for the data source.
func (d *zoneDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
resp.Schema = schema.Schema{
Description: "DNS Zone resource schema.",
Attributes: map[string]schema.Attribute{
"id": schema.StringAttribute{
Description: "Terraform's internal resource ID.",
Computed: true,
},
"project_id": schema.StringAttribute{
Description: "STACKIT project ID to which the dns zone is associated.",
Required: true,
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"zone_id": schema.StringAttribute{
Description: "The zone ID.",
Required: true,
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"name": schema.StringAttribute{
Description: "The user given name of the zone.",
Computed: true,
},
"dns_name": schema.StringAttribute{
Description: "The zone name. E.g. `example.com`",
Computed: true,
},
"description": schema.StringAttribute{
Description: "Description of the zone.",
Computed: true,
},
"acl": schema.StringAttribute{
Description: "The access control list.",
Computed: true,
},
"active": schema.BoolAttribute{
Description: "",
Computed: true,
},
"contact_email": schema.StringAttribute{
Description: "A contact e-mail for the zone.",
Computed: true,
},
"default_ttl": schema.Int64Attribute{
Description: "Default time to live.",
Computed: true,
},
"expire_time": schema.Int64Attribute{
Description: "Expire time.",
Computed: true,
},
"is_reverse_zone": schema.BoolAttribute{
Description: "Specifies, if the zone is a reverse zone or not.",
Computed: true,
},
"negative_cache": schema.Int64Attribute{
Description: "Negative caching.",
Computed: true,
},
"primary_name_server": schema.StringAttribute{
Description: "Primary name server. FQDN.",
Computed: true,
},
"primaries": schema.ListAttribute{
Description: `Primary name server for secondary zone.`,
Computed: true,
ElementType: types.StringType,
},
"record_count": schema.Int64Attribute{
Description: "Record count how many records are in the zone.",
Computed: true,
},
"refresh_time": schema.Int64Attribute{
Description: "Refresh time.",
Computed: true,
},
"retry_time": schema.Int64Attribute{
Description: "Retry time.",
Computed: true,
},
"serial_number": schema.Int64Attribute{
Description: "Serial number.",
Computed: true,
},
"type": schema.StringAttribute{
Description: "Zone type.",
Computed: true,
},
"visibility": schema.StringAttribute{
Description: "Visibility of the zone.",
Computed: true,
},
"state": schema.StringAttribute{
Description: "Zone state.",
Computed: true,
},
},
}
}
// Read refreshes the Terraform state with the latest data.
func (d *zoneDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
var state Model
diags := req.Config.Get(ctx, &state)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := state.ProjectId.ValueString()
zoneId := state.ZoneId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
zoneResp, err := d.client.GetZone(ctx, projectId, zoneId).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Unable to Read Zone", err.Error())
return
}
err = mapFields(zoneResp, &state)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Mapping fields", err.Error())
return
}
diags = resp.State.Set(ctx, state)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
tflog.Info(ctx, "DNS zone read")
}

608
stackit/services/dns/zone/resource.go Normal file
View file

@ -0,0 +1,608 @@
package dns
import (
"context"
"fmt"
"math"
"strings"
"time"
"github.com/hashicorp/terraform-plugin-framework-validators/int64validator"
"github.com/hashicorp/terraform-plugin-framework-validators/listvalidator"
"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
"github.com/hashicorp/terraform-plugin-framework/attr"
"github.com/hashicorp/terraform-plugin-framework/path"
"github.com/hashicorp/terraform-plugin-framework/resource"
"github.com/hashicorp/terraform-plugin-framework/resource/schema"
"github.com/hashicorp/terraform-plugin-framework/resource/schema/booldefault"
"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringdefault"
"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
"github.com/hashicorp/terraform-plugin-framework/schema/validator"
"github.com/hashicorp/terraform-plugin-framework/types"
"github.com/hashicorp/terraform-plugin-log/tflog"
"github.com/stackitcloud/stackit-sdk-go/core/config"
"github.com/stackitcloud/stackit-sdk-go/services/dns"
"github.com/stackitcloud/terraform-provider-stackit/stackit/conversion"
"github.com/stackitcloud/terraform-provider-stackit/stackit/core"
"github.com/stackitcloud/terraform-provider-stackit/stackit/validate"
)
// Ensure the implementation satisfies the expected interfaces.
var (
_ resource.Resource = &zoneResource{}
_ resource.ResourceWithConfigure = &zoneResource{}
_ resource.ResourceWithImportState = &zoneResource{}
)
type Model struct {
Id types.String `tfsdk:"id"` // needed by TF
ZoneId types.String `tfsdk:"zone_id"`
ProjectId types.String `tfsdk:"project_id"`
Name types.String `tfsdk:"name"`
DnsName types.String `tfsdk:"dns_name"`
Description types.String `tfsdk:"description"`
Acl types.String `tfsdk:"acl"`
Active types.Bool `tfsdk:"active"`
ContactEmail types.String `tfsdk:"contact_email"`
DefaultTTL types.Int64 `tfsdk:"default_ttl"`
ExpireTime types.Int64 `tfsdk:"expire_time"`
IsReverseZone types.Bool `tfsdk:"is_reverse_zone"`
NegativeCache types.Int64 `tfsdk:"negative_cache"`
PrimaryNameServer types.String `tfsdk:"primary_name_server"`
Primaries types.List `tfsdk:"primaries"`
RecordCount types.Int64 `tfsdk:"record_count"`
RefreshTime types.Int64 `tfsdk:"refresh_time"`
RetryTime types.Int64 `tfsdk:"retry_time"`
SerialNumber types.Int64 `tfsdk:"serial_number"`
Type types.String `tfsdk:"type"`
Visibility types.String `tfsdk:"visibility"`
State types.String `tfsdk:"state"`
}
// NewZoneResource is a helper function to simplify the provider implementation.
func NewZoneResource() resource.Resource {
return &zoneResource{}
}
// zoneResource is the resource implementation.
type zoneResource struct {
client *dns.APIClient
}
// Metadata returns the resource type name.
func (r *zoneResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
resp.TypeName = req.ProviderTypeName + "_dns_zone"
}
// Configure adds the provider configured client to the resource.
func (r *zoneResource) Configure(ctx context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
// Prevent panic if the provider has not been configured.
if req.ProviderData == nil {
return
}
providerData, ok := req.ProviderData.(core.ProviderData)
if !ok {
resp.Diagnostics.AddError("Unexpected Resource Configure Type", fmt.Sprintf("Expected stackit.ProviderData, got %T. Please report this issue to the provider developers.", req.ProviderData))
return
}
var apiClient *dns.APIClient
var err error
if providerData.DnsCustomEndpoint != "" {
ctx = tflog.SetField(ctx, "dns_custom_endpoint", providerData.DnsCustomEndpoint)
apiClient, err = dns.NewAPIClient(
config.WithCustomAuth(providerData.RoundTripper),
config.WithEndpoint(providerData.DnsCustomEndpoint),
)
} else {
apiClient, err = dns.NewAPIClient(
config.WithCustomAuth(providerData.RoundTripper),
)
}
if err != nil {
resp.Diagnostics.AddError("Could not Configure API Client", err.Error())
return
}
tflog.Info(ctx, "DNS zone client configured")
r.client = apiClient
}
// Schema defines the schema for the resource.
func (r *zoneResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
resp.Schema = schema.Schema{
Description: "DNS Zone resource schema.",
Attributes: map[string]schema.Attribute{
"id": schema.StringAttribute{
Description: "Terraform's internal resource ID.",
Computed: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.UseStateForUnknown(),
},
},
"project_id": schema.StringAttribute{
Description: "STACKIT project ID to which the dns zone is associated.",
Required: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.RequiresReplace(),
},
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"zone_id": schema.StringAttribute{
Description: "The zone ID.",
Computed: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.UseStateForUnknown(),
},
Validators: []validator.String{
validate.UUID(),
validate.NoSeparator(),
},
},
"name": schema.StringAttribute{
Description: "The user given name of the zone.",
Required: true,
Validators: []validator.String{
stringvalidator.LengthAtLeast(1),
stringvalidator.LengthAtMost(63),
},
},
"dns_name": schema.StringAttribute{
Description: "The zone name. E.g. `example.com`",
Required: true,
PlanModifiers: []planmodifier.String{
stringplanmodifier.RequiresReplace(),
},
Validators: []validator.String{
stringvalidator.LengthAtLeast(1),
stringvalidator.LengthAtMost(253),
},
},
"description": schema.StringAttribute{
Description: "Description of the zone.",
Optional: true,
Computed: true,
Validators: []validator.String{
stringvalidator.LengthAtMost(1024),
},
},
"acl": schema.StringAttribute{
Description: "The access control list. E.g. `0.0.0.0/0,::/0`",
Optional: true,
Computed: true,
Validators: []validator.String{
stringvalidator.LengthAtMost(2000),
},
},
"active": schema.BoolAttribute{
Description: "",
Optional: true,
Computed: true,
},
"contact_email": schema.StringAttribute{
Description: "A contact e-mail for the zone.",
Optional: true,
Computed: true,
Validators: []validator.String{
stringvalidator.LengthAtMost(255),
},
},
"default_ttl": schema.Int64Attribute{
Description: "Default time to live. E.g. 3600.",
Optional: true,
Computed: true,
Validators: []validator.Int64{
int64validator.Between(60, 99999999),
},
},
"expire_time": schema.Int64Attribute{
Description: "Expire time. E.g. 1209600.",
Optional: true,
Computed: true,
Validators: []validator.Int64{
int64validator.Between(60, 99999999),
},
},
"is_reverse_zone": schema.BoolAttribute{
Description: "Specifies, if the zone is a reverse zone or not.",
Optional: true,
Computed: true,
Default: booldefault.StaticBool(false),
},
"negative_cache": schema.Int64Attribute{
Description: "Negative caching. E.g. 60",
Optional: true,
Computed: true,
Validators: []validator.Int64{
int64validator.Between(60, 99999999),
},
},
"primaries": schema.ListAttribute{
Description: `Primary name server for secondary zone. E.g. ["1.2.3.4"]`,
Optional: true,
Computed: true,
ElementType: types.StringType,
Validators: []validator.List{
listvalidator.SizeAtMost(10),
},
},
"refresh_time": schema.Int64Attribute{
Description: "Refresh time. E.g. 3600",
Optional: true,
Computed: true,
Validators: []validator.Int64{
int64validator.Between(60, 99999999),
},
},
"retry_time": schema.Int64Attribute{
Description: "Retry time. E.g. 600",
Optional: true,
Computed: true,
Validators: []validator.Int64{
int64validator.Between(60, 99999999),
},
},
"type": schema.StringAttribute{
Description: "Zone type. E.g. `primary`",
Optional: true,
Computed: true,
Default: stringdefault.StaticString("primary"),
Validators: []validator.String{
stringvalidator.OneOf("primary", "secondary"),
},
},
"primary_name_server": schema.StringAttribute{
Description: "Primary name server. FQDN.",
Computed: true,
Validators: []validator.String{
stringvalidator.LengthAtLeast(1),
stringvalidator.LengthAtMost(253),
},
},
"serial_number": schema.Int64Attribute{
Description: "Serial number. E.g. `2022111400`.",
Computed: true,
Validators: []validator.Int64{
int64validator.AtLeast(0),
int64validator.AtMost(math.MaxInt32 - 1),
},
},
"visibility": schema.StringAttribute{
Description: "Visibility of the zone. E.g. `public`.",
Computed: true,
},
"record_count": schema.Int64Attribute{
Description: "Record count how many records are in the zone.",
Computed: true,
},
"state": schema.StringAttribute{
Description: "Zone state. E.g. `CREATE_SUCCEEDED`.",
Computed: true,
},
},
}
}
// Create creates the resource and sets the initial Terraform state.
func (r *zoneResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) { // nolint:gocritic // function signature required by Terraform
// Retrieve values from plan
var model Model
diags := req.Plan.Get(ctx, &model)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := model.ProjectId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
// Generate API request body from model
payload, err := toCreatePayload(&model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating zone", fmt.Sprintf("Creating API payload: %v", err))
return
}
// Create new zone
createResp, err := r.client.CreateZone(ctx, projectId).CreateZonePayload(*payload).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating zone", fmt.Sprintf("Calling API: %v", err))
return
}
if createResp.Zone.Id == nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating zone", "API didn't return zone id")
return
}
zoneId := *createResp.Zone.Id
ctx = tflog.SetField(ctx, "zone_id", zoneId)
wr, err := dns.CreateZoneWaitHandler(ctx, r.client, projectId, zoneId).SetTimeout(10 * time.Minute).WaitWithContext(ctx)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating zone", fmt.Sprintf("Instance creation waiting: %v", err))
return
}
got, ok := wr.(*dns.ZoneResponse)
if !ok {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating zone", fmt.Sprintf("Wait result conversion, got %+v", got))
return
}
// Map response body to schema and populate Computed attribute values
err = mapFields(got, &model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error mapping fields", err.Error())
return
}
// Set state to fully populated data
diags = resp.State.Set(ctx, model)
resp.Diagnostics.Append(diags...)
tflog.Info(ctx, "DNS zone created")
}
// Read refreshes the Terraform state with the latest data.
func (r *zoneResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
var state Model
diags := req.State.Get(ctx, &state)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := state.ProjectId.ValueString()
zoneId := state.ZoneId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
zoneResp, err := r.client.GetZone(ctx, projectId, zoneId).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading zones", err.Error())
return
}
// Map response body to schema and populate Computed attribute values
err = mapFields(zoneResp, &state)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error mapping fields", err.Error())
return
}
// Set refreshed state
diags = resp.State.Set(ctx, state)
resp.Diagnostics.Append(diags...)
tflog.Info(ctx, "DNS zone read")
}
// Update updates the resource and sets the updated Terraform state on success.
func (r *zoneResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) { // nolint:gocritic // function signature required by Terraform
// Retrieve values from plan
var model Model
diags := req.Plan.Get(ctx, &model)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := model.ProjectId.ValueString()
zoneId := model.ZoneId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
// Generate API request body from model
payload, err := toUpdatePayload(&model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating zone", fmt.Sprintf("Could not create API payload: %v", err))
return
}
// Update existing zone
_, err = r.client.UpdateZone(ctx, projectId, zoneId).UpdateZonePayload(*payload).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating zone", err.Error())
return
}
wr, err := dns.UpdateZoneWaitHandler(ctx, r.client, projectId, zoneId).SetTimeout(10 * time.Minute).WaitWithContext(ctx)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating zone", fmt.Sprintf("Instance update waiting: %v", err))
return
}
got, ok := wr.(*dns.ZoneResponse)
if !ok {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating zone", fmt.Sprintf("Wait result conversion, got %+v", got))
return
}
// Fetch updated zone
zoneResp, err := r.client.GetZone(ctx, projectId, zoneId).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading updated data", err.Error())
return
}
err = mapFields(zoneResp, &model)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error mapping fields in update", err.Error())
return
}
diags = resp.State.Set(ctx, model)
resp.Diagnostics.Append(diags...)
tflog.Info(ctx, "DNS zone updated")
}
// Delete deletes the resource and removes the Terraform state on success.
func (r *zoneResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) { // nolint:gocritic // function signature required by Terraform
// Retrieve values from state
var model Model
diags := req.State.Get(ctx, &model)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {
return
}
projectId := model.ProjectId.ValueString()
zoneId := model.ZoneId.ValueString()
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
// Delete existing zone
_, err := r.client.DeleteZone(ctx, projectId, zoneId).Execute()
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting zone", err.Error())
return
}
_, err = dns.DeleteZoneWaitHandler(ctx, r.client, projectId, zoneId).SetTimeout(10 * time.Minute).WaitWithContext(ctx)
if err != nil {
core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting zone", fmt.Sprintf("Instance deletion waiting: %v", err))
return
}
tflog.Info(ctx, "DNS zone deleted")
}
// ImportState imports a resource into the Terraform state on success.
// The expected format of the resource import identifier is: project_id,zone_id
func (r *zoneResource) ImportState(ctx context.Context, req resource.ImportStateRequest, resp *resource.ImportStateResponse) {
idParts := strings.Split(req.ID, core.Separator)
if len(idParts) != 2 || idParts[0] == "" || idParts[1] == "" {
resp.Diagnostics.AddError(
"Unexpected Import Identifier",
fmt.Sprintf("Expected import identifier with format: [project_id],[zone_id] Got: %q", req.ID),
)
return
}
projectId := idParts[0]
zoneId := idParts[1]
ctx = tflog.SetField(ctx, "project_id", projectId)
ctx = tflog.SetField(ctx, "zone_id", zoneId)
resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("project_id"), projectId)...)
resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("zone_id"), zoneId)...)
tflog.Info(ctx, "DNS zone state imported")
}
func mapFields(zoneResp *dns.ZoneResponse, model *Model) error {
if zoneResp == nil || zoneResp.Zone == nil {
return fmt.Errorf("response input is nil")
}
if model == nil {
return fmt.Errorf("model input is nil")
}
z := zoneResp.Zone
var rc *int64
if z.RecordCount != nil {
recordCount64 := int64(*z.RecordCount)
rc = &recordCount64
} else {
rc = nil
}
var zoneId string
if model.ZoneId.ValueString() != "" {
zoneId = model.ZoneId.ValueString()
} else if z.Id != nil {
zoneId = *z.Id
} else {
return fmt.Errorf("zone id not present")
}
idParts := []string{
model.ProjectId.ValueString(),
zoneId,
}
model.Id = types.StringValue(
strings.Join(idParts, core.Separator),
)
if z.Primaries == nil {
model.Primaries = types.ListNull(types.StringType)
} else {
respZonePrimaries := []attr.Value{}
for _, primary := range *z.Primaries {
respZonePrimaries = append(respZonePrimaries, types.StringValue(primary))
respZonePrimariesList, diags := types.ListValue(types.StringType, respZonePrimaries)
if diags.HasError() {
return fmt.Errorf("creating primaries list: %w", core.DiagsToError(diags))
}
model.Primaries = respZonePrimariesList
}
}
model.ZoneId = types.StringValue(zoneId)
model.Description = types.StringPointerValue(z.Description)
model.Acl = types.StringPointerValue(z.Acl)
model.Active = types.BoolPointerValue(z.Active)
model.ContactEmail = types.StringPointerValue(z.ContactEmail)
model.DefaultTTL = conversion.ToTypeInt64(z.DefaultTTL)
model.DnsName = types.StringPointerValue(z.DnsName)
model.ExpireTime = conversion.ToTypeInt64(z.ExpireTime)
model.IsReverseZone = types.BoolPointerValue(z.IsReverseZone)
model.Name = types.StringPointerValue(z.Name)
model.NegativeCache = conversion.ToTypeInt64(z.NegativeCache)
model.PrimaryNameServer = types.StringPointerValue(z.PrimaryNameServer)
model.RecordCount = types.Int64PointerValue(rc)
model.RefreshTime = conversion.ToTypeInt64(z.RefreshTime)
model.RetryTime = conversion.ToTypeInt64(z.RetryTime)
model.SerialNumber = conversion.ToTypeInt64(z.SerialNumber)
model.State = types.StringPointerValue(z.State)
model.Type = types.StringPointerValue(z.Type)
model.Visibility = types.StringPointerValue(z.Visibility)
return nil
}
func toCreatePayload(model *Model) (*dns.CreateZonePayload, error) {
if model == nil {
return nil, fmt.Errorf("nil model")
}
modelPrimaries := []string{}
for _, primary := range model.Primaries.Elements() {
primaryString, ok := primary.(types.String)
if !ok {
return nil, fmt.Errorf("type assertion failed")
}
modelPrimaries = append(modelPrimaries, primaryString.ValueString())
}
return &dns.CreateZonePayload{
Name: model.Name.ValueStringPointer(),
DnsName: model.DnsName.ValueStringPointer(),
ContactEmail: model.ContactEmail.ValueStringPointer(),
Description: model.Description.ValueStringPointer(),
Acl: model.Acl.ValueStringPointer(),
Type: model.Type.ValueStringPointer(),
DefaultTTL: conversion.ToPtrInt32(model.DefaultTTL),
ExpireTime: conversion.ToPtrInt32(model.ExpireTime),
RefreshTime: conversion.ToPtrInt32(model.RefreshTime),
RetryTime: conversion.ToPtrInt32(model.RetryTime),
NegativeCache: conversion.ToPtrInt32(model.NegativeCache),
IsReverseZone: model.IsReverseZone.ValueBoolPointer(),
Primaries: &modelPrimaries,
}, nil
}
func toUpdatePayload(model *Model) (*dns.UpdateZonePayload, error) {
if model == nil {
return nil, fmt.Errorf("nil model")
}
modelPrimaries := []string{}
for _, primary := range model.Primaries.Elements() {
primaryString, ok := primary.(types.String)
if !ok {
return nil, fmt.Errorf("type assertion failed")
}
modelPrimaries = append(modelPrimaries, primaryString.ValueString())
}
return &dns.UpdateZonePayload{
Name: model.Name.ValueStringPointer(),
ContactEmail: model.ContactEmail.ValueStringPointer(),
Description: model.Description.ValueStringPointer(),
Acl: model.Acl.ValueStringPointer(),
DefaultTTL: conversion.ToPtrInt32(model.DefaultTTL),
ExpireTime: conversion.ToPtrInt32(model.ExpireTime),
RefreshTime: conversion.ToPtrInt32(model.RefreshTime),
RetryTime: conversion.ToPtrInt32(model.RetryTime),
NegativeCache: conversion.ToPtrInt32(model.NegativeCache),
Primaries: &modelPrimaries,
}, nil
}

351
stackit/services/dns/zone/resource_test.go Normal file
View file

@ -0,0 +1,351 @@
package dns
import (
"testing"
"github.com/google/go-cmp/cmp"
"github.com/hashicorp/terraform-plugin-framework/attr"
"github.com/hashicorp/terraform-plugin-framework/types"
"github.com/stackitcloud/stackit-sdk-go/core/utils"
"github.com/stackitcloud/stackit-sdk-go/services/dns"
)
func TestMapFields(t *testing.T) {
tests := []struct {
description string
input *dns.ZoneResponse
expected Model
isValid bool
}{
{
"default_ok",
&dns.ZoneResponse{
Zone: &dns.Zone{
Id: utils.Ptr("zid"),
},
},
Model{
Id: types.StringValue("pid,zid"),
ProjectId: types.StringValue("pid"),
ZoneId: types.StringValue("zid"),
Name: types.StringNull(),
DnsName: types.StringNull(),
Acl: types.StringNull(),
DefaultTTL: types.Int64Null(),
ExpireTime: types.Int64Null(),
RefreshTime: types.Int64Null(),
RetryTime: types.Int64Null(),
SerialNumber: types.Int64Null(),
NegativeCache: types.Int64Null(),
Type: types.StringNull(),
State: types.StringNull(),
PrimaryNameServer: types.StringNull(),
Primaries: types.ListNull(types.StringType),
Visibility: types.StringNull(),
},
true,
},
{
"values_ok",
&dns.ZoneResponse{
Zone: &dns.Zone{
Id: utils.Ptr("zid"),
Name: utils.Ptr("name"),
DnsName: utils.Ptr("dnsname"),
Acl: utils.Ptr("acl"),
Active: utils.Ptr(false),
CreationStarted: utils.Ptr("bar"),
CreationFinished: utils.Ptr("foo"),
DefaultTTL: utils.Ptr(int32(1)),
ExpireTime: utils.Ptr(int32(2)),
RefreshTime: utils.Ptr(int32(3)),
RetryTime: utils.Ptr(int32(4)),
SerialNumber: utils.Ptr(int32(5)),
NegativeCache: utils.Ptr(int32(6)),
State: utils.Ptr("state"),
Type: utils.Ptr("type"),
Primaries: &[]string{"primary"},
PrimaryNameServer: utils.Ptr("pns"),
UpdateStarted: utils.Ptr("ufoo"),
UpdateFinished: utils.Ptr("ubar"),
Visibility: utils.Ptr("visibility"),
Error: utils.Ptr("error"),
ContactEmail: utils.Ptr("a@b.cd"),
Description: utils.Ptr("description"),
IsReverseZone: utils.Ptr(false),
RecordCount: utils.Ptr(int32(3)),
},
},
Model{
Id: types.StringValue("pid,zid"),
ProjectId: types.StringValue("pid"),
ZoneId: types.StringValue("zid"),
Name: types.StringValue("name"),
DnsName: types.StringValue("dnsname"),
Acl: types.StringValue("acl"),
Active: types.BoolValue(false),
DefaultTTL: types.Int64Value(1),
ExpireTime: types.Int64Value(2),
RefreshTime: types.Int64Value(3),
RetryTime: types.Int64Value(4),
SerialNumber: types.Int64Value(5),
NegativeCache: types.Int64Value(6),
Type: types.StringValue("type"),
State: types.StringValue("state"),
PrimaryNameServer: types.StringValue("pns"),
Primaries: types.ListValueMust(types.StringType, []attr.Value{
types.StringValue("primary"),
}),
Visibility: types.StringValue("visibility"),
ContactEmail: types.StringValue("a@b.cd"),
Description: types.StringValue("description"),
IsReverseZone: types.BoolValue(false),
RecordCount: types.Int64Value(3),
},
true,
},
{
"nullable_fields_and_int_conversions_ok",
&dns.ZoneResponse{
Zone: &dns.Zone{
Id: utils.Ptr("zid"),
Name: utils.Ptr("name"),
DnsName: utils.Ptr("dnsname"),
Acl: utils.Ptr("acl"),
Active: nil,
CreationStarted: utils.Ptr("bar"),
CreationFinished: utils.Ptr("foo"),
DefaultTTL: utils.Ptr(int32(2123456789)),
ExpireTime: utils.Ptr(int32(-2)),
RefreshTime: utils.Ptr(int32(3)),
RetryTime: utils.Ptr(int32(4)),
SerialNumber: utils.Ptr(int32(5)),
NegativeCache: utils.Ptr(int32(0)),
State: utils.Ptr("state"),
Type: utils.Ptr("type"),
Primaries: nil,
PrimaryNameServer: utils.Ptr("pns"),
UpdateStarted: utils.Ptr("ufoo"),
UpdateFinished: utils.Ptr("ubar"),
Visibility: utils.Ptr("visibility"),
ContactEmail: nil,
Description: nil,
IsReverseZone: nil,
RecordCount: utils.Ptr(int32(-2123456789)),
},
},
Model{
Id: types.StringValue("pid,zid"),
ProjectId: types.StringValue("pid"),
ZoneId: types.StringValue("zid"),
Name: types.StringValue("name"),
DnsName: types.StringValue("dnsname"),
Acl: types.StringValue("acl"),
Active: types.BoolNull(),
DefaultTTL: types.Int64Value(2123456789),
ExpireTime: types.Int64Value(-2),
RefreshTime: types.Int64Value(3),
RetryTime: types.Int64Value(4),
SerialNumber: types.Int64Value(5),
NegativeCache: types.Int64Value(0),
Type: types.StringValue("type"),
Primaries: types.ListNull(types.StringType),
State: types.StringValue("state"),
PrimaryNameServer: types.StringValue("pns"),
Visibility: types.StringValue("visibility"),
ContactEmail: types.StringNull(),
Description: types.StringNull(),
IsReverseZone: types.BoolNull(),
RecordCount: types.Int64Value(-2123456789),
},
true,
},
{
"response_nil_fail",
nil,
Model{},
false,
},
{
"no_resource_id",
&dns.ZoneResponse{},
Model{},
false,
},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
state := &Model{
ProjectId: tt.expected.ProjectId,
}
err := mapFields(tt.input, state)
if !tt.isValid && err == nil {
t.Fatalf("Should have failed")
}
if tt.isValid && err != nil {
t.Fatalf("Should not have failed: %v", err)
}
if tt.isValid {
diff := cmp.Diff(state, &tt.expected)
if diff != "" {
t.Fatalf("Data does not match: %s", diff)
}
}
})
}
}
func TestToCreatePayload(t *testing.T) {
tests := []struct {
description string
input *Model
expected *dns.CreateZonePayload
isValid bool
}{
{
"default_ok",
&Model{
Name: types.StringValue("Name"),
DnsName: types.StringValue("DnsName"),
},
&dns.CreateZonePayload{
Name: utils.Ptr("Name"),
DnsName: utils.Ptr("DnsName"),
Primaries: &[]string{},
},
true,
},
{
"mapping_with_conversions_ok",
&Model{
Name: types.StringValue("Name"),
DnsName: types.StringValue("DnsName"),
Acl: types.StringValue("Acl"),
Description: types.StringValue("Description"),
Type: types.StringValue("Type"),
ContactEmail: types.StringValue("ContactEmail"),
RetryTime: types.Int64Value(3),
RefreshTime: types.Int64Value(4),
ExpireTime: types.Int64Value(5),
DefaultTTL: types.Int64Value(4534534),
NegativeCache: types.Int64Value(-4534534),
Primaries: types.ListValueMust(types.StringType, []attr.Value{
types.StringValue("primary"),
}),
IsReverseZone: types.BoolValue(true),
},
&dns.CreateZonePayload{
Name: utils.Ptr("Name"),
DnsName: utils.Ptr("DnsName"),
Acl: utils.Ptr("Acl"),
Description: utils.Ptr("Description"),
Type: utils.Ptr("Type"),
ContactEmail: utils.Ptr("ContactEmail"),
Primaries: &[]string{"primary"},
RetryTime: utils.Ptr(int32(3)),
RefreshTime: utils.Ptr(int32(4)),
ExpireTime: utils.Ptr(int32(5)),
DefaultTTL: utils.Ptr(int32(4534534)),
NegativeCache: utils.Ptr(int32(-4534534)),
IsReverseZone: utils.Ptr(true),
},
true,
},
{
"nil_model",
nil,
nil,
false,
},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
output, err := toCreatePayload(tt.input)
if !tt.isValid && err == nil {
t.Fatalf("Should have failed")
}
if tt.isValid && err != nil {
t.Fatalf("Should not have failed: %v", err)
}
if tt.isValid {
diff := cmp.Diff(output, tt.expected)
if diff != "" {
t.Fatalf("Data does not match: %s", diff)
}
}
})
}
}
func TestToPayloadUpdate(t *testing.T) {
tests := []struct {
description string
input *Model
expected *dns.UpdateZonePayload
isValid bool
}{
{
"single_field_change_ok",
&Model{
Name: types.StringValue("Name"),
},
&dns.UpdateZonePayload{
Name: utils.Ptr("Name"),
Primaries: &[]string{},
},
true,
},
{
"mapping_with_conversions_ok",
&Model{
Name: types.StringValue("Name"),
DnsName: types.StringValue("DnsName"),
Acl: types.StringValue("Acl"),
Active: types.BoolValue(true),
Description: types.StringValue("Description"),
Type: types.StringValue("Type"),
ContactEmail: types.StringValue("ContactEmail"),
PrimaryNameServer: types.StringValue("PrimaryNameServer"),
Primaries: types.ListValueMust(types.StringType, []attr.Value{
types.StringValue("Primary"),
}),
RetryTime: types.Int64Value(3),
RefreshTime: types.Int64Value(4),
ExpireTime: types.Int64Value(5),
DefaultTTL: types.Int64Value(4534534),
NegativeCache: types.Int64Value(-4534534),
IsReverseZone: types.BoolValue(true),
},
&dns.UpdateZonePayload{
Name: utils.Ptr("Name"),
Acl: utils.Ptr("Acl"),
Description: utils.Ptr("Description"),
ContactEmail: utils.Ptr("ContactEmail"),
Primaries: &[]string{"Primary"},
RetryTime: utils.Ptr(int32(3)),
RefreshTime: utils.Ptr(int32(4)),
ExpireTime: utils.Ptr(int32(5)),
DefaultTTL: utils.Ptr(int32(4534534)),
NegativeCache: utils.Ptr(int32(-4534534)),
},
true,
},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
output, err := toUpdatePayload(tt.input)
if !tt.isValid && err == nil {
t.Fatalf("Should have failed")
}
if tt.isValid && err != nil {
t.Fatalf("Should not have failed: %v", err)
}
if tt.isValid {
diff := cmp.Diff(output, tt.expected)
if diff != "" {
t.Fatalf("Data does not match: %s", diff)
}
}
})
}
}