test implemented

Author: lychung83

monitoring/exporter/stackdriver/data_test.go

@@ -23,7 +23,7 @@ import (
 	"go.opencensus.io/stats"
 	"go.opencensus.io/stats/view"
 	"go.opencensus.io/tag"
-	monitoredrespb "google.golang.org/genproto/googleapis/api/monitoredres"
+	mrpb "google.golang.org/genproto/googleapis/api/monitoredres"
 )
 
 // This file defines various data needed for testing.
@@ -56,8 +56,9 @@ const (
 var (
 	ctx = context.Background()
 
+	invalidDataErrStr = "invalid data"
 	// This error is used for test to catch some error happpened.
-	invalidDataError = errors.New("invalid data")
+	invalidDataError = errors.New(invalidDataErrStr)
 	// This error is used for unexpected error.
 	unrecognizedDataError = errors.New("unrecognized data")
 
@@ -84,7 +85,7 @@ var (
 		Name:        metric3name,
 		Description: metric3desc,
 		TagKeys:     []tag.Key{projectKey},
-		Measure:     stats.Int(metric3name, metric3desc, stats.UnitDimensionless),
+		Measure:     stats.Int64(metric3name, metric3desc, stats.UnitDimensionless),
 		Aggregation: view.Sum(),
 	}
 
@@ -111,11 +112,11 @@ var (
 		Data: &view.SumData{Value: 5},
 	}
 	view3row1 = &view.Row{
-		Tags: []tag.Tag{{ProjectKeyName, project1}},
+		Tags: []tag.Tag{{projectKey, project1}},
 		Data: &view.SumData{Value: 6},
 	}
 	view3row2 = &view.Row{
-		Tags: []tag.Tag{{ProjectKeyName, project1}},
+		Tags: []tag.Tag{{projectKey, project2}},
 		Data: &view.SumData{Value: 7},
 	}
 	// This Row does not have valid Data field, so is invalid.
@@ -126,15 +127,15 @@ var (
 	startTime2 = endTime2.Add(-10 * time.Second)
 	endTime2   = time.Now()
 
-	resource1 = &monitoredrespb.MonitoredResource{
+	resource1 = &mrpb.MonitoredResource{
 		Type: "cloudsql_database",
 		Labels: map[string]string{
 			"project_id":  project1,
 			"region":      "us-central1",
 			"database_id": "cloud-SQL-instance-1",
 		},
 	}
-	resource2 = &monitoredrespb.MonitoredResource{
+	resource2 = &mrpb.MonitoredResource{
 		Type: "gce_instance",
 		Labels: map[string]string{
 			"project_id":  project2,

monitoring/exporter/stackdriver/mock_check_test.go

@@ -17,124 +17,101 @@ package stackdriver
 import (
 	"context"
 	"fmt"
-	"os"
 	"strings"
 	"testing"
-	"time"
 
 	monitoring "cloud.google.com/go/monitoring/apiv3"
 	gax "github.com/googleapis/gax-go"
 	"google.golang.org/api/option"
 	"google.golang.org/api/support/bundler"
-	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
+	mpb "google.golang.org/genproto/googleapis/monitoring/v3"
 )
 
 // This file defines various mocks for testing, and checking functions for mocked data. We mock
 // metric client and bundler because their actions involves RPC calls or non-deterministic behavior.
 
 var (
-	// bundlerMark records
-	bundlerMark map[string]*bundler.Bundler
-	// projAddedRds saves all
-	projAddedRds map[string][]*RowData
+	// bundlerRec records project ID of given bundler.
+	bndlerProjMap map[*bundler.Bundler]string
+	// projRds saves all RowData objects passed to addToBundler call by project ID.
+	projRds map[string]*[]*RowData
 
 	// timeSeriesReqs saves all incoming requests for creating time series.
-	timeSerieReqs []*monitoringpb.CreateTimeSeriesRequest
+	timeSeriesReqs []*mpb.CreateTimeSeriesRequest
 	// timeSeriesResults holds predefined error values to be returned by mockCreateTimeSerie()
 	// calls. Each errors in timeSeriesResults are returned per each mockCreateTimeSeries()
 	// call. If all errors in timeSeriesResults are used, all other mockCreateTimeSeries calls
 	// will return nil.
 	timeSeriesResults []error
+
+	errRds []errRowData
 )
 
 func init() {
 	// For testing convenience, we reduce maximum time series that metric client accepts.
 	MaxTimeSeriesPerUpload = 3
 
+	// Mock functions.
 	newMetricClient = mockNewMetricClient
 	createTimeSeries = mockCreateTimeSeries
+	newBundler = mockNewBundler
+	addToBundler = mockAddToBundler
+}
 
+func testInit() {
+	bndlerProjMap = map[*bundler.Bundler]string{}
+	projRds = map[string]*[]*RowData{}
+	timeSeriesReqs = nil
+	timeSeriesResults = nil
+	errRds = nil
 }
 
 func mockNewMetricClient(_ context.Context, _ ...option.ClientOption) (*monitoring.MetricClient, error) {
 	return nil, nil
 }
 
-func mockCreateTimeSeries(_ *monitoing.MetricClient, _ context.Context, req *monitoringpb.CreateTimeSeriesRequest, _ ...gax.CallOption) error {
-	createTimeSeriesReq = append(createTimeSeriesReq, req)
-	// Check returnErrs and if not empty, return the first error from it.
-	if len(createTimereturnErrs) == 0 {
+func mockCreateTimeSeries(_ *monitoring.MetricClient, _ context.Context, req *mpb.CreateTimeSeriesRequest, _ ...gax.CallOption) error {
+	timeSeriesReqs = append(timeSeriesReqs, req)
+	// Check timeSeriesResults and if not empty, return the first error from it.
+	if len(timeSeriesResults) == 0 {
 		return nil
 	}
-	err := data.returnErrs[0]
+	err := timeSeriesResults[0]
 	// Delete the returning error.
-	data.returnErrs = data.returnErrs[1:]
+	timeSeriesResults = timeSeriesResults[1:]
 	return err
 }
 
-func mockNewBundler(projectID string, _ interface{}, _ int) *bundler.Bundler {
+func mockNewBundler(projectID string, _ interface{}, _ func(interface{})) *bundler.Bundler {
 	bndler := &bundler.Bundler{}
-	bndler2proj[bndler] = projectID
-	return bndlr
+	bndlerProjMap[bndler] = projectID
+	return bndler
 }
 
-func addToBundler(bndler *bundler.Bundler, item interface{}, _ int) error {
-	rds := &projAddRds[bndler2proj[bndler]]
-	*rds = append(*rds, iterm.(*RowData))
-	return nil
-}
-
-func TestMain(m *testing.M) {
-
-	// Clear all data that stores behavior of mocked functions.
-	createTimeSeriesReq = nil
-	createTimeSeriesReturnErrs = nil
-
-	os.Exit(m.Run())
-}
-
-// We define mock Client.
-
-func (data *mockMetricClientData) createTimeSeries(_ *monitoring.MetricClient, _ context.Context, req *monitoringpb.CreateTimeSeriesRequest, opts ...gax.CallOption) error {
-	data.reqs = append(data.reqs, req)
-	// Check returnErrs and if not empty, return the first error from it.
-	if len(data.returnErrs) == 0 {
-		return nil
+func mockAddToBundler(bndler *bundler.Bundler, item interface{}, _ int) error {
+	projID := bndlerProjMap[bndler]
+	rds, ok := projRds[projID]
+	if !ok {
+		var rdsOrig []*RowData
+		rds = &rdsOrig
+		projRds[projID] = rds
 	}
-	err := data.returnErrs[0]
-	// Delete the returning error.
-	data.returnErrs = data.returnErrs[1:]
-	return err
-}
-
-func (data *mockMetricClientData) addReturnErrs(errs ...error) {
-	data.returnErrs = append(data.returnErrs, errs...)
-}
-
-func (data *mockMetricClientData) newMetricClient(_ context.Context, _ ...option.ClientOption) (*monitoring.MetricClient, error) {
-	return nil, nil
-}
-
-func newMockClientData() *mockMetricClientData {
-	data := &mockMetricClientData{}
-	newMetricClient = data.newMetricClient
-	createTimeSeries = data.createTimesSeries
-	return data
+	*rds = append(*rds, item.(*RowData))
+	return nil
 }
 
 // checkMetricClient checks all recorded requests in mock metric client. We only compare int64
 // values of the time series. To make this work, we assigned different int64 values for all valid
 // rows in the test.
-func checkMetricClientData(t *testing.T, data *mockMetricClientData, wantReqsValues [][]int64) {
-	reqs := data.reqs
-	reqsLen, wantReqsLen := len(reqs), len(wantReqsValues)
+func checkMetricClient(t *testing.T, wantReqsValues [][]int64) {
+	reqsLen, wantReqsLen := len(timeSeriesReqs), len(wantReqsValues)
 	if reqsLen != wantReqsLen {
 		t.Errorf("number of requests got: %d, want %d", reqsLen, wantReqsLen)
 		return
 	}
 	for i := 0; i < reqsLen; i++ {
 		prefix := fmt.Sprintf("%d-th request mismatch", i+1)
-		tsArr := reqs[i].TimeSeries
+		tsArr := timeSeriesReqs[i].TimeSeries
 		wantTsValues := wantReqsValues[i]
 		tsArrLen, wantTsArrLen := len(tsArr), len(wantTsValues)
 		if tsArrLen != wantTsArrLen {
@@ -143,7 +120,7 @@ func checkMetricClientData(t *testing.T, data *mockMetricClientData, wantReqsVal
 		}
 		for j := 0; j < tsArrLen; j++ {
 			// This is how monitoring API stores the int64 value.
-			tsVal := tsArr[j].Points[0].Value.Value.(*monitoringpb.TypedValue_Int64Value).Int64Value
+			tsVal := tsArr[j].Points[0].Value.Value.(*mpb.TypedValue_Int64Value).Int64Value
 			wantTsVal := wantTsValues[j]
 			if tsVal != wantTsVal {
 				t.Errorf("%s: Value got: %d, want: %d", prefix, tsVal, wantTsVal)
@@ -152,39 +129,17 @@ func checkMetricClientData(t *testing.T, data *mockMetricClientData, wantReqsVal
 	}
 }
 
-// We define mock bundler.
-
-type mockBundler struct {
-	// rowDataArr saves all incoming RowData to the bundler.
-	rowDataArr []*RowData
-}
-
-func (b *mockBundler) Add(rowData interface{}, _ int) error {
-	b.rowDataArr = append(b.rowDataArr, rowData.(*RowData))
-	return nil
-}
-
-func (b *mockBundler) Flush() {}
-
-func mockNewExpBundler(_ func(interface{}), _ time.Duration, _ int) expBundler {
-	return &mockBundler{}
-}
-
 // We define a storage for all errors happened in export operation.
 
-type errStorage struct {
-	errRds []errRowData
-}
-
 type errRowData struct {
 	err error
 	rds []*RowData
 }
 
 // onError records any incoming error and accompanying RowData array. This method is passed to the
 // exporter to record errors.
-func (e *errStorage) onError(err error, rds ...*RowData) {
-	e.errRds = append(e.errRds, errRowData{err, rds})
+func testOnError(err error, rds ...*RowData) {
+	errRds = append(errRds, errRowData{err, rds})
 }
 
 // errRowDataCheck contains data for checking content of error storage.
@@ -194,8 +149,7 @@ type errRowDataCheck struct {
 }
 
 // checkErrStorage checks content of error storage. For returned errors, we check prefix and suffix.
-func checkErrStorage(t *testing.T, errStore *errStorage, wantErrRdCheck []errRowDataCheck) {
-	errRds := errStore.errRds
+func checkErrStorage(t *testing.T, wantErrRdCheck []errRowDataCheck) {
 	gotLen, wantLen := len(errRds), len(wantErrRdCheck)
 	if gotLen != wantLen {
 		t.Errorf("number of reported errors: %d, want: %d", gotLen, wantLen)
@@ -248,48 +202,43 @@ func checkRowData(rd, wantRd *RowData) error {
 
 // newMockExp creates mock expoter and error storage storing all errors. Caller need not set
 // opts.OnError.
-func newMockExp(t *testing.T, opts *Options) (*StatsExporter, *errStorage) {
-	errStore := &errStorage{}
-	opts.OnError = errStore.onError
-	exp, err := NewStatsExporter(ctx, opts)
+func newTestExp(t *testing.T, opts *Options) *Exporter {
+	opts.OnError = testOnError
+	exp, err := NewExporter(ctx, opts)
 	if err != nil {
 		t.Fatalf("creating exporter failed: %v", err)
 	}
-	return exp, errStore
+	return exp
 }
 
 // checkExpProjData checks all data passed to the bundler by bundler.Add().
-func checkExpProjData(t *testing.T, exp *StatsExporter, wantProjData map[string][]*RowData) {
+func checkExpProjData(t *testing.T, wantProjData map[string][]*RowData) {
 	wantProj := map[string]bool{}
 	for proj := range wantProjData {
 		wantProj[proj] = true
 	}
-	for proj := range exp.projDataMap {
+	for proj := range projRds {
 		if !wantProj[proj] {
 			t.Errorf("project in exporter's project data not wanted: %s", proj)
 		}
 	}
 
 	for proj, wantRds := range wantProjData {
-		pd, ok := exp.projDataMap[proj]
+		rds, ok := projRds[proj]
 		if !ok {
 			t.Errorf("wanted project not found in exporter's project data: %v", proj)
 			continue
 		}
-		// We know that bundler is mocked, so we can check the data in it.
-		if err := checkRowDataArr(pd.bndler.(*mockBundler).rowDataArr, wantRds); err != nil {
+		if err := checkRowDataArr(*rds, wantRds); err != nil {
 			t.Errorf("RowData array mismatch for project %s: %v", proj, err)
 		}
 	}
 }
 
 // newMockUploader creates objects to test behavior of projectData.uploadRowData. Other uses are not
 // recommended.
-func newMockUploader(t *testing.T, opts *Options) (*projectData, *mockMetricClient, *errStorage) {
-	exp, errStore := newMockExp(t, opts)
-	pd := exp.newProjectData(project1)
-	cl := exp.client.(*mockMetricClient)
-	return pd, cl, errStore
+func newTestProjData(t *testing.T, opts *Options) *projectData {
+	return newTestExp(t, opts).newProjectData(project1)
 }
 
 // checkLabels checks data in labels.