Added unit annotation supports onto tsmon in go.

common/tsmon/store/storetest/testing.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 // Package storetest is imported exclusively by tests for Store implementations.
 package storetest
 
 import (
         "bytes"
         "fmt"
@@ skipping 149 matching lines @@
                         wantIncrSuccess: false,
                 },
         }
 
         Convey("Set and get", t, func() {
                 Convey("With no fields", func() {
                         for i, test := range tests {
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
-                                                m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{}, test.typ}, test.bucketer}
+                                                m = &fakeDistributionMetric{FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}, test.bucketer}
                                         } else {
-                                                m = &FakeMetric{"m", "", []field.Field{}, test.typ}
+                                                m = &FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{},
+                                                }
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
 
                                         // Value should be nil initially.
                                         v, err := s.Get(ctx, m, time.Time{}, []interface{}{})
                                         So(err, ShouldBeNil)
                                         So(v, ShouldBeNil)
 
@@ skipping 13 matching lines @@
                                         }
                                 })
                         }
                 })
 
                 Convey("With fields", func() {
                         for i, test := range tests {
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
-                                                m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{field.String("f")}, test.typ}, test.bucketer}
+                                                m = &fakeDistributionMetric{FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{field.String("f")}, test.typ},
+                                                        types.MetricMetadata{}}, test.bucketer}
                                         } else {
-                                                m = &FakeMetric{"m", "", []field.Field{field.String("f")}, test.typ}
+                                                m = &FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{field.String("f")}, test.typ},
+                                                        types.MetricMetadata{}}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
 
                                         // Values should be nil initially.
                                         v, err := s.Get(ctx, m, time.Time{}, makeInterfaceSlice("one"))
                                         So(err, ShouldBeNil)
                                         So(v, ShouldBeNil)
                                         v, err = s.Get(ctx, m, time.Time{}, makeInterfaceSlice("two"))
@@ skipping 35 matching lines @@
 
                 Convey("With a fixed reset time", func() {
                         for i, test := range tests {
                                 if !test.wantSetSuccess {
                                         continue
                                 }
 
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
-                                                m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{}, test.typ}, test.bucketer}
+                                                m = &fakeDistributionMetric{FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}, test.bucketer}
                                         } else {
-                                                m = &FakeMetric{"m", "", []field.Field{}, test.typ}
+                                                m = &FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
                                         opts.RegistrationFinished(s)
 
                                         // Do the set with a fixed time.
                                         t := time.Date(1972, 5, 6, 7, 8, 9, 0, time.UTC)
                                         So(s.Set(ctx, m, t, []interface{}{}, test.values[0]), ShouldBeNil)
 
@@ skipping 22 matching lines @@
 
                 Convey("With a target set in the context", func() {
                         for i, test := range tests {
                                 if !test.wantSetSuccess {
                                         continue
                                 }
 
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
-                                                m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{}, test.typ}, test.bucketer}
+                                                m = &fakeDistributionMetric{FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}, test.bucketer}
                                         } else {
-                                                m = &FakeMetric{"m", "", []field.Field{}, test.typ}
+                                                m = &FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
                                         opts.RegistrationFinished(s)
 
                                         // Create a context with a different target.
                                         t := target.Task{}
                                         t.AsProto().ServiceName = proto.String("foo")
                                         ctxWithTarget := target.Set(ctx, &t)
@@ skipping 32 matching lines @@
                                 })
                         }
                 })
 
                 Convey("With a decreasing value", func() {
                         for i, test := range tests {
                                 if !test.typ.IsCumulative() || test.bucketer != nil {
                                         continue
                                 }
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
-                                        m := &FakeMetric{"m", "", []field.Field{}, test.typ}
+                                        m := &FakeMetric{
+                                                types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                types.MetricMetadata{}}
                                         s := opts.Factory()
                                         s.Register(m)
 
                                         // Set the bigger value.
                                         So(s.Set(ctx, m, time.Time{}, []interface{}{}, test.values[1]), ShouldBeNil)
 
                                         // Setting the smaller value should fail.
                                         So(s.Set(ctx, m, time.Time{}, []interface{}{}, test.values[0]), ShouldNotBeNil)
                                 })
                         }
                 })
         })
 
         Convey("Increment and get", t, func() {
                 Convey("With no fields", func() {
                         for i, test := range tests {
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
-                                                m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{}, test.typ}, test.bucketer}
+                                                m = &fakeDistributionMetric{FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}, test.bucketer}
+
                                         } else {
-                                                m = &FakeMetric{"m", "", []field.Field{}, test.typ}
+                                                m = &FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
 
                                         // Value should be nil initially.
                                         v, err := s.Get(ctx, m, time.Time{}, []interface{}{})
                                         So(err, ShouldBeNil)
                                         So(v, ShouldBeNil)
 
@@ skipping 19 matching lines @@
                                         }
                                 })
                         }
                 })
 
                 Convey("With fields", func() {
                         for i, test := range tests {
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
-                                                m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{field.String("f")}, test.typ}, test.bucketer}
+                                                m = &fakeDistributionMetric{FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{field.String("f")}, test.typ},
+                                                        types.MetricMetadata{}}, test.bucketer}
                                         } else {
-                                                m = &FakeMetric{"m", "", []field.Field{field.String("f")}, test.typ}
+                                                m = &FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{field.String("f")}, test.typ},
+                                                        types.MetricMetadata{}}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
 
                                         // Values should be nil initially.
                                         v, err := s.Get(ctx, m, time.Time{}, makeInterfaceSlice("one"))
                                         So(err, ShouldBeNil)
                                         So(v, ShouldBeNil)
                                         v, err = s.Get(ctx, m, time.Time{}, makeInterfaceSlice("two"))
