Unit test cases

Author: Ravikirana-Microsoft

src/tests/backend/sql_agents/agents/semantic_verifier/semantic_verifier_agent_test.py

@@ -0,0 +1,48 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from sql_agents.agents.semantic_verifier.agent import SemanticVerifierAgent
+from sql_agents.agents.semantic_verifier.response import SemanticVerifierResponse
+from sql_agents.helpers.models import AgentType
+
+
+@pytest.fixture
+def mock_config():
+    """Fixture to create a mock configuration."""
+    mock_config = MagicMock()
+    mock_config.model_type = {
+        AgentType.SEMANTIC_VERIFIER: "semantic_verifier_model"
+    }
+    return mock_config
+
+
+@pytest.fixture
+def semantic_verifier_agent(mock_config):
+    """Fixture to create a SemanticVerifierAgent instance."""
+    agent = SemanticVerifierAgent(
+        agent_type=AgentType.SEMANTIC_VERIFIER,
+        config=mock_config
+    )
+    return agent
+
+
+def test_response_object(semantic_verifier_agent):
+    """Test that the response_object property returns SemanticVerifierResponse."""
+    assert semantic_verifier_agent.response_object == SemanticVerifierResponse
+
+
+def test_deployment_name(semantic_verifier_agent):
+    """Test that the deployment_name property returns the correct model name."""
+    assert semantic_verifier_agent.deployment_name == "semantic_verifier_model"
+
+
+def test_missing_deployment_name(mock_config):
+    """Test that accessing deployment_name raises a KeyError if the model type is missing."""
+    mock_config.model_type = {}
+    agent = SemanticVerifierAgent(
+        agent_type=AgentType.SEMANTIC_VERIFIER,
+        config=mock_config
+    )
+    with pytest.raises(KeyError):
+        _ = agent.deployment_name

src/tests/backend/sql_agents/agents/semantic_verifier/semantic_verifier_response_test.py

@@ -0,0 +1,62 @@
+import pytest
+
+from sql_agents.agents.semantic_verifier.response import SemanticVerifierResponse
+
+
+def test_semantic_verifier_response_initialization():
+    """Test initializing SemanticVerifierResponse with valid data."""
+    response = SemanticVerifierResponse(
+        judgement="valid",
+        differences=["difference1", "difference2"],
+        summary="This is a summary."
+    )
+    assert response.judgement == "valid"
+    assert response.differences == ["difference1", "difference2"]
+    assert response.summary == "This is a summary."
+
+
+def test_semantic_verifier_response_empty_fields():
+    """Test initializing SemanticVerifierResponse with empty fields."""
+    response = SemanticVerifierResponse(
+        judgement="",
+        differences=[],
+        summary=""
+    )
+    assert response.judgement == ""
+    assert response.differences == []
+    assert response.summary == ""
+
+
+def test_semantic_verifier_response_invalid_data():
+    """Test initializing SemanticVerifierResponse with invalid data."""
+    with pytest.raises(ValueError):
+        SemanticVerifierResponse(
+            judgement=123,  # Invalid type
+            differences="not a list",  # Invalid type
+            summary=None  # Invalid type
+        )
+
+
+def test_semantic_verifier_response_large_differences():
+    """Test initializing SemanticVerifierResponse with a large number of differences."""
+    differences = [f"difference{i}" for i in range(1000)]  # Large list of differences
+    response = SemanticVerifierResponse(
+        judgement="valid",
+        differences=differences,
+        summary="This is a summary."
+    )
+    assert len(response.differences) == 1000
+    assert response.judgement == "valid"
+    assert response.summary == "This is a summary."
+
+
+def test_semantic_verifier_response_special_characters():
+    """Test initializing SemanticVerifierResponse with special characters."""
+    response = SemanticVerifierResponse(
+        judgement="valid!@#$%^&*()",
+        differences=["difference1", "difference2"],
+        summary="This is a summary with special characters!@#$%^&*()"
+    )
+    assert response.judgement == "valid!@#$%^&*()"
+    assert response.differences == ["difference1", "difference2"]
+    assert response.summary == "This is a summary with special characters!@#$%^&*()"

src/tests/backend/sql_agents/agents/syntax_checker/syntax_checker_agent_test.py

@@ -0,0 +1,57 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from sql_agents.agents.syntax_checker.agent import SyntaxCheckerAgent
+from sql_agents.agents.syntax_checker.plug_ins import SyntaxCheckerPlugin
+from sql_agents.agents.syntax_checker.response import SyntaxCheckerResponse
+from sql_agents.helpers.models import AgentType
+
+
+@pytest.fixture
+def mock_config():
+    """Fixture to create a mock configuration."""
+    mock_config = MagicMock()
+    mock_config.model_type = {
+        AgentType.SYNTAX_CHECKER: "syntax_checker_model"
+    }
+    return mock_config
+
+
+@pytest.fixture
+def syntax_checker_agent(mock_config):
+    """Fixture to create a SyntaxCheckerAgent instance."""
+    agent = SyntaxCheckerAgent(
+        agent_type=AgentType.SYNTAX_CHECKER,
+        config=mock_config
+    )
+    return agent
+
+
+def test_response_object(syntax_checker_agent):
+    """Test that the response_object property returns SyntaxCheckerResponse."""
+    assert syntax_checker_agent.response_object == SyntaxCheckerResponse
+
+
+def test_plugins(syntax_checker_agent):
+    """Test that the plugins property returns the correct plugins."""
+    plugins = syntax_checker_agent.plugins
+    assert isinstance(plugins, list)
+    assert plugins[0] == "check_syntax"
+    assert isinstance(plugins[1], SyntaxCheckerPlugin)
+
+
+def test_deployment_name(syntax_checker_agent):
+    """Test that the deployment_name property returns the correct model name."""
+    assert syntax_checker_agent.deployment_name == "syntax_checker_model"
+
+
+def test_missing_deployment_name(mock_config):
+    """Test that accessing deployment_name raises a KeyError if the model type is missing."""
+    mock_config.model_type = {}  # Simulate missing AgentType in model_type
+    agent = SyntaxCheckerAgent(
+        agent_type=AgentType.SYNTAX_CHECKER,
+        config=mock_config
+    )
+    with pytest.raises(KeyError):
+        _ = agent.deployment_name

