cipd: Refactor client to make it more readable.

go/src/infra/tools/cipd/local/builder_test.go

 // Copyright 2014 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 cipd
+package local
 
 import (
         "archive/zip"
         "bytes"
         "crypto/sha1"
         "encoding/hex"
-        "fmt"
-        "io"
         "io/ioutil"
         "os"
         "runtime"
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestGoVersion(t *testing.T) {
         Convey("Make sure using pinned Go version", t, func() {
@@ skipping 32 matching lines @@
                                 mode: 0600,
                                 body: []byte(goodManifest),
                         },
                 })
         })
 
         Convey("Building package with a bunch of files", t, func() {
                 out := bytes.Buffer{}
                 err := BuildInstance(BuildInstanceOptions{
                         Input: []File{
-                                makeTestFile("testing/qwerty", "12345", false),
-                                makeTestFile("abc", "duh", true),
-                                makeTestSymlink("rel_symlink", "abc"),
-                                makeTestSymlink("abs_symlink", "/abc/def"),
+                                NewTestFile("testing/qwerty", "12345", false),
+                                NewTestFile("abc", "duh", true),
+                                NewTestSymlink("rel_symlink", "abc"),
+                                NewTestSymlink("abs_symlink", "/abc/def"),
                         },
                         Output:      &out,
                         PackageName: "testing",
                 })
                 So(err, ShouldBeNil)
 
                 // The manifest and all added files.
                 files := readZip(out.Bytes())
                 So(files, ShouldResemble, []zippedFile{
                         zippedFile{
@@ skipping 26 matching lines @@
                                 size: uint64(len(goodManifest)),
                                 mode: 0600,
                                 body: []byte(goodManifest),
                         },
                 })
         })
 
         Convey("Duplicate files fail", t, func() {
                 err := BuildInstance(BuildInstanceOptions{
                         Input: []File{
-                                makeTestFile("a", "12345", false),
-                                makeTestFile("a", "12345", false),
+                                NewTestFile("a", "12345", false),
+                                NewTestFile("a", "12345", false),
                         },
                         Output:      &bytes.Buffer{},
                         PackageName: "testing",
                 })
                 So(err, ShouldNotBeNil)
         })
 
         Convey("Writing to service dir fails", t, func() {
                 err := BuildInstance(BuildInstanceOptions{
                         Input: []File{
-                                makeTestFile(".cipdpkg/stuff", "12345", false),
+                                NewTestFile(".cipdpkg/stuff", "12345", false),
                         },
                         Output:      &bytes.Buffer{},
                         PackageName: "testing",
                 })
                 So(err, ShouldNotBeNil)
         })
 
         Convey("Bad name fails", t, func() {
                 err := BuildInstance(BuildInstanceOptions{
                         Output:      &bytes.Buffer{},
@@ skipping 40 matching lines @@
                 }
                 files[i] = zippedFile{
                         name: zf.Name,
                         size: zf.FileHeader.UncompressedSize64,
                         mode: zf.Mode(),
                         body: body,
                 }
         }
         return files
 }
-
-////////////////////////////////////////////////////////////////////////////////
-
-type testFile struct {
-        name          string
-        data          string
-        executable    bool
-        symlinkTarget string
-}
-
-func (f *testFile) Name() string     { return f.name }
-func (f *testFile) Size() uint64     { return uint64(len(f.data)) }
-func (f *testFile) Executable() bool { return f.executable }
-func (f *testFile) Symlink() bool    { return f.symlinkTarget != "" }
-
-func (f *testFile) SymlinkTarget() (string, error) {
-        if f.symlinkTarget == "" {
-                return "", fmt.Errorf("Not a symlink: %s", f.Name())
-        }
-        return f.symlinkTarget, nil
-}
-
-func (f *testFile) Open() (io.ReadCloser, error) {
-        if f.Symlink() {
-                return nil, fmt.Errorf("Can't open symlink: %s", f.Name())
-        }
-        r := bytes.NewReader([]byte(f.data))
-        return ioutil.NopCloser(r), nil
-}
-
-func makeTestFile(name string, data string, executable bool) File {
-        return &testFile{
-                name:       name,
-                data:       data,
-                executable: executable,
-        }
-}
-
-func makeTestSymlink(name string, target string) File {
-        return &testFile{
-                name:          name,
-                symlinkTarget: target,
-        }
-}