From 7b4377ad9d8a7205416df8d6217ef2b010f89481 Mon Sep 17 00:00:00 2001 From: Taras Madan Date: Wed, 22 Jan 2025 16:07:17 +0100 Subject: vendor: delete --- vendor/github.com/kunwardeep/paralleltest/LICENSE | 21 -- .../paralleltest/pkg/paralleltest/paralleltest.go | 320 --------------------- 2 files changed, 341 deletions(-) delete mode 100644 vendor/github.com/kunwardeep/paralleltest/LICENSE delete mode 100644 vendor/github.com/kunwardeep/paralleltest/pkg/paralleltest/paralleltest.go (limited to 'vendor/github.com/kunwardeep') diff --git a/vendor/github.com/kunwardeep/paralleltest/LICENSE b/vendor/github.com/kunwardeep/paralleltest/LICENSE deleted file mode 100644 index 77f0d26a6..000000000 --- a/vendor/github.com/kunwardeep/paralleltest/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2020 Kunwardeep Bedi - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/vendor/github.com/kunwardeep/paralleltest/pkg/paralleltest/paralleltest.go b/vendor/github.com/kunwardeep/paralleltest/pkg/paralleltest/paralleltest.go deleted file mode 100644 index e9187d6fd..000000000 --- a/vendor/github.com/kunwardeep/paralleltest/pkg/paralleltest/paralleltest.go +++ /dev/null @@ -1,320 +0,0 @@ -package paralleltest - -import ( - "flag" - "go/ast" - "go/types" - "strings" - - "golang.org/x/tools/go/analysis" - "golang.org/x/tools/go/ast/inspector" -) - -const Doc = `check that tests use t.Parallel() method -It also checks that the t.Parallel is used if multiple tests cases are run as part of single test. -As part of ensuring parallel tests works as expected it checks for reinitialising of the range value -over the test cases.(https://tinyurl.com/y6555cy6)` - -func NewAnalyzer() *analysis.Analyzer { - return newParallelAnalyzer().analyzer -} - -// parallelAnalyzer is an internal analyzer that makes options available to a -// run pass. It wraps an `analysis.Analyzer` that should be returned for -// linters. -type parallelAnalyzer struct { - analyzer *analysis.Analyzer - ignoreMissing bool - ignoreMissingSubtests bool - ignoreLoopVar bool -} - -func newParallelAnalyzer() *parallelAnalyzer { - a := ¶llelAnalyzer{} - - var flags flag.FlagSet - flags.BoolVar(&a.ignoreMissing, "i", false, "ignore missing calls to t.Parallel") - flags.BoolVar(&a.ignoreMissingSubtests, "ignoremissingsubtests", false, "ignore missing calls to t.Parallel in subtests") - flags.BoolVar(&a.ignoreLoopVar, "ignoreloopVar", false, "ignore loop variable detection") - - a.analyzer = &analysis.Analyzer{ - Name: "paralleltest", - Doc: Doc, - Run: a.run, - Flags: flags, - } - return a -} - -func (a *parallelAnalyzer) run(pass *analysis.Pass) (interface{}, error) { - inspector := inspector.New(pass.Files) - - nodeFilter := []ast.Node{ - (*ast.FuncDecl)(nil), - } - - inspector.Preorder(nodeFilter, func(node ast.Node) { - funcDecl := node.(*ast.FuncDecl) - var funcHasParallelMethod, - funcCantParallelMethod, - rangeStatementOverTestCasesExists, - rangeStatementHasParallelMethod, - rangeStatementCantParallelMethod bool - var loopVariableUsedInRun *string - var numberOfTestRun int - var positionOfTestRunNode []ast.Node - var rangeNode ast.Node - - // Check runs for test functions only - isTest, testVar := isTestFunction(funcDecl) - if !isTest { - return - } - - for _, l := range funcDecl.Body.List { - switch v := l.(type) { - - case *ast.ExprStmt: - ast.Inspect(v, func(n ast.Node) bool { - // Check if the test method is calling t.Parallel - if !funcHasParallelMethod { - funcHasParallelMethod = methodParallelIsCalledInTestFunction(n, testVar) - } - - // Check if the test calls t.Setenv, cannot be used in parallel tests or tests with parallel ancestors - if !funcCantParallelMethod { - funcCantParallelMethod = methodSetenvIsCalledInTestFunction(n, testVar) - } - - // Check if the t.Run within the test function is calling t.Parallel - if methodRunIsCalledInTestFunction(n, testVar) { - // n is a call to t.Run; find out the name of the subtest's *testing.T parameter. - innerTestVar := getRunCallbackParameterName(n) - - hasParallel := false - cantParallel := false - numberOfTestRun++ - ast.Inspect(v, func(p ast.Node) bool { - if !hasParallel { - hasParallel = methodParallelIsCalledInTestFunction(p, innerTestVar) - } - if !cantParallel { - cantParallel = methodSetenvIsCalledInTestFunction(p, innerTestVar) - } - return true - }) - if !hasParallel && !cantParallel { - positionOfTestRunNode = append(positionOfTestRunNode, n) - } - } - return true - }) - - // Check if the range over testcases is calling t.Parallel - case *ast.RangeStmt: - rangeNode = v - - var loopVars []types.Object - for _, expr := range []ast.Expr{v.Key, v.Value} { - if id, ok := expr.(*ast.Ident); ok { - loopVars = append(loopVars, pass.TypesInfo.ObjectOf(id)) - } - } - - ast.Inspect(v, func(n ast.Node) bool { - // nolint: gocritic - switch r := n.(type) { - case *ast.ExprStmt: - if methodRunIsCalledInRangeStatement(r.X, testVar) { - // r.X is a call to t.Run; find out the name of the subtest's *testing.T parameter. - innerTestVar := getRunCallbackParameterName(r.X) - - rangeStatementOverTestCasesExists = true - - if !rangeStatementHasParallelMethod { - rangeStatementHasParallelMethod = methodParallelIsCalledInMethodRun(r.X, innerTestVar) - } - - if !rangeStatementCantParallelMethod { - rangeStatementCantParallelMethod = methodSetenvIsCalledInMethodRun(r.X, innerTestVar) - } - - if !a.ignoreLoopVar && loopVariableUsedInRun == nil { - if run, ok := r.X.(*ast.CallExpr); ok { - loopVariableUsedInRun = loopVarReferencedInRun(run, loopVars, pass.TypesInfo) - } - } - } - } - return true - }) - } - } - - // Descendents which call Setenv, also prevent tests from calling Parallel - if rangeStatementCantParallelMethod { - funcCantParallelMethod = true - } - - if !a.ignoreMissing && !funcHasParallelMethod && !funcCantParallelMethod { - pass.Reportf(node.Pos(), "Function %s missing the call to method parallel\n", funcDecl.Name.Name) - } - - if rangeStatementOverTestCasesExists && rangeNode != nil { - if !rangeStatementHasParallelMethod && !rangeStatementCantParallelMethod { - if !a.ignoreMissing && !a.ignoreMissingSubtests { - pass.Reportf(rangeNode.Pos(), "Range statement for test %s missing the call to method parallel in test Run\n", funcDecl.Name.Name) - } - } else if loopVariableUsedInRun != nil { - pass.Reportf(rangeNode.Pos(), "Range statement for test %s does not reinitialise the variable %s\n", funcDecl.Name.Name, *loopVariableUsedInRun) - } - } - - // Check if the t.Run is more than one as there is no point making one test parallel - if !a.ignoreMissing && !a.ignoreMissingSubtests { - if numberOfTestRun > 1 && len(positionOfTestRunNode) > 0 { - for _, n := range positionOfTestRunNode { - pass.Reportf(n.Pos(), "Function %s missing the call to method parallel in the test run\n", funcDecl.Name.Name) - } - } - } - }) - - return nil, nil -} - -func methodParallelIsCalledInMethodRun(node ast.Node, testVar string) bool { - return targetMethodIsCalledInMethodRun(node, testVar, "Parallel") -} - -func methodSetenvIsCalledInMethodRun(node ast.Node, testVar string) bool { - return targetMethodIsCalledInMethodRun(node, testVar, "Setenv") -} - -func targetMethodIsCalledInMethodRun(node ast.Node, testVar, targetMethod string) bool { - var called bool - // nolint: gocritic - switch callExp := node.(type) { - case *ast.CallExpr: - for _, arg := range callExp.Args { - if !called { - ast.Inspect(arg, func(n ast.Node) bool { - if !called { - called = exprCallHasMethod(n, testVar, targetMethod) - return true - } - return false - }) - } - } - } - return called -} - -func methodParallelIsCalledInTestFunction(node ast.Node, testVar string) bool { - return exprCallHasMethod(node, testVar, "Parallel") -} - -func methodRunIsCalledInRangeStatement(node ast.Node, testVar string) bool { - return exprCallHasMethod(node, testVar, "Run") -} - -func methodRunIsCalledInTestFunction(node ast.Node, testVar string) bool { - return exprCallHasMethod(node, testVar, "Run") -} - -func methodSetenvIsCalledInTestFunction(node ast.Node, testVar string) bool { - return exprCallHasMethod(node, testVar, "Setenv") -} - -func exprCallHasMethod(node ast.Node, receiverName, methodName string) bool { - // nolint: gocritic - switch n := node.(type) { - case *ast.CallExpr: - if fun, ok := n.Fun.(*ast.SelectorExpr); ok { - if receiver, ok := fun.X.(*ast.Ident); ok { - return receiver.Name == receiverName && fun.Sel.Name == methodName - } - } - } - return false -} - -// In an expression of the form t.Run(x, func(q *testing.T) {...}), return the -// value "q". In _most_ code, the name is probably t, but we shouldn't just -// assume. -func getRunCallbackParameterName(node ast.Node) string { - if n, ok := node.(*ast.CallExpr); ok { - if len(n.Args) < 2 { - // We want argument #2, but this call doesn't have two - // arguments. Maybe it's not really t.Run. - return "" - } - funcArg := n.Args[1] - if fun, ok := funcArg.(*ast.FuncLit); ok { - if len(fun.Type.Params.List) < 1 { - // Subtest function doesn't have any parameters. - return "" - } - firstArg := fun.Type.Params.List[0] - // We'll assume firstArg.Type is *testing.T. - if len(firstArg.Names) < 1 { - return "" - } - return firstArg.Names[0].Name - } - } - return "" -} - -// Checks if the function has the param type *testing.T; if it does, then the -// parameter name is returned, too. -func isTestFunction(funcDecl *ast.FuncDecl) (bool, string) { - testMethodPackageType := "testing" - testMethodStruct := "T" - testPrefix := "Test" - - if !strings.HasPrefix(funcDecl.Name.Name, testPrefix) { - return false, "" - } - - if funcDecl.Type.Params != nil && len(funcDecl.Type.Params.List) != 1 { - return false, "" - } - - param := funcDecl.Type.Params.List[0] - if starExp, ok := param.Type.(*ast.StarExpr); ok { - if selectExpr, ok := starExp.X.(*ast.SelectorExpr); ok { - if selectExpr.Sel.Name == testMethodStruct { - if s, ok := selectExpr.X.(*ast.Ident); ok { - if len(param.Names) > 0 { - return s.Name == testMethodPackageType, param.Names[0].Name - } - } - } - } - } - - return false, "" -} - -func loopVarReferencedInRun(call *ast.CallExpr, vars []types.Object, typeInfo *types.Info) (found *string) { - if len(call.Args) != 2 { - return - } - - ast.Inspect(call.Args[1], func(n ast.Node) bool { - ident, ok := n.(*ast.Ident) - if !ok { - return true - } - for _, o := range vars { - if typeInfo.ObjectOf(ident) == o { - found = &ident.Name - } - } - return true - }) - - return -} -- cgit mrf-deployment