dispatcher: fix test result parsing, build ranges for failure alerts, other fixes

go/src/infra/monitoring/analyzer/analyzer_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package analyzer
 
 import (
         "fmt"
         "infra/monitoring/messages"
         "reflect"
@@ skipping 83 matching lines @@
                         name: "Future master",
                         url:  "http://fake.master",
                         be: messages.BuildExtract{
                                 CreatedTimestamp: messages.EpochTime(110),
                         },
                         t:    time.Unix(100, 0),
                         want: []messages.Alert{},
                 },
         }
 
-        a := New(&mockClient{}, 10)
+        a := New(&mockClient{}, 0, 10)
 
         for _, test := range tests {
                 a.now = fakeNow(test.t)
                 got := a.MasterAlerts(test.url, &test.be)
                 if !reflect.DeepEqual(got, test.want) {
                         t.Errorf("%s failed. Got %+v, want: %+v", test.name, got, test.want)
                 }
         }
 }
 
 func TestBuilderAlerts(t *testing.T) {
         tests := []struct {
                 name         string
                 url          string
                 be           messages.BuildExtract
                 filter       string
                 t            time.Time
                 wantBuilders []messages.Alert
                 wantMasters  []messages.Alert
         }{
                 {
                         name:         "Empty",
+                        url:          "https://build.chromium.org/p/fake.master/json",
                         wantBuilders: []messages.Alert{},
                         wantMasters:  []messages.Alert{},
                 },
                 {
                         name: "No Alerts",
-                        url:  "http://fake.master",
+                        url:  "https://build.chromium.org/p/fake.master/json",
                         be: messages.BuildExtract{
                                 CreatedTimestamp: messages.EpochTime(100),
                         },
                         t:            time.Unix(100, 0),
                         wantBuilders: []messages.Alert{},
                         wantMasters:  []messages.Alert{},
                 },
         }
 
-        a := New(&mockClient{}, 10)
+        a := New(&mockClient{}, 0, 10)
 
         for _, test := range tests {
                 a.now = fakeNow(test.t)
                 got := a.BuilderAlerts(test.url, &test.be)
                 if !reflect.DeepEqual(got, test.wantBuilders) {
                         t.Errorf("%s failed. Got %+v, want: %+v", test.name, got, test.wantBuilders)
                 }
         }
 }
 
@@ skipping 53 matching lines @@
                         },
                         b: messages.Builders{
                                 State:         messages.StateBuilding,
                                 BuilderName:   "fake.builder",
                                 CachedBuilds:  []int64{0, 1, 2, 3},
                                 CurrentBuilds: []int64{5, 6, 7, 8},
                         },
                         time: time.Unix(0, 0).Add(4 * time.Hour),
                         wantAlerts: []messages.Alert{
                                 {
-                                        Key:   "fake.master.fake.builder.hung",
-                                        Title: "fake.master.fake.builder is hung in step fake_step.",
-                                        Time:  messages.TimeToEpochTime(time.Unix(0, 0).Add(4 * time.Hour)),
-                                        Body:  "fake.master.fake.builder has been building for 3h59m50s (last step update 1970-01-01 00:00:10 +0000 UTC), past the alerting threshold of 3h0m0s",
+                                        Key:      "fake.master.fake.builder.hung",
+                                        Title:    "fake.master.fake.builder is hung in step fake_step.",
+                                        Time:     messages.TimeToEpochTime(time.Unix(0, 0).Add(4 * time.Hour)),
+                                        Body:     "fake.master.fake.builder has been building for 3h59m50s (last step update 1970-01-01 00:00:10 +0000 UTC), past the alerting threshold of 3h0m0s",
+                                        Severity: 1,
                                         Links: []messages.Link{
                                                 {Title: "Builder", Href: "https://build.chromium.org/p/fake.master/builders/fake.builder"},
                                                 {Title: "Last build", Href: "https://build.chromium.org/p/fake.master/builders/fake.builder/builds/3"},
                                                 {Title: "Last build step", Href: "https://build.chromium.org/p/fake.master/builders/fake.builder/builds/3/steps/fake_step"},
                                         },
                                 },
                         },
                         wantErrs: []error{},
                 },
         }
 
-        a := New(nil, 10)
+        a := New(nil, 0, 10)
 
         for _, test := range tests {
                 a.now = fakeNow(test.time)
                 a.Client = mockClient{
                         build: test.builds,
                 }
                 gotAlerts, gotErrs := a.builderAlerts(test.master, test.builder, &test.b)
                 if !reflect.DeepEqual(gotAlerts, test.wantAlerts) {
                         t.Errorf("%s failed. Got:\n%+v, want:\n%+v", test.name, gotAlerts, test.wantAlerts)
                 }
@@ skipping 53 matching lines @@
                         want:        []string{},
                 },
                 {
                         name: "GTests",
                         f: stepFailure{
                                 step: messages.Steps{
                                         Name: "something_tests",
                                 },
                         },
                         testResults: &messages.TestResults{
-                                Tests: map[string]messages.TestResult{
-                                        "test a": messages.TestResult{
-                                                Expected: "PASS",
-                                                Actual:   "FAIL",
+                                Tests: map[string]interface{}{
+                                        "test a": map[string]interface{}{
+                                                "expected": "PASS",
+                                                "actual":   "FAIL",
                                         },
                                 },
                         },
                         want: []string{"test a"},
                 },
         }
 
         mc := &mockClient{}
-        a := New(mc, 10)
+        a := New(mc, 0, 10)
 
         for _, test := range tests {
                 mc.testResults = test.testResults
                 got := a.reasonsForFailure(test.f)
                 if !reflect.DeepEqual(got, test.want) {
                         t.Errorf("% s failed. Got: %+v, want: %+v", test.name, got, test.want)
                 }
         }
 }
 
