compressed_test.go

Documentation: github.com/google/go-containerregistry/pkg/v1/partial

     1  // Copyright 2019 Google LLC All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //    http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package partial_test
    16  
    17  import (
    18  	"io"
    19  	"net/http/httptest"
    20  	"net/url"
    21  	"path"
    22  	"testing"
    23  
    24  	"github.com/google/go-cmp/cmp"
    25  	"github.com/google/go-containerregistry/internal/compare"
    26  	"github.com/google/go-containerregistry/pkg/name"
    27  	"github.com/google/go-containerregistry/pkg/registry"
    28  	v1 "github.com/google/go-containerregistry/pkg/v1"
    29  	"github.com/google/go-containerregistry/pkg/v1/partial"
    30  	"github.com/google/go-containerregistry/pkg/v1/random"
    31  	"github.com/google/go-containerregistry/pkg/v1/remote"
    32  	"github.com/google/go-containerregistry/pkg/v1/types"
    33  	"github.com/google/go-containerregistry/pkg/v1/validate"
    34  )
    35  
    36  // Remote leverages a lot of compressed partials.
    37  func TestRemote(t *testing.T) {
    38  	// Set up a fake registry.
    39  	s := httptest.NewServer(registry.New())
    40  	defer s.Close()
    41  	u, err := url.Parse(s.URL)
    42  	if err != nil {
    43  		t.Fatal(err)
    44  	}
    45  
    46  	rnd, err := random.Image(1024, 3)
    47  	if err != nil {
    48  		t.Fatal(err)
    49  	}
    50  
    51  	src := path.Join(u.Host, "test/compressed")
    52  	ref, err := name.ParseReference(src)
    53  	if err != nil {
    54  		t.Fatal(err)
    55  	}
    56  	if err := remote.Write(ref, rnd); err != nil {
    57  		t.Fatal(err)
    58  	}
    59  
    60  	img, err := remote.Image(ref)
    61  	if err != nil {
    62  		t.Fatal(err)
    63  	}
    64  	if err := validate.Image(img); err != nil {
    65  		t.Fatal(err)
    66  	}
    67  
    68  	cf, err := img.ConfigFile()
    69  	if err != nil {
    70  		t.Fatal(err)
    71  	}
    72  	m, err := img.Manifest()
    73  	if err != nil {
    74  		t.Fatal(err)
    75  	}
    76  	layer, err := img.LayerByDiffID(cf.RootFS.DiffIDs[0])
    77  	if err != nil {
    78  		t.Fatal(err)
    79  	}
    80  	d, err := layer.Digest()
    81  	if err != nil {
    82  		t.Fatal(err)
    83  	}
    84  
    85  	if diff := cmp.Diff(d, m.Layers[0].Digest); diff != "" {
    86  		t.Errorf("mismatched digest: %v", diff)
    87  	}
    88  
    89  	ok, err := partial.Exists(layer)
    90  	if err != nil {
    91  		t.Fatal(err)
    92  	}
    93  	if got, want := ok, true; got != want {
    94  		t.Errorf("Exists() = %t != %t", got, want)
    95  	}
    96  
    97  	cl, err := partial.ConfigLayer(img)
    98  	if err != nil {
    99  		t.Fatal(err)
   100  	}
   101  	if _, ok := cl.(*remote.MountableLayer); !ok {
   102  		t.Errorf("ConfigLayer() expected to be MountableLayer, got %T", cl)
   103  	}
   104  }
   105  
   106  type noDiffID struct {
   107  	l v1.Layer
   108  }
   109  
   110  func (l *noDiffID) Digest() (v1.Hash, error) {
   111  	return l.l.Digest()
   112  }
   113  func (l *noDiffID) Compressed() (io.ReadCloser, error) {
   114  	return l.l.Compressed()
   115  }
   116  func (l *noDiffID) Size() (int64, error) {
   117  	return l.l.Size()
   118  }
   119  func (l *noDiffID) MediaType() (types.MediaType, error) {
   120  	return l.l.MediaType()
   121  }
   122  func (l *noDiffID) Descriptor() (*v1.Descriptor, error) {
   123  	return partial.Descriptor(l.l)
   124  }
   125  func (l *noDiffID) UncompressedSize() (int64, error) {
   126  	return partial.UncompressedSize(l.l)
   127  }
   128  
   129  func TestCompressedLayerExtender(t *testing.T) {
   130  	rnd, err := random.Layer(1000, types.OCILayer)
   131  	if err != nil {
   132  		t.Fatal(err)
   133  	}
   134  	l, err := partial.CompressedToLayer(&noDiffID{rnd})
   135  	if err != nil {
   136  		t.Fatal(err)
   137  	}
   138  
   139  	if err := compare.Layers(rnd, l); err != nil {
   140  		t.Fatalf("compare.Layers: %v", err)
   141  	}
   142  	if _, err := partial.Descriptor(l); err != nil {
   143  		t.Fatalf("partial.Descriptor: %v", err)
   144  	}
   145  	if _, err := partial.UncompressedSize(l); err != nil {
   146  		t.Fatalf("partial.UncompressedSize: %v", err)
   147  	}
   148  }
   149  
   150  type compressedImage struct {
   151  	img v1.Image
   152  }
   153  
   154  func (i *compressedImage) RawConfigFile() ([]byte, error) {
   155  	return i.img.RawConfigFile()
   156  }
   157  
   158  func (i *compressedImage) MediaType() (types.MediaType, error) {
   159  	return i.img.MediaType()
   160  }
   161  
   162  func (i *compressedImage) LayerByDigest(h v1.Hash) (partial.CompressedLayer, error) {
   163  	return i.img.LayerByDigest(h)
   164  }
   165  
   166  func (i *compressedImage) RawManifest() ([]byte, error) {
   167  	return i.img.RawManifest()
   168  }
   169  
   170  func (i *compressedImage) Descriptor() (*v1.Descriptor, error) {
   171  	return partial.Descriptor(i.img)
   172  }
   173  
   174  func TestCompressed(t *testing.T) {
   175  	rnd, err := random.Image(1024, 1)
   176  	if err != nil {
   177  		t.Fatal(err)
   178  	}
   179  
   180  	core := &compressedImage{rnd}
   181  
   182  	img, err := partial.CompressedToImage(core)
   183  	if err != nil {
   184  		t.Fatal(err)
   185  	}
   186  
   187  	if err := validate.Image(img); err != nil {
   188  		t.Fatalf("validate.Image: %v", err)
   189  	}
   190  	if _, err := partial.Descriptor(img); err != nil {
   191  		t.Fatalf("partial.Descriptor: %v", err)
   192  	}
   193  }
   194
View as plain text