Merge branch 'feature/relational-db' into rel-db-presenter-tests

Author: vkrasnovyd

openslides_backend/action/actions/poll/delete.py

@@ -34,7 +34,6 @@ def prefetch(self, action_data: ActionData) -> None:
                         "option_ids",
                         "global_option_id",
                         "projection_ids",
-                        "meta_position",
                         "state",
                     ],
                 ),
@@ -82,7 +81,6 @@ def prefetch(self, action_data: ActionData) -> None:
                     "poll_id",
                     "used_as_global_option_in_poll_id",
                     "vote_ids",
-                    "meta_position",
                 ],
             ),
             GetManyRequest(

openslides_backend/action/actions/poll/mixins.py

@@ -6,12 +6,7 @@
 
 from ....services.database.commands import GetManyRequest
 from ....shared.exceptions import ActionException, VoteServiceException
-from ....shared.interfaces.write_request import WriteRequest
-from ....shared.patterns import (
-    collection_from_fqid,
-    collectionfield_and_fqid_from_fqfield,
-    fqid_from_collection_and_id,
-)
+from ....shared.patterns import collection_from_fqid, fqid_from_collection_and_id
 from ...action import Action
 from ..option.set_auto_fields import OptionSetAutoFields
 from ..projector_countdown.mixins import CountdownCommand, CountdownControl
@@ -79,29 +74,6 @@ def check_permissions(self, instance: dict[str, Any]) -> None:
 
 
 class StopControl(CountdownControl, Action):
-    def build_write_request(self) -> WriteRequest | None:
-        """
-        Reduce locked fields
-        """
-        self.datastore.locked_fields = {
-            k: v
-            for k, v in self.datastore.locked_fields.items()
-            if collectionfield_and_fqid_from_fqfield(k)[0]
-            not in (
-                "meeting_user/user_id",
-                "meeting_user/vote_delegated_to_id",
-                "poll/pollmethod",
-                "poll/global_option_id",
-                "poll/meeting_id",
-                "poll/content_object_id",
-                "meeting/users_enable_vote_weight",
-                "meeting/poll_couple_countdown",
-                "meeting/poll_countdown_id",
-                "option/meeting_id",
-            )
-        }
-        return super().build_write_request()
-
     def on_stop(self, instance: dict[str, Any]) -> None:
         poll = self.datastore.get(
             fqid_from_collection_and_id(self.model.collection, instance["id"]),

openslides_backend/action/actions/poll/update.py

@@ -1,5 +1,7 @@
 from typing import Any
 
+from psycopg.types.json import Jsonb
+
 from openslides_backend.action.mixins.extend_history_mixin import ExtendHistoryMixin
 from openslides_backend.services.database.interface import PartialModel
 
@@ -155,6 +157,11 @@ def update_instance(self, instance: dict[str, Any]) -> dict[str, Any]:
 
         instance.pop("publish_immediately", None)
         self.check_anonymous_not_in_list_fields(instance, ["entitled_group_ids"])
+
+        if raw_entitled_users_at_stop := instance.get("entitled_users_at_stop"):
+            if isinstance(raw_entitled_users_at_stop, list):
+                instance["entitled_users_at_stop"] = Jsonb(raw_entitled_users_at_stop)
+
         return instance
 
     def check_onehundred_percent_base(self, instance: dict[str, Any]) -> None:

tests/system/action/poll/base_poll_test.py

@@ -1,10 +1,26 @@
-import pytest
+from typing import Any
 
 from tests.system.action.base import BaseActionTestCase
 
 
-@pytest.mark.skip(reason="During development of relational DB not necessary")
 class BasePollTestCase(BaseActionTestCase):
     def setUp(self) -> None:
         super().setUp()
         self.vote_service.clear_all()
+
+    def create_assignment(
+        self, base: int, meeting_id: int, assignment_data: dict[str, Any] = {}
+    ) -> None:
+        self.set_models(
+            {
+                f"assignment/{base}": {
+                    "title": "just do it",
+                    "meeting_id": meeting_id,
+                    **assignment_data,
+                },
+                f"list_of_speakers/{base + 100}": {
+                    "content_object_id": f"assignment/{base}",
+                    "meeting_id": meeting_id,
+                },
+            }
+        )

tests/system/action/poll/poll_test_mixin.py

@@ -10,50 +10,28 @@ def start_poll(self, id: int) -> None:
     def prepare_users_and_poll(self, user_count: int) -> list[int]:
         user_ids = list(range(2, user_count + 2))
         self.create_meeting()
+        self.create_motion(1, 1)
         self.set_models(
             {
-                "motion/1": {
-                    "meeting_id": 1,
-                },
                 "poll/1": {
                     "content_object_id": "motion/1",
                     "type": Poll.TYPE_NAMED,
                     "pollmethod": "YNA",
                     "backend": "fast",
                     "state": Poll.STATE_STARTED,
-                    "option_ids": [1],
                     "meeting_id": 1,
                     "entitled_group_ids": [3],
                     "onehundred_percent_base": "YNA",
                     "title": "Poll 1",
                 },
                 "option/1": {"meeting_id": 1, "poll_id": 1},
+                **{f"user/{i}": {**self._get_user_data(f"user{i}")} for i in user_ids},
                 **{
-                    f"user/{i}": {
-                        **self._get_user_data(f"user{i}"),
-                        "is_present_in_meeting_ids": [1],
-                        "meeting_ids": [1],
-                        "meeting_user_ids": [i + 10],
-                    }
-                    for i in user_ids
-                },
-                **{
-                    f"meeting_user/{i+10}": {
-                        "meeting_id": 1,
-                        "user_id": i,
-                        "group_ids": [3],
-                    }
+                    f"meeting_user/{i+10}": {"meeting_id": 1, "user_id": i}
                     for i in user_ids
                 },
-                "group/3": {
-                    "meeting_user_ids": [id_ + 10 for id_ in user_ids],
-                    "meeting_id": 1,
-                },
-                "meeting/1": {
-                    "user_ids": user_ids,
-                    "group_ids": [3],
-                    "name": "test",
-                },
+                "group/3": {"meeting_user_ids": [id_ + 10 for id_ in user_ids]},
+                "meeting/1": {"present_user_ids": user_ids},
             }
         )
         self.start_poll(1)

tests/system/action/poll/test_anonymize.py

@@ -1,5 +1,8 @@
+from typing import Any
+
 from openslides_backend.models.models import Poll
 from openslides_backend.permissions.permissions import Permissions
+from openslides_backend.services.database.interface import PartialModel
 
 from .base_poll_test import BasePollTestCase
 
@@ -8,113 +11,110 @@ class PollAnonymize(BasePollTestCase):
     def setUp(self) -> None:
         super().setUp()
         self.create_meeting()
-        self.set_models(
-            {
-                "poll/1": {
-                    "option_ids": [1],
-                    "global_option_id": 2,
-                    "meeting_id": 1,
-                    "state": Poll.STATE_FINISHED,
-                    "type": Poll.TYPE_NAMED,
-                    "content_object_id": "topic/1",
-                },
-                "topic/1": {"meeting_id": 1},
-                "option/1": {"vote_ids": [1], "meeting_id": 1},
-                "option/2": {"vote_ids": [2], "meeting_id": 1},
-                "vote/1": {
-                    "user_id": 1,
-                    "meeting_id": 1,
-                    "delegated_user_id": 1,
-                },
-                "vote/2": {
-                    "user_id": 1,
-                    "meeting_id": 1,
-                    "delegated_user_id": 1,
-                },
-                "user/1": {
-                    "meeting_user_ids": [11],
-                    "delegated_vote_ids": [1, 2],
-                    "vote_ids": [1, 2],
-                },
-                "meeting_user/11": {
-                    "meeting_id": 1,
-                    "user_id": 1,
-                },
-            }
-        )
+        self.create_topic(1, 1)
+        self.set_user_groups(1, [1])
+        self.test_data: dict[str, dict[str, Any]] = {
+            "poll/1": {
+                "title": "Poll 1",
+                "global_option_id": 2,
+                "meeting_id": 1,
+                "state": Poll.STATE_FINISHED,
+                "type": Poll.TYPE_NAMED,
+                "content_object_id": "topic/1",
+                "pollmethod": "Y",
+                "onehundred_percent_base": Poll.ONEHUNDRED_PERCENT_BASE_Y,
+            },
+            "option/1": {"meeting_id": 1, "poll_id": 1},
+            "option/2": {"meeting_id": 1, "poll_id": 1},
+            "vote/1": {
+                "user_id": 1,
+                "meeting_id": 1,
+                "delegated_user_id": 1,
+                "user_token": "abc",
+                "option_id": 1,
+            },
+            "vote/2": {
+                "user_id": 1,
+                "meeting_id": 1,
+                "delegated_user_id": 1,
+                "user_token": "edf",
+                "option_id": 2,
+            },
+        }
+
+    def set_test_data(self, poll_data: PartialModel = {}) -> None:
+        if poll_data:
+            self.test_data["poll/1"].update(poll_data)
+        self.set_models(self.test_data)
 
     def assert_anonymize(self) -> None:
-        poll = self.get_model("poll/1")
-        assert poll.get("is_pseudoanonymized") is True
+        self.assert_model_exists("poll/1", {"is_pseudoanonymized": True})
         for fqid in ("vote/1", "vote/2"):
-            vote = self.get_model(fqid)
-            assert vote.get("user_id") is None
-            assert vote.get("delegated_user_id") is None
-        self.assert_model_exists("user/1", {"vote_ids": [], "delegated_vote_ids": []})
+            self.assert_model_exists(fqid, {"user_id": None, "delegated_user_id": None})
+        self.assert_model_exists(
+            "user/1", {"vote_ids": None, "delegated_vote_ids": None}
+        )
 
     def test_anonymize(self) -> None:
+        self.set_test_data()
         response = self.request("poll.anonymize", {"id": 1})
         self.assert_status_code(response, 200)
         self.assert_anonymize()
         self.assert_history_information("topic/1", ["Voting anonymized"])
 
     def test_anonymize_assignment_poll(self) -> None:
-        self.set_models(
-            {
-                "assignment/1": {
-                    "meeting_id": 1,
-                },
-                "poll/1": {
-                    "content_object_id": "assignment/1",
-                },
-            }
-        )
+        self.create_assignment(1, 1)
+        self.set_test_data({"content_object_id": "assignment/1"})
         response = self.request("poll.anonymize", {"id": 1})
         self.assert_status_code(response, 200)
         self.assert_history_information("assignment/1", ["Ballot anonymized"])
 
     def test_anonymize_publish_state(self) -> None:
-        self.update_model("poll/1", {"state": Poll.STATE_PUBLISHED})
+        self.set_test_data({"state": Poll.STATE_PUBLISHED})
         response = self.request("poll.anonymize", {"id": 1})
         self.assert_status_code(response, 200)
         self.assert_anonymize()
 
     def test_anonymize_wrong_state(self) -> None:
-        self.update_model("poll/1", {"state": Poll.STATE_CREATED})
+        self.set_test_data({"state": Poll.STATE_CREATED})
         response = self.request("poll.anonymize", {"id": 1})
         self.assert_status_code(response, 400)
         for vote_fqid in ("vote/1", "vote/2"):
-            vote = self.get_model(vote_fqid)
-            assert vote.get("user_id") == 1
-            assert vote.get("delegated_user_id") == 1
+            self.assert_model_exists(vote_fqid, {"user_id": 1, "delegated_user_id": 1})
+        self.assertEqual(
+            "Anonymizing can only be done after finishing a poll.",
+            response.json["message"],
+        )
 
     def test_anonymize_wrong_type(self) -> None:
-        self.update_model("poll/1", {"type": Poll.TYPE_ANALOG})
+        self.set_test_data({"type": Poll.TYPE_ANALOG})
         response = self.request("poll.anonymize", {"id": 1})
         self.assert_status_code(response, 400)
         for vote_fqid in ("vote/1", "vote/2"):
-            vote = self.get_model(vote_fqid)
-            assert vote.get("user_id") == 1
-            assert vote.get("delegated_user_id") == 1
+            self.assert_model_exists(vote_fqid, {"user_id": 1, "delegated_user_id": 1})
+        self.assertEqual(
+            "You can only anonymize named polls.",
+            response.json["message"],
+        )
 
     def test_anonymize_no_permissions(self) -> None:
         self.base_permission_test(
-            {},
+            self.test_data,
             "poll.anonymize",
             {"id": 1},
         )
 
     def test_anonymize_permissions(self) -> None:
         self.base_permission_test(
-            {},
+            self.test_data,
             "poll.anonymize",
             {"id": 1},
             Permissions.Poll.CAN_MANAGE,
         )
 
     def test_anonymize_permissions_locked_meeting(self) -> None:
         self.base_locked_out_superadmin_permission_test(
-            {},
+            self.test_data,
             "poll.anonymize",
             {"id": 1},
         )