chore(azure): consolidate test files and add WithClient variants for all modules

Test cleanup:
- Delete old //go:build azure integration test stubs that required real
  Azure credentials and were never run in CI
- Rename _withclient_test.go files to _test.go
- Delete azure.go (package doc moved to client_factory.go)

WithClient extraction (all remaining modules):
- compute.go: GetVirtualMachineWithClient, ListVirtualMachinesForResourceGroupWithClient, GetVirtualMachinesForResourceGroupWithClient
- storage.go: GetStorageAccountPropertyWithClient, GetStorageBlobContainerWithClient, GetStorageFileShareWithClient
- appService.go: GetAppServiceWithClient
- keyvault.go: GetKeyVaultWithClient
- container_apps.go: GetManagedEnvironmentWithClient, GetContainerAppWithClient, GetContainerAppJobWithClient
- datafactory.go: GetDataFactoryWithClient
- privatednszone.go: GetPrivateDNSZoneWithClient
- mysql.go: GetMYSQLServerWithClient, GetMYSQLDBWithClient, ListMySQLDBWithClient
- postgresql.go: GetPostgreSQLServerWithClient, GetPostgreSQLDBWithClient, ListPostgreSQLDBWithClient
- sql.go: GetSQLServerWithClient, GetSQLDatabaseWithClient, ListSQLServerDatabasesWithClient
- sql_managedinstance.go: GetManagedInstanceWithClient, GetManagedInstanceDatabaseWithClient
- synapse.go: GetSynapseWorkspaceWithClient, GetSynapseSQLPoolWithClient
- nsg.go: GetDefaultNSGRulesWithClient, GetCustomNSGRulesWithClient

Every module file now has azfake unit tests.

Author: james00012

modules/azure/aks_withclient_test.go modules/azure/aks_test.gomodules/azure/aks_withclient_test.go renamed to modules/azure/aks_test.go

@@ -87,7 +87,13 @@ func GetAppServiceContextE(ctx context.Context, appName string, resGroupName str
 		return nil, err
 	}
 
