linters/internal/analyzers/noliteral/linter_test.go

package noliteral

import (
	"go/ast"
	"go/parser"
	"go/token"
	"path/filepath"
	"runtime"
	"testing"

	"golang.org/x/tools/go/analysis"
)

func newNoliteral() (*analysis.Analyzer, error) {
	cfg := Configuration{
		ConstantsPackage: "git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs",
	}
	return New(cfg)
}

func TestAnalyzer_negative(t *testing.T) {
	const countNegativeCases = 4

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/literals/negative._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	Count := 0
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			Count++
		},
	}

	linter, err := newNoliteral()
	if err != nil {
		t.Fatal(err)
	}
	_, err = linter.Run(pass)

	if Count != countNegativeCases {
		t.Fail()
	}
	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzer_negativeExtend(t *testing.T) {
	const (
		countNegativeCases = 1
		testFilePath       = "test-case/literals/negative._go"
	)

	linter, err := New(Configuration{
		ConstantsPackage: "git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs",
		Position:         func(i int) *int { return &i }(1),
	})
	if err != nil {
		t.Fatal(err)
	}

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, testFilePath, nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	var count int
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(analysis.Diagnostic) {
			count++
		},
	}

	if _, err := linter.Run(pass); err != nil {
		t.Fatal(err)
	}

	if count != countNegativeCases {
		t.Errorf("got %d negative cases, want %d", count, countNegativeCases)
	}
}

func TestAnalyzer_literals_positive(t *testing.T) {
	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/literals/positive._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			flag = true
		},
	}
	linter, err := newNoliteral()
	if err != nil {
		t.Fatal(err)
	}
	_, err = linter.Run(pass)

	if flag {
		t.Fail()
	}

	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzer_const_location_negative(t *testing.T) {
	const countNegativeCases = 3
	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/const-location/negative._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	Count := 0
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			Count++
		},
	}

	linter, err := newNoliteral()
	if err != nil {
		t.Fatal(err)
	}
	_, err = linter.Run(pass)

	if Count != countNegativeCases {
		t.Fail()
	}
	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzer_const_location_positive(t *testing.T) {
	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/const-location/positive._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			flag = true
		},
	}

	linter, err := newNoliteral()
	if err != nil {
		t.Fatal(err)
	}
	_, err = linter.Run(pass)

	if flag {
		t.Fail()
	}

	if err != nil {
		t.Fatal(err)
	}
}