python-tdd/src/apps/dashboard/tests/integrated/test_sky_views.py

"""Integration tests for the My Sky dashboard views.

sky_view    — GET /dashboard/sky/  → renders sky template
sky_preview — GET /dashboard/sky/preview  → proxies to PySwiss (no DB write)
sky_save    — POST /dashboard/sky/save    → saves natal data to User model;
              grants Stargazer Note on first save with real chart_data
"""

import json
from unittest.mock import patch, MagicMock

from django.test import TestCase
from django.urls import reverse

from apps.drama.models import Note
from apps.lyric.models import User


class SkyViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="star@test.io")
        self.client.force_login(self.user)

    def test_sky_view_renders_template(self):
        response = self.client.get(reverse("sky"))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "apps/dashboard/sky.html")

    def test_sky_view_requires_login(self):
        self.client.logout()
        response = self.client.get(reverse("sky"))
        self.assertEqual(response.status_code, 302)
        self.assertIn("/?next=", response["Location"])

    def test_sky_view_passes_preview_and_save_urls(self):
        response = self.client.get(reverse("sky"))
        self.assertContains(response, reverse("sky_preview"))
        self.assertContains(response, reverse("sky_save"))


class SkyPreviewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="star@test.io")
        self.client.force_login(self.user)
        self.url = reverse("sky_preview")

    def test_requires_login(self):
        self.client.logout()
        response = self.client.get(self.url, {"date": "1990-06-15", "lat": "51.5", "lon": "-0.1"})
        self.assertEqual(response.status_code, 302)
        self.assertIn("/?next=", response["Location"])

    def test_missing_params_returns_400(self):
        response = self.client.get(self.url, {"date": "1990-06-15"})
        self.assertEqual(response.status_code, 400)

    def test_invalid_lat_returns_400(self):
        response = self.client.get(self.url, {"date": "1990-06-15", "lat": "999", "lon": "0"})
        self.assertEqual(response.status_code, 400)

    @patch("apps.dashboard.views.http_requests")
    def test_proxies_to_pyswiss_and_returns_chart(self, mock_requests):
        chart_payload = {
            "planets": {"Sun": {"degree": 84.5, "sign": "Gemini", "retrograde": False}},
            "houses":  {"cusps": [0]*12},
            "elements": {"Fire": 1, "Earth": 0, "Air": 0, "Water": 0},
            "house_system": "O",
        }
        tz_response = MagicMock()
        tz_response.json.return_value = {"timezone": "Europe/London"}
        tz_response.raise_for_status = MagicMock()

        chart_response = MagicMock()
        chart_response.json.return_value = chart_payload
        chart_response.raise_for_status = MagicMock()

        mock_requests.get.side_effect = [tz_response, chart_response]

        response = self.client.get(self.url, {
            "date": "1990-06-15", "time": "09:30",
            "lat": "51.5074", "lon": "-0.1278",
        })

        self.assertEqual(response.status_code, 200)
        data = response.json()
        self.assertIn("planets", data)
        # Earth→Stone rename applied
        self.assertIn("Stone", data["elements"])
        self.assertNotIn("Earth", data["elements"])
        self.assertIn("timezone", data)
        self.assertIn("distinctions", data)


class SkySaveTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="star@test.io")
        self.client.force_login(self.user)
        self.url = reverse("sky_save")

    def _post(self, payload):
        return self.client.post(
            self.url,
            data=json.dumps(payload),
            content_type="application/json",
        )

    def test_requires_login(self):
        self.client.logout()
        response = self._post({})
        self.assertEqual(response.status_code, 302)
        self.assertIn("/?next=", response["Location"])

    def test_get_not_allowed(self):
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 405)

    def test_saves_sky_fields_to_user(self):
        payload = {
            "birth_dt":    "1990-06-15T08:30:00",
            "birth_lat":   51.5074,
            "birth_lon":   -0.1278,
            "birth_place": "London, UK",
            "house_system": "O",
            "chart_data":  {},
        }
        response = self._post(payload)
        self.assertEqual(response.status_code, 200)

        self.user.refresh_from_db()
        self.assertEqual(str(self.user.sky_birth_dt), "1990-06-15 08:30:00+00:00")
        self.assertAlmostEqual(float(self.user.sky_birth_lat), 51.5074, places=3)
        self.assertAlmostEqual(float(self.user.sky_birth_lon), -0.1278, places=3)
        self.assertEqual(self.user.sky_birth_place, "London, UK")
        self.assertEqual(self.user.sky_house_system, "O")

    def test_invalid_json_returns_400(self):
        response = self.client.post(
            self.url, data="not json", content_type="application/json"
        )
        self.assertEqual(response.status_code, 400)

    def test_response_contains_saved_flag(self):
        payload = {
            "birth_dt":   "1990-06-15T08:30:00",
            "birth_lat":  51.5,
            "birth_lon":  -0.1,
            "birth_place": "",
            "house_system": "O",
            "chart_data": {},
        }
        data = self._post(payload).json()
        self.assertTrue(data["saved"])

    def test_invalid_birth_dt_string_sets_sky_birth_dt_to_none(self):
        payload = {
            "birth_dt": "not-a-date",
            "birth_lat": 51.5,
            "birth_lon": -0.1,
            "birth_place": "",
            "house_system": "O",
            "chart_data": {},
        }
        response = self._post(payload)
        self.assertEqual(response.status_code, 200)
        self.user.refresh_from_db()
        self.assertIsNone(self.user.sky_birth_dt)


class SkyPreviewErrorPathTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="star2@test.io")
        self.client.force_login(self.user)
        self.url = reverse("sky_preview")

    def test_non_numeric_lat_returns_400(self):
        response = self.client.get(self.url, {"date": "1990-06-15", "lat": "abc", "lon": "0"})
        self.assertEqual(response.status_code, 400)

    def test_invalid_tz_string_returns_400(self):
        response = self.client.get(
            self.url, {"date": "1990-06-15", "lat": "51.5", "lon": "-0.1", "tz": "Not/ATimezone"}
        )
        self.assertEqual(response.status_code, 400)

    def test_bad_date_format_returns_400(self):
        response = self.client.get(
            self.url,
            {"date": "not-a-date", "time": "09:00", "lat": "51.5", "lon": "-0.1", "tz": "UTC"},
        )
        self.assertEqual(response.status_code, 400)

    @patch("apps.dashboard.views.http_requests")
    def test_pyswiss_tz_failure_falls_back_to_utc_and_continues(self, mock_requests):
        chart_payload = {
            "planets": {"Sun": {"degree": 84.5, "sign": "Gemini", "retrograde": False}},
            "houses": {"cusps": [0] * 12},
            "elements": {},
            "house_system": "O",
        }
        tz_response = MagicMock()
        tz_response.raise_for_status.side_effect = Exception("tz timeout")

        chart_response = MagicMock()
        chart_response.json.return_value = chart_payload
        chart_response.raise_for_status = MagicMock()

        mock_requests.get.side_effect = [tz_response, chart_response]

        response = self.client.get(self.url, {"date": "1990-06-15", "lat": "51.5", "lon": "-0.1"})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json()["timezone"], "UTC")

    @patch("apps.dashboard.views.http_requests")
    def test_pyswiss_chart_failure_returns_502(self, mock_requests):
        tz_response = MagicMock()
        tz_response.json.return_value = {"timezone": "UTC"}
        tz_response.raise_for_status = MagicMock()

        chart_response = MagicMock()
        chart_response.raise_for_status.side_effect = Exception("chart timeout")

        mock_requests.get.side_effect = [tz_response, chart_response]

        response = self.client.get(self.url, {"date": "1990-06-15", "lat": "51.5", "lon": "-0.1"})
        self.assertEqual(response.status_code, 502)


_REAL_CHART = {
    "planets": {"Sun": {"degree": 66.7, "sign": "Gemini", "retrograde": False}},
    "houses":  {"cusps": [180, 210, 240, 270, 300, 330, 0, 30, 60, 90, 120, 150]},
    "elements": {"Fire": 1, "Stone": 2, "Air": 4, "Water": 0, "Time": 1, "Space": 1},
    "aspects": [],
}


class SkySaveNoteTest(TestCase):
    """sky_save grants the Stargazer Note on the first save with real chart_data."""

    def setUp(self):
        self.user = User.objects.create(email="star@test.io")
        self.client.force_login(self.user)
        self.url = reverse("sky_save")

    def _post(self, chart_data=_REAL_CHART):
        return self.client.post(
            self.url,
            data=json.dumps({
                "birth_dt":    "1990-06-15T08:30:00",
                "birth_lat":   51.5074,
                "birth_lon":   -0.1278,
                "birth_place": "London, UK",
                "birth_tz":    "Europe/London",
                "house_system": "O",
                "chart_data":  chart_data,
            }),
            content_type="application/json",
        )

    def test_first_save_with_chart_data_returns_stargazer_note(self):
        data = self._post().json()
        self.assertIn("note", data)
        recog = data["note"]
        self.assertEqual(recog["slug"], "stargazer")
        self.assertIn("title", recog)
        self.assertIn("description", recog)
        self.assertIn("earned_at", recog)

    def test_first_save_creates_note_in_db(self):
        self._post()
        self.assertEqual(Note.objects.filter(user=self.user, slug="stargazer").count(), 1)

    def test_second_save_returns_null_note(self):
        self._post()
        data = self._post().json()
        self.assertIsNone(data["note"])

    def test_second_save_does_not_create_duplicate_note(self):
        self._post()
        self._post()
        self.assertEqual(Note.objects.filter(user=self.user, slug="stargazer").count(), 1)

    def test_save_with_empty_chart_data_does_not_grant_note(self):
        data = self._post(chart_data={}).json()
        self.assertIsNone(data["note"])
        self.assertEqual(Note.objects.filter(user=self.user, slug="stargazer").count(), 0)

    def test_save_with_null_chart_data_does_not_grant_note(self):
        data = self._post(chart_data=None).json()
        self.assertIsNone(data["note"])
        self.assertEqual(Note.objects.filter(user=self.user, slug="stargazer").count(), 0)