X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/ac037435f2ee9688957f1c0be6bfa9066ac027ba..2d4198a095e193102daa2710c6b2baba7be7c9ce:/services/keepstore/trash_worker_test.go?ds=sidebyside

diff --git a/services/keepstore/trash_worker_test.go b/services/keepstore/trash_worker_test.go
index e4f7fb3a0b..0511b48d37 100644
--- a/services/keepstore/trash_worker_test.go
+++ b/services/keepstore/trash_worker_test.go
@@ -15,9 +15,11 @@ type TrashWorkerTestData struct {
 	Block2      []byte
 	BlockMtime2 int64
 
-	CreateData       bool
-	CreateInVolume1  bool
-	UseDelayToCreate bool
+	CreateData      bool
+	CreateInVolume1 bool
+
+	UseTrashLifeTime bool
+	DifferentMtimes  bool
 
 	DeleteLocator string
 
@@ -120,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,
 
@@ -154,29 +156,43 @@ func TestTrashWorkerIntegration_TwoDifferentLocatorsInVolume1(t *testing.T) {
 	performTrashWorkerTest(testData, t)
 }
 
+/* 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) {
+	testData := TrashWorkerTestData{
+		Locator1: TEST_HASH,
+		Block1:   TEST_BLOCK,
+
+		Locator2: TEST_HASH_2,
+		Block2:   TEST_BLOCK_2,
+
+		CreateData:      true,
+		CreateInVolume1: true,
+
+		UseTrashLifeTime: true,
+
+		DeleteLocator: TEST_HASH, // locator 1
+
+		// Since trash life time is in effect, block won't be deleted.
+		ExpectLocator1: true,
+		ExpectLocator2: true,
+	}
+	performTrashWorkerTest(testData, t)
+}
+
 /* Perform the test */
 func performTrashWorkerTest(testData TrashWorkerTestData, t *testing.T) {
 	// Create Keep Volumes
 	KeepVM = MakeTestVolumeManager(2)
-
-	// Set trash life time delta to 0 so that the test can delete the blocks right after create
-	DEFAULT_TRASH_LIFE_TIME = 0
-
-	// Delete from volume will not take place if the block MTime is within permission_ttl
-	permission_ttl = time.Duration(1) * time.Second
-
-	vols := KeepVM.Volumes()
+	defer KeepVM.Close()
 
 	// Put test content
+	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"))
@@ -186,22 +202,35 @@ 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()
+	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(trashq)
+
 	trashq.ReplaceQueue(trashList)
-	time.Sleep(10 * time.Millisecond) // give it a moment to finish processing the trash list
+	time.Sleep(10 * time.Millisecond) // give a moment to finish processing the list
 
 	// Verify Locator1 to be un/deleted as expected
 	data, _ := GetBlock(testData.Locator1, false)
@@ -229,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()
 }