slidge 0.1.0rc1__py3-none-any.whl → 0.1.2__py3-none-any.whl

slidge/util/test.py

@@ -2,11 +2,13 @@
 import tempfile
 import types
 from pathlib import Path
-from typing import Union
+from typing import Optional, Union
 from xml.dom.minidom import parseString
 
+import xmldiff.main
 from slixmpp import (
     ElementBase,
+    Iq,
     MatcherId,
     MatchXMLMask,
     MatchXPath,
@@ -14,100 +16,31 @@ from slixmpp import (
     Presence,
     StanzaPath,
 )
+from slixmpp.stanza.error import Error
 from slixmpp.test import SlixTest, TestTransport
 from slixmpp.xmlstream import highlight, tostring
 from slixmpp.xmlstream.matcher import MatchIDSender
 
-from slidge import *
+from slidge import (
+    BaseGateway,
+    BaseSession,
+    LegacyBookmarks,
+    LegacyContact,
+    LegacyMUC,
+    LegacyParticipant,
+    LegacyRoster,
+    user_store,
+)
 
+from ..command import Command
 from ..core import config
+from ..core.config import _TimedeltaSeconds
 
 
-class SlidgeTest(SlixTest):
-    plugin: Union[types.ModuleType, dict]
-
-    class Config:
-        jid = "aim.shakespeare.lit"
-        secret = "test"
-        server = "shakespeare.lit"
-        port = 5222
-        upload_service = "upload.test"
-        home_dir = Path(tempfile.mkdtemp())
-        user_jid_validator = ".*@shakespeare.lit"
-        admins: list[str] = []
-        no_roster_push = False
-        upload_requester = None
-        ignore_delay_threshold = 300
-
-    @classmethod
-    def setUpClass(cls):
-        user_store.set_file(Path(tempfile.mkdtemp()) / "test.db")
-        for k, v in vars(cls.Config).items():
-            setattr(config, k.upper(), v)
-
+class SlixTestPlus(SlixTest):
     def setUp(self):
-        BaseGateway._subclass = find_subclass(self.plugin, BaseGateway)
-        BaseSession._subclass = find_subclass(self.plugin, BaseSession)
-        LegacyRoster._subclass = find_subclass(self.plugin, LegacyRoster, base_ok=True)
-        LegacyContact._subclass = find_subclass(
-            self.plugin, LegacyContact, base_ok=True
-        )
-        LegacyMUC._subclass = find_subclass(self.plugin, LegacyMUC, base_ok=True)
-        LegacyBookmarks._subclass = find_subclass(
-            self.plugin, LegacyBookmarks, base_ok=True
-        )
-
-        self.xmpp = BaseGateway.get_self_or_unique_subclass()()
-
-        self.xmpp._always_send_everything = True
-
-        self.xmpp.connection_made(TestTransport(self.xmpp))
-        self.xmpp.session_bind_event.set()
-        # Remove unique ID prefix to make it easier to test
-        self.xmpp._id_prefix = ""
-        self.xmpp.default_lang = None
-        self.xmpp.peer_default_lang = None
-
-        def new_id():
-            self.xmpp._id += 1
-            return str(self.xmpp._id)
-
-        self.xmpp._id = 0
-        self.xmpp.new_id = new_id
-
-        # Must have the stream header ready for xmpp.process() to work.
-        header = self.xmpp.stream_header
-
-        self.xmpp.data_received(header)
-        self.wait_for_send_queue()
-
-        self.xmpp.socket.next_sent()
-        self.xmpp.socket.next_sent()
-
-        # Some plugins require messages to have ID values. Set
-        # this to True in tests related to those plugins.
-        self.xmpp.use_message_ids = False
-        self.xmpp.use_presence_ids = False
-
-    @classmethod
-    def tearDownClass(cls):
-        BaseSession.reset_subclass()
-        BaseGateway.reset_subclass()
-        LegacyRoster.reset_subclass()
-        LegacyContact.reset_subclass()
-        LegacyMUC.reset_subclass()
-        LegacyBookmarks.reset_subclass()
-        user_store._users = None
-
-    def next_sent(self):
-        self.wait_for_send_queue()
-        sent = self.xmpp.socket.next_sent(timeout=1)
-        if sent is None:
-            return None
-        xml = self.parse_xml(sent)
-        self.fix_namespaces(xml, "jabber:component:accept")
-        sent = self.xmpp._build_stanza(xml, "jabber:component:accept")
-        return sent
+        super().setUp()
+        Error.namespace = "jabber:component:accept"
 
     def check(self, stanza, criteria, method="exact", defaults=None, use_values=True):
         """
@@ -218,8 +151,102 @@ class SlidgeTest(SlixTest):
                 result = self.compare(xml, stanza.xml, stanza2.xml)
             stanza_class.namespace = old_ns
 
+            if not result:
+                debug += str(
+                    xmldiff.main.diff_texts(tostring(xml), tostring(stanza.xml))
+                )
+                if use_values:
+                    debug += str(
+                        xmldiff.main.diff_texts(tostring(xml), tostring(stanza2.xml))
+                    )
             self.assertTrue(result, debug)
 
+    def next_sent(self, timeout=0.05) -> Optional[Union[Message, Iq, Presence]]:
+        self.wait_for_send_queue()
+        sent = self.xmpp.socket.next_sent(timeout=timeout)
+        if sent is None:
+            return None
+        xml = self.parse_xml(sent)
+        self.fix_namespaces(xml, "jabber:component:accept")
+        sent = self.xmpp._build_stanza(xml, "jabber:component:accept")
+        return sent
+
+
+class SlidgeTest(SlixTestPlus):
+    plugin: Union[types.ModuleType, dict]
+
+    class Config:
+        jid = "aim.shakespeare.lit"
+        secret = "test"
+        server = "shakespeare.lit"
+        port = 5222
+        upload_service = "upload.test"
+        home_dir = Path(tempfile.mkdtemp())
+        user_jid_validator = ".*"
+        admins: list[str] = []
+        no_roster_push = False
+        upload_requester = None
+        ignore_delay_threshold = _TimedeltaSeconds("300")
+
+    @classmethod
+    def setUpClass(cls):
+        user_store.set_file(Path(tempfile.mkdtemp()) / "test.db")
+        for k, v in vars(cls.Config).items():
+            setattr(config, k.upper(), v)
+
+    def setUp(self):
+        if hasattr(self, "plugin"):
+            BaseGateway._subclass = find_subclass(self.plugin, BaseGateway)
+            BaseSession._subclass = find_subclass(self.plugin, BaseSession)
+            LegacyRoster._subclass = find_subclass(
+                self.plugin, LegacyRoster, base_ok=True
+            )
+            LegacyContact._subclass = find_subclass(
+                self.plugin, LegacyContact, base_ok=True
+            )
+            LegacyMUC._subclass = find_subclass(self.plugin, LegacyMUC, base_ok=True)
+            LegacyBookmarks._subclass = find_subclass(
+                self.plugin, LegacyBookmarks, base_ok=True
+            )
+
+        self.xmpp = BaseGateway.get_self_or_unique_subclass()()
+
+        self.xmpp._always_send_everything = True
+
+        self.xmpp.connection_made(TestTransport(self.xmpp))
+        self.xmpp.session_bind_event.set()
+        # Remove unique ID prefix to make it easier to test
+        self.xmpp._id_prefix = ""
+        self.xmpp.default_lang = None
+        self.xmpp.peer_default_lang = None
+
+        def new_id():
+            self.xmpp._id += 1
+            return str(self.xmpp._id)
+
+        self.xmpp._id = 0
+        self.xmpp.new_id = new_id
+
+        # Must have the stream header ready for xmpp.process() to work.
+        header = self.xmpp.stream_header
+
+        self.xmpp.data_received(header)
+        self.wait_for_send_queue()
+
+        self.xmpp.socket.next_sent()
+        self.xmpp.socket.next_sent()
+
+        # Some plugins require messages to have ID values. Set
+        # this to True in tests related to those plugins.
+        self.xmpp.use_message_ids = False
+        self.xmpp.use_presence_ids = False
+        Error.namespace = "jabber:component:accept"
+
+    @classmethod
+    def tearDownClass(cls):
+        reset_subclasses()
+        user_store._users = None
+
 
 def format_stanza(stanza):
     return highlight(
@@ -243,3 +270,26 @@ def find_subclass(o, parent, base_ok=False):
             return parent
         else:
             raise RuntimeError
+
+
+def reset_subclasses():
+    """
+    Reset registered subclasses between test classes.
+
+    Needed because these classes are meant to only be subclassed once and raise
+    exceptions otherwise.
+    """
+    BaseSession.reset_subclass()
+    BaseGateway.reset_subclass()
+    LegacyRoster.reset_subclass()
+    LegacyContact.reset_subclass()
+    LegacyMUC.reset_subclass()
+    LegacyBookmarks.reset_subclass()
+    LegacyParticipant.reset_subclass()
+    # reset_commands()
+
+
+def reset_commands():
+    Command.subclasses = [
+        c for c in Command.subclasses if str(c).startswith("<class 'slidge.core")
+    ]

slidge/util/types.py

@@ -1,39 +1,180 @@
+"""
+Typing stuff
+"""
+
+from dataclasses import dataclass
+from enum import IntEnum
 from pathlib import Path
-from typing import TYPE_CHECKING, Hashable, Literal, TypeVar, Union
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Hashable,
+    Literal,
+    NamedTuple,
+    Optional,
+    TypedDict,
+    TypeVar,
+    Union,
+)
+
+from slixmpp import Message, Presence
+from slixmpp.types import PresenceShows
 
 if TYPE_CHECKING:
-    from ..core.contact import LegacyContact, LegacyRoster
-    from ..core.gateway import BaseGateway
-    from ..core.muc.bookmarks import LegacyBookmarks
-    from ..core.muc.participant import LegacyParticipant
-    from ..core.muc.room import LegacyMUC
+    from ..contact import LegacyContact
     from ..core.pubsub import PepItem
     from ..core.session import BaseSession
+    from ..group.participant import LegacyMUC, LegacyParticipant
+    from .db import GatewayUser
+
+    AnyBaseSession = BaseSession[Any, Any]
+else:
+    AnyBaseSession = None
+
+
+class URL(str):
+    pass
+
 
-BookmarksType = TypeVar("BookmarksType", bound="LegacyBookmarks")
-GatewayType = TypeVar("GatewayType", bound="BaseGateway")
-LegacyContactType = TypeVar("LegacyContactType", bound="LegacyContact")
 LegacyGroupIdType = TypeVar("LegacyGroupIdType", bound=Hashable)
+"""
+Type of the unique identifier for groups, usually a str or an int,
+but anything hashable should work.
+"""
 LegacyMessageType = TypeVar("LegacyMessageType", bound=Hashable)
+LegacyThreadType = TypeVar("LegacyThreadType", bound=Hashable)
+LegacyUserIdType = TypeVar("LegacyUserIdType", bound=Hashable)
+
+LegacyContactType = TypeVar("LegacyContactType", bound="LegacyContact")
 LegacyMUCType = TypeVar("LegacyMUCType", bound="LegacyMUC")
 LegacyParticipantType = TypeVar("LegacyParticipantType", bound="LegacyParticipant")
-LegacyRosterType = TypeVar("LegacyRosterType", bound="LegacyRoster")
-LegacyUserIdType = TypeVar("LegacyUserIdType", bound=Hashable)
+
 PepItemType = TypeVar("PepItemType", bound="PepItem")
-SessionType = TypeVar("SessionType", bound="BaseSession")
-Chat = Union[LegacyMUCType, LegacyContactType]
+
+Recipient = Union["LegacyMUC", "LegacyContact"]
+RecipientType = TypeVar("RecipientType", bound=Recipient)
+Sender = Union["LegacyContact", "LegacyParticipant"]
 AvatarType = Union[bytes, str, Path]
+LegacyFileIdType = Union[int, str]
+AvatarIdType = Union[LegacyFileIdType, URL]
 
 ChatState = Literal["active", "composing", "gone", "inactive", "paused"]
 ProcessingHint = Literal["no-store", "markable", "store"]
 Marker = Literal["acknowledged", "received", "displayed"]
-PresenceShow = Literal["away", "chat", "dnd", "xa"]
 FieldType = Literal[
     "boolean",
     "fixed",
     "text-single",
     "jid-single",
+    "jid-multi",
     "list-single",
     "list-multi",
     "text-private",
 ]
+MucAffiliation = Literal["owner", "admin", "member", "outcast", "none"]
+MucRole = Literal["visitor", "participant", "moderator", "none"]
+
+
+@dataclass
+class MessageReference(Generic[LegacyMessageType]):
+    """
+    A "message reply", ie a "quoted message" (:xep:`0461`)
+
+    At the very minimum, the legacy message ID attribute must be set, but to
+    ensure that the quote is displayed in all XMPP clients, the author must also
+    be set.
+    The body is used as a fallback for XMPP clients that do not support :xep:`0461`
+    of that failed to find the referenced message.
+    """
+
+    legacy_id: LegacyMessageType
+    author: Optional[Union["GatewayUser", "LegacyParticipant", "LegacyContact"]] = None
+    body: Optional[str] = None
+
+
+@dataclass
+class LegacyAttachment:
+    """
+    A file attachment to a message
+
+    At the minimum, one of the ``path``, ``steam``, ``data`` or ``url`` attribute
+    has to be set
+
+    To be used with :meth:`.LegacyContact.send_files` or
+    :meth:`.LegacyParticipant.send_files`
+    """
+
+    path: Optional[Union[Path, str]] = None
+    name: Optional[Union[str]] = None
+    stream: Optional[IO[bytes]] = None
+    data: Optional[bytes] = None
+    content_type: Optional[str] = None
+    legacy_file_id: Optional[Union[str, int]] = None
+    url: Optional[str] = None
+    caption: Optional[str] = None
+    """
+    A caption for this specific image. For a global caption for a list of attachments,
+    use the ``body`` parameter of :meth:`.AttachmentMixin.send_files`
+    """
+
+    def __post_init__(self):
+        if not any(
+            x is not None for x in (self.path, self.stream, self.data, self.url)
+        ):
+            raise TypeError("There is not data in this attachment", self)
+
+
+class MucType(IntEnum):
+    """
+    The type of group, private, public, anonymous or not.
+    """
+
+    GROUP = 0
+    """
+    A private group, members-only and non-anonymous, eg a family group.
+    """
+    CHANNEL = 1
+    """
+    A public group, aka an anonymous channel.
+    """
+    CHANNEL_NON_ANONYMOUS = 2
+    """
+    A public group where participants' legacy IDs are visible to everybody.
+    """
+
+
+PseudoPresenceShow = Union[PresenceShows, Literal[""]]
+
+
+class ResourceDict(TypedDict):
+    show: PseudoPresenceShow
+    status: str
+    priority: int
+
+
+MessageOrPresenceTypeVar = TypeVar(
+    "MessageOrPresenceTypeVar", bound=Union[Message, Presence]
+)
+
+
+class LinkPreview(NamedTuple):
+    about: str
+    title: Optional[str]
+    description: Optional[str]
+    url: Optional[str]
+    image: Optional[str]
+    type: Optional[str]
+    site_name: Optional[str]
+
+
+class Mention(NamedTuple):
+    contact: "LegacyContact"
+    start: int
+    end: int
+
+
+class Hat(NamedTuple):
+    uri: str
+    title: str