Log eventlogs from legacy isolate archive command

client/cmd/isolate/isolate_event_logger_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 main
+
+import (
+        "fmt"
+        "reflect"
+        "testing"
+        "time"
+
+        "golang.org/x/net/context"
+
+        "github.com/golang/protobuf/proto"
+        "github.com/luci/luci-go/common/eventlog"
+        logpb "github.com/luci/luci-go/common/eventlog/proto"
+)
+
+// fakeLogger implements syncLogger by storing method arguments for later inspection.
+type fakeLogger struct {
+        events []*eventlog.ChromeInfraLogEvent
+}
+
+func (fl *fakeLogger) LogSync(ctx context.Context, events ...*eventlog.ChromeInfraLogEvent) error {
+        fl.events = append(fl.events, events...)
+        return nil
+}
+
+func defaultEvent() *eventlog.ChromeInfraLogEvent {
+        point := logpb.ChromeInfraEvent_POINT
+        return &eventlog.ChromeInfraLogEvent{
+                LogEvent: &logpb.LogRequestLite_LogEventLite{
+                        EventTimeMs: proto.Int64(10),
+                },
+                InfraEvent: &logpb.ChromeInfraEvent{
+                        TimestampKind: &point,
+                },
+        }
+}
+
+func (fl *fakeLogger) NewLogEvent(ctx context.Context, eventTime eventlog.TypedTime) *eventlog.ChromeInfraLogEvent {
+        return defaultEvent()
+}
+
+func fakeGetEnvValue(key string) *string {
+        if key == "" {
+                return nil
+        }
+
+        ret := fmt.Sprintf("%s value", key)
+        return &ret
+}
+
+func TestLogSync(t *testing.T) {
+        flogger := &fakeLogger{}
+        eventlogger := &IsolateEventLogger{client: flogger, getEnvironmentValue: fakeGetEnvValue}
+        ctx := context.Background()
+        op := logpb.IsolateClientEvent_ARCHIVE.Enum()
+        const startUsec = 100
+        const endUsec = 200
+        start := time.Unix(0, startUsec*1000)
+        end := time.Unix(0, endUsec*1000)
+
+        details := &logpb.IsolateClientEvent_ArchiveDetails{
+                HitCount:    proto.Int64(1),
+                MissCount:   proto.Int64(2),
+                HitBytes:    proto.Int64(4),
+                MissBytes:   proto.Int64(8),
+                IsolateHash: []string{"hash brown"},
+        }
+
+        wantEvent := defaultEvent()
+        wantEvent.InfraEvent.IsolateClientEvent = &logpb.IsolateClientEvent{
+                Binary: &logpb.Binary{
+                        Name:          proto.String("isolate"),
+                        VersionNumber: proto.String(version),
+                },
+                Operation:      op,
+                ArchiveDetails: details,
+                Master:         proto.String("BUILDBOT_MASTERNAME value"),
+                Builder:        proto.String("BUILDBOT_BUILDERNAME value"),
+                BuildId:        proto.String("BUILDBOT_BUILDNUMBER value"),
+                Slave:          proto.String("BUILDBOT_SLAVENAME value"),
+                StartTsUsec:    proto.Int64(startUsec),
+                EndTsUsec:      proto.Int64(endUsec),
+        }
+
+        err := eventlogger.logStats(ctx, op, start, end, details)
+        if err != nil {
+                t.Fatalf("IsolateEventLogger.logStats: got err %v; want %v", err, nil)
+        }
+        if got, want := flogger.events, []*eventlog.ChromeInfraLogEvent{wantEvent}; !reflect.DeepEqual(got, want) {
+                t.Errorf("IsolateEventLogger.logStats: got %v; want %v", got, want)
+        }
+}