[milo] {buildbucket,buildbot,swarming,logdog} -> backends/*.

milo/appengine/job_source/swarming/html_data.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 swarming
 
 import (
         "encoding/json"
         "fmt"
         "io/ioutil"
@@ skipping 20 matching lines @@
         "github.com/luci/luci-go/milo/appengine/common"
         "github.com/luci/luci-go/milo/appengine/common/model"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/authtest"
         "github.com/luci/luci-go/server/templates"
 )
 
 type testCase struct {
         name string
 
+        swarmingRelDir string
+
         swarmResult string
         swarmOutput string
         annotations string
 }
 
-func getTestCases() []*testCase {
+func getTestCases(swarmingRelDir string) []*testCase {
         testCases := make(map[string]*testCase)
 
-        // References "milo/appengine/swarming/testdata".
-        testdata := filepath.Join("..", "swarming", "testdata")
+        // References "milo/appengine/job_source/swarming/testdata".
+        testdata := filepath.Join(swarmingRelDir, "testdata")
         f, err := ioutil.ReadDir(testdata)
         if err != nil {
                 panic(err)
         }
         for _, fi := range f {
                 fileName := fi.Name()
                 parts := strings.SplitN(fileName, ".", 2)
 
                 name := parts[0]
                 tc := testCases[name]
                 if tc == nil {
                         tc = &testCase{name: name}
                         testCases[name] = tc
                 }
+                tc.swarmingRelDir = swarmingRelDir
 
                 switch {
                 case len(parts) == 1:
                         tc.swarmOutput = fileName
                 case parts[1] == "swarm":
                         tc.swarmResult = fileName
                 case parts[1] == "pb.txt":
                         tc.annotations = fileName
                 }
         }
@@ skipping 14 matching lines @@
 }
 
 func (tc *testCase) getContent(name string) []byte {
         if name == "" {
                 return nil
         }
 
         // ../swarming below assumes that
         // - this code is not executed by tests outside of this dir
         // - this dir is a sibling of frontend dir
-        path := filepath.Join("..", "swarming", "testdata", name)
+        path := filepath.Join(tc.swarmingRelDir, "testdata", name)
         data, err := ioutil.ReadFile(path)
         if err != nil {
                 panic(fmt.Errorf("failed to read [%s]: %s", path, err))
         }
         return data
 }
 
 func (tc *testCase) getSwarmingResult() *swarming.SwarmingRpcsTaskResult {
         var sr swarming.SwarmingRpcsTaskResult
         data := tc.getContent(tc.swarmResult)
@@ skipping 116 matching lines @@
                                         Datagram: &logpb.Datagram{
                                                 Data: data,
                                         },
                                 },
                         },
                 },
         }
 }
 
 // BuildTestData returns sample test data for swarming build pages.
-func BuildTestData() []common.TestBundle {
+func BuildTestData(swarmingRelDir string) []common.TestBundle {
         basic := resp.MiloBuild{
                 Summary: resp.BuildComponent{
                         Label:    "Test swarming build",
                         Status:   model.Success,
                         Started:  time.Date(2016, 1, 2, 15, 4, 5, 999999999, time.UTC),
                         Finished: time.Date(2016, 1, 2, 15, 4, 6, 999999999, time.UTC),
                         Duration: time.Second,
                 },
         }
         results := []common.TestBundle{
                 {
                         Description: "Basic successful build",
                         Data:        templates.Args{"Build": basic},
                 },
         }
         c := context.Background()
         c = memory.UseWithAppID(c, "dev~luci-milo")
         c = testconfig.WithCommonClient(c, memcfg.New(aclConfgs))
         c = auth.WithState(c, &authtest.FakeState{
                 Identity:       "user:alicebob@google.com",
                 IdentityGroups: []string{"all", "googlers"},
         })
         c, _ = testclock.UseTime(c, time.Date(2016, time.March, 14, 11, 0, 0, 0, time.UTC))
 
-        for _, tc := range getTestCases() {
+        for _, tc := range getTestCases(swarmingRelDir) {
                 svc := debugSwarmingService{tc}
                 bl := buildLoader{
                         logDogClientFunc: logDogClientFunc(tc),
                 }
 
                 build, err := bl.swarmingBuildImpl(c, svc, "foo", tc.name)
                 if err != nil {
                         panic(fmt.Errorf("Error while processing %s: %s", tc.name, err))
                 }
                 results = append(results, common.TestBundle{
@@ skipping 15 matching lines @@
 `
 
 var aclConfgs = map[string]memcfg.ConfigSet{
         "projects/secret": {
                 "project.cfg": secretProjectCfg,
         },
         "projects/opensource": {
                 "project.cfg": publicProjectCfg,
         },
 }