@@ skipping 55 matching lines @@
                                                 Name:       "broken_step",
                                                 IsFinished: true,
                                                 Results:    []interface{}{float64(3)},
                                         },
                                 },
                         },
                 },
         }
 
         mc := &mockClient{}
-        a := New(mc, 10)
+        a := New(mc, 0, 10)
 
         for _, test := range tests {
                 mc.build = test.b
                 a.bCache = test.bCache
                 got, err := a.stepFailures(test.master, test.builder, test.bID)
                 if !reflect.DeepEqual(got, test.want) {
                         t.Errorf("%s failed.\nGot:\n%+v\nwant:\n%+v", test.name, got, test.want)
                 }
                 if !reflect.DeepEqual(err, test.wantErr) {
                         t.Errorf("%s failed. Got %+v, want %+v", test.name, err, test.wantErr)
                 }
         }
 }
 
+func TestStepFailureAlerts(t *testing.T) {
+        tests := []struct {
+                name        string
+                failures    []stepFailure
+                testResults messages.TestResults
+                alerts      []messages.Alert
+                err         error
+        }{
+                {
+                        name:   "empty",
+                        alerts: []messages.Alert{},
+                },
+                {
+                        name: "single failure",
+                        failures: []stepFailure{
+                                {
+                                        masterName:  "fake.master",
+                                        builderName: "fake.builder",
+                                        build: messages.Builds{
+                                                Number: 2,
+                                        },
+                                        step: messages.Steps{
+                                                Name: "steps",
+                                        },
+                                },
+                                {
+                                        masterName:  "fake.master",
+                                        builderName: "fake.builder",
+                                        build: messages.Builds{
+                                                Number: 42,
+                                        },
+                                        step: messages.Steps{
+                                                Name: "fake_tests",
+                                        },
+                                },
+                        },
+                        testResults: messages.TestResults{},
+                        alerts: []messages.Alert{
+                                {
+                                        Key:   "fake.master.fake.builder.fake_tests.",
+                                        Title: "Builder step failure: fake.master.fake.builder",
+                                        Type:  "buildfailure",
+                                        Extension: messages.BuildFailure{
+                                                Builders: []messages.AlertedBuilder{
+                                                        {
+                                                                Name:          "fake.builder",
+                                                                URL:           "https://build.chromium.org/p/fake.master/builders/fake.builder",
+                                                                FirstFailure:  42,
+                                                                LatestFailure: 42,
+                                                        },
+                                                },
+                                        },
+                                },
+                        },
+                },
+        }
+
+        mc := &mockClient{}
+        a := New(mc, 0, 10)
+        a.now = fakeNow(time.Unix(0, 0))
+
+        for _, test := range tests {
+                mc.testResults = &test.testResults
+                alerts, err := a.stepFailureAlerts(test.failures)
+                if !reflect.DeepEqual(alerts, test.alerts) {
+                        t.Errorf("%s failed. Got:\n\t%+v, want:\n\t%+v", test.name, alerts, test.alerts)
+                }
+                if !reflect.DeepEqual(err, test.err) {
+                        t.Errorf("%s failed. Got %+v, want %+v", test.name, err, test.err)
+                }
+        }
+}
+
 func TestLatestBuildStep(t *testing.T) {
         tests := []struct {
                 name       string
                 b          messages.Builds
                 wantStep   string
                 wantUpdate messages.EpochTime
                 wantErr    error
         }{
                 {
                         name:    "blank",
@@ skipping 99 matching lines @@
                                                         messages.TimeToEpochTime(time.Unix(7, 0)),
                                                 },
                                         },
                                 },
                         },
                         wantStep:   StepCompletedRun,
                         wantUpdate: messages.TimeToEpochTime(time.Unix(42, 0)),
                 },
         }
 
-        a := New(&mockClient{}, 10)
+        a := New(&mockClient{}, 0, 10)
         a.now = fakeNow(time.Unix(0, 0))
         for _, test := range tests {
                 gotStep, gotUpdate, gotErr := a.latestBuildStep(&test.b)
                 if gotStep != test.wantStep {
                         t.Errorf("%s failed. Got %q, want %q.", test.name, gotStep, test.wantStep)
                 }
                 if gotUpdate != test.wantUpdate {
                         t.Errorf("%s failed. Got %v, want %v.", test.name, gotUpdate, test.wantUpdate)
                 }
                 if gotErr != test.wantErr {
                         t.Errorf("%s failed. Got %s, want %s.", test.name, gotErr, test.wantErr)
                 }
         }
 }