Coverage for tests / unit / parsers / base_parser / test_validate_fields.py: 100%

1"""Tests for field validation functions.""" 

2 

3from __future__ import annotations 

4 

5from unittest.mock import patch 

6 

7from assertpy import assert_that 

8 

9from lintro.parsers.base_parser import validate_int_field, validate_str_field 

10 

11# === Validate Str Field Tests === 

12 

13 

14def test_validate_str_field_valid_string() -> None: 

15 """Return string value unchanged.""" 

16 result = validate_str_field("test", "field_name") 

17 assert_that(result).is_equal_to("test") 

18 

19 

20def test_validate_str_field_non_string_returns_default() -> None: 

21 """Return default for non-string values.""" 

22 result = validate_str_field(123, "field_name", default="unknown") 

23 assert_that(result).is_equal_to("unknown") 

24 

25 

26def test_validate_str_field_none_returns_default() -> None: 

27 """Return default for None values.""" 

28 result = validate_str_field(None, "field_name", default="default") 

29 assert_that(result).is_equal_to("default") 

30 

31 

32def test_validate_str_field_logs_warning() -> None: 

33 """Log warning when log_warning is True and type mismatches.""" 

34 with patch("lintro.parsers.base_parser.logger") as mock_logger: 

35 validate_str_field(123, "test_field", log_warning=True) 

36 mock_logger.warning.assert_called_once() 

37 call_args = mock_logger.warning.call_args[0][0] 

38 assert_that(call_args).contains("test_field") 

39 assert_that(call_args).contains("int") 

40 

41 

42def test_validate_str_field_no_warning_for_none() -> None: 

43 """Do not log warning for None values.""" 

44 with patch("lintro.parsers.base_parser.logger") as mock_logger: 

45 validate_str_field(None, "test_field", log_warning=True) 

46 mock_logger.warning.assert_not_called() 

47 

48 

49# === Validate Int Field Tests === 

50 

51 

52def test_validate_int_field_valid_int() -> None: 

53 """Return integer value unchanged.""" 

54 result = validate_int_field(42, "field_name") 

55 assert_that(result).is_equal_to(42) 

56 

57 

58def test_validate_int_field_non_int_returns_default() -> None: 

59 """Return default for non-integer values.""" 

60 result = validate_int_field("not_int", "field_name", default=0) 

61 assert_that(result).is_equal_to(0) 

62 

63 

64def test_validate_int_field_bool_returns_default() -> None: 

65 """Return default for boolean values (bools are not treated as ints).""" 

66 result = validate_int_field(True, "field_name", default=-1) 

67 assert_that(result).is_equal_to(-1) 

68 

69 

70def test_validate_int_field_none_returns_default() -> None: 

71 """Return default for None values.""" 

72 result = validate_int_field(None, "field_name", default=99) 

73 assert_that(result).is_equal_to(99) 

74 

75 

76def test_validate_int_field_logs_warning() -> None: 

77 """Log warning when log_warning is True and type mismatches.""" 

78 with patch("lintro.parsers.base_parser.logger") as mock_logger: 

79 validate_int_field("bad", "line_number", log_warning=True) 

80 mock_logger.warning.assert_called_once() 

81 call_args = mock_logger.warning.call_args[0][0] 

82 assert_that(call_args).contains("line_number")