milo: Enable Swarming LogDog log loading.

milo/appengine/swarming/buildinfo_test.go

 // Copyright 2017 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 (
         "fmt"
         "testing"
 
         swarming "github.com/luci/luci-go/common/api/swarming/swarming/v1"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/logdog/api/endpoints/coordinator/logs/v1"
-        "github.com/luci/luci-go/logdog/api/logpb"
         "github.com/luci/luci-go/logdog/client/coordinator"
         milo "github.com/luci/luci-go/milo/api/proto"
 
         "github.com/luci/gae/impl/memory"
 
-        "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
-        "google.golang.org/grpc"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
-// testLogDogClient is a minimal functional LogsClient implementation.
-//
-// It retains its latest input parameter and returns its configured err (if not
-// nil) or resp.
-type testLogDogClient struct {
-        logdog.LogsClient
-
-        req  interface{}
-        resp interface{}
-        err  error
-}
-
-func (tc *testLogDogClient) Tail(ctx context.Context, in *logdog.TailRequest, opts ...grpc.CallOption) (
-        *logdog.GetResponse, error) {
-
-        tc.req = in
-        if tc.err != nil {
-                return nil, tc.err
-        }
-        return tc.resp.(*logdog.GetResponse), nil
-}
-
 type testSwarmingService struct {
         swarmingService
 
         host string
         req  swarming.SwarmingRpcsTaskRequest
         res  swarming.SwarmingRpcsTaskResult
 }
 
 func (sf *testSwarmingService) getHost() string { return sf.host }
 
 func (sf *testSwarmingService) getSwarmingResult(c context.Context, taskID string) (
         *swarming.SwarmingRpcsTaskResult, error) {
 
         return &sf.res, nil
 }
 
 func (sf *testSwarmingService) getSwarmingRequest(c context.Context, taskID string) (
         *swarming.SwarmingRpcsTaskRequest, error) {
 
         return &sf.req, nil
 }
 
-func datagramGetResponse(project, prefix string, msg proto.Message) *logdog.GetResponse {
-        data, err := proto.Marshal(msg)
-        if err != nil {
-                panic(err)
-        }
-        return &logdog.GetResponse{
-                Project: project,
-                Desc: &logpb.LogStreamDescriptor{
-                        Prefix:      prefix,
-                        ContentType: miloProto.ContentTypeAnnotations,
-                        StreamType:  logpb.StreamType_DATAGRAM,
-                },
-                State: &logdog.LogStreamState{},
-                Logs: []*logpb.LogEntry{
-                        {
-                                Content: &logpb.LogEntry_Datagram{
-                                        Datagram: &logpb.Datagram{
-                                                Data: data,
-                                        },
-                                },
-                        },
-                },
-        }
-}
-
 func TestBuildInfo(t *testing.T) {
         t.Parallel()
 
         Convey("A testing BuildInfoProvider", t, func() {
                 c := context.Background()
                 c = memory.Use(c)
 
                 testClient := testLogDogClient{}
                 testSvc := testSwarmingService{
                         host: "swarming.example.com",
@@ skipping 10 matching lines @@
                                 State:  TaskRunning,
                                 Tags: []string{
                                         "allow_milo:1",
                                         "foo:1",
                                         "bar:2",
                                 },
                                 TryNumber: 1,
                         },
                 }
                 bip := BuildInfoProvider{
-                        LogdogClientFunc: func(context.Context) (*coordinator.Client, error) {
-                                return &coordinator.Client{
-                                        C:    &testClient,
-                                        Host: "example.com",
-                                }, nil
+                        bl: buildLoader{
+                                logDogClientFunc: func(c context.Context, host string) (*coordinator.Client, error) {
+                                        if host == "" {
+                                                host = "example.com"
+                                        }
+                                        return &coordinator.Client{
+                                                C:    &testClient,
+                                                Host: host,
+                                        }, nil
+                                },
                         },
                         swarmingServiceFunc: func(context.Context, string) (swarmingService, error) {
                                 return &testSvc, nil
                         },
                 }
 
                 logdogStep := miloProto.Step{
                         Command: &miloProto.Step_Command{
                                 CommandLine: []string{"foo", "bar", "baz"},
                         },
@@ skipping 130 matching lines @@
                 }
 
                 for _, tc := range failures {
                         Convey(fmt.Sprintf("Failes to parse %q / %q (%s)", tc.taskID, tc.tryNumber, tc.err), func() {
                                 _, err := getRunID(tc.taskID, tc.tryNumber)
                                 So(err, ShouldErrLike, tc.err)
                         })
                 }
         })
 }