005c6e0236
Signed-off-by: Wenkai Yin <yinw@vmware.com>
209 lines
4.1 KiB
Go
209 lines
4.1 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/docker/distribution"
|
|
"github.com/docker/distribution/reference"
|
|
"github.com/docker/distribution/registry/storage/driver/inmemory"
|
|
)
|
|
|
|
type tagsTestEnv struct {
|
|
ts distribution.TagService
|
|
ctx context.Context
|
|
}
|
|
|
|
func testTagStore(t *testing.T) *tagsTestEnv {
|
|
ctx := context.Background()
|
|
d := inmemory.New()
|
|
reg, err := NewRegistry(ctx, d)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
repoRef, _ := reference.WithName("a/b")
|
|
repo, err := reg.Repository(ctx, repoRef)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
return &tagsTestEnv{
|
|
ctx: ctx,
|
|
ts: repo.Tags(ctx),
|
|
}
|
|
}
|
|
|
|
func TestTagStoreTag(t *testing.T) {
|
|
env := testTagStore(t)
|
|
tags := env.ts
|
|
ctx := env.ctx
|
|
|
|
d := distribution.Descriptor{}
|
|
err := tags.Tag(ctx, "latest", d)
|
|
if err == nil {
|
|
t.Errorf("unexpected error putting malformed descriptor : %s", err)
|
|
}
|
|
|
|
d.Digest = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
err = tags.Tag(ctx, "latest", d)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
d1, err := tags.Get(ctx, "latest")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if d1.Digest != d.Digest {
|
|
t.Error("put and get digest differ")
|
|
}
|
|
|
|
// Overwrite existing
|
|
d.Digest = "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
|
|
err = tags.Tag(ctx, "latest", d)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
d1, err = tags.Get(ctx, "latest")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if d1.Digest != d.Digest {
|
|
t.Error("put and get digest differ")
|
|
}
|
|
}
|
|
|
|
func TestTagStoreUnTag(t *testing.T) {
|
|
env := testTagStore(t)
|
|
tags := env.ts
|
|
ctx := env.ctx
|
|
desc := distribution.Descriptor{Digest: "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"}
|
|
|
|
err := tags.Untag(ctx, "latest")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
err = tags.Tag(ctx, "latest", desc)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
err = tags.Untag(ctx, "latest")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
errExpect := distribution.ErrTagUnknown{Tag: "latest"}.Error()
|
|
_, err = tags.Get(ctx, "latest")
|
|
if err == nil || err.Error() != errExpect {
|
|
t.Error("Expected error getting untagged tag")
|
|
}
|
|
}
|
|
|
|
func TestTagStoreAll(t *testing.T) {
|
|
env := testTagStore(t)
|
|
tagStore := env.ts
|
|
ctx := env.ctx
|
|
|
|
alpha := "abcdefghijklmnopqrstuvwxyz"
|
|
for i := 0; i < len(alpha); i++ {
|
|
tag := alpha[i]
|
|
desc := distribution.Descriptor{Digest: "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"}
|
|
err := tagStore.Tag(ctx, string(tag), desc)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
all, err := tagStore.All(ctx)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if len(all) != len(alpha) {
|
|
t.Errorf("Unexpected count returned from enumerate")
|
|
}
|
|
|
|
for i, c := range all {
|
|
if c != string(alpha[i]) {
|
|
t.Errorf("unexpected tag in enumerate %s", c)
|
|
}
|
|
}
|
|
|
|
removed := "a"
|
|
err = tagStore.Untag(ctx, removed)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
all, err = tagStore.All(ctx)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
for _, tag := range all {
|
|
if tag == removed {
|
|
t.Errorf("unexpected tag in enumerate %s", removed)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func TestTagLookup(t *testing.T) {
|
|
env := testTagStore(t)
|
|
tagStore := env.ts
|
|
ctx := env.ctx
|
|
|
|
descA := distribution.Descriptor{Digest: "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}
|
|
desc0 := distribution.Descriptor{Digest: "sha256:0000000000000000000000000000000000000000000000000000000000000000"}
|
|
|
|
tags, err := tagStore.Lookup(ctx, descA)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(tags) != 0 {
|
|
t.Fatalf("Lookup returned > 0 tags from empty store")
|
|
}
|
|
|
|
err = tagStore.Tag(ctx, "a", descA)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = tagStore.Tag(ctx, "b", descA)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = tagStore.Tag(ctx, "0", desc0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = tagStore.Tag(ctx, "1", desc0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tags, err = tagStore.Lookup(ctx, descA)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(tags) != 2 {
|
|
t.Errorf("Lookup of descA returned %d tags, expected 2", len(tags))
|
|
}
|
|
|
|
tags, err = tagStore.Lookup(ctx, desc0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(tags) != 2 {
|
|
t.Errorf("Lookup of descB returned %d tags, expected 2", len(tags))
|
|
}
|
|
|
|
}
|