Test Docker client Tag

Author: David Collom

pkg/client/docker/docker.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/hashicorp/go-retryablehttp"
 	"github.com/jetstack/version-checker/pkg/api"
+	"github.com/jetstack/version-checker/pkg/client/util"
 )
 
 // Ensure that we are an ImageClient
@@ -119,11 +120,18 @@ func (c *Client) Tags(ctx context.Context, _, repo, image string) ([]api.ImageTa
 			}
 
 			tag := api.ImageTag{
-				Tag:          result.Name,
-				Timestamp:    timestamp,
-				SHA:          result.Digest,
+				Tag:       result.Name,
+				Timestamp: timestamp,
 			}
 
+			// If we have a Digest, lets set it..
+			if result.Digest != "" {
+				tag.SHA = result.Digest
+			}
+
+			// Attempt to get OS/Arch, from the Tag Name
+			tag.OS, tag.Architecture = util.OSArchFromTag(result.Name)
+
 			for _, image := range result.Images {
 				// Image without digest contains no real image.
 				if len(image.Digest) == 0 {

pkg/client/docker/docker_test.go

@@ -0,0 +1,138 @@
+package docker
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/jetstack/version-checker/pkg/api"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/sirupsen/logrus"
+)
+
+type hostnameOverride struct {
+	Host string
+	RT   http.RoundTripper
+}
+
+func (r *hostnameOverride) RoundTrip(req *http.Request) (*http.Response, error) {
+	if req.Host != r.Host {
+		if testing.Verbose() {
+			fmt.Printf("Overriding URI from: %s to %s\n", req.Host, strings.TrimPrefix(r.Host, "http://"))
+		}
+		req.Host = strings.TrimPrefix(r.Host, "http://")
+		req.URL.Host = strings.TrimPrefix(r.Host, "http://")
+		req.URL.Scheme = "http"
+	}
+	// fmt.Printf("Req: %+v", req)
+	return r.RT.RoundTrip(req)
+}
+
+func TestTags(t *testing.T) {
+	log := logrus.NewEntry(logrus.New())
+	ctx := context.Background()
+
+	t.Run("successful Tags fetch", func(t *testing.T) {
+
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			require.NotEmpty(t, r.Header.Get("Authorization"))
+
+			require.Equal(t, "/v2/repositories/testrepo/testimage/tags", r.URL.Path)
+			w.WriteHeader(http.StatusOK)
+			_ = json.NewEncoder(w).Encode(TagResponse{
+				Results: []Result{
+					{
+						Name:      "v1.0.0",
+						Timestamp: time.Now().Add(-24 * time.Hour).Format(time.RFC3339Nano),
+						Digest:    "sha256:abcdef",
+						Images: []Image{
+							{Digest: "sha256:child1", OS: "linux", Architecture: "amd64"},
+						},
+					},
+					{
+						Name:      "v2.0.0",
+						Timestamp: time.Now().Add(-48 * time.Hour).Format(time.RFC3339Nano),
+						Images: []Image{
+							{Digest: "sha256:child2", OS: "linux", Architecture: "amd64"},
+						},
+					},
+				},
+			})
+		}))
+		defer server.Close()
+
+		client := &Client{
+			Client: server.Client(),
+			log:    log,
+			Options: Options{
+				Token: "testtoken",
+			},
+		}
+
+		client.Transport = &hostnameOverride{RT: server.Client().Transport, Host: server.URL}
+
+		tags, err := client.Tags(ctx, "NOT USED!", "testrepo", "testimage")
+		require.NoError(t, err)
+		require.Len(t, tags, 2)
+
+		assert.Equal(t, "v1.0.0", tags[0].Tag)
+		assert.Equal(t, "sha256:abcdef", tags[0].SHA)
+		assert.Equal(t, api.OS("linux"), tags[0].Children[0].OS)
+		assert.Equal(t, api.Architecture("amd64"), tags[0].Children[0].Architecture)
+
+		assert.Equal(t, "v2.0.0", tags[1].Tag)
+		assert.NotEmpty(t, tags[1].SHA)
+	})
+
+	t.Run("error on invalid response", func(t *testing.T) {
+
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("invalid json"))
+		}))
+		defer server.Close()
+
+		client := &Client{
+			Client: server.Client(),
+			log:    log,
+			Options: Options{
+				Token: "testtoken",
+			},
+		}
+		client.Transport = &hostnameOverride{RT: server.Client().Transport, Host: server.URL}
+
+		tags, err := client.Tags(ctx, "NOT USED!", "testrepo", "testimage")
+		assert.Nil(t, tags)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "unexpected image tags response")
+	})
+
+	t.Run("error on non-200 status code", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusNotFound)
+			_, _ = w.Write([]byte("not found"))
+		}))
+		defer server.Close()
+
+		client := &Client{
+			Client: server.Client(),
+			log:    log,
+			Options: Options{
+				Token: "testtoken",
+			},
+		}
+		client.Transport = &hostnameOverride{RT: server.Client().Transport, Host: server.URL}
+
+		tags, err := client.Tags(ctx, "NOT USED!", "testrepo", "testimage")
+		assert.Nil(t, tags)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "unexpected image")
+	})
+}

pkg/client/oci/oci.go

@@ -128,15 +128,20 @@ func (c *Client) Manifests(ctx context.Context, repo name.Repository, tags []str
 				Timestamp: ts,
 			}
 
-			// We have a suitable Image Index!
-			if manifest.MediaType == types.OCIImageIndex || manifest.MediaType == types.DockerManifestList {
+			switch manifest.MediaType {
+
+			case types.OCIImageIndex, types.DockerManifestList:
 				children := []*api.ImageTag{}
 				imgidx, err := manifest.ImageIndex()
 				if err != nil {
-					log.Errorf("getting imageindex: %s", err)
+					log.Errorf("getting ImageIndex: %s", err)
 					return
 				}
 				idxman, err := imgidx.IndexManifest()
+				if err != nil {
+					log.Errorf("getting IndexManifest: %s", err)
+					return
+				}
 				for _, img := range idxman.Manifests {
 
 					children = append(children, &api.ImageTag{
@@ -145,7 +150,8 @@ func (c *Client) Manifests(ctx context.Context, repo name.Repository, tags []str
 					})
 				}
 				baseTag.Children = children
-			} else if manifest.MediaType == types.OCIManifestSchema1 || manifest.MediaType == types.DockerManifestSchema2 {
+
+			case types.OCIManifestSchema1, types.DockerManifestSchema2:
 				img, err := manifest.Image()
 				if err != nil {
 					log.Errorf("unable to collect image from manifest: %s", err)

pkg/client/selfhosted/selfhosted.go

@@ -228,7 +228,7 @@ func (c *Client) Tags(ctx context.Context, host, repo, image string) ([]api.Imag
 		}
 
 		if len(manifestListResponse.Manifests) == 0 {
-
+			// TODO:
 		}
 
 		for _, manifest := range manifestListResponse.Manifests {