chore: fix nat rule type no_snat and no_dnat

.changelog/820.txt

@@ -0,0 +1,3 @@
+```release-note:bug
+`resource/cloudavenue_vm` - Now Nat rule support correctly `NO_SNAT` and `NO_DNAT` type.
+```

.golangci.yml

@@ -73,7 +73,6 @@ linters:
     - gochecknoinits # Checks that no init functions are present in Go code [fast: true, auto-fix: false]
     - gocognit # Computes and checks the cognitive complexity of functions [fast: true, auto-fix: false]
     - godox # Tool for detection of FIXME, TODO and other comment keywords [fast: true, auto-fix: false]
-    - gomnd # An analyzer to detect magic numbers. [fast: true, auto-fix: false]
     - lll # Reports long lines [fast: true, auto-fix: false]
     - maintidx # maintidx measures the maintainability index of each function. [fast: true, auto-fix: false]
     - nestif # Reports deeply nested if statements [fast: true, auto-fix: false]

docs/resources/edgegateway_nat_rule.md

@@ -61,8 +61,6 @@ resource "cloudavenue_edgegateway_nat_rule" "example-reflexive" {
 
 ### Required
 
-- `external_address` (String) The external address for the NAT Rule. This must be supplied as a single IP or Network CIDR. For a DNAT rule, this is the external facing IP Address for incoming traffic. For an SNAT rule, this is the external facing IP Address for outgoing traffic. These IPs are typically allocated/suballocated IP Addresses on the Edge Gateway. For a REFLEXIVE rule, these are the external facing IPs.
-- `internal_address` (String) The internal address for the NAT Rule. This must be supplied as a single IP or Network CIDR. For a DNAT rule, this is the internal IP address for incoming traffic. For an SNAT rule, this is the internal IP Address for outgoing traffic. For a REFLEXIVE rule, these are the internal IPs. These IPs are typically the Private IPs that are allocated to workloads.
 - `name` (String) (ForceNew) The Name of the Nat Rule.
 - `rule_type` (String) (ForceNew) Nat Rule type. Value must be one of: `DNAT` (Rule translates the external IP to an internal IP and is used for inbound traffic.), `NO_DNAT` (Prevents external IP translation.), `SNAT` (Translates an internal IP to an external IP and is used for outbound traffic.), `NO_SNAT` (Prevents internal IP translation.), `REFLEXIVE` (This translates an internal IP to an external IP and vice versa.).
 
@@ -73,7 +71,9 @@ resource "cloudavenue_edgegateway_nat_rule" "example-reflexive" {
 - `edge_gateway_id` (String) (ForceNew) The ID of the Edge Gateway. Ensure that one and only one attribute from this collection is set : `edge_gateway_name`, `edge_gateway_id`.
 - `edge_gateway_name` (String) (ForceNew) The Name of the Edge Gateway. Ensure that one and only one attribute from this collection is set : `edge_gateway_name`, `edge_gateway_id`.
 - `enabled` (Boolean) Enable or Disable the Nat Rule. Value defaults to `true`.
+- `external_address` (String) The external address for the NAT Rule. This must be supplied as a single IP or Network CIDR. For a DNAT rule, this is the external facing IP Address for incoming traffic. For an SNAT rule, this is the external facing IP Address for outgoing traffic. These IPs are typically allocated/suballocated IP Addresses on the Edge Gateway. For a REFLEXIVE rule, these are the external facing IPs. If the value of [`rule_type`](#rule_type) attribute is `NO_SNAT` this attribute is **NULL**.
 - `firewall_match` (String) You can set a firewall match rule to determine how firewall is applied during NAT. Value must be one of: `MATCH_INTERNAL_ADDRESS` (Applies firewall rule to the internal address of a NAT rule.), `MATCH_EXTERNAL_ADDRESS` (Applies firewall rule to the external address of a NAT rule.), `BYPASS` (Skip applying firewall rule to NAT rule.).
+- `internal_address` (String) The internal address for the NAT Rule. This must be supplied as a single IP or Network CIDR. For a DNAT rule, this is the internal IP address for incoming traffic. For an SNAT rule, this is the internal IP Address for outgoing traffic. For a REFLEXIVE rule, these are the internal IPs. These IPs are typically the Private IPs that are allocated to workloads. If the value of [`rule_type`](#rule_type) attribute is `NO_DNAT` this attribute is **NULL**.
 - `priority` (Number) If an address has multiple NAT rule, you can assign these rule different priorities to determine the order in which they are applied. A lower value means a higher priority for this rule. Value defaults to `0`.
 - `snat_destination_address` (String) The destination addresses to match in the SNAT Rule. This must be supplied as a single IP or Network CIDR. Providing no value for this field results in match with ANY destination network. If the value of [`rule_type`](#rule_type) attribute is one of `DNAT`, `NO_DNAT` or `REFLEXIVE` this attribute is **NULL**.
 

internal/provider/edgegw/nat_rule_resource.go

@@ -386,6 +386,7 @@ func (r *natRuleResource) read(planOrState *NATRuleModel) (stateRefreshed *NATRu
 	}
 	if err != nil {
 		if govcd.ContainsNotFound(err) {
+			diags.AddWarning("Error NAT Rule Not Found", err.Error())
 			return nil, false, diags
 		}
 		diags.AddError("Error retrieving NAT Rule ID", err.Error())

internal/provider/edgegw/nat_rule_schema.go

@@ -149,7 +149,10 @@ func natRuleSchema(_ context.Context) superschema.Schema {
 					MarkdownDescription: "The external address for the NAT Rule. This must be supplied as a single IP or Network CIDR. For a DNAT rule, this is the external facing IP Address for incoming traffic. For an SNAT rule, this is the external facing IP Address for outgoing traffic. These IPs are typically allocated/suballocated IP Addresses on the Edge Gateway. For a REFLEXIVE rule, these are the external facing IPs.",
 				},
 				Resource: &schemaR.StringAttribute{
-					Required: true,
+					Optional: true,
+					Validators: []validator.String{
+						fstringvalidator.NullIfAttributeIsOneOf(path.MatchRoot("rule_type"), []attr.Value{types.StringValue("NO_SNAT")}),
+					},
 					// TODO - Validator of IP or IP/CIDR
 				},
 				DataSource: &schemaD.StringAttribute{
@@ -161,7 +164,10 @@ func natRuleSchema(_ context.Context) superschema.Schema {
 					MarkdownDescription: "The internal address for the NAT Rule. This must be supplied as a single IP or Network CIDR. For a DNAT rule, this is the internal IP address for incoming traffic. For an SNAT rule, this is the internal IP Address for outgoing traffic. For a REFLEXIVE rule, these are the internal IPs. These IPs are typically the Private IPs that are allocated to workloads.",
 				},
 				Resource: &schemaR.StringAttribute{
-					Required: true,
+					Optional: true,
+					Validators: []validator.String{
+						fstringvalidator.NullIfAttributeIsOneOf(path.MatchRoot("rule_type"), []attr.Value{types.StringValue("NO_DNAT")}),
+					},
 					// TODO - Validator of IP or IP/CIDR
 				},
 				DataSource: &schemaD.StringAttribute{

internal/testsacc/acctest_datasources_test.go

@@ -27,6 +27,7 @@ func GetDataSourceConfig() map[testsacc.ResourceName]func() *testsacc.ResourceCo
 		EdgeGatewayAppPortProfileDatasourceName: testsacc.NewResourceConfig(NewEdgeGatewayAppPortProfileDatasourceTest()),
 		EdgeGatewaySecurityGroupDataSourceName:  testsacc.NewResourceConfig(NewEdgeGatewaySecurityGroupDataSourceTest()),
 		EdgeGatewayDhcpForwardingDataSourceName: testsacc.NewResourceConfig(NewEdgeGatewayDhcpForwardingDataSourceTest()),
+		EdgeGatewayNATRuleDataSourceName:        testsacc.NewResourceConfig(NewEdgeGatewayNATRuleDataSourceTest()),
 
 		// * S3
 		S3BucketVersioningConfigurationDatasourceName: testsacc.NewResourceConfig(NewS3BucketVersioningConfigurationDatasourceTest()),

internal/testsacc/acctest_resources_test.go

@@ -27,6 +27,7 @@ func GetResourceConfig() map[testsacc.ResourceName]func() *testsacc.ResourceConf
 		EdgeGatewayFirewallResourceName:       testsacc.NewResourceConfig(NewEdgeGatewayFirewallResourceTest()),
 		EdgeGatewaySecurityGroupResourceName:  testsacc.NewResourceConfig(NewEdgeGatewaySecurityGroupResourceTest()),
 		EdgeGatewayDhcpForwardingResourceName: testsacc.NewResourceConfig(NewEdgeGatewayDhcpForwardingResourceTest()),
+		EdgeGatewayNATRuleResourceName:        testsacc.NewResourceConfig(NewEdgeGatewayNATRuleResourceTest()),
 
 		// * Backup
 		BackupResourceName: testsacc.NewResourceConfig(NewBackupResourceTest()),

internal/testsacc/edgegw_nat_rule_datasource_test.go

@@ -1,32 +1,73 @@
 package testsacc
 
 import (
+	"context"
 	"testing"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+
+	"github.com/orange-cloudavenue/terraform-provider-cloudavenue/internal/helpers/testsacc"
+)
+
+var _ testsacc.TestACC = &EdgeGatewayNATRuleDataSource{}
+
+const (
+	EdgeGatewayNATRuleDataSourceName = testsacc.ResourceName("data.cloudavenue_edgegateway_nat_rule")
 )
 
-const testAccNATRuleDataSourceConfig = `
-data "cloudavenue_edgegateway_nat_rule" "example" {
-	depends_on = [cloudavenue_edgegateway.example_with_vdc, cloudavenue_edgegateway_nat_rule.example]
-	edge_gateway_id = cloudavenue_edgegateway.example_with_vdc.id
-	name = "example-snat"
+type EdgeGatewayNATRuleDataSource struct{}
+
+func NewEdgeGatewayNATRuleDataSourceTest() testsacc.TestACC {
+	return &EdgeGatewayNATRuleDataSource{}
 }
-`
 
-func TestAccNatRuleDataSource(t *testing.T) {
-	dataSourceName := "data.cloudavenue_edgegateway_nat_rule.example"
+// GetResourceName returns the name of the resource.
+func (r *EdgeGatewayNATRuleDataSource) GetResourceName() string {
+	return EdgeGatewayNATRuleDataSourceName.String()
+}
 
+func (r *EdgeGatewayNATRuleDataSource) DependenciesConfig() (resp testsacc.DependenciesConfigResponse) {
+	resp.Append(GetResourceConfig()[EdgeGatewayNATRuleResourceName]().GetDefaultConfig)
+	return
+}
+
+func (r *EdgeGatewayNATRuleDataSource) Tests(ctx context.Context) map[testsacc.TestName]func(ctx context.Context, resourceName string) testsacc.Test {
+	return map[testsacc.TestName]func(ctx context.Context, resourceName string) testsacc.Test{
+		// * Test One (with edge_gateway_id)
+		"example": func(_ context.Context, _ string) testsacc.Test {
+			return testsacc.Test{
+				// ! Create testing
+				Create: testsacc.TFConfig{
+					TFConfig: `
+					data "cloudavenue_edgegateway_nat_rule" "example" {
+						edge_gateway_id = cloudavenue_edgegateway.example.id
+						name = "example"
+					}`,
+					Checks: GetResourceConfig()[EdgeGatewayNATRuleResourceName]().GetDefaultChecks(),
+				},
+			}
+		},
+		// * Test Two (with edge_gateway_name)
+		"example_with_edge_gateway_name": func(_ context.Context, _ string) testsacc.Test {
+			return testsacc.Test{
+				// ! Create testing
+				Create: testsacc.TFConfig{
+					TFConfig: `
+					data "cloudavenue_edgegateway_nat_rule" "example_with_edge_gateway_name" {
+						edge_gateway_name = cloudavenue_edgegateway.example.name
+						name = "example"
+					}`,
+					Checks: GetResourceConfig()[EdgeGatewayNATRuleResourceName]().GetDefaultChecks(),
+				},
+			}
+		},
+	}
+}
+
+func TestAccEdgeGatewayNATRuleDataSource(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { TestAccPreCheck(t) },
 		ProtoV6ProviderFactories: TestAccProtoV6ProviderFactories,
-		Steps: []resource.TestStep{
-			// Read testing
-			{
-				// Apply test
-				Config: ConcatTests(testAccNATRuleResourceConfigSnat, testAccNATRuleDataSourceConfig, testAccEdgeGatewayResourceConfig),
-				Check:  natRuleSnatTestCheck(dataSourceName),
-			},
-		},
+		Steps:                    testsacc.GenerateTests(&EdgeGatewayNATRuleDataSource{}),
 	})
 }