Add test to ManifestV2()

.travis.yml

@@ -1,5 +1,5 @@
 language: go
-go: 1.7.1
+go: 1.8
 sudo: false
 script: make travis
 notifications:

registry/.gitignore

@@ -0,0 +1,2 @@
+private_test.go
+testdata/registry_tests.private.json

registry/manifest_test.go

@@ -0,0 +1,68 @@
+package registry_test
+
+import (
+	"testing"
+
+	"github.com/docker/distribution"
+	"github.com/docker/distribution/manifest/schema1"
+	"github.com/docker/distribution/manifest/schema2"
+	"github.com/opencontainers/go-digest"
+)
+
+func checkManifest(t *testing.T, tc *TestCase,
+	wantDigest *string, wantMediaType string,
+	getManifest func(t *testing.T) (distribution.Manifest, error)) {
+
+	if *wantDigest == "" {
+		return
+	}
+
+	t.Run(tc.Name(), func(t *testing.T) {
+		got, err := getManifest(t)
+		if err != nil {
+			t.Error(err)
+			return
+		}
+		mediaType, payload, err := got.Payload()
+		if err != nil {
+			t.Error("Payload() error:", err)
+			return
+		}
+		d := digest.FromBytes(payload).String()
+
+		if !*_testDataUpdate {
+			// do actual testing of manifest
+			if mediaType != wantMediaType {
+				t.Errorf("MediaType = %v, want %v", mediaType, wantMediaType)
+			}
+			if d != *wantDigest {
+				t.Errorf("digest = %v, want %v", d, *wantDigest)
+			}
+			if !blobSlicesAreEqual(got.References(), tc.Blobs) {
+				t.Errorf("\nblobs:\n%v,\nwant:\n%v", got.References(), tc.Blobs)
+			}
+		} else {
+			// update TestCase to reflect the result of the tested method
+			*wantDigest = d
+			tc.Blobs = got.References()
+		}
+	})
+}
+
+func TestRegistry_Manifest(t *testing.T) {
+	for _, tc := range testCases(t) {
+		checkManifest(t, tc, &tc.ManifestV1Digest, schema1.MediaTypeSignedManifest, func(t *testing.T) (distribution.Manifest, error) {
+			return tc.Registry(t).Manifest(tc.Repository, tc.Reference)
+		})
+	}
+	updateTestData(t)
+}
+
+func TestRegistry_ManifestV2(t *testing.T) {
+	for _, tc := range testCases(t) {
+		checkManifest(t, tc, &tc.ManifestV2Digest, schema2.MediaTypeManifest, func(t *testing.T) (distribution.Manifest, error) {
+			return tc.Registry(t).ManifestV2(tc.Repository, tc.Reference)
+		})
+	}
+	updateTestData(t)
+}

registry/testdata/registry_tests.public.json

@@ -0,0 +1,22 @@
+[
+  {
+    "url": "https://registry-1.docker.io",
+    "repository": "library/alpine",
+    "reference": "3.8",
+    "expected": {
+      "manifest_v2_digest": "sha256:02892826401a9d18f0ea01f8a2f35d328ef039db4e1edcc45c630314a0457d5b",
+      "blobs": [
+        {
+          "mediaType": "application/vnd.docker.container.image.v1+json",
+          "size": 1512,
+          "digest": "sha256:196d12cf6ab19273823e700516e98eb1910b03b17840f9d5509f03858484d321"
+        },
+        {
+          "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
+          "size": 2206931,
+          "digest": "sha256:4fe2ade4980c2dda4fc95858ebb981489baec8c1e4bd282ab1c3560be8ff9bde"
+        }
+      ]
+    }
+  }
+]

registry/testing_test.go

