constellation/internal/versionsapi/list_test.go
Paul Meyer 3f00f89d55 versionsapi: new implementation
Signed-off-by: Paul Meyer <49727155+katexochen@users.noreply.github.com>
2023-01-04 11:39:19 +01:00

355 lines
8.1 KiB
Go

/*
Copyright (c) Edgeless Systems GmbH
SPDX-License-Identifier: AGPL-3.0-only
*/
package versionsapi
import (
"testing"
"github.com/edgelesssys/constellation/v2/internal/constants"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestListJSONPath(t *testing.T) {
testCases := map[string]struct {
list List
wantPath string
}{
"major list": {
list: List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMajor,
Base: "v1",
Kind: VersionKindImage,
},
wantPath: constants.CDNAPIPrefix + "/ref/test-ref/stream/nightly/versions/major/v1/image.json",
},
"minor list": {
list: List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMinor,
Base: "v1.1",
Kind: VersionKindImage,
},
wantPath: constants.CDNAPIPrefix + "/ref/test-ref/stream/nightly/versions/minor/v1.1/image.json",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
assert.Equal(t, tc.wantPath, tc.list.JSONPath())
})
}
}
func TestListURL(t *testing.T) {
testCases := map[string]struct {
list List
wantURL string
wantPath string
}{
"major list": {
list: List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMajor,
Base: "v1",
Kind: VersionKindImage,
},
wantURL: constants.CDNRepositoryURL + "/" + constants.CDNAPIPrefix + "/ref/test-ref/stream/nightly/versions/major/v1/image.json",
},
"minor list": {
list: List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMinor,
Base: "v1.1",
Kind: VersionKindImage,
},
wantURL: constants.CDNRepositoryURL + "/" + constants.CDNAPIPrefix + "/ref/test-ref/stream/nightly/versions/minor/v1.1/image.json",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
assert := assert.New(t)
url, err := tc.list.URL()
assert.NoError(err)
assert.Equal(tc.wantURL, url)
})
}
}
func TestListValidate(t *testing.T) {
majorList := func() *List {
return &List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMajor,
Base: "v1",
Kind: VersionKindImage,
Versions: []string{
"v1.0", "v1.1", "v1.2",
},
}
}
minorList := func() *List {
return &List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMinor,
Base: "v1.1",
Kind: VersionKindImage,
Versions: []string{
"v1.1.0", "v1.1.1", "v1.1.2",
},
}
}
testCases := map[string]struct {
listFunc func() *List
overrideFunc func(list *List)
wantErr bool
}{
"valid major list": {
listFunc: majorList,
},
"valid minor list": {
listFunc: minorList,
},
"invalid ref": {
listFunc: majorList,
overrideFunc: func(list *List) { list.Ref = "" },
wantErr: true,
},
"invalid stream": {
listFunc: majorList,
overrideFunc: func(list *List) { list.Stream = "invalid" },
wantErr: true,
},
"invalid granularity": {
listFunc: majorList,
overrideFunc: func(list *List) { list.Granularity = GranularityUnknown },
wantErr: true,
},
"invalid kind": {
listFunc: majorList,
overrideFunc: func(list *List) { list.Kind = VersionKindUnknown },
wantErr: true,
},
"base ver is not semantic version": {
listFunc: majorList,
overrideFunc: func(list *List) { list.Base = "invalid" },
wantErr: true,
},
"base ver does not reflect major granularity": {
listFunc: majorList,
overrideFunc: func(list *List) { list.Base = "v1.0" },
wantErr: true,
},
"base ver does not reflect minor granularity": {
listFunc: minorList,
overrideFunc: func(list *List) { list.Base = "v1" },
wantErr: true,
},
"version in list is not semantic version": {
listFunc: majorList,
overrideFunc: func(list *List) { list.Versions[0] = "invalid" },
wantErr: true,
},
"version in list is not sub version of base": {
listFunc: majorList,
overrideFunc: func(list *List) { list.Versions[0] = "v2.1" },
wantErr: true,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
list := tc.listFunc()
if tc.overrideFunc != nil {
tc.overrideFunc(list)
}
err := list.Validate()
if tc.wantErr {
assert.Error(err)
return
}
require.NoError(err)
})
}
}
func TestListValidateRequest(t *testing.T) {
majorListReq := func() *List {
return &List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMajor,
Base: "v1",
Kind: VersionKindImage,
}
}
minorListReq := func() *List {
return &List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMinor,
Base: "v1.1",
Kind: VersionKindImage,
}
}
testCases := map[string]struct {
listFunc func() *List
overrideFunc func(list *List)
wantErr bool
}{
"valid major list": {
listFunc: majorListReq,
},
"valid minor list": {
listFunc: minorListReq,
},
"invalid ref": {
listFunc: majorListReq,
overrideFunc: func(list *List) { list.Ref = "" },
wantErr: true,
},
"invalid stream": {
listFunc: majorListReq,
overrideFunc: func(list *List) { list.Stream = "invalid" },
wantErr: true,
},
"invalid granularity": {
listFunc: majorListReq,
overrideFunc: func(list *List) { list.Granularity = GranularityUnknown },
wantErr: true,
},
"invalid kind": {
listFunc: majorListReq,
overrideFunc: func(list *List) { list.Kind = VersionKindUnknown },
wantErr: true,
},
"base ver is not semantic version": {
listFunc: majorListReq,
overrideFunc: func(list *List) { list.Base = "invalid" },
wantErr: true,
},
"base ver does not reflect major granularity": {
listFunc: majorListReq,
overrideFunc: func(list *List) { list.Base = "v1.0" },
wantErr: true,
},
"base ver does not reflect minor granularity": {
listFunc: minorListReq,
overrideFunc: func(list *List) { list.Base = "v1" },
wantErr: true,
},
"version in list is not empty": {
listFunc: majorListReq,
overrideFunc: func(list *List) { list.Versions = []string{"v1.1"} },
wantErr: true,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
list := tc.listFunc()
if tc.overrideFunc != nil {
tc.overrideFunc(list)
}
err := list.ValidateRequest()
if tc.wantErr {
assert.Error(err)
return
}
require.NoError(err)
})
}
}
func TestListContainer(t *testing.T) {
testCases := map[string]struct {
versions []string
version string
want bool
}{
"empty list": {
versions: []string{},
version: "v1.1.1",
want: false,
},
"version not in list": {
versions: []string{"v1.1.1"},
version: "v1.1.2",
want: false,
},
"version in list": {
versions: []string{"v1.1.1", "v1.1.2"},
version: "v1.1.1",
want: true,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
assert := assert.New(t)
list := &List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMinor,
Base: "v1.1",
Kind: VersionKindImage,
Versions: tc.versions,
}
assert.Equal(tc.want, list.Contains(tc.version))
})
}
}
func TestListStructuredVersions(t *testing.T) {
assert := assert.New(t)
list := List{
Ref: "test-ref",
Stream: "nightly",
Granularity: GranularityMinor,
Base: "v1.1",
Kind: VersionKindImage,
Versions: []string{"v1.1.1", "v1.1.2", "v1.1.3", "v1.1.4", "v1.1.5"},
}
versions := list.StructuredVersions()
assert.Len(versions, 5)
verStrs := make([]string, len(versions))
for i, v := range versions {
assert.Equal(list.Ref, v.Ref)
assert.Equal(list.Stream, v.Stream)
assert.Equal(list.Kind, v.Kind)
verStrs[i] = v.Version
}
assert.ElementsMatch(list.Versions, verStrs)
}