Source file src/github.com/docker/distribution/manifest/schema1/reference_builder_test.go

Documentation: github.com/docker/distribution/manifest/schema1

     1  package schema1
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/distribution/reference"
     7  	"github.com/docker/distribution/context"
     8  	"github.com/docker/distribution/manifest"
     9  	"github.com/docker/libtrust"
    10  	"github.com/opencontainers/go-digest"
    11  )
    12  
    13  func makeSignedManifest(t *testing.T, pk libtrust.PrivateKey, refs []Reference) *SignedManifest {
    14  	u := &Manifest{
    15  		Versioned: manifest.Versioned{
    16  			SchemaVersion: 1,
    17  		},
    18  		Name:         "foo/bar",
    19  		Tag:          "latest",
    20  		Architecture: "amd64",
    21  	}
    22  
    23  	for i := len(refs) - 1; i >= 0; i-- {
    24  		u.FSLayers = append(u.FSLayers, FSLayer{
    25  			BlobSum: refs[i].Digest,
    26  		})
    27  		u.History = append(u.History, History{
    28  			V1Compatibility: refs[i].History.V1Compatibility,
    29  		})
    30  	}
    31  
    32  	signedManifest, err := Sign(u, pk)
    33  	if err != nil {
    34  		t.Fatalf("unexpected error signing manifest: %v", err)
    35  	}
    36  	return signedManifest
    37  }
    38  
    39  func TestReferenceBuilder(t *testing.T) {
    40  	pk, err := libtrust.GenerateECP256PrivateKey()
    41  	if err != nil {
    42  		t.Fatalf("unexpected error generating private key: %v", err)
    43  	}
    44  
    45  	r1 := Reference{
    46  		Digest:  "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    47  		Size:    1,
    48  		History: History{V1Compatibility: "{\"a\" : 1 }"},
    49  	}
    50  	r2 := Reference{
    51  		Digest:  "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
    52  		Size:    2,
    53  		History: History{V1Compatibility: "{\"\a\" : 2 }"},
    54  	}
    55  
    56  	handCrafted := makeSignedManifest(t, pk, []Reference{r1, r2})
    57  
    58  	ref, err := reference.WithName(handCrafted.Manifest.Name)
    59  	if err != nil {
    60  		t.Fatalf("could not parse reference: %v", err)
    61  	}
    62  	ref, err = reference.WithTag(ref, handCrafted.Manifest.Tag)
    63  	if err != nil {
    64  		t.Fatalf("could not add tag: %v", err)
    65  	}
    66  
    67  	b := NewReferenceManifestBuilder(pk, ref, handCrafted.Manifest.Architecture)
    68  	_, err = b.Build(context.Background())
    69  	if err == nil {
    70  		t.Fatal("Expected error building zero length manifest")
    71  	}
    72  
    73  	err = b.AppendReference(r1)
    74  	if err != nil {
    75  		t.Fatal(err)
    76  	}
    77  
    78  	err = b.AppendReference(r2)
    79  	if err != nil {
    80  		t.Fatal(err)
    81  	}
    82  
    83  	refs := b.References()
    84  	if len(refs) != 2 {
    85  		t.Fatalf("Unexpected reference count : %d != %d", 2, len(refs))
    86  	}
    87  
    88  	// Ensure ordering
    89  	if refs[0].Digest != r2.Digest {
    90  		t.Fatalf("Unexpected reference : %v", refs[0])
    91  	}
    92  
    93  	m, err := b.Build(context.Background())
    94  	if err != nil {
    95  		t.Fatal(err)
    96  	}
    97  
    98  	built, ok := m.(*SignedManifest)
    99  	if !ok {
   100  		t.Fatalf("unexpected type from Build() : %T", built)
   101  	}
   102  
   103  	d1 := digest.FromBytes(built.Canonical)
   104  	d2 := digest.FromBytes(handCrafted.Canonical)
   105  	if d1 != d2 {
   106  		t.Errorf("mismatching canonical JSON")
   107  	}
   108  }
   109  

View as plain text