cipd: Client can resolve tags to instance IDs.

go/src/infra/tools/cipd/client_test.go

 // Copyright 2015 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
 
 import (
         "bytes"
         "fmt"
         "io"
@@ skipping 52 matching lines @@
                                 Reply:  `{"status":"VERIFYING"}`,
                         })
                 }
                 client := mockClient(c, calls)
                 client.storage = &mockedStorage{c, nil}
                 err := client.UploadToCAS("abc", nil, nil)
                 So(err, ShouldEqual, ErrFinalizationTimeout)
         })
 }
 
+func TestResolveVersion(t *testing.T) {
+        Convey("ResolveVersion works", t, func(c C) {
+                client := mockClient(c, []expectedHTTPCall{
+                        {
+                                Method: "GET",
+                                Path:   "/_ah/api/repo/v1/instance/resolve",
+                                Query: url.Values{
+                                        "package_name": []string{"pkgname"},
+                                        "version":      []string{"tag_key:value"},
+                                },
+                                Reply: `{
+                                        "status": "SUCCESS",
+                                        "instance_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                                }`,
+                        },
+                })
+                pin, err := client.ResolveVersion("pkgname", "tag_key:value")
+                So(err, ShouldBeNil)
+                So(pin, ShouldResemble, common.Pin{
+                        PackageName: "pkgname",
+                        InstanceID:  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                })
+        })
+
+        Convey("ResolveVersion with instance ID", t, func(c C) {
+                // No calls to the backend expected.
+                client := mockClient(c, nil)
+                pin, err := client.ResolveVersion("pkgname", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+                So(err, ShouldBeNil)
+                So(pin, ShouldResemble, common.Pin{
+                        PackageName: "pkgname",
+                        InstanceID:  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                })
+        })
+
+        Convey("ResolveVersion bad package name", t, func(c C) {
+                client := mockClient(c, nil)
+                _, err := client.ResolveVersion("bad package", "tag_key:value")
+                So(err, ShouldNotBeNil)
+        })
+
+        Convey("ResolveVersion bad version", t, func(c C) {
+                client := mockClient(c, nil)
+                _, err := client.ResolveVersion("pkgname", "BAD_TAG:")
+                So(err, ShouldNotBeNil)
+        })
+}
+
 func TestRegisterInstance(t *testing.T) {
         Convey("Mocking a package instance", t, func() {
                 // Build an empty package to be uploaded.
                 out := bytes.Buffer{}
                 err := local.BuildInstance(local.BuildInstanceOptions{
                         Input:       []local.File{},
                         Output:      &out,
                         PackageName: "testing",
                 })
                 So(err, ShouldBeNil)
@@ skipping 170 matching lines @@
 
                         // 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"))
                 })
         })
 }
 
 func TestProcessEnsureFile(t *testing.T) {
-        call := func(c C, data string) ([]common.Pin, error) {
-                client := mockClient(c, nil)
+        call := func(c C, data string, calls []expectedHTTPCall) ([]common.Pin, error) {
+                client := mockClient(c, calls)
                 return client.ProcessEnsureFile(bytes.NewBufferString(data))
         }
 
         Convey("ProcessEnsureFile works", t, func(c C) {
                 out, err := call(c, `
                         # Comment
 
                         pkg/a  0000000000000000000000000000000000000000
                         pkg/b  1000000000000000000000000000000000000000
-                `)
+                `, nil)
                 So(err, ShouldBeNil)
                 So(out, ShouldResemble, []common.Pin{
                         {"pkg/a", "0000000000000000000000000000000000000000"},
                         {"pkg/b", "1000000000000000000000000000000000000000"},
                 })
         })
 
+        Convey("ProcessEnsureFile resolves versions", t, func(c C) {
+                out, err := call(c, "pkg/a tag_key:value", []expectedHTTPCall{
+                        {
+                                Method: "GET",
+                                Path:   "/_ah/api/repo/v1/instance/resolve",
+                                Query: url.Values{
+                                        "package_name": []string{"pkg/a"},
+                                        "version":      []string{"tag_key:value"},
+                                },
+                                Reply: `{"status":"SUCCESS","instance_id":"0000000000000000000000000000000000000000"}`,
+                        },
+                })
+                So(err, ShouldBeNil)
+                So(out, ShouldResemble, []common.Pin{
+                        {"pkg/a", "0000000000000000000000000000000000000000"},
+                })
+        })
+
         Convey("ProcessEnsureFile empty", t, func(c C) {
-                out, err := call(c, "")
+                out, err := call(c, "", nil)
                 So(err, ShouldBeNil)
                 So(out, ShouldResemble, []common.Pin{})
         })
 
         Convey("ProcessEnsureFile bad package name", t, func(c C) {
-                _, err := call(c, "bad.package.name/a  0000000000000000000000000000000000000000")
+                _, err := call(c, "bad.package.name/a 0000000000000000000000000000000000000000", nil)
                 So(err, ShouldNotBeNil)
         })
 
         Convey("ProcessEnsureFile bad instance ID", t, func(c C) {
-                _, err := call(c, "pkg/a  0000")
+                _, err := call(c, "pkg/a 0000", nil)
                 So(err, ShouldNotBeNil)
         })
 
         Convey("ProcessEnsureFile bad line", t, func(c C) {
-                _, err := call(c, "pkg/a")
+                _, err := call(c, "pkg/a", nil)
                 So(err, ShouldNotBeNil)
         })
 }
 
 func TestEnsurePackages(t *testing.T) {
         Convey("Mocking temp dir", t, func() {
                 tempDir, err := ioutil.TempDir("", "cipd_test")
                 So(err, ShouldBeNil)
                 Reset(func() { os.RemoveAll(tempDir) })
 
@@ skipping 275 matching lines @@
                                 w.Header().Add(k, s)
                         }
                 }
                 w.WriteHeader(exp.Status)
         }
         if exp.Reply != "" {
                 w.Write([]byte(exp.Reply))
         }
         s.index++
 }