Updated unit tests

Author: emartinez-dev

src/models.py

@@ -53,9 +53,6 @@ class TrainRideFilter(BaseModel):
     destination: str
 
     departure_date: datetime
-
-    min_departure_hour: Optional[time] = None
-    max_departure_hour: Optional[time] = None
     max_duration_minutes: Optional[int] = None
 
     max_price: Optional[float] = None

tests/test_config.py

@@ -0,0 +1,9 @@
+import pytest
+from unittest.mock import patch, mock_open
+from src.config import init_bot, get_bot_token
+
+def test_get_bot_token_no_config():
+    with patch("builtins.open", mock_open(read_data="")):
+        with patch("src.config.init_bot") as mock_init_bot:
+            with pytest.raises(KeyError):
+                get_bot_token()

tests/test_models.py

@@ -46,8 +46,6 @@ def test_filter_rides_origin_and_destination(sample_rides):
         origin="Madrid",
         destination="Barcelona",
         departure_date=datetime(2025, 1, 30),
-        min_departure_hour=None,
-        max_departure_hour=None,
         max_duration_minutes=None,
         max_price=None
     )
@@ -61,9 +59,7 @@ def test_filter_rides_by_min_departure_hour(sample_rides):
     filter = TrainRideFilter(
         origin="Madrid",
         destination="Barcelona",
-        departure_date=datetime(2025, 1, 30),
-        min_departure_hour=time(9, 0),
-        max_departure_hour=None,
+        departure_date=datetime(2025, 1, 30, 9, 0),
         max_duration_minutes=None,
         max_price=None
     )
@@ -73,29 +69,11 @@ def test_filter_rides_by_min_departure_hour(sample_rides):
     assert len(result) == 1  # Only the third ride should pass
 
 
-def test_filter_rides_by_max_departure_hour(sample_rides):
-    filter = TrainRideFilter(
-        origin="Madrid",
-        destination="Barcelona",
-        departure_date=datetime(2025, 1, 30),
-        min_departure_hour=None,
-        max_departure_hour=time(9, 0),
-        max_duration_minutes=None,
-        max_price=None
-    )
-
-    result = filter.filter_rides(sample_rides)
-
-    assert len(result) == 1  # Only the first ride should pass
-
-
 def test_filter_rides_by_max_duration(sample_rides):
     filter = TrainRideFilter(
         origin="Madrid",
         destination="Barcelona",
         departure_date=datetime(2025, 1, 30),
-        min_departure_hour=None,
-        max_departure_hour=None,
         max_duration_minutes=180,
         max_price=None
     )
@@ -110,8 +88,6 @@ def test_filter_rides_by_max_price(sample_rides):
         origin="Madrid",
         destination="Barcelona",
         departure_date=datetime(2025, 1, 30),
-        min_departure_hour=None,
-        max_departure_hour=None,
         max_duration_minutes=None,
         max_price=55.0
     )
@@ -126,9 +102,7 @@ def test_filter_rides_no_results(sample_rides):
         origin="Madrid",
         destination="Barcelona",
         departure_date=datetime(2025, 1, 31),  # Different date
-        min_departure_hour=None,
-        max_departure_hour=None,
-        max_duration_minutes=None,
+        max_duration_minutes=1,
         max_price=None
     )
 

tests/test_scraper.py

@@ -1,82 +1,102 @@
-import unittest
-from unittest.mock import patch, MagicMock
+import pytest
 from datetime import datetime
