github.com/containers/podman/v2@v2.2.2-0.20210501105131-c1e07d070c4c/libpod/image/parts_test.go (about)

     1  package image
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/require"
     8  )
     9  
    10  func TestDecompose(t *testing.T) {
    11  	const digestSuffix = "@sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
    12  
    13  	for _, c := range []struct {
    14  		input                                       string
    15  		registry, name, suspiciousTagValueForSearch string
    16  		hasRegistry                                 bool
    17  	}{
    18  		{"#", "", "", "", false}, // Entirely invalid input
    19  		{ // Fully qualified docker.io, name-only input
    20  			"docker.io/library/busybox", "docker.io", "library/busybox", "latest", true,
    21  		},
    22  		{ // Fully qualified example.com, name-only input
    23  			"example.com/ns/busybox", "example.com", "ns/busybox", "latest", true,
    24  		},
    25  		{ // Unqualified single-name input
    26  			"busybox", "", "busybox", "latest", false,
    27  		},
    28  		{ // Unqualified namespaced input
    29  			"ns/busybox", "", "ns/busybox", "latest", false,
    30  		},
    31  		{ // name:tag
    32  			"example.com/ns/busybox:notlatest", "example.com", "ns/busybox", "notlatest", true,
    33  		},
    34  		{ // name@digest
    35  			// FIXME? .suspiciousTagValueForSearch == "none"
    36  			"example.com/ns/busybox" + digestSuffix, "example.com", "ns/busybox", "none", true,
    37  		},
    38  		{ // name:tag@digest
    39  			"example.com/ns/busybox:notlatest" + digestSuffix, "example.com", "ns/busybox", "notlatest", true,
    40  		},
    41  	} {
    42  		parts, err := decompose(c.input)
    43  		if c.name == "" {
    44  			assert.Error(t, err, c.input)
    45  		} else {
    46  			assert.NoError(t, err, c.input)
    47  			registry, name, suspiciousTagValueForSearch := parts.suspiciousRefNameTagValuesForSearch()
    48  			assert.Equal(t, c.registry, registry, c.input)
    49  			assert.Equal(t, c.name, name, c.input)
    50  			assert.Equal(t, c.suspiciousTagValueForSearch, suspiciousTagValueForSearch, c.input)
    51  			assert.Equal(t, c.hasRegistry, parts.hasRegistry, c.input)
    52  		}
    53  	}
    54  }
    55  
    56  func TestImagePartsReferenceWithRegistry(t *testing.T) {
    57  	const digestSuffix = "@sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
    58  
    59  	for _, c := range []struct {
    60  		input                     string
    61  		withDocker, withNonDocker string
    62  	}{
    63  		{"example.com/ns/busybox", "", ""},                                                                            // Fully-qualified input is invalid.
    64  		{"busybox", "docker.io/library/busybox", "example.com/busybox"},                                               // Single-name input
    65  		{"ns/busybox", "docker.io/ns/busybox", "example.com/ns/busybox"},                                              // Namespaced input
    66  		{"ns/busybox:notlatest", "docker.io/ns/busybox:notlatest", "example.com/ns/busybox:notlatest"},                // name:tag
    67  		{"ns/busybox" + digestSuffix, "docker.io/ns/busybox" + digestSuffix, "example.com/ns/busybox" + digestSuffix}, // name@digest
    68  		{ // name:tag@digest
    69  			"ns/busybox:notlatest" + digestSuffix,
    70  			"docker.io/ns/busybox:notlatest" + digestSuffix, "example.com/ns/busybox:notlatest" + digestSuffix,
    71  		},
    72  	} {
    73  		parts, err := decompose(c.input)
    74  		require.NoError(t, err)
    75  		if c.withDocker == "" {
    76  			_, err := parts.referenceWithRegistry("docker.io")
    77  			assert.Error(t, err, c.input)
    78  			_, err = parts.referenceWithRegistry("example.com")
    79  			assert.Error(t, err, c.input)
    80  		} else {
    81  			ref, err := parts.referenceWithRegistry("docker.io")
    82  			require.NoError(t, err, c.input)
    83  			assert.Equal(t, c.withDocker, ref.String())
    84  			ref, err = parts.referenceWithRegistry("example.com")
    85  			require.NoError(t, err, c.input)
    86  			assert.Equal(t, c.withNonDocker, ref.String())
    87  		}
    88  	}
    89  
    90  	// Invalid registry value
    91  	parts, err := decompose("busybox")
    92  	require.NoError(t, err)
    93  	_, err = parts.referenceWithRegistry("invalid@domain")
    94  	assert.Error(t, err)
    95  }
    96  
    97  func TestImagePartsNormalizedReference(t *testing.T) {
    98  	const digestSuffix = "@sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
    99  
   100  	for _, c := range []struct{ input, expected string }{
   101  		{"busybox", ""}, // Unqualified input is invalid
   102  		{"docker.io/busybox", "docker.io/library/busybox"},                                 // docker.io single-name
   103  		{"example.com/busybox", "example.com/busybox"},                                     // example.com single-name
   104  		{"docker.io/ns/busybox", "docker.io/ns/busybox"},                                   // docker.io namespaced
   105  		{"example.com/ns/busybox", "example.com/ns/busybox"},                               // example.com namespaced
   106  		{"example.com/ns/busybox:notlatest", "example.com/ns/busybox:notlatest"},           // name:tag
   107  		{"example.com/ns/busybox" + digestSuffix, "example.com/ns/busybox" + digestSuffix}, // name@digest
   108  		{ // name:tag@digest
   109  			"example.com/ns/busybox:notlatest" + digestSuffix, "example.com/ns/busybox:notlatest" + digestSuffix,
   110  		},
   111  	} {
   112  		parts, err := decompose(c.input)
   113  		require.NoError(t, err)
   114  		if c.expected == "" {
   115  			_, err := parts.normalizedReference()
   116  			assert.Error(t, err, c.input)
   117  		} else {
   118  			ref, err := parts.normalizedReference()
   119  			require.NoError(t, err, c.input)
   120  			assert.Equal(t, c.expected, ref.String())
   121  		}
   122  	}
   123  }