isolate: add uploadtracker tests for symlinks and isolated files

client/cmd/isolate/upload_tracker.go

 // Copyright 2017 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 package main
 
 import (
+        "bytes"
         "encoding/json"
         "fmt"
-        "io/ioutil"
+        "io"
         "log"
         "os"
         "path/filepath"
         "strings"
 
         humanize "github.com/dustin/go-humanize"
         "github.com/luci/luci-go/common/isolated"
         "github.com/luci/luci-go/common/isolatedclient"
 )
 
+// limitedOS contains a subset of the functions from the os package.
+type limitedOS interface {
+        Readlink(string) (string, error)
+        openFiler
+}
+
+type openFiler interface {
+        // OpenFile is like os.OpenFile, but returns an io.WriteCloser since
+        // that's all we need and it's easier to implment with a fake.
+        OpenFile(string, int, os.FileMode) (io.WriteCloser, error)
+}
+
+// standardOS implements limitedOS by delegating to the standard library's os package.
+type standardOS struct{}
+
+func (sos standardOS) Readlink(name string) (string, error) {
+        return os.Readlink(name)
+}
+
+func (sos standardOS) OpenFile(name string, flag int, perm os.FileMode) (io.WriteCloser, error) {
+        return os.OpenFile(name, flag, perm)
+}
+
 // UploadTracker uploads and keeps track of files.
 type UploadTracker struct {
-        checker  *Checker
-        uploader *Uploader
+        checker  Checker
+        uploader Uploader
         isol     *isolated.Isolated
+
+        // Override for testing.
+        lOS limitedOS
 }
 
 // NewUploadTracker constructs an UploadTracker.  It tracks uploaded files in isol.Files.
-func NewUploadTracker(checker *Checker, uploader *Uploader, isol *isolated.Isolated) *UploadTracker {
+func NewUploadTracker(checker Checker, uploader Uploader, isol *isolated.Isolated) *UploadTracker {
         // TODO: share a Checker and Uploader with other UploadTrackers
         // when batch uploading.
         isol.Files = make(map[string]isolated.File)
         return &UploadTracker{
                 checker:  checker,
                 uploader: uploader,
                 isol:     isol,
+                lOS:      standardOS{},
         }
 }
 
 // UploadDeps uploads all of the items in parts.
 func (ut *UploadTracker) UploadDeps(parts partitionedDeps) error {
         if err := ut.populateSymlinks(parts.links.items); err != nil {
                 return err
         }
 
         if err := ut.tarAndUploadFiles(parts.filesToArchive.items); err != nil {
                 return err
         }
 
         if err := ut.uploadFiles(parts.indivFiles.items); err != nil {
                 return err
         }
         return nil
 }
 
 // Files returns the files which have been uploaded.
 // Note: files may not have completed uploading until the tracker's Checker and
 // Uploader have been closed.
 func (ut *UploadTracker) Files() map[string]isolated.File {
         return ut.isol.Files
 }
 
 // populateSymlinks adds an isolated.File to files for each provided symlink
 func (ut *UploadTracker) populateSymlinks(symlinks []*Item) error {
         for _, item := range symlinks {
-                l, err := os.Readlink(item.Path)
+                l, err := ut.lOS.Readlink(item.Path)
                 if err != nil {
                         return fmt.Errorf("unable to resolve symlink for %q: %v", item.Path, err)
                 }
                 ut.isol.Files[item.RelPath] = isolated.SymLink(l)
         }
         return nil
 }
 
 // tarAndUploadFiles creates bundles of files, uploads them, and adds each bundle to files.
 func (ut *UploadTracker) tarAndUploadFiles(smallFiles []*Item) error {
@@ skipping 86 matching lines @@
         if err := ut.checker.Close(); err != nil {
                 return IsolatedSummary{}, err
         }
 
         // Make sure that all the uploads have completed successfully.
         if err := ut.uploader.Close(); err != nil {
                 return IsolatedSummary{}, err
         }
 
         // Write the isolated file...
-        if err := isolFile.writeJSONFile(); err != nil {
+        if err := isolFile.writeJSONFile(ut.lOS); err != nil {
                 return IsolatedSummary{}, err
         }
 
         return IsolatedSummary{
                 Name:   isolFile.name(),
                 Digest: isolFile.item().Digest,
         }, nil
 }
 
 // isolatedFile is an isolated file which is stored in memory.
@@ skipping 20 matching lines @@
                 Digest:  isolated.HashBytes(ij.json),
                 Size:    int64(len(ij.json)),
         }
 }
 
 func (ij *isolatedFile) contents() []byte {
         return ij.json
 }
 
 // writeJSONFile writes the file contents to the filesystem.
-func (ij *isolatedFile) writeJSONFile() error {
-        return ioutil.WriteFile(ij.path, ij.json, 0644)
+func (ij *isolatedFile) writeJSONFile(opener openFiler) error {
+        f, err := opener.OpenFile(ij.path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+        if err != nil {
+                return err
+        }
+        _, err = io.Copy(f, bytes.NewBuffer(ij.json))
+        err2 := f.Close()
+        if err != nil {
+                return err
+        }
+        return err2
 }
 
 // name returns the base name of the isolated file, extension stripped.
 func (ij *isolatedFile) name() string {
         name := filepath.Base(ij.path)
         if i := strings.LastIndex(name, "."); i != -1 {
                 name = name[:i]
         }
         return name
 }