Better testability of analyzeBlock command, start tests

- Factor out `extractBlock()` to retrieve specific block from db.Blocks()
- Write tests for said function
- Simple, non-output test for `analyzeBlock()` command

Author: obitech

cmd/tsdb/main.go

@@ -41,6 +41,7 @@ import (
 
 const (
 	printBlocksTableHeader = "BLOCK ULID\tMIN TIME\tMAX TIME\tNUM SAMPLES\tNUM CHUNKS\tNUM SERIES"
+	defaultAnalyzeLimit    = "20"
 )
 
 func main() {
@@ -66,7 +67,7 @@ func execute() (err error) {
 		analyzeCmd           = cli.Command("analyze", "analyze churn, label pair cardinality.")
 		analyzePath          = analyzeCmd.Arg("db path", "database path (default is "+defaultDBPath+")").Default(defaultDBPath).String()
 		analyzeBlockID       = analyzeCmd.Arg("block id", "block to analyze (default is the last block)").String()
-		analyzeLimit         = analyzeCmd.Flag("limit", "how many items to show in each list").Default("20").Int()
+		analyzeLimit         = analyzeCmd.Flag("limit", "how many items to show in each list").Default(defaultAnalyzeLimit).Int()
 		dumpCmd              = cli.Command("dump", "dump samples from a TSDB")
 		dumpPath             = dumpCmd.Arg("db path", "database path (default is "+defaultDBPath+")").Default(defaultDBPath).String()
 		dumpMinTime          = dumpCmd.Flag("min-time", "minimum timestamp to dump").Default(strconv.FormatInt(math.MinInt64, 10)).Int64()
@@ -114,21 +115,12 @@ func execute() (err error) {
 		if err != nil {
 			return err
 		}
-		var block tsdb.BlockReader
-		if *analyzeBlockID != "" {
-			for _, b := range blocks {
-				if b.Meta().ULID.String() == *analyzeBlockID {
-					block = b
-					break
-				}
-			}
-		} else if len(blocks) > 0 {
-			block = blocks[len(blocks)-1]
-		}
-		if block == nil {
-			return fmt.Errorf("block not found")
+		block, err := extractBlock(blocks, analyzeBlockID)
+		if err != nil {
+			return err
 		}
-		return analyzeBlock(block, *analyzeLimit)
+
+		return analyzeBlock(os.Stdout, block, *analyzeLimit)
 	case dumpCmd.FullCommand():
 		db, err := tsdb.OpenDBReadOnly(*dumpPath, nil)
 		if err != nil {
@@ -144,6 +136,25 @@ func execute() (err error) {
 	return nil
 }
 
+// extractBlock takes a slice of BlockReader and returns a specific block by ID.
+func extractBlock(blocks []tsdb.BlockReader, analyzeBlockID *string) (tsdb.BlockReader, error) {
+	var block tsdb.BlockReader
+	if *analyzeBlockID != "" {
+		for _, b := range blocks {
+			if b.Meta().ULID.String() == *analyzeBlockID {
+				block = b
+				break
+			}
+		}
+	} else if len(blocks) > 0 {
+		block = blocks[len(blocks)-1]
+	}
+	if block == nil {
+		return nil, fmt.Errorf("block not found")
+	}
+	return block, nil
+}
+
 type writeBenchmark struct {
 	outPath     string
 	samplesFile string
@@ -465,12 +476,12 @@ func getFormatedTime(timestamp int64, humanReadable *bool) string {
 	return strconv.FormatInt(timestamp, 10)
 }
 
-func analyzeBlock(b tsdb.BlockReader, limit int) error {
+func analyzeBlock(w io.Writer, b tsdb.BlockReader, limit int) error {
 	meta := b.Meta()
-	fmt.Printf("Block ID: %s\n", meta.ULID)
+	fmt.Fprintf(w, "Block ID: %s\n", meta.ULID)
 	// Presume 1ms resolution that Prometheus uses.
-	fmt.Printf("Duration: %s\n", (time.Duration(meta.MaxTime-meta.MinTime) * 1e6).String())
-	fmt.Printf("Series: %d\n", meta.Stats.NumSeries)
+	fmt.Fprintf(w, "Duration: %s\n", (time.Duration(meta.MaxTime-meta.MinTime) * 1e6).String())
+	fmt.Fprintf(w, "Series: %d\n", meta.Stats.NumSeries)
 	ir, err := b.Index()
 	if err != nil {
 		return err
@@ -481,7 +492,7 @@ func analyzeBlock(b tsdb.BlockReader, limit int) error {
 	if err != nil {
 		return err
 	}
-	fmt.Printf("Label names: %d\n", len(allLabelNames))
+	fmt.Fprintf(w, "Label names: %d\n", len(allLabelNames))
 
 	type postingInfo struct {
 		key    string
@@ -493,7 +504,7 @@ func analyzeBlock(b tsdb.BlockReader, limit int) error {
 		sort.Slice(postingInfos, func(i, j int) bool { return postingInfos[i].metric > postingInfos[j].metric })
 
 		for i, pc := range postingInfos {
-			fmt.Printf("%d %s\n", pc.metric, pc.key)
+			fmt.Fprintf(w, "%d %s\n", pc.metric, pc.key)
 			if i >= limit {
 				break
 			}
@@ -527,31 +538,31 @@ func analyzeBlock(b tsdb.BlockReader, limit int) error {
 	if p.Err() != nil {
 		return p.Err()
 	}
-	fmt.Printf("Postings (unique label pairs): %d\n", len(labelpairsUncovered))
-	fmt.Printf("Postings entries (total label pairs): %d\n", entries)
+	fmt.Fprintf(w, "Postings (unique label pairs): %d\n", len(labelpairsUncovered))
+	fmt.Fprintf(w, "Postings entries (total label pairs): %d\n", entries)
 
 	postingInfos = postingInfos[:0]
 	for k, m := range labelpairsUncovered {
 		postingInfos = append(postingInfos, postingInfo{k, uint64(float64(m) / float64(meta.MaxTime-meta.MinTime))})
 	}
 
-	fmt.Printf("\nLabel pairs most involved in churning:\n")
+	fmt.Fprintf(w, "\nLabel pairs most involved in churning:\n")
 	printInfo(postingInfos)
 
 	postingInfos = postingInfos[:0]
 	for k, m := range labelsUncovered {
 		postingInfos = append(postingInfos, postingInfo{k, uint64(float64(m) / float64(meta.MaxTime-meta.MinTime))})
 	}
 
-	fmt.Printf("\nLabel names most involved in churning:\n")
+	fmt.Fprintf(w, "\nLabel names most involved in churning:\n")
 	printInfo(postingInfos)
 
 	postingInfos = postingInfos[:0]
 	for k, m := range labelpairsCount {
 		postingInfos = append(postingInfos, postingInfo{k, m})
 	}
 
-	fmt.Printf("\nMost common label pairs:\n")
+	fmt.Fprintf(w, "\nMost common label pairs:\n")
 	printInfo(postingInfos)
 
 	postingInfos = postingInfos[:0]
@@ -575,7 +586,7 @@ func analyzeBlock(b tsdb.BlockReader, limit int) error {
 		postingInfos = append(postingInfos, postingInfo{n, cumulativeLength})
 	}
 
-	fmt.Printf("\nLabel names with highest cumulative label value length:\n")
+	fmt.Fprintf(w, "\nLabel names with highest cumulative label value length:\n")
 	printInfo(postingInfos)
 
 	postingInfos = postingInfos[:0]
@@ -586,7 +597,7 @@ func analyzeBlock(b tsdb.BlockReader, limit int) error {
 		}
 		postingInfos = append(postingInfos, postingInfo{n, uint64(lv.Len())})
 	}
-	fmt.Printf("\nHighest cardinality labels:\n")
+	fmt.Fprintf(w, "\nHighest cardinality labels:\n")
 	printInfo(postingInfos)
 
 	postingInfos = postingInfos[:0]
@@ -614,7 +625,7 @@ func analyzeBlock(b tsdb.BlockReader, limit int) error {
 			postingInfos = append(postingInfos, postingInfo{n, uint64(count)})
 		}
 	}
-	fmt.Printf("\nHighest cardinality metric names:\n")
+	fmt.Fprintf(w, "\nHighest cardinality metric names:\n")
 	printInfo(postingInfos)
 	return nil
 }

cmd/tsdb/main_test.go

@@ -18,6 +18,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"strconv"
 	"strings"
 	"testing"
 	"text/tabwriter"
@@ -92,11 +93,12 @@ func TestPrintBlocks(t *testing.T) {
 	}
 
 	// Test table contents.
-	var actualStdout bytes.Buffer
 	blocks, err = db.Blocks()
 	if err != nil {
 		t.Error(err)
 	}
+
+	var actualStdout bytes.Buffer
 	printBlocks(&actualStdout, blocks, &hr)
 
 	actual = actualStdout.String()
@@ -113,3 +115,74 @@ func TestPrintBlocks(t *testing.T) {
 		t.Errorf("expected (%#v) != actual (%#v)", expected, actual)
 	}
 }
+
+func TestExtractBlock(t *testing.T) {
+	db, closeFn := createRoDb(t)
+	defer closeFn()
+
+	blocks, err := db.Blocks()
+	if err != nil {
+		t.Error(err)
+	}
+
+	var analyzeBlockID string
+
+	// Pass: analyze last block (default).
+	block, err := extractBlock(blocks, &analyzeBlockID)
+	if err != nil {
+		t.Error(err)
+	}
+	if block == nil {
+		t.Error("block shouldn't be nil")
+	}
+
+	// Pass: analyze specific block.
+	analyzeBlockID = block.Meta().ULID.String()
+	block, err = extractBlock(blocks, &analyzeBlockID)
+	if err != nil {
+		t.Error(err)
+	}
+	if block == nil {
+		t.Error("block shouldn't be nil")
+	}
+
+	// Fail: analyze non-existing block
+	analyzeBlockID = "foo"
+	block, err = extractBlock(blocks, &analyzeBlockID)
+	if err == nil {
+		t.Errorf("Analyzing block %q should throw error", analyzeBlockID)
+	}
+	if block != nil {
+		t.Error("block should be nil")
+	}
+}
+
+func TestAnalyzeBlocks(t *testing.T) {
+	db, closeFn := createRoDb(t)
+	defer closeFn()
+
+	blocks, err := db.Blocks()
+	if err != nil {
+		t.Error(err)
+	}
+
+	var analyzeBlockID string
+	block, err := extractBlock(blocks, &analyzeBlockID)
+	if err != nil {
+		t.Error(err)
+	}
+	if block == nil {
+		t.Errorf("block shouldn't be nil")
+	}
+
+	dal, err := strconv.Atoi(defaultAnalyzeLimit)
+	if err != nil {
+		t.Error(err)
+	}
+
+	var actual bytes.Buffer
+	err = analyzeBlock(&actual, block, dal)
+	if err != nil {
+		t.Error(err)
+	}
+}