test: consolidate Go tests (#39962)

Consolidate all Go tests. Coverage is identical to before. Go tests are
around 5% faster while being 7% smaller. No non-test code is touched.

modules/packages/chef/metadata_test.go

@@ -22,43 +22,37 @@ const (
 )
 
 func TestParsePackage(t *testing.T) {
-	t.Run("MissingMetadataFile", func(t *testing.T) {
-		var buf bytes.Buffer
-		zw := gzip.NewWriter(&buf)
-		tw := tar.NewWriter(zw)
-		tw.Close()
-		zw.Close()
+	for _, name := range []string{"MissingMetadataFile", "Valid"} {
+		t.Run(name, func(t *testing.T) {
+			var buf bytes.Buffer
+			zw := gzip.NewWriter(&buf)
+			tw := tar.NewWriter(zw)
+			if name == "Valid" {
+				content := `{"name":"` + packageName + `","version":"` + packageVersion + `"}`
+				hdr := &tar.Header{
+					Name: packageName + "/metadata.json",
+					Mode: 0o600,
+					Size: int64(len(content)),
+				}
+				tw.WriteHeader(hdr)
+				tw.Write([]byte(content))
+			}
+			tw.Close()
+			zw.Close()
 
-		p, err := ParsePackage(&buf)
-		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrMissingMetadataFile)
-	})
-
-	t.Run("Valid", func(t *testing.T) {
-		var buf bytes.Buffer
-		zw := gzip.NewWriter(&buf)
-		tw := tar.NewWriter(zw)
-
-		content := `{"name":"` + packageName + `","version":"` + packageVersion + `"}`
-
-		hdr := &tar.Header{
-			Name: packageName + "/metadata.json",
-			Mode: 0o600,
-			Size: int64(len(content)),
-		}
-		tw.WriteHeader(hdr)
-		tw.Write([]byte(content))
-
-		tw.Close()
-		zw.Close()
-
-		p, err := ParsePackage(&buf)
-		assert.NoError(t, err)
-		assert.NotNil(t, p)
-		assert.Equal(t, packageName, p.Name)
-		assert.Equal(t, packageVersion, p.Version)
-		assert.NotNil(t, p.Metadata)
-	})
+			p, err := ParsePackage(&buf)
+			if name == "MissingMetadataFile" {
+				assert.Nil(t, p)
+				assert.ErrorIs(t, err, ErrMissingMetadataFile)
+			} else {
+				assert.NoError(t, err)
+				assert.NotNil(t, p)
+				assert.Equal(t, packageName, p.Name)
+				assert.Equal(t, packageVersion, p.Version)
+				assert.NotNil(t, p.Metadata)
+			}
+		})
+	}
 }
 
 func TestParseChefMetadata(t *testing.T) {

modules/packages/composer/metadata_test.go

@@ -75,45 +75,28 @@ func TestCommentsUnmarshal(t *testing.T) {
 }
 
 func TestParsePackage(t *testing.T) {
-	t.Run("MissingComposerFile", func(t *testing.T) {
-		data := test.WriteZipArchive(map[string]string{"dummy.txt": ""}).Bytes()
+	for _, tc := range []struct {
+		name, filename, content string
+		expectedError           error
+	}{
+		{"MissingComposerFile", "dummy.txt", "", ErrMissingComposerFile},
+		{"MissingComposerFileInRoot", "sub/sub/composer.json", "", ErrMissingComposerFile},
+		{"InvalidComposerFile", "composer.json", "", nil},
+		{"InvalidPackageName", "composer.json", "{}", ErrInvalidName},
+		{"InvalidPackageVersion", "composer.json", `{"name": "gitea/composer-package", "version": "1.a.3"}`, ErrInvalidVersion},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			data := test.WriteZipArchive(map[string]string{tc.filename: tc.content}).Bytes()
 
-		cp, err := ParsePackage(bytes.NewReader(data))
-		assert.Nil(t, cp)
-		assert.ErrorIs(t, err, ErrMissingComposerFile)
-	})
-
-	t.Run("MissingComposerFileInRoot", func(t *testing.T) {
-		data := test.WriteZipArchive(map[string]string{"sub/sub/composer.json": ""}).Bytes()
-
-		cp, err := ParsePackage(bytes.NewReader(data))
-		assert.Nil(t, cp)
-		assert.ErrorIs(t, err, ErrMissingComposerFile)
-	})
-
-	t.Run("InvalidComposerFile", func(t *testing.T) {
-		data := test.WriteZipArchive(map[string]string{"composer.json": ""}).Bytes()
-
-		cp, err := ParsePackage(bytes.NewReader(data))
-		assert.Nil(t, cp)
-		assert.Error(t, err)
-	})
-
-	t.Run("InvalidPackageName", func(t *testing.T) {
-		data := test.WriteZipArchive(map[string]string{"composer.json": "{}"}).Bytes()
-
-		cp, err := ParsePackage(bytes.NewReader(data))
-		assert.Nil(t, cp)
-		assert.ErrorIs(t, err, ErrInvalidName)
-	})
-
-	t.Run("InvalidPackageVersion", func(t *testing.T) {
-		data := test.WriteZipArchive(map[string]string{"composer.json": `{"name": "gitea/composer-package", "version": "1.a.3"}`}).Bytes()
-
-		cp, err := ParsePackage(bytes.NewReader(data))
-		assert.Nil(t, cp)
-		assert.ErrorIs(t, err, ErrInvalidVersion)
-	})
+			cp, err := ParsePackage(bytes.NewReader(data))
+			assert.Nil(t, cp)
+			if tc.expectedError == nil {
+				assert.Error(t, err)
+			} else {
+				assert.ErrorIs(t, err, tc.expectedError)
+			}
+		})
+	}
 
 	t.Run("InvalidReadmePath", func(t *testing.T) {
 		data := test.WriteZipArchive(map[string]string{"composer.json": `{"name": "gitea/composer-package", "readme": "sub/README.md"}`}).Bytes()

modules/packages/conan/reference_test.go

@@ -49,45 +49,25 @@ func TestNewRecipeReference(t *testing.T) {
 }
 
 func TestRecipeReferenceRevisionOrDefault(t *testing.T) {
-	rref, err := NewRecipeReference("name", "1.0", "", "", "")
-	assert.NoError(t, err)
-	assert.Equal(t, DefaultRevision, rref.RevisionOrDefault())
-
-	rref, err = NewRecipeReference("name", "1.0", "", "", DefaultRevision)
-	assert.NoError(t, err)
-	assert.Equal(t, DefaultRevision, rref.RevisionOrDefault())
-
-	rref, err = NewRecipeReference("name", "1.0", "", "", "Az09")
-	assert.NoError(t, err)
-	assert.Equal(t, "Az09", rref.RevisionOrDefault())
-}
-
-func TestRecipeReferenceString(t *testing.T) {
-	rref, err := NewRecipeReference("name", "1.0", "", "", "")
-	assert.NoError(t, err)
-	assert.Equal(t, "name/1.0", rref.String())
-
-	rref, err = NewRecipeReference("name", "1.0", "user", "channel", "")
-	assert.NoError(t, err)
-	assert.Equal(t, "name/1.0@user/channel", rref.String())
-
-	rref, err = NewRecipeReference("name", "1.0", "user", "channel", "Az09")
-	assert.NoError(t, err)
-	assert.Equal(t, "name/1.0@user/channel#Az09", rref.String())
-}
-
-func TestRecipeReferenceLinkName(t *testing.T) {
-	rref, err := NewRecipeReference("name", "1.0", "", "", "")
-	assert.NoError(t, err)
-	assert.Equal(t, "name/1.0/_/_/0", rref.LinkName())
-
-	rref, err = NewRecipeReference("name", "1.0", "user", "channel", "")
-	assert.NoError(t, err)
-	assert.Equal(t, "name/1.0/user/channel/0", rref.LinkName())
-
-	rref, err = NewRecipeReference("name", "1.0", "user", "channel", "Az09")
-	assert.NoError(t, err)
-	assert.Equal(t, "name/1.0/user/channel/Az09", rref.LinkName())
+	for _, test := range []struct {
+		user, channel, revision string
+		method                  func(*RecipeReference) string
+		expected                string
+	}{
+		{"", "", "", (*RecipeReference).RevisionOrDefault, DefaultRevision},
+		{"", "", DefaultRevision, (*RecipeReference).RevisionOrDefault, DefaultRevision},
+		{"", "", "Az09", (*RecipeReference).RevisionOrDefault, "Az09"},
+		{"", "", "", (*RecipeReference).String, "name/1.0"},
+		{"user", "channel", "", (*RecipeReference).String, "name/1.0@user/channel"},
+		{"user", "channel", "Az09", (*RecipeReference).String, "name/1.0@user/channel#Az09"},
+		{"", "", "", (*RecipeReference).LinkName, "name/1.0/_/_/0"},
+		{"user", "channel", "", (*RecipeReference).LinkName, "name/1.0/user/channel/0"},
+		{"user", "channel", "Az09", (*RecipeReference).LinkName, "name/1.0/user/channel/Az09"},
+	} {
+		rref, err := NewRecipeReference("name", "1.0", test.user, test.channel, test.revision)
+		assert.NoError(t, err)
+		assert.Equal(t, test.expected, test.method(rref))
+	}
 }
 
 func TestNewPackageReference(t *testing.T) {
@@ -121,27 +101,19 @@ func TestNewPackageReference(t *testing.T) {
 func TestPackageReferenceRevisionOrDefault(t *testing.T) {
 	rref, _ := NewRecipeReference("name", "1.0", "", "", "")
 
-	pref, err := NewPackageReference(rref, "ref", "")
-	assert.NoError(t, err)
-	assert.Equal(t, DefaultRevision, pref.RevisionOrDefault())
-
-	pref, err = NewPackageReference(rref, "ref", DefaultRevision)
-	assert.NoError(t, err)
-	assert.Equal(t, DefaultRevision, pref.RevisionOrDefault())
-
-	pref, err = NewPackageReference(rref, "ref", "Az09")
-	assert.NoError(t, err)
-	assert.Equal(t, "Az09", pref.RevisionOrDefault())
-}
-
-func TestPackageReferenceLinkName(t *testing.T) {
-	rref, _ := NewRecipeReference("name", "1.0", "", "", "")
-
-	pref, err := NewPackageReference(rref, "ref", "")
-	assert.NoError(t, err)
-	assert.Equal(t, "ref/0", pref.LinkName())
-
-	pref, err = NewPackageReference(rref, "ref", "Az09")
-	assert.NoError(t, err)
-	assert.Equal(t, "ref/Az09", pref.LinkName())
+	for _, test := range []struct {
+		revision string
+		method   func(*PackageReference) string
+		expected string
+	}{
+		{"", (*PackageReference).RevisionOrDefault, DefaultRevision},
+		{DefaultRevision, (*PackageReference).RevisionOrDefault, DefaultRevision},
+		{"Az09", (*PackageReference).RevisionOrDefault, "Az09"},
+		{"", (*PackageReference).LinkName, "ref/0"},
+		{"Az09", (*PackageReference).LinkName, "ref/Az09"},
+	} {
+		pref, err := NewPackageReference(rref, "ref", test.revision)
+		assert.NoError(t, err)
+		assert.Equal(t, test.expected, test.method(pref))
+	}
 }

modules/packages/cran/metadata_test.go

@@ -37,8 +37,11 @@ func createDescription(name, version string) *bytes.Buffer {
 }
 
 func TestParsePackage(t *testing.T) {
-	t.Run(".tar.gz", func(t *testing.T) {
-		createArchive := func(filename string, content []byte) *bytes.Reader {
+	for _, archive := range []struct {
+		extension string
+		create    func(string, []byte) *bytes.Reader
+	}{
+		{".tar.gz", func(filename string, content []byte) *bytes.Reader {
 			var buf bytes.Buffer
 			gw := gzip.NewWriter(&buf)
 			tw := tar.NewWriter(gw)
@@ -52,70 +55,43 @@ func TestParsePackage(t *testing.T) {
 			tw.Close()
 			gw.Close()
 			return bytes.NewReader(buf.Bytes())
-		}
-
-		t.Run("MissingDescriptionFile", func(t *testing.T) {
-			buf := createArchive(
-				"dummy.txt",
-				[]byte{},
-			)
-
-			p, err := ParsePackage(buf, buf.Size())
-			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrMissingDescriptionFile)
-		})
-
-		t.Run("Valid", func(t *testing.T) {
-			buf := createArchive(
-				"package/DESCRIPTION",
-				createDescription(packageName, packageVersion).Bytes(),
-			)
-
-			p, err := ParsePackage(buf, buf.Size())
-
-			assert.NotNil(t, p)
-			assert.NoError(t, err)
-
-			assert.Equal(t, packageName, p.Name)
-			assert.Equal(t, packageVersion, p.Version)
-		})
-	})
-
-	t.Run(".zip", func(t *testing.T) {
-		createArchive := func(filename string, content []byte) *bytes.Reader {
+		}},
+		{".zip", func(filename string, content []byte) *bytes.Reader {
 			var buf bytes.Buffer
 			archive := zip.NewWriter(&buf)
 			w, _ := archive.Create(filename)
 			w.Write(content)
 			archive.Close()
 			return bytes.NewReader(buf.Bytes())
-		}
+		}},
+	} {
+		t.Run(archive.extension, func(t *testing.T) {
+			t.Run("MissingDescriptionFile", func(t *testing.T) {
+				buf := archive.create(
+					"dummy.txt",
+					[]byte{},
+				)
 
-		t.Run("MissingDescriptionFile", func(t *testing.T) {
-			buf := createArchive(
-				"dummy.txt",
-				[]byte{},
-			)
+				p, err := ParsePackage(buf, buf.Size())
+				assert.Nil(t, p)
+				assert.ErrorIs(t, err, ErrMissingDescriptionFile)
+			})
 
-			p, err := ParsePackage(buf, buf.Size())
-			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrMissingDescriptionFile)
+			t.Run("Valid", func(t *testing.T) {
+				buf := archive.create(
+					"package/DESCRIPTION",
+					createDescription(packageName, packageVersion).Bytes(),
+				)
+
+				p, err := ParsePackage(buf, buf.Size())
+				assert.NotNil(t, p)
+				assert.NoError(t, err)
+
+				assert.Equal(t, packageName, p.Name)
+				assert.Equal(t, packageVersion, p.Version)
+			})
 		})
-
-		t.Run("Valid", func(t *testing.T) {
-			buf := createArchive(
-				"package/DESCRIPTION",
-				createDescription(packageName, packageVersion).Bytes(),
-			)
-
-			p, err := ParsePackage(buf, buf.Size())
-			assert.NotNil(t, p)
-			assert.NoError(t, err)
-
-			assert.Equal(t, packageName, p.Name)
-			assert.Equal(t, packageVersion, p.Version)
-		})
-	})
+	}
 }
 
 func TestParseDescription(t *testing.T) {

modules/packages/debian/metadata_test.go

@@ -110,21 +110,14 @@ func TestParsePackage(t *testing.T) {
 				w.Write(buf.Bytes())
 				w.Close()
 
-				data := createArchive(map[string][]byte{"control.tar" + c.Extension: cbuf.Bytes()})
-
-				p, err := ParsePackage(data)
-				assert.NotNil(t, p)
-				assert.NoError(t, err)
-				assert.Equal(t, "gitea", p.Name)
-
-				t.Run("TrailingSlash", func(t *testing.T) {
-					data := createArchive(map[string][]byte{"control.tar" + c.Extension + "/": cbuf.Bytes()})
+				for _, suffix := range []string{"", "/"} {
+					data := createArchive(map[string][]byte{"control.tar" + c.Extension + suffix: cbuf.Bytes()})
 
 					p, err := ParsePackage(data)
 					assert.NotNil(t, p)
 					assert.NoError(t, err)
 					assert.Equal(t, "gitea", p.Name)
-				})
+				}
 			})
 		}
 	})

modules/packages/goproxy/metadata_test.go

@@ -28,58 +28,41 @@ func TestParsePackage(t *testing.T) {
 		return bytes.NewReader(buf.Bytes())
 	}
 
-	t.Run("EmptyPackage", func(t *testing.T) {
-		data := createArchive(nil)
-
-		p, err := ParsePackage(data, int64(data.Len()))
-		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidStructure)
-	})
-
-	t.Run("InvalidNameOrVersionStructure", func(t *testing.T) {
-		data := createArchive(map[string][]byte{
+	for _, testCase := range []struct {
+		name          string
+		files         map[string][]byte
+		expectedError error
+		goMod         string
+	}{
+		{"EmptyPackage", nil, ErrInvalidStructure, ""},
+		{"InvalidNameOrVersionStructure", map[string][]byte{
 			packageName + "/" + packageVersion + "/go.mod": {},
-		})
-
-		p, err := ParsePackage(data, int64(data.Len()))
-		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidStructure)
-	})
-
-	t.Run("GoModFileInWrongDirectory", func(t *testing.T) {
-		data := createArchive(map[string][]byte{
+		}, ErrInvalidStructure, ""},
+		{"GoModFileInWrongDirectory", map[string][]byte{
 			packageName + "@" + packageVersion + "/subdir/go.mod": {},
-		})
-
-		p, err := ParsePackage(data, int64(data.Len()))
-		assert.NotNil(t, p)
-		assert.NoError(t, err)
-		assert.Equal(t, packageName, p.Name)
-		assert.Equal(t, packageVersion, p.Version)
-		assert.Equal(t, "module gitea.com/go-gitea/gitea", p.GoMod)
-	})
-
-	t.Run("InvalidVersion", func(t *testing.T) {
-		data := createArchive(map[string][]byte{
+		}, nil, "module gitea.com/go-gitea/gitea"},
+		{"InvalidVersion", map[string][]byte{
 			packageName + "@v1.0.0\nv99.0.0/go.mod": []byte("module " + packageName),
-		})
-
-		p, err := ParsePackage(data, int64(data.Len()))
-		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidVersion)
-	})
-
-	t.Run("Valid", func(t *testing.T) {
-		data := createArchive(map[string][]byte{
+		}, ErrInvalidVersion, ""},
+		{"Valid", map[string][]byte{
 			packageName + "@" + packageVersion + "/subdir/go.mod": []byte("invalid"),
 			packageName + "@" + packageVersion + "/go.mod":        []byte("valid"),
-		})
+		}, nil, "valid"},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			data := createArchive(testCase.files)
 
-		p, err := ParsePackage(data, int64(data.Len()))
-		assert.NotNil(t, p)
-		assert.NoError(t, err)
-		assert.Equal(t, packageName, p.Name)
-		assert.Equal(t, packageVersion, p.Version)
-		assert.Equal(t, "valid", p.GoMod)
-	})
+			p, err := ParsePackage(data, int64(data.Len()))
+			if testCase.expectedError != nil {
+				assert.Nil(t, p)
+				assert.ErrorIs(t, err, testCase.expectedError)
+			} else {
+				assert.NotNil(t, p)
+				assert.NoError(t, err)
+				assert.Equal(t, packageName, p.Name)
+				assert.Equal(t, packageVersion, p.Version)
+				assert.Equal(t, testCase.goMod, p.GoMod)
+			}
+		})
+	}
 }