-from scraper import Scraper, extract_dwr_token, create_cookiedict, create_search_id, create_session_script_id
-from models import StationRecord
-from errors import InvalidTrainRideFilter, InvalidDWRToken
+from unittest.mock import patch, MagicMock
+from src.scraper import Scraper, extract_dwr_token, extract_train_list, create_search_id, create_session_script_id, tokenify
+from models import StationRecord, TrainRideRecord
+from errors import InvalidDWRToken, InvalidTrainRideFilter
+
+@pytest.fixture
+def scraper():
+    origin = StationRecord(name="Madrid", code="MAD")
+    destination = StationRecord(name="Barcelona", code="BCN")
+    departure_date = datetime(2023, 12, 25)
+    return Scraper(origin, destination, departure_date)
+
+def test_create_search_id():
+    search_id = create_search_id()
+    assert len(search_id) == 5
+    assert search_id.startswith("_")
+
+def test_create_session_script_id():
+    dwr_token = "test_token"
+    session_script_id = create_session_script_id(dwr_token)
+    assert session_script_id.startswith(dwr_token)
+
+def test_tokenify():
+    number = 123456
+    token = tokenify(number)
+    assert isinstance(token, str)
+
+def test_extract_dwr_token():
+    response_text = 'r.handleCallback("0","0","test_token")'
+    token = extract_dwr_token(response_text)
+    assert token == "test_token"
+
+def test_extract_dwr_token_invalid():
+    response_text = 'invalid response'
+    with pytest.raises(InvalidDWRToken):
+        extract_dwr_token(response_text)
+
+def test_extract_train_list():
+    response_text = 'r.handleCallback(0,0,{"listadoTrenes":[]});'
+    train_list = extract_train_list(response_text)
+    assert "listadoTrenes" in train_list
+
+def test_invalid_return_date():
+    origin = StationRecord(name="Madrid", code="MAD")
+    destination = StationRecord(name="Barcelona", code="BCN")
+    departure_date = datetime(2023, 12, 25)
+    return_date = datetime(2023, 12, 24)
+    with pytest.raises(InvalidTrainRideFilter):
+        Scraper(origin, destination, departure_date, return_date)
+
+@patch('src.scraper.requests.Session.post')
+def test_do_search(mock_post, scraper):
+    mock_post.return_value.ok = True
+    scraper._do_search()
+    assert mock_post.called
+
+@patch('src.scraper.requests.Session.post')
+def test_do_get_dwr_token(mock_post, scraper):
+    mock_post.return_value.ok = True
+    mock_post.return_value.text = 'r.handleCallback("0","0","test_token")'
+    scraper._do_get_dwr_token()
+    assert scraper.dwr_token == "test_token"
 
-class TestScraper(unittest.TestCase):
-    def setUp(self):
-        # Setup mock data for testing
-        self.origin = StationRecord(name="Madrid", code="MAD")
-        self.destination = StationRecord(name="Barcelona", code="BCN")
-        self.departure_date = datetime(2025, 1, 31, 10, 0)
-        self.return_date = datetime(2025, 2, 1, 10, 0)
-        
-        self.scraper = Scraper(
-            origin=self.origin, 
-            destination=self.destination, 
-            departure_date=self.departure_date, 
-            return_date=self.return_date
-        )
-    
-    @patch('scraper.requests.Session.post')
-    def test_get_trainrides(self, mock_post):
-        # Mock the HTTP responses for the scraper methods
-        mock_post.return_value.ok = True
-        mock_post.return_value.text = '{"listadoTrenes": []}'  # mock response for getting train list
+@patch('src.scraper.requests.Session.post')
+def test_do_update_session_objects(mock_post, scraper):
+    mock_post.return_value.ok = True
+    scraper.dwr_token = "test_token"
+    scraper.script_session_id = "test_script_session_id"
+    scraper._do_update_session_objects()
+    assert mock_post.called
 
-        # Mock necessary functions
-        self.scraper._do_search = MagicMock()
-        self.scraper._do_get_dwr_token = MagicMock()
-        self.scraper._do_update_session_objects = MagicMock()
-        self.scraper._do_get_train_list = MagicMock(return_value={"listadoTrenes": []})
+@patch('src.scraper.requests.Session.post')
+def test_do_get_train_list(mock_post, scraper):
+    mock_post.return_value.ok = True
+    mock_post.return_value.text = 'r.handleCallback(0,0,{"listadoTrenes":[]});'
+    train_list = scraper._do_get_train_list()
+    assert "listadoTrenes" in train_list
 
-        # Test if get_trainrides returns an empty list when no trains are found
-        result = self.scraper.get_trainrides()
-        self.assertEqual(result, [])
-    
-    def test_invalid_trainride_filter(self):
-        # Test the case where return_date is before departure_date
-        with self.assertRaises(InvalidTrainRideFilter):
-            Scraper(
-                origin=self.origin, 
-                destination=self.destination, 
-                departure_date=self.departure_date, 
-                return_date=datetime(2025, 1, 30, 10, 0)  # Invalid return date
-            )
-    
-    @patch('scraper.extract_dwr_token')
-    def test_extract_dwr_token(self, mock_extract_dwr_token):
-        # Test extracting the DWR token with a valid response
-        mock_response = 'throw #DWR-REPLY\nr.handleCallback("1","0","12345");'
-        mock_extract_dwr_token.return_value = '12345'
-        token = extract_dwr_token(mock_response)
-        self.assertEqual(token, '12345')
+def test_change_datetime_hour():
+    date = datetime(2023, 12, 25)
+    hour = "14:30"
+    new_date = Scraper._change_datetime_hour(hour, date)
+    assert new_date.hour == 14
+    assert new_date.minute == 30
 
