potyarkin/distribution
1
0
Fork 0
forked from TrueCloudLab/distribution
Code Pull requests Activity

reference: use consistent names for test-tables

Browse source 
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn 2023-04-30 14:48:09 +02:00
parent 8900e90699
commit fcbddfc6ae
No known key found for this signature in database
GPG key ID: 76698F39D527CE8C
3 changed files with 135 additions and 135 deletions
Download patch file Download diff file Expand all files Collapse all files

64
reference/normalize_test.go
View file

@ -146,7 +146,7 @@ func TestParseRepositoryInfo(t *testing.T) {
RemoteName, FamiliarName, FullName, AmbiguousName, Domain string
}
tcases := []tcase{
tests := []tcase{
{
RemoteName: "fooo/bar",
FamiliarName: "fooo/bar",
@ -261,7 +261,7 @@ func TestParseRepositoryInfo(t *testing.T) {
},
}
for i, tc := range tcases {
for i, tc := range tests {
tc := tc
refStrings := []string{tc.FamiliarName, tc.FullName}
if tc.AmbiguousName != "" {
@ -367,7 +367,7 @@ func equalReference(r1, r2 Reference) bool {
func TestParseAnyReference(t *testing.T) {
t.Parallel()
tcases := []struct {
tests := []struct {
Reference string
Equivalent string
Expected Reference
@ -432,22 +432,22 @@ func TestParseAnyReference(t *testing.T) {
},
}
for _, tcase := range tcases {
for _, tc := range tests {
var ref Reference
var err error
ref, err = ParseAnyReference(tcase.Reference)
ref, err = ParseAnyReference(tc.Reference)
if err != nil {
t.Fatalf("Error parsing reference %s: %v", tcase.Reference, err)
t.Fatalf("Error parsing reference %s: %v", tc.Reference, err)
}
if ref.String() != tcase.Equivalent {
t.Fatalf("Unexpected string: %s, expected %s", ref.String(), tcase.Equivalent)
if ref.String() != tc.Equivalent {
t.Fatalf("Unexpected string: %s, expected %s", ref.String(), tc.Equivalent)
}
expected := tcase.Expected
expected := tc.Expected
if expected == nil {
expected, err = Parse(tcase.Equivalent)
expected, err = Parse(tc.Equivalent)
if err != nil {
t.Fatalf("Error parsing reference %s: %v", tcase.Equivalent, err)
t.Fatalf("Error parsing reference %s: %v", tc.Equivalent, err)
}
}
if !equalReference(ref, expected) {
@ -458,7 +458,7 @@ func TestParseAnyReference(t *testing.T) {
func TestNormalizedSplitHostname(t *testing.T) {
t.Parallel()
testcases := []struct {
tests := []struct {
input string
domain string
name string
@ -519,22 +519,22 @@ func TestNormalizedSplitHostname(t *testing.T) {
name: "library/foo/bar",
},
}
for _, testcase := range testcases {
for _, tc := range tests {
failf := func(format string, v ...interface{}) {
t.Logf(strconv.Quote(testcase.input)+": "+format, v...)
t.Logf(strconv.Quote(tc.input)+": "+format, v...)
t.Fail()
}
named, err := ParseNormalizedNamed(testcase.input)
named, err := ParseNormalizedNamed(tc.input)
if err != nil {
failf("error parsing name: %s", err)
}
domain, name := SplitHostname(named)
if domain != testcase.domain {
failf("unexpected domain: got %q, expected %q", domain, testcase.domain)
if domain != tc.domain {
failf("unexpected domain: got %q, expected %q", domain, tc.domain)
}
if name != testcase.name {
failf("unexpected name: got %q, expected %q", name, testcase.name)
if name != tc.name {
failf("unexpected name: got %q, expected %q", name, tc.name)
}
}
}
@ -553,7 +553,7 @@ func TestMatchError(t *testing.T) {
func TestMatch(t *testing.T) {
t.Parallel()
matchCases := []struct {
tests := []struct {
reference string
pattern string
expected bool
@ -604,24 +604,24 @@ func TestMatch(t *testing.T) {
expected: true,
},
}
for _, c := range matchCases {
named, err := ParseAnyReference(c.reference)
for _, tc := range tests {
named, err := ParseAnyReference(tc.reference)
if err != nil {
t.Fatal(err)
}
actual, err := FamiliarMatch(c.pattern, named)
actual, err := FamiliarMatch(tc.pattern, named)
if err != nil {
t.Fatal(err)
}
if actual != c.expected {
t.Fatalf("expected %s match %s to be %v, was %v", c.reference, c.pattern, c.expected, actual)
if actual != tc.expected {
t.Fatalf("expected %s match %s to be %v, was %v", tc.reference, tc.pattern, tc.expected, actual)
}
}
}
func TestParseDockerRef(t *testing.T) {
t.Parallel()
testcases := []struct {
tests := []struct {
name string
input string
expected string
@ -682,17 +682,17 @@ func TestParseDockerRef(t *testing.T) {
expected: "gcr.io/library/busybox@sha256:e6693c20186f837fc393390135d8a598a96a833917917789d63766cab6c59582",
},
}
for _, test := range testcases {
test := test
t.Run(test.name, func(t *testing.T) {
for _, tc := range tests {
tc := tc
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
normalized, err := ParseDockerRef(test.input)
normalized, err := ParseDockerRef(tc.input)
if err != nil {
t.Fatal(err)
}
output := normalized.String()
if output != test.expected {
t.Fatalf("expected %q to be parsed as %v, got %v", test.input, test.expected, output)
if output != tc.expected {
t.Fatalf("expected %q to be parsed as %v, got %v", tc.input, tc.expected, output)
}
_, err = Parse(output)
if err != nil {