New tests 2

.github/workflows/run_tests.yml

@@ -21,15 +21,17 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
+        # Install the project in editable mode to pick up changes
         pip install -e .
-        pip install pytest typer numpy
-        # Note: Ideally, you should fix your requirements.txt and use:
-        # pip install .
-        # Or at least:
-        # pip install -r requirements.txt
-        # But due to the encoding and importlib issues observed,
-        # installing specific dependencies needed for tests directly for now.
+        # Install test dependencies, including pytest-cov for coverage
+        pip install pytest typer numpy pytest-cov
+        # Note: Ideally, dependencies should be managed via requirements-dev.txt
+        # Consider adding pytest-cov to requirements-dev.txt later.
 
-    - name: Run tests
+    - name: Run tests with coverage
       run: |
-        python -m pytest tests/analyze/
+        # Run pytest on the entire tests directory
+        # Generate coverage report for specified source directories
+        # Report missing lines directly in the terminal output
+        python -m pytest tests/ --cov=spice --cov=cli --cov=utils --cov=parser --cov=lexers --cov-report=term-missing
+

tests/cli/__init__.py

@@ -0,0 +1 @@
+

tests/cli/commands/__init__.py

@@ -0,0 +1 @@
+

tests/cli/commands/test_version.py

@@ -0,0 +1,92 @@
+import pytest
+import os
+from unittest.mock import patch, mock_open, MagicMock
+from typer.testing import CliRunner
+
+# Assuming cli.main is the entry point for typer app
+# We need to adjust imports based on actual structure if main.py is elsewhere
+# Let's assume main.py exists and imports version_command correctly
+# We will test the command function directly for simplicity here, 
+# avoiding the need for a full typer app setup in this unit test.
+from cli.commands.version import version_command
+
+# Dummy translation messages
+DUMMY_MESSAGES = {
+    "version_info": "SpiceCode Version:",
+    "version_not_found": "Version information not found in setup.py",
+    "setup_not_found": "Error: setup.py not found.",
+    "error": "Error:",
+}
+
+# Mock CURRENT_DIR (assuming it's the 'cli' directory for the command)
+TEST_CURRENT_DIR = "/home/ubuntu/spicecode/cli"
+EXPECTED_SETUP_PATH = "/home/ubuntu/spicecode/setup.py"
+
+@patch("cli.commands.version.get_translation")
+@patch("os.path.exists")
+def test_version_command_success(mock_exists, mock_get_translation, capsys):
+    """Test version command when setup.py exists and contains version."""
+    mock_get_translation.return_value = DUMMY_MESSAGES
+    mock_exists.return_value = True
+
+    # Create file content with version line
+    file_content = 'name="spicecode",\nversion="1.2.3",\nauthor="test"\n'
+
+    # Use mock_open with read_data parameter
+    with patch("builtins.open", mock_open(read_data=file_content)) as mock_file:
+        version_command(LANG_FILE="dummy_lang.txt", CURRENT_DIR=TEST_CURRENT_DIR)
+
+        captured = capsys.readouterr()
+
+        mock_exists.assert_called_once_with(EXPECTED_SETUP_PATH)
+        mock_file.assert_called_once_with(EXPECTED_SETUP_PATH, "r")
+        assert "SpiceCode Version: 1.2.3" in captured.out
+
+@patch("cli.commands.version.get_translation")
+@patch("os.path.exists")
+def test_version_command_version_not_in_setup(mock_exists, mock_get_translation, capsys):
+    """Test version command when setup.py exists but lacks version info."""
+    mock_get_translation.return_value = DUMMY_MESSAGES
+    mock_exists.return_value = True
+
+    # Create file content without version line
+    file_content = 'name="spicecode",\nauthor="test",\ndescription="A CLI tool"\n'
+
+    with patch("builtins.open", mock_open(read_data=file_content)) as mock_file:
+        version_command(LANG_FILE="dummy_lang.txt", CURRENT_DIR=TEST_CURRENT_DIR)
+
+        captured = capsys.readouterr()
+
+        mock_exists.assert_called_once_with(EXPECTED_SETUP_PATH)
+        mock_file.assert_called_once_with(EXPECTED_SETUP_PATH, "r")
+        assert "Version information not found in setup.py" in captured.out
+
+@patch("cli.commands.version.get_translation")
+@patch("os.path.exists")
+def test_version_command_setup_not_found(mock_exists, mock_get_translation, capsys):
+    """Test version command when setup.py does not exist."""
+    mock_get_translation.return_value = DUMMY_MESSAGES
+    mock_exists.return_value = False
+
+    version_command(LANG_FILE="dummy_lang.txt", CURRENT_DIR=TEST_CURRENT_DIR)
+
+    captured = capsys.readouterr()
+
+    mock_exists.assert_called_once_with(EXPECTED_SETUP_PATH)
+    assert "Error: setup.py not found." in captured.out
+
+@patch("cli.commands.version.get_translation")
+@patch("os.path.exists")
+def test_version_command_read_error(mock_exists, mock_get_translation, capsys):
+    """Test version command handles exceptions during file reading."""
+    mock_get_translation.return_value = DUMMY_MESSAGES
+    mock_exists.return_value = True
+
+    with patch("builtins.open", side_effect=OSError("Permission denied")) as mock_file:
+        version_command(LANG_FILE="dummy_lang.txt", CURRENT_DIR=TEST_CURRENT_DIR)
+
+        captured = capsys.readouterr()
+
+        mock_exists.assert_called_once_with(EXPECTED_SETUP_PATH)
+        mock_file.assert_called_once_with(EXPECTED_SETUP_PATH, "r")
+        assert "Error: Permission denied" in captured.out

