Milo: Clean up builds that are no longer current.

milo/appengine/buildbot/pubsub_test.go

 // Copyright 2016 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 buildbot
 
 import (
         "bytes"
         "compress/zlib"
         "encoding/base64"
@@ skipping 153 matching lines @@
                         })
                 })
 
                 Convey("Build panics on invalid query", func() {
                         build := &buildbotBuild{
                                 Master: "Fake Master",
                         }
                         So(func() { ds.Put(c, build) }, ShouldPanicLike, "No Master or Builder found")
                 })
 
+                ts := 555
                 b := &buildbotBuild{
                         Master:      "Fake Master",
                         Buildername: "Fake buildername",
                         Number:      1234,
                         Currentstep: "this is a string",
                         Times:       buildbotTimesPending(123.0),
+                        TimeStamp:   &ts,
                 }
 
                 Convey("Basic master + build pusbsub subscription", func() {
                         h := httptest.NewRecorder()
                         slaves := map[string]*buildbotSlave{}
                         ft := 1234.0
                         slaves["testslave"] = &buildbotSlave{
                                 Name:      "testslave",
                                 Connected: true,
                                 Runningbuilds: []*buildbotBuild{
                                         {
                                                 Master:      "Fake Master",
                                                 Buildername: "Fake buildername",
                                                 Number:      2222,
                                                 Times:       []*float64{&ft, nil},
                                         },
                                 },
                         }
                         ms := buildbotMaster{
-                                Name:    "fakename",
-                                Project: buildbotProject{Title: "some title"},
-                                Slaves:  slaves,
+                                Name:     "Fake Master",
+                                Project:  buildbotProject{Title: "some title"},
+                                Slaves:   slaves,
+                                Builders: map[string]*buildbotBuilder{},
+                        }
+
+                        ms.Builders["Fake buildername"] = &buildbotBuilder{
+                                CurrentBuilds: []int{1234},
                         }
                         r := &http.Request{
                                 Body: newCombinedPsBody([]*buildbotBuild{b}, &ms, false),
                         }
                         p := httprouter.Params{}
                         PubSubHandler(&router.Context{
                                 Context: c,
                                 Writer:  h,
                                 Request: r,
                                 Params:  p,
                         })
                         So(h.Code, ShouldEqual, 200)
                         Convey("And stores correctly", func() {
                                 loadB := &buildbotBuild{
                                         Master:      "Fake Master",
                                         Buildername: "Fake buildername",
                                         Number:      1234,
                                 }
                                 err := ds.Get(c, loadB)
                                 So(err, ShouldBeNil)
                                 So(loadB.Master, ShouldEqual, "Fake Master")
                                 So(loadB.Currentstep.(string), ShouldEqual, "this is a string")
-                                m, t, err := getMasterJSON(c, "fakename")
+                                m, t, err := getMasterJSON(c, "Fake Master")
                                 So(err, ShouldBeNil)
                                 So(t.Unix(), ShouldEqual, 981173106)
-                                So(m.Name, ShouldEqual, "fakename")
+                                So(m.Name, ShouldEqual, "Fake Master")
                                 So(m.Project.Title, ShouldEqual, "some title")
                                 So(m.Slaves["testslave"].Name, ShouldEqual, "testslave")
                                 So(len(m.Slaves["testslave"].Runningbuilds), ShouldEqual, 0)
                                 So(len(m.Slaves["testslave"].RunningbuildsMap), ShouldEqual, 1)
                                 So(m.Slaves["testslave"].RunningbuildsMap["Fake buildername"][0],
                                         ShouldEqual, 2222)
                         })
 
                         Convey("And a new master overwrites", func() {
                                 c, _ = testclock.UseTime(c, fakeTime.Add(time.Duration(1*time.Second)))
                                 ms.Project.Title = "some other title"
                                 h = httptest.NewRecorder()
                                 r := &http.Request{
                                         Body: newCombinedPsBody([]*buildbotBuild{b}, &ms, false)}
                                 p = httprouter.Params{}
                                 PubSubHandler(&router.Context{
                                         Context: c,
                                         Writer:  h,
                                         Request: r,
                                         Params:  p,
                                 })
                                 So(h.Code, ShouldEqual, 200)
-                                m, t, err := getMasterJSON(c, "fakename")
+                                m, t, err := getMasterJSON(c, "Fake Master")
                                 So(err, ShouldBeNil)
                                 So(m.Project.Title, ShouldEqual, "some other title")
                                 So(t.Unix(), ShouldEqual, 981173107)
-                                So(m.Name, ShouldEqual, "fakename")
+                                So(m.Name, ShouldEqual, "Fake Master")
                         })
                         Convey("And a new build overwrites", func() {
                                 b.Times = buildbotTimesFinished(123.0, 124.0)
                                 h = httptest.NewRecorder()
                                 r = &http.Request{
                                         Body: newCombinedPsBody([]*buildbotBuild{b}, &ms, false),
                                 }
                                 p = httprouter.Params{}
                                 PubSubHandler(&router.Context{
                                         Context: c,
@@ skipping 29 matching lines @@
                                                 Master:      "Fake Master",
                                                 Buildername: "Fake buildername",
                                                 Number:      1234,
                                         }
                                         err := ds.Get(c, loadB)
                                         So(err, ShouldBeNil)
                                         So(*loadB.Times[0], ShouldEqual, 123.0)
                                         So(*loadB.Times[1], ShouldEqual, 124.0)
                                 })
                         })
+                        Convey("Expire non-existant current build", func() {
+                                b.Number = 1235
+                                h = httptest.NewRecorder()
+                                r = &http.Request{
+                                        Body: newCombinedPsBody([]*buildbotBuild{b}, &ms, false),
+                                }
+                                p = httprouter.Params{}
+                                ds.GetTestable(c).Consistent(true)

[hinoka, 2016/10/12 06:58:31]

This sort of cheats, because the pubsub handler stores all the builds first, and
then does the master functions.  But it works.

+                                PubSubHandler(&router.Context{
+                                        Context: c,
+                                        Writer:  h,
+                                        Request: r,
+                                        Params:  p,
+                                })
+                                So(h.Code, ShouldEqual, 200)
+                                loadB := &buildbotBuild{
+                                        Master:      "Fake Master",
+                                        Buildername: "Fake buildername",
+                                        Number:      1235,
+                                }
+                                err := ds.Get(c, loadB)
+                                So(err, ShouldBeNil)
+                                So(loadB.Finished, ShouldEqual, true)
+                                So(*loadB.Times[0], ShouldEqual, 123.0)
+                                So(loadB.Times[1], ShouldNotEqual, nil)
+                                So(*loadB.Times[1], ShouldEqual, 555.0)
+                                So(*loadB.Results, ShouldEqual, 2)
+                        })
                         Convey("Large pubsub message", func() {
                                 // This has to be a random string, so that after gzip compresses it
                                 // it remains larger than 950KB
                                 b.Text = append(b.Text, RandStringRunes(1500000))
                                 h := httptest.NewRecorder()
                                 r := &http.Request{
                                         Body: newCombinedPsBody([]*buildbotBuild{b}, &ms, false),
                                 }
                                 p := httprouter.Params{}
                                 PubSubHandler(&router.Context{
@@ skipping 30 matching lines @@
                                 Runningbuilds: []*buildbotBuild{
                                         {
                                                 Master:      "Fake Master",
                                                 Buildername: "Fake buildername",
                                                 Number:      2222,
                                                 Times:       []*float64{&ft, nil},
                                         },
                                 },
                         }
                         ms := buildbotMaster{
-                                Name:    "fakename",
+                                Name:    "Fake Master",
                                 Project: buildbotProject{Title: "some title"},
                                 Slaves:  slaves,
                         }
                         r := &http.Request{
                                 Body: newCombinedPsBody([]*buildbotBuild{b}, &ms, true),
                         }
                         p := httprouter.Params{}
                         PubSubHandler(&router.Context{
                                 Context: c,
                                 Writer:  h,
@@ skipping 12 matching lines @@
                                 loadB := &buildbotBuild{
                                         Master:      "Fake Master",
                                         Buildername: "Fake buildername",
                                         Number:      1234,
                                 }
                                 err = ds.Get(c, loadB)
                                 So(err, ShouldBeNil)
                                 So(loadB.Master, ShouldEqual, "Fake Master")
                                 So(loadB.Internal, ShouldEqual, true)
                                 So(loadB.Currentstep.(string), ShouldEqual, "this is a string")
-                                m, t, err := getMasterJSON(c, "fakename")
+                                m, t, err := getMasterJSON(c, "Fake Master")
                                 So(err, ShouldBeNil)
                                 So(t.Unix(), ShouldEqual, 981173106)
-                                So(m.Name, ShouldEqual, "fakename")
+                                So(m.Name, ShouldEqual, "Fake Master")
                                 So(m.Project.Title, ShouldEqual, "some title")
                                 So(m.Slaves["testslave"].Name, ShouldEqual, "testslave")
                                 So(len(m.Slaves["testslave"].Runningbuilds), ShouldEqual, 0)
                                 So(len(m.Slaves["testslave"].RunningbuildsMap), ShouldEqual, 1)
                                 So(m.Slaves["testslave"].RunningbuildsMap["Fake buildername"][0],
                                         ShouldEqual, 2222)
                         })
                 })
         })
 }
 
 var secretProjectCfg = `
 ID: "buildbot-internal"
 Readers: "google.com"
 `
 
 var aclConfgs = map[string]memcfg.ConfigSet{
         "projects/buildbot-internal.git": {
                 "luci-milo.cfg": secretProjectCfg,
         },
 }