@@ skipping 31 matching lines @@
 
                 Convey("With a fixed reset time", func() {
                         for i, test := range tests {
                                 if !test.wantIncrSuccess {
                                         continue
                                 }
 
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
-                                                m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{}, test.typ}, test.bucketer}
+                                                m = &fakeDistributionMetric{FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}, test.bucketer}
                                         } else {
-                                                m = &FakeMetric{"m", "", []field.Field{}, test.typ}
+                                                m = &FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
                                         opts.RegistrationFinished(s)
 
                                         // Do the incr with a fixed time.
                                         t := time.Date(1972, 5, 6, 7, 8, 9, 0, time.UTC)
                                         So(s.Incr(ctx, m, t, []interface{}{}, test.deltas[0]), ShouldBeNil)
 
@@ skipping 14 matching lines @@
 
                 Convey("With a target set in the context", func() {
                         for i, test := range tests {
                                 if !test.wantIncrSuccess {
                                         continue
                                 }
 
                                 Convey(fmt.Sprintf("%d. %s", i, test.typ), func() {
                                         var m types.Metric
                                         if test.bucketer != nil {
-                                                m = &fakeDistributionMetric{FakeMetric{"m", "", []field.Field{}, test.typ}, test.bucketer}
+                                                m = &fakeDistributionMetric{
+                                                        FakeMetric{types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                                types.MetricMetadata{}},
+                                                        test.bucketer}
                                         } else {
-                                                m = &FakeMetric{"m", "", []field.Field{}, test.typ}
+                                                m = &FakeMetric{
+                                                        types.MetricInfo{"m", "", []field.Field{}, test.typ},
+                                                        types.MetricMetadata{}}
                                         }
 
                                         s := opts.Factory()
                                         s.Register(m)
                                         opts.RegistrationFinished(s)
 
                                         // Create a context with a different target.
                                         t := target.Task{}
                                         t.AsProto().ServiceName = proto.String("foo")
                                         ctxWithTarget := target.Set(ctx, &t)
@@ skipping 21 matching lines @@
                                         So(coll.Data[1].Task.GetServiceName(), ShouldEqual, t.AsProto().GetServiceName())
                                 })
                         }
                 })
         })
 
         Convey("GetAll", t, func() {
                 ctx, tc := testclock.UseTime(context.Background(), testclock.TestTimeLocal)
 
                 s := opts.Factory()
-                foo := &FakeMetric{"foo", "", []field.Field{}, types.NonCumulativeIntType}
-                bar := &FakeMetric{"bar", "", []field.Field{field.String("f")}, types.StringType}
-                baz := &FakeMetric{"baz", "", []field.Field{field.String("f")}, types.NonCumulativeFloatType}
+                foo := &FakeMetric{
+                        types.MetricInfo{"foo", "", []field.Field{}, types.NonCumulativeIntType},
+                        types.MetricMetadata{}}
+                bar := &FakeMetric{
+                        types.MetricInfo{"bar", "", []field.Field{field.String("f")}, types.StringType},
+                        types.MetricMetadata{}}
+                baz := &FakeMetric{
+                        types.MetricInfo{"baz", "", []field.Field{field.String("f")}, types.NonCumulativeFloatType},
+                        types.MetricMetadata{}}
                 s.Register(foo)
                 s.Register(bar)
                 s.Register(baz)
                 opts.RegistrationFinished(s)
 
                 // Add test records. We increment the test clock each time so that the added
                 // records sort deterministically using sortableCellSlice.
                 for _, m := range []struct {
                         metric    types.Metric
                         fieldvals []interface{}
@@ skipping 11 matching lines @@
 
                 got := s.GetAll(ctx)
                 sort.Sort(sortableCellSlice(got))
                 want := []types.Cell{
                         {
                                 types.MetricInfo{
                                         Name:      "foo",
                                         Fields:    []field.Field{},
                                         ValueType: types.NonCumulativeIntType,
                                 },
+                                types.MetricMetadata{},
                                 types.CellData{
                                         FieldVals: []interface{}{},
                                         Value:     int64(42),
                                 },
                         },
                         {
                                 types.MetricInfo{
                                         Name:      "bar",
                                         Fields:    []field.Field{field.String("f")},
                                         ValueType: types.StringType,
                                 },
+                                types.MetricMetadata{},
                                 types.CellData{
                                         FieldVals: makeInterfaceSlice("one"),
                                         Value:     "hello",
                                 },
                         },
                         {
                                 types.MetricInfo{
                                         Name:      "bar",
                                         Fields:    []field.Field{field.String("f")},
                                         ValueType: types.StringType,
                                 },
+                                types.MetricMetadata{},
                                 types.CellData{
                                         FieldVals: makeInterfaceSlice("two"),
                                         Value:     "world",
                                 },
                         },
                         {
                                 types.MetricInfo{
                                         Name:      "baz",
                                         Fields:    []field.Field{field.String("f")},
                                         ValueType: types.NonCumulativeFloatType,
                                 },
+                                types.MetricMetadata{},
                                 types.CellData{
                                         FieldVals: makeInterfaceSlice("three"),
                                         Value:     1.23,
                                 },
                         },
                         {
                                 types.MetricInfo{
                                         Name:      "baz",
                                         Fields:    []field.Field{field.String("f")},
                                         ValueType: types.NonCumulativeFloatType,
                                 },
+                                types.MetricMetadata{},
                                 types.CellData{
                                         FieldVals: makeInterfaceSlice("four"),
                                         Value:     4.56,
                                 },
                         },
                 }
                 So(len(got), ShouldEqual, len(want))
 
                 for i, g := range got {
                         w := want[i]
 
                         Convey(fmt.Sprintf("%d", i), func() {
                                 So(g.Name, ShouldEqual, w.Name)
                                 So(len(g.Fields), ShouldEqual, len(w.Fields))
                                 So(g.ValueType, ShouldEqual, w.ValueType)
                                 So(g.FieldVals, ShouldResemble, w.FieldVals)
                                 So(g.Value, ShouldEqual, w.Value)
                         })
                 }
         })
 
         Convey("Concurrency", t, func() {
                 const numIterations = 100
                 const numGoroutines = 32
 
                 Convey("Incr", func(c C) {
                         s := opts.Factory()
-                        m := &FakeMetric{"m", "", []field.Field{}, types.CumulativeIntType}
+                        m := &FakeMetric{
+                                types.MetricInfo{"m", "", []field.Field{}, types.CumulativeIntType},
+                                types.MetricMetadata{}}
                         s.Register(m)
 
                         wg := sync.WaitGroup{}
                         f := func(n int) {
                                 defer wg.Done()
                                 for i := 0; i < numIterations; i++ {
                                         c.So(s.Incr(ctx, m, time.Time{}, []interface{}{}, int64(1)), ShouldBeNil)
                                 }
                         }
 
                         for n := 0; n < numGoroutines; n++ {
                                 wg.Add(1)
                                 go f(n)
                         }
                         wg.Wait()
 
                         val, err := s.Get(ctx, m, time.Time{}, []interface{}{})
                         So(val, ShouldEqual, numIterations*numGoroutines)
                         So(err, ShouldBeNil)
                 })
         })
 
         Convey("Different targets", t, func() {
                 Convey("Gets from context", func() {
                         s := opts.Factory()
-                        m := &FakeMetric{"m", "", []field.Field{}, types.NonCumulativeIntType}
+                        m := &FakeMetric{
+                                types.MetricInfo{"m", "", []field.Field{}, types.NonCumulativeIntType},
+                                types.MetricMetadata{}}
                         s.Register(m)
                         opts.RegistrationFinished(s)
 
                         t := target.Task{}
                         t.AsProto().ServiceName = proto.String("foo")
                         ctxWithTarget := target.Set(ctx, &t)
 
                         So(s.Set(ctx, m, time.Time{}, []interface{}{}, int64(42)), ShouldBeNil)
                         So(s.Set(ctxWithTarget, m, time.Time{}, []interface{}{}, int64(43)), ShouldBeNil)
 
@@ skipping 18 matching lines @@
                         }
                 })
         })
 }
 
 func makeInterfaceSlice(v ...interface{}) []interface{} {
         return v
 }
 
 // FakeMetric is a fake Metric implementation.
