Merge branch 'feat/aws-acm-mock-tests' into fix/aws-rds-bounds-acm-pagination

Author: james00012

go.mod

@@ -96,7 +96,7 @@ require (
 	github.com/gonvenience/ytbx v1.4.4
 	github.com/hashicorp/go-getter/v2 v2.2.3
 	github.com/homeport/dyff v1.6.0
-	github.com/jackc/pgx/v5 v5.7.1
+	github.com/jackc/pgx/v5 v5.9.0
 	github.com/lib/pq v1.10.9
 	github.com/slack-go/slack v0.15.0
 	gopkg.in/yaml.v3 v3.0.1

go.sum

@@ -373,8 +373,8 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs=
-github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA=
+github.com/jackc/pgx/v5 v5.9.0 h1:T/dI+2TvmI2H8s/KH1/lXIbz1CUFk3gn5oTjr0/mBsE=
+github.com/jackc/pgx/v5 v5.9.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
 github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
 github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a h1:zPPuIq2jAWWPTrGt70eK/BSch+gFAGrNzecsoENgu2o=

modules/azure/availabilityset.go

@@ -228,7 +228,7 @@ func GetAvailabilitySetFaultDomainCountContextE(t testing.TestingT, ctx context.
 
 // ExtractAvailabilitySetFaultDomainCount gets the Fault Domain Count from the provided AvailabilitySet.
 func ExtractAvailabilitySetFaultDomainCount(avs *armcompute.AvailabilitySet) (int32, error) {
-	if avs.Properties == nil || avs.Properties.PlatformFaultDomainCount == nil {
+	if avs == nil || avs.Properties == nil || avs.Properties.PlatformFaultDomainCount == nil {
 		return -1, errors.New("availability set has no fault domain count")
 	}
 

modules/azure/compute.go

@@ -136,7 +136,7 @@ func GetVirtualMachineNicsContextE(ctx context.Context, vmName string, resGroupN
 
 // extractVMNics extracts the Network Interface names from a Virtual Machine object.
 func extractVMNics(vm *armcompute.VirtualMachine) ([]string, error) {
-	if vm.Properties == nil || vm.Properties.NetworkProfile == nil {
+	if vm == nil || vm.Properties == nil || vm.Properties.NetworkProfile == nil {
 		return nil, nil
 	}
 
@@ -145,6 +145,10 @@ func extractVMNics(vm *armcompute.VirtualMachine) ([]string, error) {
 	var nics []string
 
 	for _, nic := range vmNICs {
+		if nic == nil || nic.ID == nil {
+			continue
+		}
+
 		nicName, err := GetNameFromResourceIDE(*nic.ID)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse NIC resource ID %q: %w", *nic.ID, err)
@@ -198,11 +202,20 @@ func GetVirtualMachineManagedDisksContextE(ctx context.Context, vmName string, r
 
 // extractVMManagedDisks extracts the Managed Disk names from a Virtual Machine object.
 func extractVMManagedDisks(vm *armcompute.VirtualMachine) []string {
+	if vm == nil || vm.Properties == nil || vm.Properties.StorageProfile == nil {
+		return nil
+	}
+
 	vmDisks := vm.Properties.StorageProfile.DataDisks
 
-	diskNames := make([]string, len(vmDisks))
-	for i, v := range vmDisks {
-		diskNames[i] = *v.Name
+	diskNames := make([]string, 0, len(vmDisks))
+
+	for _, v := range vmDisks {
+		if v == nil || v.Name == nil {
+			continue
+		}
+
+		diskNames = append(diskNames, *v.Name)
 	}
 
 	return diskNames
@@ -250,6 +263,11 @@ func GetVirtualMachineOSDiskNameContextE(ctx context.Context, vmName string, res
 
 // extractVMOSDiskName extracts the OS Disk name from a Virtual Machine object.
 func extractVMOSDiskName(vm *armcompute.VirtualMachine) string {
+	if vm == nil || vm.Properties == nil || vm.Properties.StorageProfile == nil ||
+		vm.Properties.StorageProfile.OSDisk == nil || vm.Properties.StorageProfile.OSDisk.Name == nil {
+		return ""
+	}
+
 	return *vm.Properties.StorageProfile.OSDisk.Name
 }
 
@@ -295,7 +313,8 @@ func GetVirtualMachineAvailabilitySetIDContextE(ctx context.Context, vmName stri
 
 // extractVMAvailabilitySetID extracts the Availability Set ID from a Virtual Machine object.
 func extractVMAvailabilitySetID(vm *armcompute.VirtualMachine) (string, error) {
-	if vm.Properties.AvailabilitySet == nil {
+	if vm == nil || vm.Properties == nil || vm.Properties.AvailabilitySet == nil ||
+		vm.Properties.AvailabilitySet.ID == nil {
 		return "", nil
 	}
 
@@ -358,10 +377,15 @@ func GetVirtualMachineImageContextE(ctx context.Context, vmName string, resGroup
 // extractVMImage extracts the Image reference from a Virtual Machine object.
 // For custom images where Publisher/Offer/SKU/Version may be nil, empty strings are returned.
 func extractVMImage(vm *armcompute.VirtualMachine) *VMImage {
-	ref := vm.Properties.StorageProfile.ImageReference
-
 	img := &VMImage{}
 
+	if vm == nil || vm.Properties == nil || vm.Properties.StorageProfile == nil ||
+		vm.Properties.StorageProfile.ImageReference == nil {
+		return img
+	}
+
+	ref := vm.Properties.StorageProfile.ImageReference
+
 	if ref.Publisher != nil {
 		img.Publisher = *ref.Publisher
 	}
@@ -423,6 +447,11 @@ func GetSizeOfVirtualMachineContextE(ctx context.Context, vmName string, resGrou
 
 // extractVMSize extracts the VM size from a Virtual Machine object.
 func extractVMSize(vm *armcompute.VirtualMachine) armcompute.VirtualMachineSizeTypes {
+	if vm == nil || vm.Properties == nil || vm.Properties.HardwareProfile == nil ||
+		vm.Properties.HardwareProfile.VMSize == nil {
+		return ""
+	}
+
 	return *vm.Properties.HardwareProfile.VMSize
 }
 
@@ -470,11 +499,15 @@ func GetVirtualMachineTagsContextE(ctx context.Context, vmName string, resGroupN
 func extractVMTags(vm *armcompute.VirtualMachine) map[string]string {
 	tags := make(map[string]string)
 
-	if vm.Tags == nil {
+	if vm == nil || vm.Tags == nil {
 		return tags
 	}
 
 	for k, v := range vm.Tags {
+		if v == nil {
+			continue
+		}
+
 		tags[k] = *v
 	}
 
@@ -544,6 +577,10 @@ func listVirtualMachineNames(ctx context.Context, client *armcompute.VirtualMach
 		}
 
 		for _, v := range page.Value {
+			if v == nil || v.Name == nil {
+				continue
+			}
+
 			vmDetails = append(vmDetails, *v.Name)
 		}
 	}
@@ -615,6 +652,10 @@ func listVirtualMachineProperties(ctx context.Context, client *armcompute.Virtua
 		}
 
 		for _, v := range page.Value {
+			if v == nil || v.Name == nil || v.Properties == nil {
+				continue
+			}
+
 			vmDetails[*v.Name] = *v.Properties
 		}
 	}
@@ -633,6 +674,11 @@ type Instance struct {
 
 // GetVirtualMachineInstanceSize gets the size of the Virtual Machine.
 func (vm *Instance) GetVirtualMachineInstanceSize() armcompute.VirtualMachineSizeTypes {
+	if vm == nil || vm.VirtualMachine == nil || vm.Properties == nil ||
+		vm.Properties.HardwareProfile == nil || vm.Properties.HardwareProfile.VMSize == nil {
+		return ""
+	}
+
 	return *vm.Properties.HardwareProfile.VMSize
 }
 

modules/azure/loadbalancer.go

@@ -271,7 +271,7 @@ func GetLoadBalancerWithClient(ctx context.Context, client *armnetwork.LoadBalan
 // ExtractLoadBalancerFrontendIPConfigNames gets a list of the Frontend IP Configuration Names
 // from a Load Balancer.
 func ExtractLoadBalancerFrontendIPConfigNames(lb *armnetwork.LoadBalancer) []string {
-	if lb.Properties == nil {
+	if lb == nil || lb.Properties == nil {
 		return nil
 	}
 
@@ -284,9 +284,11 @@ func ExtractLoadBalancerFrontendIPConfigNames(lb *armnetwork.LoadBalancer) []str
 	configNames := make([]string, 0, len(feConfigs))
 
 	for _, config := range feConfigs {
-		if config.Name != nil {
-			configNames = append(configNames, *config.Name)
+		if config == nil || config.Name == nil {
+			continue
 		}
+
+		configNames = append(configNames, *config.Name)
 	}
 
 	return configNames
@@ -296,33 +298,34 @@ func ExtractLoadBalancerFrontendIPConfigNames(lb *armnetwork.LoadBalancer) []str
 // specified Frontend IP Configuration. For public IPs it requires a PublicIPAddressesClient
 // to resolve the public IP address.
 func GetIPOfLoadBalancerFrontendIPConfigWithClient(ctx context.Context, feConfig *armnetwork.FrontendIPConfiguration, pipClient *armnetwork.PublicIPAddressesClient, resourceGroupName string) (string, LoadBalancerIPType, error) {
-	if feConfig.Properties == nil {
+	if feConfig == nil || feConfig.Properties == nil {
 		return "", NoIP, errors.New("frontend IP configuration has nil properties")
 	}
 
 	feProps := feConfig.Properties
 
-	if feProps.PublicIPAddress != nil && feProps.PublicIPAddress.ID != nil {
-		pipName := GetNameFromResourceID(*feProps.PublicIPAddress.ID)
-
-		ipValue, err := GetPublicIPAddressWithClient(ctx, pipClient, resourceGroupName, pipName)
-		if err != nil {
-			return "", NoIP, err
+	pip := feProps.PublicIPAddress
+	if pip == nil || pip.ID == nil {
+		if feProps.PrivateIPAddress == nil {
+			return "", NoIP, errors.New("frontend IP configuration has no private or public IP address assigned")
 		}
 
-		ip, err := ExtractIPOfPublicIPAddress(ipValue)
-		if err != nil {
-			return "", NoIP, err
-		}
+		return *feProps.PrivateIPAddress, PrivateIP, nil
+	}
+
+	pipName := GetNameFromResourceID(*pip.ID)
 
-		return ip, PublicIP, nil
+	ipValue, err := GetPublicIPAddressWithClient(ctx, pipClient, resourceGroupName, pipName)
+	if err != nil {
+		return "", NoIP, err
 	}
 
-	if feProps.PrivateIPAddress == nil {
-		return "", NoIP, errors.New("frontend IP configuration has no private or public IP address assigned")
+	ip, err := ExtractIPOfPublicIPAddress(ipValue)
+	if err != nil {
+		return "", NoIP, err
 	}
 
-	return *feProps.PrivateIPAddress, PrivateIP, nil
+	return ip, PublicIP, nil
 }
 
 // GetLoadBalancerClientContextE gets a new Load Balancer client in the specified Azure Subscription.

modules/azure/networkinterface.go

@@ -133,21 +133,36 @@ func GetNetworkInterfacePublicIPsContextE(ctx context.Context, nicName string, r
 		return publicIPs, err
 	}
 
-	// Get the Public IPs from each configuration available
+	if nic == nil || nic.Properties == nil {
+		return publicIPs, nil
+	}
+
+	// Get the Public IPs from each configuration available.
+	// Not failing on individual errors as this is an optimistic accumulator —
+	// it collects what it can and skips configurations that fail.
 	for _, IPConfiguration := range nic.Properties.IPConfigurations {
-		// Iterate each config, for successful configurations check for a Public Address reference.
-		// Not failing on errors as this is an optimistic accumulator.
+		if IPConfiguration == nil || IPConfiguration.Name == nil {
+			continue
+		}
+
 		nicConfig, err := GetNetworkInterfaceConfigurationContextE(ctx, nicName, *IPConfiguration.Name, resGroupName, subscriptionID)
-		if err == nil {
-			if nicConfig.Properties.PublicIPAddress != nil {
-				publicAddressID := GetNameFromResourceID(*nicConfig.Properties.PublicIPAddress.ID)
-
-				publicIP, err := GetIPOfPublicIPAddressByNameContextE(ctx, publicAddressID, resGroupName, subscriptionID)
-				if err == nil {
-					publicIPs = append(publicIPs, publicIP)
-				}
-			}
+		if err != nil {
+			continue
+		}
+
+		if nicConfig == nil || nicConfig.Properties == nil || nicConfig.Properties.PublicIPAddress == nil ||
+			nicConfig.Properties.PublicIPAddress.ID == nil {
+			continue
 		}
+
+		publicAddressID := GetNameFromResourceID(*nicConfig.Properties.PublicIPAddress.ID)
+
+		publicIP, err := GetIPOfPublicIPAddressByNameContextE(ctx, publicAddressID, resGroupName, subscriptionID)
+		if err != nil {
+			continue
+		}
+
+		publicIPs = append(publicIPs, publicIP)
 	}
 
 	return publicIPs, nil
@@ -234,16 +249,18 @@ func GetNetworkInterfaceWithClient(ctx context.Context, client *armnetwork.Inter
 
 // ExtractNetworkInterfacePrivateIPs gets a list of the Private IPs from a Network Interface.
 func ExtractNetworkInterfacePrivateIPs(nic *armnetwork.Interface) []string {
-	if nic.Properties == nil {
+	if nic == nil || nic.Properties == nil {
 		return nil
 	}
 
 	privateIPs := make([]string, 0, len(nic.Properties.IPConfigurations))
 
 	for _, ipConfig := range nic.Properties.IPConfigurations {
-		if ipConfig.Properties != nil && ipConfig.Properties.PrivateIPAddress != nil {
-			privateIPs = append(privateIPs, *ipConfig.Properties.PrivateIPAddress)
+		if ipConfig == nil || ipConfig.Properties == nil || ipConfig.Properties.PrivateIPAddress == nil {
+			continue
 		}
+
+		privateIPs = append(privateIPs, *ipConfig.Properties.PrivateIPAddress)
 	}
 
 	return privateIPs

modules/azure/nsg.go

@@ -214,6 +214,10 @@ func collectDefaultSecurityRules(ctx context.Context, client *armnetwork.Default
 		}
 
 		for _, rule := range page.Value {
+			if rule == nil {
+				continue
+			}
+
 			rules = append(rules, convertToNsgRuleSummary(rule.Name, rule.Properties))
 		}
 	}
@@ -234,6 +238,10 @@ func collectCustomSecurityRules(ctx context.Context, client *armnetwork.Security
 		}
 
 		for _, rule := range page.Value {
+			if rule == nil {
+				continue
+			}
+
 			rules = append(rules, convertToNsgRuleSummary(rule.Name, rule.Properties))
 		}
 	}

modules/azure/publicaddress.go

@@ -137,6 +137,10 @@ func CheckPublicDNSNameAvailabilityContextE(ctx context.Context, location string
 		return false, err
 	}
 
+	if res.Available == nil {
+		return false, nil
+	}
+
 	return *res.Available, nil
 }
 
@@ -175,6 +179,10 @@ func GetPublicIPAddressWithClient(ctx context.Context, client *armnetwork.Public
 
 // ExtractIPOfPublicIPAddress gets the IP string from a PublicIPAddress.
 func ExtractIPOfPublicIPAddress(pip *armnetwork.PublicIPAddress) (string, error) {
+	if pip == nil {
+		return "", fmt.Errorf("public IP address is nil")
+	}
+
 	if pip.Properties == nil || pip.Properties.IPAddress == nil {
 		name := "<unknown>"
 		if pip.Name != nil {

modules/azure/recoveryservices.go

@@ -234,7 +234,7 @@ func GetBackupPolicyListWithClient(ctx context.Context, client *armrecoveryservi
 		}
 
 		for _, v := range page.Value {
-			if v.Name == nil {
+			if v == nil || v.Name == nil {
 				continue
 			}
 
@@ -262,9 +262,16 @@ func GetBackupProtectedVMListWithClient(ctx context.Context, client *armrecovery
 		}
 
 		for _, item := range page.Value {
-			if vmItem, ok := item.Properties.(*armrecoveryservicesbackup.AzureIaaSComputeVMProtectedItem); ok {
-				vmList[*vmItem.FriendlyName] = *vmItem
+			if item == nil || item.Properties == nil {
+				continue
 			}
+
+			vmItem, ok := item.Properties.(*armrecoveryservicesbackup.AzureIaaSComputeVMProtectedItem)
+			if !ok || vmItem == nil || vmItem.FriendlyName == nil {
+				continue
+			}
+
+			vmList[*vmItem.FriendlyName] = *vmItem
 		}
 	}