cipd: Refactor client to make it more readable.

go/src/infra/tools/cipd/local/deployer_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 (
         "bytes"
         "fmt"
         "io"
         "io/ioutil"
         "os"
         "path/filepath"
         "sort"
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
+
+        . "infra/tools/cipd/common"
 )
 
 func TestUtilities(t *testing.T) {
         Convey("Given a temp directory", t, func() {
                 tempDir, err := ioutil.TempDir("", "cipd_test")
                 So(err, ShouldBeNil)
                 Reset(func() { os.RemoveAll(tempDir) })
 
                 // Wrappers that accept paths relative to tempDir.
                 touch := func(rel string) {
@@ skipping 98 matching lines @@
 func TestDeployInstance(t *testing.T) {
         Convey("Given a temp directory", t, func() {
                 tempDir, err := ioutil.TempDir("", "cipd_test")
                 So(err, ShouldBeNil)
                 Reset(func() { os.RemoveAll(tempDir) })
 
                 Convey("DeployInstance new empty package instance", func() {
                         inst := makeTestInstance("test/package", nil)
                         info, err := DeployInstance(tempDir, inst)
                         So(err, ShouldBeNil)
-                        So(info, ShouldResemble, PackageState{
-                                PackageName: "test/package",
-                                InstanceID:  inst.InstanceID(),
-                        })
+                        So(info, ShouldResemble, inst.Pin())
                         So(scanDir(tempDir), ShouldResemble, []string{
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/.cipdpkg/manifest.json",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/_current:0123456789abcdef00000123456789abcdef0000",
                         })
                 })
 
                 Convey("DeployInstance new non-empty package instance", func() {
                         inst := makeTestInstance("test/package", []File{
-                                makeTestFile("some/file/path", "data a", false),
-                                makeTestFile("some/executable", "data b", true),
-                                makeTestSymlink("some/symlink", "executable"),
+                                NewTestFile("some/file/path", "data a", false),
+                                NewTestFile("some/executable", "data b", true),
+                                NewTestSymlink("some/symlink", "executable"),
                         })
                         _, err := DeployInstance(tempDir, inst)
                         So(err, ShouldBeNil)
                         So(scanDir(tempDir), ShouldResemble, []string{
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/.cipdpkg/manifest.json",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/some/executable*",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/some/file/path",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/some/symlink:executable",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/_current:0123456789abcdef00000123456789abcdef0000",
                                 "some/executable:../.cipd/pkgs/test_package_B6R4ErK5ko/_current/some/executable",
                                 "some/file/path:../../.cipd/pkgs/test_package_B6R4ErK5ko/_current/some/file/path",
                                 "some/symlink:../.cipd/pkgs/test_package_B6R4ErK5ko/_current/some/symlink",
                         })
                         // Ensure symlinks are actually traversable.
                         body, err := ioutil.ReadFile(filepath.Join(tempDir, "some", "file", "path"))
                         So(err, ShouldBeNil)
                         So(string(body), ShouldEqual, "data a")
                         // Symlink to symlink is traversable too.
                         body, err = ioutil.ReadFile(filepath.Join(tempDir, "some", "symlink"))
                         So(err, ShouldBeNil)
                         So(string(body), ShouldEqual, "data b")
                 })
 
                 Convey("Redeploy same package instance", func() {
                         inst := makeTestInstance("test/package", []File{
-                                makeTestFile("some/file/path", "data a", false),
-                                makeTestFile("some/executable", "data b", true),
-                                makeTestSymlink("some/symlink", "executable"),
+                                NewTestFile("some/file/path", "data a", false),
+                                NewTestFile("some/executable", "data b", true),
+                                NewTestSymlink("some/symlink", "executable"),
                         })
                         _, err := DeployInstance(tempDir, inst)
                         So(err, ShouldBeNil)
                         _, err = DeployInstance(tempDir, inst)
                         So(err, ShouldBeNil)
                         So(scanDir(tempDir), ShouldResemble, []string{
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/.cipdpkg/manifest.json",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/some/executable*",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/some/file/path",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/0123456789abcdef00000123456789abcdef0000/some/symlink:executable",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/_current:0123456789abcdef00000123456789abcdef0000",
                                 "some/executable:../.cipd/pkgs/test_package_B6R4ErK5ko/_current/some/executable",
                                 "some/file/path:../../.cipd/pkgs/test_package_B6R4ErK5ko/_current/some/file/path",
                                 "some/symlink:../.cipd/pkgs/test_package_B6R4ErK5ko/_current/some/symlink",
                         })
                 })
 
                 Convey("DeployInstance package update", func() {
                         oldPkg := makeTestInstance("test/package", []File{
-                                makeTestFile("some/file/path", "data a old", false),
-                                makeTestFile("some/executable", "data b old", true),
-                                makeTestFile("old only", "data c old", true),
-                                makeTestFile("mode change 1", "data d", true),
-                                makeTestFile("mode change 2", "data e", false),
-                                makeTestSymlink("symlink unchanged", "target"),
-                                makeTestSymlink("symlink changed", "old target"),
-                                makeTestSymlink("symlink removed", "target"),
+                                NewTestFile("some/file/path", "data a old", false),
+                                NewTestFile("some/executable", "data b old", true),
+                                NewTestFile("old only", "data c old", true),
+                                NewTestFile("mode change 1", "data d", true),
+                                NewTestFile("mode change 2", "data e", false),
+                                NewTestSymlink("symlink unchanged", "target"),
+                                NewTestSymlink("symlink changed", "old target"),
+                                NewTestSymlink("symlink removed", "target"),
                         })
                         oldPkg.instanceID = "0000000000000000000000000000000000000000"
 
                         newPkg := makeTestInstance("test/package", []File{
-                                makeTestFile("some/file/path", "data a new", false),
-                                makeTestFile("some/executable", "data b new", true),
-                                makeTestFile("mode change 1", "data d", false),
-                                makeTestFile("mode change 2", "data d", true),
-                                makeTestSymlink("symlink unchanged", "target"),
-                                makeTestSymlink("symlink changed", "new target"),
+                                NewTestFile("some/file/path", "data a new", false),
+                                NewTestFile("some/executable", "data b new", true),
+                                NewTestFile("mode change 1", "data d", false),
+                                NewTestFile("mode change 2", "data d", true),
+                                NewTestSymlink("symlink unchanged", "target"),
+                                NewTestSymlink("symlink changed", "new target"),
                         })
                         newPkg.instanceID = "1111111111111111111111111111111111111111"
 
                         _, err := DeployInstance(tempDir, oldPkg)
                         So(err, ShouldBeNil)
                         _, err = DeployInstance(tempDir, newPkg)
                         So(err, ShouldBeNil)
 
                         So(scanDir(tempDir), ShouldResemble, []string{
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/1111111111111111111111111111111111111111/.cipdpkg/manifest.json",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/1111111111111111111111111111111111111111/mode change 1",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/1111111111111111111111111111111111111111/mode change 2*",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/1111111111111111111111111111111111111111/some/executable*",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/1111111111111111111111111111111111111111/some/file/path",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/1111111111111111111111111111111111111111/symlink changed:new target",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/1111111111111111111111111111111111111111/symlink unchanged:target",
                                 ".cipd/pkgs/test_package_B6R4ErK5ko/_current:1111111111111111111111111111111111111111",
                                 "mode change 1:.cipd/pkgs/test_package_B6R4ErK5ko/_current/mode change 1",
                                 "mode change 2:.cipd/pkgs/test_package_B6R4ErK5ko/_current/mode change 2",
                                 "some/executable:../.cipd/pkgs/test_package_B6R4ErK5ko/_current/some/executable",
                                 "some/file/path:../../.cipd/pkgs/test_package_B6R4ErK5ko/_current/some/file/path",
                                 "symlink changed:.cipd/pkgs/test_package_B6R4ErK5ko/_current/symlink changed",
                                 "symlink unchanged:.cipd/pkgs/test_package_B6R4ErK5ko/_current/symlink unchanged",
                         })
                 })
 
                 Convey("DeployInstance two different packages", func() {
                         pkg1 := makeTestInstance("test/package", []File{
-                                makeTestFile("some/file/path", "data a old", false),
-                                makeTestFile("some/executable", "data b old", true),
-                                makeTestFile("pkg1 file", "data c", false),
+                                NewTestFile("some/file/path", "data a old", false),
+                                NewTestFile("some/executable", "data b old", true),
+                                NewTestFile("pkg1 file", "data c", false),
                         })
                         pkg1.instanceID = "0000000000000000000000000000000000000000"
 
                         // Nesting in package names is allowed.
                         pkg2 := makeTestInstance("test/package/another", []File{
-                                makeTestFile("some/file/path", "data a new", false),
-                                makeTestFile("some/executable", "data b new", true),
-                                makeTestFile("pkg2 file", "data d", false),
+                                NewTestFile("some/file/path", "data a new", false),
+                                NewTestFile("some/executable", "data b new", true),
+                                NewTestFile("pkg2 file", "data d", false),
                         })
                         pkg2.instanceID = "1111111111111111111111111111111111111111"
 
                         _, err := DeployInstance(tempDir, pkg1)
                         So(err, ShouldBeNil)
                         _, err = DeployInstance(tempDir, pkg2)
                         So(err, ShouldBeNil)
 
                         // TODO: Conflicting symlinks point to last installed package, it is not
                         // very deterministic.
@@ skipping 48 matching lines @@
                         _, err = DeployInstance(tempDir, makeTestInstance("test/pkg/456", nil))
                         So(err, ShouldBeNil)
                         _, err = DeployInstance(tempDir, makeTestInstance("test/pkg", nil))
                         So(err, ShouldBeNil)
                         _, err = DeployInstance(tempDir, makeTestInstance("test", nil))
                         So(err, ShouldBeNil)
 
                         // Verify it is discoverable.
                         out, err := FindDeployed(tempDir)
                         So(err, ShouldBeNil)
-                        So(out, ShouldResemble, []PackageState{
-                                PackageState{
-                                        PackageName: "test",
-                                        InstanceID:  "0123456789abcdef00000123456789abcdef0000",
-                                },
-                                PackageState{
-                                        PackageName: "test/pkg",
-                                        InstanceID:  "0123456789abcdef00000123456789abcdef0000",
-                                },
-                                PackageState{
-                                        PackageName: "test/pkg/123",
-                                        InstanceID:  "0123456789abcdef00000123456789abcdef0000",
-                                },
-                                PackageState{
-                                        PackageName: "test/pkg/456",
-                                        InstanceID:  "0123456789abcdef00000123456789abcdef0000",
-                                },
+                        So(out, ShouldResemble, []Pin{
+                                {"test", "0123456789abcdef00000123456789abcdef0000"},
+                                {"test/pkg", "0123456789abcdef00000123456789abcdef0000"},
+                                {"test/pkg/123", "0123456789abcdef00000123456789abcdef0000"},
+                                {"test/pkg/456", "0123456789abcdef00000123456789abcdef0000"},
                         })
                 })
         })
 }
 
 func TestRemoveDeployed(t *testing.T) {
         Convey("Given a temp directory", t, func() {
                 tempDir, err := ioutil.TempDir("", "cipd_test")
                 So(err, ShouldBeNil)
                 Reset(func() { os.RemoveAll(tempDir) })
 
                 Convey("RemoveDeployed works with missing package", func() {
                         err := RemoveDeployed(tempDir, "package/path")
                         So(err, ShouldBeNil)
                 })
 
                 Convey("RemoveDeployed works", func() {
                         // Deploy some instance (to keep it).
                         inst := makeTestInstance("test/package/123", []File{
-                                makeTestFile("some/file/path1", "data a", false),
-                                makeTestFile("some/executable1", "data b", true),
+                                NewTestFile("some/file/path1", "data a", false),
+                                NewTestFile("some/executable1", "data b", true),
                         })
                         _, err := DeployInstance(tempDir, inst)
                         So(err, ShouldBeNil)
 
                         // Deploy another instance (to remove it).
                         inst = makeTestInstance("test/package", []File{
-                                makeTestFile("some/file/path2", "data a", false),
-                                makeTestFile("some/executable2", "data b", true),
-                                makeTestSymlink("some/symlink", "executable"),
+                                NewTestFile("some/file/path2", "data a", false),
+                                NewTestFile("some/executable2", "data b", true),
+                                NewTestSymlink("some/symlink", "executable"),
                         })
                         _, err = DeployInstance(tempDir, inst)
                         So(err, ShouldBeNil)
 
                         // Now remove the second package.
                         err = RemoveDeployed(tempDir, "test/package")
                         So(err, ShouldBeNil)
 
                         // Verify the final state (only first package should survive).
                         So(scanDir(tempDir), ShouldResemble, []string{
@@ skipping 20 matching lines @@
 func makeTestInstance(name string, files []File) *testPackageInstance {
         // Generate and append manifest file.
         out := bytes.Buffer{}
         err := writeManifest(&Manifest{
                 FormatVersion: manifestFormatVersion,
                 PackageName:   name,
         }, &out)
         if err != nil {
                 panic("Failed to write a manifest")
         }
-        files = append(files, makeTestFile(manifestName, string(out.Bytes()), false))
+        files = append(files, NewTestFile(manifestName, string(out.Bytes()), false))
         return &testPackageInstance{
                 packageName: name,
                 instanceID:  "0123456789abcdef00000123456789abcdef0000",
                 files:       files,
         }
 }
 
 func (f *testPackageInstance) Close() error              { return nil }
-func (f *testPackageInstance) PackageName() string       { return f.packageName }
-func (f *testPackageInstance) InstanceID() string        { return f.instanceID }
+func (f *testPackageInstance) Pin() Pin                  { return Pin{f.packageName, f.instanceID} }
 func (f *testPackageInstance) Files() []File             { return f.files }
 func (f *testPackageInstance) DataReader() io.ReadSeeker { panic("Not implemented") }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // scanDir returns list of files (regular and symlinks) it finds in a directory.
 // Symlinks are returned as "path:target". Regular executable files are suffixed
 // with '*'. All paths are relative to the scanned directory and slash
 // separated. Symlink targets are slash separated too, but otherwise not
 // modified. Does not look inside symlinked directories.
@@ skipping 29 matching lines @@
                 }
 
                 out = append(out, item+suffix)
                 return nil
         })
         if err != nil {
                 panic("Failed to walk a directory")
         }
         return
 }