9c88801a12
Back in the before time, the best practices surrounding usage of Context weren't quite worked out. We defined our own type to make usage easier. As this packaged was used elsewhere, it make it more and more challenging to integrate with the forked `Context` type. Now that it is available in the standard library, we can just use that one directly. To make usage more consistent, we now use `dcontext` when referring to the distribution context package. Signed-off-by: Stephen J Day <stephen.day@docker.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.Errorf("Expected error untagging non-existant tag")
|
|
}
|
|
|
|
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))
|
|
}
|
|
|
|
}
|