reference: use subtests for reference tests

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn 2022-11-10 15:14:53 +01:00
parent 21622ca699
commit f481f877f1
No known key found for this signature in database
GPG key ID: 76698F39D527CE8C

View file

@ -4,7 +4,6 @@ import (
_ "crypto/sha256" _ "crypto/sha256"
_ "crypto/sha512" _ "crypto/sha512"
"encoding/json" "encoding/json"
"strconv"
"strings" "strings"
"testing" "testing"
@ -103,10 +102,10 @@ func TestReferenceParse(t *testing.T) {
}, },
// FIXME "Uppercase" is incorrectly handled as a domain-name here, therefore passes. // FIXME "Uppercase" is incorrectly handled as a domain-name here, therefore passes.
// See https://github.com/distribution/distribution/pull/1778, and https://github.com/docker/docker/pull/20175 // See https://github.com/distribution/distribution/pull/1778, and https://github.com/docker/docker/pull/20175
//{ // {
// input: "Uppercase/lowercase:tag", // input: "Uppercase/lowercase:tag",
// err: ErrNameContainsUppercase, // err: ErrNameContainsUppercase,
//}, // },
{ {
input: "test:5000/Uppercase/lowercase:tag", input: "test:5000/Uppercase/lowercase:tag",
err: ErrNameContainsUppercase, err: ErrNameContainsUppercase,
@ -268,65 +267,62 @@ func TestReferenceParse(t *testing.T) {
}, },
} }
for _, testcase := range referenceTestcases { for _, testcase := range referenceTestcases {
failf := func(format string, v ...interface{}) { testcase := testcase
t.Logf(strconv.Quote(testcase.input)+": "+format, v...) t.Run(testcase.input, func(t *testing.T) {
t.Fail() repo, err := Parse(testcase.input)
} if testcase.err != nil {
if err == nil {
repo, err := Parse(testcase.input) t.Errorf("missing expected error: %v", testcase.err)
if testcase.err != nil { } else if testcase.err != err {
if err == nil { t.Errorf("mismatched error: got %v, expected %v", err, testcase.err)
failf("missing expected error: %v", testcase.err)
} else if testcase.err != err {
failf("mismatched error: got %v, expected %v", err, testcase.err)
}
continue
} else if err != nil {
failf("unexpected parse error: %v", err)
continue
}
if repo.String() != testcase.input {
failf("mismatched repo: got %q, expected %q", repo.String(), testcase.input)
}
if named, ok := repo.(Named); ok {
if named.Name() != testcase.repository {
failf("unexpected repository: got %q, expected %q", named.Name(), testcase.repository)
}
domain, _ := SplitHostname(named)
if domain != testcase.domain {
failf("unexpected domain: got %q, expected %q", domain, testcase.domain)
}
} else if testcase.repository != "" || testcase.domain != "" {
failf("expected named type, got %T", repo)
}
tagged, ok := repo.(Tagged)
if testcase.tag != "" {
if ok {
if tagged.Tag() != testcase.tag {
failf("unexpected tag: got %q, expected %q", tagged.Tag(), testcase.tag)
} }
} else { return
failf("expected tagged type, got %T", repo) } else if err != nil {
t.Errorf("unexpected parse error: %v", err)
return
}
if repo.String() != testcase.input {
t.Errorf("mismatched repo: got %q, expected %q", repo.String(), testcase.input)
} }
} else if ok {
failf("unexpected tagged type")
}
digested, ok := repo.(Digested) if named, ok := repo.(Named); ok {
if testcase.digest != "" { if named.Name() != testcase.repository {
if ok { t.Errorf("unexpected repository: got %q, expected %q", named.Name(), testcase.repository)
if digested.Digest().String() != testcase.digest {
failf("unexpected digest: got %q, expected %q", digested.Digest().String(), testcase.digest)
} }
} else { domain, _ := SplitHostname(named)
failf("expected digested type, got %T", repo) if domain != testcase.domain {
t.Errorf("unexpected domain: got %q, expected %q", domain, testcase.domain)
}
} else if testcase.repository != "" || testcase.domain != "" {
t.Errorf("expected named type, got %T", repo)
} }
} else if ok {
failf("unexpected digested type")
}
tagged, ok := repo.(Tagged)
if testcase.tag != "" {
if ok {
if tagged.Tag() != testcase.tag {
t.Errorf("unexpected tag: got %q, expected %q", tagged.Tag(), testcase.tag)
}
} else {
t.Errorf("expected tagged type, got %T", repo)
}
} else if ok {
t.Errorf("unexpected tagged type")
}
digested, ok := repo.(Digested)
if testcase.digest != "" {
if ok {
if digested.Digest().String() != testcase.digest {
t.Errorf("unexpected digest: got %q, expected %q", digested.Digest().String(), testcase.digest)
}
} else {
t.Errorf("expected digested type, got %T", repo)
}
} else if ok {
t.Errorf("unexpected digested type")
}
})
} }
} }
@ -363,15 +359,13 @@ func TestWithNameFailure(t *testing.T) {
}, },
} }
for _, testcase := range testcases { for _, testcase := range testcases {
failf := func(format string, v ...interface{}) { testcase := testcase
t.Logf(strconv.Quote(testcase.input)+": "+format, v...) t.Run(testcase.input, func(t *testing.T) {
t.Fail() _, err := WithName(testcase.input)
} if err == nil {
t.Errorf("no error parsing name. expected: %s", testcase.err)
_, err := WithName(testcase.input) }
if err == nil { })
failf("no error parsing name. expected: %s", testcase.err)
}
} }
} }
@ -413,22 +407,20 @@ func TestSplitHostname(t *testing.T) {
}, },
} }
for _, testcase := range testcases { for _, testcase := range testcases {
failf := func(format string, v ...interface{}) { testcase := testcase
t.Logf(strconv.Quote(testcase.input)+": "+format, v...) t.Run(testcase.input, func(t *testing.T) {
t.Fail() named, err := WithName(testcase.input)
} if err != nil {
t.Errorf("error parsing name: %s", err)
named, err := WithName(testcase.input) }
if err != nil { domain, name := SplitHostname(named)
failf("error parsing name: %s", err) if domain != testcase.domain {
} t.Errorf("unexpected domain: got %q, expected %q", domain, testcase.domain)
domain, name := SplitHostname(named) }
if domain != testcase.domain { if name != testcase.name {
failf("unexpected domain: got %q, expected %q", domain, testcase.domain) t.Errorf("unexpected name: got %q, expected %q", name, testcase.name)
} }
if name != testcase.name { })
failf("unexpected name: got %q, expected %q", name, testcase.name)
}
} }
} }
@ -469,95 +461,92 @@ func TestSerialization(t *testing.T) {
}, },
} }
for _, testcase := range testcases { for _, testcase := range testcases {
failf := func(format string, v ...interface{}) { testcase := testcase
t.Logf(strconv.Quote(testcase.input)+": "+format, v...) t.Run(testcase.description, func(t *testing.T) {
t.Fail() m := map[string]string{
} "Description": testcase.description,
"Field": testcase.input,
m := map[string]string{
"Description": testcase.description,
"Field": testcase.input,
}
b, err := json.Marshal(m)
if err != nil {
failf("error marshalling: %v", err)
}
t := serializationType{}
if err := json.Unmarshal(b, &t); err != nil {
if testcase.err == nil {
failf("error unmarshalling: %v", err)
} }
if err != testcase.err { b, err := json.Marshal(m)
failf("wrong error, expected %v, got %v", testcase.err, err) if err != nil {
t.Errorf("error marshalling: %v", err)
} }
st := serializationType{}
continue if err := json.Unmarshal(b, &st); err != nil {
} else if testcase.err != nil { if testcase.err == nil {
failf("expected error unmarshalling: %v", testcase.err) t.Errorf("error unmarshalling: %v", err)
}
if t.Description != testcase.description {
failf("wrong description, expected %q, got %q", testcase.description, t.Description)
}
ref := t.Field.Reference()
if named, ok := ref.(Named); ok {
if named.Name() != testcase.name {
failf("unexpected repository: got %q, expected %q", named.Name(), testcase.name)
}
} else if testcase.name != "" {
failf("expected named type, got %T", ref)
}
tagged, ok := ref.(Tagged)
if testcase.tag != "" {
if ok {
if tagged.Tag() != testcase.tag {
failf("unexpected tag: got %q, expected %q", tagged.Tag(), testcase.tag)
} }
} else { if err != testcase.err {
failf("expected tagged type, got %T", ref) t.Errorf("wrong error, expected %v, got %v", testcase.err, err)
}
} else if ok {
failf("unexpected tagged type")
}
digested, ok := ref.(Digested)
if testcase.digest != "" {
if ok {
if digested.Digest().String() != testcase.digest {
failf("unexpected digest: got %q, expected %q", digested.Digest().String(), testcase.digest)
} }
} else {
failf("expected digested type, got %T", ref) return
} else if testcase.err != nil {
t.Errorf("expected error unmarshalling: %v", testcase.err)
} }
} else if ok {
failf("unexpected digested type")
}
t = serializationType{ if st.Description != testcase.description {
Description: testcase.description, t.Errorf("wrong description, expected %q, got %q", testcase.description, st.Description)
Field: AsField(ref), }
}
b2, err := json.Marshal(t) ref := st.Field.Reference()
if err != nil {
failf("error marshing serialization type: %v", err)
}
if string(b) != string(b2) { if named, ok := ref.(Named); ok {
failf("unexpected serialized value: expected %q, got %q", string(b), string(b2)) if named.Name() != testcase.name {
} t.Errorf("unexpected repository: got %q, expected %q", named.Name(), testcase.name)
}
} else if testcase.name != "" {
t.Errorf("expected named type, got %T", ref)
}
// Ensure t.Field is not implementing "Reference" directly, getting tagged, ok := ref.(Tagged)
// around the Reference type system if testcase.tag != "" {
var fieldInterface interface{} = t.Field if ok {
if _, ok := fieldInterface.(Reference); ok { if tagged.Tag() != testcase.tag {
failf("field should not implement Reference interface") t.Errorf("unexpected tag: got %q, expected %q", tagged.Tag(), testcase.tag)
} }
} else {
t.Errorf("expected tagged type, got %T", ref)
}
} else if ok {
t.Errorf("unexpected tagged type")
}
digested, ok := ref.(Digested)
if testcase.digest != "" {
if ok {
if digested.Digest().String() != testcase.digest {
t.Errorf("unexpected digest: got %q, expected %q", digested.Digest().String(), testcase.digest)
}
} else {
t.Errorf("expected digested type, got %T", ref)
}
} else if ok {
t.Errorf("unexpected digested type")
}
st = serializationType{
Description: testcase.description,
Field: AsField(ref),
}
b2, err := json.Marshal(st)
if err != nil {
t.Errorf("error marshing serialization type: %v", err)
}
if string(b) != string(b2) {
t.Errorf("unexpected serialized value: expected %q, got %q", string(b), string(b2))
}
// Ensure st.Field is not implementing "Reference" directly, getting
// around the Reference type system
var fieldInterface interface{} = st.Field
if _, ok := fieldInterface.(Reference); ok {
t.Errorf("field should not implement Reference interface")
}
})
} }
} }
@ -596,30 +585,28 @@ func TestWithTag(t *testing.T) {
}, },
} }
for _, testcase := range testcases { for _, testcase := range testcases {
failf := func(format string, v ...interface{}) { testcase := testcase
t.Logf(strconv.Quote(testcase.name)+": "+format, v...) t.Run(testcase.combined, func(t *testing.T) {
t.Fail() named, err := WithName(testcase.name)
}
named, err := WithName(testcase.name)
if err != nil {
failf("error parsing name: %s", err)
}
if testcase.digest != "" {
canonical, err := WithDigest(named, testcase.digest)
if err != nil { if err != nil {
failf("error adding digest") t.Errorf("error parsing name: %s", err)
}
if testcase.digest != "" {
canonical, err := WithDigest(named, testcase.digest)
if err != nil {
t.Errorf("error adding digest")
}
named = canonical
} }
named = canonical
}
tagged, err := WithTag(named, testcase.tag) tagged, err := WithTag(named, testcase.tag)
if err != nil { if err != nil {
failf("WithTag failed: %s", err) t.Errorf("WithTag failed: %s", err)
} }
if tagged.String() != testcase.combined { if tagged.String() != testcase.combined {
failf("unexpected: got %q, expected %q", tagged.String(), testcase.combined) t.Errorf("unexpected: got %q, expected %q", tagged.String(), testcase.combined)
} }
})
} }
} }
@ -653,29 +640,27 @@ func TestWithDigest(t *testing.T) {
}, },
} }
for _, testcase := range testcases { for _, testcase := range testcases {
failf := func(format string, v ...interface{}) { testcase := testcase
t.Logf(strconv.Quote(testcase.name)+": "+format, v...) t.Run(testcase.combined, func(t *testing.T) {
t.Fail() named, err := WithName(testcase.name)
}
named, err := WithName(testcase.name)
if err != nil {
failf("error parsing name: %s", err)
}
if testcase.tag != "" {
tagged, err := WithTag(named, testcase.tag)
if err != nil { if err != nil {
failf("error adding tag") t.Errorf("error parsing name: %s", err)
} }
named = tagged if testcase.tag != "" {
} tagged, err := WithTag(named, testcase.tag)
digested, err := WithDigest(named, testcase.digest) if err != nil {
if err != nil { t.Errorf("error adding tag")
failf("WithDigest failed: %s", err) }
} named = tagged
if digested.String() != testcase.combined { }
failf("unexpected: got %q, expected %q", digested.String(), testcase.combined) digested, err := WithDigest(named, testcase.digest)
} if err != nil {
t.Errorf("WithDigest failed: %s", err)
}
if digested.String() != testcase.combined {
t.Errorf("unexpected: got %q, expected %q", digested.String(), testcase.combined)
}
})
} }
} }
@ -724,31 +709,29 @@ func TestParseNamed(t *testing.T) {
}, },
} }
for _, testcase := range testcases { for _, testcase := range testcases {
failf := func(format string, v ...interface{}) { testcase := testcase
t.Logf(strconv.Quote(testcase.input)+": "+format, v...) t.Run(testcase.input, func(t *testing.T) {
t.Fail() named, err := ParseNamed(testcase.input)
} if err != nil && testcase.err == nil {
t.Errorf("error parsing name: %s", err)
return
} else if err == nil && testcase.err != nil {
t.Errorf("parsing succeeded: expected error %v", testcase.err)
return
} else if err != testcase.err {
t.Errorf("unexpected error %v, expected %v", err, testcase.err)
return
} else if err != nil {
return
}
named, err := ParseNamed(testcase.input) domain, name := SplitHostname(named)
if err != nil && testcase.err == nil { if domain != testcase.domain {
failf("error parsing name: %s", err) t.Errorf("unexpected domain: got %q, expected %q", domain, testcase.domain)
continue }
} else if err == nil && testcase.err != nil { if name != testcase.name {
failf("parsing succeeded: expected error %v", testcase.err) t.Errorf("unexpected name: got %q, expected %q", name, testcase.name)
continue }
} else if err != testcase.err { })
failf("unexpected error %v, expected %v", err, testcase.err)
continue
} else if err != nil {
continue
}
domain, name := SplitHostname(named)
if domain != testcase.domain {
failf("unexpected domain: got %q, expected %q", domain, testcase.domain)
}
if name != testcase.name {
failf("unexpected name: got %q, expected %q", name, testcase.name)
}
} }
} }