test-results: package model: Add type TestList

go/src/infra/appengine/test-results/model/aggregate_result.go

 package model
 
 import (
         "bytes"
         "encoding/json"
         "errors"
         "fmt"
         "io"
         "io/ioutil"
         "strconv"
@@ skipping 24 matching lines @@
         if bytes.HasPrefix(b, CleanPrefix) && bytes.HasSuffix(b, CleanSuffix) {
                 result := bytes.TrimPrefix(b, CleanPrefix)
                 result = bytes.TrimSuffix(result, CleanSuffix)
                 return bytes.NewReader(result), nil
         }
 
         return bytes.NewReader(b), nil
 }
 
 // AggregateResult represents "results.json" and "results-small.json" files.
-// The Builder field must be set to the expected builder name before unmarshaling.
 type AggregateResult struct {
         Version int
         Builder string
         *BuilderInfo
 }
 
 // BuilderInfo represents aggregate information for a builder.
 type BuilderInfo struct {
         // SecondsEpoch is the start time of tests expressed in seconds from
         // the Unix epoch.
@@ skipping 23 matching lines @@
         FailuresByType map[string][]int `json:"num_failures_by_type,omitempty"`
 
         // FixableCounts represents test failures in a legacy format,
         // and is usually nil.
         //
         // It is included here because it may be needed to compute
         // FailuresByType when unmarshaling JSON.
         FixableCounts []map[string]int `json:"fixableCounts,omitempty"`
 }
 
+// TestList is a representation an AggregateResult in which
+// the Results and Runtimes fields of all the AggregateTestLeafs
+// are set to nil.
+type TestList struct {
+        Builder string
+        Tests   AggregateTest
+}
+
+// MarshalJSON marshals tl into JSON.
+func (tl *TestList) MarshalJSON() ([]byte, error) {
+        return json.Marshal(map[string]map[string]AggregateTest{
+                tl.Builder: {
+                        "tests": tl.Tests,
+                },
+        })
+}
+
+// ToTestList returns a TestList representation of ag.
+// The receiver's Tests field will be modified in the process.
+func (ag *AggregateResult) ToTestList() TestList {
+        tl := TestList{
+                Builder: ag.Builder,
+                Tests:   ag.Tests,
+        }
+        tl.Tests.WalkLeaves(func(_ string, leaf *AggregateTestLeaf) {
+                leaf.Results = nil
+                leaf.Runtimes = nil
+        })
+        return tl
+}
+
 // MarshalJSON marshal ag into JSON.
 func (ag *AggregateResult) MarshalJSON() ([]byte, error) {
         v, err := json.Marshal(ag.Version)
         if err != nil {
                 return nil, err
         }
         vRaw := json.RawMessage(v)
 
         info := *ag.BuilderInfo
 
         // If FailuresByType exists, do not include FixableCounts
         // because it is deprecated.
         if info.FailuresByType != nil {
                 info.FixableCounts = nil
         }
 
         b, err := json.Marshal(&info)
         if err != nil {
                 return nil, err
         }
         infoRaw := json.RawMessage(b)
 
         return json.Marshal(map[string]*json.RawMessage{
                 "version":  &vRaw,
                 ag.Builder: &infoRaw,
         })
 }
 
+// extractBuilderName gets the builder name from the supplied map.
+// This depends on the fact that AggregateResults are expected to
+// only have two top-level keys: (1) "version" (2) the builder name.
+func extractBuilderName(m map[string]json.RawMessage) (string, error) {
+        for k := range m {
+                if k != "version" {
+                        return k, nil
+                }
+        }
+        return "", errors.New("builder name not found")
+}
+
 // UnmarshalJSON decodes JSON data into t.
 //
 // The expected format is a modified version of the format described in the URL
 // below. The modifications account for the structure of results.json and
 // results_small.json files in the wild.
 //
 //   https://chromium.googlesource.com/chromium/src/+/c7dd0560d9544a15908239bebc177410899851ca/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/layout_package/bot_test_expectations.py#45
 func (ag *AggregateResult) UnmarshalJSON(data []byte) error {
         var m map[string]json.RawMessage
         if err := json.Unmarshal(data, &m); err != nil {
                 return err
         }
 
         // Version.
 
         n, err := parseVersion(m)
         if err != nil {
                 return err
         }
         ag.Version = n
 
+        // Builder name.
+
+        builder, err := extractBuilderName(m)
+        if err != nil {
+                return err
+        }
+        ag.Builder = builder
+
         // BuilderInfo.
 
-        raw, ok := m[ag.Builder]
-        if !ok {
-                return fmt.Errorf("model: missing builder %q", ag.Builder)
-        }
-
         var info *BuilderInfo
-        if err := json.Unmarshal(raw, &info); err != nil {
+        if err := json.Unmarshal(m[builder], &info); err != nil {
                 return err
         }
         ag.BuilderInfo = info
 
         if err := ag.checkFields(); err != nil {
                 return err
         }
         if err := info.computeFailuresByType(); err != nil {
                 return err
         }
@@ skipping 13 matching lines @@
         }
         return n, nil
 }
 
 type fieldError struct {
         Name  string      // Name of field.
         Value interface{} // Invalid value in the field that caused error.
 }
 
 func (f *fieldError) Error() string {
-        return fmt.Sprintf("model: field %q has invalid value: %v", f.Name, f.Value)
+        return fmt.Sprintf("model: field %q has invalid value: %v (%T)", f.Name, f.Value, f.Value)
 }
 
 func (ag *AggregateResult) checkFields() error {
         if ag.Version > ResultsVersion {
                 return &fieldError{"Version", ag.Version}
         }
         if ag.BuilderInfo == nil {
                 return &fieldError{"BuilderInfo", ag.BuilderInfo}
         }
         return nil
@@ skipping 59 matching lines @@
 // WalkLeaves is similar to Walk but only calls fn for
 // *AggregateTestLeaf.
 func (at AggregateTest) WalkLeaves(fn func(key string, leaf *AggregateTestLeaf)) {
         at.Walk(func(key string, node Node) {
                 if leaf, ok := node.(*AggregateTestLeaf); ok {
                         fn(key, leaf)
                 }
         })
 }
 
-// ToTestList set the Results and Runtimes fields of all the
-// AggregateTestLeaf under the receiver AggregateTest to nil.
-func (at AggregateTest) ToTestList() {
-        at.WalkLeaves(func(_ string, leaf *AggregateTestLeaf) {
-                leaf.Results = nil
-                leaf.Runtimes = nil
-        })
-}
-
 // MarshalJSON marshals at into JSON.
 func (at *AggregateTest) MarshalJSON() ([]byte, error) {
         if at == nil {
                 return json.Marshal(nil)
         }
 
         m := make(map[string]*json.RawMessage)
 
         for k, v := range *at {
                 b, err := json.Marshal(&v)
@@ skipping 48 matching lines @@
                 }
                 if *at == nil {
                         *at = AggregateTest{}
                 }
                 (*at)[k] = child
         }
 
         return nil
 }
 