tests/lexers/__init__.py

@@ -0,0 +1 @@
+

tests/lexers/test_golexer.py

@@ -0,0 +1,196 @@
+# import pytest
+# from lexers.golang.golexer import GoLexer
+# from lexers.token import TokenType
+
+# # Helper function to compare token lists, ignoring EOF
+# def assert_tokens_equal(actual_tokens, expected_tokens_data):
+#     if actual_tokens and actual_tokens[-1].type == TokenType.EOF:
+#         actual_tokens = actual_tokens[:-1]
+
+#     assert len(actual_tokens) == len(expected_tokens_data), \
+#         f"Expected {len(expected_tokens_data)} tokens, but got {len(actual_tokens)}\nActual: {actual_tokens}\nExpected data: {expected_tokens_data}"
+
+#     for i, (token_type, value) in enumerate(expected_tokens_data):
+#         assert actual_tokens[i].type == token_type, f"Token {i} type mismatch: Expected {token_type}, got {actual_tokens[i].type} ({actual_tokens[i].value})"
+#         assert actual_tokens[i].value == value, f"Token {i} value mismatch: Expected '{value}', got '{actual_tokens[i].value}'"
+
+# # --- Test Cases ---
+
+# def test_go_empty_input():
+#     lexer = GoLexer("")
+#     tokens = lexer.tokenize()
+#     assert len(tokens) == 1
+#     assert tokens[0].type == TokenType.EOF
+
+# def test_go_keywords():
+#     code = "package import func var const type struct interface if else for range switch case default return break continue goto fallthrough defer go select chan map make new len cap append copy delete panic recover true false nil"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.KEYWORD, "package"), (TokenType.KEYWORD, "import"), (TokenType.KEYWORD, "func"), (TokenType.KEYWORD, "var"),
+#         (TokenType.KEYWORD, "const"), (TokenType.KEYWORD, "type"), (TokenType.KEYWORD, "struct"), (TokenType.KEYWORD, "interface"),
+#         (TokenType.KEYWORD, "if"), (TokenType.KEYWORD, "else"), (TokenType.KEYWORD, "for"), (TokenType.KEYWORD, "range"),
+#         (TokenType.KEYWORD, "switch"), (TokenType.KEYWORD, "case"), (TokenType.KEYWORD, "default"), (TokenType.KEYWORD, "return"),
+#         (TokenType.KEYWORD, "break"), (TokenType.KEYWORD, "continue"), (TokenType.KEYWORD, "goto"), (TokenType.KEYWORD, "fallthrough"),
+#         (TokenType.KEYWORD, "defer"), (TokenType.KEYWORD, "go"), (TokenType.KEYWORD, "select"), (TokenType.KEYWORD, "chan"),
+#         (TokenType.KEYWORD, "map"), (TokenType.KEYWORD, "make"), (TokenType.KEYWORD, "new"), (TokenType.KEYWORD, "len"),
+#         (TokenType.KEYWORD, "cap"), (TokenType.KEYWORD, "append"), (TokenType.KEYWORD, "copy"), (TokenType.KEYWORD, "delete"),
+#         (TokenType.KEYWORD, "panic"), (TokenType.KEYWORD, "recover"), (TokenType.KEYWORD, "true"), (TokenType.KEYWORD, "false"),
+#         (TokenType.KEYWORD, "nil")
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_identifiers():
+#     code = "myVar _anotherVar var123 _"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.IDENTIFIER, "myVar"),
+#         (TokenType.IDENTIFIER, "_anotherVar"),
+#         (TokenType.IDENTIFIER, "var123"),
+#         (TokenType.IDENTIFIER, "_"),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_numbers():
+#     code = "123 45.67 0.5 1e3 2.5e-2 99"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.NUMBER, "123"),
+#         (TokenType.NUMBER, "45.67"),
+#         (TokenType.NUMBER, "0.5"),
+#         (TokenType.NUMBER, "1e3"),
+#         (TokenType.NUMBER, "2.5e-2"),
+#         (TokenType.NUMBER, "99"),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_strings():
+#     code = "\"hello\" `raw string\nwith newline` \"with \\\"escape\\\"\""
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.STRING, "\"hello\""),
+#         (TokenType.STRING, "`raw string\nwith newline`"),
+#         (TokenType.STRING, "\"with \\\"escape\\\"\""),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_operators():
+#     code = "+ - * / % = == != < > <= >= && || ! & | ^ << >> &^ += -= *= /= %= &= |= ^= <<= >>= &^= ++ -- := ... -> <-"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.OPERATOR, "+"), (TokenType.OPERATOR, "-"), (TokenType.OPERATOR, "*"), (TokenType.OPERATOR, "/"), (TokenType.OPERATOR, "%"),
+#         (TokenType.OPERATOR, "="), (TokenType.OPERATOR, "=="), (TokenType.OPERATOR, "!="), (TokenType.OPERATOR, "<"), (TokenType.OPERATOR, ">"),
+#         (TokenType.OPERATOR, "<="), (TokenType.OPERATOR, ">="), (TokenType.OPERATOR, "&&"), (TokenType.OPERATOR, "||"), (TokenType.OPERATOR, "!"),
+#         (TokenType.OPERATOR, "&"), (TokenType.OPERATOR, "|"), (TokenType.OPERATOR, "^"), (TokenType.OPERATOR, "<<"), (TokenType.OPERATOR, ">>"),
+#         (TokenType.OPERATOR, "&^"), (TokenType.OPERATOR, "+="), (TokenType.OPERATOR, "-="), (TokenType.OPERATOR, "*="), (TokenType.OPERATOR, "/="),
+#         (TokenType.OPERATOR, "%="), (TokenType.OPERATOR, "&="), (TokenType.OPERATOR, "|="), (TokenType.OPERATOR, "^="), (TokenType.OPERATOR, "<<="),
+#         (TokenType.OPERATOR, ">>="), (TokenType.OPERATOR, "&^="), (TokenType.OPERATOR, "++"), (TokenType.OPERATOR, "--"), (TokenType.OPERATOR, ":="),
+#         (TokenType.OPERATOR, "..."), (TokenType.OPERATOR, "->"), (TokenType.OPERATOR, "<-")
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_delimiters():
+#     code = "( ) { } [ ] , ; . :"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.DELIMITER, "("), (TokenType.DELIMITER, ")"),
+#         (TokenType.DELIMITER, "{"), (TokenType.DELIMITER, "}"),
+#         (TokenType.DELIMITER, "["), (TokenType.DELIMITER, "]"),
+#         (TokenType.DELIMITER, ","), (TokenType.DELIMITER, ";"),
+#         (TokenType.DELIMITER, "."), (TokenType.DELIMITER, ":"),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_comments():
+#     code = "// Single line comment\nvar x = 1 // Another comment\n/* Multi-line\n comment */ y := 2"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.COMMENT, "// Single line comment"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.KEYWORD, "var"), (TokenType.IDENTIFIER, "x"), (TokenType.OPERATOR, "="), (TokenType.NUMBER, "1"), (TokenType.COMMENT, "// Another comment"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.COMMENT, "/* Multi-line\n comment */"),
+#         (TokenType.IDENTIFIER, "y"), (TokenType.OPERATOR, ":="), (TokenType.NUMBER, "2"),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_mixed_code():
+#     code = """
+# package main
+
+# import "fmt"
+
+# func main() {
+# 	// Declare and initialize
+# 	message := "Hello, Go!"
+# 	fmt.Println(message) // Print message
+# 	num := 10 + 5
+# 	if num > 10 {
+# 		return
+# 	}
+# }
+# """
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.NEWLINE, "\\n"),
+#         (TokenType.KEYWORD, "package"), (TokenType.IDENTIFIER, "main"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.NEWLINE, "\\n"),
+#         (TokenType.KEYWORD, "import"), (TokenType.STRING, "\"fmt\""), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.NEWLINE, "\\n"),
+#         (TokenType.KEYWORD, "func"), (TokenType.IDENTIFIER, "main"), (TokenType.DELIMITER, "("), (TokenType.DELIMITER, ")"), (TokenType.DELIMITER, "{"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.COMMENT, "// Declare and initialize"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.IDENTIFIER, "message"), (TokenType.OPERATOR, ":="), (TokenType.STRING, "\"Hello, Go!\""), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.IDENTIFIER, "fmt"), (TokenType.DELIMITER, "."), (TokenType.IDENTIFIER, "Println"), (TokenType.DELIMITER, "("), (TokenType.IDENTIFIER, "message"), (TokenType.DELIMITER, ")"), (TokenType.COMMENT, "// Print message"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.IDENTIFIER, "num"), (TokenType.OPERATOR, ":="), (TokenType.NUMBER, "10"), (TokenType.OPERATOR, "+"), (TokenType.NUMBER, "5"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.KEYWORD, "if"), (TokenType.IDENTIFIER, "num"), (TokenType.OPERATOR, ">"), (TokenType.NUMBER, "10"), (TokenType.DELIMITER, "{"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.KEYWORD, "return"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.DELIMITER, "}"), (TokenType.NEWLINE, "\\n"),
+#         (TokenType.DELIMITER, "}"), (TokenType.NEWLINE, "\\n"),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_error_character():
+#     code = "var a = @;"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.KEYWORD, "var"),
+#         (TokenType.IDENTIFIER, "a"),
+#         (TokenType.OPERATOR, "="),
+#         (TokenType.ERROR, "@"),
+#         (TokenType.DELIMITER, ";"),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_unterminated_string():
+#     code = "\"unterminated string"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     # Go lexer should return the unterminated string as a STRING token
+#     expected = [
+#         (TokenType.STRING, "\"unterminated string"),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_unterminated_raw_string():
+#     code = "`unterminated raw string"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     expected = [
+#         (TokenType.STRING, "`unterminated raw string"),
+#     ]
+#     assert_tokens_equal(tokens, expected)
+
+# def test_go_unterminated_comment():
+#     code = "/* Unterminated comment"
+#     lexer = GoLexer(code)
+#     tokens = lexer.tokenize()
+#     # Go lexer returns an ERROR token for unterminated multi-line comments
+#     assert len(tokens) == 2 # ERROR token + EOF
+#     assert tokens[0].type == TokenType.ERROR
+#     assert "unterminated comment" in tokens[0].value.lower()