2023-07-18 12:27:26 -05:00
|
|
|
package meta_test
|
2023-01-09 15:37:44 -05:00
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
"path"
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
godigest "github.com/opencontainers/go-digest"
|
|
|
|
ispec "github.com/opencontainers/image-spec/specs-go/v1"
|
|
|
|
. "github.com/smartystreets/goconvey/convey"
|
|
|
|
|
2023-08-19 00:52:03 -05:00
|
|
|
zcommon "zotregistry.io/zot/pkg/common"
|
2023-01-09 15:37:44 -05:00
|
|
|
"zotregistry.io/zot/pkg/extensions/monitoring"
|
|
|
|
"zotregistry.io/zot/pkg/log"
|
2023-07-18 12:27:26 -05:00
|
|
|
"zotregistry.io/zot/pkg/meta"
|
|
|
|
"zotregistry.io/zot/pkg/meta/boltdb"
|
|
|
|
"zotregistry.io/zot/pkg/meta/dynamodb"
|
|
|
|
mTypes "zotregistry.io/zot/pkg/meta/types"
|
2023-01-09 15:37:44 -05:00
|
|
|
"zotregistry.io/zot/pkg/storage"
|
|
|
|
"zotregistry.io/zot/pkg/storage/local"
|
2023-05-26 13:08:19 -05:00
|
|
|
storageTypes "zotregistry.io/zot/pkg/storage/types"
|
2023-09-27 13:34:48 -05:00
|
|
|
"zotregistry.io/zot/pkg/test/deprecated"
|
2023-09-15 11:53:15 -05:00
|
|
|
. "zotregistry.io/zot/pkg/test/image-utils"
|
2023-01-09 15:37:44 -05:00
|
|
|
"zotregistry.io/zot/pkg/test/mocks"
|
2023-09-27 13:34:48 -05:00
|
|
|
"zotregistry.io/zot/pkg/test/signature"
|
2023-10-05 06:34:50 -05:00
|
|
|
tskip "zotregistry.io/zot/pkg/test/skip"
|
2023-01-09 15:37:44 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
const repo = "repo"
|
|
|
|
|
2023-03-23 13:08:11 -05:00
|
|
|
func TestParseStorageErrors(t *testing.T) {
|
2023-03-28 12:20:09 -05:00
|
|
|
Convey("ParseStorage", t, func() {
|
2023-01-09 15:37:44 -05:00
|
|
|
imageStore := mocks.MockedImageStore{
|
|
|
|
GetIndexContentFn: func(repo string) ([]byte, error) {
|
|
|
|
return nil, ErrTestError
|
|
|
|
},
|
|
|
|
GetRepositoriesFn: func() ([]string, error) {
|
|
|
|
return []string{"repo1", "repo2"}, nil
|
|
|
|
},
|
|
|
|
}
|
|
|
|
storeController := storage.StoreController{DefaultStore: imageStore}
|
2023-07-18 12:27:26 -05:00
|
|
|
metaDB := mocks.MetaDBMock{}
|
2023-01-09 15:37:44 -05:00
|
|
|
|
|
|
|
// sync repo fail
|
2023-07-18 12:27:26 -05:00
|
|
|
err := meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", ""))
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldNotBeNil)
|
|
|
|
|
|
|
|
Convey("getAllRepos errors", func() {
|
|
|
|
imageStore1 := mocks.MockedImageStore{
|
|
|
|
GetRepositoriesFn: func() ([]string, error) {
|
|
|
|
return []string{"repo1", "repo2"}, nil
|
|
|
|
},
|
|
|
|
}
|
|
|
|
imageStore2 := mocks.MockedImageStore{
|
|
|
|
GetRepositoriesFn: func() ([]string, error) {
|
|
|
|
return nil, ErrTestError
|
|
|
|
},
|
|
|
|
}
|
|
|
|
storeController := storage.StoreController{
|
|
|
|
DefaultStore: imageStore1,
|
2023-05-26 13:08:19 -05:00
|
|
|
SubStore: map[string]storageTypes.ImageStore{
|
2023-01-09 15:37:44 -05:00
|
|
|
"a": imageStore2,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
err := meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", ""))
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldNotBeNil)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2023-03-28 12:20:09 -05:00
|
|
|
Convey("Parse Repo", t, func() {
|
2023-01-09 15:37:44 -05:00
|
|
|
imageStore := mocks.MockedImageStore{}
|
|
|
|
storeController := storage.StoreController{DefaultStore: &imageStore}
|
2023-07-18 12:27:26 -05:00
|
|
|
metaDB := mocks.MetaDBMock{}
|
2023-01-09 15:37:44 -05:00
|
|
|
log := log.NewLogger("debug", "")
|
|
|
|
|
|
|
|
Convey("imageStore.GetIndexContent errors", func() {
|
|
|
|
imageStore.GetIndexContentFn = func(repo string) ([]byte, error) {
|
|
|
|
return nil, ErrTestError
|
|
|
|
}
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
err := meta.ParseRepo("repo", metaDB, storeController, log)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldNotBeNil)
|
|
|
|
})
|
|
|
|
|
|
|
|
Convey("json.Unmarshal errors", func() {
|
|
|
|
imageStore.GetIndexContentFn = func(repo string) ([]byte, error) {
|
|
|
|
return []byte("Invalid JSON"), nil
|
|
|
|
}
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
err := meta.ParseRepo("repo", metaDB, storeController, log)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldNotBeNil)
|
|
|
|
})
|
|
|
|
|
|
|
|
Convey("manifestMetaIsPresent true", func() {
|
|
|
|
indexContent := ispec.Index{
|
|
|
|
Manifests: []ispec.Descriptor{
|
|
|
|
{
|
|
|
|
Digest: godigest.FromString("manifest1"),
|
|
|
|
MediaType: ispec.MediaTypeImageManifest,
|
|
|
|
Annotations: map[string]string{
|
|
|
|
ispec.AnnotationRefName: "tag1",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
indexBlob, err := json.Marshal(indexContent)
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
imageStore.GetIndexContentFn = func(repo string) ([]byte, error) {
|
|
|
|
return indexBlob, nil
|
|
|
|
}
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
Convey("metaDB.SetRepoReference", func() {
|
2023-10-30 15:06:04 -05:00
|
|
|
metaDB.SetRepoReferenceFn = func(repo, reference string, imageMeta mTypes.ImageMeta) error {
|
2023-01-09 15:37:44 -05:00
|
|
|
return ErrTestError
|
|
|
|
}
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
err = meta.ParseRepo("repo", metaDB, storeController, log)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldNotBeNil)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-05-15 04:02:23 -05:00
|
|
|
func TestParseStorageWithBoltDB(t *testing.T) {
|
2023-01-09 15:37:44 -05:00
|
|
|
Convey("Boltdb", t, func() {
|
|
|
|
rootDir := t.TempDir()
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
boltDB, err := boltdb.GetBoltDriver(boltdb.DBParameters{
|
2023-03-23 13:08:11 -05:00
|
|
|
RootDir: rootDir,
|
|
|
|
})
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
metaDB, err := boltdb.New(boltDB, log.NewLogger("debug", ""))
|
2023-03-28 12:20:09 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
RunParseStorageTests(rootDir, metaDB)
|
2023-03-23 13:08:11 -05:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestParseStorageDynamoWrapper(t *testing.T) {
|
2023-10-05 06:34:50 -05:00
|
|
|
tskip.SkipDynamo(t)
|
2023-03-23 13:08:11 -05:00
|
|
|
|
|
|
|
Convey("Dynamodb", t, func() {
|
|
|
|
rootDir := t.TempDir()
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
params := dynamodb.DBDriverParameters{
|
2023-10-30 15:06:04 -05:00
|
|
|
Endpoint: os.Getenv("DYNAMODBMOCK_ENDPOINT"),
|
|
|
|
Region: "us-east-2",
|
|
|
|
RepoMetaTablename: "RepoMetadataTable",
|
|
|
|
RepoBlobsInfoTablename: "RepoBlobsInfoTablename",
|
|
|
|
ImageMetaTablename: "ImageMetaTablename",
|
|
|
|
UserDataTablename: "UserDataTable",
|
|
|
|
APIKeyTablename: "ApiKeyTable",
|
|
|
|
VersionTablename: "Version",
|
2023-03-28 12:20:09 -05:00
|
|
|
}
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
dynamoClient, err := dynamodb.GetDynamoClient(params)
|
2023-03-28 12:20:09 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
dynamoWrapper, err := dynamodb.New(dynamoClient, params, log.NewLogger("debug", ""))
|
2023-03-23 13:08:11 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
err = dynamoWrapper.ResetTable(dynamoWrapper.RepoMetaTablename)
|
2023-03-23 13:08:11 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
err = dynamoWrapper.ResetTable(dynamoWrapper.RepoBlobsTablename)
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
err = dynamoWrapper.ResetTable(dynamoWrapper.ImageMetaTablename)
|
2023-03-23 13:08:11 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
RunParseStorageTests(rootDir, dynamoWrapper)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
func RunParseStorageTests(rootDir string, metaDB mTypes.MetaDB) {
|
2023-05-15 04:02:23 -05:00
|
|
|
Convey("Test with simple case", func() {
|
2023-09-22 13:51:20 -05:00
|
|
|
imageStore := local.NewImageStore(rootDir, false, false,
|
2023-01-09 15:37:44 -05:00
|
|
|
log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), nil, nil)
|
|
|
|
|
|
|
|
storeController := storage.StoreController{DefaultStore: imageStore}
|
|
|
|
manifests := []ispec.Manifest{}
|
|
|
|
for i := 0; i < 3; i++ {
|
2023-09-27 13:34:48 -05:00
|
|
|
config, layers, manifest, err := deprecated.GetRandomImageComponents(100) //nolint:staticcheck
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
manifests = append(manifests, manifest)
|
|
|
|
|
2023-09-27 13:34:48 -05:00
|
|
|
err = WriteImageToFileSystem(
|
2023-09-15 11:53:15 -05:00
|
|
|
Image{
|
2023-07-28 09:53:46 -05:00
|
|
|
Config: config,
|
|
|
|
Layers: layers,
|
|
|
|
Manifest: manifest,
|
|
|
|
}, repo, fmt.Sprintf("tag%d", i), storeController)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
}
|
|
|
|
|
|
|
|
// add fake signature for tag1
|
2023-09-27 13:34:48 -05:00
|
|
|
signatureTag, err := signature.GetCosignSignatureTagForManifest(manifests[1])
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
manifestBlob, err := json.Marshal(manifests[1])
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
signedManifestDigest := godigest.FromBytes(manifestBlob)
|
|
|
|
|
2023-09-27 13:34:48 -05:00
|
|
|
config, layers, manifest, err := deprecated.GetRandomImageComponents(100) //nolint:staticcheck
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-09-27 13:34:48 -05:00
|
|
|
err = WriteImageToFileSystem(
|
2023-09-15 11:53:15 -05:00
|
|
|
Image{
|
2023-07-28 09:53:46 -05:00
|
|
|
Config: config,
|
|
|
|
Layers: layers,
|
|
|
|
Manifest: manifest,
|
|
|
|
}, repo, signatureTag, storeController)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
// remove tag2 from index.json
|
|
|
|
indexPath := path.Join(rootDir, repo, "index.json")
|
|
|
|
indexFile, err := os.Open(indexPath)
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
buf, err := io.ReadAll(indexFile)
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
var index ispec.Index
|
|
|
|
if err = json.Unmarshal(buf, &index); err == nil {
|
|
|
|
for _, manifest := range index.Manifests {
|
|
|
|
if val, ok := manifest.Annotations[ispec.AnnotationRefName]; ok && val == "tag2" {
|
|
|
|
delete(manifest.Annotations, ispec.AnnotationRefName)
|
|
|
|
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
buf, err = json.Marshal(index)
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
err = os.WriteFile(indexPath, buf, 0o600)
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
err = meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", ""))
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-07-31 14:16:09 -05:00
|
|
|
repos, err := metaDB.GetMultipleRepoMeta(context.Background(),
|
2023-10-30 15:06:04 -05:00
|
|
|
func(repoMeta mTypes.RepoMeta) bool { return true })
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
So(len(repos), ShouldEqual, 1)
|
|
|
|
So(len(repos[0].Tags), ShouldEqual, 2)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
ctx := context.Background()
|
|
|
|
|
|
|
|
for tag, descriptor := range repos[0].Tags {
|
|
|
|
imageManifestData, err := metaDB.GetFullImageMeta(ctx, repo, tag)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
if descriptor.Digest == signedManifestDigest.String() {
|
2023-10-30 15:06:04 -05:00
|
|
|
So(imageManifestData.Signatures, ShouldNotBeEmpty)
|
2023-01-09 15:37:44 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2023-05-15 04:02:23 -05:00
|
|
|
Convey("Accept orphan signatures", func() {
|
2023-09-22 13:51:20 -05:00
|
|
|
imageStore := local.NewImageStore(rootDir, false, false,
|
2023-01-09 15:37:44 -05:00
|
|
|
log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), nil, nil)
|
|
|
|
|
|
|
|
storeController := storage.StoreController{DefaultStore: imageStore}
|
|
|
|
// add an image
|
2023-09-27 13:34:48 -05:00
|
|
|
config, layers, manifest, err := deprecated.GetRandomImageComponents(100) //nolint:staticcheck
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-09-27 13:34:48 -05:00
|
|
|
err = WriteImageToFileSystem(
|
2023-09-15 11:53:15 -05:00
|
|
|
Image{
|
2023-07-28 09:53:46 -05:00
|
|
|
Config: config,
|
|
|
|
Layers: layers,
|
|
|
|
Manifest: manifest,
|
|
|
|
}, repo, "tag1", storeController)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
|
|
|
// add mock cosign signature without pushing the signed image
|
2023-09-27 13:34:48 -05:00
|
|
|
image, err := deprecated.GetRandomImage() //nolint:staticcheck
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-09-27 13:34:48 -05:00
|
|
|
signatureTag, err := signature.GetCosignSignatureTagForManifest(image.Manifest)
|
2023-05-15 04:02:23 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-07-26 05:08:04 -05:00
|
|
|
missingImageDigest := image.Digest()
|
2023-01-09 15:37:44 -05:00
|
|
|
|
|
|
|
// get the body of the signature
|
2023-09-27 13:34:48 -05:00
|
|
|
config, layers, manifest, err = deprecated.GetRandomImageComponents(100) //nolint:staticcheck
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-09-27 13:34:48 -05:00
|
|
|
err = WriteImageToFileSystem(
|
2023-09-15 11:53:15 -05:00
|
|
|
Image{
|
2023-07-28 09:53:46 -05:00
|
|
|
Config: config,
|
|
|
|
Layers: layers,
|
|
|
|
Manifest: manifest,
|
|
|
|
}, repo, signatureTag, storeController)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
err = meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", ""))
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
repos, err := metaDB.GetMultipleRepoMeta(context.Background(),
|
|
|
|
func(repoMeta mTypes.RepoMeta) bool { return true })
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-05-15 04:02:23 -05:00
|
|
|
for _, desc := range repos[0].Tags {
|
|
|
|
So(desc.Digest, ShouldNotResemble, missingImageDigest.String())
|
|
|
|
}
|
|
|
|
|
2023-01-09 15:37:44 -05:00
|
|
|
So(len(repos), ShouldEqual, 1)
|
|
|
|
So(repos[0].Tags, ShouldContainKey, "tag1")
|
|
|
|
So(repos[0].Tags, ShouldNotContainKey, signatureTag)
|
2023-05-15 04:02:23 -05:00
|
|
|
So(repos[0].Signatures, ShouldContainKey, missingImageDigest.String())
|
2023-01-09 15:37:44 -05:00
|
|
|
})
|
|
|
|
|
2023-03-23 13:08:11 -05:00
|
|
|
Convey("Check statistics after load", func() {
|
2023-09-22 13:51:20 -05:00
|
|
|
imageStore := local.NewImageStore(rootDir, false, false,
|
2023-01-09 15:37:44 -05:00
|
|
|
log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), nil, nil)
|
|
|
|
|
|
|
|
storeController := storage.StoreController{DefaultStore: imageStore}
|
2023-03-23 13:08:11 -05:00
|
|
|
// add an image
|
2023-10-30 15:06:04 -05:00
|
|
|
image := CreateRandomImage() //nolint:staticcheck
|
2023-01-09 15:37:44 -05:00
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
err := WriteImageToFileSystem(image, repo, "tag", storeController)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
err = metaDB.SetRepoReference(repo, "tag", image.AsImageMeta())
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
err = metaDB.IncrementRepoStars(repo)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
2023-07-18 12:27:26 -05:00
|
|
|
err = metaDB.IncrementImageDownloads(repo, "tag")
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
2023-07-18 12:27:26 -05:00
|
|
|
err = metaDB.IncrementImageDownloads(repo, "tag")
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
2023-07-18 12:27:26 -05:00
|
|
|
err = metaDB.IncrementImageDownloads(repo, "tag")
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
repoMeta, err := metaDB.GetRepoMeta(context.Background(), repo)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
So(repoMeta.Statistics[image.DigestStr()].DownloadCount, ShouldEqual, 3)
|
|
|
|
So(repoMeta.StarCount, ShouldEqual, 1)
|
2023-01-09 15:37:44 -05:00
|
|
|
|
2023-07-18 12:27:26 -05:00
|
|
|
err = meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", ""))
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
repoMeta, err = metaDB.GetRepoMeta(context.Background(), repo)
|
2023-01-09 15:37:44 -05:00
|
|
|
So(err, ShouldBeNil)
|
|
|
|
|
2023-10-30 15:06:04 -05:00
|
|
|
So(repoMeta.Statistics[image.DigestStr()].DownloadCount, ShouldEqual, 3)
|
|
|
|
So(repoMeta.StarCount, ShouldEqual, 1)
|
2023-03-10 13:37:29 -05:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-05-24 11:46:16 -05:00
|
|
|
func TestGetSignatureLayersInfo(t *testing.T) {
|
|
|
|
Convey("wrong signature type", t, func() {
|
2023-07-18 12:27:26 -05:00
|
|
|
layers, err := meta.GetSignatureLayersInfo("repo", "tag", "123", "wrong signature type", []byte{},
|
2023-05-24 11:46:16 -05:00
|
|
|
nil, log.NewLogger("debug", ""))
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
So(layers, ShouldBeEmpty)
|
|
|
|
})
|
|
|
|
|
2023-10-12 20:45:20 -05:00
|
|
|
Convey("notation index", t, func() {
|
|
|
|
notationIndex := ispec.Index{
|
|
|
|
MediaType: ispec.MediaTypeImageIndex,
|
|
|
|
}
|
|
|
|
|
|
|
|
notationIndexBlob, err := json.Marshal(notationIndex)
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
layers, err := meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.NotationSignature, notationIndexBlob,
|
|
|
|
nil, log.NewLogger("debug", ""))
|
|
|
|
So(err, ShouldBeNil)
|
|
|
|
So(layers, ShouldBeEmpty)
|
|
|
|
})
|
|
|
|
|
2023-05-24 11:46:16 -05:00
|
|
|
Convey("error while unmarshaling manifest content", t, func() {
|
2023-08-19 00:52:03 -05:00
|
|
|
_, err := meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.CosignSignature, []byte("bad manifest"),
|
2023-05-24 11:46:16 -05:00
|
|
|
nil, log.NewLogger("debug", ""))
|
|
|
|
So(err, ShouldNotBeNil)
|
|
|
|
|
2023-08-19 00:52:03 -05:00
|
|
|
_, err = meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.NotationSignature, []byte("bad manifest"),
|
2023-05-24 11:46:16 -05:00
|
|
|
nil, log.NewLogger("debug", ""))
|
|
|
|
So(err, ShouldNotBeNil)
|
|
|
|
})
|
|
|
|
}
|