-// isAggregateTestLeaf returns true if the supplied map is likely represents a
+// isAggregateTestLeaf returns true if the supplied map is likely an
 // AggregateTestLeaf.
 func isAggregateTestLeaf(m map[string]interface{}) bool {
         for key, val := range m {
                 if key == "results" {
                         if _, ok := val.([]interface{}); ok {
                                 return true
                         }
                 }
         }
         return false
@@ skipping 21 matching lines @@
 func (leaf *AggregateTestLeaf) node() {}
 
 // aggregateTestLeafAux is used to marshal and unmarshal AggregateTestLeaf.
 type aggregateTestLeafAux struct {
         Results  []ResultSummary  `json:"results,omitempty"`
         Runtimes []RuntimeSummary `json:"times,omitempty"`
         Expected *string          `json:"expected,omitempty"`
         Bugs     []string         `json:"bugs,omitempty"`
 }
 
-// MarshalJSON marshal l into JSON.
+// MarshalJSON marshals leaf into JSON.
 func (leaf *AggregateTestLeaf) MarshalJSON() ([]byte, error) {
         aux := aggregateTestLeafAux{
                 Results:  leaf.Results,
                 Runtimes: leaf.Runtimes,
                 Bugs:     leaf.Bugs,
         }
         if s := strings.Join(leaf.Expected, " "); len(s) > 0 {
                 aux.Expected = &s
         }
         return json.Marshal(&aux)
 }
 
-// UnmarshalJSON unmarshal the supplied data into l.
+// UnmarshalJSON unmarshals the supplied data into leaf.
 func (leaf *AggregateTestLeaf) UnmarshalJSON(data []byte) error {
         var aux aggregateTestLeafAux
         if err := json.Unmarshal(data, &aux); err != nil {
                 return err
         }
 
         leaf.Results = aux.Results
         leaf.Runtimes = aux.Runtimes
         if aux.Expected != nil {
                 leaf.Expected = strings.Split(*aux.Expected, " ")
@@ skipping 244 matching lines @@
 
 func isDebugBuilder(builder string) bool {
         for _, s := range []string{"debug", "dbg"} {
                 if strings.Contains(strings.ToLower(builder), s) {
                         return true
                 }
         }
         return false
 }
 
-// Trim trims the leaves of Tests in ar to the specified size.
+// Trim trims ag's fields to the specified size.
 func (ag *AggregateResult) Trim(size int) error {
         t := runtimeThresholdNormal
 
         if isDebugBuilder(ag.Builder) {
                 t = runtimeThresholdDebug
         }
 
+        ag.SecondsEpoch = ag.SecondsEpoch[:min(size, len(ag.SecondsEpoch))]
+        ag.BlinkRevs = ag.BlinkRevs[:min(size, len(ag.BlinkRevs))]
+        ag.ChromeRevs = ag.ChromeRevs[:min(size, len(ag.ChromeRevs))]
+        ag.BuildNumbers = ag.BuildNumbers[:min(size, len(ag.BuildNumbers))]
+
         return ag.Tests.trim(size, t)
 }
 
 func (at AggregateTest) trim(size int, threshold float64) error {
         for k, v := range at {
                 if leaf, ok := v.(*AggregateTestLeaf); ok {
                         leaf.trim(size)
                         if leaf.shouldDelete(threshold) {
                                 delete(at, k)
                         }
@@ skipping 61 matching lines @@
                 }
         }
         for _, r := range leaf.Runtimes {
                 if r.Runtime >= threshold {
                         return false
                 }
         }
 
         return true
 }