[cipd] update internal function signatures in preparation for subdir.

cipd/client/cipd/client_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 cipd
 
 import (
         "bytes"
         "fmt"
         "io"
@@ skipping 560 matching lines @@
                         out.Close()
 
                         fetched, err := local.OpenInstanceFile(ctx, tempFile, "")
                         So(err, ShouldBeNil)
                         So(fetched.Pin(), ShouldResemble, inst.Pin())
                         fetched.Close()
                 })
 
                 Convey("FetchAndDeployInstance works", func() {
                         // Install the package, fetching it from the fake server.
-                        err := client.FetchAndDeployInstance(ctx, inst.Pin())
+                        err := client.FetchAndDeployInstance(ctx, "", inst.Pin())
                         So(err, ShouldBeNil)
 
                         // The file from the package should be installed.
                         data, err := ioutil.ReadFile(filepath.Join(tempDir, "file"))
                         So(err, ShouldBeNil)
                         So(data, ShouldResemble, []byte("test data"))
                 })
         })
 }
 
@@ skipping 60 matching lines @@
                         defer a1.Close()
                         a2 := buildInstanceInMemory(ctx, "pkg/a", []local.File{local.NewTestFile("file a 2", "test data", false)})
                         defer a2.Close()
                         b := buildInstanceInMemory(ctx, "pkg/b", []local.File{local.NewTestFile("file b", "test data", false)})
                         defer b.Close()
 
                         // Calls EnsurePackages, mocking fetch backend first. Backend will be mocked
                         // to serve only 'fetched' packages.
                         callEnsure := func(instances []local.PackageInstance, fetched []local.PackageInstance) (Actions, error) {
                                 client := mockClientForFetch(c, tempDir, fetched)
-                                pins := PinSlice{}
+                                pins := PinSliceBySubdir{}
                                 for _, i := range instances {
-                                        pins = append(pins, i.Pin())
+                                        pins[""] = append(pins[""], i.Pin())
                                 }
                                 return client.EnsurePackages(ctx, pins, false)
                         }
 
-                        findDeployed := func(root string) PinSlice {
+                        findDeployed := func(root string) PinSliceBySubdir {
                                 deployer := local.NewDeployer(root)
                                 pins, err := deployer.FindDeployed(ctx)
                                 So(err, ShouldBeNil)
                                 return pins
                         }
 
                         // Noop run on top of empty directory.
                         actions, err := callEnsure(nil, nil)
                         So(err, ShouldBeNil)
                         So(actions, ShouldResemble, Actions{})
 
                         // Specify same package twice. Fails.
                         actions, err = callEnsure([]local.PackageInstance{a1, a2}, nil)
                         So(err, ShouldNotBeNil)
                         So(actions, ShouldResemble, Actions{})
 
                         // Install a1 into a site root.
                         actions, err = callEnsure([]local.PackageInstance{a1}, []local.PackageInstance{a1})
                         So(err, ShouldBeNil)
                         So(actions, ShouldResemble, Actions{
                                 ToInstall: PinSlice{a1.Pin()},
                         })
                         assertFile("file a 1", "test data")
-                        So(findDeployed(tempDir), ShouldResemble, PinSlice{a1.Pin()})
+                        So(findDeployed(tempDir), ShouldResemble, PinSliceBySubdir{"": PinSlice{a1.Pin()}})
 
                         // Noop run. Nothing is fetched.
                         actions, err = callEnsure([]local.PackageInstance{a1}, nil)
                         So(err, ShouldBeNil)
                         So(actions, ShouldResemble, Actions{})
                         assertFile("file a 1", "test data")
-                        So(findDeployed(tempDir), ShouldResemble, PinSlice{a1.Pin()})
+                        So(findDeployed(tempDir), ShouldResemble, PinSliceBySubdir{"": PinSlice{a1.Pin()}})
 
                         // Upgrade a1 to a2.
                         actions, err = callEnsure([]local.PackageInstance{a2}, []local.PackageInstance{a2})
                         So(err, ShouldBeNil)
                         So(actions, ShouldResemble, Actions{
                                 ToUpdate: []UpdatedPin{
                                         {
                                                 From: a1.Pin(),
                                                 To:   a2.Pin(),
                                         },
                                 },
                         })
                         assertFile("file a 2", "test data")
-                        So(findDeployed(tempDir), ShouldResemble, PinSlice{a2.Pin()})
+                        So(findDeployed(tempDir), ShouldResemble, PinSliceBySubdir{"": PinSlice{a2.Pin()}})
 
                         // Remove a2 and install b.
                         actions, err = callEnsure([]local.PackageInstance{b}, []local.PackageInstance{b})
                         So(err, ShouldBeNil)
                         So(actions, ShouldResemble, Actions{
                                 ToInstall: PinSlice{b.Pin()},
                                 ToRemove:  PinSlice{a2.Pin()},
                         })
                         assertFile("file b", "test data")
-                        So(findDeployed(tempDir), ShouldResemble, PinSlice{b.Pin()})
+                        So(findDeployed(tempDir), ShouldResemble, PinSliceBySubdir{"": PinSlice{b.Pin()}})
 
                         // Remove b.
                         actions, err = callEnsure(nil, nil)
                         So(err, ShouldBeNil)
                         So(actions, ShouldResemble, Actions{
                                 ToRemove: PinSlice{b.Pin()},
                         })
-                        So(findDeployed(tempDir), ShouldResemble, PinSlice{})
+                        So(findDeployed(tempDir), ShouldResemble, PinSliceBySubdir{"": PinSlice{}})
 
                         // Install a1 and b.
                         actions, err = callEnsure([]local.PackageInstance{a1, b}, []local.PackageInstance{a1, b})
                         So(err, ShouldBeNil)
                         So(actions, ShouldResemble, Actions{
                                 ToInstall: PinSlice{a1.Pin(), b.Pin()},
                         })
                         assertFile("file a 1", "test data")
                         assertFile("file b", "test data")
-                        So(findDeployed(tempDir), ShouldResemble, PinSlice{a1.Pin(), b.Pin()})
+                        So(findDeployed(tempDir), ShouldResemble, PinSliceBySubdir{"": PinSlice{a1.Pin(), b.Pin()}})
                 })
         })
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // buildInstanceInMemory makes fully functional PackageInstance object that uses
 // memory buffer as a backing store.
 func buildInstanceInMemory(ctx context.Context, pkgName string, files []local.File) local.PackageInstance {
         out := bytes.Buffer{}
@@ skipping 181 matching lines @@
                                 w.Header().Add(k, s)
                         }
                 }
                 w.WriteHeader(exp.Status)
         }
         if exp.Reply != "" {
                 w.Write([]byte(exp.Reply))
         }
         s.index++
 }