Simplify image tag command

Author: chruffins

pkg/cmd/imagecmd_test.go

@@ -96,15 +96,15 @@ func TestTagCommandPostsEscapedSourceAndTarget(t *testing.T) {
 	assert.Contains(t, string(output), "docker.io/library/myapp:latest")
 }
 
-func TestTagCommandFallsBackToDockerWhenHypemanMisses(t *testing.T) {
+func TestTagCommandPropagatesNotFound(t *testing.T) {
 	server := httptest.NewServer(http.NotFoundHandler())
 	defer server.Close()
 
 	err := Command.Run(context.Background(), []string{
 		"hypeman", "--base-url", server.URL,
-		"tag", "not a valid image", "myapp:latest",
+		"tag", "alpine:missing", "myapp:latest",
 	})
-	require.ErrorContains(t, err, "was not found in Hypeman; stage it from Docker")
+	require.ErrorContains(t, err, "404")
 }
 
 func TestTagCommandPropagatesNotReady(t *testing.T) {

pkg/cmd/pushcmd.go

@@ -105,7 +105,6 @@ func handleRemotePushTarget(ctx context.Context, cmd *cli.Command, target string
 		return fmt.Errorf("get cached image %s: %w", target, err)
 	}
 
-	// If Hypeman does not have the image, preserve the Docker-daemon fallback.
 	if _, err := stageDockerImage(ctx, cmd, &client, target, target); err != nil {
 		return fmt.Errorf("image %q was not found in Hypeman; stage it from Docker: %w", target, err)
 	}

pkg/cmd/tag.go

@@ -13,16 +13,11 @@ import (
 )
 
 var tagCmd = cli.Command{
-	Name:            "tag",
-	Usage:           "Create a local image tag",
-	ArgsUsage:       "<source> <target>",
-	Description:     "Create a local image tag in Hypeman without pulling or converting the image.",
-	Action:          handleTag,
-	HideHelpCommand: true,
-}
-
-type tagImageRequest struct {
-	Target string `json:"target"`
+	Name:        "tag",
+	Usage:       "Create a local image tag",
+	ArgsUsage:   "<source> <target>",
+	Description: "Create a local image tag in Hypeman without pulling or converting the image.",
+	Action:      handleTag,
 }
 
 func handleTag(ctx context.Context, cmd *cli.Command) error {
@@ -33,30 +28,32 @@ func handleTag(ctx context.Context, cmd *cli.Command) error {
 
 	source, target := args[0], args[1]
 	client := hypeman.NewClient(getDefaultRequestOptions(cmd)...)
+	res, err := tagImage(ctx, cmd, &client, source, target)
+	if err != nil {
+		return err
+	}
+
+	return printTagResult(cmd, target, res)
+}
 
-	var opts []option.RequestOption
+func tagImage(ctx context.Context, cmd *cli.Command, client *hypeman.Client, source, target string) ([]byte, error) {
+	var res []byte
+	opts := []option.RequestOption{option.WithResponseBodyInto(&res)}
 	if cmd.Root().Bool("debug") {
 		opts = append(opts, debugMiddlewareOption)
 	}
 
-	var res []byte
-	opts = append(opts, option.WithResponseBodyInto(&res))
 	path := "/images/" + url.PathEscape(source) + "/tag"
-	if err := client.Post(ctx, path, tagImageRequest{Target: target}, nil, opts...); err != nil {
-		if !isNotFoundError(err) {
-			return err
-		}
-
-		// Keep the Docker fallback for sources that have not been imported into
-		// Hypeman yet. Once staged, the image is available under the requested
-		// target and can be pushed through the normal cached-image flow.
-		staged, stageErr := stageDockerImage(ctx, cmd, &client, source, target)
-		if stageErr != nil {
-			return fmt.Errorf("image %q was not found in Hypeman; stage it from Docker: %w", source, stageErr)
-		}
-		res = []byte(staged.RawJSON())
+	body := struct {
+		Target string `json:"target"`
+	}{Target: target}
+	if err := client.Post(ctx, path, body, nil, opts...); err != nil {
+		return nil, err
 	}
+	return res, nil
+}
 
+func printTagResult(cmd *cli.Command, target string, res []byte) error {
 	format := cmd.Root().String("format")
 	transform := cmd.Root().String("transform")
 	result := gjson.ParseBytes(res)