Fix Annotee stream name generation.

logdog/client/annotee/annotation/annotation_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 annotation
 
 import (
         "bufio"
         "flag"
         "fmt"
@@ skipping 21 matching lines @@
 
 var generate = flag.Bool("annotee.generate", false, "If true, regenerate expectations from source.")
 
 type testCase struct {
         name string
         exe  *Execution
 }
 
 func (tc *testCase) state(startTime time.Time) *State {
         cb := testCallbacks{
-                closed:   map[string]struct{}{},
+                closed:   map[*Step]struct{}{},
                 logs:     map[types.StreamName][]string{},
                 logsOpen: map[types.StreamName]struct{}{},
         }
         return &State{
                 LogNameBase: types.StreamName("base"),
                 Callbacks:   &cb,
                 Clock:       testclock.New(startTime),
                 Execution:   tc.exe,
         }
 }
 
 func (tc *testCase) generate(t *testing.T, startTime time.Time, touched stringset.Set) error {
         st := tc.state(startTime)
         p, err := playAnnotationScript(t, tc.name, st)
         if err != nil {
                 return err
         }
         touched.Add(p)
         st.Finish()
 
         // Write out generated protos.
         merr := errors.MultiError(nil)
 
         step := st.RootStep()
-        p, err = writeStepProto(tc.name, step.CanonicalName(), step.Proto())
+        p, err = writeStepProto(tc.name, step)
         if err != nil {
-                merr = append(merr, fmt.Errorf("Failed to write step proto for %q::%q: %v", tc.name, step.CanonicalName(), err))
+                merr = append(merr, fmt.Errorf("Failed to write step proto for %q::%q: %v", tc.name, step.LogNameBase, err))
         }
         touched.Add(p)
 
         // Write out generated logs.
         cb := st.Callbacks.(*testCallbacks)
         for logName, lines := range cb.logs {
                 p, err := writeLogText(tc.name, string(logName), lines)
                 if err != nil {
                         merr = append(merr, fmt.Errorf("Failed to write log text for %q::%q: %v", tc.name, logName, err))
                 }
@@ skipping 84 matching lines @@
                                 }
                         } else if err != nil {
                                 return "", err
                         }
                 }
         }
 
         return path, nil
 }
 
-func loadStepProto(t *testing.T, test, name string) *milo.Step {
-        path := filepath.Join(testExpDir, fmt.Sprintf("%s_%s.proto.txt", normalize(test), normalize(name)))
+func loadStepProto(t *testing.T, test string, s *Step) *milo.Step {
+        path := filepath.Join(testExpDir, fmt.Sprintf("%s_%s.proto.txt", normalize(test), normalize(string(s.LogNameBase))))
         data, err := ioutil.ReadFile(path)
         if err != nil {
                 t.Errorf("Failed to read milo.Step proto [%s]: %v", path, err)
                 return nil
         }
 
         st := milo.Step{}
         if err := proto.UnmarshalText(string(data), &st); err != nil {
                 t.Errorf("Failed to Unmarshal milo.Step proto [%s]: %v", path, err)
                 return nil
         }
         return &st
 }
 
-func writeStepProto(test, name string, step *milo.Step) (string, error) {
-        path := filepath.Join(testExpDir, fmt.Sprintf("%s_%s.proto.txt", normalize(test), normalize(name)))
-        return path, ioutil.WriteFile(path, []byte(proto.MarshalTextString(step)), 0644)
+func writeStepProto(test string, s *Step) (string, error) {
+        path := filepath.Join(testExpDir, fmt.Sprintf("%s_%s.proto.txt", normalize(test), normalize(string(s.LogNameBase))))
+        return path, ioutil.WriteFile(path, []byte(proto.MarshalTextString(s.Proto())), 0644)
 }
 
 func loadLogText(t *testing.T, test, name string) []string {
         path := filepath.Join(testExpDir, fmt.Sprintf("%s_%s.txt", normalize(test), normalize(name)))
         f, err := os.Open(path)
         if err != nil {
                 t.Errorf("Failed to open log lines [%s]: %v", path, err)
                 return nil
         }
         defer f.Close()
 
         lines := []string(nil)
         scanner := bufio.NewScanner(f)
         for scanner.Scan() {
                 lines = append(lines, scanner.Text())
         }
         return lines
 }
 
 func writeLogText(test, name string, text []string) (string, error) {
         path := filepath.Join(testExpDir, fmt.Sprintf("%s_%s.txt", normalize(test), normalize(name)))
         return path, ioutil.WriteFile(path, []byte(strings.Join(text, "\n")), 0644)
 }
 
 // testCallbacks implements the Callbacks interface, retaining all callback
 // data in memory.
 type testCallbacks struct {
-        // closed is the set of steps that have been closed, keyed on step
-        // CanonicalName.
-        closed map[string]struct{}
+        // closed is the set of steps that have been closed.
+        closed map[*Step]struct{}
 
         // logs is the content of emitted annotation logs, keyed on stream name.
         logs map[types.StreamName][]string
         // logsOpen tracks whether a given annotation log is open.
         logsOpen map[types.StreamName]struct{}
 }
 
 func (tc *testCallbacks) StepClosed(s *Step) {
-        tc.closed[s.CanonicalName()] = struct{}{}
+        tc.closed[s] = struct{}{}
 }
 
 func (tc *testCallbacks) StepLogLine(s *Step, n types.StreamName, label, line string) {
         if _, ok := tc.logs[n]; ok {
                 // The log exists. Assert that it is open.
                 if _, ok := tc.logsOpen[n]; !ok {
                         panic(fmt.Errorf("write to closed log stream: %q", n))
                 }
         }
 
@@ skipping 68 matching lines @@
                                 // All log streams should be closed.
                                 cb := st.Callbacks.(*testCallbacks)
                                 So(cb.logsOpen, ShouldResemble, map[types.StreamName]struct{}{})
 
                                 // Iterate over each generated stream and assert that it matches its
                                 // expectation. Do it deterministically so failures aren't frustrating
                                 // to reproduce.
                                 Convey(`Has correct Step value`, func() {
                                         rootStep := st.RootStep()
 
-                                        exp := loadStepProto(t, testCase.name, rootStep.CanonicalName())
+                                        exp := loadStepProto(t, testCase.name, rootStep)
                                         So(rootStep.Proto(), ShouldResemble, exp)
                                 })
 
                                 // Iterate over each generated log and assert that it matches its
                                 // expectations.
                                 logs := make([]string, 0, len(cb.logs))
                                 for k := range cb.logs {
                                         logs = append(logs, string(k))
                                 }
                                 sort.Strings(logs)
                                 for _, logName := range logs {
                                         log := cb.logs[types.StreamName(logName)]
                                         exp := loadLogText(t, testCase.name, logName)
                                         So(log, ShouldResemble, exp)
                                 }
                         })
                 }
 
                 Convey(`Append to a closed State is a no-op.`, func() {
                         st := testCases[0].state(startTime)
                         st.Finish()
                         sclone := st
                         So(st.Append("asdf"), ShouldBeNil)
                         So(st, ShouldResemble, sclone)
                 })
         })
 }