ci: unleash the paralleltest lints (#100)

hashicorp · Jan 25, 2023 · bbacfd4 · bbacfd4
1 parent ef34f3a
commit bbacfd4
Show file tree

Hide file tree

Showing 66 changed files with 70 additions and 1 deletion.
diff --git a/.golangci.yml b/.golangci.yml
@@ -15,7 +15,7 @@ linters:
     - makezero
     - misspell
     - nilerr
-    # - paralleltest # Reference: https://github.com/kunwardeep/paralleltest/issues/14
+    - paralleltest
     - predeclared
     - staticcheck
     - tenv

diff --git a/float64validator/all_test.go b/float64validator/all_test.go
@@ -54,6 +54,7 @@ func TestAllValidatorValidateFloat64(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Float64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/float64validator/any_test.go b/float64validator/any_test.go
@@ -65,6 +65,7 @@ func TestAnyValidatorValidateFloat64(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Float64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/float64validator/any_with_all_warnings_test.go b/float64validator/any_with_all_warnings_test.go
@@ -66,6 +66,7 @@ func TestAnyWithAllWarningsValidatorValidateFloat64(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Float64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/float64validator/at_least_test.go b/float64validator/at_least_test.go
@@ -50,6 +50,7 @@ func TestAtLeastValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Float64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/float64validator/at_most_test.go b/float64validator/at_most_test.go
@@ -50,6 +50,7 @@ func TestAtMostValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Float64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/float64validator/between_test.go b/float64validator/between_test.go
@@ -68,6 +68,7 @@ func TestBetweenValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Float64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/float64validator/none_of_test.go b/float64validator/none_of_test.go
@@ -62,6 +62,7 @@ func TestNoneOfValidator(t *testing.T) {
 	for name, test := range testCases {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			req := validator.Float64Request{
 				ConfigValue: test.in,
 			}

diff --git a/float64validator/one_of_test.go b/float64validator/one_of_test.go
@@ -62,6 +62,7 @@ func TestOneOfValidator(t *testing.T) {
 	for name, test := range testCases {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			req := validator.Float64Request{
 				ConfigValue: test.in,
 			}

diff --git a/helpers/validatordiag/diag_test.go b/helpers/validatordiag/diag_test.go
@@ -33,6 +33,7 @@ func TestCapitalize(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			got := capitalize(test.input)
 
 			if got != test.expected {

diff --git a/int64validator/all_test.go b/int64validator/all_test.go
@@ -54,6 +54,7 @@ func TestAllValidatorValidateInt64(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/any_test.go b/int64validator/any_test.go
@@ -65,6 +65,7 @@ func TestAnyValidatorValidateInt64(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/any_with_all_warnings_test.go b/int64validator/any_with_all_warnings_test.go
@@ -66,6 +66,7 @@ func TestAnyWithAllWarningsValidatorValidateInt64(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/at_least_sum_of_test.go b/int64validator/at_least_sum_of_test.go
@@ -146,6 +146,7 @@ func TestAtLeastSumOfValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/at_least_test.go b/int64validator/at_least_test.go
@@ -46,6 +46,7 @@ func TestAtLeastValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/at_most_sum_of_test.go b/int64validator/at_most_sum_of_test.go
@@ -146,6 +146,7 @@ func TestAtMostSumOfValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/at_most_test.go b/int64validator/at_most_test.go
@@ -46,6 +46,7 @@ func TestAtMostValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/between_test.go b/int64validator/between_test.go
@@ -63,6 +63,7 @@ func TestBetweenValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/equal_to_sum_of_test.go b/int64validator/equal_to_sum_of_test.go
@@ -147,6 +147,7 @@ func TestEqualToSumOfValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.Int64Request{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/int64validator/none_of_test.go b/int64validator/none_of_test.go
@@ -62,6 +62,7 @@ func TestNoneOfValidator(t *testing.T) {
 	for name, test := range testCases {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			req := validator.Int64Request{
 				ConfigValue: test.in,
 			}

diff --git a/int64validator/one_of_test.go b/int64validator/one_of_test.go
@@ -62,6 +62,7 @@ func TestOneOfValidator(t *testing.T) {
 	for name, test := range testCases {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			req := validator.Int64Request{
 				ConfigValue: test.in,
 			}

diff --git a/internal/schemavalidator/also_requires_test.go b/internal/schemavalidator/also_requires_test.go
@@ -235,7 +235,9 @@ func TestAlsoRequiresValidatorValidate(t *testing.T) {
 	}
 
 	for name, test := range testCases {
+		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			res := &schemavalidator.AlsoRequiresValidatorResponse{}
 
 			schemavalidator.AlsoRequiresValidator{

diff --git a/internal/schemavalidator/at_least_one_of_test.go b/internal/schemavalidator/at_least_one_of_test.go
@@ -234,7 +234,9 @@ func TestAtLeastOneOfValidatorValidate(t *testing.T) {
 	}
 
 	for name, test := range testCases {
+		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			res := &schemavalidator.AtLeastOneOfValidatorResponse{}
 
 			schemavalidator.AtLeastOneOfValidator{

diff --git a/internal/schemavalidator/conflicts_with_test.go b/internal/schemavalidator/conflicts_with_test.go
@@ -236,7 +236,9 @@ func TestConflictsWithValidatorValidate(t *testing.T) {
 	}
 
 	for name, test := range testCases {
+		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			res := &schemavalidator.ConflictsWithValidatorResponse{}
 
 			schemavalidator.ConflictsWithValidator{

diff --git a/internal/schemavalidator/exactly_one_of_test.go b/internal/schemavalidator/exactly_one_of_test.go
@@ -237,7 +237,9 @@ func TestExactlyOneOfValidator(t *testing.T) {
 	}
 
 	for name, test := range testCases {
+		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			res := &schemavalidator.ExactlyOneOfValidatorResponse{}
 
 			schemavalidator.ExactlyOneOfValidator{

diff --git a/listvalidator/all_test.go b/listvalidator/all_test.go
@@ -67,6 +67,7 @@ func TestAllValidatorValidateList(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ListRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/listvalidator/any_test.go b/listvalidator/any_test.go
@@ -84,6 +84,7 @@ func TestAnyValidatorValidateList(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ListRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/listvalidator/any_with_all_warnings_test.go b/listvalidator/any_with_all_warnings_test.go
@@ -85,6 +85,7 @@ func TestAnyWithAllWarningsValidatorValidateList(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ListRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/listvalidator/size_at_least_test.go b/listvalidator/size_at_least_test.go
@@ -65,6 +65,7 @@ func TestSizeAtLeastValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ListRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/listvalidator/size_at_most_test.go b/listvalidator/size_at_most_test.go
@@ -69,6 +69,7 @@ func TestSizeAtMostValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ListRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/listvalidator/size_between_test.go b/listvalidator/size_between_test.go
@@ -108,6 +108,7 @@ func TestSizeBetweenValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ListRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/mapvalidator/all_test.go b/mapvalidator/all_test.go
@@ -67,6 +67,7 @@ func TestAllValidatorValidateMap(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.MapRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/mapvalidator/any_test.go b/mapvalidator/any_test.go
@@ -84,6 +84,7 @@ func TestAnyValidatorValidateMap(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.MapRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/mapvalidator/any_with_all_warnings_test.go b/mapvalidator/any_with_all_warnings_test.go
@@ -85,6 +85,7 @@ func TestAnyWithAllWarningsValidatorValidateMap(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.MapRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/mapvalidator/keys_are_test.go b/mapvalidator/keys_are_test.go
@@ -91,6 +91,7 @@ func TestKeysAreValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.MapRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/mapvalidator/size_at_least_test.go b/mapvalidator/size_at_least_test.go
@@ -65,6 +65,7 @@ func TestSizeAtLeastValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.MapRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/mapvalidator/size_at_most_test.go b/mapvalidator/size_at_most_test.go
@@ -69,6 +69,7 @@ func TestSizeAtMostValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.MapRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/mapvalidator/size_between_test.go b/mapvalidator/size_between_test.go
@@ -108,6 +108,7 @@ func TestSizeBetweenValidator(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.MapRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/numbervalidator/all_test.go b/numbervalidator/all_test.go
@@ -55,6 +55,7 @@ func TestAllValidatorValidateNumber(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.NumberRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/numbervalidator/any_test.go b/numbervalidator/any_test.go
@@ -66,6 +66,7 @@ func TestAnyValidatorValidateNumber(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.NumberRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/numbervalidator/any_with_all_warnings_test.go b/numbervalidator/any_with_all_warnings_test.go
@@ -67,6 +67,7 @@ func TestAnyWithAllWarningsValidatorValidateNumber(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.NumberRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/numbervalidator/none_of_test.go b/numbervalidator/none_of_test.go
@@ -63,6 +63,7 @@ func TestNoneOfValidator(t *testing.T) {
 	for name, test := range testCases {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			req := validator.NumberRequest{
 				ConfigValue: test.in,
 			}

diff --git a/numbervalidator/one_of_test.go b/numbervalidator/one_of_test.go
@@ -63,6 +63,7 @@ func TestOneOfValidator(t *testing.T) {
 	for name, test := range testCases {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			req := validator.NumberRequest{
 				ConfigValue: test.in,
 			}

diff --git a/objectvalidator/all_test.go b/objectvalidator/all_test.go
@@ -81,6 +81,7 @@ func TestAllValidatorValidateObject(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ObjectRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/objectvalidator/any_test.go b/objectvalidator/any_test.go
@@ -124,6 +124,7 @@ func TestAnyValidatorValidateObject(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ObjectRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/objectvalidator/any_with_all_warnings_test.go b/objectvalidator/any_with_all_warnings_test.go
@@ -129,6 +129,7 @@ func TestAnyWithAllWarningsValidatorValidateObject(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.ObjectRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/setvalidator/all_test.go b/setvalidator/all_test.go
@@ -67,6 +67,7 @@ func TestAllValidatorValidateSet(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.SetRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),

diff --git a/setvalidator/any_test.go b/setvalidator/any_test.go
@@ -84,6 +84,7 @@ func TestAnyValidatorValidateSet(t *testing.T) {
 	for name, test := range tests {
 		name, test := name, test
 		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 			request := validator.SetRequest{
 				Path:           path.Root("test"),
 				PathExpression: path.MatchRoot("test"),