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

     1  package cache_test
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/buildpacks/pack/pkg/cache"
     8  
     9  	"github.com/buildpacks/imgutil/local"
    10  	"github.com/docker/docker/api/types/filters"
    11  	"github.com/docker/docker/api/types/image"
    12  	"github.com/docker/docker/client"
    13  	"github.com/google/go-containerregistry/pkg/name"
    14  	"github.com/heroku/color"
    15  	"github.com/sclevine/spec"
    16  	"github.com/sclevine/spec/report"
    17  
    18  	h "github.com/buildpacks/pack/testhelpers"
    19  )
    20  
    21  func TestImageCache(t *testing.T) {
    22  	h.RequireDocker(t)
    23  	color.Disable(true)
    24  	defer color.Disable(false)
    25  
    26  	spec.Run(t, "ImageCache", testImageCache, spec.Parallel(), spec.Report(report.Terminal{}))
    27  }
    28  
    29  func testImageCache(t *testing.T, when spec.G, it spec.S) {
    30  	when("#NewImageCache", func() {
    31  		var dockerClient client.CommonAPIClient
    32  
    33  		it.Before(func() {
    34  			var err error
    35  			dockerClient, err = client.NewClientWithOpts(client.FromEnv, client.WithVersion("1.38"))
    36  			h.AssertNil(t, err)
    37  		})
    38  
    39  		when("#Name", func() {
    40  			it("should return the image reference used in intialization", func() {
    41  				refName := "gcr.io/my/repo:tag"
    42  				ref, err := name.ParseReference(refName, name.WeakValidation)
    43  				h.AssertNil(t, err)
    44  				subject := cache.NewImageCache(ref, dockerClient)
    45  				actual := subject.Name()
    46  				if actual != refName {
    47  					t.Fatalf("Incorrect cache name expected %s, got %s", refName, actual)
    48  				}
    49  			})
    50  		})
    51  
    52  		it("resolves implied tag", func() {
    53  			ref, err := name.ParseReference("my/repo:latest", name.WeakValidation)
    54  			h.AssertNil(t, err)
    55  			subject := cache.NewImageCache(ref, dockerClient)
    56  
    57  			ref, err = name.ParseReference("my/repo", name.WeakValidation)
    58  			h.AssertNil(t, err)
    59  			expected := cache.NewImageCache(ref, dockerClient)
    60  
    61  			h.AssertEq(t, subject.Name(), expected.Name())
    62  		})
    63  
    64  		it("resolves implied registry", func() {
    65  			ref, err := name.ParseReference("index.docker.io/my/repo", name.WeakValidation)
    66  			h.AssertNil(t, err)
    67  			subject := cache.NewImageCache(ref, dockerClient)
    68  			ref, err = name.ParseReference("my/repo", name.WeakValidation)
    69  			h.AssertNil(t, err)
    70  			expected := cache.NewImageCache(ref, dockerClient)
    71  			if subject.Name() != expected.Name() {
    72  				t.Fatalf("The same repo name should result in the same image")
    73  			}
    74  		})
    75  	})
    76  
    77  	when("#Type", func() {
    78  		var (
    79  			dockerClient client.CommonAPIClient
    80  		)
    81  
    82  		it.Before(func() {
    83  			var err error
    84  			dockerClient, err = client.NewClientWithOpts(client.FromEnv, client.WithVersion("1.38"))
    85  			h.AssertNil(t, err)
    86  		})
    87  
    88  		it("returns the cache type", func() {
    89  			ref, err := name.ParseReference("my/repo", name.WeakValidation)
    90  			h.AssertNil(t, err)
    91  			subject := cache.NewImageCache(ref, dockerClient)
    92  			expected := cache.Image
    93  			h.AssertEq(t, subject.Type(), expected)
    94  		})
    95  	})
    96  
    97  	when("#Clear", func() {
    98  		var (
    99  			imageName    string
   100  			dockerClient client.CommonAPIClient
   101  			subject      *cache.ImageCache
   102  			ctx          context.Context
   103  		)
   104  
   105  		it.Before(func() {
   106  			var err error
   107  			dockerClient, err = client.NewClientWithOpts(client.FromEnv, client.WithVersion("1.38"))
   108  			h.AssertNil(t, err)
   109  			ctx = context.TODO()
   110  
   111  			ref, err := name.ParseReference(h.RandString(10), name.WeakValidation)
   112  			h.AssertNil(t, err)
   113  			subject = cache.NewImageCache(ref, dockerClient)
   114  			h.AssertNil(t, err)
   115  			imageName = subject.Name()
   116  		})
   117  
   118  		when("there is a cache image", func() {
   119  			it.Before(func() {
   120  				img, err := local.NewImage(imageName, dockerClient)
   121  				h.AssertNil(t, err)
   122  
   123  				h.AssertNil(t, img.Save())
   124  			})
   125  
   126  			it("removes the image", func() {
   127  				err := subject.Clear(ctx)
   128  				h.AssertNil(t, err)
   129  				images, err := dockerClient.ImageList(context.TODO(), image.ListOptions{
   130  					Filters: filters.NewArgs(filters.KeyValuePair{
   131  						Key:   "reference",
   132  						Value: imageName,
   133  					}),
   134  				})
   135  				h.AssertNil(t, err)
   136  				h.AssertEq(t, len(images), 0)
   137  			})
   138  		})
   139  
   140  		when("there is no cache image", func() {
   141  			it("does not fail", func() {
   142  				err := subject.Clear(ctx)
   143  				h.AssertNil(t, err)
   144  			})
   145  		})
   146  	})
   147  }