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

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package kubernetes
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/terramate-io/tf/backend"
    10  	"github.com/terramate-io/tf/states/remote"
    11  	"github.com/terramate-io/tf/states/statemgr"
    12  )
    13  
    14  func TestRemoteClient_impl(t *testing.T) {
    15  	var _ remote.Client = new(RemoteClient)
    16  	var _ remote.ClientLocker = new(RemoteClient)
    17  }
    18  
    19  func TestRemoteClient(t *testing.T) {
    20  	testACC(t)
    21  	defer cleanupK8sResources(t)
    22  
    23  	b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
    24  		"secret_suffix": secretSuffix,
    25  	}))
    26  
    27  	state, err := b.StateMgr(backend.DefaultStateName)
    28  	if err != nil {
    29  		t.Fatal(err)
    30  	}
    31  
    32  	remote.TestClient(t, state.(*remote.State).Client)
    33  }
    34  
    35  func TestRemoteClientLocks(t *testing.T) {
    36  	testACC(t)
    37  	defer cleanupK8sResources(t)
    38  
    39  	b1 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
    40  		"secret_suffix": secretSuffix,
    41  	}))
    42  
    43  	b2 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
    44  		"secret_suffix": secretSuffix,
    45  	}))
    46  
    47  	s1, err := b1.StateMgr(backend.DefaultStateName)
    48  	if err != nil {
    49  		t.Fatal(err)
    50  	}
    51  
    52  	s2, err := b2.StateMgr(backend.DefaultStateName)
    53  	if err != nil {
    54  		t.Fatal(err)
    55  	}
    56  
    57  	remote.TestRemoteLocks(t, s1.(*remote.State).Client, s2.(*remote.State).Client)
    58  }
    59  
    60  func TestForceUnlock(t *testing.T) {
    61  	testACC(t)
    62  	defer cleanupK8sResources(t)
    63  
    64  	b1 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
    65  		"secret_suffix": secretSuffix,
    66  	}))
    67  
    68  	b2 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
    69  		"secret_suffix": secretSuffix,
    70  	}))
    71  
    72  	// first test with default
    73  	s1, err := b1.StateMgr(backend.DefaultStateName)
    74  	if err != nil {
    75  		t.Fatal(err)
    76  	}
    77  
    78  	info := statemgr.NewLockInfo()
    79  	info.Operation = "test"
    80  	info.Who = "clientA"
    81  
    82  	lockID, err := s1.Lock(info)
    83  	if err != nil {
    84  		t.Fatal("unable to get initial lock:", err)
    85  	}
    86  
    87  	// s1 is now locked, get the same state through s2 and unlock it
    88  	s2, err := b2.StateMgr(backend.DefaultStateName)
    89  	if err != nil {
    90  		t.Fatal("failed to get default state to force unlock:", err)
    91  	}
    92  
    93  	if err := s2.Unlock(lockID); err != nil {
    94  		t.Fatal("failed to force-unlock default state")
    95  	}
    96  
    97  	// now try the same thing with a named state
    98  	// first test with default
    99  	s1, err = b1.StateMgr("test")
   100  	if err != nil {
   101  		t.Fatal(err)
   102  	}
   103  
   104  	info = statemgr.NewLockInfo()
   105  	info.Operation = "test"
   106  	info.Who = "clientA"
   107  
   108  	lockID, err = s1.Lock(info)
   109  	if err != nil {
   110  		t.Fatal("unable to get initial lock:", err)
   111  	}
   112  
   113  	// s1 is now locked, get the same state through s2 and unlock it
   114  	s2, err = b2.StateMgr("test")
   115  	if err != nil {
   116  		t.Fatal("failed to get named state to force unlock:", err)
   117  	}
   118  
   119  	if err = s2.Unlock(lockID); err != nil {
   120  		t.Fatal("failed to force-unlock named state")
   121  	}
   122  }