[cipd] stop doing weird ownership transfer

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"
         "hash"
@@ skipping 129 matching lines @@
                         Input:            []local.File{},
                         Output:           &out,
                         PackageName:      "testing",
                         CompressionLevel: 5,
                 })
                 So(err, ShouldBeNil)
 
                 // Open it for reading.
                 inst, err := local.OpenInstance(ctx, bytes.NewReader(out.Bytes()), "", local.VerifyHash)
                 So(err, ShouldBeNil)
-                defer inst.Close()
 
                 Convey("RegisterInstance full flow", func(c C) {
                         client := mockClient(c, "", []expectedHTTPCall{
                                 {
                                         Method: "POST",
                                         Path:   "/_ah/api/repo/v1/instance",
                                         Query: url.Values{
                                                 "instance_id":  []string{inst.Pin().InstanceID},
                                                 "package_name": []string{inst.Pin().PackageName},
                                         },
@@ skipping 319 matching lines @@
         ctx := makeTestContext()
 
         Convey("Mocking remote services", t, func(c C) {
                 tempDir, err := ioutil.TempDir("", "cipd_test")
                 So(err, ShouldBeNil)
                 defer os.RemoveAll(tempDir)
 
                 inst := buildInstanceInMemory(ctx, "testing/package", []local.File{
                         local.NewTestFile("file", "test data", false),
                 })
-                defer inst.Close()
 
                 client := mockClientForFetch(c, tempDir, []local.PackageInstance{inst})
 
                 Convey("FetchInstance (no cache)", func() {
                         reader, err := client.FetchInstance(ctx, inst.Pin())
                         So(err, ShouldBeNil)
+                        defer reader.Close() // just in case
 
                         // Backed by a temp file.
                         tmpFile := reader.(deleteOnClose)
                         _, err = os.Stat(tmpFile.Name())
                         So(err, ShouldBeNil)
 
                         fetched, err := local.OpenInstance(ctx, reader, "", local.VerifyHash)
                         So(err, ShouldBeNil)
                         So(fetched.Pin(), ShouldResemble, inst.Pin())
-                        fetched.Close() // this closes the 'reader' too
+                        tmpFile.Close()
 
                         // The temp file is gone.
                         _, err = os.Stat(tmpFile.Name())
                         So(os.IsNotExist(err), ShouldBeTrue)
                 })
 
                 Convey("FetchInstance (with cache)", func() {
                         client.CacheDir = filepath.Join(tempDir, "instance_cache")
 
                         reader, err := client.FetchInstance(ctx, inst.Pin())
                         So(err, ShouldBeNil)
+                        defer reader.Close()
 
                         // Backed by a real file.
                         cachedFile := reader.(*os.File)
                         info1, err := os.Stat(cachedFile.Name())
                         So(err, ShouldBeNil)
 
                         fetched, err := local.OpenInstance(ctx, reader, "", local.VerifyHash)
                         So(err, ShouldBeNil)
                         So(fetched.Pin(), ShouldResemble, inst.Pin())
-                        fetched.Close() // this closes the 'reader' too
 
                         // The real file is still there, in the cache.
                         _, err = os.Stat(cachedFile.Name())
                         So(err, ShouldBeNil)
 
                         // Fetch again.
                         reader, err = client.FetchInstance(ctx, inst.Pin())
                         So(err, ShouldBeNil)
 
                         // Got same exact file.
                         cachedFile = reader.(*os.File)
                         info2, err := os.Stat(cachedFile.Name())
                         So(err, ShouldBeNil)
                         So(os.SameFile(info1, info2), ShouldBeTrue)
 
                         reader.Close()
                 })
 
                 Convey("FetchInstanceTo (no cache)", func() {
                         tempFile := filepath.Join(tempDir, "pkg")
                         out, err := os.OpenFile(tempFile, os.O_WRONLY|os.O_CREATE, 0666)
                         So(err, ShouldBeNil)
                         defer out.Close()
 
                         err = client.FetchInstanceTo(ctx, inst.Pin(), out)
                         So(err, ShouldBeNil)
                         out.Close()
 
-                        fetched, err := local.OpenInstanceFile(ctx, tempFile, "", local.VerifyHash)
+                        fetched, closer, err := local.OpenInstanceFile(ctx, tempFile, "", local.VerifyHash)
                         So(err, ShouldBeNil)
+                        defer closer()
                         So(fetched.Pin(), ShouldResemble, inst.Pin())
-                        fetched.Close()
                 })
 
                 Convey("FetchInstanceTo (with cache)", func() {
                         client.CacheDir = filepath.Join(tempDir, "instance_cache")
 
                         tempFile := filepath.Join(tempDir, "pkg")
                         out, err := os.OpenFile(tempFile, os.O_WRONLY|os.O_CREATE, 0666)
                         So(err, ShouldBeNil)
                         defer out.Close()
 
                         err = client.FetchInstanceTo(ctx, inst.Pin(), out)
                         So(err, ShouldBeNil)
                         out.Close()
 
-                        fetched, err := local.OpenInstanceFile(ctx, tempFile, "", local.VerifyHash)
+                        fetched, closer, err := local.OpenInstanceFile(ctx, tempFile, "", local.VerifyHash)
                         So(err, ShouldBeNil)
+                        defer closer()
                         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())
                         So(err, ShouldBeNil)
 
                         // The file from the package should be installed.
                         data, err := ioutil.ReadFile(filepath.Join(tempDir, "file"))
                         So(err, ShouldBeNil)
@@ skipping 57 matching lines @@
                         body, err := ioutil.ReadFile(filepath.Join(tempDir, relPath.(string)))
                         if ret := ShouldBeNil(err); ret != "" {
                                 return ret
                         }
                         return ShouldEqual(string(body), data[0].(string))
                 }
 
                 Convey("EnsurePackages full flow", func(c C) {
                         // Prepare a bunch of packages.
                         a1 := buildInstanceInMemory(ctx, "pkg/a", []local.File{local.NewTestFile("file a 1", "test data", false)})
-                        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()
 
                         pil := func(insts ...local.PackageInstance) []local.PackageInstance {
                                 return insts
                         }
 
                         // Calls EnsurePackages, mocking fetch backend first. Backend will be mocked
                         // to serve only 'fetched' packages. callEnsure will ensure the state
                         // reflected by the 'state' variable.
                         state := map[string][]local.PackageInstance{}
                         callEnsure := func(fetched ...local.PackageInstance) (ActionMap, error) {
@@ skipping 345 matching lines @@
                                 w.Header().Add(k, s)
                         }
                 }
                 w.WriteHeader(exp.Status)
         }
         if exp.Reply != "" {
                 w.Write([]byte(exp.Reply))
         }
         s.index++
 }