client/isolate: add context to NewChecker func

client/cmd/isolate/checker_test.go

 // Copyright 2016 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 (
         "errors"
         "fmt"
         "sync"
@@ skipping 42 matching lines @@
                 states = append(states, ps)
         }
         if f.errc != nil {
                 return states, <-f.errc
         }
         return states, nil
 }
 
 func TestChecker(t *testing.T) {
         fake := &fakeIsolateService{}
-        checker := newChecker(fake)
+        checker := newChecker(context.Background(), fake)
 
         type itemPair struct {
                 item *Item
                 ps   *isolatedclient.PushState
         }
 
         gotc := make(chan itemPair, 150)
         for i := 0; i < 150; i++ {
                 item := &Item{
                         Path:   fmt.Sprintf("/item/%d", i),
@@ skipping 32 matching lines @@
                 t.Errorf("checker hit count: got %v ; want: %v", got, want)
         }
         if got, want := checker.Miss.Count, 150; got != want {
                 t.Errorf("checker hit count: got %v ; want: %v", got, want)
         }
 }
 
 func TestCheckerDelay(t *testing.T) {
         batchc := make(chan []*service.HandlersEndpointsV1Digest, 2)
         fake := &fakeIsolateService{batchc: batchc}
-        checker := newChecker(fake)
+        checker := newChecker(context.Background(), fake)
 
         nop := func(item *Item, ps *isolatedclient.PushState) {}
         checker.AddItem(&Item{Digest: "aaa"}, false, nop)
         checker.AddItem(&Item{Digest: "bbb"}, false, nop)
         <-batchc // Block until a batch is sent.
         checker.AddItem(&Item{Digest: "ccc"}, false, nop)
 
         if err := checker.Close(); err != nil {
                 t.Fatalf("checker.Close: got error %v; want %v", err, nil)
         }
 
         // Check that we have 2 batches (of 2 and 1 items respectively).
         if got, want := len(fake.itemBatches), 2; got != want {
                 t.Errorf("checker received %d batches, want %d", got, want)
         }
         for i, batch := range fake.itemBatches {
                 if got, want := len(batch), 2-i; got != want {
                         t.Errorf("checker batch[%d] has len %d, want %d", i, got, want)
                 }
         }
 }
 
 func TestCheckerErrors(t *testing.T) {
         // Make an error channel which sends errBang on the second receive.
         errc := make(chan error, 2)
-        errBang := errors.New("bang!")
+        errBang := errors.New("bang")
         errc <- nil
         errc <- errBang
         close(errc)
 
         fake := &fakeIsolateService{errc: errc}
-        checker := newChecker(fake)
+        checker := newChecker(context.Background(), fake)
 
         nop := func(item *Item, ps *isolatedclient.PushState) {}
         for i := 0; i < 150; i++ {
                 item := &Item{
                         Path:   fmt.Sprintf("/item/%d", i),
                         Digest: isolated.HexDigest(fmt.Sprintf("digest%d", i)),
                 }
                 checker.AddItem(item, false, nop)
         }
 
         if err := checker.Close(); err != errBang {
                 t.Fatalf("checker.Close: got error %v; want %v", err, errBang)
         }
 }