a few tests

Author: Antony Bailey

.github/workflows/python-package-conda.yml

@@ -24,7 +24,7 @@ pip install pysqly
 ### Using the Python API
 
 ```python
-from sqly.executor import SQLYExecutor
+from sqly.SQLYExecutor import SQLYExecutor
 
 datasource = "your_database_connection"
 db_type = "postgres"  # Choose from sqlite, mariadb, postgres, oracle, mssql

README.md

@@ -0,0 +1,36 @@
+import unittest
+from unittest.mock import Mock
+from BaseDBConnector import BaseDBConnector
+
+class TestBaseDBConnector(unittest.TestCase):
+    """
+    Unit tests for the BaseDBConnector class.
+
+    TestBaseDBConnector is a test case for testing the initialization of the BaseDBConnector class.
+
+    Methods:
+        test_init: Tests the initialization of the BaseDBConnector class with a mock connection object.
+    """
+    def test_init(self):
+        """
+        Test the initialization of the BaseDBConnector class.
+
+        This test creates a mock connection object and initializes the BaseDBConnector
+        with it. It then asserts that the connection attribute of the connector is set
+        correctly to the mock connection.
+
+        Assertions:
+            - The connection attribute of the BaseDBConnector instance should be equal
+              to the mock connection object.
+        """
+        # Create a mock connection object
+        mock_connection = Mock()
+
+        # Initialize the BaseDBConnector with the mock connection
+        connector = BaseDBConnector(mock_connection)
+
+        # Assert that the connection attribute is set correctly
+        self.assertEqual(connector.connection, mock_connection)
+
+if __name__ == '__main__':
+    unittest.main()

test_BaseDBConnector.py

@@ -0,0 +1,56 @@
+import unittest
+from SQLYExecutor import SQLYExecutor
+
+class TestSQLYExecutor(unittest.TestCase):
+    """
+    Unit tests for the SQLYExecutor class.
+
+    This test suite contains tests to verify the correct initialization of the
+    SQLYExecutor class with different parameters.
+
+    Classes:
+        TestSQLYExecutor: Contains unit tests for the SQLYExecutor class.
+
+    Methods:
+        test_init_with_datasource_only: Tests the initialization of SQLYExecutor with only the datasource parameter.
+        test_init_with_datasource_and_db_type: Tests the initialization of SQLYExecutor with a datasource and database type.
+    """
+    def test_init_with_datasource_only(self):
+        """
+        Test the initialization of SQLYExecutor with only the datasource parameter.
+
+        This test verifies that the SQLYExecutor is correctly initialized when only
+        the datasource parameter is provided. It checks that the datasource attribute
+        is set correctly and the db_type attribute is None.
+
+        Assertions:
+            - The datasource attribute of the executor should match the provided datasource.
+            - The db_type attribute of the executor should be None.
+        """
+        datasource = "path/to/datasource"
+        executor = SQLYExecutor(datasource)
+        self.assertEqual(executor.datasource, datasource)
+        self.assertIsNone(executor.db_type)
+
+    def test_init_with_datasource_and_db_type(self):
+        """
+        Test the initialization of SQLYExecutor with a datasource and database type.
+
+        This test verifies that the SQLYExecutor object is correctly initialized
+        with the provided datasource and database type. It checks that the
+        datasource and db_type attributes of the executor match the expected values.
+
+        Assertions:
+            - The datasource attribute of the executor should match the provided datasource.
+            - The db_type attribute of the executor should match the provided db_type.
+        """
+        datasource = "path/to/datasource"
+        db_type = "sqlite"
+        executor = SQLYExecutor(datasource, db_type)
+        self.assertEqual(executor.datasource, datasource)
+        self.assertEqual(executor.db_type, db_type)
+
+
+
+if __name__ == '__main__':
+    unittest.main()

test_SQLYExecutor.py

@@ -0,0 +1,98 @@
+import unittest
+from SQLYParser import SQLYParser
+from SQLYParseError import SQLYParseError
+
+class TestSQLYParser(unittest.TestCase):
+    """
+    Test suite for the SQLYParser class.
+
+    This test suite contains the following test cases:
+
+    1. test_parse_valid_query:
+        - Test case for parsing a valid SQLY query.
+        - Verifies that the SQLYParser correctly parses a valid query string into the expected dictionary format.
+        - The query string contains key-value pairs separated by colons and new lines.
+        - Assertions: The parsed result from SQLYParser.parse(query) should match the expected_result dictionary.
+
+    2. test_parse_invalid_query:
+        - Test case for parsing an invalid SQLY query.
+        - Verifies that the SQLYParser raises an SQLYParseError when attempting to parse a query with invalid syntax.
+        - The query provided has a missing colon between 'key2' and 'value2', which should trigger the error.
+
+    3. test_parse_empty_query:
+        - Test case for parsing an empty SQL query.
+        - Verifies that the SQLYParser correctly handles an empty query string by returning None.
+        - Steps:
+            1. Define an empty query string.
+            2. Define the expected result as None.
+            3. Parse the empty query string using SQLYParser.
+            4. Assert that the result matches the expected result (None).
+
+    Classes:
+        TestSQLYParser: Contains unit tests for the SQLYParser class.
+
+    Methods:
+        test_parse_valid_query: Test case for parsing a valid SQLY query.
+        test_parse_invalid_query: Test case for parsing an invalid SQLY query.
+        test_parse_empty_query: Test case for parsing an empty SQL query.
+    """
+    def test_parse_valid_query(self):
+        """
+        Test case for parsing a valid SQLY query.
+
+        This test verifies that the SQLYParser correctly parses a valid query string
+        into the expected dictionary format.
+
+        The query string contains key-value pairs separated by colons and new lines.
+        The expected result is a dictionary with the corresponding key-value pairs.
+
+        Assertions:
+            The parsed result from SQLYParser.parse(query) should match the expected_result dictionary.
+        """
+        query = """
+        key1: value1
+        key2: value2
+        """
+        expected_result = {
+            'key1': 'value1',
+            'key2': 'value2'
+        }
+        result = SQLYParser.parse(query)
+        self.assertEqual(result, expected_result)
+
+    def test_parse_invalid_query(self):
+        """
+        Test case for parsing an invalid SQLY query.
+
+        This test verifies that the SQLYParser raises an SQLYParseError
+        when attempting to parse a query with invalid syntax. The query
+        provided has a missing colon between 'key2' and 'value2', which
+        should trigger the error.
+        """
+        query = """
+        key1: value1
+        key2 value2
+        """
+        with self.assertRaises(SQLYParseError):
+            SQLYParser.parse(query)
+
+    def test_parse_empty_query(self):
+        """
+        Test case for parsing an empty SQL query.
+
+        This test verifies that the SQLYParser correctly handles an empty query string
+        by returning None.
+
+        Steps:
+        1. Define an empty query string.
+        2. Define the expected result as None.
+        3. Parse the empty query string using SQLYParser.
+        4. Assert that the result matches the expected result (None).
+        """
+        query = ""
+        expected_result = None
+        result = SQLYParser.parse(query)
+        self.assertEqual(result, expected_result)
+
+if __name__ == '__main__':
+    unittest.main()

test_SQLYParser.py

@@ -0,0 +1,85 @@
+import unittest
+from SQLYUtils import SQLYUtils
+
+class TestSQLYUtils(unittest.TestCase):
+    """
+    Unit tests for the SQLYUtils class.
+
+    Test Cases:
+    - test_validate_query_valid: Tests that a valid query dictionary with 'select' and 'from' keys returns True.
+    - test_validate_query_missing_select: Tests that a query dictionary missing the 'select' key returns False.
+    - test_validate_query_missing_from: Tests that a query dictionary missing the 'from' key returns False.
+    - test_validate_query_empty_dict: Tests that an empty query dictionary returns False.
+    - test_validate_query_not_dict: Tests that a query which is not a dictionary returns False.
+    """
+
+    def test_validate_query_valid(self):
+        """
+        Test case for validating a correct SQL query structure.
+
+        This test checks if the `validate_query` method of `SQLYUtils` correctly
+        identifies a valid query structure. The query structure being tested
+        includes a "select" key with a list of columns and a "from" key with the
+        table name.
+
+        The test asserts that the `validate_query` method returns True for the
+        given valid query.
+        """
+        query = {
+            "select": ["id", "name"],
+            "from": "users"
+        }
+        self.assertTrue(SQLYUtils.validate_query(query))
+
+    def test_validate_query_missing_select(self):
+        """
+        Test case for validating a query that is missing the 'select' clause.
+
+        This test ensures that the `validate_query` method of the `SQLYUtils` class
+        returns `False` when the query dictionary does not contain the required 'select' key.
+
+        The query dictionary in this test case only contains the 'from' key with the value 'users'.
+        """
+        query = {
+            "from": "users"
+        }
+        self.assertFalse(SQLYUtils.validate_query(query))
+
+    def test_validate_query_missing_from(self):
+        """
+        Test case for the validate_query method in SQLYUtils class.
+
+        This test checks the scenario where the 'from' clause is missing in the query.
+        The query dictionary contains only the 'select' clause with fields 'id' and 'name'.
+        The test asserts that the validate_query method should return False, indicating
+        that the query is invalid due to the missing 'from' clause.
+        """
+        query = {
+            "select": ["id", "name"]
+        }
+        self.assertFalse(SQLYUtils.validate_query(query))
+
+    def test_validate_query_empty_dict(self):
+        """
+        Test case for SQLYUtils.validate_query method with an empty dictionary.
+
+        This test verifies that the validate_query method returns False when
+        an empty dictionary is passed as the query parameter.
+        """
+        query = {}
+        self.assertFalse(SQLYUtils.validate_query(query))
+
+    def test_validate_query_not_dict(self):
+        """
+        Test case for SQLYUtils.validate_query method.
+
+        This test checks that the validate_query method returns False when the input query is not a dictionary.
+
+        Assertions:
+            - The method should return False when a string query is provided.
+        """
+        query = "SELECT * FROM users"
+        self.assertFalse(SQLYUtils.validate_query(query))
+
+if __name__ == '__main__':
+    unittest.main()