github.com/hooklift/terraform@v0.11.0-beta1.0.20171117000744-6786c1361ffe/backend/remote-state/azure/client_test.go (about)

     1  package azure
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/Azure/azure-sdk-for-go/storage"
     7  	"github.com/hashicorp/terraform/backend"
     8  	"github.com/hashicorp/terraform/helper/acctest"
     9  	"github.com/hashicorp/terraform/state/remote"
    10  )
    11  
    12  func TestRemoteClient_impl(t *testing.T) {
    13  	var _ remote.Client = new(RemoteClient)
    14  	var _ remote.ClientLocker = new(RemoteClient)
    15  }
    16  
    17  func TestRemoteClient(t *testing.T) {
    18  	testACC(t)
    19  
    20  	keyName := "testState"
    21  	res := setupResources(t, keyName)
    22  	defer destroyResources(t, res.resourceGroupName)
    23  
    24  	b := backend.TestBackendConfig(t, New(), map[string]interface{}{
    25  		"storage_account_name": res.storageAccountName,
    26  		"container_name":       res.containerName,
    27  		"key":                  keyName,
    28  		"access_key":           res.accessKey,
    29  	}).(*Backend)
    30  
    31  	state, err := b.State(backend.DefaultStateName)
    32  	if err != nil {
    33  		t.Fatal(err)
    34  	}
    35  
    36  	remote.TestClient(t, state.(*remote.State).Client)
    37  }
    38  
    39  func TestRemoteClientLocks(t *testing.T) {
    40  	testACC(t)
    41  
    42  	keyName := "testState"
    43  	res := setupResources(t, keyName)
    44  	defer destroyResources(t, res.resourceGroupName)
    45  
    46  	b1 := backend.TestBackendConfig(t, New(), map[string]interface{}{
    47  		"storage_account_name": res.storageAccountName,
    48  		"container_name":       res.containerName,
    49  		"key":                  keyName,
    50  		"access_key":           res.accessKey,
    51  	}).(*Backend)
    52  
    53  	b2 := backend.TestBackendConfig(t, New(), map[string]interface{}{
    54  		"storage_account_name": res.storageAccountName,
    55  		"container_name":       res.containerName,
    56  		"key":                  keyName,
    57  		"access_key":           res.accessKey,
    58  	}).(*Backend)
    59  
    60  	s1, err := b1.State(backend.DefaultStateName)
    61  	if err != nil {
    62  		t.Fatal(err)
    63  	}
    64  
    65  	s2, err := b2.State(backend.DefaultStateName)
    66  	if err != nil {
    67  		t.Fatal(err)
    68  	}
    69  
    70  	remote.TestRemoteLocks(t, s1.(*remote.State).Client, s2.(*remote.State).Client)
    71  }
    72  
    73  func TestPutMaintainsMetaData(t *testing.T) {
    74  	testACC(t)
    75  
    76  	keyName := "testState"
    77  	headerName := "acceptancetest"
    78  	expectedValue := "f3b56bad-33ad-4b93-a600-7a66e9cbd1eb"
    79  	res := setupResources(t, keyName)
    80  	defer destroyResources(t, res.resourceGroupName)
    81  
    82  	config := getBackendConfig(t, res)
    83  	blobClient, err := getBlobClient(config)
    84  	if err != nil {
    85  		t.Fatalf("Error getting Blob Client: %+v", err)
    86  	}
    87  
    88  	containerReference := blobClient.GetContainerReference(res.containerName)
    89  	blobReference := containerReference.GetBlobReference(keyName)
    90  
    91  	err = blobReference.CreateBlockBlob(&storage.PutBlobOptions{})
    92  	if err != nil {
    93  		t.Fatalf("Error Creating Block Blob: %+v", err)
    94  	}
    95  
    96  	err = blobReference.GetMetadata(&storage.GetBlobMetadataOptions{})
    97  	if err != nil {
    98  		t.Fatalf("Error loading MetaData: %+v", err)
    99  	}
   100  
   101  	blobReference.Metadata[headerName] = expectedValue
   102  	err = blobReference.SetMetadata(&storage.SetBlobMetadataOptions{})
   103  	if err != nil {
   104  		t.Fatalf("Error setting MetaData: %+v", err)
   105  	}
   106  
   107  	// update the metadata using the Backend
   108  	remoteClient := RemoteClient{
   109  		keyName:       res.keyName,
   110  		containerName: res.containerName,
   111  		blobClient:    blobClient,
   112  	}
   113  
   114  	bytes := []byte(acctest.RandString(20))
   115  	err = remoteClient.Put(bytes)
   116  	if err != nil {
   117  		t.Fatalf("Error putting data: %+v", err)
   118  	}
   119  
   120  	// Verify it still exists
   121  	err = blobReference.GetMetadata(&storage.GetBlobMetadataOptions{})
   122  	if err != nil {
   123  		t.Fatalf("Error loading MetaData: %+v", err)
   124  	}
   125  
   126  	if blobReference.Metadata[headerName] != expectedValue {
   127  		t.Fatalf("%q was not set to %q in the MetaData: %+v", headerName, expectedValue, blobReference.Metadata)
   128  	}
   129  }
   130  
   131  func getBackendConfig(t *testing.T, res testResources) BackendConfig {
   132  	clients := getTestClient(t)
   133  	return BackendConfig{
   134  		ClientID:       clients.clientID,
   135  		ClientSecret:   clients.clientSecret,
   136  		Environment:    clients.environment.Name,
   137  		SubscriptionID: clients.subscriptionID,
   138  		TenantID:       clients.tenantID,
   139  
   140  		ResourceGroupName:  res.resourceGroupName,
   141  		StorageAccountName: res.storageAccountName,
   142  	}
   143  }