From 4bdaffb586d776a81b580487a5592df7326fcd5c Mon Sep 17 00:00:00 2001 From: Martin Atkins Date: Mon, 1 Oct 2018 14:55:15 -0700 Subject: [PATCH] state: Remove tests for obsolete components Most of the functionality in this package has been obsoleted by equivalent symbols in states/statemgr. We're keeping this package around for the moment mainly just to house the type aliases in state.go. The tests in here no longer work because they are written against the old APIs. We will eventually remove the components these are testing too, but we're keeping them around for the moment so that we don't break the build for some leftover callers that are still depending on these. --- state/backup_test.go | 65 -------------- state/inmem_test.go | 52 ----------- state/local_test.go | 207 ------------------------------------------- state/state_test.go | 58 ------------ 4 files changed, 382 deletions(-) delete mode 100644 state/backup_test.go delete mode 100644 state/inmem_test.go delete mode 100644 state/local_test.go diff --git a/state/backup_test.go b/state/backup_test.go deleted file mode 100644 index 8ef0afec6..000000000 --- a/state/backup_test.go +++ /dev/null @@ -1,65 +0,0 @@ -package state - -import ( - "io/ioutil" - "os" - "sync" - "testing" -) - -func TestBackupState_locker(t *testing.T) { - var _ Locker = new(BackupState) -} - -func TestBackupState(t *testing.T) { - f, err := ioutil.TempFile("", "tf") - if err != nil { - t.Fatalf("err: %s", err) - } - f.Close() - defer os.Remove(f.Name()) - - ls := testLocalState(t) - defer os.Remove(ls.Path) - TestState(t, &BackupState{ - Real: ls, - Path: f.Name(), - }) - - if fi, err := os.Stat(f.Name()); err != nil { - t.Fatalf("err: %s", err) - } else if fi.Size() == 0 { - t.Fatalf("bad: %d", fi.Size()) - } -} - -func TestBackupStateRace(t *testing.T) { - f, err := ioutil.TempFile("", "tf") - if err != nil { - t.Fatalf("err: %s", err) - } - f.Close() - defer os.Remove(f.Name()) - - ls := testLocalState(t) - defer os.Remove(ls.Path) - bs := &BackupState{ - Real: ls, - Path: f.Name(), - } - - current := TestStateInitial() - - var wg sync.WaitGroup - for i := 0; i < 100; i++ { - wg.Add(1) - go func() { - defer wg.Done() - bs.WriteState(current) - bs.PersistState() - bs.RefreshState() - }() - } - - wg.Wait() -} diff --git a/state/inmem_test.go b/state/inmem_test.go deleted file mode 100644 index 6ca8a69a5..000000000 --- a/state/inmem_test.go +++ /dev/null @@ -1,52 +0,0 @@ -package state - -import ( - "testing" -) - -func TestInmemState(t *testing.T) { - TestState(t, &InmemState{state: TestStateInitial()}) -} - -func TestInmemState_impl(t *testing.T) { - var _ StateReader = new(InmemState) - var _ StateWriter = new(InmemState) - var _ StatePersister = new(InmemState) - var _ StateRefresher = new(InmemState) -} - -func TestInmemLocker(t *testing.T) { - inmem := &InmemState{state: TestStateInitial()} - // test that it correctly wraps the inmem state - s := &inmemLocker{InmemState: inmem} - TestState(t, s) - - info := NewLockInfo() - - id, err := s.Lock(info) - if err != nil { - t.Fatal(err) - } - - if id == "" { - t.Fatal("no lock id from state lock") - } - - // locking again should fail - _, err = s.Lock(NewLockInfo()) - if err == nil { - t.Fatal("state locked while locked") - } - - if err.(*LockError).Info.ID != id { - t.Fatal("wrong lock id from lock failure") - } - - if err := s.Unlock(id); err != nil { - t.Fatal(err) - } - - if _, err := s.Lock(NewLockInfo()); err != nil { - t.Fatal(err) - } -} diff --git a/state/local_test.go b/state/local_test.go deleted file mode 100644 index 13dcf6eab..000000000 --- a/state/local_test.go +++ /dev/null @@ -1,207 +0,0 @@ -package state - -import ( - "io/ioutil" - "os" - "os/exec" - "sync" - "testing" - - "github.com/hashicorp/terraform/terraform" -) - -func TestLocalState(t *testing.T) { - ls := testLocalState(t) - defer os.Remove(ls.Path) - TestState(t, ls) -} - -func TestLocalStateRace(t *testing.T) { - ls := testLocalState(t) - defer os.Remove(ls.Path) - - current := TestStateInitial() - - var wg sync.WaitGroup - for i := 0; i < 100; i++ { - wg.Add(1) - go func() { - defer wg.Done() - ls.WriteState(current) - }() - } -} - -func TestLocalStateLocks(t *testing.T) { - s := testLocalState(t) - defer os.Remove(s.Path) - - // lock first - info := NewLockInfo() - info.Operation = "test" - lockID, err := s.Lock(info) - if err != nil { - t.Fatal(err) - } - - out, err := exec.Command("go", "run", "testdata/lockstate.go", s.Path).CombinedOutput() - if err != nil { - t.Fatal("unexpected lock failure", err, string(out)) - } - - if string(out) != "lock failed" { - t.Fatal("expected 'locked failed', got", string(out)) - } - - // check our lock info - lockInfo, err := s.lockInfo() - if err != nil { - t.Fatal(err) - } - - if lockInfo.Operation != "test" { - t.Fatalf("invalid lock info %#v\n", lockInfo) - } - - // a noop, since we unlock on exit - if err := s.Unlock(lockID); err != nil { - t.Fatal(err) - } - - // local locks can re-lock - lockID, err = s.Lock(info) - if err != nil { - t.Fatal(err) - } - - if err := s.Unlock(lockID); err != nil { - t.Fatal(err) - } - - // we should not be able to unlock the same lock twice - if err := s.Unlock(lockID); err == nil { - t.Fatal("unlocking an unlocked state should fail") - } - - // make sure lock info is gone - lockInfoPath := s.lockInfoPath() - if _, err := os.Stat(lockInfoPath); !os.IsNotExist(err) { - t.Fatal("lock info not removed") - } -} - -// Verify that we can write to the state file, as Windows' mandatory locking -// will prevent writing to a handle different than the one that hold the lock. -func TestLocalState_writeWhileLocked(t *testing.T) { - s := testLocalState(t) - defer os.Remove(s.Path) - - // lock first - info := NewLockInfo() - info.Operation = "test" - lockID, err := s.Lock(info) - if err != nil { - t.Fatal(err) - } - defer func() { - if err := s.Unlock(lockID); err != nil { - t.Fatal(err) - } - }() - - if err := s.WriteState(TestStateInitial()); err != nil { - t.Fatal(err) - } -} - -func TestLocalState_pathOut(t *testing.T) { - f, err := ioutil.TempFile("", "tf") - if err != nil { - t.Fatalf("err: %s", err) - } - f.Close() - defer os.Remove(f.Name()) - - ls := testLocalState(t) - ls.PathOut = f.Name() - defer os.Remove(ls.Path) - - TestState(t, ls) -} - -func TestLocalState_nonExist(t *testing.T) { - ls := &LocalState{Path: "ishouldntexist"} - if err := ls.RefreshState(); err != nil { - t.Fatalf("err: %s", err) - } - - if state := ls.State(); state != nil { - t.Fatalf("bad: %#v", state) - } -} - -func TestLocalState_impl(t *testing.T) { - var _ StateReader = new(LocalState) - var _ StateWriter = new(LocalState) - var _ StatePersister = new(LocalState) - var _ StateRefresher = new(LocalState) -} - -func testLocalState(t *testing.T) *LocalState { - f, err := ioutil.TempFile("", "tf") - if err != nil { - t.Fatalf("err: %s", err) - } - - err = terraform.WriteState(TestStateInitial(), f) - f.Close() - if err != nil { - t.Fatalf("err: %s", err) - } - - ls := &LocalState{Path: f.Name()} - if err := ls.RefreshState(); err != nil { - t.Fatalf("bad: %s", err) - } - - return ls -} - -// Make sure we can refresh while the state is locked -func TestLocalState_refreshWhileLocked(t *testing.T) { - f, err := ioutil.TempFile("", "tf") - if err != nil { - t.Fatalf("err: %s", err) - } - - err = terraform.WriteState(TestStateInitial(), f) - f.Close() - if err != nil { - t.Fatalf("err: %s", err) - } - - s := &LocalState{Path: f.Name()} - defer os.Remove(s.Path) - - // lock first - info := NewLockInfo() - info.Operation = "test" - lockID, err := s.Lock(info) - if err != nil { - t.Fatal(err) - } - defer func() { - if err := s.Unlock(lockID); err != nil { - t.Fatal(err) - } - }() - - if err := s.RefreshState(); err != nil { - t.Fatal(err) - } - - readState := s.State() - if readState == nil || readState.Lineage == "" { - t.Fatal("missing state") - } -} diff --git a/state/state_test.go b/state/state_test.go index a8fdec6ab..e93f5680a 100644 --- a/state/state_test.go +++ b/state/state_test.go @@ -1,14 +1,12 @@ package state import ( - "context" "encoding/json" "flag" "io/ioutil" "log" "os" "testing" - "time" "github.com/hashicorp/terraform/helper/logging" ) @@ -52,59 +50,3 @@ func TestNewLockInfo(t *testing.T) { t.Fatal(err) } } - -func TestLockWithContext(t *testing.T) { - inmem := &InmemState{state: TestStateInitial()} - // test that it correctly wraps the inmem state - s := &inmemLocker{InmemState: inmem} - - id, err := s.Lock(NewLockInfo()) - if err != nil { - t.Fatal(err) - } - - // use a cancelled context for an immediate timeout - ctx, cancel := context.WithCancel(context.Background()) - cancel() - - info := NewLockInfo() - info.Info = "lock with context" - _, err = LockWithContext(ctx, s, info) - if err == nil { - t.Fatal("lock should have failed immediately") - } - - // block until LockwithContext has made a first attempt - attempted := make(chan struct{}) - postLockHook = func() { - close(attempted) - postLockHook = nil - } - - // unlock the state during LockWithContext - unlocked := make(chan struct{}) - go func() { - defer close(unlocked) - <-attempted - if err := s.Unlock(id); err != nil { - t.Fatal(err) - } - }() - - ctx, cancel = context.WithTimeout(context.Background(), 2*time.Second) - defer cancel() - - id, err = LockWithContext(ctx, s, info) - if err != nil { - t.Fatal("lock should have completed within 2s:", err) - } - - // ensure the goruotine completes - <-unlocked - - // Lock should have been called a total of 4 times. - // 1 initial lock, 1 failure, 1 failure + 1 retry - if s.lockCounter != 4 { - t.Fatalf("lock only called %d times", s.lockCounter) - } -}