github.com/terramate-io/tf@v0.0.0-20230830114523-fce866b4dfcd/backend/remote-state/azure/client_test.go (about)

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package azure
     5  
     6  import (
     7  	"context"
     8  	"os"
     9  	"testing"
    10  
    11  	"github.com/terramate-io/tf/backend"
    12  	"github.com/terramate-io/tf/legacy/helper/acctest"
    13  	"github.com/terramate-io/tf/states/remote"
    14  	"github.com/tombuildsstuff/giovanni/storage/2018-11-09/blob/blobs"
    15  )
    16  
    17  func TestRemoteClient_impl(t *testing.T) {
    18  	var _ remote.Client = new(RemoteClient)
    19  	var _ remote.ClientLocker = new(RemoteClient)
    20  }
    21  
    22  func TestRemoteClientAccessKeyBasic(t *testing.T) {
    23  	testAccAzureBackend(t)
    24  	rs := acctest.RandString(4)
    25  	res := testResourceNames(rs, "testState")
    26  	armClient := buildTestClient(t, res)
    27  
    28  	ctx := context.TODO()
    29  	err := armClient.buildTestResources(ctx, &res)
    30  	defer armClient.destroyTestResources(ctx, res)
    31  	if err != nil {
    32  		t.Fatalf("Error creating Test Resources: %q", err)
    33  	}
    34  
    35  	b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
    36  		"storage_account_name": res.storageAccountName,
    37  		"container_name":       res.storageContainerName,
    38  		"key":                  res.storageKeyName,
    39  		"access_key":           res.storageAccountAccessKey,
    40  		"environment":          os.Getenv("ARM_ENVIRONMENT"),
    41  		"endpoint":             os.Getenv("ARM_ENDPOINT"),
    42  	})).(*Backend)
    43  
    44  	state, err := b.StateMgr(backend.DefaultStateName)
    45  	if err != nil {
    46  		t.Fatal(err)
    47  	}
    48  
    49  	remote.TestClient(t, state.(*remote.State).Client)
    50  }
    51  
    52  func TestRemoteClientManagedServiceIdentityBasic(t *testing.T) {
    53  	testAccAzureBackendRunningInAzure(t)
    54  	rs := acctest.RandString(4)
    55  	res := testResourceNames(rs, "testState")
    56  	armClient := buildTestClient(t, res)
    57  
    58  	ctx := context.TODO()
    59  	err := armClient.buildTestResources(ctx, &res)
    60  	defer armClient.destroyTestResources(ctx, res)
    61  	if err != nil {
    62  		t.Fatalf("Error creating Test Resources: %q", err)
    63  	}
    64  
    65  	b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
    66  		"storage_account_name": res.storageAccountName,
    67  		"container_name":       res.storageContainerName,
    68  		"key":                  res.storageKeyName,
    69  		"resource_group_name":  res.resourceGroup,
    70  		"use_msi":              true,
    71  		"subscription_id":      os.Getenv("ARM_SUBSCRIPTION_ID"),
    72  		"tenant_id":            os.Getenv("ARM_TENANT_ID"),
    73  		"environment":          os.Getenv("ARM_ENVIRONMENT"),
    74  		"endpoint":             os.Getenv("ARM_ENDPOINT"),
    75  	})).(*Backend)
    76  
    77  	state, err := b.StateMgr(backend.DefaultStateName)
    78  	if err != nil {
    79  		t.Fatal(err)
    80  	}
    81  
    82  	remote.TestClient(t, state.(*remote.State).Client)
    83  }
    84  
    85  func TestRemoteClientSasTokenBasic(t *testing.T) {
    86  	testAccAzureBackend(t)
    87  	rs := acctest.RandString(4)
    88  	res := testResourceNames(rs, "testState")
    89  	armClient := buildTestClient(t, res)
    90  
    91  	ctx := context.TODO()
    92  	err := armClient.buildTestResources(ctx, &res)
    93  	defer armClient.destroyTestResources(ctx, res)
    94  	if err != nil {
    95  		t.Fatalf("Error creating Test Resources: %q", err)
    96  	}
    97  
    98  	sasToken, err := buildSasToken(res.storageAccountName, res.storageAccountAccessKey)
    99  	if err != nil {
   100  		t.Fatalf("Error building SAS Token: %+v", err)
   101  	}
   102  
   103  	b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
   104  		"storage_account_name": res.storageAccountName,
   105  		"container_name":       res.storageContainerName,
   106  		"key":                  res.storageKeyName,
   107  		"sas_token":            *sasToken,
   108  		"environment":          os.Getenv("ARM_ENVIRONMENT"),
   109  		"endpoint":             os.Getenv("ARM_ENDPOINT"),
   110  	})).(*Backend)
   111  
   112  	state, err := b.StateMgr(backend.DefaultStateName)
   113  	if err != nil {
   114  		t.Fatal(err)
   115  	}
   116  
   117  	remote.TestClient(t, state.(*remote.State).Client)
   118  }
   119  
   120  func TestRemoteClientServicePrincipalBasic(t *testing.T) {
   121  	testAccAzureBackend(t)
   122  	rs := acctest.RandString(4)
   123  	res := testResourceNames(rs, "testState")
   124  	armClient := buildTestClient(t, res)
   125  
   126  	ctx := context.TODO()
   127  	err := armClient.buildTestResources(ctx, &res)
   128  	defer armClient.destroyTestResources(ctx, res)
   129  	if err != nil {
   130  		t.Fatalf("Error creating Test Resources: %q", err)
   131  	}
   132  
   133  	b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
   134  		"storage_account_name": res.storageAccountName,
   135  		"container_name":       res.storageContainerName,
   136  		"key":                  res.storageKeyName,
   137  		"resource_group_name":  res.resourceGroup,
   138  		"subscription_id":      os.Getenv("ARM_SUBSCRIPTION_ID"),
   139  		"tenant_id":            os.Getenv("ARM_TENANT_ID"),
   140  		"client_id":            os.Getenv("ARM_CLIENT_ID"),
   141  		"client_secret":        os.Getenv("ARM_CLIENT_SECRET"),
   142  		"environment":          os.Getenv("ARM_ENVIRONMENT"),
   143  		"endpoint":             os.Getenv("ARM_ENDPOINT"),
   144  	})).(*Backend)
   145  
   146  	state, err := b.StateMgr(backend.DefaultStateName)
   147  	if err != nil {
   148  		t.Fatal(err)
   149  	}
   150  
   151  	remote.TestClient(t, state.(*remote.State).Client)
   152  }
   153  
   154  func TestRemoteClientAccessKeyLocks(t *testing.T) {
   155  	testAccAzureBackend(t)
   156  	rs := acctest.RandString(4)
   157  	res := testResourceNames(rs, "testState")
   158  	armClient := buildTestClient(t, res)
   159  
   160  	ctx := context.TODO()
   161  	err := armClient.buildTestResources(ctx, &res)
   162  	defer armClient.destroyTestResources(ctx, res)
   163  	if err != nil {
   164  		t.Fatalf("Error creating Test Resources: %q", err)
   165  	}
   166  
   167  	b1 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
   168  		"storage_account_name": res.storageAccountName,
   169  		"container_name":       res.storageContainerName,
   170  		"key":                  res.storageKeyName,
   171  		"access_key":           res.storageAccountAccessKey,
   172  		"environment":          os.Getenv("ARM_ENVIRONMENT"),
   173  		"endpoint":             os.Getenv("ARM_ENDPOINT"),
   174  	})).(*Backend)
   175  
   176  	b2 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
   177  		"storage_account_name": res.storageAccountName,
   178  		"container_name":       res.storageContainerName,
   179  		"key":                  res.storageKeyName,
   180  		"access_key":           res.storageAccountAccessKey,
   181  		"environment":          os.Getenv("ARM_ENVIRONMENT"),
   182  		"endpoint":             os.Getenv("ARM_ENDPOINT"),
   183  	})).(*Backend)
   184  
   185  	s1, err := b1.StateMgr(backend.DefaultStateName)
   186  	if err != nil {
   187  		t.Fatal(err)
   188  	}
   189  
   190  	s2, err := b2.StateMgr(backend.DefaultStateName)
   191  	if err != nil {
   192  		t.Fatal(err)
   193  	}
   194  
   195  	remote.TestRemoteLocks(t, s1.(*remote.State).Client, s2.(*remote.State).Client)
   196  }
   197  
   198  func TestRemoteClientServicePrincipalLocks(t *testing.T) {
   199  	testAccAzureBackend(t)
   200  	rs := acctest.RandString(4)
   201  	res := testResourceNames(rs, "testState")
   202  	armClient := buildTestClient(t, res)
   203  
   204  	ctx := context.TODO()
   205  	err := armClient.buildTestResources(ctx, &res)
   206  	defer armClient.destroyTestResources(ctx, res)
   207  	if err != nil {
   208  		t.Fatalf("Error creating Test Resources: %q", err)
   209  	}
   210  
   211  	b1 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
   212  		"storage_account_name": res.storageAccountName,
   213  		"container_name":       res.storageContainerName,
   214  		"key":                  res.storageKeyName,
   215  		"resource_group_name":  res.resourceGroup,
   216  		"subscription_id":      os.Getenv("ARM_SUBSCRIPTION_ID"),
   217  		"tenant_id":            os.Getenv("ARM_TENANT_ID"),
   218  		"client_id":            os.Getenv("ARM_CLIENT_ID"),
   219  		"client_secret":        os.Getenv("ARM_CLIENT_SECRET"),
   220  		"environment":          os.Getenv("ARM_ENVIRONMENT"),
   221  		"endpoint":             os.Getenv("ARM_ENDPOINT"),
   222  	})).(*Backend)
   223  
   224  	b2 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
   225  		"storage_account_name": res.storageAccountName,
   226  		"container_name":       res.storageContainerName,
   227  		"key":                  res.storageKeyName,
   228  		"resource_group_name":  res.resourceGroup,
   229  		"subscription_id":      os.Getenv("ARM_SUBSCRIPTION_ID"),
   230  		"tenant_id":            os.Getenv("ARM_TENANT_ID"),
   231  		"client_id":            os.Getenv("ARM_CLIENT_ID"),
   232  		"client_secret":        os.Getenv("ARM_CLIENT_SECRET"),
   233  		"environment":          os.Getenv("ARM_ENVIRONMENT"),
   234  		"endpoint":             os.Getenv("ARM_ENDPOINT"),
   235  	})).(*Backend)
   236  
   237  	s1, err := b1.StateMgr(backend.DefaultStateName)
   238  	if err != nil {
   239  		t.Fatal(err)
   240  	}
   241  
   242  	s2, err := b2.StateMgr(backend.DefaultStateName)
   243  	if err != nil {
   244  		t.Fatal(err)
   245  	}
   246  
   247  	remote.TestRemoteLocks(t, s1.(*remote.State).Client, s2.(*remote.State).Client)
   248  }
   249  
   250  func TestPutMaintainsMetaData(t *testing.T) {
   251  	testAccAzureBackend(t)
   252  	rs := acctest.RandString(4)
   253  	res := testResourceNames(rs, "testState")
   254  	armClient := buildTestClient(t, res)
   255  
   256  	ctx := context.TODO()
   257  	err := armClient.buildTestResources(ctx, &res)
   258  	defer armClient.destroyTestResources(ctx, res)
   259  	if err != nil {
   260  		t.Fatalf("Error creating Test Resources: %q", err)
   261  	}
   262  
   263  	headerName := "acceptancetest"
   264  	expectedValue := "f3b56bad-33ad-4b93-a600-7a66e9cbd1eb"
   265  
   266  	client, err := armClient.getBlobClient(ctx)
   267  	if err != nil {
   268  		t.Fatalf("Error building Blob Client: %+v", err)
   269  	}
   270  
   271  	_, err = client.PutBlockBlob(ctx, res.storageAccountName, res.storageContainerName, res.storageKeyName, blobs.PutBlockBlobInput{})
   272  	if err != nil {
   273  		t.Fatalf("Error Creating Block Blob: %+v", err)
   274  	}
   275  
   276  	blobReference, err := client.GetProperties(ctx, res.storageAccountName, res.storageContainerName, res.storageKeyName, blobs.GetPropertiesInput{})
   277  	if err != nil {
   278  		t.Fatalf("Error loading MetaData: %+v", err)
   279  	}
   280  
   281  	blobReference.MetaData[headerName] = expectedValue
   282  	opts := blobs.SetMetaDataInput{
   283  		MetaData: blobReference.MetaData,
   284  	}
   285  	_, err = client.SetMetaData(ctx, res.storageAccountName, res.storageContainerName, res.storageKeyName, opts)
   286  	if err != nil {
   287  		t.Fatalf("Error setting MetaData: %+v", err)
   288  	}
   289  
   290  	// update the metadata using the Backend
   291  	remoteClient := RemoteClient{
   292  		keyName:       res.storageKeyName,
   293  		containerName: res.storageContainerName,
   294  		accountName:   res.storageAccountName,
   295  
   296  		giovanniBlobClient: *client,
   297  	}
   298  
   299  	bytes := []byte(acctest.RandString(20))
   300  	err = remoteClient.Put(bytes)
   301  	if err != nil {
   302  		t.Fatalf("Error putting data: %+v", err)
   303  	}
   304  
   305  	// Verify it still exists
   306  	blobReference, err = client.GetProperties(ctx, res.storageAccountName, res.storageContainerName, res.storageKeyName, blobs.GetPropertiesInput{})
   307  	if err != nil {
   308  		t.Fatalf("Error loading MetaData: %+v", err)
   309  	}
   310  
   311  	if blobReference.MetaData[headerName] != expectedValue {
   312  		t.Fatalf("%q was not set to %q in the MetaData: %+v", headerName, expectedValue, blobReference.MetaData)
   313  	}
   314  }