-	resp, err := client.Get(ctx, rgName, appName, nil)
+	return GetAppServiceWithClient(ctx, client, rgName, appName)
+}
+
+// GetAppServiceWithClient gets the App service object using the provided client.
+// This variant is useful for testing with fake clients.
+func GetAppServiceWithClient(ctx context.Context, client *armappservice.WebAppsClient, resourceGroupName string, appName string) (*armappservice.Site, error) {
+	resp, err := client.Get(ctx, resourceGroupName, appName, nil)
 	if err != nil {
 		return nil, err
 	}

modules/azure/appService.go

@@ -1,50 +1,101 @@
-//go:build azure
-// +build azure
-
-// NOTE: We use build tags to differentiate azure testing because we currently do not have azure access setup for
-// CircleCI.
-
 package azure_test
 
 import (
+	"context"
+	"net/http"
 	"testing"
 
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/arm"
+	azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appservice/armappservice/v2"
+	appservicefake "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appservice/armappservice/v2/fake"
 	"github.com/gruntwork-io/terratest/modules/azure"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-/*
-The below tests are currently stubbed out, with the expectation that they will throw errors.
-If/when CRUD methods are introduced for Azure MySQL server and database, these tests can be extended
-*/
+// ---------------------------------------------------------------------------
+// Fake client helper
+// ---------------------------------------------------------------------------
 
-func TestAppExistsE(t *testing.T) {
-	t.Parallel()
+func newFakeWebAppsClient(t *testing.T, srv *appservicefake.WebAppsServer) *armappservice.WebAppsClient {
+	t.Helper()
 
-	resGroupName := ""
-	appName := ""
-	subscriptionID := ""
+	client, err := armappservice.NewWebAppsClient("fake-sub", &azfake.TokenCredential{},
+		&arm.ClientOptions{ClientOptions: policy.ClientOptions{
+			Transport: appservicefake.NewWebAppsServerTransport(srv),
+		}})
+	require.NoError(t, err)
 
-	_, err := azure.AppExistsE(appName, resGroupName, subscriptionID)
-	require.Error(t, err)
+	return client
 }
 
-func TestGetAppServiceE(t *testing.T) {
+// ---------------------------------------------------------------------------
+// GetAppServiceWithClient tests
+// ---------------------------------------------------------------------------
+
+func TestGetAppServiceWithClient(t *testing.T) {
 	t.Parallel()
 
-	resGroupName := ""
-	appName := ""
-	subscriptionID := ""
+	tests := []struct { //nolint:govet // fieldalignment not worth optimizing in test structs
+		name      string
+		wantName  string
+		errSubstr string
+		server    appservicefake.WebAppsServer
+		wantErr   bool
+	}{
+		{
+			name: "Success",
+			server: appservicefake.WebAppsServer{
+				Get: func(_ context.Context, _ string, _ string, _ *armappservice.WebAppsClientGetOptions) (resp azfake.Responder[armappservice.WebAppsClientGetResponse], errResp azfake.ErrorResponder) {
+					result := armappservice.WebAppsClientGetResponse{
+						Site: armappservice.Site{
+							Name: to.Ptr("test-app"),
+						},
+					}
+					resp.SetResponse(http.StatusOK, result, nil)
 
-	_, err := azure.GetAppServiceE(appName, resGroupName, subscriptionID)
-	require.Error(t, err)
-}
+					return
+				},
+			},
+			wantName: "test-app",
+		},
+		{
+			name: "NotFound",
+			server: appservicefake.WebAppsServer{
+				Get: func(_ context.Context, _ string, _ string, _ *armappservice.WebAppsClientGetOptions) (resp azfake.Responder[armappservice.WebAppsClientGetResponse], errResp azfake.ErrorResponder) {
+					errResp.SetResponseError(http.StatusNotFound, "ResourceNotFound")
 
-func TestGetAppServiceClientE(t *testing.T) {
-	t.Parallel()
+					return
+				},
+			},
+			wantErr:   true,
+			errSubstr: "ResourceNotFound",
+		},
+	}
 
-	subscriptionID := ""
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
 
-	_, err := azure.GetAppServiceClientE(subscriptionID)
-	require.NoError(t, err)
+			client := newFakeWebAppsClient(t, &tc.server)
+
+			site, err := azure.GetAppServiceWithClient(context.Background(), client, "rg", "app")
+			if tc.wantErr {
+				require.Error(t, err)
+
+				var respErr *azcore.ResponseError
+				require.ErrorAs(t, err, &respErr)
+				assert.Equal(t, tc.errSubstr, respErr.ErrorCode)
+
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tc.wantName, *site.Name)
+		})
+	}
 }

modules/azure/appService_test.go

@@ -1,93 +1,149 @@
-//go:build azure
-// +build azure
-
-// NOTE: We use build tags to differentiate azure testing because we currently do not have azure access setup for
-// CircleCI.
-
 package azure_test
 
 import (
 	"context"
+	"net/http"
 	"testing"
 
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/arm"
+	azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
+	computefake "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6/fake"
 	"github.com/gruntwork-io/terratest/modules/azure"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-/*
-The below tests are currently stubbed out, with the expectation that they will throw errors.
-If/when methods to create and delete network resources are added, these tests can be extended.
-*/
-
-func TestCreateAvailabilitySetClientE(t *testing.T) {
-	t.Parallel()
+func newFakeAvailabilitySetsClient(t *testing.T, srv *computefake.AvailabilitySetsServer) *armcompute.AvailabilitySetsClient {
+	t.Helper()
 
-	subscriptionID := ""
+	transport := computefake.NewAvailabilitySetsServerTransport(srv)
+	client, err := armcompute.NewAvailabilitySetsClient("fake-sub", &azfake.TokenCredential{}, &arm.ClientOptions{
+		ClientOptions: policy.ClientOptions{Transport: transport},
+	})
+	require.NoError(t, err)
 
-	client, err := azure.CreateAvailabilitySetClientE(subscriptionID)
+	return client
+}
 
-	require.NoError(t, err)
-	assert.NotEmpty(t, *client)
+func fakeAvsGetHandler(avsName string, vmIDs []string, faultDomainCount int32) func(context.Context, string, string, *armcompute.AvailabilitySetsClientGetOptions) (azfake.Responder[armcompute.AvailabilitySetsClientGetResponse], azfake.ErrorResponder) {
+	return func(_ context.Context, _ string, _ string, _ *armcompute.AvailabilitySetsClientGetOptions) (resp azfake.Responder[armcompute.AvailabilitySetsClientGetResponse], errResp azfake.ErrorResponder) {
+		vms := make([]*armcompute.SubResource, len(vmIDs))
+		for i, id := range vmIDs {
+			vms[i] = &armcompute.SubResource{ID: to.Ptr(id)}
+		}
+
+		resp.SetResponse(http.StatusOK, armcompute.AvailabilitySetsClientGetResponse{
+			AvailabilitySet: armcompute.AvailabilitySet{
+				Name: to.Ptr(avsName),
+				Properties: &armcompute.AvailabilitySetProperties{
+					VirtualMachines:          vms,
+					PlatformFaultDomainCount: to.Ptr(faultDomainCount),
+				},
+			},
+		}, nil)
+
+		return
+	}
 }
 
-func TestGetAvailabilitySetE(t *testing.T) {
+func TestGetAvailabilitySetWithClient(t *testing.T) {
 	t.Parallel()
 
-	avsName := ""
-	rgName := ""
-	subscriptionID := ""
-
-	_, err := azure.GetAvailabilitySetContextE(t, context.Background(), avsName, rgName, subscriptionID)
+	srv := &computefake.AvailabilitySetsServer{
+		Get: fakeAvsGetHandler("my-avs", nil, 2),
+	}
+	client := newFakeAvailabilitySetsClient(t, srv)
 
-	require.Error(t, err)
+	avs, err := azure.GetAvailabilitySetWithClient(t.Context(), client, "rg", "my-avs")
+	require.NoError(t, err)
+	assert.Equal(t, "my-avs", *avs.Name)
 }
 
-func TestCheckAvailabilitySetContainsVME(t *testing.T) {
+func TestCheckAvailabilitySetContainsVMWithClient(t *testing.T) {
 	t.Parallel()
 
-	vmName := ""
-	avsName := ""
-	rgName := ""
-	subscriptionID := ""
-
-	_, err := azure.CheckAvailabilitySetContainsVMContextE(t, context.Background(), vmName, avsName, rgName, subscriptionID)
-
-	require.Error(t, err)
+	vmIDs := []string{
+		"/subscriptions/sub/resourceGroups/RG/providers/Microsoft.Compute/virtualMachines/VM-ONE",
+		"/subscriptions/sub/resourceGroups/RG/providers/Microsoft.Compute/virtualMachines/VM-TWO",
+	}
+
+	tests := []struct {
+		name    string
+		vmName  string
+		found   bool
+		wantErr bool
+	}{
+		{name: "exact case match", vmName: "VM-ONE", found: true},
+		{name: "case insensitive match", vmName: "vm-one", found: true},
+		{name: "not found", vmName: "vm-three", found: false, wantErr: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			srv := &computefake.AvailabilitySetsServer{
+				Get: fakeAvsGetHandler("avs", vmIDs, 2),
+			}
+			client := newFakeAvailabilitySetsClient(t, srv)
+
+			found, err := azure.CheckAvailabilitySetContainsVMWithClient(t.Context(), client, "rg", "avs", tc.vmName)
+
+			if tc.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+
+			assert.Equal(t, tc.found, found)
+		})
+	}
 }
 
-func TestGetAvailabilitySetVMNamesInCapsE(t *testing.T) {
+func TestGetAvailabilitySetVMNamesInCapsWithClient(t *testing.T) {
 	t.Parallel()
 
-	avsName := ""
-	rgName := ""
-	subscriptionID := ""
+	vmIDs := []string{
+		"/subscriptions/sub/resourceGroups/RG/providers/Microsoft.Compute/virtualMachines/VM-ALPHA",
+		"/subscriptions/sub/resourceGroups/RG/providers/Microsoft.Compute/virtualMachines/VM-BETA",
+	}
 
-	_, err := azure.GetAvailabilitySetVMNamesInCapsContextE(t, context.Background(), avsName, rgName, subscriptionID)
+	srv := &computefake.AvailabilitySetsServer{
+		Get: fakeAvsGetHandler("avs", vmIDs, 3),
+	}
+	client := newFakeAvailabilitySetsClient(t, srv)
 
-	require.Error(t, err)
+	names, err := azure.GetAvailabilitySetVMNamesInCapsWithClient(t.Context(), client, "rg", "avs")
+	require.NoError(t, err)
+	assert.Equal(t, []string{"VM-ALPHA", "VM-BETA"}, names)
 }
 
-func TestGetAvailabilitySetFaultDomainCountE(t *testing.T) {
+func TestExtractAvailabilitySetFaultDomainCount(t *testing.T) {
 	t.Parallel()
 
-	avsName := ""
-	rgName := ""
-	subscriptionID := ""
+	t.Run("valid", func(t *testing.T) {
+		t.Parallel()
 
-	_, err := azure.GetAvailabilitySetFaultDomainCountContextE(t, context.Background(), avsName, rgName, subscriptionID)
+		avs := &armcompute.AvailabilitySet{
+			Properties: &armcompute.AvailabilitySetProperties{
+				PlatformFaultDomainCount: to.Ptr[int32](3),
+			},
+		}
 
-	require.Error(t, err)
-}
-
-func TestAvailabilitySetExistsE(t *testing.T) {
-	t.Parallel()
+		count, err := azure.ExtractAvailabilitySetFaultDomainCount(avs)
+		require.NoError(t, err)
+		assert.Equal(t, int32(3), count)
+	})
 
-	avsName := ""
-	rgName := ""
-	subscriptionID := ""
+	t.Run("nil properties", func(t *testing.T) {
+		t.Parallel()
 
-	_, err := azure.AvailabilitySetExistsContextE(t, context.Background(), avsName, rgName, subscriptionID)
+		avs := &armcompute.AvailabilitySet{}
 
-	require.Error(t, err)
+		_, err := azure.ExtractAvailabilitySetFaultDomainCount(avs)
+		require.Error(t, err)
+	})
 }