-    def test_extract_dwr_token_invalid(self):
-        # Test extracting the DWR token with an invalid response
-        with self.assertRaises(InvalidDWRToken):
-            extract_dwr_token('Invalid response')
-    
-    def test_create_cookiedict(self):
-        # Test the creation of cookies for the search
-        cookies = create_cookiedict(self.origin, self.destination)
-        self.assertIn("Search", cookies["name"])
-        self.assertIn(self.origin.code, cookies["value"])
-    
-    def test_create_search_id(self):
-        # Test the creation of search_id
-        search_id = create_search_id()
-        self.assertTrue(search_id.startswith('_'))
-        self.assertEqual(len(search_id), 5)
-    
-    def test_create_session_script_id(self):
-        # Test the creation of session script ID
-        with patch('scraper.tokenify', return_value='test_token'):
-            script_id = create_session_script_id('dwr_token')
-            self.assertTrue(script_id.startswith('dwr_token/'))
-            self.assertIn('test_token', script_id)
+def test_is_train_available():
+    train = {
+        "completo": False,
+        "razonNoDisponible": "",
+        "tarifaMinima": "10.00"
+    }
+    assert Scraper._is_train_available(train)
 
-if __name__ == "__main__":
-    unittest.main()
+def test_is_train_not_available():
+    train = {
+        "completo": True,
+        "razonNoDisponible": "1",
+        "tarifaMinima": None
+    }
+    assert not Scraper._is_train_available(train)

tests/test_validators.py

@@ -0,0 +1,98 @@
+import pytest
+from datetime import datetime
+from dataclasses import dataclass
+from validators import validate_station, validate_date, validate_float, StationValidationResult, DateValidationResult, FloatValidationResult
+from errors import StationNotFound
+from models import StationRecord
+from storage import StationsStorage
+from messages import user_messages as msg
+
+@dataclass
+class Message:
+    text: str | None = None
+
+@pytest.fixture
+def mock_message():
+    return Message()
+
+def test_validate_station_valid(mock_message, mocker):
+    mock_message.text = "Madrid"
+    mock_station = StationRecord(name="Madrid", code="MAD")
+    mocker.patch.object(StationsStorage, 'get_station', return_value=mock_station)
+    
+    result = validate_station(mock_message)
+    
+    assert result.is_valid
+    assert result.station == mock_station
+    assert result.error_message == ""
+
+def test_validate_station_not_found(mock_message, mocker):
+    mock_message.text = "Unknown"
+    mocker.patch.object(StationsStorage, 'get_station', side_effect=StationNotFound)
+    mocker.patch.object(StationsStorage, 'find_station', return_value=["Madrid", "Barcelona"])
+    
+    result = validate_station(mock_message)
+    
+    assert not result.is_valid
+    assert result.station is None
+    assert result.error_message == msg["station_not_found"].format("Unknown", "Madrid\nBarcelona")
+
+def test_validate_station_no_text(mock_message):
+    mock_message.text = None
+    
+    result = validate_station(mock_message)
+    
+    assert not result.is_valid
+    assert result.station is None
+    assert result.error_message == msg["station_invalid"]
+
+def test_validate_date_valid(mock_message):
+    mock_message.text = "Hoy a las 07:00"
+    
+    result = validate_date(mock_message)
+    
+    assert result.is_valid
+    assert result.date == datetime.now().replace(hour=7, minute=0, second=0, microsecond=0)
+    assert result.error_message == ""
+
+def test_validate_date_invalid(mock_message):
+    mock_message.text = "invalid date"
+    
+    result = validate_date(mock_message)
+    
+    assert not result.is_valid
+    assert result.date is None
+    assert result.error_message == msg["wrong_date"]
+
+def test_validate_date_no_text(mock_message):
+    mock_message.text = None
+    
+    result = validate_date(mock_message)
+    
+    assert not result.is_valid
+    assert result.date is None
+    assert result.error_message == msg["wrong_date"]
+
+def test_validate_float_valid(mock_message):
+    mock_message.text = "123.45"
+    
+    result = validate_float(mock_message)
+    
+    assert result.is_valid
+    assert result.number == 123.45
+    assert result.error_message == ""
+
+def test_validate_float_invalid(mock_message):
+    mock_message.text = "invalid number"
+    
+    with pytest.raises(ValueError):
+        validate_float(mock_message)
+
+def test_validate_float_no_text(mock_message):
+    mock_message.text = None
+    
+    result = validate_float(mock_message)
+    
+    assert not result.is_valid
+    assert result.number is None
+    assert result.error_message == msg["wrong_number"]