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/templates/helper_test.go

@@ -15,47 +15,29 @@ import (
 )
 
 func TestSubjectBodySeparator(t *testing.T) {
-	test := func(input, subject, body string) {
-		loc := mailSubjectSplit.FindStringIndex(input)
+	for _, testCase := range []struct {
+		input, subject, body string
+	}{
+		{"Simple\n---------------\nCase", "Simple\n", "\nCase"},
+		{"Only\nBody", "", "Only\nBody"},
+		{"Minimal\n---\nseparator", "Minimal\n", "\nseparator"},
+		{"False --- separator", "", "False --- separator"},
+		{"False\n--- separator", "", "False\n--- separator"},
+		{"False ---\nseparator", "", "False ---\nseparator"},
+		{"With extra spaces\n-----   \t   \nBody", "With extra spaces\n", "\nBody"},
+		{"With leading spaces\n   -------\nOnly body", "", "With leading spaces\n   -------\nOnly body"},
+		{"Multiple\n---\n-------\n---\nSeparators", "Multiple\n", "\n-------\n---\nSeparators"},
+		{"Insufficient\n--\nSeparators", "", "Insufficient\n--\nSeparators"},
+	} {
+		loc := mailSubjectSplit.FindStringIndex(testCase.input)
 		if loc == nil {
-			assert.Empty(t, subject, "no subject found, but one expected")
-			assert.Equal(t, body, input)
+			assert.Empty(t, testCase.subject, "no subject found, but one expected")
+			assert.Equal(t, testCase.body, testCase.input)
 		} else {
-			assert.Equal(t, subject, input[0:loc[0]])
-			assert.Equal(t, body, input[loc[1]:])
+			assert.Equal(t, testCase.subject, testCase.input[0:loc[0]])
+			assert.Equal(t, testCase.body, testCase.input[loc[1]:])
 		}
 	}
-
-	test("Simple\n---------------\nCase",
-		"Simple\n",
-		"\nCase")
-	test("Only\nBody",
-		"",
-		"Only\nBody")
-	test("Minimal\n---\nseparator",
-		"Minimal\n",
-		"\nseparator")
-	test("False --- separator",
-		"",
-		"False --- separator")
-	test("False\n--- separator",
-		"",
-		"False\n--- separator")
-	test("False ---\nseparator",
-		"",
-		"False ---\nseparator")
-	test("With extra spaces\n-----   \t   \nBody",
-		"With extra spaces\n",
-		"\nBody")
-	test("With leading spaces\n   -------\nOnly body",
-		"",
-		"With leading spaces\n   -------\nOnly body")
-	test("Multiple\n---\n-------\n---\nSeparators",
-		"Multiple\n",
-		"\n-------\n---\nSeparators")
-	test("Insufficient\n--\nSeparators",
-		"",
-		"Insufficient\n--\nSeparators")
 }
 
 func TestSanitizeHTML(t *testing.T) {
@@ -148,33 +130,20 @@ func TestQueryBuild(t *testing.T) {
 		assert.Equal(t, "a=1&b=2&", string(QueryBuild("a=1&", "b", 2)))
 	})
 
-	t.Run("replace", func(t *testing.T) {
-		assert.Equal(t, "a=1&c=d&e=f", string(QueryBuild("a=b&c=d&e=f", "a", 1)))
-		assert.Equal(t, "a=b&c=1&e=f", string(QueryBuild("a=b&c=d&e=f", "c", 1)))
-		assert.Equal(t, "a=b&c=d&e=1", string(QueryBuild("a=b&c=d&e=f", "e", 1)))
-		assert.Equal(t, "a=b&c=d&e=f&k=1", string(QueryBuild("a=b&c=d&e=f", "k", 1)))
-	})
-
-	t.Run("replace-&", func(t *testing.T) {
-		assert.Equal(t, "&a=1&c=d&e=f", string(QueryBuild("&a=b&c=d&e=f", "a", 1)))
-		assert.Equal(t, "&a=b&c=1&e=f", string(QueryBuild("&a=b&c=d&e=f", "c", 1)))
-		assert.Equal(t, "&a=b&c=d&e=1", string(QueryBuild("&a=b&c=d&e=f", "e", 1)))
-		assert.Equal(t, "&a=b&c=d&e=f&k=1", string(QueryBuild("&a=b&c=d&e=f", "k", 1)))
-	})
-
-	t.Run("delete", func(t *testing.T) {
-		assert.Equal(t, "c=d&e=f", string(QueryBuild("a=b&c=d&e=f", "a", "")))
-		assert.Equal(t, "a=b&e=f", string(QueryBuild("a=b&c=d&e=f", "c", "")))
-		assert.Equal(t, "a=b&c=d", string(QueryBuild("a=b&c=d&e=f", "e", "")))
-		assert.Equal(t, "a=b&c=d&e=f", string(QueryBuild("a=b&c=d&e=f", "k", "")))
-	})
-
-	t.Run("delete-&", func(t *testing.T) {
-		assert.Equal(t, "&c=d&e=f", string(QueryBuild("&a=b&c=d&e=f", "a", "")))
-		assert.Equal(t, "&a=b&e=f", string(QueryBuild("&a=b&c=d&e=f", "c", "")))
-		assert.Equal(t, "&a=b&c=d", string(QueryBuild("&a=b&c=d&e=f", "e", "")))
-		assert.Equal(t, "&a=b&c=d&e=f", string(QueryBuild("&a=b&c=d&e=f", "k", "")))
-	})
+	for _, prefix := range []string{"", "&"} {
+		t.Run("replace"+prefix, func(t *testing.T) {
+			assert.Equal(t, prefix+"a=1&c=d&e=f", string(QueryBuild(prefix+"a=b&c=d&e=f", "a", 1)))
+			assert.Equal(t, prefix+"a=b&c=1&e=f", string(QueryBuild(prefix+"a=b&c=d&e=f", "c", 1)))
+			assert.Equal(t, prefix+"a=b&c=d&e=1", string(QueryBuild(prefix+"a=b&c=d&e=f", "e", 1)))
+			assert.Equal(t, prefix+"a=b&c=d&e=f&k=1", string(QueryBuild(prefix+"a=b&c=d&e=f", "k", 1)))
+		})
+		t.Run("delete"+prefix, func(t *testing.T) {
+			assert.Equal(t, prefix+"c=d&e=f", string(QueryBuild(prefix+"a=b&c=d&e=f", "a", "")))
+			assert.Equal(t, prefix+"a=b&e=f", string(QueryBuild(prefix+"a=b&c=d&e=f", "c", "")))
+			assert.Equal(t, prefix+"a=b&c=d", string(QueryBuild(prefix+"a=b&c=d&e=f", "e", "")))
+			assert.Equal(t, prefix+"a=b&c=d&e=f", string(QueryBuild(prefix+"a=b&c=d&e=f", "k", "")))
+		})
+	}
 }
 
 const queryNonASCII = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~" // all non-letter & non-number chars

