tests/test_data_sync.py

"""
Tests for DataSync - data synchronization.
"""

from unittest.mock import MagicMock, patch

import pandas as pd
import pytest


class TestDataSync:
    """Tests for DataSync class."""

    @pytest.fixture
    def data_sync(self):
        """Create DataSync instance with mocked provider."""
        from core.data_sync import DataSync

        with (
            patch("core.data_sync.AlpacaProvider") as mock_provider,
            patch("core.data_sync.ParallelExecutor") as mock_executor,
            patch("core.data_sync.ensure_dir"),
        ):
            mock_provider_instance = MagicMock()
            mock_provider.return_value = mock_provider_instance

            mock_executor_instance = MagicMock()
            mock_executor.return_value = mock_executor_instance

            ds = DataSync.__new__(DataSync)
            ds.provider = mock_provider_instance
            ds.executor = mock_executor_instance
            ds.batch_size = 200

            return ds, mock_provider_instance, mock_executor_instance

    def test_init(self, data_sync):
        """Test DataSync initialization."""
        ds, mock_provider, mock_executor = data_sync
        assert ds.provider is not None
        assert ds.batch_size == 200

    def test_get_nasdaq_symbols(self, data_sync):
        """Test get_nasdaq_symbols calls provider."""
        ds, mock_provider, _ = data_sync
        mock_provider.fetch_nasdaq_symbols.return_value = ["AAPL", "GOOGL"]

        result = ds.get_nasdaq_symbols()

        mock_provider.fetch_nasdaq_symbols.assert_called_once()
        assert result == ["AAPL", "GOOGL"]

    def test_sync_metadata(self, data_sync):
        """Test sync_metadata saves CSV."""
        ds, mock_provider, _ = data_sync

        mock_df = pd.DataFrame(
            {
                "symbol": ["AAPL", "GOOGL"],
                "sector": ["Tech", "Tech"],
            }
        )
        mock_provider.fetch_nasdaq_metadata.return_value = mock_df

        with patch("pandas.DataFrame.to_csv") as mock_to_csv:
            ds.sync_metadata()
            mock_to_csv.assert_called_once()

    def test_sync_calendar(self, data_sync):
        """Test sync_calendar saves calendar data."""
        ds, mock_provider, _ = data_sync

        mock_calendar = pd.DataFrame(
            {
                "date": ["2026-04-15"],
                "is_open": [True],
            }
        )
        mock_provider.fetch_calendar.return_value = mock_calendar

        with patch("pandas.DataFrame.to_csv") as mock_to_csv:
            ds.sync_calendar()
            mock_to_csv.assert_called_once()


class TestAlpacaProvider:
    """Tests for AlpacaProvider."""

    def test_alpaca_provider_init(self):
        """Test AlpacaProvider initialization."""
        from core.data_provider import AlpacaProvider

        provider = AlpacaProvider()
        assert provider is not None


class TestYahooProvider:
    """Tests for YahooProvider."""

    def test_yahoo_provider_init(self):
        """Test YahooProvider initialization."""
        from core.yahoo_provider import YahooProvider

        provider = YahooProvider()
        assert provider is not None


class TestWebullProvider:
    """Tests for WebullProvider."""

    def test_webull_provider_init(self):
        """Test WebullProvider initialization."""
        from core.webull_provider import WebullProvider

        provider = WebullProvider()
        assert provider is not None