Merge branch '5748-max-buffers-leak-TC' refs #5748

[arvados.git] / services / keepstore / trash_worker_test.go

diff --git a/services/keepstore/trash_worker_test.go b/services/keepstore/trash_worker_test.go
index dee8f174c1795f58a9c00c97f5ff61c72cad08bb..0511b48d372fc3cc33b5513411512f624f12a199 100644 (file)
--- a/services/keepstore/trash_worker_test.go
+++ b/services/keepstore/trash_worker_test.go
@@ -2,8 +2,6 @@ package main
 
 import (
        "container/list"
-       "git.curoverse.com/arvados.git/sdk/go/arvadosclient"
-       "log"
        "testing"
        "time"
 )
@@ -17,11 +15,11 @@ type TrashWorkerTestData struct {
        Block2      []byte
        BlockMtime2 int64
 
-       CreateData       bool
-       CreateInVolume1  bool
-       UseDelayToCreate bool
+       CreateData      bool
+       CreateInVolume1 bool
 
-       UseDefaultTrashTime bool
+       UseTrashLifeTime bool
+       DifferentMtimes  bool
 
        DeleteLocator string
 
@@ -124,8 +122,8 @@ func TestTrashWorkerIntegration_MtimeMatchesForLocator1ButNotForLocator2(t *test
                Locator2: TEST_HASH,
                Block2:   TEST_BLOCK,
 
-               CreateData:       true,
-               UseDelayToCreate: true,
+               CreateData:      true,
+               DifferentMtimes: true,
 
                DeleteLocator: TEST_HASH,
 
@@ -158,7 +156,7 @@ func TestTrashWorkerIntegration_TwoDifferentLocatorsInVolume1(t *testing.T) {
        performTrashWorkerTest(testData, t)
 }
 
-/* Allow defaultTrashLifetime to be used. Thus, the newly created block
+/* Allow default Trash Life time to be used. Thus, the newly created block
    will not be deleted becuase its Mtime is within the trash life time.
 */
 func TestTrashWorkerIntegration_SameLocatorInTwoVolumesWithDefaultTrashLifeTime(t *testing.T) {
@@ -172,11 +170,11 @@ func TestTrashWorkerIntegration_SameLocatorInTwoVolumesWithDefaultTrashLifeTime(
                CreateData:      true,
                CreateInVolume1: true,
 
-               UseDefaultTrashTime: true,
+               UseTrashLifeTime: true,
 
                DeleteLocator: TEST_HASH, // locator 1
 
-               // Since defaultTrashLifetime is in effect, block won't be deleted.
+               // Since trash life time is in effect, block won't be deleted.
                ExpectLocator1: true,
                ExpectLocator2: true,
        }
@@ -187,21 +185,14 @@ func TestTrashWorkerIntegration_SameLocatorInTwoVolumesWithDefaultTrashLifeTime(
 func performTrashWorkerTest(testData TrashWorkerTestData, t *testing.T) {
        // Create Keep Volumes
        KeepVM = MakeTestVolumeManager(2)
-
-       // Delete from volume will not take place if the block MTime is within permission_ttl
-       permission_ttl = time.Duration(1) * time.Second
+       defer KeepVM.Close()
 
        // Put test content
-       vols := KeepVM.Volumes()
+       vols := KeepVM.AllWritable()
        if testData.CreateData {
                vols[0].Put(testData.Locator1, testData.Block1)
                vols[0].Put(testData.Locator1+".meta", []byte("metadata"))
 
-               // One of the tests deletes a locator with different Mtimes in two different volumes
-               if testData.UseDelayToCreate {
-                       time.Sleep(1 * time.Second)
-               }
-
                if testData.CreateInVolume1 {
                        vols[0].Put(testData.Locator2, testData.Block2)
                        vols[0].Put(testData.Locator2+".meta", []byte("metadata"))
@@ -211,31 +202,32 @@ func performTrashWorkerTest(testData TrashWorkerTestData, t *testing.T) {
                }
        }
 
+       oldBlockTime := time.Now().Add(-blob_signature_ttl - time.Minute)
+
        // Create TrashRequest for the test
        trashRequest := TrashRequest{
                Locator:    testData.DeleteLocator,
-               BlockMtime: time.Now().Unix(),
+               BlockMtime: oldBlockTime.Unix(),
        }
 
-       // delay by permission_ttl to allow deletes to work
-       time.Sleep(1 * time.Second)
-
        // Run trash worker and put the trashRequest on trashq
        trashList := list.New()
        trashList.PushBack(trashRequest)
        trashq = NewWorkQueue()
-
-       // Trash worker would not delete block if its Mtime is within defaultTrashLifetime
-       // Hence, we will have to bypass it to allow the deletion to succeed.
-       if !testData.UseDefaultTrashTime {
-               go RunTrashWorker(nil, trashq)
-       } else {
-               arv, err := arvadosclient.MakeArvadosClient()
-               if err != nil {
-                       log.Fatalf("Error setting up arvados client %s", err.Error())
+       defer trashq.Close()
+
+       if !testData.UseTrashLifeTime {
+               // Trash worker would not delete block if its Mtime is
+               // within trash life time. Back-date the block to
+               // allow the deletion to succeed.
+               for _, v := range vols {
+                       v.(*MockVolume).Timestamps[testData.DeleteLocator] = oldBlockTime
+                       if testData.DifferentMtimes {
+                               oldBlockTime = oldBlockTime.Add(time.Second)
+                       }
                }
-               go RunTrashWorker(&arv, trashq)
        }
+       go RunTrashWorker(trashq)
 
        trashq.ReplaceQueue(trashList)
        time.Sleep(10 * time.Millisecond) // give a moment to finish processing the list
@@ -266,22 +258,18 @@ func performTrashWorkerTest(testData TrashWorkerTestData, t *testing.T) {
                }
        }
 
-       // One test used the same locator in two different volumes but with different Mtime values
-       // Hence let's verify that only one volume has it and the other is deleted
-       if (testData.ExpectLocator1) &&
-               (testData.Locator1 == testData.Locator2) {
+       // The DifferentMtimes test puts the same locator in two
+       // different volumes, but only one copy has an Mtime matching
+       // the trash request.
+       if testData.DifferentMtimes {
                locatorFoundIn := 0
-               for _, volume := range KeepVM.Volumes() {
+               for _, volume := range KeepVM.AllReadable() {
                        if _, err := volume.Get(testData.Locator1); err == nil {
                                locatorFoundIn = locatorFoundIn + 1
                        }
                }
                if locatorFoundIn != 1 {
-                       t.Errorf("Expected locator to be found in only one volume after deleting. But found: %s", locatorFoundIn)
+                       t.Errorf("Found %d copies of %s, expected 1", locatorFoundIn, testData.Locator1)
                }
        }
-
-       // Done
-       trashq.Close()
-       KeepVM.Quit()
 }