test_dashboard_service.py

import unittest
from unittest.mock import patch, MagicMock
from datetime import datetime, date
import pytz

from app.services.dashboard_service import DashboardService
from app.models.user import User
from app.models.user_addiction import UserAddiction
from app.models.addiction import Addiction
from app.models.daily_log import DailyLog
from app.dto.dashboard_dto import DashboardResponseDTO, DayStatusDTO


class TestDashboardService(unittest.TestCase):

    @patch('app.services.dashboard_service.User')
    @patch('app.services.dashboard_service.UserAddiction')
    @patch('app.services.dashboard_service.DashboardService._calculate_total_savings')
    @patch('app.services.dashboard_service.DashboardService._get_all_days_status')
    @patch('app.services.dashboard_service.DashboardService._calculate_daily_streak')
    def test_get_user_dashboard_data_success(self, mock_streak, mock_all_days,
                                           mock_savings, mock_user_addiction, mock_user):
        # Arrange
        mock_user_obj = MagicMock()
        mock_user_obj.id = 1
        mock_user.query.filter_by.return_value.first.return_value = mock_user_obj

        mock_addiction = MagicMock()
        mock_addiction.name = "Papierosy"

        mock_user_addiction_obj = MagicMock()
        mock_user_addiction_obj.addiction = mock_addiction
        mock_user_addiction.query.filter_by.return_value.first.return_value = mock_user_addiction_obj

        mock_savings.return_value = 1234.56
        mock_all_days.return_value = [
            DayStatusDTO(date="2026-01-07", day_of_week="wt", status="success")
        ]
        mock_streak.return_value = 3

        # Act
        result = DashboardService.get_user_dashboard_data("testuser")

        # Assert
        self.assertIsInstance(result, DashboardResponseDTO)
        self.assertEqual(result.addiction_name, "Papierosy")
        self.assertEqual(result.total_savings, 1234.56)
        self.assertEqual(result.daily_streak, 3)
        self.assertEqual(len(result.all_days), 1)

    @patch('app.services.dashboard_service.User')
    def test_get_user_dashboard_data_user_not_found(self, mock_user):
        # Arrange
        mock_user.query.filter_by.return_value.first.return_value = None

        # Act & Assert
        with self.assertRaises(Exception) as context:
            DashboardService.get_user_dashboard_data("nonexistent")

        self.assertIn("User 'nonexistent' not found", str(context.exception))

    @patch('app.services.dashboard_service.User')
    @patch('app.services.dashboard_service.UserAddiction')
    def test_get_user_dashboard_data_no_addiction(self, mock_user_addiction, mock_user):
        # Arrange
        mock_user_obj = MagicMock()
        mock_user_obj.id = 1
        mock_user.query.filter_by.return_value.first.return_value = mock_user_obj
        mock_user_addiction.query.filter_by.return_value.first.return_value = None

        # Act & Assert
        with self.assertRaises(Exception) as context:
            DashboardService.get_user_dashboard_data("testuser")

        self.assertIn("No addiction found for user 'testuser'", str(context.exception))

    @patch('app.services.dashboard_service.db.session')
    def test_calculate_total_savings_with_cost(self, mock_session):
        # Arrange
        mock_user_addiction = MagicMock()
        mock_user_addiction.id = 1
        mock_user_addiction.cost_per_day = 15

        # Mock the query chain - filter() with multiple args, then count()
        mock_session.query.return_value.filter.return_value.count.return_value = 10

        # Act
        result = DashboardService._calculate_total_savings(mock_user_addiction)

        # Assert
        self.assertEqual(result, 150)  # 10 successful days * 15 PLN

    def test_calculate_total_savings_without_cost(self):
        # Arrange
        mock_user_addiction = MagicMock()
        mock_user_addiction.cost_per_day = None

        # Act
        result = DashboardService._calculate_total_savings(mock_user_addiction)

        # Assert
        self.assertEqual(result, 0.0)

    @patch('app.services.dashboard_service.DailyLog')
    @patch('app.services.dashboard_service.datetime')
    def test_get_last_7_days_status(self, mock_datetime, mock_daily_log):
        # Arrange
        mock_user_addiction = MagicMock()
        mock_user_addiction.id = 1
        # Mock start_date as 7 days ago (Unix timestamp)
        mock_user_addiction.start_date = datetime(2026, 1, 1, tzinfo=pytz.timezone('Europe/Warsaw')).timestamp()

        # Mock today as 2026-01-07 (Tuesday)
        test_date = date(2026, 1, 7)
        mock_datetime.now.return_value.date.return_value = test_date

        # Mock fromtimestamp to return start date
        mock_datetime.fromtimestamp.return_value.date.return_value = date(2026, 1, 1)

        # Mock different calls to filter based on call count
        call_count = [0]
        def mock_filter(*args):
            mock_query = MagicMock()
            # First call (today 2026-01-07) returns success
            if call_count[0] == 0:
                mock_log = MagicMock()
                mock_log.relapse = 0
                mock_query.first.return_value = mock_log
            else:
                # Other calls return None
                mock_query.first.return_value = None
            call_count[0] += 1
            return mock_query

        mock_daily_log.query.filter = mock_filter

        tz = pytz.timezone('Europe/Warsaw')

        # Act
        result = DashboardService._get_all_days_status(mock_user_addiction, tz)

        # Assert
        self.assertEqual(len(result), 252)  # 7 days from 2026-01-01 to 2026-01-07
        self.assertEqual(result[0].date, "2026-01-07")
        self.assertEqual(result[0].day_of_week, "śr")  # 2026-01-07 is Wednesday
        self.assertEqual(result[0].status, "success")
        # Other days should have "none" status
        for i in range(1, 7):
            self.assertEqual(result[i].status, "none")

    @patch('app.services.dashboard_service.DailyLog')
    @patch('app.services.dashboard_service.datetime')
    def test_calculate_daily_streak(self, mock_datetime, mock_daily_log):
        # Arrange
        mock_user_addiction = MagicMock()
        mock_user_addiction.id = 1

        # Mock today as 2026-01-07
        test_date = date(2026, 1, 7)
        mock_datetime.now.return_value.date.return_value = test_date

        # Mock 3 consecutive success days: 2026-01-07, 2026-01-06, 2026-01-05
        call_count = [0]
        def mock_filter_side_effect(*args, **kwargs):
            mock_query = MagicMock()
            if call_count[0] < 3:  # First 3 calls return success
                mock_log = MagicMock()
                mock_log.relapse = 0
                mock_query.first.return_value = mock_log
            else:  # 4th call returns None (break streak)
                mock_query.first.return_value = None
            call_count[0] += 1
            return mock_query

        mock_daily_log.query.filter.side_effect = mock_filter_side_effect

        tz = pytz.timezone('Europe/Warsaw')

        # Act
        result = DashboardService._calculate_daily_streak(mock_user_addiction, tz)

        # Assert
        self.assertEqual(result, 3)

    def test_serialize_dashboard_response(self):
        # Arrange
        day_dto = DayStatusDTO(date="2026-01-07", day_of_week="wt", status="success")
        dashboard_dto = DashboardResponseDTO(
            addiction_name="Papierosy",
            total_savings=123.45,
            all_days=[day_dto],
            daily_streak=5
        )

        # Act
        result = DashboardService.serialize_dashboard_response(dashboard_dto)

        # Assert
        expected = {
            'addictionName': 'Papierosy',
            'totalSavings': 123.45,
            'last7Days': [{
                'date': '2026-01-07',
                'dayOfWeek': 'wt',
                'status': 'success'
            }],
            'dailyStreak': 5
        }
        self.assertEqual(result, expected)