-type FakeMetric types.MetricInfo
+type FakeMetric struct {
+        types.MetricInfo
+        types.MetricMetadata
+}
 
-// Info implements Metric.Info.
-func (m *FakeMetric) Info() types.MetricInfo { return types.MetricInfo(*m) }
+// Info implements Metric.Info
+func (m *FakeMetric) Info() types.MetricInfo { return m.MetricInfo }
+
+// Metadata implements Metric.Metadata
+func (m *FakeMetric) Metadata() types.MetricMetadata { return m.MetricMetadata }
 
 // SetFixedResetTime implements Metric.SetFixedResetTime.
 func (m *FakeMetric) SetFixedResetTime(t time.Time) {}
 
 type fakeDistributionMetric struct {
         FakeMetric
 
         bucketer *distribution.Bucketer
 }
 
 func (m *fakeDistributionMetric) Bucketer() *distribution.Bucketer { return m.bucketer }
 
 type sortableCellSlice []types.Cell
 
 func (s sortableCellSlice) Len() int { return len(s) }
 func (s sortableCellSlice) Less(i, j int) bool {
         return s[i].ResetTime.UnixNano() < s[j].ResetTime.UnixNano()
 }
 func (s sortableCellSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
 
 type sortableDataSlice []*pb.MetricsData
 
 func (s sortableDataSlice) Len() int { return len(s) }
 func (s sortableDataSlice) Less(i, j int) bool {
         a, _ := proto.Marshal(s[i])
         b, _ := proto.Marshal(s[j])
         return bytes.Compare(a, b) > 0
 }
 func (s sortableDataSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }