github.com/danp/terraform@v0.9.5-0.20170426144147-39d740081351/backend/remote-state/consul/client_test.go (about)

     1  package consul
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/hashicorp/terraform/backend"
     9  	"github.com/hashicorp/terraform/state"
    10  	"github.com/hashicorp/terraform/state/remote"
    11  )
    12  
    13  func TestRemoteClient_impl(t *testing.T) {
    14  	var _ remote.Client = new(RemoteClient)
    15  	var _ remote.ClientLocker = new(RemoteClient)
    16  }
    17  
    18  func TestRemoteClient(t *testing.T) {
    19  	srv := newConsulTestServer(t)
    20  	defer srv.Stop()
    21  
    22  	// Get the backend
    23  	b := backend.TestBackendConfig(t, New(), map[string]interface{}{
    24  		"address": srv.HTTPAddr,
    25  		"path":    fmt.Sprintf("tf-unit/%s", time.Now().String()),
    26  	})
    27  
    28  	// Grab the client
    29  	state, err := b.State(backend.DefaultStateName)
    30  	if err != nil {
    31  		t.Fatalf("err: %s", err)
    32  	}
    33  
    34  	// Test
    35  	remote.TestClient(t, state.(*remote.State).Client)
    36  }
    37  
    38  // test the gzip functionality of the client
    39  func TestRemoteClient_gzipUpgrade(t *testing.T) {
    40  	srv := newConsulTestServer(t)
    41  	defer srv.Stop()
    42  
    43  	statePath := fmt.Sprintf("tf-unit/%s", time.Now().String())
    44  
    45  	// Get the backend
    46  	b := backend.TestBackendConfig(t, New(), map[string]interface{}{
    47  		"address": srv.HTTPAddr,
    48  		"path":    statePath,
    49  	})
    50  
    51  	// Grab the client
    52  	state, err := b.State(backend.DefaultStateName)
    53  	if err != nil {
    54  		t.Fatalf("err: %s", err)
    55  	}
    56  
    57  	// Test
    58  	remote.TestClient(t, state.(*remote.State).Client)
    59  
    60  	// create a new backend with gzip
    61  	b = backend.TestBackendConfig(t, New(), map[string]interface{}{
    62  		"address": srv.HTTPAddr,
    63  		"path":    statePath,
    64  		"gzip":    true,
    65  	})
    66  
    67  	// Grab the client
    68  	state, err = b.State(backend.DefaultStateName)
    69  	if err != nil {
    70  		t.Fatalf("err: %s", err)
    71  	}
    72  
    73  	// Test
    74  	remote.TestClient(t, state.(*remote.State).Client)
    75  }
    76  
    77  func TestConsul_stateLock(t *testing.T) {
    78  	srv := newConsulTestServer(t)
    79  	defer srv.Stop()
    80  
    81  	path := fmt.Sprintf("tf-unit/%s", time.Now().String())
    82  
    83  	// create 2 instances to get 2 remote.Clients
    84  	sA, err := backend.TestBackendConfig(t, New(), map[string]interface{}{
    85  		"address": srv.HTTPAddr,
    86  		"path":    path,
    87  	}).State(backend.DefaultStateName)
    88  	if err != nil {
    89  		t.Fatal(err)
    90  	}
    91  
    92  	sB, err := backend.TestBackendConfig(t, New(), map[string]interface{}{
    93  		"address": srv.HTTPAddr,
    94  		"path":    path,
    95  	}).State(backend.DefaultStateName)
    96  	if err != nil {
    97  		t.Fatal(err)
    98  	}
    99  
   100  	remote.TestRemoteLocks(t, sA.(*remote.State).Client, sB.(*remote.State).Client)
   101  }
   102  
   103  func TestConsul_destroyLock(t *testing.T) {
   104  	srv := newConsulTestServer(t)
   105  	defer srv.Stop()
   106  
   107  	// Get the backend
   108  	b := backend.TestBackendConfig(t, New(), map[string]interface{}{
   109  		"address": srv.HTTPAddr,
   110  		"path":    fmt.Sprintf("tf-unit/%s", time.Now().String()),
   111  	})
   112  
   113  	// Grab the client
   114  	s, err := b.State(backend.DefaultStateName)
   115  	if err != nil {
   116  		t.Fatalf("err: %s", err)
   117  	}
   118  
   119  	c := s.(*remote.State).Client.(*RemoteClient)
   120  
   121  	info := state.NewLockInfo()
   122  	id, err := c.Lock(info)
   123  	if err != nil {
   124  		t.Fatal(err)
   125  	}
   126  
   127  	lockPath := c.Path + lockSuffix
   128  
   129  	if err := c.Unlock(id); err != nil {
   130  		t.Fatal(err)
   131  	}
   132  
   133  	// get the lock val
   134  	pair, _, err := c.Client.KV().Get(lockPath, nil)
   135  	if err != nil {
   136  		t.Fatal(err)
   137  	}
   138  	if pair != nil {
   139  		t.Fatalf("lock key not cleaned up at: %s", pair.Key)
   140  	}
   141  }