modules/packages/multi_hasher_test.go

@@ -18,36 +18,28 @@ const (
 )
 
 func TestMultiHasherSums(t *testing.T) {
-	t.Run("Sums", func(t *testing.T) {
-		h := NewMultiHasher()
-		h.Write([]byte("gitea"))
+	for _, content := range []string{"gitea", "git"} {
+		t.Run(content, func(t *testing.T) {
+			h := NewMultiHasher()
+			h.Write([]byte(content))
 
-		hashMD5, hashSHA1, hashSHA256, hashSHA512 := h.Sums()
+			if content == "git" {
+				state, err := h.MarshalBinary()
+				assert.NoError(t, err)
 
-		assert.Equal(t, expectedMD5, hex.EncodeToString(hashMD5))
-		assert.Equal(t, expectedSHA1, hex.EncodeToString(hashSHA1))
-		assert.Equal(t, expectedSHA256, hex.EncodeToString(hashSHA256))
-		assert.Equal(t, expectedSHA512, hex.EncodeToString(hashSHA512))
-	})
+				h = NewMultiHasher()
+				err = h.UnmarshalBinary(state)
+				assert.NoError(t, err)
 
-	t.Run("State", func(t *testing.T) {
-		h := NewMultiHasher()
-		h.Write([]byte("git"))
+				h.Write([]byte("ea"))
+			}
 
-		state, err := h.MarshalBinary()
-		assert.NoError(t, err)
+			hashMD5, hashSHA1, hashSHA256, hashSHA512 := h.Sums()
 
-		h2 := NewMultiHasher()
-		err = h2.UnmarshalBinary(state)
-		assert.NoError(t, err)
-
-		h2.Write([]byte("ea"))
-
-		hashMD5, hashSHA1, hashSHA256, hashSHA512 := h2.Sums()
-
-		assert.Equal(t, expectedMD5, hex.EncodeToString(hashMD5))
-		assert.Equal(t, expectedSHA1, hex.EncodeToString(hashSHA1))
-		assert.Equal(t, expectedSHA256, hex.EncodeToString(hashSHA256))
-		assert.Equal(t, expectedSHA512, hex.EncodeToString(hashSHA512))
-	})
+			assert.Equal(t, expectedMD5, hex.EncodeToString(hashMD5))
+			assert.Equal(t, expectedSHA1, hex.EncodeToString(hashSHA1))
+			assert.Equal(t, expectedSHA256, hex.EncodeToString(hashSHA256))
+			assert.Equal(t, expectedSHA512, hex.EncodeToString(hashSHA512))
+		})
+	}
 }

