test compares normal vs canceled compaction times

Signed-off-by: Krasi Georgiev <kgeorgie@redhat.com>

compact_test.go

@@ -15,6 +15,7 @@ package tsdb
 
 import (
 	"context"
+	"fmt"
 	"io/ioutil"
 	"math"
 	"os"
@@ -747,17 +748,50 @@ func TestDisableAutoCompactions(t *testing.T) {
 // TestCancelCompactions ensures that when the db is closed
 // any running compaction is cancelled to unblock closing the db.
 func TestCancelCompactions(t *testing.T) {
-	tmpdir, err := ioutil.TempDir("", "test")
+	createTestDb := func() (*DB, func()) {
+		tmpdir, err := ioutil.TempDir("", "testCancelCompaction")
 		testutil.Ok(t, err)
-	defer os.RemoveAll(tmpdir)
 
 		// Create some blocks to fall within the compaction range.
-	createBlock(t, tmpdir, 3000, 0, 1000)
+		createBlock(t, tmpdir, 4000, 0, 1000)
-	createBlock(t, tmpdir, 3000, 1000, 2000)
+		createBlock(t, tmpdir, 4000, 1000, 2000)
 		createBlock(t, tmpdir, 1, 2000, 2001) // The most recent block is ignored so can be e small one.
-
 		db, err := Open(tmpdir, log.NewNopLogger(), nil, &Options{BlockRanges: []int64{1, 2000}})
 		testutil.Ok(t, err)
+		testutil.Equals(t, 3, len(db.Blocks()), "initial block count mismatch")
+		testutil.Equals(t, 0.0, prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.ran), "initial compaction counter mismatch")
+
+		return db, func() {
+			os.RemoveAll(tmpdir)
+		}
+	}
+	// First lets mesure the compaction time without interupting it.
+	var timeCompactionUninterrupted time.Duration
+	{
+		db, delete := createTestDb()
+		defer delete()
+		db.compactc <- struct{}{} // Trigger a compaction.
+		var start time.Time
+		for {
+			if prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.populatingBlocks) > 0 {
+				start = time.Now()
+				break
+			}
+			time.Sleep(3 * time.Millisecond)
+		}
+
+		for {
+			if prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.ran) == 1 {
+				timeCompactionUninterrupted = time.Since(start)
+				break
+			}
+			time.Sleep(3 * time.Millisecond)
+		}
+	}
+	// Closing the db in the middle of compaction should take half the time.
+	{
+		db, delete := createTestDb()
+		defer delete()
 
 		db.compactc <- struct{}{} // Trigger a compaction.
 		dbClosed := make(chan struct{})
@@ -775,6 +809,9 @@ func TestCancelCompactions(t *testing.T) {
 		start := time.Now()
 		<-dbClosed
 		actT := time.Since(start)
-	expT := time.Duration(100000000)
+		fmt.Println(timeCompactionUninterrupted)
+		fmt.Println(actT)
+		expT := time.Duration(timeCompactionUninterrupted / 2)
 		testutil.Assert(t, actT < expT, "closing the db took more than expected. exp: <%v, act: %v", expT, actT)
+	}
 }