test_utils.py

"""Unit tests for commons/utils.py module."""

import unittest

from pyflowintel.commons.utils import (
    validate_file_ext,
    validate_nat_num,
    validate_list_of,
)


class TestFileValidation(unittest.TestCase):
    """Unit tests for file validation utilities."""

    def test_validate_file_ext_valid_json(self):
        """Test that valid JSON extension passes."""
        self.assertTrue(validate_file_ext("test.json", ["json"]))

    def test_validate_file_ext_valid_yaml(self):
        """Test that valid YAML extensions pass."""
        self.assertTrue(validate_file_ext("test.yaml", ["yaml", "yml"]))
        self.assertTrue(validate_file_ext("test.yml", ["yaml", "yml"]))

    def test_validate_file_ext_invalid(self):
        """Test that invalid extension raises ValueError."""
        with self.assertRaises(ValueError) as ctx:
            validate_file_ext("test.txt", ["json"])
        self.assertIn("must have one of these extensions", str(ctx.exception))

    def test_validate_file_ext_no_extension(self):
        """Test that file without extension raises ValueError."""
        with self.assertRaises(ValueError) as ctx:
            validate_file_ext("testfile", ["json"])
        self.assertIn("must have one of these extensions", str(ctx.exception))


class TestValidateNatNum(unittest.TestCase):
    """Unit tests for validate_int function."""

    def test_validate_nat_with_integer(self):
        """Test integer values."""
        # Should not raise
        validate_nat_num(42)
        with self.assertRaises(ValueError) as ctx:
            validate_nat_num(0)
        self.assertIn("integer is expected", str(ctx.exception))
        with self.assertRaises(ValueError) as ctx:
            validate_nat_num(-1)
        self.assertIn("integer is expected", str(ctx.exception))

    def test_validate_nat_with_string(self):
        """Test that string raises ValueError."""
        with self.assertRaises(ValueError) as ctx:
            validate_nat_num("123")
        self.assertIn("integer is expected", str(ctx.exception))

    def test_validate_nat_with_float(self):
        """Test that float raises ValueError."""
        with self.assertRaises(ValueError) as ctx:
            validate_nat_num(42.5)
        self.assertIn("integer is expected", str(ctx.exception))

    def test_validate_nat_with_none(self):
        """Test that None raises ValueError."""
        with self.assertRaises(ValueError) as ctx:
            validate_nat_num(None)
        self.assertIn("integer is expected", str(ctx.exception))

    def test_validate_nat_with_boolean(self):
        """Test boolean values (bool is subclass of int in Python)."""
        # In Python, bool is a subclass of int, so this passes
        validate_nat_num(True)
        with self.assertRaises(ValueError) as ctx:
            validate_nat_num(False)
        self.assertIn("integer is expected", str(ctx.exception))


class TestValidateListOf(unittest.TestCase):
    """Unit tests for validate_list_of function."""

    def test_validate_list_of_with_valid_list_no_type(self):
        """Test that list passes validation without type checking."""
        validate_list_of([1, 2, 3])
        validate_list_of([])
        validate_list_of(["a", "b", "c"])

    def test_validate_list_of_with_none(self):
        """Test that non-list raises ValueError."""
        with self.assertRaises(ValueError) as ctx:
            validate_list_of(None)
        self.assertIn("List expected", str(ctx.exception))

    def test_validate_list_of_with_non_list(self):
        """Test that non-list raises ValueError."""
        with self.assertRaises(ValueError) as ctx:
            validate_list_of("not a list")
        self.assertIn("List expected", str(ctx.exception))
        
        with self.assertRaises(ValueError) as ctx:
            validate_list_of(123)
        self.assertIn("List expected", str(ctx.exception))

    def test_validate_list_of_integers(self):
        """Test validation of list of integers."""
        validate_list_of([1, 2, 3], "int")
        validate_list_of([0, -5, 100], "int")

    def test_validate_list_of_integers_invalid(self):
        """Test that mixed types fail integer validation."""
        with self.assertRaises(ValueError) as ctx:
            validate_list_of([1, "2", 3], "int")
        self.assertIn("All elements must be of type int", str(ctx.exception))

    def test_validate_list_of_strings(self):
        """Test validation of list of strings."""
        validate_list_of(["a", "b", "c"], "str")
        validate_list_of([""], "str")

    def test_validate_list_of_floats(self):
        """Test validation of list of floats."""
        validate_list_of([1.5, 2.3, 3.7], "float")

    def test_validate_list_of_floats_invalid(self):
        """Test that integers don't pass float validation."""
        with self.assertRaises(ValueError) as ctx:
            validate_list_of([1.5, 2, 3.7], "float")
        self.assertIn("All elements must be of type float", str(ctx.exception))

    def test_validate_list_of_bools(self):
        """Test validation of list of booleans."""
        validate_list_of([True, False, True], "bool")

    def test_validate_list_of_lists(self):
        """Test validation of list of lists."""
        validate_list_of([[1, 2], [3, 4]], "list")

    def test_validate_list_of_unknown_type(self):
        """Test that unknown type raises ValueError."""
        with self.assertRaises(ValueError) as ctx:
            validate_list_of([1, 2, 3], "dict")
        self.assertIn("Unknown validation type", str(ctx.exception))

    def test_validate_list_of_empty_list(self):
        """Test that empty list passes all type validations."""
        validate_list_of([], "int")
        validate_list_of([], "str")
        validate_list_of([], "float")


if __name__ == "__main__":
    unittest.main()