Fix walk graph to recurse correctly.

dm/appengine/deps/walk_graph_test.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 deps
 
 import (
         "fmt"
         "testing"
         "time"
@@ skipping 36 matching lines @@
 func TestWalkGraph(t *testing.T) {
         t.Parallel()
 
         Convey("WalkGraph", t, func() {
                 ttest, c, dist, s := testSetup()
 
                 ds := datastore.Get(c)
 
                 req := &dm.WalkGraphReq{
                         Query: dm.AttemptListQueryL(map[string][]uint32{"quest": {1}}),
-                        Limit: &dm.WalkGraphReq_Limit{MaxDepth: 1},
                 }
                 So(req.Normalize(), ShouldBeNil)
 
                 Convey("no read access", func() {
                         _, err := s.WalkGraph(c, req)
                         So(err, ShouldBeRPCPermissionDenied, "not authorized")
                 })
 
                 c = reader(c)
 
@@ skipping 22 matching lines @@
                                         Quests: map[string]*dm.Quest{
                                                 w: {
                                                         Attempts: map[uint32]*dm.Attempt{1: {}},
                                                 },
                                         },
                                 })
                         })
 
                         Convey("quest dne", func() {
                                 req.Include.Quest.Data = true
-                                req.Limit.MaxDepth = 1
                                 req.Query.AttemptList = dm.NewAttemptList(
                                         map[string][]uint32{"noex": {1}})
                                 So(req, fake.WalkShouldReturn(c, s), &dm.GraphData{
                                         Quests: map[string]*dm.Quest{
                                                 "noex": {
                                                         DNE:      true,
                                                         Attempts: map[uint32]*dm.Attempt{1: {DNE: true}},
                                                 },
                                         },
                                 })
@@ skipping 82 matching lines @@
 
                                 wEx := dm.NewExecutionID(w, 1, 1)
                                 dist.RunTask(c, wEx, func(tsk *fake.Task) error {
                                         tsk.MustActivate(c, s).DepOn(
                                                 dm.NewAttemptID(x, 1), dm.NewAttemptID(x, 2), dm.NewAttemptID(x, 3),
                                                 dm.NewAttemptID(x, 4))
                                         return nil
                                 })
                                 ttest.Drain(c)
 
-                                req.Limit.MaxDepth = 1
                                 Convey("normal", func() {
                                         req.Query = dm.AttemptRangeQuery(x, 2, 4)
                                         So(req, fake.WalkShouldReturn(c, s), &dm.GraphData{
                                                 Quests: map[string]*dm.Quest{
                                                         x: {Attempts: map[uint32]*dm.Attempt{2: {}, 3: {}}},
                                                 },
                                         })
                                 })
 
                                 Convey("oob range", func() {
@@ skipping 41 matching lines @@
                                 ttest.Drain(c)
 
                                 wEID := dm.NewExecutionID(w, 1, 2)
                                 wEx := model.ExecutionFromID(c, wEID)
                                 So(ds.Get(wEx), ShouldBeNil)
 
                                 dist.RunTask(c, wEID, func(tsk *fake.Task) error {
                                         So(tsk.State, ShouldResemble, dm.NewJsonResult(`{"originalState":true}`))
 
                                         act := tsk.MustActivate(c, s)
-                                        req.Limit.MaxDepth = 2
+                                        req.Limit.MaxDepth = 1
                                         req.Include.Attempt.Result = true
                                         req.Include.NumExecutions = 1
                                         req.Query = dm.AttemptListQueryL(map[string][]uint32{x: nil})
 
                                         x1Expect := dm.NewAttemptFinished(dm.NewJsonResult(x1data))
                                         x1Expect.Data.NumExecutions = 1
                                         x1Expect.Executions = map[uint32]*dm.Execution{
                                                 1: addDistributorInfo(
                                                         dm.NewExecutionID(x, 1, 1),
                                                         dm.NewExecutionFinished(dm.NewJsonResult(`{"atmpt1":true}`))),
@@ skipping 34 matching lines @@
                                 x1data := `{"data":["I can see this"]}`
                                 dist.RunTask(c, dm.NewExecutionID(x, 1, 1), func(tsk *fake.Task) error {
                                         tsk.MustActivate(c, s).Finish(x1data, exp)
                                         tsk.State = dm.NewJsonResult(`{"state": true}`)
                                         return nil
                                 })
                                 ttest.Drain(c)
 
                                 dist.RunTask(c, dm.NewExecutionID(w, 1, 2), func(tsk *fake.Task) error {
                                         act := tsk.MustActivate(c, s)
-                                        req.Limit.MaxDepth = 2
+                                        req.Limit.MaxDepth = 1
                                         req.Include.Attempt.Result = true
                                         req.Include.NumExecutions = 1
                                         req.Query = dm.AttemptListQueryL(map[string][]uint32{w: {1}})
 
                                         x1Expect := dm.NewAttemptFinished(dm.NewJsonResult(x1data))
                                         x1Expect.Data.NumExecutions = 1
                                         x1Expect.Executions = map[uint32]*dm.Execution{
                                                 1: addDistributorInfo(
                                                         dm.NewExecutionID(x, 1, 1),
                                                         dm.NewExecutionFinished(dm.NewJsonResult(`{"state":true}`))),
@@ skipping 15 matching lines @@
                                                 Quests: map[string]*dm.Quest{
                                                         w: {Attempts: map[uint32]*dm.Attempt{1: w1Exepct}},
                                                         x: {Attempts: map[uint32]*dm.Attempt{1: x1Expect}},
                                                 },
                                         })
                                         return nil
                                 })
                         })
 
                         Convey("deps (no dest attempts)", func() {
-                                req.Limit.MaxDepth = 3
+                                req.Limit.MaxDepth = 2
 
                                 x := s.ensureQuest(c, "x", 1)
                                 ttest.Drain(c)
 
                                 dist.RunTask(c, dm.NewExecutionID(w, 1, 1), func(tsk *fake.Task) error {
                                         tsk.MustActivate(c, s).DepOn(dm.NewAttemptID(x, 1), dm.NewAttemptID(x, 2))
 
                                         Convey("before tumble", func() {
                                                 req.Include.FwdDeps = true
                                                 // didn't run tumble, so that x|1 and x|2 don't get created.
@@ skipping 70 matching lines @@
                                                                         w: {Attempts: map[uint32]*dm.Attempt{1: {}}},
                                                                         x: {Attempts: map[uint32]*dm.Attempt{1: {}, 2: {}}},
                                                                         z: {Attempts: map[uint32]*dm.Attempt{1: {}}},
                                                                 },
                                                         })
                                                 })
 
                                         })
 
                                         Convey("attemptlist", func() {
-                                                req.Limit.MaxDepth = 1
                                                 req.Include.Quest.Ids = true
                                                 req.Include.Attempt.Ids = true
                                                 req.Query = dm.AttemptListQueryL(map[string][]uint32{x: nil})
                                                 So(req, fake.WalkShouldReturn(c, s), &dm.GraphData{
                                                         Quests: map[string]*dm.Quest{
                                                                 x: {
                                                                         Id: dm.NewQuestID(x),
                                                                         Attempts: map[uint32]*dm.Attempt{
                                                                                 1: {Id: dm.NewAttemptID(x, 1)},
                                                                                 2: {Id: dm.NewAttemptID(x, 2)},
@@ skipping 16 matching lines @@
                                         })
                                         ret, err := s.WalkGraph(c, req)
                                         So(err, ShouldBeNil)
                                         So(ret.HadMore, ShouldBeTrue)
                                 })
 
                         })
                 })
         })
 }