Complete test coverage for query package (#20)

Author: stephen-soltesz

query/bigquery_runner.go

@@ -4,54 +4,46 @@
 package query
 
 import (
-	"context"
-	"log"
 	"math"
 	"sort"
 	"strings"
 
-	"github.com/m-lab/prometheus-bigquery-exporter/sql"
-
 	"cloud.google.com/go/bigquery"
-	"google.golang.org/api/iterator"
+	"github.com/m-lab/prometheus-bigquery-exporter/query/bqiface"
+	"github.com/m-lab/prometheus-bigquery-exporter/sql"
 )
 
 // BQRunner is a concerete implementation of QueryRunner for BigQuery.
 type BQRunner struct {
-	client *bigquery.Client
+	runner runner
+}
+
+// runner interface allows unit testing of the Query function.
+type runner interface {
+	Query(q string, visit func(row map[string]bigquery.Value) error) error
 }
 
 // NewBQRunner creates a new QueryRunner instance.
 func NewBQRunner(client *bigquery.Client) *BQRunner {
-	return &BQRunner{client}
+	return &BQRunner{
+		runner: &bqiface.BigQueryImpl{
+			Client: client,
+		},
+	}
 }
 
 // Query executes the given query. Query only supports standard SQL. The
 // query must define a column named "value" for the value, and may define
 // additional columns, all of which are used as metric labels.
 func (qr *BQRunner) Query(query string) ([]sql.Metric, error) {
 	metrics := []sql.Metric{}
-
-	q := qr.client.Query(query)
-	// TODO: add context timeout.
-	it, err := q.Read(context.Background())
+	err := qr.runner.Query(query, func(row map[string]bigquery.Value) error {
+		metrics = append(metrics, rowToMetric(row))
+		return nil
+	})
 	if err != nil {
-		log.Print(err)
 		return nil, err
 	}
-
-	for {
-		var row map[string]bigquery.Value
-		err := it.Next(&row)
-		if err == iterator.Done {
-			break
-		}
-		if err != nil {
-			log.Printf("%#v %d", err, len(metrics))
-			return nil, err
-		}
-		metrics = append(metrics, rowToMetric(row))
-	}
 	return metrics, nil
 }
 

query/bigquery_runner_test.go

@@ -1,6 +1,8 @@
 package query
 
 import (
+	"fmt"
+	"math"
 	"reflect"
 	"testing"
 
@@ -10,9 +12,10 @@ import (
 
 func TestRowToMetric(t *testing.T) {
 	tests := []struct {
-		name   string
-		row    map[string]bigquery.Value
-		metric sql.Metric
+		name    string
+		row     map[string]bigquery.Value
+		metric  sql.Metric
+		wantNaN bool
 	}{
 		{
 			name: "Extract labels",
@@ -72,12 +75,92 @@ func TestRowToMetric(t *testing.T) {
 				Values:      map[string]float64{"": 2.1},
 			},
 		},
+		{
+			name: "NaN value",
+			row: map[string]bigquery.Value{
+				"value": "this-is-NaN",
+			},
+			metric: sql.Metric{
+				Values: map[string]float64{"": math.NaN()},
+			},
+			wantNaN: true,
+		},
 	}
 
 	for _, test := range tests {
 		m := rowToMetric(test.row)
-		if !reflect.DeepEqual(m, test.metric) {
+		if !test.wantNaN && !reflect.DeepEqual(m, test.metric) {
+			t.Errorf("Failed to convert row to metric. want %#v; got %#v", test.metric, m)
+		}
+		if test.wantNaN && !math.IsNaN(m.Values[""]) {
 			t.Errorf("Failed to convert row to metric. want %#v; got %#v", test.metric, m)
 		}
 	}
 }
+
+type fakeQuery struct {
+	err  error
+	rows []map[string]bigquery.Value
+}
+
+func (f *fakeQuery) Query(q string, visit func(row map[string]bigquery.Value) error) error {
+	if f.err != nil {
+		return f.err
+	}
+	for i := range f.rows {
+		err := visit(f.rows[i])
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func TestBQRunner_Query(t *testing.T) {
+	tests := []struct {
+		name    string
+		runner  runner
+		want    []sql.Metric
+		wantErr bool
+	}{
+		{
+			name: "okay",
+			runner: &fakeQuery{
+				rows: []map[string]bigquery.Value{
+					{
+						"value_name": 1.23,
+					},
+				},
+			},
+			want: []sql.Metric{
+				sql.NewMetric(nil, nil, map[string]float64{"_name": 1.23}),
+			},
+		},
+		{
+			name: "query-error",
+			runner: &fakeQuery{
+				err: fmt.Errorf("Fake query error"),
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			qr := &BQRunner{
+				runner: tt.runner,
+			}
+			got, err := qr.Query("select * from `fake-table`")
+			if (err != nil) != tt.wantErr {
+				t.Errorf("BQRunner.Query() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("BQRunner.Query() = %#v, want %#v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewBQRunner(t *testing.T) {
+	NewBQRunner(nil)
+}

query/bqiface/bqiface.go

@@ -0,0 +1,28 @@
+package bqiface
+
+import (
+	"context"
+
+	"cloud.google.com/go/bigquery"
+	"google.golang.org/api/iterator"
+)
+
+type BigQueryImpl struct {
+	Client *bigquery.Client
+}
+
+func (b *BigQueryImpl) Query(query string, visit func(row map[string]bigquery.Value) error) error {
+	q := b.Client.Query(query)
+	it, err := q.Read(context.Background())
+	if err != nil {
+		return err
+	}
+	var row map[string]bigquery.Value
+	for err = it.Next(&row); err != iterator.Done; err = it.Next(&row) {
+		err2 := visit(row)
+		if err2 != nil {
+			return err2
+		}
+	}
+	return nil
+}