Reuse blacklisting code in exp_archive.

client/cmd/isolate/exp_archive_test.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 (
         "errors"
         "os"
         "reflect"
         "testing"
+
+        "github.com/luci/luci-go/client/internal/common"
 )
 
 // basicFileInfo implements some of os.FileInfo, and panics if unexpected parts
 // of that interface are called.
 type basicFileInfo struct {
         size  int64
         mode  os.FileMode
         isDir bool
 
         os.FileInfo
@@ skipping 36 matching lines @@
                 bfi: basicFileInfo{
                         size:  0,
                         mode:  os.ModeDir,
                         isDir: true,
                 },
         }
 }
 
 var errBang = errors.New("bang")
 
+// fsView constructs a FilesystemView with no blacklist.
+func fsView(root string) common.FilesystemView {
+        fsView, err := common.NewFilesystemView("/rootDir", nil)
+        if err != nil {
+                // NewFilesystemView only fails due to bad blacklists. So this should never occur.
+                panic("unexpected failure to construct FilesytemView")
+        }
+        return fsView
+}
+
 func TestWalkFn(t *testing.T) {
         type testCase struct {
                 name      string
                 files     []file
                 walkFnErr error
                 want      partitionedDeps
         }
 
         testCases := []testCase{
                 {
@@ skipping 145 matching lines @@
                                                 },
                                         },
                                         totalSize: 1024 + 2048,
                                 },
                         },
                 },
         }
 
 TestCases:
         for _, tc := range testCases {
-                pw := partitioningWalker{rootDir: "/rootDir"}
+                pw := partitioningWalker{fsView: fsView("/rootDir")}
                 for _, f := range tc.files {
                         if err := pw.walkFn(f.path, f.bfi, tc.walkFnErr); err != nil {
                                 t.Errorf("partitioning deps(%s): walkFn got err %v; want nil", tc.name, err)
                                 continue TestCases
                         }
                 }
                 if got, want := pw.parts, tc.want; !reflect.DeepEqual(got, want) {
                         t.Errorf("partitioning deps(%s): got %#v; want %#v", tc.name, got, want)
                 }
         }
 
 }
 
 func TestWalkFn_BadRelpath(t *testing.T) {
-        pw := partitioningWalker{rootDir: "/rootDir"}
+        pw := partitioningWalker{fsView: fsView("/rootDir")}
         f := regularFile("./patha", 1)
         if err := pw.walkFn(f.path, f.bfi, nil); err == nil {
                 t.Errorf("testing bad relpath: walkFn returned nil err; want non-nil err")
         }
 }
 
 func TestWalkFn_ReturnsErrorsUnchanged(t *testing.T) {
-        pw := partitioningWalker{rootDir: "/rootDir"}
+        pw := partitioningWalker{fsView: fsView("/rootDir")}
         f := regularFile("/rootDir/patha", 1)
         if err := pw.walkFn(f.path, f.bfi, errBang); err != errBang {
                 t.Errorf("walkFn err: got: %v; want %v", err, errBang)
         }
 }
 
 func TestWalkFn_DoesNothingForDirectories(t *testing.T) {
-        pw := partitioningWalker{rootDir: "/rootDir"}
+        pw := partitioningWalker{fsView: fsView("/rootDir")}
         f := directory("/rootDir/patha")
         if err := pw.walkFn(f.path, f.bfi, nil); err != nil {
                 t.Errorf("walkFn err: got: %v; want nil", err)
         }
 }