[cipd] ignore .cipd/* while extracting.

cipd/client/cipd/local/reader_test.go

 // Copyright 2014 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 local
 
 import (
         "bytes"
         "encoding/json"
         "io"
         "io/ioutil"
         "os"
+        "strings"
         "testing"
 
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/cipd/client/cipd/common"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func normalizeJSON(s string) (string, error) {
         // Round trip through default json marshaller to normalize indentation.
@@ skipping 113 matching lines @@
                 So(err, ShouldBeNil)
         })
 
         Convey("ExtractInstance works", t, func() {
                 // Add a bunch of files to a package.
                 out := bytes.Buffer{}
                 err := BuildInstance(ctx, BuildInstanceOptions{
                         Input: []File{
                                 NewTestFile("testing/qwerty", "12345", false),
                                 NewTestFile("abc", "duh", true),
+                                NewTestFile("bad_dir/pkg/0/description.json", "{}", false),
                                 NewTestSymlink("rel_symlink", "abc"),
                                 NewTestSymlink("abs_symlink", "/abc/def"),
                         },
                         Output:           &out,
                         PackageName:      "testing",
                         VersionFile:      "subpath/version.json",
                         CompressionLevel: 5,
                 })
                 So(err, ShouldBeNil)
 
                 // Extract files.
                 inst, err := OpenInstance(ctx, bytes.NewReader(out.Bytes()), "")
                 if inst != nil {
                         defer inst.Close()
                 }
                 So(err, ShouldBeNil)
                 dest := &testDestination{}
-                err = ExtractInstance(ctx, inst, dest)
+                err = ExtractInstance(ctx, inst, dest, func(f File) bool {
+                        return strings.HasPrefix(f.Name(), "bad_dir/")
+                })
                 So(err, ShouldBeNil)
                 So(dest.beginCalls, ShouldEqual, 1)
                 So(dest.endCalls, ShouldEqual, 1)
 
                 // Verify file list, file data and flags are correct.
                 names := []string{}
                 for _, f := range dest.files {
                         names = append(names, f.name)
                 }
                 So(names, ShouldResemble, []string{
                         "testing/qwerty",
                         "abc",
                         "rel_symlink",
                         "abs_symlink",
                         "subpath/version.json",
                         ".cipdpkg/manifest.json",
                 })
                 So(string(dest.files[0].Bytes()), ShouldEqual, "12345")
                 So(dest.files[1].executable, ShouldBeTrue)
                 So(dest.files[2].symlinkTarget, ShouldEqual, "abc")
                 So(dest.files[3].symlinkTarget, ShouldEqual, "/abc/def")
 
                 // Verify version file is correct.
                 goodVersionFile := `{
-                        "instance_id": "dd08e20d0e436c5c778ccbd87c99a05182dc5558",
+                        "instance_id": "5503734d74bc46f2b4d59c23bf4b1293696861a9",
                         "package_name": "testing"
                 }`
                 So(dest.files[4].name, ShouldEqual, "subpath/version.json")
                 So(string(dest.files[4].Bytes()), shouldBeSameJSONDict, goodVersionFile)
 
                 // Verify manifest file is correct.
                 goodManifest := `{
                         "format_version": "1",
                         "package_name": "testing",
                         "version_file": "subpath/version.json",
@@ skipping 65 matching lines @@
                 symlinkTarget: target,
         }
         d.files = append(d.files, f)
         return nil
 }
 
 func (d *testDestination) End(ctx context.Context, success bool) error {
         d.endCalls++
         return nil
 }