increase test coverage for engine (#66)

internal/engine.go

@@ -144,13 +144,14 @@ func (e *Engine) cleanupTemp(temp string) {
 	}
 }
 
+// filterUndefinedIssue filters out golangci-lint's undefined symbol issues.
+// TODO: This is a temporary fix. need to find a better way to handle this.
 func (e *Engine) filterUndefinedIssues(issues []tt.Issue) []tt.Issue {
-	var filtered []tt.Issue
+	filtered := make([]tt.Issue, 0, len(issues))
 	for _, issue := range issues {
-		if issue.Rule == "typecheck" && strings.Contains(issue.Message, "undefined:") {
-			symbol := strings.TrimSpace(strings.TrimPrefix(issue.Message, "undefined:"))
+		if issue.Rule == "typecheck" && strings.HasPrefix(issue.Message, "undefined:") {
+			symbol := strings.TrimSpace(issue.Message[10:])
 			if e.SymbolTable.IsDefined(symbol) {
-				// ignore issues if the symbol is defined in the symbol table
 				continue
 			}
 		}
@@ -159,6 +160,9 @@ func (e *Engine) filterUndefinedIssues(issues []tt.Issue) []tt.Issue {
 	return filtered
 }
 
+// createTempGoFile converts a .gno file to a .go file.
+// Since golangci-lint does not support .gno file, we need to convert it to .go file.
+// gno has a identical syntax to go, so it is possible to convert it to go file.
 func createTempGoFile(gnoFile string) (string, error) {
 	content, err := os.ReadFile(gnoFile)
 	if err != nil {

internal/engine_test.go

@@ -1,12 +1,149 @@
 package internal
 
 import (
+	"os"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"testing"
+
+	"github.com/gnoswap-labs/tlin/internal/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-func BenchmarkGoroutineEngine(b *testing.B) {
+func TestNewEngine(t *testing.T) {
+	t.Parallel()
+
+	tempDir, err := os.MkdirTemp("", "engine_test")
+	require.NoError(t, err)
+	defer os.RemoveAll(tempDir)
+
+	engine, err := NewEngine(tempDir)
+	assert.NoError(t, err)
+	assert.NotNil(t, engine)
+	assert.NotNil(t, engine.SymbolTable)
+	assert.NotEmpty(t, engine.rules)
+}
+
+func TestEngine_IgnoreRule(t *testing.T) {
+	t.Parallel()
+	engine := &Engine{}
+	engine.IgnoreRule("test_rule")
+
+	assert.True(t, engine.ignoredRules["test_rule"])
+}
+
+func TestEngine_PrepareFile(t *testing.T) {
+	t.Parallel()
+	engine := &Engine{}
+
+	t.Run("Go file", func(t *testing.T) {
+		goFile := "test.go"
+		result, err := engine.prepareFile(goFile)
+		assert.NoError(t, err)
+		assert.Equal(t, goFile, result)
+	})
+
+	t.Run("Gno file", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "gno_test")
+		require.NoError(t, err)
+		defer os.RemoveAll(tempDir)
+
+		gnoFile := filepath.Join(tempDir, "test.gno")
+		err = os.WriteFile(gnoFile, []byte("package main"), 0644)
+		require.NoError(t, err)
+
+		result, err := engine.prepareFile(gnoFile)
+		assert.NoError(t, err)
+		assert.NotEqual(t, gnoFile, result)
+		assert.True(t, filepath.Ext(result) == ".go")
+	})
+}
+
+func TestEngine_CleanupTemp(t *testing.T) {
+	t.Parallel()
+	engine := &Engine{}
+
+	tempDir, err := os.MkdirTemp("", "cleanup_test")
+	require.NoError(t, err)
+	defer os.RemoveAll(tempDir)
+
+	tempFile := filepath.Join(tempDir, "temp_test.go")
+	_, err = os.Create(tempFile)
+	require.NoError(t, err)
+
+	engine.cleanupTemp(tempFile)
+	_, err = os.Stat(tempFile)
+	assert.True(t, os.IsNotExist(err))
+}
+
+func TestReadSourceCode(t *testing.T) {
+	t.Parallel()
+	tempDir, err := os.MkdirTemp("", "source_code_test")
+	require.NoError(t, err)
+	defer os.RemoveAll(tempDir)
+
+	testFile := filepath.Join(tempDir, "test.go")
+	content := "package main\n\nfunc main() {\n\tprintln(\"Hello, World!\")\n}"
+	err = os.WriteFile(testFile, []byte(content), 0644)
+	require.NoError(t, err)
+
+	sourceCode, err := ReadSourceCode(testFile)
+	assert.NoError(t, err)
+	assert.NotNil(t, sourceCode)
+	assert.Len(t, sourceCode.Lines, 5)
+	assert.Equal(t, "package main", sourceCode.Lines[0])
+}
+
+func BenchmarkFilterUndefinedIssues(b *testing.B) {
+	engine := &Engine{
+		SymbolTable: &SymbolTable{},
+	}
+
+	issues := []types.Issue{
+		{Rule: "typecheck", Message: "undefined: someSymbol"},
+		{Rule: "other", Message: "some other issue"},
+		{Rule: "typecheck", Message: "undefined: anotherSymbol"},
+		{Rule: "typecheck", Message: "some other typecheck issue"},
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		engine.filterUndefinedIssues(issues)
+	}
+}
+
+// create dummy source code for benchmark
+var testSrc = strings.Repeat("hello world", 5000)
+
+func BenchmarkCreateTempGoFile(b *testing.B) {
+	tempDir, err := os.MkdirTemp("", "benchmark")
+	if err != nil {
+		b.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// create temp go file for benchmark
+	gnoContent := []byte(testSrc)
+	gnoFile := filepath.Join(tempDir, "main.gno")
+	if err := os.WriteFile(gnoFile, gnoContent, 0o644); err != nil {
+		b.Fatalf("failed to write temp gno file: %v", err)
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		f, err := createTempGoFile(gnoFile)
+		if err != nil {
+			b.Fatalf("failed to create temp go file: %v", err)
+		}
+		os.Remove(f)
+	}
+}
+
+func BenchmarkRun(b *testing.B) {
 	_, currentFile, _, _ := runtime.Caller(0)
 	testDataDir := filepath.Join(filepath.Dir(currentFile), "../testdata")