test-results: package model: Add full_result.go and tests

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

 package model
 
 import (
         "bytes"
         "encoding/json"
         "io/ioutil"
         "path/filepath"
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
-func TestCleanTestResultsJSON(t *testing.T) {
-        Convey("CleanTestResultsJSON", t, func() {
+func TestCleanJSON(t *testing.T) {
+        Convey("CleanJSON", t, func() {
                 data := `{"foo":"bar"}`
 
                 Convey("Strips prefix and suffix", func() {
                         r := bytes.NewReader([]byte(`ADD_RESULTS(` + data + `);`))
-                        res, err := CleanTestResultsJSON(r)
+                        res, err := CleanJSON(r)
                         So(err, ShouldBeNil)
                         b, err := ioutil.ReadAll(res)
                         So(err, ShouldBeNil)
                         So(string(b), ShouldEqual, data)
                 })
 
                 Convey("Returns original when prefix and suffix are absent", func() {
                         r := bytes.NewReader([]byte(data))
-                        res, err := CleanTestResultsJSON(r)
+                        res, err := CleanJSON(r)
                         So(err, ShouldBeNil)
                         b, err := ioutil.ReadAll(res)
                         So(err, ShouldBeNil)
                         So(string(b), ShouldEqual, data)
                 })
         })
 }
 
 func TestResultSummary(t *testing.T) {
         t.Parallel()
@@ skipping 215 matching lines @@
 
                                 Convey("secondsSinceEpoch", func() {
                                         Convey("Wrong secondsSinceEpoch element type", func() {
                                                 tm["foo_builder"].(map[string]interface{})["secondsSinceEpoch"] =
                                                         []interface{}{1, 2, "a"}
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldNotBeNil)
                                         })
 
-                                        Convey("Wrong secondsSinceEpoch list type", func() {
-                                                tm["foo_builder"].(map[string]interface{})["secondsSinceEpoch"] =
-                                                        nil
-                                                b := marshal(tm)
-                                                err := json.Unmarshal(b, &t)
-                                                So(err, ShouldNotBeNil)
-                                        })
-
                                         Convey("Valid secondsSinceEpoch", func() {
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldBeNil)
                                                 So(t.SecondsEpoch, ShouldResemble,
                                                         tm["foo_builder"].(map[string]interface{})["secondsSinceEpoch"])
                                         })
                                 })
 
                                 Convey("blinkRevison", func() {
                                         Convey("Wrong blinkRevison element type", func() {
                                                 tm["foo_builder"].(map[string]interface{})["blinkRevision"] =
                                                         []interface{}{"900", "bad"}
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldNotBeNil)
                                         })
 
-                                        Convey("Wrong blinkRevision list type", func() {
-                                                tm["foo_builder"].(map[string]interface{})["blinkRevision"] = nil
-                                                b := marshal(tm)
-                                                err := json.Unmarshal(b, &t)
-                                                So(err, ShouldNotBeNil)
-                                        })
-
                                         Convey("Valid blinkRevision", func() {
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldBeNil)
-                                                So(t.BlinkRevs, ShouldResemble, []number{100, 200, 0, -50})
+                                                So(t.BlinkRevs, ShouldResemble, []Number{100, 200, 0, -50})
                                         })
                                 })
 
                                 Convey("buildNumbers", func() {
                                         Convey("Wrong buildNumbers element type", func() {
                                                 tm["foo_builder"].(map[string]interface{})["buildNumbers"] =
                                                         []interface{}{"900", "bad"}
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldNotBeNil)
                                         })
 
                                         Convey("Wrong buildNumbers list type", func() {
                                                 tm["foo_builder"].(map[string]interface{})["buildNumbers"] = nil
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldNotBeNil)
                                         })
 
                                         Convey("Valid buildNumbers", func() {
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldBeNil)
-                                                So(t.BuildNumbers, ShouldResemble, []number{9000, 7500, -42, 0})
+                                                So(t.BuildNumbers, ShouldResemble, []Number{9000, 7500, -42, 0})
                                         })
                                 })
 
                                 Convey("chromeRevision", func() {
                                         Convey("Wrong chromeRevision element type", func() {
                                                 tm["foo_builder"].(map[string]interface{})["chromeRevision"] =
                                                         []interface{}{"900", false, "str"}
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldNotBeNil)
                                         })
 
-                                        Convey("Wrong chromeRevision list type", func() {
-                                                tm["foo_builder"].(map[string]interface{})["chromeRevision"] = nil
-                                                b := marshal(tm)
-                                                err := json.Unmarshal(b, &t)
-                                                So(err, ShouldNotBeNil)
-                                        })
-
                                         Convey("Valid chromeRevision", func() {
                                                 b := marshal(tm)
                                                 err := json.Unmarshal(b, &t)
                                                 So(err, ShouldBeNil)
                                                 So(t.ChromeRevs, ShouldResemble,
                                                         []string{"10", "40", "900", "65536", "afd807a", "88da8f4"},
                                                 )
                                         })
                                 })
 
@@ skipping 73 matching lines @@
                                                 So(err, ShouldBeNil)
 
                                                 So(json.Unmarshal(b, &actual), ShouldBeNil)
                                                 So(actual, ShouldResemble, t)
                                         })
                                 })
                         })
                 })
         })
 }