github.com/YousefHaggyHeroku/pack@v1.5.5/internal/cache/image_cache_test.go (about)

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