sajad-dev/Logic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UPDATE

Browse Source
This commit is contained in:
Mohammad Sajad Pourajam
2026-05-11 03:27:21 +03:30
parent cf7cbb937c
commit d0e68a1a56
854 changed files with 102985 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Modules/Backend/irrigation/tests.py
+734
View File
@@ -0,0 +1,734 @@
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.test import TestCase
from rest_framework.test import APIRequestFactory, force_authenticate
from external_api_adapter.adapter import AdapterResponse
from farm_hub.models import FarmHub, FarmType
from farmer_calendar.models import FarmerCalendarEvent
from .models import IrrigationPlan, IrrigationRecommendationRequest
from .services import IrrigationDataUnavailableError, build_recommendation_response
from .views import (
IrrigationMethodListView,
IrrigationPlanDetailView,
IrrigationPlanListView,
IrrigationPlanStatusView,
PlanFromTextView,
RecommendView,
RecommendationDetailView,
RecommendationListView,
WaterStressView,
)
class IrrigationServiceFailureTests(TestCase):
def setUp(self):
self.user = get_user_model().objects.create_user(
username="irrigation-service-user",
password="secret123",
email="irrigation-service@example.com",
phone_number="09120000009",
)
self.farm_type = FarmType.objects.create(name="زراعی")
self.farm = FarmHub.objects.create(owner=self.user, farm_type=self.farm_type, name="Service Farm")
def test_get_water_need_prediction_raises_structured_error_for_missing_daily_entries(self):
IrrigationRecommendationRequest.objects.create(
farm=self.farm,
response_payload={"data": {"result": {"plan": {"bestTimeOfDay": "05:00"}}}},
)
from .services import get_water_need_prediction_data
with self.assertRaises(IrrigationDataUnavailableError) as exc_info:
get_water_need_prediction_data(self.farm)
self.assertEqual(exc_info.exception.contract.error_code, "empty_daily_data")
def test_build_recommendation_response_rejects_non_object_payload(self):
with self.assertRaises(IrrigationDataUnavailableError) as exc_info:
build_recommendation_response(["not-a-dict"])
self.assertEqual(exc_info.exception.contract.error_code, "invalid_payload")
class WaterStressViewTests(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
self.user = get_user_model().objects.create_user(
username="farmer",
password="secret123",
email="farmer@example.com",
phone_number="09120000000",
)
self.other_user = get_user_model().objects.create_user(
username="other-farmer",
password="secret123",
email="other@example.com",
phone_number="09120000001",
)
self.farm_type = FarmType.objects.create(name="زراعی")
self.farm = FarmHub.objects.create(owner=self.user, farm_type=self.farm_type, name="Farm 1")
self.other_farm = FarmHub.objects.create(owner=self.other_user, farm_type=self.farm_type, name="Farm 2")
@patch("irrigation.views.external_api_request")
def test_post_proxies_request_to_ai_service(self, mock_external_api_request):
mock_external_api_request.return_value = AdapterResponse(
status_code=200,
data={
"data": {
"result": {
"waterStressIndex": 12,
"level": "پایین",
"sourceMetric": {"soilMoisture": 24},
}
}
},
)
request = self.factory.post(
"/api/irrigation/water-stress/",
{"farm_uuid": str(self.farm.farm_uuid)},
format="json",
)
force_authenticate(request, user=self.user)
response = WaterStressView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["code"], 200)
self.assertEqual(response.data["msg"], "success")
self.assertEqual(response.data["data"]["farm_uuid"], str(self.farm.farm_uuid))
self.assertEqual(response.data["data"]["waterStressIndex"], 12)
self.assertEqual(response.data["data"]["level"], "پایین")
self.assertEqual(response.data["data"]["sourceMetric"], {"soilMoisture": 24})
self.assertEqual(response.data["meta"]["flow_type"], "direct_proxy")
self.assertEqual(response.data["meta"]["source_service"], "ai_irrigation_water_stress")
mock_external_api_request.assert_called_once_with(
"ai",
"/api/irrigation/water-stress/",
method="POST",
payload={"farm_uuid": str(self.farm.farm_uuid)},
)
def test_post_rejects_foreign_farm_uuid(self):
request = self.factory.post(
"/api/irrigation/water-stress/",
{"farm_uuid": str(self.other_farm.farm_uuid)},
format="json",
)
force_authenticate(request, user=self.user)
response = WaterStressView.as_view()(request)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.data["code"], 404)
self.assertEqual(response.data["data"]["farm_uuid"][0], "Farm not found.")
@patch("irrigation.views.external_api_request")
def test_post_returns_upstream_failure_without_masking_as_empty(self, mock_external_api_request):
mock_external_api_request.return_value = AdapterResponse(
status_code=503,
data={"message": "AI unavailable", "status": "error"},
)
request = self.factory.post(
"/api/irrigation/water-stress/",
{"farm_uuid": str(self.farm.farm_uuid)},
format="json",
)
force_authenticate(request, user=self.user)
response = WaterStressView.as_view()(request)
self.assertEqual(response.status_code, 503)
self.assertEqual(response.data["data"]["message"], "AI unavailable")
self.assertNotEqual(response.data.get("data"), [])
self.assertNotEqual(response.data.get("data"), {})
class IrrigationPlanFromTextViewTests(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
self.user = get_user_model().objects.create_user(
username="plan-parser-user",
password="secret123",
email="plan-parser@example.com",
phone_number="09120000005",
)
self.farm_type = FarmType.objects.create(name="گلخانه ای")
self.farm = FarmHub.objects.create(owner=self.user, farm_type=self.farm_type, name="Plan Parser Farm")
@patch("irrigation.views.external_api_request")
def test_plan_from_text_proxies_to_ai_service(self, mock_external_api_request):
mock_external_api_request.return_value = AdapterResponse(
status_code=200,
data={
"code": 200,
"msg": "موفق",
"data": {
"status": "completed",
"status_fa": "تکمیل شد",
"summary": "done",
"missing_fields": [],
"questions": [],
"collected_data": {"crop_name": "گوجه فرنگی"},
"final_plan": {"crop_name": "گوجه فرنگی"},
},
},
)
request = self.factory.post(
"/api/irrigation/plan-from-text/",
{"message": "متن برنامه", "farm_uuid": str(self.farm.farm_uuid)},
format="json",
)
force_authenticate(request, user=self.user)
response = PlanFromTextView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["data"]["status"], "completed")
self.assertEqual(response.data["meta"]["flow_type"], "direct_proxy")
self.assertEqual(response.data["meta"]["ownership"], "backend")
self.assertEqual(IrrigationPlan.objects.count(), 1)
plan = IrrigationPlan.objects.get()
self.assertEqual(plan.source, IrrigationPlan.SOURCE_FREE_TEXT)
self.assertEqual(plan.crop_id, "گوجه فرنگی")
mock_external_api_request.assert_called_once_with(
"ai",
"/api/irrigation/plan-from-text/",
method="POST",
payload={"message": "متن برنامه", "farm_uuid": str(self.farm.farm_uuid)},
)
def test_plan_from_text_requires_message_or_answers_or_partial_plan(self):
request = self.factory.post("/api/irrigation/plan-from-text/", {}, format="json")
force_authenticate(request, user=self.user)
response = PlanFromTextView.as_view()(request)
self.assertEqual(response.status_code, 400)
self.assertIn("non_field_errors", response.data)
class IrrigationMethodListViewTests(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
@patch("irrigation.views.external_api_request")
def test_get_proxies_irrigation_methods_from_ai(self, mock_external_api_request):
mock_external_api_request.return_value = AdapterResponse(
status_code=200,
data={
"data": [
{
"id": 1,
"name": "Drip",
"category": "micro",
"description": "Efficient irrigation",
"water_efficiency_percent": 90.0,
}
]
},
)
request = self.factory.get("/api/irrigation/")
response = IrrigationMethodListView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["code"], 200)
self.assertEqual(response.data["data"][0]["name"], "Drip")
self.assertEqual(response.data["meta"]["flow_type"], "direct_proxy")
self.assertTrue(response.data["meta"]["live"])
mock_external_api_request.assert_called_once_with(
"ai",
"/api/irrigation/",
method="GET",
)
@patch("irrigation.views.external_api_request")
def test_post_proxies_irrigation_method_creation_to_ai(self, mock_external_api_request):
mock_external_api_request.return_value = AdapterResponse(
status_code=201,
data={
"data": {
"id": 1,
"name": "Drip",
"category": "micro",
}
},
)
request = self.factory.post("/api/irrigation/", {"name": "Drip"}, format="json")
response = IrrigationMethodListView.as_view()(request)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data["data"]["name"], "Drip")
self.assertEqual(response.data["meta"]["source_service"], "ai_irrigation")
mock_external_api_request.assert_called_once_with(
"ai",
"/api/irrigation/",
method="POST",
payload={"name": "Drip"},
)
class RecommendViewTests(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
self.user = get_user_model().objects.create_user(
username="recommend-farmer",
password="secret123",
email="recommend@example.com",
phone_number="09120000002",
)
self.farm_type = FarmType.objects.create(name="باغی")
self.farm = FarmHub.objects.create(
owner=self.user,
farm_type=self.farm_type,
name="Recommend Farm",
irrigation_method_id=3,
irrigation_method_name="آبیاری قطره ای",
)
@patch("irrigation.views.external_api_request")
def test_post_returns_full_recommendation_shape(self, mock_external_api_request):
mock_external_api_request.return_value = AdapterResponse(
status_code=200,
data={
"data": {
"result": {
"plan": {
"frequencyPerWeek": 4,
"durationMinutes": 38,
"bestTimeOfDay": "05:30 تا 08:00 صبح",
"moistureLevel": 72,
"warning": "در ساعات گرم روز آبیاری انجام نشود",
},
"water_balance": {
"active_kc": 0.93,
"crop_profile": {
"kc_initial": 0.55,
"kc_mid": 1.05,
"kc_end": 0.78,
},
"daily": [
{
"forecast_date": "2025-02-12",
"et0_mm": 5.4,
"etc_mm": 4.9,
"effective_rainfall_mm": 0,
"gross_irrigation_mm": 17,
"irrigation_timing": "05:30 - 07:00",
}
],
},
"timeline": [
{
"step_number": 1,
"title": "بررسی فشار",
"description": "فشار ابتدا و انتهای لاین کنترل شود",
}
],
"sections": [
{
"title": "هشدار تبخیر بالا",
"icon": "tabler-alert-triangle",
"type": "warning",
"content": "در ساعات گرم روز آبیاری انجام نشود",
},
{
"title": "نکته بهره وری",
"icon": "tabler-bulb",
"type": "tip",
"content": "شست وشوی فیلترها به یکنواختی آبیاری کمک می کند",
},
],
}
}
},
)
request = self.factory.post(
"/api/irrigation/recommend/",
{
"farm_uuid": str(self.farm.farm_uuid),
"plant_name": "گوجه فرنگی",
"growth_stage": "گلدهی",
},
format="json",
)
force_authenticate(request, user=self.user)
response = RecommendView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["code"], 200)
self.assertIn("recommendation_uuid", response.data["data"])
self.assertEqual(response.data["data"]["status"], IrrigationRecommendationRequest.STATUS_PENDING_CONFIRMATION)
self.assertEqual(response.data["data"]["status_label"], "منتظر تایید")
self.assertEqual(IrrigationPlan.objects.count(), 1)
plan = IrrigationPlan.objects.get()
self.assertEqual(plan.source, IrrigationPlan.SOURCE_RECOMMENDATION)
self.assertFalse(plan.is_active)
self.assertFalse(plan.is_deleted)
self.assertEqual(response.data["data"]["plan"]["durationMinutes"], 38)
self.assertEqual(response.data["data"]["water_balance"]["active_kc"], 0.93)
self.assertEqual(response.data["data"]["timeline"][0]["step_number"], 1)
self.assertEqual(response.data["data"]["sections"][0]["type"], "warning")
@patch("irrigation.views.external_api_request")
def test_recommend_view_persists_real_response_and_never_returns_fake_success_on_invalid_payload(self, mock_external_api_request):
mock_external_api_request.return_value = AdapterResponse(
status_code=200,
data={"data": {"result": {"plan": {"bestTimeOfDay": "05:00"}}}},
)
request = self.factory.post(
"/api/irrigation/recommend/",
{
"farm_uuid": str(self.farm.farm_uuid),
"plant_name": "گوجه فرنگی",
"growth_stage": "گلدهی",
},
format="json",
)
force_authenticate(request, user=self.user)
response = RecommendView.as_view()(request)
self.assertEqual(response.status_code, 502)
self.assertEqual(IrrigationRecommendationRequest.objects.count(), 1)
self.assertEqual(IrrigationRecommendationRequest.objects.get().status, IrrigationRecommendationRequest.STATUS_ERROR)
mock_external_api_request.assert_called_once_with(
"ai",
"/api/irrigation/recommend/",
method="POST",
payload={
"farm_uuid": str(self.farm.farm_uuid),
"plant_name": "گوجه فرنگی",
"growth_stage": "گلدهی",
"irrigation_method_id": 3,
"irrigation_type": "آبیاری قطره ای",
"irrigation_method_name": "آبیاری قطره ای",
},
)
@patch("irrigation.views.external_api_request")
def test_post_includes_active_irrigation_plan_in_ai_payload(self, mock_external_api_request):
IrrigationPlan.objects.create(
farm=self.farm,
source=IrrigationPlan.SOURCE_FREE_TEXT,
title="برنامه فعال",
crop_id="گوجه فرنگی",
growth_stage="گلدهی",
plan_payload={
"plan": {"frequencyPerWeek": 2, "durationMinutes": 25, "bestTimeOfDay": "صبح"},
"water_balance": {"active_kc": 0.82, "daily": []},
"timeline": [{"step_number": 1, "title": "مرحله", "description": "توضیح"}],
"sections": [{"type": "warning", "title": "هشدار", "content": "متن"}],
},
is_active=True,
)
mock_external_api_request.return_value = AdapterResponse(status_code=200, data={"data": {"result": {"plan": {}}}})
request = self.factory.post(
"/api/irrigation/recommend/",
{"farm_uuid": str(self.farm.farm_uuid), "plant_name": "گوجه فرنگی", "growth_stage": "گلدهی"},
format="json",
)
force_authenticate(request, user=self.user)
response = RecommendView.as_view()(request)
self.assertEqual(response.status_code, 200)
sent_payload = mock_external_api_request.call_args.kwargs["payload"]
self.assertIn("active_irrigation_plan", sent_payload)
self.assertEqual(sent_payload["active_irrigation_plan"]["plan"]["durationMinutes"], 25)
self.assertEqual(sent_payload["active_irrigation_plan"]["water_balance"]["active_kc"], 0.82)
class IrrigationRecommendationHistoryTests(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
self.user = get_user_model().objects.create_user(
username="history-farmer",
password="secret123",
email="history@example.com",
phone_number="09120000003",
)
self.other_user = get_user_model().objects.create_user(
username="other-history-farmer",
password="secret123",
email="other-history@example.com",
phone_number="09120000004",
)
self.farm_type = FarmType.objects.create(name="گلخانه ای")
self.farm = FarmHub.objects.create(owner=self.user, farm_type=self.farm_type, name="History Farm")
self.other_farm = FarmHub.objects.create(owner=self.other_user, farm_type=self.farm_type, name="Other History Farm")
def test_recommendation_list_returns_paginated_items(self):
first = IrrigationRecommendationRequest.objects.create(
farm=self.farm,
crop_id="گندم",
growth_stage="vegetative",
status=IrrigationRecommendationRequest.STATUS_COMPLETED,
request_payload={"irrigation_method_name": "بارانی"},
response_payload={"data": {"plan": {"durationMinutes": 20}}},
)
second = IrrigationRecommendationRequest.objects.create(
farm=self.farm,
crop_id="ذرت",
growth_stage="flowering",
status=IrrigationRecommendationRequest.STATUS_PENDING_CONFIRMATION,
request_payload={"irrigation_method_name": "قطره ای"},
response_payload={"data": {"plan": {"durationMinutes": 35}}},
)
request = self.factory.get(
f"/api/irrigation/recommendations/?farm_uuid={self.farm.farm_uuid}&page=1&page_size=1"
)
force_authenticate(request, user=self.user)
response = RecommendationListView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["code"], 200)
self.assertEqual(len(response.data["data"]), 1)
self.assertEqual(response.data["pagination"]["total_items"], 2)
self.assertEqual(response.data["data"][0]["recommendation_uuid"], str(second.uuid))
self.assertEqual(response.data["data"][0]["plant_name"], "ذرت")
self.assertEqual(response.data["data"][0]["growth_stage"], "flowering")
self.assertEqual(response.data["data"][0]["irrigation_method_name"], "قطره ای")
self.assertEqual(response.data["data"][0]["status"], IrrigationRecommendationRequest.STATUS_PENDING_CONFIRMATION)
self.assertEqual(response.data["data"][0]["status_label"], "منتظر تایید")
self.assertNotEqual(response.data["data"][0]["recommendation_uuid"], str(first.uuid))
def test_recommendation_detail_returns_saved_shape(self):
recommendation = IrrigationRecommendationRequest.objects.create(
farm=self.farm,
crop_id="گوجه فرنگی",
growth_stage="fruiting",
status=IrrigationRecommendationRequest.STATUS_COMPLETED,
request_payload={"irrigation_method_name": "قطره ای"},
response_payload={
"data": {
"result": {
"plan": {"frequencyPerWeek": 4, "durationMinutes": 30},
"water_balance": {"active_kc": 0.93, "daily": []},
"timeline": [{"step_number": 1, "title": "مرحله اول", "description": "اجرا شود"}],
"sections": [{"type": "tip", "title": "نکته", "content": "صبح زود آبیاری شود"}],
}
}
},
)
request = self.factory.get(f"/api/irrigation/recommendations/{recommendation.uuid}/")
force_authenticate(request, user=self.user)
response = RecommendationDetailView.as_view()(request, recommendation_uuid=recommendation.uuid)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["code"], 200)
self.assertEqual(response.data["data"]["recommendation_uuid"], str(recommendation.uuid))
self.assertEqual(response.data["data"]["crop_id"], "گوجه فرنگی")
self.assertEqual(response.data["data"]["plant_name"], "گوجه فرنگی")
self.assertEqual(response.data["data"]["growth_stage"], "fruiting")
self.assertEqual(response.data["data"]["irrigation_method_name"], "قطره ای")
self.assertEqual(response.data["data"]["status"], IrrigationRecommendationRequest.STATUS_COMPLETED)
self.assertEqual(response.data["data"]["status_label"], "پایان یافته")
self.assertEqual(response.data["data"]["plan"]["durationMinutes"], 30)
self.assertEqual(response.data["data"]["timeline"][0]["step_number"], 1)
self.assertEqual(response.data["data"]["sections"][0]["type"], "tip")
def test_recommendation_detail_rejects_foreign_recommendation(self):
recommendation = IrrigationRecommendationRequest.objects.create(
farm=self.other_farm,
crop_id="خیار",
status=IrrigationRecommendationRequest.STATUS_PENDING_CONFIRMATION,
)
request = self.factory.get(f"/api/irrigation/recommendations/{recommendation.uuid}/")
force_authenticate(request, user=self.user)
response = RecommendationDetailView.as_view()(request, recommendation_uuid=recommendation.uuid)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.data["msg"], "Recommendation not found.")
@patch("irrigation.views.external_api_request")
def test_post_accepts_sensor_uuid_as_farm_uuid_alias(self, mock_external_api_request):
mock_external_api_request.return_value = AdapterResponse(
status_code=200,
data={"data": {"result": {"sections": []}}},
)
request = self.factory.post(
"/api/irrigation/recommend/",
{
"sensor_uuid": str(self.farm.farm_uuid),
},
format="json",
)
force_authenticate(request, user=self.user)
response = RecommendView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["data"]["plan"]["frequencyPerWeek"], 4)
mock_external_api_request.assert_called_once_with(
"ai",
"/api/irrigation/recommend/",
method="POST",
payload={
"farm_uuid": str(self.farm.farm_uuid),
"irrigation_method_id": 3,
"irrigation_type": "آبیاری قطره ای",
"irrigation_method_name": "آبیاری قطره ای",
},
)
class IrrigationPlanApiTests(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
self.user = get_user_model().objects.create_user(
username="irrigation-plan-user",
password="secret123",
email="irrigation-plan@example.com",
phone_number="09124445566",
)
self.farm_type = FarmType.objects.create(name="زراعی")
self.farm = FarmHub.objects.create(owner=self.user, farm_type=self.farm_type, name="Irrigation Plan Farm")
self.plan = IrrigationPlan.objects.create(
farm=self.farm,
source=IrrigationPlan.SOURCE_FREE_TEXT,
title="برنامه آبیاری نمونه",
crop_id="گندم",
growth_stage="flowering",
plan_payload={"plan": {"durationMinutes": 25}},
)
def test_plan_list_returns_non_deleted_plans(self):
IrrigationPlan.objects.create(
farm=self.farm,
source=IrrigationPlan.SOURCE_RECOMMENDATION,
title="حذف شده",
is_deleted=True,
is_active=False,
)
request = self.factory.get(f"/api/irrigation/plans/?farm_uuid={self.farm.farm_uuid}")
force_authenticate(request, user=self.user)
response = IrrigationPlanListView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["code"], 200)
self.assertEqual(len(response.data["data"]), 1)
self.assertEqual(response.data["data"][0]["plan_uuid"], str(self.plan.uuid))
def test_plan_detail_returns_plan_payload(self):
request = self.factory.get(f"/api/irrigation/plans/{self.plan.uuid}/")
force_authenticate(request, user=self.user)
response = IrrigationPlanDetailView.as_view()(request, plan_uuid=self.plan.uuid)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["data"]["plan_uuid"], str(self.plan.uuid))
self.assertEqual(response.data["data"]["plan_payload"]["plan"]["durationMinutes"], 25)
def test_plan_delete_is_soft_delete(self):
request = self.factory.delete(f"/api/irrigation/plans/{self.plan.uuid}/")
force_authenticate(request, user=self.user)
response = IrrigationPlanDetailView.as_view()(request, plan_uuid=self.plan.uuid)
self.assertEqual(response.status_code, 200)
self.plan.refresh_from_db()
self.assertTrue(self.plan.is_deleted)
self.assertFalse(self.plan.is_active)
def test_plan_status_patch_updates_is_active(self):
request = self.factory.patch(
f"/api/irrigation/plans/{self.plan.uuid}/status/",
{"is_active": True},
format="json",
)
force_authenticate(request, user=self.user)
response = IrrigationPlanStatusView.as_view()(request, plan_uuid=self.plan.uuid)
self.assertEqual(response.status_code, 200)
self.plan.refresh_from_db()
self.assertTrue(self.plan.is_active)
def test_activating_one_plan_deactivates_other_active_plan(self):
other_plan = IrrigationPlan.objects.create(
farm=self.farm,
source=IrrigationPlan.SOURCE_FREE_TEXT,
title="برنامه دوم",
is_active=True,
)
request = self.factory.patch(
f"/api/irrigation/plans/{self.plan.uuid}/status/",
{"is_active": True},
format="json",
)
force_authenticate(request, user=self.user)
response = IrrigationPlanStatusView.as_view()(request, plan_uuid=self.plan.uuid)
self.assertEqual(response.status_code, 200)
self.plan.refresh_from_db()
other_plan.refresh_from_db()
self.assertTrue(self.plan.is_active)
self.assertFalse(other_plan.is_active)
def test_plan_status_patch_syncs_calendar_events(self):
self.plan.plan_payload = {
"plan": {"durationMinutes": 25, "bestTimeOfDay": "05:30 - 06:00"},
"water_balance": {
"daily": [
{
"forecast_date": "2025-02-12",
"gross_irrigation_mm": 17,
"irrigation_timing": "05:30 - 06:00",
}
]
},
}
self.plan.is_active = False
self.plan.save(update_fields=["plan_payload", "is_active", "updated_at"])
activate_request = self.factory.patch(
f"/api/irrigation/plans/{self.plan.uuid}/status/",
{"is_active": True},
format="json",
)
force_authenticate(activate_request, user=self.user)
activate_response = IrrigationPlanStatusView.as_view()(activate_request, plan_uuid=self.plan.uuid)
self.assertEqual(activate_response.status_code, 200)
events = FarmerCalendarEvent.objects.filter(farm=self.farm, extended_props__plan_uuid=str(self.plan.uuid))
self.assertEqual(events.count(), 1)
self.assertEqual(events.first().extended_props["plan_type"], "irrigation")
deactivate_request = self.factory.patch(
f"/api/irrigation/plans/{self.plan.uuid}/status/",
{"is_active": False},
format="json",
)
force_authenticate(deactivate_request, user=self.user)
deactivate_response = IrrigationPlanStatusView.as_view()(deactivate_request, plan_uuid=self.plan.uuid)
self.assertEqual(deactivate_response.status_code, 200)
self.assertFalse(
FarmerCalendarEvent.objects.filter(farm=self.farm, extended_props__plan_uuid=str(self.plan.uuid)).exists()
)