github.com/buildpacks/pack@v0.33.3-0.20240516162812-884dd1837311/pkg/buildpack/parse_name_test.go (about)

     1  package buildpack_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/heroku/color"
     7  	"github.com/sclevine/spec"
     8  	"github.com/sclevine/spec/report"
     9  
    10  	"github.com/buildpacks/pack/pkg/buildpack"
    11  	h "github.com/buildpacks/pack/testhelpers"
    12  )
    13  
    14  func TestParseName(t *testing.T) {
    15  	color.Disable(true)
    16  	defer color.Disable(false)
    17  	spec.Run(t, "ParseName", testParseName, spec.Parallel(), spec.Report(report.Terminal{}))
    18  }
    19  
    20  func testParseName(t *testing.T, when spec.G, it spec.S) {
    21  	var (
    22  		assert = h.NewAssertionManager(t)
    23  	)
    24  
    25  	when("#ParseIDLocator", func() {
    26  		type testParams struct {
    27  			desc            string
    28  			locator         string
    29  			expectedID      string
    30  			expectedVersion string
    31  		}
    32  
    33  		for _, params := range []testParams{
    34  			{
    35  				desc:            "naked id+version",
    36  				locator:         "ns/name@0.0.1",
    37  				expectedID:      "ns/name",
    38  				expectedVersion: "0.0.1",
    39  			},
    40  			{
    41  				desc:            "naked only id",
    42  				locator:         "ns/name",
    43  				expectedID:      "ns/name",
    44  				expectedVersion: "",
    45  			},
    46  			{
    47  				desc:            "from=builder id+version",
    48  				locator:         "from=builder:ns/name@1.2.3",
    49  				expectedID:      "ns/name",
    50  				expectedVersion: "1.2.3",
    51  			},
    52  			{
    53  				desc:            "urn:cnb:builder id+version",
    54  				locator:         "urn:cnb:builder:ns/name@1.2.3",
    55  				expectedID:      "ns/name",
    56  				expectedVersion: "1.2.3",
    57  			},
    58  			{
    59  				desc:            "urn:cnb:registry id+version",
    60  				locator:         "urn:cnb:registry:ns/name@1.2.3",
    61  				expectedID:      "ns/name",
    62  				expectedVersion: "1.2.3",
    63  			},
    64  		} {
    65  			params := params
    66  			when(params.desc+" "+params.locator, func() {
    67  				it("should parse as id="+params.expectedID+" and version="+params.expectedVersion, func() {
    68  					id, version := buildpack.ParseIDLocator(params.locator)
    69  					assert.Equal(id, params.expectedID)
    70  					assert.Equal(version, params.expectedVersion)
    71  				})
    72  			})
    73  		}
    74  	})
    75  
    76  	when("#ParsePackageLocator", func() {
    77  		type testParams struct {
    78  			desc              string
    79  			locator           string
    80  			expectedImageName string
    81  		}
    82  
    83  		for _, params := range []testParams{
    84  			{
    85  				desc:              "docker scheme (missing host)",
    86  				locator:           "docker:///ns/name:latest",
    87  				expectedImageName: "ns/name:latest",
    88  			},
    89  			{
    90  				desc:              "docker scheme (missing host shorthand)",
    91  				locator:           "docker:/ns/name:latest",
    92  				expectedImageName: "ns/name:latest",
    93  			},
    94  			{
    95  				desc:              "docker scheme",
    96  				locator:           "docker://docker.io/ns/name:latest",
    97  				expectedImageName: "docker.io/ns/name:latest",
    98  			},
    99  			{
   100  				desc:              "schemaless w/ host",
   101  				locator:           "docker.io/ns/name:latest",
   102  				expectedImageName: "docker.io/ns/name:latest",
   103  			},
   104  			{
   105  				desc:              "schemaless w/o host",
   106  				locator:           "ns/name:latest",
   107  				expectedImageName: "ns/name:latest",
   108  			},
   109  		} {
   110  			params := params
   111  			when(params.desc+" "+params.locator, func() {
   112  				it("should parse as "+params.expectedImageName, func() {
   113  					imageName := buildpack.ParsePackageLocator(params.locator)
   114  					assert.Equal(imageName, params.expectedImageName)
   115  				})
   116  			})
   117  		}
   118  	})
   119  
   120  	when("#ParseRegistryID", func() {
   121  		type testParams struct {
   122  			desc,
   123  			locator,
   124  			expectedNS,
   125  			expectedName,
   126  			expectedVersion,
   127  			expectedErr string
   128  		}
   129  
   130  		for _, params := range []testParams{
   131  			{
   132  				desc:            "naked id+version",
   133  				locator:         "ns/name@0.1.2",
   134  				expectedNS:      "ns",
   135  				expectedName:    "name",
   136  				expectedVersion: "0.1.2",
   137  			},
   138  			{
   139  				desc:            "naked id",
   140  				locator:         "ns/name",
   141  				expectedNS:      "ns",
   142  				expectedName:    "name",
   143  				expectedVersion: "",
   144  			},
   145  			{
   146  				desc:            "urn:cnb:registry ref",
   147  				locator:         "urn:cnb:registry:ns/name@1.2.3",
   148  				expectedNS:      "ns",
   149  				expectedName:    "name",
   150  				expectedVersion: "1.2.3",
   151  			},
   152  			{
   153  				desc:        "invalid id",
   154  				locator:     "invalid/id/name@1.2.3",
   155  				expectedErr: "invalid registry ID: invalid/id/name@1.2.3",
   156  			},
   157  		} {
   158  			params := params
   159  			when(params.desc, func() {
   160  				if params.expectedErr != "" {
   161  					it("errors", func() {
   162  						_, _, _, err := buildpack.ParseRegistryID(params.locator)
   163  						assert.ErrorWithMessage(err, params.expectedErr)
   164  					})
   165  				} else {
   166  					it("parses", func() {
   167  						ns, name, version, err := buildpack.ParseRegistryID(params.locator)
   168  						assert.Nil(err)
   169  						assert.Equal(ns, params.expectedNS)
   170  						assert.Equal(name, params.expectedName)
   171  						assert.Equal(version, params.expectedVersion)
   172  					})
   173  				}
   174  			})
   175  		}
   176  	})
   177  }