src/tests/backend/sql_agents/agents/syntax_checker/syntax_checker_plug_ins_test.py

@@ -0,0 +1,171 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sql_agents.agents.syntax_checker.plug_ins import SyntaxCheckerPlugin
+
+
+@pytest.fixture
+def syntax_checker_plugin():
+    """Fixture to create a SyntaxCheckerPlugin instance."""
+    return SyntaxCheckerPlugin()
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_windows_path(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method on Windows."""
+    with patch("platform.system", return_value="Windows"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = "SELECT * FROM table"
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            [r".\sql_agents\tools\win-x64\tsqlParser.exe", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_linux_path(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method on Linux."""
+    with patch("platform.system", return_value="Linux"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = "SELECT * FROM table"
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            ["./sql_agents/tools/linux-x64/tsqlParser", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_other_os(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method on other OS."""
+    with patch("platform.system", return_value="Other"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = "SELECT * FROM table"
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            ["./sql_agents/tools/linux-x64/tsqlParser", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_empty_string(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method with an empty string."""
+    with patch("platform.system", return_value="Windows"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = ""
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            [r".\sql_agents\tools\win-x64\tsqlParser.exe", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_empty_string_linux(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method with an empty string."""
+    with patch("platform.system", return_value="Linux"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = ""
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            ["./sql_agents/tools/linux-x64/tsqlParser", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_empty_string_other_os(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method with an empty string."""
+    with patch("platform.system", return_value="Other"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = ""
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            ["./sql_agents/tools/linux-x64/tsqlParser", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_invalid_sql(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method with invalid SQL."""
+    with patch("platform.system", return_value="Windows"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = "INVALID SQL"
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            [r".\sql_agents\tools\win-x64\tsqlParser.exe", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_invalid_sql_linux(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method with invalid SQL."""
+    with patch("platform.system", return_value="Linux"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = "INVALID SQL"
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            ["./sql_agents/tools/linux-x64/tsqlParser", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_invalid_sql_other_os(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method with invalid SQL."""
+    with patch("platform.system", return_value="Other"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = "INVALID SQL"
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            ["./sql_agents/tools/linux-x64/tsqlParser", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+
+@patch("sql_agents.agents.syntax_checker.plug_ins.subprocess.run")
+def test_check_syntax_valid_sql(mock_subprocess_run, syntax_checker_plugin):
+    """Test the _call_tsqlparser method with valid SQL."""
+    with patch("platform.system", return_value="Windows"):
+        mock_subprocess_run.return_value = MagicMock(stdout="[]")
+        candidate_sql = "SELECT * FROM table"
+        result = syntax_checker_plugin.check_syntax(candidate_sql)
+        assert result == "[]"
+        mock_subprocess_run.assert_called_once_with(
+            [r".\sql_agents\tools\win-x64\tsqlParser.exe", "--string", candidate_sql],
+            capture_output=True,
+            text=True,
+            check=True,
+        )

src/tests/backend/sql_agents/agents/syntax_checker/syntax_checker_response_test.py

@@ -0,0 +1,37 @@
+from sql_agents.agents.syntax_checker.response import SyntaxCheckerResponse, SyntaxErrorInt
+
+
+def test_syntax_error_int_initialization():
+    """Test initializing SyntaxErrorInt with valid data."""
+    syntax_error = SyntaxErrorInt(line=1, column=5, error="Syntax error")
+    assert syntax_error.line == 1
+    assert syntax_error.column == 5
+    assert syntax_error.error == "Syntax error"
+
+
+def test_syntax_checker_response_initialization():
+    """Test initializing SyntaxCheckerResponse with valid data."""
+    syntax_error = SyntaxErrorInt(line=1, column=5, error="Syntax error")
+    response = SyntaxCheckerResponse(
+        thought="Analyzing SQL query",
+        syntax_errors=[syntax_error],
+        summary="1 syntax error found"
+    )
+    assert response.thought == "Analyzing SQL query"
+    assert len(response.syntax_errors) == 1
+    assert response.syntax_errors[0].line == 1
+    assert response.syntax_errors[0].column == 5
+    assert response.syntax_errors[0].error == "Syntax error"
+    assert response.summary == "1 syntax error found"
+
+
+def test_syntax_checker_response_empty_fields():
+    """Test initializing SyntaxCheckerResponse with empty fields."""
+    response = SyntaxCheckerResponse(
+        thought="",
+        syntax_errors=[],
+        summary=""
+    )
+    assert response.thought == ""
+    assert response.syntax_errors == []
+    assert response.summary == ""