github.com/rliebz/terraform@v0.9.0-beta2.0.20170307220345-5d894e4ffda7/backend/testing.go (about)

     1  package backend
     2  
     3  import (
     4  	"reflect"
     5  	"sort"
     6  	"testing"
     7  
     8  	"github.com/hashicorp/terraform/config"
     9  	"github.com/hashicorp/terraform/terraform"
    10  )
    11  
    12  // TestBackendConfig validates and configures the backend with the
    13  // given configuration.
    14  func TestBackendConfig(t *testing.T, b Backend, c map[string]interface{}) Backend {
    15  	// Get the proper config structure
    16  	rc, err := config.NewRawConfig(c)
    17  	if err != nil {
    18  		t.Fatalf("bad: %s", err)
    19  	}
    20  	conf := terraform.NewResourceConfig(rc)
    21  
    22  	// Validate
    23  	warns, errs := b.Validate(conf)
    24  	if len(warns) > 0 {
    25  		t.Fatalf("warnings: %s", warns)
    26  	}
    27  	if len(errs) > 0 {
    28  		t.Fatalf("errors: %s", errs)
    29  	}
    30  
    31  	// Configure
    32  	if err := b.Configure(conf); err != nil {
    33  		t.Fatalf("err: %s", err)
    34  	}
    35  
    36  	return b
    37  }
    38  
    39  // TestBackend will test the functionality of a Backend. The backend is
    40  // assumed to already be configured. This will test state functionality.
    41  // If the backend reports it doesn't support multi-state by returning the
    42  // error ErrNamedStatesNotSupported, then it will not test that.
    43  func TestBackend(t *testing.T, b Backend) {
    44  	testBackendStates(t, b)
    45  }
    46  
    47  func testBackendStates(t *testing.T, b Backend) {
    48  	states, err := b.States()
    49  	if err == ErrNamedStatesNotSupported {
    50  		t.Logf("TestBackend: named states not supported in %T, skipping", b)
    51  		return
    52  	}
    53  
    54  	// Test it starts with only the default
    55  	if len(states) != 1 || states[0] != DefaultStateName {
    56  		t.Fatalf("should only have default to start: %#v", states)
    57  	}
    58  
    59  	// Create a couple states
    60  	fooState, err := b.State("foo")
    61  	if err != nil {
    62  		t.Fatalf("error: %s", err)
    63  	}
    64  	if err := fooState.RefreshState(); err != nil {
    65  		t.Fatalf("bad: %s", err)
    66  	}
    67  	if v := fooState.State(); v.HasResources() {
    68  		t.Fatalf("should be empty: %s", v)
    69  	}
    70  
    71  	barState, err := b.State("bar")
    72  	if err != nil {
    73  		t.Fatalf("error: %s", err)
    74  	}
    75  	if err := barState.RefreshState(); err != nil {
    76  		t.Fatalf("bad: %s", err)
    77  	}
    78  	if v := barState.State(); v.HasResources() {
    79  		t.Fatalf("should be empty: %s", v)
    80  	}
    81  
    82  	// Verify they are distinct states
    83  	{
    84  		s := barState.State()
    85  		s.Lineage = "bar"
    86  		if err := barState.WriteState(s); err != nil {
    87  			t.Fatalf("bad: %s", err)
    88  		}
    89  		if err := barState.PersistState(); err != nil {
    90  			t.Fatalf("bad: %s", err)
    91  		}
    92  
    93  		if err := fooState.RefreshState(); err != nil {
    94  			t.Fatalf("bad: %s", err)
    95  		}
    96  		if v := fooState.State(); v.Lineage == "bar" {
    97  			t.Fatalf("bad: %#v", v)
    98  		}
    99  	}
   100  
   101  	// Verify we can now list them
   102  	{
   103  		states, err := b.States()
   104  		if err == ErrNamedStatesNotSupported {
   105  			t.Logf("TestBackend: named states not supported in %T, skipping", b)
   106  			return
   107  		}
   108  
   109  		sort.Strings(states)
   110  		expected := []string{"bar", "default", "foo"}
   111  		if !reflect.DeepEqual(states, expected) {
   112  			t.Fatalf("bad: %#v", states)
   113  		}
   114  	}
   115  
   116  	// Delete some states
   117  	if err := b.DeleteState("foo"); err != nil {
   118  		t.Fatalf("err: %s", err)
   119  	}
   120  
   121  	// Verify the default state can't be deleted
   122  	if err := b.DeleteState(DefaultStateName); err == nil {
   123  		t.Fatal("expected error")
   124  	}
   125  
   126  	// Verify deletion
   127  	{
   128  		states, err := b.States()
   129  		if err == ErrNamedStatesNotSupported {
   130  			t.Logf("TestBackend: named states not supported in %T, skipping", b)
   131  			return
   132  		}
   133  
   134  		sort.Strings(states)
   135  		expected := []string{"bar", "default"}
   136  		if !reflect.DeepEqual(states, expected) {
   137  			t.Fatalf("bad: %#v", states)
   138  		}
   139  	}
   140  }