modules/templates/util_date_test.go

@@ -39,21 +39,10 @@ func TestDateTime(t *testing.T) {
 
 	actual = du.FullTime(refTimeStamp)
 	assert.EqualValues(t, `<relative-time weekday="" year="numeric" format="datetime" month="short" day="numeric" hour="numeric" minute="numeric" second="numeric" data-tooltip-content data-tooltip-interactive="true" datetime="2017-12-31T19:00:00-05:00">2017-12-31 19:00:00 -05:00</relative-time>`, actual)
-}
 
-func TestTimeSince(t *testing.T) {
-	testTz, _ := time.LoadLocation("America/New_York")
-	defer test.MockVariableValue(&setting.DefaultUILocation, testTz)()
-	defer test.MockVariableValue(&setting.IsProd, true)()
-	defer test.MockVariableValue(&setting.IsInTesting, false)()
-
-	du := NewDateUtils()
 	assert.EqualValues(t, "-", du.TimeSince(nil))
 
-	refTimeStr := "2018-01-01T00:00:00Z"
-	refTime, _ := time.Parse(time.RFC3339, refTimeStr)
-
-	actual := du.TimeSince(refTime)
+	actual = du.TimeSince(refTime)
 	assert.EqualValues(t, `<relative-time prefix="" tense="past" datetime="2018-01-01T00:00:00Z" data-tooltip-content data-tooltip-interactive="true">2018-01-01 00:00:00 +00:00</relative-time>`, actual)
 
 	actual = timeSinceTo(&refTime, time.Time{})

modules/templates/util_render_test.go

@@ -77,40 +77,18 @@ func TestRenderRepoComment(t *testing.T) {
 	}
 	t.Run("RenderCommitBody", func(t *testing.T) {
 		defer test.MockVariableValue(&markup.RenderBehaviorForTesting.DisableAdditionalAttributes, true)()
-		type args struct {
-			msg string
-		}
 		tests := []struct {
 			name string
-			args args
-			want template.HTML
+			msg  string
 		}{
-			{
-				name: "multiple lines",
-				args: args{
-					msg: "first line\nsecond line",
-				},
-				want: "second line",
-			},
-			{
-				name: "multiple lines with leading newlines",
-				args: args{
-					msg: "\n\n\n\nfirst line\nsecond line",
-				},
-				want: "second line",
-			},
-			{
-				name: "multiple lines with trailing newlines",
-				args: args{
-					msg: "first line\nsecond line\n\n\n",
-				},
-				want: "second line",
-			},
+			{"multiple lines", "first line\nsecond line"},
+			{"multiple lines with leading newlines", "\n\n\n\nfirst line\nsecond line"},
+			{"multiple lines with trailing newlines", "first line\nsecond line\n\n\n"},
 		}
 		ut := newTestRenderUtils(t)
 		for _, tt := range tests {
 			t.Run(tt.name, func(t *testing.T) {
-				assert.Equalf(t, tt.want, ut.RenderCommitBody(tt.args.msg, mockRepo), "RenderCommitBody(%v, %v)", tt.args.msg, nil)
+				assert.Equalf(t, template.HTML("second line"), ut.RenderCommitBody(tt.msg, mockRepo), "RenderCommitBody(%v, %v)", tt.msg, nil)
 			})
 		}