@@ -0,0 +1,133 @@
+package registry_test
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"testing"
+
+	"github.com/docker/distribution"
+	"github.com/heroku/docker-registry-client/registry"
+)
+
+// Options stores optional parameters for constructing a new Registry
+type Options struct {
+	Username         string                `json:"username,omitempty"`
+	Password         string                `json:"password,omitempty"`
+	Insecure         bool                  `json:"insecure,omitempty"`
+	Logf             registry.LogfCallback `json:"-"`
+	DoInitialPing    bool                  `json:"do_initial_ping,omitempty"`
+	DisableBasicAuth bool                  `json:"disable_basicauth,omitempty"`
+}
+
+// Expected stores the expected results of various tests
+type Expected struct {
+	ManifestV1Digest   string                    `json:"manifest_v1_digest,omitempty"`
+	ManifestV2Digest   string                    `json:"manifest_v2_digest,omitempty"`
+	ManifestListDigest string                    `json:"manifestlist_digest,omitempty"`
+	Blobs              []distribution.Descriptor `json:"blobs,omitempty"`
+}
+
+// TestCase represents a test case normally read from a test data file.
+type TestCase struct {
+	Url        string `json:"url"`
+	Repository string `json:"repository"`
+	Reference  string `json:"reference"`
+	Writeable  bool   `json:"writeable,omitempty"`
+
+	Options
+	registry *registry.Registry
+
+	Expected `json:"expected"`
+	Origin   string `json:"-"` // name of the test data file that this TestCase was read from
+}
+
+func (tc TestCase) Name() string {
+	return fmt.Sprintf("%s/%s@%s,%v", tc.Url, tc.Repository, tc.Reference, tc.Writeable)
+}
+
+func (tc *TestCase) Registry(t *testing.T) *registry.Registry {
+	if tc.registry == nil {
+		var err error
+		tc.registry, err = registry.New(tc.Url, tc.Username, tc.Password)
+		if err != nil {
+			t.Fatal("failed to create registry client:", err)
+		}
+	}
+	return tc.registry
+}
+
+const testDataFilePattern = "testdata/registry_tests*.json"
+
+var _testDataUpdate = flag.Bool("update", false, "update testdata files")
+var _testCases []*TestCase
+
+// testCases loads all test data files and returns with the union of all testcases read
+func testCases(t *testing.T) []*TestCase {
+	if _testCases != nil {
+		return _testCases
+	}
+
+	tdFilenames, err := filepath.Glob(testDataFilePattern)
+	if err != nil {
+		t.Fatal("failed to list test data files:", testDataFilePattern)
+	}
+
+	for _, tdFilename := range tdFilenames {
+		tdFile, err := os.Open(tdFilename)
+		if err != nil {
+			t.Fatal("failed to open test data file:", tdFilename)
+		}
+
+		var tcs []*TestCase
+		err = json.NewDecoder(tdFile).Decode(&tcs)
+		if err != nil {
+			t.Fatalf("failed to load test data from %s: %s", tdFilename, err)
+		}
+		for i := range tcs {
+			tcs[i].Origin = tdFilename
+		}
+		_testCases = append(_testCases, tcs...)
+	}
+	return _testCases
+}
+
+// updateTestData writes the actual results back to the test data files
+// if the --update flag was given to the test
+func updateTestData(t *testing.T) {
+	if !*_testDataUpdate {
+		return
+	}
+
+	tdFiles := make(map[string][]*TestCase)
+	for _, tc := range testCases(t) {
+		tdFiles[tc.Origin] = append(tdFiles[tc.Origin], tc)
+	}
+	for tdFilename, tcs := range tdFiles {
+		tdFile, err := os.Create(tdFilename)
+		if err != nil {
+			t.Fatal(err)
+		}
+		enc := json.NewEncoder(tdFile)
+		enc.SetIndent("", "  ")
+		err = enc.Encode(tcs)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+// blobSlicesAreEqual checks if the two given slices are equal
+// WARNING: this will modify (i.e. sort) both a and b
+func blobSlicesAreEqual(a, b []distribution.Descriptor) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	sort.Slice(a, func(i, j int) bool { return a[i].Digest.String() < a[j].Digest.String() })
+	sort.Slice(b, func(i, j int) bool { return b[i].Digest.String() < b[j].Digest.String() })
+	return reflect.DeepEqual(a, b)
+}