Sever isolate package's dependency on client/internal.

client/isolate/isolate_test.go

 // Copyright 2015 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 isolate
 
 import (
         "encoding/json"
         "io/ioutil"
         "log"
         "net/http/httptest"
         "os"
         "path/filepath"
         "strings"
         "testing"
 
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/client/archiver"
-        "github.com/luci/luci-go/client/internal/common"
         isolateservice "github.com/luci/luci-go/common/api/isolate/isolateservice/v1"
         "github.com/luci/luci-go/common/data/text/units"
+        "github.com/luci/luci-go/common/flag/stringlistflag"
         "github.com/luci/luci-go/common/isolated"
         "github.com/luci/luci-go/common/isolatedclient"
         "github.com/luci/luci-go/common/isolatedclient/isolatedfake"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func init() {
         log.SetOutput(ioutil.Discard)
 }
@@ skipping 71 matching lines @@
                         }],
                         ['OS=="win"', {
                                 'variables': {
                                         'command': ['win'],
                                 },
                         }],
                 ],
         }`
                 isolatePath := filepath.Join(fooDir, "baz.isolate")
                 So(ioutil.WriteFile(isolatePath, []byte(isolate), 0600), ShouldBeNil)
-                if !common.IsWindows() {
+                if !IsWindows() {
                         So(os.Symlink(filepath.Join("base", "bar"), filepath.Join(tmpDir, "link")), ShouldBeNil)
                 } else {
                         So(ioutil.WriteFile(filepath.Join(tmpDir, "link"), []byte("no link on Windows"), 0600), ShouldBeNil)
                 }
                 opts := &ArchiveOptions{
                         Isolate:         isolatePath,
                         Isolated:        filepath.Join(tmpDir, "baz.isolated"),
-                        Blacklist:       common.Strings{"ignored", "*.isolate"},
+                        Blacklist:       stringlistflag.Flag{"ignored", "*.isolate"},
                         PathVariables:   map[string]string{"VAR": "wonderful"},
                         ExtraVariables:  map[string]string{"EXTRA": "really"},
                         ConfigVariables: map[string]string{"OS": "amiga"},
                 }
                 item := Archive(a, opts)
                 So(item.DisplayName, ShouldResemble, "baz.isolated")
                 item.WaitForHashed()
                 So(item.Error(), ShouldBeNil)
                 So(a.Close(), ShouldBeNil)
 
                 mode := 0600
-                if common.IsWindows() {
+                if IsWindows() {
                         mode = 0666
                 }
 
                 //   /base/
                 baseIsolatedData := isolated.Isolated{
                         Algo: "sha-1",
                         Files: map[string]isolated.File{
                                 filepath.Join("base", "bar"): isolated.BasicFile("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", mode, 3),
                         },
                         Version: isolated.IsolatedFormatVersion,
@@ skipping 18 matching lines @@
 
                 isolatedData := isolated.Isolated{
                         Algo:    "sha-1",
                         Command: []string{"amiga", "really"},
                         Files:   map[string]isolated.File{},
                         // This list must be in deterministic order.
                         Includes:    isolated.HexDigests{baseIsolatedHash, secondIsolatedHash},
                         RelativeCwd: "foo",
                         Version:     isolated.IsolatedFormatVersion,
                 }
-                if !common.IsWindows() {
+                if !IsWindows() {
                         isolatedData.Files["link"] = isolated.SymLink(filepath.Join("base", "bar"))
                 } else {
                         isolatedData.Files["link"] = isolated.BasicFile("12339b9756c2994f85c310d560bc8c142a6b79a1", 0666, 18)
                 }
                 encoded, err = json.Marshal(isolatedData)
                 So(err, ShouldBeNil)
                 isolatedEncoded := string(encoded) + "\n"
                 isolatedHash := isolated.HashBytes([]byte(isolatedEncoded))
 
                 expected := map[string]string{
                         "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33": "foo",
                         "aaadd94977b8fbf3f6fb09fc3bbbc9edbdfa8427": "foo2",
                         string(baseIsolatedHash):                   baseIsolatedEncoded,
                         string(isolatedHash):                       isolatedEncoded,
                         string(secondIsolatedHash):                 secondIsolatedEncoded,
                 }
-                if common.IsWindows() {
+                if IsWindows() {
                         expected["12339b9756c2994f85c310d560bc8c142a6b79a1"] = "no link on Windows"
                 }
                 actual := map[string]string{}
                 for k, v := range server.Contents() {
                         actual[string(k)] = string(v)
                         So(actual[string(k)], ShouldResemble, expected[string(k)])
                 }
                 So(actual, ShouldResemble, expected)
                 So(item.Digest(), ShouldResemble, isolatedHash)
 
                 stats := a.Stats()
                 So(stats.TotalHits(), ShouldBeZeroValue)
                 So(stats.TotalBytesHits(), ShouldResemble, units.Size(0))
                 size := 3 + 4 + len(baseIsolatedEncoded) + len(isolatedEncoded) + len(secondIsolatedEncoded)
-                if !common.IsWindows() {
+                if !IsWindows() {
                         So(stats.TotalMisses(), ShouldEqual, 5)
                         So(stats.TotalBytesPushed(), ShouldResemble, units.Size(size))
                 } else {
                         So(stats.TotalMisses(), ShouldEqual, 6)
                         // Includes the duplicate due to lack of symlink.
                         So(stats.TotalBytesPushed(), ShouldResemble, units.Size(size+18))
                 }
 
                 So(server.Error(), ShouldBeNil)
                 digest, err := isolated.HashFile(filepath.Join(tmpDir, "baz.isolated"))
@@ skipping 15 matching lines @@
                 }
                 item := Archive(a, opts)
                 item.WaitForHashed()
                 err := item.Error()
                 So(strings.HasPrefix(err.Error(), "open /this-file-does-not-exist: "), ShouldBeTrue)
                 closeErr := a.Close()
                 So(closeErr, ShouldNotBeNil)
                 So(strings.HasPrefix(closeErr.Error(), "open /this-file-does-not-exist: "), ShouldBeTrue)
         })
 }