Infrastructure/zot
0
Fork 0
mirror of https://github.com/project-zot/zot.git synced 2024-12-16 21:56:37 -05:00
Code Issues Activity
zot/pkg/meta/meta_test.go
peusebiu 1df743f173
fix(gc): sync repodb when gc'ing manifests (#1819) 
fix(gc): fix cleaning deduped blobs because they have the modTime of
the original blobs, fixed by updating the modTime when hard linking
the blobs.
fix(gc): failing to parse rootDir at zot startup when using s3 storage
because there are no files under rootDir and we can not create empty dirs
on s3, fixed by creating an empty file under rootDir.

Signed-off-by: Petu Eusebiu <peusebiu@cisco.com>
2023-09-22 11:51:20 -07:00

2754 lines
85 KiB
Go
Raw Blame History

//go:build imagetrust
// +build imagetrust
package meta_test
import (
"context"
"encoding/json"
"fmt"
"math/rand"
"os"
"path"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
guuid "github.com/gofrs/uuid"
"github.com/notaryproject/notation-core-go/signature/jws"
"github.com/notaryproject/notation-go"
"github.com/notaryproject/notation-go/signer"
godigest "github.com/opencontainers/go-digest"
"github.com/opencontainers/image-spec/specs-go"
ispec "github.com/opencontainers/image-spec/specs-go/v1"
. "github.com/smartystreets/goconvey/convey"
"zotregistry.io/zot/pkg/extensions/imagetrust"
"zotregistry.io/zot/pkg/log"
"zotregistry.io/zot/pkg/meta"
"zotregistry.io/zot/pkg/meta/boltdb"
"zotregistry.io/zot/pkg/meta/common"
mdynamodb "zotregistry.io/zot/pkg/meta/dynamodb"
mTypes "zotregistry.io/zot/pkg/meta/types"
reqCtx "zotregistry.io/zot/pkg/requestcontext"
"zotregistry.io/zot/pkg/test"
)
const (
LINUX = "linux"
WINDOWS = "windows"
AMD = "amd"
ARM = "arm64"
)
func TestBoltDB(t *testing.T) {
Convey("BoltDB creation", t, func() {
boltDBParams := boltdb.DBParameters{RootDir: t.TempDir()}
repoDBPath := path.Join(boltDBParams.RootDir, "repo.db")
boltDriver, err := boltdb.GetBoltDriver(boltDBParams)
So(err, ShouldBeNil)
defer os.Remove(repoDBPath)
log := log.NewLogger("debug", "")
metaDB, err := boltdb.New(boltDriver, log)
So(metaDB, ShouldNotBeNil)
So(err, ShouldBeNil)
err = os.Chmod(repoDBPath, 0o200)
So(err, ShouldBeNil)
_, err = boltdb.GetBoltDriver(boltDBParams)
So(err, ShouldNotBeNil)
err = os.Chmod(repoDBPath, 0o600)
So(err, ShouldBeNil)
})
Convey("BoltDB Wrapper", t, func() {
boltDBParams := boltdb.DBParameters{RootDir: t.TempDir()}
boltDriver, err := boltdb.GetBoltDriver(boltDBParams)
So(err, ShouldBeNil)
log := log.NewLogger("debug", "")
imgTrustStore, err := imagetrust.NewLocalImageTrustStore(boltDBParams.RootDir)
So(err, ShouldBeNil)
boltdbWrapper, err := boltdb.New(boltDriver, log)
boltdbWrapper.SetImageTrustStore(imgTrustStore)
defer func() {
os.Remove(path.Join(boltDBParams.RootDir, "repo.db"))
os.RemoveAll(path.Join(boltDBParams.RootDir, "_cosign"))
os.RemoveAll(path.Join(boltDBParams.RootDir, "_notation"))
}()
So(boltdbWrapper, ShouldNotBeNil)
So(err, ShouldBeNil)
RunMetaDBTests(t, boltdbWrapper)
})
}
func TestDynamoDBWrapper(t *testing.T) {
skipIt(t)
uuid, err := guuid.NewV4()
if err != nil {
panic(err)
}
repoMetaTablename := "RepoMetadataTable" + uuid.String()
manifestDataTablename := "ManifestDataTable" + uuid.String()
versionTablename := "Version" + uuid.String()
indexDataTablename := "IndexDataTable" + uuid.String()
userDataTablename := "UserDataTable" + uuid.String()
apiKeyTablename := "ApiKeyTable" + uuid.String()
Convey("DynamoDB Wrapper", t, func() {
dynamoDBDriverParams := mdynamodb.DBDriverParameters{
Endpoint: os.Getenv("DYNAMODBMOCK_ENDPOINT"),
RepoMetaTablename: repoMetaTablename,
ManifestDataTablename: manifestDataTablename,
IndexDataTablename: indexDataTablename,
VersionTablename: versionTablename,
UserDataTablename: userDataTablename,
APIKeyTablename: apiKeyTablename,
Region: "us-east-2",
}
t.Logf("using dynamo driver options: %v", dynamoDBDriverParams)
dynamoClient, err := mdynamodb.GetDynamoClient(dynamoDBDriverParams)
So(err, ShouldBeNil)
log := log.NewLogger("debug", "")
dynamoDriver, err := mdynamodb.New(dynamoClient, dynamoDBDriverParams, log)
So(dynamoDriver, ShouldNotBeNil)
So(err, ShouldBeNil)
imgTrustStore, err := imagetrust.NewAWSImageTrustStore(dynamoDBDriverParams.Region, dynamoDBDriverParams.Endpoint)
So(err, ShouldBeNil)
dynamoDriver.SetImageTrustStore(imgTrustStore)
resetDynamoDBTables := func() error {
err := dynamoDriver.ResetRepoMetaTable()
if err != nil {
return err
}
// Note: Tests are very slow if we reset the UserData table every new convey. We'll reset it as needed
err = dynamoDriver.ResetManifestDataTable()
return err
}
RunMetaDBTests(t, dynamoDriver, resetDynamoDBTables)
})
}
func RunMetaDBTests(t *testing.T, metaDB mTypes.MetaDB, preparationFuncs ...func() error) { //nolint: thelper
Convey("Test MetaDB Interface implementation", func() {
for _, prepFunc := range preparationFuncs {
err := prepFunc()
So(err, ShouldBeNil)
}
Convey("Test CRUD operations on UserData and API keys", func() {
hashKey1 := "id"
label1 := "apiKey1"
apiKeys := make(map[string]mTypes.APIKeyDetails)
apiKeyDetails := mTypes.APIKeyDetails{
Label: label1,
Scopes: []string{"repo"},
UUID: hashKey1,
}
apiKeys[hashKey1] = apiKeyDetails
userProfileSrc := mTypes.UserData{
Groups: []string{"group1", "group2"},
APIKeys: apiKeys,
}
Convey("Test basic operations on API keys", func() {
hashKey2 := "key"
label2 := "apiKey2"
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("test")
ctx := userAc.DeriveContext(context.Background())
err := metaDB.AddUserAPIKey(ctx, hashKey1, &apiKeyDetails)
So(err, ShouldBeNil)
isExpired, err := metaDB.IsAPIKeyExpired(ctx, hashKey1)
So(isExpired, ShouldBeFalse)
So(err, ShouldBeNil)
storedAPIKeys, err := metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 1)
So(storedAPIKeys[0], ShouldResemble, apiKeyDetails)
userProfile, err := metaDB.GetUserData(ctx)
So(err, ShouldBeNil)
So(userProfile.APIKeys, ShouldContainKey, hashKey1)
So(userProfile.APIKeys[hashKey1].Label, ShouldEqual, apiKeyDetails.Label)
So(userProfile.APIKeys[hashKey1].Scopes, ShouldResemble, apiKeyDetails.Scopes)
err = metaDB.SetUserData(ctx, userProfileSrc)
So(err, ShouldBeNil)
userProfile, err = metaDB.GetUserData(ctx)
So(err, ShouldBeNil)
So(userProfile.Groups, ShouldResemble, userProfileSrc.Groups)
So(userProfile.APIKeys, ShouldContainKey, hashKey1)
So(userProfile.APIKeys[hashKey1].Label, ShouldEqual, apiKeyDetails.Label)
So(userProfile.APIKeys[hashKey1].Scopes, ShouldResemble, apiKeyDetails.Scopes)
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 1)
So(storedAPIKeys[0], ShouldResemble, apiKeyDetails)
lastUsed := userProfile.APIKeys[hashKey1].LastUsed
err = metaDB.UpdateUserAPIKeyLastUsed(ctx, hashKey1)
So(err, ShouldBeNil)
userProfile, err = metaDB.GetUserData(ctx)
So(err, ShouldBeNil)
So(userProfile.APIKeys[hashKey1].LastUsed, ShouldHappenAfter, lastUsed)
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 1)
So(storedAPIKeys[0].LastUsed, ShouldHappenAfter, lastUsed)
userGroups, err := metaDB.GetUserGroups(ctx)
So(err, ShouldBeNil)
So(userGroups, ShouldResemble, userProfileSrc.Groups)
apiKeyDetails.UUID = hashKey2
apiKeyDetails.Label = label2
err = metaDB.AddUserAPIKey(ctx, hashKey2, &apiKeyDetails)
So(err, ShouldBeNil)
userProfile, err = metaDB.GetUserData(ctx)
So(err, ShouldBeNil)
So(userProfile.Groups, ShouldResemble, userProfileSrc.Groups)
So(userProfile.APIKeys, ShouldContainKey, hashKey2)
So(userProfile.APIKeys[hashKey2].Label, ShouldEqual, apiKeyDetails.Label)
So(userProfile.APIKeys[hashKey2].Scopes, ShouldResemble, apiKeyDetails.Scopes)
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 2)
So(storedAPIKeys[0].Scopes, ShouldResemble, apiKeyDetails.Scopes)
So(storedAPIKeys[1].Scopes, ShouldResemble, apiKeyDetails.Scopes)
scopes := []string{storedAPIKeys[0].Label, storedAPIKeys[1].Label}
// order is not preserved when getting api keys from db
So(scopes, ShouldContain, label1)
So(scopes, ShouldContain, label2)
email, err := metaDB.GetUserAPIKeyInfo(hashKey2)
So(err, ShouldBeNil)
So(email, ShouldEqual, "test")
email, err = metaDB.GetUserAPIKeyInfo(hashKey1)
So(err, ShouldBeNil)
So(email, ShouldEqual, "test")
err = metaDB.DeleteUserAPIKey(ctx, hashKey1)
So(err, ShouldBeNil)
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 1)
So(storedAPIKeys[0].Label, ShouldEqual, label2)
userProfile, err = metaDB.GetUserData(ctx)
So(err, ShouldBeNil)
So(len(userProfile.APIKeys), ShouldEqual, 1)
err = metaDB.DeleteUserAPIKey(ctx, hashKey2)
So(err, ShouldBeNil)
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 0)
userProfile, err = metaDB.GetUserData(ctx)
So(err, ShouldBeNil)
So(len(userProfile.APIKeys), ShouldEqual, 0)
So(userProfile.APIKeys, ShouldNotContainKey, hashKey2)
// delete non existent api key
err = metaDB.DeleteUserAPIKey(ctx, hashKey2)
So(err, ShouldBeNil)
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 0)
err = metaDB.DeleteUserData(ctx)
So(err, ShouldBeNil)
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 0)
email, err = metaDB.GetUserAPIKeyInfo(hashKey2)
So(err, ShouldNotBeNil)
So(email, ShouldBeEmpty)
email, err = metaDB.GetUserAPIKeyInfo(hashKey1)
So(err, ShouldNotBeNil)
So(email, ShouldBeEmpty)
_, err = metaDB.GetUserData(ctx)
So(err, ShouldNotBeNil)
userGroups, err = metaDB.GetUserGroups(ctx)
So(err, ShouldNotBeNil)
So(userGroups, ShouldBeEmpty)
err = metaDB.SetUserGroups(ctx, userProfileSrc.Groups)
So(err, ShouldBeNil)
userGroups, err = metaDB.GetUserGroups(ctx)
So(err, ShouldBeNil)
So(userGroups, ShouldResemble, userProfileSrc.Groups)
})
Convey("Test API keys operations with invalid access control context", func() {
var invalid struct{}
key := reqCtx.GetContextKey()
ctx := context.WithValue(context.Background(), key, invalid)
_, err := metaDB.GetUserAPIKeys(ctx)
So(err, ShouldNotBeNil)
err = metaDB.AddUserAPIKey(ctx, hashKey1, &apiKeyDetails)
So(err, ShouldNotBeNil)
isExpired, err := metaDB.IsAPIKeyExpired(ctx, hashKey1)
So(isExpired, ShouldBeFalse)
So(err, ShouldNotBeNil)
err = metaDB.DeleteUserAPIKey(ctx, hashKey1)
So(err, ShouldNotBeNil)
_, err = metaDB.GetUserData(ctx)
So(err, ShouldNotBeNil)
_, err = metaDB.GetUserGroups(ctx)
So(err, ShouldNotBeNil)
_, err = metaDB.GetUserAPIKeyInfo(hashKey1)
So(err, ShouldNotBeNil)
err = metaDB.UpdateUserAPIKeyLastUsed(ctx, hashKey1)
So(err, ShouldNotBeNil)
err = metaDB.SetUserData(ctx, userProfileSrc)
So(err, ShouldNotBeNil)
})
Convey("Test API keys operations with empty userid", func() {
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("")
ctx := userAc.DeriveContext(context.Background())
_, err := metaDB.GetUserAPIKeys(ctx)
So(err, ShouldNotBeNil)
isExpired, err := metaDB.IsAPIKeyExpired(ctx, hashKey1)
So(isExpired, ShouldBeFalse)
So(err, ShouldNotBeNil)
err = metaDB.AddUserAPIKey(ctx, hashKey1, &apiKeyDetails)
So(err, ShouldNotBeNil)
err = metaDB.DeleteUserAPIKey(ctx, hashKey1)
So(err, ShouldNotBeNil)
_, err = metaDB.GetUserData(ctx)
So(err, ShouldNotBeNil)
_, err = metaDB.GetUserGroups(ctx)
So(err, ShouldNotBeNil)
_, err = metaDB.GetUserAPIKeyInfo(hashKey1)
So(err, ShouldNotBeNil)
err = metaDB.UpdateUserAPIKeyLastUsed(ctx, hashKey1)
So(err, ShouldNotBeNil)
err = metaDB.SetUserData(ctx, userProfileSrc)
So(err, ShouldNotBeNil)
})
Convey("Test API keys with short expiration date", func() {
expirationDate := time.Now().Add(500 * time.Millisecond).Local().Round(time.Millisecond)
apiKeyDetails.ExpirationDate = expirationDate
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("test")
ctx := userAc.DeriveContext(context.Background())
err := metaDB.AddUserAPIKey(ctx, hashKey1, &apiKeyDetails)
So(err, ShouldBeNil)
storedAPIKeys, err := metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 1)
So(storedAPIKeys[0].ExpirationDate, ShouldResemble, expirationDate)
So(storedAPIKeys[0].Label, ShouldEqual, apiKeyDetails.Label)
So(storedAPIKeys[0].Scopes, ShouldResemble, apiKeyDetails.Scopes)
isExpired, err := metaDB.IsAPIKeyExpired(ctx, hashKey1)
So(isExpired, ShouldBeFalse)
So(err, ShouldBeNil)
time.Sleep(600 * time.Millisecond)
Convey("GetUserAPIKeys detects api key expired", func() {
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 1)
So(storedAPIKeys[0].IsExpired, ShouldBeTrue)
isExpired, err = metaDB.IsAPIKeyExpired(ctx, hashKey1)
So(isExpired, ShouldBeTrue)
So(err, ShouldBeNil)
})
Convey("IsAPIKeyExpired detects api key expired", func() {
isExpired, err = metaDB.IsAPIKeyExpired(ctx, hashKey1)
So(isExpired, ShouldBeTrue)
So(err, ShouldBeNil)
storedAPIKeys, err = metaDB.GetUserAPIKeys(ctx)
So(err, ShouldBeNil)
So(len(storedAPIKeys), ShouldEqual, 1)
So(storedAPIKeys[0].IsExpired, ShouldBeTrue)
})
})
})
Convey("Test SetManifestData and GetManifestData", func() {
configBlob, manifestBlob, err := generateTestImage()
So(err, ShouldBeNil)
manifestDigest := godigest.FromBytes(manifestBlob)
err = metaDB.SetManifestData(manifestDigest, mTypes.ManifestData{
ManifestBlob: manifestBlob,
ConfigBlob: configBlob,
})
So(err, ShouldBeNil)
mm, err := metaDB.GetManifestData(manifestDigest)
So(err, ShouldBeNil)
So(mm.ManifestBlob, ShouldResemble, manifestBlob)
So(mm.ConfigBlob, ShouldResemble, configBlob)
})
Convey("Test GetManifestMeta fails", func() {
_, err := metaDB.GetManifestMeta("repo", "bad digest")
So(err, ShouldNotBeNil)
})
Convey("Test SetManifestMeta", func() {
Convey("RepoMeta not found", func() {
var (
manifestDigest = godigest.FromString("dig")
manifestBlob = []byte("manifestBlob")
configBlob = []byte("configBlob")
signatures = mTypes.ManifestSignatures{
"digest1": []mTypes.SignatureInfo{
{
SignatureManifestDigest: "signatureDigest",
LayersInfo: []mTypes.LayerInfo{
{
LayerDigest: "layerDigest",
LayerContent: []byte("layerContent"),
},
},
},
},
}
)
err := metaDB.SetManifestMeta("repo", manifestDigest, mTypes.ManifestMetadata{
ManifestBlob: manifestBlob,
ConfigBlob: configBlob,
DownloadCount: 10,
Signatures: signatures,
})
So(err, ShouldBeNil)
manifestMeta, err := metaDB.GetManifestMeta("repo", manifestDigest)
So(err, ShouldBeNil)
So(manifestMeta.ManifestBlob, ShouldResemble, manifestBlob)
So(manifestMeta.ConfigBlob, ShouldResemble, configBlob)
So(manifestMeta.DownloadCount, ShouldEqual, 10)
So(manifestMeta.Signatures, ShouldResemble, signatures)
})
})
Convey("Test SetRepoReference", func() {
// test behaviours
var (
repo1 = "repo1"
repo2 = "repo2"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
tag2 = "0.0.2"
manifestDigest2 = godigest.FromString("fake-manifes2")
)
Convey("Setting a good repo", func() {
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Name, ShouldResemble, repo1)
So(repoMeta.Tags[tag1].Digest, ShouldEqual, manifestDigest1.String())
err = metaDB.SetRepoMeta(repo2, mTypes.RepoMetadata{Tags: map[string]mTypes.Descriptor{
tag2: {
Digest: manifestDigest2.String(),
},
}})
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta(repo2)
So(err, ShouldBeNil)
So(repoMeta.Name, ShouldResemble, repo2)
So(repoMeta.Tags[tag2].Digest, ShouldEqual, manifestDigest2.String())
})
Convey("Setting a good repo using a digest", func() {
_, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldNotBeNil)
digest := godigest.FromString("digest")
err = metaDB.SetRepoReference(repo1, digest.String(), digest,
ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Name, ShouldResemble, repo1)
})
Convey("Set multiple tags for repo", func() {
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Tags[tag1].Digest, ShouldEqual, manifestDigest1.String())
So(repoMeta.Tags[tag2].Digest, ShouldEqual, manifestDigest2.String())
})
Convey("Set multiple repos", func() {
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repoMeta1, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
repoMeta2, err := metaDB.GetRepoMeta(repo2)
So(err, ShouldBeNil)
So(repoMeta1.Tags[tag1].Digest, ShouldResemble, manifestDigest1.String())
So(repoMeta2.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
Convey("Setting a repo with invalid fields", func() {
Convey("Repo name is not valid", func() {
err := metaDB.SetRepoReference("", tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldNotBeNil)
})
Convey("Tag is not valid", func() {
err := metaDB.SetRepoReference(repo1, "", manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldNotBeNil)
})
Convey("Manifest Digest is not valid", func() {
err := metaDB.SetRepoReference(repo1, tag1, "", ispec.MediaTypeImageManifest)
So(err, ShouldNotBeNil)
})
})
})
Convey("Test GetRepoMeta", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
repo2 = "repo2"
tag2 = "0.0.2"
manifestDigest2 = godigest.FromString("fake-manifest2")
InexistentRepo = "InexistentRepo"
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
Convey("Get a existent repo", func() {
repoMeta1, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta1.Tags[tag1].Digest, ShouldResemble, manifestDigest1.String())
repoMeta2, err := metaDB.GetRepoMeta(repo2)
So(err, ShouldBeNil)
So(repoMeta2.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
Convey("Get a repo that doesn't exist", func() {
repoMeta, err := metaDB.GetRepoMeta(InexistentRepo)
So(err, ShouldNotBeNil)
So(repoMeta, ShouldBeZeroValue)
})
})
Convey("Test RemoveRepoReference and DeleteRepoTag", func() {
var (
repo = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
tag2 = "0.0.2"
manifestDigest2 = godigest.FromString("fake-manifest2")
)
err := metaDB.SetRepoReference(repo, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo, tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
Convey("Delete reference from repo", func() {
_, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
err = metaDB.RemoveRepoReference(repo, tag1, manifestDigest1)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
_, ok := repoMeta.Tags[tag1]
So(ok, ShouldBeFalse)
So(repoMeta.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
Convey("Delete a reference from repo", func() {
_, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
// shouldn't do anything because there is tag1 pointing to it
err = metaDB.RemoveRepoReference(repo, manifestDigest1.String(), manifestDigest1)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
_, ok := repoMeta.Tags[tag1]
So(ok, ShouldBeFalse)
So(repoMeta.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
Convey("Delete inexistent reference from repo", func() {
inexistentDigest := godigest.FromBytes([]byte("inexistent"))
err := metaDB.RemoveRepoReference(repo, inexistentDigest.String(), inexistentDigest)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
So(repoMeta.Tags[tag1].Digest, ShouldResemble, manifestDigest1.String())
So(repoMeta.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
Convey("Delete reference from inexistent repo", func() {
inexistentDigest := godigest.FromBytes([]byte("inexistent"))
err := metaDB.RemoveRepoReference("InexistentRepo", inexistentDigest.String(), inexistentDigest)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
So(repoMeta.Tags[tag1].Digest, ShouldResemble, manifestDigest1.String())
So(repoMeta.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
Convey("Delete from repo a tag", func() {
_, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
err = metaDB.DeleteRepoTag(repo, tag1)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
_, ok := repoMeta.Tags[tag1]
So(ok, ShouldBeFalse)
So(repoMeta.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
Convey("Delete inexistent tag from repo", func() {
err := metaDB.DeleteRepoTag(repo, "InexistentTag")
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
So(repoMeta.Tags[tag1].Digest, ShouldResemble, manifestDigest1.String())
So(repoMeta.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
Convey("Delete tag from inexistent repo", func() {
err := metaDB.DeleteRepoTag("InexistentRepo", "InexistentTag")
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
So(repoMeta.Tags[tag1].Digest, ShouldResemble, manifestDigest1.String())
So(repoMeta.Tags[tag2].Digest, ShouldResemble, manifestDigest2.String())
})
})
Convey("Test GetMultipleRepoMeta", func() {
var (
repo1 = "repo1"
repo2 = "repo2"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
tag2 = "0.0.2"
manifestDigest2 = godigest.FromString("fake-manifest2")
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
Convey("Get all Repometa", func() {
repoMetaSlice, err := metaDB.GetMultipleRepoMeta(context.TODO(), func(repoMeta mTypes.RepoMetadata) bool {
return true
})
So(err, ShouldBeNil)
So(len(repoMetaSlice), ShouldEqual, 2)
})
Convey("Get repo with a tag", func() {
repoMetaSlice, err := metaDB.GetMultipleRepoMeta(context.TODO(), func(repoMeta mTypes.RepoMetadata) bool {
for tag := range repoMeta.Tags {
if tag == tag1 {
return true
}
}
return false
})
So(err, ShouldBeNil)
So(len(repoMetaSlice), ShouldEqual, 1)
So(repoMetaSlice[0].Tags[tag1].Digest == manifestDigest1.String(), ShouldBeTrue)
})
})
Convey("Test IncrementRepoStars", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.IncrementRepoStars(repo1)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 1)
err = metaDB.IncrementRepoStars(repo1)
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 2)
err = metaDB.IncrementRepoStars(repo1)
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 3)
})
Convey("Test DecrementRepoStars", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.IncrementRepoStars(repo1)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 1)
err = metaDB.DecrementRepoStars(repo1)
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 0)
err = metaDB.DecrementRepoStars(repo1)
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 0)
_, err = metaDB.GetRepoMeta("badRepo")
So(err, ShouldNotBeNil)
})
Convey("Test GetRepoStars", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.IncrementRepoStars(repo1)
So(err, ShouldBeNil)
stars, err := metaDB.GetRepoStars(repo1)
So(err, ShouldBeNil)
So(stars, ShouldEqual, 1)
err = metaDB.IncrementRepoStars(repo1)
So(err, ShouldBeNil)
err = metaDB.IncrementRepoStars(repo1)
So(err, ShouldBeNil)
stars, err = metaDB.GetRepoStars(repo1)
So(err, ShouldBeNil)
So(stars, ShouldEqual, 3)
_, err = metaDB.GetRepoStars("badRepo")
So(err, ShouldNotBeNil)
})
Convey("Test repo stars for user", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
repo2 = "repo2"
)
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("user1")
userAc.SetGlobPatterns("read", map[string]bool{
repo1: true,
repo2: true,
})
// "user1"
ctx1 := userAc.DeriveContext(context.Background())
userAc = reqCtx.NewUserAccessControl()
userAc.SetUsername("user2")
userAc.SetGlobPatterns("read", map[string]bool{
repo1: true,
repo2: true,
})
// "user2"
ctx2 := userAc.DeriveContext(context.Background())
userAc = reqCtx.NewUserAccessControl()
userAc.SetGlobPatterns("read", map[string]bool{
repo1: true,
repo2: true,
})
// anonymous user
ctx3 := userAc.DeriveContext(context.Background())
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
starCount, err := metaDB.GetRepoStars(repo1)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 0)
starCount, err = metaDB.GetRepoStars(repo2)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 0)
repos, err := metaDB.GetStarredRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
repos, err = metaDB.GetStarredRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
repos, err = metaDB.GetStarredRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// User 1 bookmarks repo 1, User 2 has no stars
toggleState, err := metaDB.ToggleStarRepo(ctx1, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Added)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 1)
starCount, err = metaDB.GetRepoStars(repo1)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 1)
repos, err = metaDB.GetStarredRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
repos, err = metaDB.GetStarredRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
repos, err = metaDB.GetStarredRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// User 1 and User 2 star only repo 1
toggleState, err = metaDB.ToggleStarRepo(ctx2, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Added)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 2)
starCount, err = metaDB.GetRepoStars(repo1)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 2)
repos, err = metaDB.GetStarredRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
repos, err = metaDB.GetStarredRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
repos, err = metaDB.GetStarredRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// User 1 stars repos 1 and 2, and User 2 stars only repo 1
toggleState, err = metaDB.ToggleStarRepo(ctx1, repo2)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Added)
repoMeta, err = metaDB.GetRepoMeta(repo2)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 1)
starCount, err = metaDB.GetRepoStars(repo2)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 1)
repos, err = metaDB.GetStarredRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 2)
So(repos, ShouldContain, repo1)
So(repos, ShouldContain, repo2)
repos, err = metaDB.GetStarredRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
repos, err = metaDB.GetStarredRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// User 1 stars only repo 2, and User 2 stars only repo 1
toggleState, err = metaDB.ToggleStarRepo(ctx1, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Removed)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 1)
starCount, err = metaDB.GetRepoStars(repo1)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 1)
repos, err = metaDB.GetStarredRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo2)
repos, err = metaDB.GetStarredRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
repos, err = metaDB.GetStarredRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// User 1 stars both repos 1 and 2, and User 2 removes all stars
toggleState, err = metaDB.ToggleStarRepo(ctx1, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Added)
toggleState, err = metaDB.ToggleStarRepo(ctx2, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Removed)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 1)
repoMeta, err = metaDB.GetRepoMeta(repo2)
So(err, ShouldBeNil)
So(repoMeta.Stars, ShouldEqual, 1)
starCount, err = metaDB.GetRepoStars(repo1)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 1)
starCount, err = metaDB.GetRepoStars(repo2)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 1)
repos, err = metaDB.GetStarredRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 2)
So(repos, ShouldContain, repo1)
So(repos, ShouldContain, repo2)
repos, err = metaDB.GetStarredRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
repos, err = metaDB.GetStarredRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// Anonyous user attempts to toggle a star
toggleState, err = metaDB.ToggleStarRepo(ctx3, repo1)
So(err, ShouldNotBeNil)
So(toggleState, ShouldEqual, mTypes.NotChanged)
starCount, err = metaDB.GetRepoStars(repo1)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 1)
repos, err = metaDB.GetStarredRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// User 1 stars just repo 1
toggleState, err = metaDB.ToggleStarRepo(ctx1, repo2)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Removed)
starCount, err = metaDB.GetRepoStars(repo2)
So(err, ShouldBeNil)
So(starCount, ShouldEqual, 0)
repos, err = metaDB.GetStarredRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
})
Convey("Test repo bookmarks for user", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
repo2 = "repo2"
)
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("user1")
userAc.SetGlobPatterns("read", map[string]bool{
repo1: true,
repo2: true,
})
// "user1"
ctx1 := userAc.DeriveContext(context.Background())
userAc = reqCtx.NewUserAccessControl()
userAc.SetUsername("user2")
userAc.SetGlobPatterns("read", map[string]bool{
repo1: true,
repo2: true,
})
// "user2"
ctx2 := userAc.DeriveContext(context.Background())
userAc = reqCtx.NewUserAccessControl()
userAc.SetGlobPatterns("read", map[string]bool{
repo1: true,
repo2: true,
})
// anonymous user
ctx3 := userAc.DeriveContext(context.Background())
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repos, err := metaDB.GetBookmarkedRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
repos, err = metaDB.GetBookmarkedRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// anonymous cannot use bookmarks
repos, err = metaDB.GetBookmarkedRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
toggleState, err := metaDB.ToggleBookmarkRepo(ctx3, repo1)
So(err, ShouldNotBeNil)
So(toggleState, ShouldEqual, mTypes.NotChanged)
repos, err = metaDB.GetBookmarkedRepos(ctx3)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// User 1 bookmarks repo 1, User 2 has no bookmarks
toggleState, err = metaDB.ToggleBookmarkRepo(ctx1, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Added)
repos, err = metaDB.GetBookmarkedRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
repos, err = metaDB.GetBookmarkedRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
// User 1 and User 2 bookmark only repo 1
toggleState, err = metaDB.ToggleBookmarkRepo(ctx2, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Added)
repos, err = metaDB.GetBookmarkedRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
repos, err = metaDB.GetBookmarkedRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
// User 1 bookmarks repos 1 and 2, and User 2 bookmarks only repo 1
toggleState, err = metaDB.ToggleBookmarkRepo(ctx1, repo2)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Added)
repos, err = metaDB.GetBookmarkedRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 2)
So(repos, ShouldContain, repo1)
So(repos, ShouldContain, repo2)
repos, err = metaDB.GetBookmarkedRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
// User 1 bookmarks only repo 2, and User 2 bookmarks only repo 1
toggleState, err = metaDB.ToggleBookmarkRepo(ctx1, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Removed)
repos, err = metaDB.GetBookmarkedRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo2)
repos, err = metaDB.GetBookmarkedRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos, ShouldContain, repo1)
// User 1 bookmarks both repos 1 and 2, and User 2 removes all bookmarks
toggleState, err = metaDB.ToggleBookmarkRepo(ctx1, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Added)
toggleState, err = metaDB.ToggleBookmarkRepo(ctx2, repo1)
So(err, ShouldBeNil)
So(toggleState, ShouldEqual, mTypes.Removed)
repos, err = metaDB.GetBookmarkedRepos(ctx1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 2)
So(repos, ShouldContain, repo1)
So(repos, ShouldContain, repo2)
repos, err = metaDB.GetBookmarkedRepos(ctx2)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
})
Convey("Test IncrementImageDownloads", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
)
configBlob, manifestBlob, err := generateTestImage()
So(err, ShouldBeNil)
manifestDigest := godigest.FromBytes(manifestBlob)
err = metaDB.SetRepoReference(repo1, tag1, manifestDigest, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest, mTypes.ManifestMetadata{
ManifestBlob: manifestBlob,
ConfigBlob: configBlob,
})
So(err, ShouldBeNil)
err = metaDB.IncrementImageDownloads(repo1, tag1)
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Statistics[manifestDigest.String()].DownloadCount, ShouldEqual, 1)
err = metaDB.IncrementImageDownloads(repo1, tag1)
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Statistics[manifestDigest.String()].DownloadCount, ShouldEqual, 2)
_, err = metaDB.GetManifestMeta(repo1, "badManiestDigest")
So(err, ShouldNotBeNil)
})
Convey("Test AddImageSignature", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, mTypes.ManifestMetadata{})
So(err, ShouldBeNil)
err = metaDB.AddManifestSignature(repo1, manifestDigest1, mTypes.SignatureMetadata{
SignatureType: "cosign",
SignatureDigest: "digest",
})
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Signatures[manifestDigest1.String()]["cosign"][0].SignatureManifestDigest,
ShouldResemble, "digest")
_, err = metaDB.GetManifestMeta(repo1, "badDigest")
So(err, ShouldNotBeNil)
})
Convey("Test UpdateSignaturesValidity", func() {
Convey("untrusted signature", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("dig")
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, mTypes.ManifestMetadata{
ManifestBlob: []byte("Bad Manifest"),
ConfigBlob: []byte("Bad Manifest"),
})
So(err, ShouldBeNil)
layerInfo := mTypes.LayerInfo{LayerDigest: "", LayerContent: []byte{}, SignatureKey: ""}
err = metaDB.AddManifestSignature(repo1, manifestDigest1, mTypes.SignatureMetadata{
SignatureType: "cosign",
SignatureDigest: string(manifestDigest1),
LayersInfo: []mTypes.LayerInfo{layerInfo},
})
So(err, ShouldBeNil)
err = metaDB.UpdateSignaturesValidity(repo1, manifestDigest1)
So(err, ShouldBeNil)
repoData, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoData.Signatures[string(manifestDigest1)]["cosign"][0].LayersInfo[0].Signer,
ShouldBeEmpty)
So(repoData.Signatures[string(manifestDigest1)]["cosign"][0].LayersInfo[0].Date,
ShouldBeZeroValue)
})
Convey("trusted signature", func() {
_, _, manifest, _ := test.GetRandomImageComponents(10) //nolint:staticcheck
manifestContent, _ := json.Marshal(manifest)
manifestDigest := godigest.FromBytes(manifestContent)
repo := "repo"
tag := "0.0.1"
err := metaDB.SetRepoReference(repo, tag, manifestDigest, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo, manifestDigest, mTypes.ManifestMetadata{
ManifestBlob: manifestContent,
ConfigBlob: []byte("configContent"),
})
So(err, ShouldBeNil)
mediaType := jws.MediaTypeEnvelope
signOpts := notation.SignerSignOptions{
SignatureMediaType: mediaType,
PluginConfig: map[string]string{},
ExpiryDuration: 24 * time.Hour,
}
tdir := t.TempDir()
uuid, err := guuid.NewV4()
So(err, ShouldBeNil)
keyName := fmt.Sprintf("notation-sign-test-%s", uuid)
test.NotationPathLock.Lock()
defer test.NotationPathLock.Unlock()
test.LoadNotationPath(tdir)
err = test.GenerateNotationCerts(tdir, keyName)
So(err, ShouldBeNil)
// getSigner
var newSigner notation.Signer
// ResolveKey
signingKeys, err := test.LoadNotationSigningkeys(tdir)
So(err, ShouldBeNil)
idx := test.Index(signingKeys.Keys, keyName)
So(idx, ShouldBeGreaterThanOrEqualTo, 0)
key := signingKeys.Keys[idx]
if key.X509KeyPair != nil {
newSigner, err = signer.NewFromFiles(key.X509KeyPair.KeyPath, key.X509KeyPair.CertificatePath)
So(err, ShouldBeNil)
}
descToSign := ispec.Descriptor{
MediaType: manifest.MediaType,
Digest: manifestDigest,
Size: int64(len(manifestContent)),
}
ctx := context.Background()
sig, _, err := newSigner.Sign(ctx, descToSign, signOpts)
So(err, ShouldBeNil)
layerInfo := mTypes.LayerInfo{
LayerDigest: string(godigest.FromBytes(sig)),
LayerContent: sig, SignatureKey: mediaType,
}
err = metaDB.AddManifestSignature(repo, manifestDigest, mTypes.SignatureMetadata{
SignatureType: "notation",
SignatureDigest: string(godigest.FromString("signature digest")),
LayersInfo: []mTypes.LayerInfo{layerInfo},
})
So(err, ShouldBeNil)
certificateContent, err := os.ReadFile(path.Join(
tdir,
"notation/localkeys",
fmt.Sprintf("%s.crt", keyName),
))
So(err, ShouldBeNil)
So(certificateContent, ShouldNotBeNil)
imgTrustStore, ok := metaDB.ImageTrustStore().(*imagetrust.ImageTrustStore)
So(ok, ShouldBeTrue)
err = imagetrust.UploadCertificate(imgTrustStore.NotationStorage, certificateContent, "ca")
So(err, ShouldBeNil)
err = metaDB.UpdateSignaturesValidity(repo, manifestDigest) //nolint:contextcheck
So(err, ShouldBeNil)
repoData, err := metaDB.GetRepoMeta(repo)
So(err, ShouldBeNil)
So(repoData.Signatures[string(manifestDigest)]["notation"][0].LayersInfo[0].Signer,
ShouldNotBeEmpty)
So(repoData.Signatures[string(manifestDigest)]["notation"][0].LayersInfo[0].Date,
ShouldNotBeZeroValue)
})
})
Convey("Test AddImageSignature with inverted order", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
)
err := metaDB.AddManifestSignature(repo1, manifestDigest1, mTypes.SignatureMetadata{
SignatureType: "cosign",
SignatureDigest: "digest",
})
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestDigest1, mTypes.ManifestData{})
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Signatures[manifestDigest1.String()]["cosign"][0].SignatureManifestDigest,
ShouldResemble, "digest")
_, err = metaDB.GetManifestMeta(repo1, "badDigest")
So(err, ShouldNotBeNil)
})
Convey("Test DeleteSignature", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestDigest1, mTypes.ManifestData{})
So(err, ShouldBeNil)
err = metaDB.AddManifestSignature(repo1, manifestDigest1, mTypes.SignatureMetadata{
SignatureType: "cosign",
SignatureDigest: "digest",
})
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Signatures[manifestDigest1.String()]["cosign"][0].SignatureManifestDigest,
ShouldResemble, "digest")
err = metaDB.DeleteSignature(repo1, manifestDigest1, mTypes.SignatureMetadata{
SignatureType: "cosign",
SignatureDigest: "digest",
})
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta(repo1)
So(err, ShouldBeNil)
So(repoMeta.Signatures[manifestDigest1.String()]["cosign"], ShouldBeEmpty)
err = metaDB.DeleteSignature(repo1, "badDigest", mTypes.SignatureMetadata{
SignatureType: "cosign",
SignatureDigest: "digest",
})
So(err, ShouldNotBeNil)
})
Convey("Test SearchRepos", func() {
var (
repo1 = "repo1"
repo2 = "repo2"
repo3 = "repo3"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
tag2 = "0.0.2"
manifestDigest2 = godigest.FromString("fake-manifest2")
tag3 = "0.0.3"
manifestDigest3 = godigest.FromString("fake-manifest3")
ctx = context.Background()
emptyManifest ispec.Manifest
emptyConfig ispec.Manifest
)
emptyManifestBlob, err := json.Marshal(emptyManifest)
So(err, ShouldBeNil)
emptyConfigBlob, err := json.Marshal(emptyConfig)
So(err, ShouldBeNil)
emptyRepoMeta := mTypes.ManifestMetadata{
ManifestBlob: emptyManifestBlob,
ConfigBlob: emptyConfigBlob,
}
Convey("Search all repos", func() {
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag3, manifestDigest3, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest2, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest3, emptyRepoMeta)
So(err, ShouldBeNil)
repos, manifestMetaMap, _, err := metaDB.SearchRepos(ctx, "")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 2)
So(len(manifestMetaMap), ShouldEqual, 3)
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest2.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest3.String())
})
Convey("Search a repo by name", func() {
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
repos, manifestMetaMap, _, err := metaDB.SearchRepos(ctx, repo1)
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(len(manifestMetaMap), ShouldEqual, 1)
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
})
Convey("Search non-existing repo by name", func() {
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repos, manifestMetaMap, _, err := metaDB.SearchRepos(ctx, "RepoThatDoesntExist")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
So(len(manifestMetaMap), ShouldEqual, 0)
})
Convey("Search with partial match", func() {
err := metaDB.SetRepoReference("alpine", tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("pine", tag2, manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("golang", tag3, manifestDigest3, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta("alpine", manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta("pine", manifestDigest2, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta("golang", manifestDigest3, emptyRepoMeta)
So(err, ShouldBeNil)
repos, manifestMetaMap, _, err := metaDB.SearchRepos(ctx, "pine")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 2)
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest2.String())
So(manifestMetaMap, ShouldNotContainKey, manifestDigest3.String())
})
Convey("Search multiple repos that share manifests", func() {
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag2, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo3, tag3, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo2, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo3, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
repos, manifestMetaMap, _, err := metaDB.SearchRepos(ctx, "")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 3)
So(len(manifestMetaMap), ShouldEqual, 1)
})
Convey("Search repos with access control", func() {
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag2, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo3, tag3, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo2, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo3, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("username")
userAc.SetGlobPatterns("read", map[string]bool{
repo1: true,
repo2: true,
})
ctx := userAc.DeriveContext(context.Background())
repos, _, _, err := metaDB.SearchRepos(ctx, "repo")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 2)
for _, k := range repos {
So(k.Name, ShouldBeIn, []string{repo1, repo2})
}
})
Convey("Search Repos with Indexes", func() {
var (
tag4 = "0.0.4"
indexDigest = godigest.FromString("Multiarch")
manifestDigest1 = godigest.FromString("manifestDigest1")
manifestDigest2 = godigest.FromString("manifestDigest2")
tag5 = "0.0.5"
manifestDigest3 = godigest.FromString("manifestDigest3")
)
err := metaDB.SetManifestData(manifestDigest1, mTypes.ManifestData{
ManifestBlob: []byte("{}"),
ConfigBlob: []byte("{}"),
})
So(err, ShouldBeNil)
config := ispec.Image{
Platform: ispec.Platform{
Architecture: "arch",
OS: "os",
},
}
confBlob, err := json.Marshal(config)
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestDigest2, mTypes.ManifestData{
ManifestBlob: []byte("{}"),
ConfigBlob: confBlob,
})
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestDigest3, mTypes.ManifestData{
ManifestBlob: []byte("{}"),
ConfigBlob: []byte("{}"),
})
So(err, ShouldBeNil)
indexContent := ispec.Index{
MediaType: ispec.MediaTypeImageIndex,
Manifests: []ispec.Descriptor{
{
Digest: manifestDigest1,
},
{
Digest: manifestDigest2,
},
},
}
indexBlob, err := json.Marshal(indexContent)
So(err, ShouldBeNil)
err = metaDB.SetIndexData(indexDigest, mTypes.IndexData{
IndexBlob: indexBlob,
})
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("repo", tag4, indexDigest, ispec.MediaTypeImageIndex)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("repo", tag5, manifestDigest3, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repos, manifestMetaMap, indexDataMap, err := metaDB.SearchRepos(ctx, "repo")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos[0].Name, ShouldResemble, "repo")
So(repos[0].Tags, ShouldContainKey, tag4)
So(repos[0].Tags, ShouldContainKey, tag5)
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest2.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest3.String())
So(indexDataMap, ShouldContainKey, indexDigest.String())
})
})
Convey("Test SearchTags", func() {
var (
repo1 = "repo1"
repo2 = "repo2"
manifestDigest1 = godigest.FromString("fake-manifest1")
manifestDigest2 = godigest.FromString("fake-manifest2")
manifestDigest3 = godigest.FromString("fake-manifest3")
ctx = context.Background()
emptyManifest ispec.Manifest
emptyConfig ispec.Manifest
)
emptyManifestBlob, err := json.Marshal(emptyManifest)
So(err, ShouldBeNil)
emptyConfigBlob, err := json.Marshal(emptyConfig)
So(err, ShouldBeNil)
emptyRepoMeta := mTypes.ManifestMetadata{
ManifestBlob: emptyManifestBlob,
ConfigBlob: emptyConfigBlob,
}
err = metaDB.SetRepoReference(repo1, "0.0.1", manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "0.0.2", manifestDigest3, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "0.1.0", manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "1.0.0", manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "1.0.1", manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, "0.0.1", manifestDigest3, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest2, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest3, emptyRepoMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo2, manifestDigest3, emptyRepoMeta)
So(err, ShouldBeNil)
Convey("With exact match", func() {
repos, manifestMetaMap, _, err := metaDB.SearchTags(ctx, "repo1:0.0.1")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(len(repos[0].Tags), ShouldEqual, 1)
So(repos[0].Tags, ShouldContainKey, "0.0.1")
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
})
Convey("With no match", func() {
repos, _, _, err := metaDB.SearchTags(ctx, "repo1:badtag")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
})
Convey("With no permision", func() {
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("user1")
userAc.SetGlobPatterns("read",
map[string]bool{
repo1: false,
repo2: false,
},
)
ctx1 := userAc.DeriveContext(context.Background())
repos, _, _, err := metaDB.SearchTags(ctx1, "repo1:0.0.1")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
})
Convey("With partial repo path", func() {
repos, manifestMetaMap, _, err := metaDB.SearchTags(ctx, "repo:0.0.1")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
So(len(manifestMetaMap), ShouldEqual, 0)
})
Convey("With partial tag", func() {
repos, manifestMetaMap, _, err := metaDB.SearchTags(ctx, "repo1:0.0")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(len(repos[0].Tags), ShouldEqual, 2)
So(repos[0].Tags, ShouldContainKey, "0.0.2")
So(repos[0].Tags, ShouldContainKey, "0.0.1")
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest3.String())
repos, manifestMetaMap, _, err = metaDB.SearchTags(ctx, "repo1:0.")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(len(repos[0].Tags), ShouldEqual, 3)
So(repos[0].Tags, ShouldContainKey, "0.0.1")
So(repos[0].Tags, ShouldContainKey, "0.0.2")
So(repos[0].Tags, ShouldContainKey, "0.1.0")
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest2.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest3.String())
})
Convey("With bad query", func() {
repos, manifestMetaMap, _, err := metaDB.SearchTags(ctx, "repo:0.0.1:test")
So(err, ShouldNotBeNil)
So(len(repos), ShouldEqual, 0)
So(len(manifestMetaMap), ShouldEqual, 0)
})
Convey("Search with access control", func() {
var (
repo1 = "repo1"
repo2 = "repo2"
repo3 = "repo3"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
tag2 = "0.0.2"
tag3 = "0.0.3"
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, tag2, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo3, tag3, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
config := ispec.Image{}
configBlob, err := json.Marshal(config)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, mTypes.ManifestMetadata{ConfigBlob: configBlob})
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo2, manifestDigest1, mTypes.ManifestMetadata{ConfigBlob: configBlob})
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo3, manifestDigest1, mTypes.ManifestMetadata{ConfigBlob: configBlob})
So(err, ShouldBeNil)
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("username")
userAc.SetGlobPatterns("read", map[string]bool{
repo1: true,
repo2: false,
})
ctx := userAc.DeriveContext(context.Background())
repos, _, _, err := metaDB.SearchTags(ctx, "repo1:")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos[0].Name, ShouldResemble, repo1)
repos, _, _, err = metaDB.SearchTags(ctx, "repo2:")
So(err, ShouldBeNil)
So(repos, ShouldBeEmpty)
})
Convey("Search Tags with Indexes", func() {
var (
tag4 = "0.0.4"
indexDigest = godigest.FromString("Multiarch")
manifestDigest1 = godigest.FromString("manifestDigest1")
manifestDigest2 = godigest.FromString("manifestDigest2")
tag5 = "0.0.5"
manifestDigest3 = godigest.FromString("manifestDigest3")
tag6 = "6.0.0"
manifestDigest4 = godigest.FromString("manifestDigest4")
)
err := metaDB.SetManifestData(manifestDigest1, mTypes.ManifestData{
ManifestBlob: []byte("{}"),
ConfigBlob: []byte("{}"),
})
So(err, ShouldBeNil)
config := ispec.Image{
Platform: ispec.Platform{
Architecture: "arch",
OS: "os",
},
}
confBlob, err := json.Marshal(config)
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestDigest2, mTypes.ManifestData{
ManifestBlob: []byte("{}"),
ConfigBlob: confBlob,
})
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestDigest3, mTypes.ManifestData{
ManifestBlob: []byte("{}"),
ConfigBlob: []byte("{}"),
})
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestDigest4, mTypes.ManifestData{
ManifestBlob: []byte("{}"),
ConfigBlob: []byte("{}"),
})
So(err, ShouldBeNil)
indexBlob, err := test.GetIndexBlobWithManifests(
[]godigest.Digest{
manifestDigest1,
manifestDigest2,
},
)
So(err, ShouldBeNil)
err = metaDB.SetIndexData(indexDigest, mTypes.IndexData{
IndexBlob: indexBlob,
})
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("repo", tag4, indexDigest, ispec.MediaTypeImageIndex)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("repo", tag5, manifestDigest3, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("repo", tag6, manifestDigest4, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repos, manifestMetaMap, indexDataMap, err := metaDB.SearchTags(ctx, "repo:0.0")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos[0].Name, ShouldResemble, "repo")
So(repos[0].Tags, ShouldContainKey, tag4)
So(repos[0].Tags, ShouldContainKey, tag5)
So(repos[0].Tags, ShouldNotContainKey, tag6)
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest2.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest3.String())
So(manifestMetaMap, ShouldNotContainKey, manifestDigest4.String())
So(indexDataMap, ShouldContainKey, indexDigest.String())
})
})
Convey("Paginated tag search", func() {
var (
repo1 = "repo1"
tag1 = "0.0.1"
manifestDigest1 = godigest.FromString("fake-manifest1")
tag2 = "0.0.2"
tag3 = "0.0.3"
tag4 = "0.0.4"
tag5 = "0.0.5"
)
err := metaDB.SetRepoReference(repo1, tag1, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag2, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag3, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag4, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, tag5, manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
config := ispec.Image{}
configBlob, err := json.Marshal(config)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, mTypes.ManifestMetadata{ConfigBlob: configBlob})
So(err, ShouldBeNil)
repos, _, _, err := metaDB.SearchTags(context.TODO(), "repo1:")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
keys := make([]string, 0, len(repos[0].Tags))
for k := range repos[0].Tags {
keys = append(keys, k)
}
repos, _, _, err = metaDB.SearchTags(context.TODO(), "repo1:")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
for k := range repos[0].Tags {
keys = append(keys, k)
}
repos, _, _, err = metaDB.SearchTags(context.TODO(), "repo1:")
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
for k := range repos[0].Tags {
keys = append(keys, k)
}
So(keys, ShouldContain, tag1)
So(keys, ShouldContain, tag2)
So(keys, ShouldContain, tag3)
})
Convey("Test FilterTags", func() {
var (
repo1 = "repo1"
repo2 = "repo2"
manifestDigest1 = godigest.FromString("fake-manifest1")
manifestDigest2 = godigest.FromString("fake-manifest2")
manifestDigest3 = godigest.FromString("fake-manifest3")
indexDigest = godigest.FromString("index-digest")
manifestFromIndexDigest1 = godigest.FromString("fake-manifestFromIndexDigest1")
manifestFromIndexDigest2 = godigest.FromString("fake-manifestFromIndexDigest2")
emptyManifest ispec.Manifest
emptyConfig ispec.Image
ctx = context.Background()
)
emptyManifestBlob, err := json.Marshal(emptyManifest)
So(err, ShouldBeNil)
emptyConfigBlob, err := json.Marshal(emptyConfig)
So(err, ShouldBeNil)
emptyManifestMeta := mTypes.ManifestMetadata{
ManifestBlob: emptyManifestBlob,
ConfigBlob: emptyConfigBlob,
}
emptyManifestData := mTypes.ManifestData{
ManifestBlob: emptyManifestBlob,
ConfigBlob: emptyConfigBlob,
}
err = metaDB.SetRepoReference(repo1, "2.0.0", indexDigest, ispec.MediaTypeImageIndex)
So(err, ShouldBeNil)
indexBlob, err := test.GetIndexBlobWithManifests([]godigest.Digest{
manifestFromIndexDigest1,
manifestFromIndexDigest2,
})
So(err, ShouldBeNil)
err = metaDB.SetIndexData(indexDigest, mTypes.IndexData{
IndexBlob: indexBlob,
})
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "0.0.1", manifestDigest1, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "0.0.2", manifestDigest3, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "0.1.0", manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "1.0.0", manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo1, "1.0.1", manifestDigest2, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo2, "0.0.1", manifestDigest3, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest1, emptyManifestMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest2, emptyManifestMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo1, manifestDigest3, emptyManifestMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestMeta(repo2, manifestDigest3, emptyManifestMeta)
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestFromIndexDigest1, emptyManifestData)
So(err, ShouldBeNil)
err = metaDB.SetManifestData(manifestFromIndexDigest2, emptyManifestData)
So(err, ShouldBeNil)
Convey("Return all tags", func() {
repos, manifestMetaMap, indexDataMap, err := metaDB.FilterTags(ctx,
func(repoMeta mTypes.RepoMetadata, manifestMeta mTypes.ManifestMetadata) bool {
return true
})
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 2)
So(repos[0].Name, ShouldEqual, "repo1")
So(repos[1].Name, ShouldEqual, "repo2")
So(len(repos[0].Tags), ShouldEqual, 6)
So(len(repos[1].Tags), ShouldEqual, 1)
So(repos[0].Tags, ShouldContainKey, "0.0.1")
So(repos[0].Tags, ShouldContainKey, "0.0.2")
So(repos[0].Tags, ShouldContainKey, "0.1.0")
So(repos[0].Tags, ShouldContainKey, "1.0.0")
So(repos[0].Tags, ShouldContainKey, "1.0.1")
So(repos[0].Tags, ShouldContainKey, "2.0.0")
So(repos[1].Tags, ShouldContainKey, "0.0.1")
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest2.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest3.String())
So(indexDataMap, ShouldContainKey, indexDigest.String())
So(manifestMetaMap, ShouldContainKey, manifestFromIndexDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestFromIndexDigest2.String())
})
Convey("Return all tags in a specific repo", func() {
repos, manifestMetaMap, indexDataMap, err := metaDB.FilterTags(
ctx,
func(repoMeta mTypes.RepoMetadata, manifestMeta mTypes.ManifestMetadata) bool {
return repoMeta.Name == repo1
})
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos[0].Name, ShouldEqual, repo1)
So(len(repos[0].Tags), ShouldEqual, 6)
So(repos[0].Tags, ShouldContainKey, "0.0.1")
So(repos[0].Tags, ShouldContainKey, "0.0.2")
So(repos[0].Tags, ShouldContainKey, "0.1.0")
So(repos[0].Tags, ShouldContainKey, "1.0.0")
So(repos[0].Tags, ShouldContainKey, "1.0.1")
So(repos[0].Tags, ShouldContainKey, "2.0.0")
So(manifestMetaMap, ShouldContainKey, manifestDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest2.String())
So(manifestMetaMap, ShouldContainKey, manifestDigest3.String())
So(indexDataMap, ShouldContainKey, indexDigest.String())
So(manifestMetaMap, ShouldContainKey, manifestFromIndexDigest1.String())
So(manifestMetaMap, ShouldContainKey, manifestFromIndexDigest2.String())
})
Convey("Filter everything out", func() {
repos, manifestMetaMap, _, err := metaDB.FilterTags(
ctx,
func(repoMeta mTypes.RepoMetadata, manifestMeta mTypes.ManifestMetadata) bool {
return false
})
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 0)
So(len(manifestMetaMap), ShouldEqual, 0)
})
Convey("Search with access control", func() {
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("username")
userAc.SetGlobPatterns("read", map[string]bool{
repo1: false,
repo2: true,
})
ctx := userAc.DeriveContext(context.Background())
repos, manifestMetaMap, _, err := metaDB.FilterTags(ctx,
func(repoMeta mTypes.RepoMetadata, manifestMeta mTypes.ManifestMetadata) bool {
return true
})
So(err, ShouldBeNil)
So(len(repos), ShouldEqual, 1)
So(repos[0].Name, ShouldResemble, repo2)
So(len(repos[0].Tags), ShouldEqual, 1)
So(repos[0].Tags, ShouldContainKey, "0.0.1")
So(manifestMetaMap, ShouldContainKey, manifestDigest3.String())
})
})
Convey("Test index logic", func() {
multiArch, err := test.GetRandomMultiarchImage("tag1") //nolint:staticcheck
So(err, ShouldBeNil)
indexDigest := multiArch.Digest()
indexData := multiArch.IndexData()
err = metaDB.SetIndexData(indexDigest, indexData)
So(err, ShouldBeNil)
result, err := metaDB.GetIndexData(indexDigest)
So(err, ShouldBeNil)
So(result, ShouldResemble, indexData)
_, err = metaDB.GetIndexData(godigest.FromString("inexistent"))
So(err, ShouldNotBeNil)
})
Convey("Test Referrers", func() {
image, err := test.GetRandomImage() //nolint:staticcheck
So(err, ShouldBeNil)
referredDigest := image.Digest()
manifestBlob, err := json.Marshal(image.Manifest)
So(err, ShouldBeNil)
configBlob, err := json.Marshal(image.Config)
So(err, ShouldBeNil)
manifestData := mTypes.ManifestData{
ManifestBlob: manifestBlob,
ConfigBlob: configBlob,
}
err = metaDB.SetManifestData(referredDigest, manifestData)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("repo", "tag", referredDigest, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
// ------- Add Artifact 1
artifact1, err := test.GetImageWithSubject( //nolint:staticcheck
referredDigest,
ispec.MediaTypeImageManifest,
)
So(err, ShouldBeNil)
artifactDigest1 := artifact1.Digest()
err = metaDB.SetReferrer("repo", referredDigest, mTypes.ReferrerInfo{
Digest: artifactDigest1.String(),
MediaType: ispec.MediaTypeImageManifest,
})
So(err, ShouldBeNil)
// ------- Add Artifact 2
artifact2, err := test.GetImageWithSubject( //nolint:staticcheck
referredDigest,
ispec.MediaTypeImageManifest,
)
So(err, ShouldBeNil)
artifactDigest2 := artifact2.Digest()
err = metaDB.SetReferrer("repo", referredDigest, mTypes.ReferrerInfo{
Digest: artifactDigest2.String(),
MediaType: ispec.MediaTypeImageManifest,
})
So(err, ShouldBeNil)
// ------ GetReferrers
referrers, err := metaDB.GetReferrersInfo("repo", referredDigest, nil)
So(len(referrers), ShouldEqual, 2)
So(referrers, ShouldContain, mTypes.ReferrerInfo{
Digest: artifactDigest1.String(),
MediaType: ispec.MediaTypeImageManifest,
})
So(referrers, ShouldContain, mTypes.ReferrerInfo{
Digest: artifactDigest2.String(),
MediaType: ispec.MediaTypeImageManifest,
})
So(err, ShouldBeNil)
// ------ DeleteReferrers
err = metaDB.DeleteReferrer("repo", referredDigest, artifactDigest1)
So(err, ShouldBeNil)
err = metaDB.DeleteReferrer("repo", referredDigest, artifactDigest2)
So(err, ShouldBeNil)
referrers, err = metaDB.GetReferrersInfo("repo", referredDigest, nil)
So(err, ShouldBeNil)
So(len(referrers), ShouldEqual, 0)
})
Convey("Test Referrers on empty Repo", func() {
repoMeta, err := metaDB.GetRepoMeta("repo")
So(err, ShouldNotBeNil)
So(repoMeta, ShouldResemble, mTypes.RepoMetadata{})
referredDigest := godigest.FromString("referredDigest")
referrerDigest := godigest.FromString("referrerDigest")
err = metaDB.SetReferrer("repo", referredDigest, mTypes.ReferrerInfo{
Digest: referrerDigest.String(),
MediaType: ispec.MediaTypeImageManifest,
})
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta("repo")
So(err, ShouldBeNil)
So(repoMeta.Referrers[referredDigest.String()][0].Digest, ShouldResemble, referrerDigest.String())
})
Convey("Test Referrers add same one twice", func() {
repoMeta, err := metaDB.GetRepoMeta("repo")
So(err, ShouldNotBeNil)
So(repoMeta, ShouldResemble, mTypes.RepoMetadata{})
referredDigest := godigest.FromString("referredDigest")
referrerDigest := godigest.FromString("referrerDigest")
err = metaDB.SetReferrer("repo", referredDigest, mTypes.ReferrerInfo{
Digest: referrerDigest.String(),
MediaType: ispec.MediaTypeImageManifest,
})
So(err, ShouldBeNil)
err = metaDB.SetReferrer("repo", referredDigest, mTypes.ReferrerInfo{
Digest: referrerDigest.String(),
MediaType: ispec.MediaTypeImageManifest,
})
So(err, ShouldBeNil)
repoMeta, err = metaDB.GetRepoMeta("repo")
So(err, ShouldBeNil)
So(len(repoMeta.Referrers[referredDigest.String()]), ShouldEqual, 1)
})
Convey("GetReferrersInfo", func() {
referredDigest := godigest.FromString("referredDigest")
err := metaDB.SetReferrer("repo", referredDigest, mTypes.ReferrerInfo{
Digest: "inexistendManifestDigest",
MediaType: ispec.MediaTypeImageManifest,
})
So(err, ShouldBeNil)
// ------- Set existent manifest and artifact manifest
err = metaDB.SetManifestData("goodManifest", mTypes.ManifestData{
ManifestBlob: []byte(`{"artifactType": "unwantedType"}`),
ConfigBlob: []byte("{}"),
})
So(err, ShouldBeNil)
err = metaDB.SetReferrer("repo", referredDigest, mTypes.ReferrerInfo{
Digest: "goodManifestUnwanted",
MediaType: ispec.MediaTypeImageManifest,
ArtifactType: "unwantedType",
})
So(err, ShouldBeNil)
err = metaDB.SetReferrer("repo", referredDigest, mTypes.ReferrerInfo{
Digest: "goodManifest",
MediaType: ispec.MediaTypeImageManifest,
ArtifactType: "wantedType",
})
So(err, ShouldBeNil)
referrerInfo, err := metaDB.GetReferrersInfo("repo", referredDigest, []string{"wantedType"})
So(err, ShouldBeNil)
So(len(referrerInfo), ShouldEqual, 1)
So(referrerInfo[0].ArtifactType, ShouldResemble, "wantedType")
So(referrerInfo[0].Digest, ShouldResemble, "goodManifest")
})
Convey("FilterRepos", func() {
img, err := test.GetRandomImage() //nolint:staticcheck
So(err, ShouldBeNil)
imgDigest := img.Digest()
manifestData, err := NewManifestData(img.Manifest, img.Config)
So(err, ShouldBeNil)
err = metaDB.SetManifestData(imgDigest, manifestData)
So(err, ShouldBeNil)
multiarch, err := test.GetRandomMultiarchImage("multi") //nolint:staticcheck
So(err, ShouldBeNil)
multiarchDigest := multiarch.Digest()
indexData, err := NewIndexData(multiarch.Index)
So(err, ShouldBeNil)
err = metaDB.SetIndexData(multiarchDigest, indexData)
So(err, ShouldBeNil)
for _, img := range multiarch.Images {
digest := img.Digest()
indManData1, err := NewManifestData(multiarch.Images[0].Manifest, multiarch.Images[0].Config)
So(err, ShouldBeNil)
err = metaDB.SetManifestData(digest, indManData1)
So(err, ShouldBeNil)
}
err = metaDB.SetRepoReference("repo", img.DigestStr(), imgDigest, img.Manifest.MediaType)
So(err, ShouldBeNil)
err = metaDB.SetRepoReference("repo", multiarch.DigestStr(), multiarchDigest, ispec.MediaTypeImageIndex)
So(err, ShouldBeNil)
repoMetas, _, _, err := metaDB.FilterRepos(context.Background(),
func(repoMeta mTypes.RepoMetadata) bool { return true })
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
})
Convey("Test bookmarked/starred field present in returned RepoMeta", func() {
repo99 := "repo99"
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("user1")
userAc.SetGlobPatterns("read", map[string]bool{
repo99: true,
})
ctx := userAc.DeriveContext(context.Background())
manifestDigest := godigest.FromString("dig")
err := metaDB.SetManifestData(manifestDigest, mTypes.ManifestData{
ManifestBlob: []byte("{}"),
ConfigBlob: []byte("{}"),
})
So(err, ShouldBeNil)
err = metaDB.SetRepoReference(repo99, "tag", manifestDigest, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
repoMetas, _, _, err := metaDB.SearchRepos(ctx, repo99)
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
So(repoMetas[0].IsBookmarked, ShouldBeFalse)
So(repoMetas[0].IsStarred, ShouldBeFalse)
repoMetas, _, _, err = metaDB.SearchTags(ctx, repo99+":")
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
So(repoMetas[0].IsBookmarked, ShouldBeFalse)
So(repoMetas[0].IsStarred, ShouldBeFalse)
repoMetas, _, _, err = metaDB.FilterRepos(ctx, func(repoMeta mTypes.RepoMetadata) bool {
return true
})
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
So(repoMetas[0].IsBookmarked, ShouldBeFalse)
So(repoMetas[0].IsStarred, ShouldBeFalse)
repoMetas, _, _, err = metaDB.FilterTags(ctx,
func(repoMeta mTypes.RepoMetadata, manifestMeta mTypes.ManifestMetadata) bool { return true })
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
So(repoMetas[0].IsBookmarked, ShouldBeFalse)
So(repoMetas[0].IsStarred, ShouldBeFalse)
_, err = metaDB.ToggleBookmarkRepo(ctx, repo99)
So(err, ShouldBeNil)
_, err = metaDB.ToggleStarRepo(ctx, repo99)
So(err, ShouldBeNil)
repoMetas, _, _, err = metaDB.SearchRepos(ctx, repo99)
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
So(repoMetas[0].IsBookmarked, ShouldBeTrue)
So(repoMetas[0].IsStarred, ShouldBeTrue)
repoMetas, _, _, err = metaDB.SearchTags(ctx, repo99+":")
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
So(repoMetas[0].IsBookmarked, ShouldBeTrue)
So(repoMetas[0].IsStarred, ShouldBeTrue)
repoMetas, _, _, err = metaDB.FilterRepos(ctx, func(repoMeta mTypes.RepoMetadata) bool {
return true
})
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
So(repoMetas[0].IsBookmarked, ShouldBeTrue)
So(repoMetas[0].IsStarred, ShouldBeTrue)
repoMetas, _, _, err = metaDB.FilterTags(ctx,
func(repoMeta mTypes.RepoMetadata, manifestMeta mTypes.ManifestMetadata) bool { return true })
So(err, ShouldBeNil)
So(len(repoMetas), ShouldEqual, 1)
So(repoMetas[0].IsBookmarked, ShouldBeTrue)
So(repoMetas[0].IsStarred, ShouldBeTrue)
})
Convey("Test GetUserRepoMeta", func() {
userAc := reqCtx.NewUserAccessControl()
userAc.SetUsername("user1")
userAc.SetGlobPatterns("read", map[string]bool{
"repo": true,
})
ctx := userAc.DeriveContext(context.Background())
digest := godigest.FromString("1")
err := metaDB.SetRepoReference("repo", "tag", digest, ispec.MediaTypeImageManifest)
So(err, ShouldBeNil)
_, err = metaDB.ToggleBookmarkRepo(ctx, "repo")
So(err, ShouldBeNil)
_, err = metaDB.ToggleStarRepo(ctx, "repo")
So(err, ShouldBeNil)
repoMeta, err := metaDB.GetUserRepoMeta(ctx, "repo")
So(err, ShouldBeNil)
So(repoMeta.IsBookmarked, ShouldBeTrue)
So(repoMeta.IsStarred, ShouldBeTrue)
So(repoMeta.Tags, ShouldContainKey, "tag")
})
})
}
func NewManifestData(manifest ispec.Manifest, config ispec.Image) (mTypes.ManifestData, error) {
configBlob, err := json.Marshal(config)
if err != nil {
return mTypes.ManifestData{}, err
}
manifest.Config.Digest = godigest.FromBytes(configBlob)
manifestBlob, err := json.Marshal(manifest)
if err != nil {
return mTypes.ManifestData{}, err
}
return mTypes.ManifestData{ManifestBlob: manifestBlob, ConfigBlob: configBlob}, nil
}
func NewIndexData(index ispec.Index) (mTypes.IndexData, error) {
indexBlob, err := json.Marshal(index)
return mTypes.IndexData{IndexBlob: indexBlob}, err
}
func TestRelevanceSorting(t *testing.T) {
Convey("Test Relevance Sorting", t, func() {
So(common.RankRepoName("alpine", "alpine"), ShouldEqual, 0)
So(common.RankRepoName("test/alpine", "test/alpine"), ShouldEqual, 0)
So(common.RankRepoName("test/alpine", "alpine"), ShouldEqual, -1)
So(common.RankRepoName("alpine", "test/alpine"), ShouldEqual, 1)
So(common.RankRepoName("test", "test/alpine"), ShouldEqual, 10)
So(common.RankRepoName("pine", "test/alpine"), ShouldEqual, 3)
So(common.RankRepoName("pine", "alpine/alpine"), ShouldEqual, 3)
So(common.RankRepoName("pine", "alpine/test"), ShouldEqual, 30)
So(common.RankRepoName("test/pine", "alpine"), ShouldEqual, -1)
So(common.RankRepoName("repo/test", "repo/test/alpine"), ShouldEqual, 10)
So(common.RankRepoName("repo/test/golang", "repo/test2/alpine"), ShouldEqual, -1)
So(common.RankRepoName("repo/test/pine", "repo/test/alpine"), ShouldEqual, 3)
So(common.RankRepoName("debian", "c3/debian/base-amd64"), ShouldEqual, 400)
So(common.RankRepoName("debian/base-amd64", "c3/debian/base-amd64"), ShouldEqual, 400)
So(common.RankRepoName("debian/base-amd64", "c3/aux/debian/base-amd64"), ShouldEqual, 800)
So(common.RankRepoName("aux/debian", "c3/aux/debian/base-amd64"), ShouldEqual, 400)
})
}
func generateTestImage() ([]byte, []byte, error) {
config := ispec.Image{
Platform: ispec.Platform{
Architecture: "amd64",
OS: LINUX,
},
RootFS: ispec.RootFS{
Type: "layers",
DiffIDs: []godigest.Digest{},
},
Author: "ZotUser",
}
configBlob, err := json.Marshal(config)
if err != nil {
return []byte{}, []byte{}, err
}
configDigest := godigest.FromBytes(configBlob)
layers := [][]byte{
make([]byte, 100),
}
// init layers with random values
for i := range layers {
//nolint:gosec
_, err := rand.Read(layers[i]) //nolint:staticcheck
if err != nil {
return []byte{}, []byte{}, err
}
}
manifest := ispec.Manifest{
Versioned: specs.Versioned{
SchemaVersion: 2,
},
Config: ispec.Descriptor{
MediaType: "application/vnd.oci.image.config.v1+json",
Digest: configDigest,
Size: int64(len(configBlob)),
},
Layers: []ispec.Descriptor{
{
MediaType: "application/vnd.oci.image.layer.v1.tar",
Digest: godigest.FromBytes(layers[0]),
Size: int64(len(layers[0])),
},
},
}
manifestBlob, err := json.Marshal(manifest)
if err != nil {
return []byte{}, []byte{}, err
}
return configBlob, manifestBlob, nil
}
func TestCreateDynamo(t *testing.T) {
skipDynamo(t)
Convey("Create", t, func() {
dynamoDBDriverParams := mdynamodb.DBDriverParameters{
Endpoint: os.Getenv("DYNAMODBMOCK_ENDPOINT"),
RepoMetaTablename: "RepoMetadataTable",
ManifestDataTablename: "ManifestDataTable",
IndexDataTablename: "IndexDataTable",
UserDataTablename: "UserDataTable",
APIKeyTablename: "ApiKeyTable",
VersionTablename: "Version",
Region: "us-east-2",
}
client, err := mdynamodb.GetDynamoClient(dynamoDBDriverParams)
So(err, ShouldBeNil)
log := log.NewLogger("debug", "")
metaDB, err := meta.Create("dynamodb", client, dynamoDBDriverParams, log)
So(metaDB, ShouldNotBeNil)
So(err, ShouldBeNil)
})
Convey("Fails", t, func() {
log := log.NewLogger("debug", "")
So(func() { _, _ = meta.Create("dynamodb", nil, boltdb.DBParameters{RootDir: "root"}, log) }, ShouldPanic)
So(func() { _, _ = meta.Create("dynamodb", &dynamodb.Client{}, "bad", log) }, ShouldPanic)
metaDB, err := meta.Create("random", nil, boltdb.DBParameters{RootDir: "root"}, log)
So(metaDB, ShouldBeNil)
So(err, ShouldNotBeNil)
})
}
func TestCreateBoltDB(t *testing.T) {
Convey("Create", t, func() {
rootDir := t.TempDir()
params := boltdb.DBParameters{
RootDir: rootDir,
}
boltDriver, err := boltdb.GetBoltDriver(params)
So(err, ShouldBeNil)
log := log.NewLogger("debug", "")
metaDB, err := meta.Create("boltdb", boltDriver, params, log)
So(metaDB, ShouldNotBeNil)
So(err, ShouldBeNil)
})
Convey("fails", t, func() {
log := log.NewLogger("debug", "")
So(func() { _, _ = meta.Create("boltdb", nil, mdynamodb.DBDriverParameters{}, log) }, ShouldPanic)
})
}
func skipDynamo(t *testing.T) {
t.Helper()
if os.Getenv("DYNAMODBMOCK_ENDPOINT") == "" {
t.Skip("Skipping testing without AWS DynamoDB mock server")
}
}
Reference in a new issue View git blame Copy permalink