modules/packages/npm/creator_test.go

@@ -52,71 +52,38 @@ func TestParsePackage(t *testing.T) {
 		assert.ErrorIs(t, err, ErrInvalidPackage)
 	})
 
-	t.Run("InvalidPackageName", func(t *testing.T) {
-		test := func(t *testing.T, name string) {
-			p, err := parseUploadPackage(&packageUpload{
-				PackageMetadata: PackageMetadata{
-					ID:   name,
-					Name: name,
-					Versions: map[string]*PackageMetadataVersion{
-						packageVersion: {
-							Name: name,
+	for _, testCase := range []struct {
+		name          string
+		names         []string
+		expectedError error
+	}{
+		{"InvalidPackageName", []string{
+			" test ", " test", "test ", "te st", "Test", "_test", ".test", "^test", "te^st",
+			"te|st", "te)(st", "te'st", "te!st", "te*st", "te~st", "invalid/scope", "@invalid/_name", "@invalid/.name",
+		}, ErrInvalidPackageName},
+		{"ValidPackageName", []string{
+			"test", "@scope/name", "@scope/q", "q", "@scope/package-name", "@scope/package.name", "@scope/package_name",
+			"123name", "----", packageFullName,
+		}, ErrInvalidPackageVersion},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			for _, name := range testCase.names {
+				p, err := parseUploadPackage(&packageUpload{
+					PackageMetadata: PackageMetadata{
+						ID:   name,
+						Name: name,
+						Versions: map[string]*PackageMetadataVersion{
+							packageVersion: {
+								Name: name,
+							},
 						},
 					},
-				},
-			})
-			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidPackageName)
-		}
-
-		test(t, " test ")
-		test(t, " test")
-		test(t, "test ")
-		test(t, "te st")
-		test(t, "Test")
-		test(t, "_test")
-		test(t, ".test")
-		test(t, "^test")
-		test(t, "te^st")
-		test(t, "te|st")
-		test(t, "te)(st")
-		test(t, "te'st")
-		test(t, "te!st")
-		test(t, "te*st")
-		test(t, "te~st")
-		test(t, "invalid/scope")
-		test(t, "@invalid/_name")
-		test(t, "@invalid/.name")
-	})
-
-	t.Run("ValidPackageName", func(t *testing.T) {
-		test := func(t *testing.T, name string) {
-			p, err := parseUploadPackage(&packageUpload{
-				PackageMetadata: PackageMetadata{
-					ID:   name,
-					Name: name,
-					Versions: map[string]*PackageMetadataVersion{
-						packageVersion: {
-							Name: name,
-						},
-					},
-				},
-			})
-			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidPackageVersion)
-		}
-
-		test(t, "test")
-		test(t, "@scope/name")
-		test(t, "@scope/q")
-		test(t, "q")
-		test(t, "@scope/package-name")
-		test(t, "@scope/package.name")
-		test(t, "@scope/package_name")
-		test(t, "123name")
-		test(t, "----")
-		test(t, packageFullName)
-	})
+				})
+				assert.Nil(t, p)
+				assert.ErrorIs(t, err, testCase.expectedError)
+			}
+		})
+	}
 
 	t.Run("InvalidPackageVersion", func(t *testing.T) {
 		version := "first-version"
@@ -136,108 +103,42 @@ func TestParsePackage(t *testing.T) {
 		assert.ErrorIs(t, err, ErrInvalidPackageVersion)
 	})
 
-	t.Run("InvalidAttachment", func(t *testing.T) {
-		b, _ := json.Marshal(packageUpload{
-			PackageMetadata: PackageMetadata{
-				ID:   packageFullName,
-				Name: packageFullName,
-				Versions: map[string]*PackageMetadataVersion{
-					packageVersion: {
-						Name:    packageFullName,
-						Version: packageVersion,
-					},
-				},
-			},
-			Attachments: map[string]*PackageAttachment{
-				"dummy.tgz": {},
-			},
-		})
-
-		p, _, err := ParseUpload(bytes.NewReader(b))
-		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidAttachment)
-	})
-
-	t.Run("InvalidData", func(t *testing.T) {
-		filename := fmt.Sprintf("%s-%s.tgz", packageFullName, packageVersion)
-		b, _ := json.Marshal(packageUpload{
-			PackageMetadata: PackageMetadata{
-				ID:   packageFullName,
-				Name: packageFullName,
-				Versions: map[string]*PackageMetadataVersion{
-					packageVersion: {
-						Name:    packageFullName,
-						Version: packageVersion,
-					},
-				},
-			},
-			Attachments: map[string]*PackageAttachment{
-				filename: {
-					Data: "/",
-				},
-			},
-		})
-
-		p, _, err := ParseUpload(bytes.NewReader(b))
-		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidAttachment)
-	})
-
-	t.Run("InvalidIntegrity", func(t *testing.T) {
-		filename := fmt.Sprintf("%s-%s.tgz", packageFullName, packageVersion)
-		b, _ := json.Marshal(packageUpload{
-			PackageMetadata: PackageMetadata{
-				ID:   packageFullName,
-				Name: packageFullName,
-				Versions: map[string]*PackageMetadataVersion{
-					packageVersion: {
-						Name:    packageFullName,
-						Version: packageVersion,
-						Dist: PackageDistribution{
-							Integrity: "sha512-test==",
+	for _, testCase := range []struct {
+		name, filename, data, integrity string
+		expectedError                   error
+	}{
+		{"InvalidAttachment", "dummy.tgz", "", "", ErrInvalidAttachment},
+		{"InvalidData", fmt.Sprintf("%s-%s.tgz", packageFullName, packageVersion), "/", "", ErrInvalidAttachment},
+		{"InvalidIntegrity", fmt.Sprintf("%s-%s.tgz", packageFullName, packageVersion), data, "sha512-test==", ErrInvalidIntegrity},
+		{"InvalidIntegrity2", fmt.Sprintf("%s-%s.tgz", packageFullName, packageVersion), base64.StdEncoding.EncodeToString([]byte("data")), integrity, ErrInvalidIntegrity},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			b, _ := json.Marshal(packageUpload{
+				PackageMetadata: PackageMetadata{
+					ID:   packageFullName,
+					Name: packageFullName,
+					Versions: map[string]*PackageMetadataVersion{
+						packageVersion: {
+							Name:    packageFullName,
+							Version: packageVersion,
+							Dist: PackageDistribution{
+								Integrity: testCase.integrity,
+							},
 						},
 					},
 				},
-			},
-			Attachments: map[string]*PackageAttachment{
-				filename: {
-					Data: data,
-				},
-			},
-		})
-
-		p, _, err := ParseUpload(bytes.NewReader(b))
-		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidIntegrity)
-	})
-
-	t.Run("InvalidIntegrity2", func(t *testing.T) {
-		filename := fmt.Sprintf("%s-%s.tgz", packageFullName, packageVersion)
-		b, _ := json.Marshal(packageUpload{
-			PackageMetadata: PackageMetadata{
-				ID:   packageFullName,
-				Name: packageFullName,
-				Versions: map[string]*PackageMetadataVersion{
-					packageVersion: {
-						Name:    packageFullName,
-						Version: packageVersion,
-						Dist: PackageDistribution{
-							Integrity: integrity,
-						},
+				Attachments: map[string]*PackageAttachment{
+					testCase.filename: {
+						Data: testCase.data,
 					},
 				},
-			},
-			Attachments: map[string]*PackageAttachment{
-				filename: {
-					Data: base64.StdEncoding.EncodeToString([]byte("data")),
-				},
-			},
-		})
+			})
 
-		p, _, err := ParseUpload(bytes.NewReader(b))
-		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidIntegrity)
-	})
+			p, _, err := ParseUpload(bytes.NewReader(b))
+			assert.Nil(t, p)
+			assert.ErrorIs(t, err, testCase.expectedError)
+		})
+	}
 
 	t.Run("Valid", func(t *testing.T) {
 		filename := fmt.Sprintf("%s-%s.tgz", packageFullName, packageVersion)

modules/packages/nuget/metadata_test.go

@@ -92,53 +92,37 @@ func TestParsePackageMetaData(t *testing.T) {
 		return buf.Bytes()
 	}
 
-	t.Run("MissingNuspecFile", func(t *testing.T) {
-		data := createArchive(map[string]string{"dummy.txt": ""})
-
-		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-		assert.Nil(t, np)
-		assert.ErrorIs(t, err, ErrMissingNuspecFile)
-	})
-
-	t.Run("MissingNuspecFileInRoot", func(t *testing.T) {
-		data := createArchive(map[string]string{"sub/package.nuspec": ""})
-
-		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-		assert.Nil(t, np)
-		assert.ErrorIs(t, err, ErrMissingNuspecFile)
-	})
-
-	t.Run("InvalidNuspecFile", func(t *testing.T) {
-		data := createArchive(map[string]string{"package.nuspec": ""})
-
-		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-		assert.Nil(t, np)
-		assert.Error(t, err)
-	})
-
-	t.Run("InvalidPackageId", func(t *testing.T) {
-		data := createArchive(map[string]string{"package.nuspec": `<?xml version="1.0" encoding="utf-8"?>
+	for _, testCase := range []struct {
+		name          string
+		files         map[string]string
+		expectedError error
+	}{
+		{"MissingNuspecFile", map[string]string{"dummy.txt": ""}, ErrMissingNuspecFile},
+		{"MissingNuspecFileInRoot", map[string]string{"sub/package.nuspec": ""}, ErrMissingNuspecFile},
+		{"InvalidNuspecFile", map[string]string{"package.nuspec": ""}, nil},
+		{"InvalidPackageId", map[string]string{"package.nuspec": `<?xml version="1.0" encoding="utf-8"?>
 		<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
 		  <metadata></metadata>
-		</package>`})
-
-		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-		assert.Nil(t, np)
-		assert.ErrorIs(t, err, ErrNuspecInvalidID)
-	})
-
-	t.Run("InvalidPackageVersion", func(t *testing.T) {
-		data := createArchive(map[string]string{"package.nuspec": `<?xml version="1.0" encoding="utf-8"?>
+		</package>`}, ErrNuspecInvalidID},
+		{"InvalidPackageVersion", map[string]string{"package.nuspec": `<?xml version="1.0" encoding="utf-8"?>
 		<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
 		  <metadata>
 			<id>` + id + `</id>
 		  </metadata>
-		</package>`})
+		</package>`}, ErrNuspecInvalidVersion},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			data := createArchive(testCase.files)
 
-		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-		assert.Nil(t, np)
-		assert.ErrorIs(t, err, ErrNuspecInvalidVersion)
-	})
+			np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
+			assert.Nil(t, np)
+			if testCase.expectedError == nil {
+				assert.Error(t, err)
+			} else {
+				assert.ErrorIs(t, err, testCase.expectedError)
+			}
+		})
+	}
 
 	t.Run("MissingReadme", func(t *testing.T) {
 		data := createArchive(map[string]string{"package.nuspec": nuspecContent})

modules/packages/rpm/metadata_test.go

@@ -110,49 +110,22 @@ OvSXaRmpzyTLHvsXg/M9EcwbAAA=`
 		},
 		p.FileMetadata.Provides,
 	)
-	assert.ElementsMatch(
-		t,
-		[]*Entry{
-			{
-				Name: "/bin/sh",
-			},
-			{
-				Name: "/bin/sh",
-			},
-			{
-				Name: "/bin/sh",
-			},
-			{
-				Name:    "rpmlib(CompressedFileNames)",
-				Flags:   "LE",
-				Version: "3.0.4",
-				Epoch:   "0",
-				Release: "1",
-			},
-			{
-				Name:    "rpmlib(FileDigests)",
-				Flags:   "LE",
-				Version: "4.6.0",
-				Epoch:   "0",
-				Release: "1",
-			},
-			{
-				Name:    "rpmlib(PayloadFilesHavePrefix)",
-				Flags:   "LE",
-				Version: "4.0",
-				Epoch:   "0",
-				Release: "1",
-			},
-			{
-				Name:    "rpmlib(PayloadIsXz)",
-				Flags:   "LE",
-				Version: "5.2",
-				Epoch:   "0",
-				Release: "1",
-			},
-		},
-		p.FileMetadata.Requires,
-	)
+	requires := []*Entry{{Name: "/bin/sh"}, {Name: "/bin/sh"}, {Name: "/bin/sh"}}
+	for _, dependency := range []struct{ name, version string }{
+		{"rpmlib(CompressedFileNames)", "3.0.4"},
+		{"rpmlib(FileDigests)", "4.6.0"},
+		{"rpmlib(PayloadFilesHavePrefix)", "4.0"},
+		{"rpmlib(PayloadIsXz)", "5.2"},
+	} {
+		requires = append(requires, &Entry{
+			Name:    dependency.name,
+			Flags:   "LE",
+			Version: dependency.version,
+			Epoch:   "0",
+			Release: "1",
+		})
+	}
+	assert.ElementsMatch(t, requires, p.FileMetadata.Requires)
 	assert.ElementsMatch(
 		t,
 		[]*File{

modules/packages/swift/metadata_test.go

@@ -164,15 +164,15 @@ func TestParsePackage(t *testing.T) {
 		assert.Equal(t, contentA, p.Metadata.Manifests[""].Content)
 	})
 
-	t.Run("WithMetadata", func(t *testing.T) {
+	parseWithMetadata := func(metadata string) (*Package, error) {
 		data := test.WriteZipArchive(map[string]string{
 			"Package.swift": "// swift-tools-version:5.7\n//\n//  Package.swift",
 		})
+		return ParsePackage(bytes.NewReader(data.Bytes()), int64(data.Len()), strings.NewReader(metadata))
+	}
 
-		p, err := ParsePackage(
-			bytes.NewReader(data.Bytes()), int64(data.Len()),
-			strings.NewReader(`{"name":"`+packageName+`","version":"`+packageVersion+`","description":"`+packageDescription+`","keywords":["swift","package"],"license":"`+packageLicense+`","licenseURL":"`+packageLicenseURL+`","codeRepository":"`+packageRepositoryURL+`","author":{"givenName":"`+packageAuthor+`"},"repositoryURLs":["`+packageRepositoryURL+`"]}`),
-		)
+	t.Run("WithMetadata", func(t *testing.T) {
+		p, err := parseWithMetadata(`{"name":"` + packageName + `","version":"` + packageVersion + `","description":"` + packageDescription + `","keywords":["swift","package"],"license":"` + packageLicense + `","licenseURL":"` + packageLicenseURL + `","codeRepository":"` + packageRepositoryURL + `","author":{"givenName":"` + packageAuthor + `"},"repositoryURLs":["` + packageRepositoryURL + `"]}`)
 		assert.NotNil(t, p)
 		assert.NoError(t, err)
 
@@ -192,15 +192,8 @@ func TestParsePackage(t *testing.T) {
 	})
 
 	t.Run("WithExplicitNameField", func(t *testing.T) {
-		data := test.WriteZipArchive(map[string]string{
-			"Package.swift": "// swift-tools-version:5.7\n//\n//  Package.swift",
-		})
-
 		authorName := "John Doe"
-		p, err := ParsePackage(
-			bytes.NewReader(data.Bytes()), int64(data.Len()),
-			strings.NewReader(`{"name":"`+packageName+`","version":"`+packageVersion+`","description":"`+packageDescription+`","author":{"name":"`+authorName+`","givenName":"John","familyName":"Doe"}}`),
-		)
+		p, err := parseWithMetadata(`{"name":"` + packageName + `","version":"` + packageVersion + `","description":"` + packageDescription + `","author":{"name":"` + authorName + `","givenName":"John","familyName":"Doe"}}`)
 		assert.NotNil(t, p)
 		assert.NoError(t, err)
 
@@ -210,14 +203,7 @@ func TestParsePackage(t *testing.T) {
 	})
 
 	t.Run("WithEmptyJSONMetadata", func(t *testing.T) {
-		data := test.WriteZipArchive(map[string]string{
-			"Package.swift": "// swift-tools-version:5.7\n//\n//  Package.swift",
-		})
-
-		p, err := ParsePackage(
-			bytes.NewReader(data.Bytes()), int64(data.Len()),
-			strings.NewReader(`{}`),
-		)
+		p, err := parseWithMetadata(`{}`)
 		assert.NotNil(t, p)
 		assert.NoError(t, err)
 		assert.NotNil(t, p.Metadata)
@@ -226,15 +212,8 @@ func TestParsePackage(t *testing.T) {
 	})
 
 	t.Run("NameFieldGeneration", func(t *testing.T) {
-		data := test.WriteZipArchive(map[string]string{
-			"Package.swift": "// swift-tools-version:5.7\n//\n//  Package.swift",
-		})
-
 		// Test with only individual name components - Name should be auto-generated
-		p, err := ParsePackage(
-			bytes.NewReader(data.Bytes()), int64(data.Len()),
-			strings.NewReader(`{"author":{"givenName":"John","middleName":"Q","familyName":"Doe"}}`),
-		)
+		p, err := parseWithMetadata(`{"author":{"givenName":"John","middleName":"Q","familyName":"Doe"}}`)
 		assert.NotNil(t, p)
 		assert.NoError(t, err)
 		assert.Equal(t, "John Q Doe", p.Metadata.Author.Name)
@@ -245,42 +224,16 @@ func TestParsePackage(t *testing.T) {
 }
 
 func TestTrimmedVersionString(t *testing.T) {
-	cases := []struct {
-		Version  *version.Version
+	for _, c := range []struct {
+		Versions []string
 		Expected string
 	}{
-		{
-			Version:  version.Must(version.NewVersion("1")),
-			Expected: "1.0",
-		},
-		{
-			Version:  version.Must(version.NewVersion("1.0")),
-			Expected: "1.0",
-		},
-		{
-			Version:  version.Must(version.NewVersion("1.0.0")),
-			Expected: "1.0",
-		},
-		{
-			Version:  version.Must(version.NewVersion("1.0.1")),
-			Expected: "1.0.1",
-		},
-		{
-			Version:  version.Must(version.NewVersion("1.0+meta")),
-			Expected: "1.0",
-		},
-		{
-			Version:  version.Must(version.NewVersion("1.0.0+meta")),
-			Expected: "1.0",
-		},
-		{
-			Version:  version.Must(version.NewVersion("1.0.1+meta")),
-			Expected: "1.0.1",
-		},
-	}
-
-	for _, c := range cases {
-		assert.Equal(t, c.Expected, TrimmedVersionString(c.Version))
+		{[]string{"1", "1.0", "1.0.0", "1.0+meta", "1.0.0+meta"}, "1.0"},
+		{[]string{"1.0.1", "1.0.1+meta"}, "1.0.1"},
+	} {
+		for _, input := range c.Versions {
+			assert.Equal(t, c.Expected, TrimmedVersionString(version.Must(version.NewVersion(input))))
+		}
 	}
 }
 

modules/packages/vagrant/metadata_test.go

@@ -49,29 +49,6 @@ func TestParseMetadataFromBox(t *testing.T) {
 		assert.NoError(t, err)
 	})
 
-	t.Run("Valid", func(t *testing.T) {
-		content, err := json.Marshal(map[string]string{
-			"description": description,
-			"author":      author,
-			"website":     projectURL,
-			"repository":  repositoryURL,
-		})
-		assert.NoError(t, err)
-
-		data := createArchive(map[string][]byte{"info.json": content})
-
-		metadata, err := ParseMetadataFromBox(data)
-		assert.NotNil(t, metadata)
-		assert.NoError(t, err)
-
-		assert.Equal(t, author, metadata.Author)
-		assert.Equal(t, description, metadata.Description)
-		assert.Equal(t, projectURL, metadata.ProjectURL)
-		assert.Equal(t, repositoryURL, metadata.RepositoryURL)
-	})
-}
-
-func TestParseInfoFile(t *testing.T) {
 	t.Run("UnknownKeys", func(t *testing.T) {
 		content, err := json.Marshal(map[string]string{
 			"package": "",
@@ -89,22 +66,31 @@ func TestParseInfoFile(t *testing.T) {
 		assert.Empty(t, metadata.RepositoryURL)
 	})
 
-	t.Run("Valid", func(t *testing.T) {
-		content, err := json.Marshal(map[string]string{
-			"description": description,
-			"author":      author,
-			"website":     projectURL,
-			"repository":  repositoryURL,
+	for name, parse := range map[string]func([]byte) (*Metadata, error){
+		"ValidBox": func(content []byte) (*Metadata, error) {
+			return ParseMetadataFromBox(createArchive(map[string][]byte{"info.json": content}))
+		},
+		"ValidInfoFile": func(content []byte) (*Metadata, error) {
+			return ParseInfoFile(bytes.NewReader(content))
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			content, err := json.Marshal(map[string]string{
+				"description": description,
+				"author":      author,
+				"website":     projectURL,
+				"repository":  repositoryURL,
+			})
+			assert.NoError(t, err)
+
+			metadata, err := parse(content)
+			assert.NotNil(t, metadata)
+			assert.NoError(t, err)
+
+			assert.Equal(t, author, metadata.Author)
+			assert.Equal(t, description, metadata.Description)
+			assert.Equal(t, projectURL, metadata.ProjectURL)
+			assert.Equal(t, repositoryURL, metadata.RepositoryURL)
 		})
-		assert.NoError(t, err)
-
-		metadata, err := ParseInfoFile(bytes.NewReader(content))
-		assert.NotNil(t, metadata)
-		assert.NoError(t, err)
-
-		assert.Equal(t, author, metadata.Author)
-		assert.Equal(t, description, metadata.Description)
-		assert.Equal(t, projectURL, metadata.ProjectURL)
-		assert.Equal(t, repositoryURL, metadata.RepositoryURL)
-	})
+	}
 }