Isolate: Use generators instead of seekers

client/isolatedclient/isolatedclient_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package isolatedclient
 
 import (
-        "bytes"
         "io"
         "log"
         "math/rand"
         "net/http"
         "net/http/httptest"
         "sync"
         "testing"
         "time"
 
         "github.com/luci/luci-go/client/internal/retry"
@@ skipping 52 matching lines @@
         flaky := &killingMux{server: server, tearDown: map[string]int{"/fake/cloudstorage": 1024}}
         flaky.ts = httptest.NewServer(flaky)
         defer flaky.ts.Close()
         client := newIsolateServer(nil, flaky.ts.URL, "default-gzip", fastRetry)
 
         digests, contents, expected := makeItems(large)
         states, err := client.Contains(digests)
         ut.AssertEqual(t, nil, err)
         ut.AssertEqual(t, len(digests), len(states))
         for _, state := range states {
-                err = client.Push(state, bytes.NewReader(contents[state.status.Index]))
+                err = client.Push(state, NewBytesSource(contents[state.status.Index]))
                 ut.AssertEqual(t, nil, err)
         }
         ut.AssertEqual(t, expected, server.Contents())
         ut.AssertEqual(t, map[string]int{}, flaky.tearDown)
 
         // Look up again to confirm.
         states, err = client.Contains(digests)
         ut.AssertEqual(t, nil, err)
         ut.AssertEqual(t, len(digests), len(states))
         for _, state := range states {
@@ skipping 59 matching lines @@
         digests, _, expected := makeItems(contents...)
         server := isolatedfake.New()
         ts := httptest.NewServer(server)
         defer ts.Close()
         client := newIsolateServer(nil, ts.URL, "default-gzip", cantRetry)
         states, err := client.Contains(digests)
         ut.AssertEqual(t, nil, err)
         ut.AssertEqual(t, len(digests), len(states))
         for _, state := range states {
                 // The data is automatically compressed.
-                err = client.Push(state, bytes.NewReader(contents[state.status.Index]))
+                err = client.Push(state, NewBytesSource(contents[state.status.Index]))
                 ut.AssertEqual(t, nil, err)
         }
         ut.AssertEqual(t, nil, server.Error())
         ut.AssertEqual(t, expected, server.Contents())
         states, err = client.Contains(digests)
         ut.AssertEqual(t, nil, err)
         ut.AssertEqual(t, len(digests), len(states))
         for _, state := range states {
                 ut.AssertEqual(t, (*PushState)(nil), state)
         }
         ut.AssertEqual(t, nil, server.Error())
 }
 
 func testFlaky(t *testing.T, flake string) {
         server := isolatedfake.New()
         flaky := &killingMux{server: server, http503: map[string]int{flake: 10}}
         flaky.ts = httptest.NewServer(flaky)
         defer flaky.ts.Close()
         client := newIsolateServer(nil, flaky.ts.URL, "default-gzip", fastRetry)
 
         digests, contents, expected := makeItems(foo, large)
         states, err := client.Contains(digests)
         ut.AssertEqual(t, nil, err)
         ut.AssertEqual(t, len(digests), len(states))
         for _, state := range states {
-                err = client.Push(state, bytes.NewReader(contents[state.status.Index]))
+                err = client.Push(state, NewBytesSource(contents[state.status.Index]))
                 ut.AssertEqual(t, nil, err)
         }
         ut.AssertEqual(t, expected, server.Contents())
         states, err = client.Contains(digests)
         ut.AssertEqual(t, nil, err)
         ut.AssertEqual(t, len(digests), len(states))
         for _, state := range states {
                 ut.AssertEqual(t, (*PushState)(nil), state)
         }
         ut.AssertEqual(t, nil, server.Error())
@@ skipping 34 matching lines @@
                         k.ts.CloseClientConnections()
                         return false
                 }
                 return true
         }
         if f() {
                 log.Printf("%-4s %s", req.Method, req.URL.Path)
                 k.server.ServeHTTP(w, req)
         }
 }