Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-04-17 21:46:35 +03:00
Code Issues Packages Projects Releases Wiki Activity

apply isort and black formatters, add format checking to CI

Browse Source
This commit is contained in:
adbenitez
2022-05-29 21:11:49 -04:00
parent 62b50c87d4
commit 16e0f0e986
26 changed files with 899 additions and 575 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
python/examples/echo_and_quit.py
View File

@@ -1,4 +1,3 @@
# content of echo_and_quit.py
from deltachat import account_hookimpl, run_cmdline
@@ -15,7 +14,9 @@ class EchoPlugin:
message.create_chat()
addr = message.get_sender_contact().addr
if message.is_system_message():
message.chat.send_text("echoing system message from {}:\n{}".format(addr, message))
message.chat.send_text(
"echoing system message from {}:\n{}".format(addr, message)
)
else:
text = message.text
message.chat.send_text("echoing from {}:\n{}".format(addr, text))

15
python/examples/group_tracking.py
View File

@@ -1,4 +1,3 @@
# content of group_tracking.py
from deltachat import account_hookimpl, run_cmdline
@@ -33,15 +32,21 @@ class GroupTrackingPlugin:
@account_hookimpl
def ac_member_added(self, chat, contact, actor, message):
print("ac_member_added {} to chat {} from {}".format(
contact.addr, chat.id, actor or message.get_sender_contact().addr))
print(
"ac_member_added {} to chat {} from {}".format(
contact.addr, chat.id, actor or message.get_sender_contact().addr
)
)
for member in chat.get_contacts():
print("chat member: {}".format(member.addr))
@account_hookimpl
def ac_member_removed(self, chat, contact, actor, message):
print("ac_member_removed {} from chat {} by {}".format(
contact.addr, chat.id, actor or message.get_sender_contact().addr))
print(
"ac_member_removed {} from chat {} by {}".format(
contact.addr, chat.id, actor or message.get_sender_contact().addr
)
)
def main(argv=None):

42
python/examples/test_examples.py
View File

@@ -1,20 +1,20 @@
import pytest
import py
import echo_and_quit
import group_tracking
import py
import pytest
from deltachat.events import FFIEventLogger
@pytest.fixture(scope='session')
@pytest.fixture(scope="session")
def datadir():
"""The py.path.local object of the test-data/ directory."""
for path in reversed(py.path.local(__file__).parts()):
datadir = path.join('test-data')
datadir = path.join("test-data")
if datadir.isdir():
return datadir
else:
pytest.skip('test-data directory not found')
pytest.skip("test-data directory not found")
def test_echo_quit_plugin(acfactory, lp):
@@ -22,7 +22,7 @@ def test_echo_quit_plugin(acfactory, lp):
botproc = acfactory.run_bot_process(echo_and_quit)
lp.sec("creating a temp account to contact the bot")
ac1, = acfactory.get_online_accounts(1)
(ac1,) = acfactory.get_online_accounts(1)
lp.sec("sending a message to the bot")
bot_contact = ac1.create_contact(botproc.addr)
@@ -44,9 +44,11 @@ def test_group_tracking_plugin(acfactory, lp):
ac1, ac2 = acfactory.get_online_accounts(2)
botproc.fnmatch_lines("""
botproc.fnmatch_lines(
"""
*ac_configure_completed*
""")
"""
)
ac1.add_account_plugin(FFIEventLogger(ac1))
ac2.add_account_plugin(FFIEventLogger(ac2))
@@ -56,9 +58,11 @@ def test_group_tracking_plugin(acfactory, lp):
ch.add_contact(bot_contact)
ch.send_text("hello")
botproc.fnmatch_lines("""
botproc.fnmatch_lines(
"""
*ac_chat_modified*bot test group*
""")
"""
)
lp.sec("adding third member {}".format(ac2.get_config("addr")))
contact3 = ac1.create_contact(ac2.get_config("addr"))
@@ -68,12 +72,20 @@ def test_group_tracking_plugin(acfactory, lp):
assert "hello" in reply.text
lp.sec("now looking at what the bot received")
botproc.fnmatch_lines("""
botproc.fnmatch_lines(
"""
*ac_member_added {}*from*{}*
""".format(contact3.addr, ac1.get_config("addr")))
""".format(
contact3.addr, ac1.get_config("addr")
)
)
lp.sec("contact successfully added, now removing")
ch.remove_contact(contact3)
botproc.fnmatch_lines("""
botproc.fnmatch_lines(
"""
*ac_member_removed {}*from*{}*
""".format(contact3.addr, ac1.get_config("addr")))
""".format(
contact3.addr, ac1.get_config("addr")
)
)

29
python/src/deltachat/__init__.py
View File

@@ -1,15 +1,15 @@
import sys
from . import capi, const, hookspec # noqa
from .capi import ffi # noqa
from .account import Account, get_core_info # noqa
from .message import Message # noqa
from .contact import Contact # noqa
from .chat import Chat # noqa
from .hookspec import account_hookimpl, global_hookimpl # noqa
from . import events
from pkg_resources import DistributionNotFound, get_distribution
from . import capi, const, events, hookspec # noqa
from .account import Account, get_core_info # noqa
from .capi import ffi # noqa
from .chat import Chat # noqa
from .contact import Contact # noqa
from .hookspec import account_hookimpl, global_hookimpl # noqa
from .message import Message # noqa
from pkg_resources import get_distribution, DistributionNotFound
try:
__version__ = get_distribution(__name__).version
except DistributionNotFound:
@@ -46,12 +46,15 @@ def run_cmdline(argv=None, account_plugins=None):
"""Run a simple default command line app, registering the specified
account plugins."""
import argparse
if argv is None:
argv = sys.argv
parser = argparse.ArgumentParser(prog=argv[0] if argv else None)
parser.add_argument("db", action="store", help="database file")
parser.add_argument("--show-ffi", action="store_true", help="show low level ffi events")
parser.add_argument(
"--show-ffi", action="store_true", help="show low level ffi events"
)
parser.add_argument("--email", action="store", help="email address")
parser.add_argument("--password", action="store", help="password")
@@ -69,9 +72,9 @@ def run_cmdline(argv=None, account_plugins=None):
ac.add_account_plugin(plugin)
if not ac.is_configured():
assert args.email and args.password, (
"you must specify --email and --password once to configure this database/account"
)
assert (
args.email and args.password
), "you must specify --email and --password once to configure this database/account"
ac.set_config("addr", args.email)
ac.set_config("mail_pw", args.password)
ac.set_config("mvbox_move", "0")

93
python/src/deltachat/_build.py
View File

@@ -20,30 +20,35 @@ def local_build_flags(projdir, target):
:param target: The rust build target, `debug` or `release`.
"""
flags = {}
if platform.system() == 'Darwin':
flags['libraries'] = ['resolv', 'dl']
flags['extra_link_args'] = [
'-framework', 'CoreFoundation',
'-framework', 'CoreServices',
'-framework', 'Security',
if platform.system() == "Darwin":
flags["libraries"] = ["resolv", "dl"]
flags["extra_link_args"] = [
"-framework",
"CoreFoundation",
"-framework",
"CoreServices",
"-framework",
"Security",
]
elif platform.system() == 'Linux':
flags['libraries'] = ['rt', 'dl', 'm']
flags['extra_link_args'] = []
elif platform.system() == "Linux":
flags["libraries"] = ["rt", "dl", "m"]
flags["extra_link_args"] = []
else:
raise NotImplementedError("Compilation not supported yet on Windows, can you help?")
raise NotImplementedError(
"Compilation not supported yet on Windows, can you help?"
)
target_dir = os.environ.get("CARGO_TARGET_DIR")
if target_dir is None:
target_dir = os.path.join(projdir, 'target')
flags['extra_objects'] = [os.path.join(target_dir, target, 'libdeltachat.a')]
assert os.path.exists(flags['extra_objects'][0]), flags['extra_objects']
flags['include_dirs'] = [os.path.join(projdir, 'deltachat-ffi')]
target_dir = os.path.join(projdir, "target")
flags["extra_objects"] = [os.path.join(target_dir, target, "libdeltachat.a")]
assert os.path.exists(flags["extra_objects"][0]), flags["extra_objects"]
flags["include_dirs"] = [os.path.join(projdir, "deltachat-ffi")]
return flags
def system_build_flags():
"""Construct build flags for building against an installed libdeltachat."""
return pkgconfig.parse('deltachat')
return pkgconfig.parse("deltachat")
def extract_functions(flags):
@@ -61,11 +66,13 @@ def extract_functions(flags):
src_name = os.path.join(tmpdir, "include.h")
dst_name = os.path.join(tmpdir, "expanded.h")
with open(src_name, "w") as src_fp:
src_fp.write('#include <deltachat.h>')
cc.preprocess(source=src_name,
src_fp.write("#include <deltachat.h>")
cc.preprocess(
source=src_name,
output_file=dst_name,
include_dirs=flags['include_dirs'],
macros=[('PY_CFFI', '1')])
include_dirs=flags["include_dirs"],
macros=[("PY_CFFI", "1")],
)
with open(dst_name, "r") as dst_fp:
return dst_fp.read()
finally:
@@ -87,7 +94,9 @@ def find_header(flags):
obj_name = os.path.join(tmpdir, "where.o")
dst_name = os.path.join(tmpdir, "where")
with open(src_name, "w") as src_fp:
src_fp.write(textwrap.dedent("""
src_fp.write(
textwrap.dedent(
"""
#include <stdio.h>
#include <deltachat.h>
@@ -95,18 +104,22 @@ def find_header(flags):
printf("%s", _dc_header_file_location());
return 0;
}
"""))
"""
)
)
cwd = os.getcwd()
try:
os.chdir(tmpdir)
cc.compile(sources=["where.c"],
include_dirs=flags['include_dirs'],
macros=[("PY_CFFI_INC", "1")])
cc.compile(
sources=["where.c"],
include_dirs=flags["include_dirs"],
macros=[("PY_CFFI_INC", "1")],
)
finally:
os.chdir(cwd)
cc.link_executable(objects=[obj_name],
output_progname="where",
output_dir=tmpdir)
cc.link_executable(
objects=[obj_name], output_progname="where", output_dir=tmpdir
)
return subprocess.check_output(dst_name)
finally:
shutil.rmtree(tmpdir)
@@ -123,7 +136,8 @@ def extract_defines(flags):
cdef() method.
"""
header = find_header(flags)
defines_re = re.compile(r"""
defines_re = re.compile(
r"""
\#define\s+ # The start of a define.
( # Begin capturing group which captures the define name.
(?: # A nested group which is not captured, this allows us
@@ -151,26 +165,28 @@ def extract_defines(flags):
) # Close the capturing group, this contains
# the entire name e.g. DC_MSG_TEXT.
\s+\S+ # Ensure there is whitespace followed by a value.
""", re.VERBOSE)
""",
re.VERBOSE,
)
defines = []
with open(header) as fp:
for line in fp:
match = defines_re.match(line)
if match:
defines.append(match.group(1))
return '\n'.join('#define {} ...'.format(d) for d in defines)
return "\n".join("#define {} ...".format(d) for d in defines)
def ffibuilder():
projdir = os.environ.get('DCC_RS_DEV')
projdir = os.environ.get("DCC_RS_DEV")
if projdir:
target = os.environ.get('DCC_RS_TARGET', 'release')
target = os.environ.get("DCC_RS_TARGET", "release")
flags = local_build_flags(projdir, target)
else:
flags = system_build_flags()
builder = cffi.FFI()
builder.set_source(
'deltachat.capi',
"deltachat.capi",
"""
#include <deltachat.h>
int dc_event_has_string_data(int e)
@@ -180,11 +196,13 @@ def ffibuilder():
""",
**flags,
)
builder.cdef("""
builder.cdef(
"""
typedef int... time_t;
void free(void *ptr);
extern int dc_event_has_string_data(int);
""")
"""
)
function_defs = extract_functions(flags)
defines = extract_defines(flags)
builder.cdef(function_defs)
@@ -192,8 +210,9 @@ def ffibuilder():
return builder
if __name__ == '__main__':
if __name__ == "__main__":
import os.path
pkgdir = os.path.join(os.path.dirname(__file__), '..')
pkgdir = os.path.join(os.path.dirname(__file__), "..")
builder = ffibuilder()
builder.compile(tmpdir=pkgdir, verbose=True)

67
python/src/deltachat/account.py
View File

@@ -1,21 +1,28 @@
""" Account class implementation. """
from __future__ import print_function
import os
from array import array
from contextlib import contextmanager
from email.utils import parseaddr
from threading import Event
import os
from array import array
from . import const
from typing import Any, Dict, Generator, List, Optional, Union
from . import const, hookspec
from .capi import ffi, lib
from .cutil import as_dc_charpointer, from_dc_charpointer, from_optional_dc_charpointer, iter_array, DCLot
from .chat import Chat
from .message import Message
from .contact import Contact
from .tracker import ImexTracker, ConfigureTracker
from . import hookspec
from .cutil import (
DCLot,
as_dc_charpointer,
from_dc_charpointer,
from_optional_dc_charpointer,
iter_array,
)
from .events import EventThread
from typing import Union, Any, Dict, Optional, List, Generator
from .message import Message
from .tracker import ConfigureTracker, ImexTracker
class MissingCredentials(ValueError):
@@ -28,10 +35,14 @@ def get_core_info():
with NamedTemporaryFile() as path:
path.close()
return get_dc_info_as_dict(ffi.gc(
lib.dc_context_new(as_dc_charpointer(""), as_dc_charpointer(path.name), ffi.NULL),
return get_dc_info_as_dict(
ffi.gc(
lib.dc_context_new(
as_dc_charpointer(""), as_dc_charpointer(path.name), ffi.NULL
),
lib.dc_context_unref,
))
)
)
def get_dc_info_as_dict(dc_context):
@@ -50,6 +61,7 @@ class Account(object):
by the underlying deltachat core library. All public Account methods are
meant to be memory-safe and return memory-safe objects.
"""
MissingCredentials = MissingCredentials
def __init__(self, db_path, os_name=None, logging=True) -> None:
@@ -102,8 +114,11 @@ class Account(object):
def _check_config_key(self, name: str) -> None:
if name not in self._configkeys:
raise KeyError("{!r} not a valid config key, existing keys: {!r}".format(
name, self._configkeys))
raise KeyError(
"{!r} not a valid config key, existing keys: {!r}".format(
name, self._configkeys
)
)
def get_info(self) -> Dict[str, str]:
"""return dictionary of built config parameters."""
@@ -175,10 +190,12 @@ class Account(object):
In other words, you don't need this.
"""
res = lib.dc_preconfigure_keypair(self._dc_context,
res = lib.dc_preconfigure_keypair(
self._dc_context,
as_dc_charpointer(addr),
as_dc_charpointer(public),
as_dc_charpointer(secret))
as_dc_charpointer(secret),
)
if res == 0:
raise Exception("Failed to set key")
@@ -224,8 +241,7 @@ class Account(object):
raise ValueError("need to configure first")
def get_latest_backupfile(self, backupdir) -> Optional[str]:
""" return the latest backup file in a given directory.
"""
"""return the latest backup file in a given directory."""
res = lib.dc_imex_has_backup(self._dc_context, as_dc_charpointer(backupdir))
return from_optional_dc_charpointer(res)
@@ -319,8 +335,7 @@ class Account(object):
:returns: list of :class:`deltachat.contact.Contact` objects.
"""
dc_array = ffi.gc(
lib.dc_get_blocked_contacts(self._dc_context),
lib.dc_array_unref
lib.dc_get_blocked_contacts(self._dc_context), lib.dc_array_unref
)
return list(iter_array(dc_array, lambda x: Contact(self, x)))
@@ -345,17 +360,13 @@ class Account(object):
if with_self:
flags |= const.DC_GCL_ADD_SELF
dc_array = ffi.gc(
lib.dc_get_contacts(self._dc_context, flags, query),
lib.dc_array_unref
lib.dc_get_contacts(self._dc_context, flags, query), lib.dc_array_unref
)
return list(iter_array(dc_array, lambda x: Contact(self, x)))
def get_fresh_messages(self) -> Generator[Message, None, None]:
"""yield all fresh messages from all chats."""
dc_array = ffi.gc(
lib.dc_get_fresh_msgs(self._dc_context),
lib.dc_array_unref
)
dc_array = ffi.gc(lib.dc_get_fresh_msgs(self._dc_context), lib.dc_array_unref)
yield from iter_array(dc_array, lambda x: Message.from_db(self, x))
def create_chat(self, obj) -> Chat:
@@ -390,8 +401,7 @@ class Account(object):
:returns: a list of :class:`deltachat.chat.Chat` objects.
"""
dc_chatlist = ffi.gc(
lib.dc_get_chatlist(self._dc_context, 0, ffi.NULL, 0),
lib.dc_chatlist_unref
lib.dc_get_chatlist(self._dc_context, 0, ffi.NULL, 0), lib.dc_chatlist_unref
)
assert dc_chatlist != ffi.NULL
@@ -529,8 +539,7 @@ class Account(object):
def check_qr(self, qr):
"""check qr code and return :class:`ScannedQRCode` instance representing the result"""
res = ffi.gc(
lib.dc_check_qr(self._dc_context, as_dc_charpointer(qr)),
lib.dc_lot_unref
lib.dc_check_qr(self._dc_context, as_dc_charpointer(qr)), lib.dc_lot_unref
)
lot = DCLot(res)
if lot.state() == const.DC_QR_ERROR:

67
python/src/deltachat/chat.py
View File

@@ -1,16 +1,22 @@
""" Chat and Location related API. """
import mimetypes
import calendar
import json
from datetime import datetime, timezone
import mimetypes
import os
from .cutil import as_dc_charpointer, from_dc_charpointer, from_optional_dc_charpointer, iter_array
from .capi import lib, ffi
from . import const
from .message import Message
from datetime import datetime, timezone
from typing import Optional
from . import const
from .capi import ffi, lib
from .cutil import (
as_dc_charpointer,
from_dc_charpointer,
from_optional_dc_charpointer,
iter_array,
)
from .message import Message
class Chat(object):
"""Chat object which manages members and through which you can send and retrieve messages.
@@ -20,13 +26,16 @@ class Chat(object):
def __init__(self, account, id) -> None:
from .account import Account
assert isinstance(account, Account), repr(account)
self.account = account
self.id = id
def __eq__(self, other) -> bool:
return self.id == getattr(other, "id", None) and \
self.account._dc_context == other.account._dc_context
return (
self.id == getattr(other, "id", None)
and self.account._dc_context == other.account._dc_context
)
def __ne__(self, other) -> bool:
return not (self == other)
@@ -37,8 +46,7 @@ class Chat(object):
@property
def _dc_chat(self):
return ffi.gc(
lib.dc_get_chat(self.account._dc_context, self.id),
lib.dc_chat_unref
lib.dc_get_chat(self.account._dc_context, self.id), lib.dc_chat_unref
)
def delete(self) -> None:
@@ -132,7 +140,9 @@ class Chat(object):
mute_duration = -1
else:
mute_duration = duration
ret = lib.dc_set_chat_mute_duration(self.account._dc_context, self.id, mute_duration)
ret = lib.dc_set_chat_mute_duration(
self.account._dc_context, self.id, mute_duration
)
if not bool(ret):
raise ValueError("Call to dc_set_chat_mute_duration failed")
@@ -167,7 +177,9 @@ class Chat(object):
:returns: True on success, False otherwise
"""
return bool(lib.dc_set_chat_ephemeral_timer(self.account._dc_context, self.id, timer))
return bool(
lib.dc_set_chat_ephemeral_timer(self.account._dc_context, self.id, timer)
)
def get_type(self) -> int:
"""(deprecated) return type of this chat.
@@ -343,7 +355,7 @@ class Chat(object):
"""
dc_array = ffi.gc(
lib.dc_get_chat_msgs(self.account._dc_context, self.id, 0, 0),
lib.dc_array_unref
lib.dc_array_unref,
)
return list(iter_array(dc_array, lambda x: Message.from_db(self.account, x)))
@@ -390,7 +402,9 @@ class Chat(object):
:returns: None
"""
contact = self.account.get_contact(obj)
ret = lib.dc_remove_contact_from_chat(self.account._dc_context, self.id, contact.id)
ret = lib.dc_remove_contact_from_chat(
self.account._dc_context, self.id, contact.id
)
if ret != 1:
raise ValueError("could not remove contact {!r} from chat".format(contact))
@@ -399,19 +413,18 @@ class Chat(object):
:returns: list of :class:`deltachat.contact.Contact` objects for this chat
"""
from .contact import Contact
dc_array = ffi.gc(
lib.dc_get_chat_contacts(self.account._dc_context, self.id),
lib.dc_array_unref
)
return list(iter_array(
dc_array, lambda id: Contact(self.account, id))
lib.dc_array_unref,
)
return list(iter_array(dc_array, lambda id: Contact(self.account, id)))
def num_contacts(self):
"""return number of contacts in this chat."""
dc_array = ffi.gc(
lib.dc_get_chat_contacts(self.account._dc_context, self.id),
lib.dc_array_unref
lib.dc_array_unref,
)
return lib.dc_array_get_cnt(dc_array)
@@ -476,7 +489,10 @@ class Chat(object):
"""return True if this chat is archived.
:returns: True if archived.
"""
return lib.dc_chat_get_visibility(self._dc_chat) == const.DC_CHAT_VISIBILITY_ARCHIVED
return (
lib.dc_chat_get_visibility(self._dc_chat)
== const.DC_CHAT_VISIBILITY_ARCHIVED
)
def enable_sending_locations(self, seconds):
"""enable sending locations for this chat.
@@ -507,17 +523,20 @@ class Chat(object):
else:
contact_id = contact.id
dc_array = lib.dc_get_locations(self.account._dc_context, self.id, contact_id, time_from, time_to)
dc_array = lib.dc_get_locations(
self.account._dc_context, self.id, contact_id, time_from, time_to
)
return [
Location(
latitude=lib.dc_array_get_latitude(dc_array, i),
longitude=lib.dc_array_get_longitude(dc_array, i),
accuracy=lib.dc_array_get_accuracy(dc_array, i),
timestamp=datetime.fromtimestamp(
lib.dc_array_get_timestamp(dc_array, i),
timezone.utc
lib.dc_array_get_timestamp(dc_array, i), timezone.utc
),
marker=from_optional_dc_charpointer(
lib.dc_array_get_marker(dc_array, i)
),
marker=from_optional_dc_charpointer(lib.dc_array_get_marker(dc_array, i)),
)
for i in range(lib.dc_array_get_cnt(dc_array))
]

14
python/src/deltachat/contact.py
View File

@@ -14,26 +14,32 @@ class Contact(object):
You obtain instances of it through :class:`deltachat.account.Account`.
"""
def __init__(self, account, id):
from .account import Account
assert isinstance(account, Account), repr(account)
self.account = account
self.id = id
def __eq__(self, other):
return self.account._dc_context == other.account._dc_context and self.id == other.id
return (
self.account._dc_context == other.account._dc_context
and self.id == other.id
)
def __ne__(self, other):
return not (self == other)
def __repr__(self):
return "<Contact id={} addr={} dc_context={}>".format(self.id, self.addr, self.account._dc_context)
return "<Contact id={} addr={} dc_context={}>".format(
self.id, self.addr, self.account._dc_context
)
@property
def _dc_contact(self):
return ffi.gc(
lib.dc_get_contact(self.account._dc_context, self.id),
lib.dc_contact_unref
lib.dc_get_contact(self.account._dc_context, self.id), lib.dc_contact_unref
)
@props.with_doc

8
python/src/deltachat/cutil.py
View File

@@ -1,9 +1,9 @@
from .capi import lib
from .capi import ffi
from datetime import datetime, timezone
from typing import Optional, TypeVar, Generator, Callable
from typing import Callable, Generator, Optional, TypeVar
T = TypeVar('T')
from .capi import ffi, lib
T = TypeVar("T")
def as_dc_charpointer(obj):

59
python/src/deltachat/direct_imap.py
View File

@@ -3,18 +3,27 @@ Internal Python-level IMAP handling used by the testplugin
and for cleaning up inbox/mvbox for each test function run.
"""
import io
import ssl
import pathlib
from contextlib import contextmanager
from imap_tools import MailBox, MailBoxTls, errors, AND, Header, MailMessageFlags, MailMessage
import imaplib
from deltachat import const, Account
import io
import pathlib
import ssl
from contextlib import contextmanager
from typing import List
from imap_tools import (
AND,
Header,
MailBox,
MailBoxTls,
MailMessage,
MailMessageFlags,
errors,
)
FLAGS = b'FLAGS'
FETCH = b'FETCH'
from deltachat import Account, const
FLAGS = b"FLAGS"
FETCH = b"FETCH"
ALL = "1:*"
@@ -88,7 +97,7 @@ class DirectImap:
to make sure the messages are really gone and not
just flagged as deleted.
"""
self.conn.client.uid('STORE', uid_list, '+FLAGS', r'(\Deleted)')
self.conn.client.uid("STORE", uid_list, "+FLAGS", r"(\Deleted)")
if expunge:
self.conn.expunge()
@@ -141,7 +150,13 @@ class DirectImap:
fn = path.joinpath(str(msg.uid))
fn.write_bytes(body)
log("Message", msg.uid, fn)
log("Message", msg.uid, msg.flags, "Message-Id:", msg.obj.get("Message-Id"))
log(
"Message",
msg.uid,
msg.flags,
"Message-Id:",
msg.obj.get("Message-Id"),
)
if empty_folders:
log("--------- EMPTY FOLDERS:", empty_folders)
@@ -163,13 +178,20 @@ class DirectImap:
"""
if msg.startswith("\n"):
msg = msg[1:]
msg = '\n'.join([s.lstrip() for s in msg.splitlines()])
self.conn.append(bytes(msg, encoding='ascii'), folder)
msg = "\n".join([s.lstrip() for s in msg.splitlines()])
self.conn.append(bytes(msg, encoding="ascii"), folder)
def get_uid_by_message_id(self, message_id) -> str:
msgs = [msg.uid for msg in self.conn.fetch(AND(header=Header('MESSAGE-ID', message_id)))]
msgs = [
msg.uid
for msg in self.conn.fetch(AND(header=Header("MESSAGE-ID", message_id)))
]
if len(msgs) == 0:
raise Exception("Did not find message " + message_id + ", maybe you forgot to select the correct folder?")
raise Exception(
"Did not find message "
+ message_id
+ ", maybe you forgot to select the correct folder?"
)
return msgs[0]
@@ -192,18 +214,17 @@ class IdleManager:
def wait_for_new_message(self, timeout=None) -> bytes:
while 1:
for item in self.check(timeout=timeout):
if b'EXISTS' in item or b'RECENT' in item:
if b"EXISTS" in item or b"RECENT" in item:
return item
def wait_for_seen(self, timeout=None) -> int:
""" Return first message with SEEN flag from a running idle-stream.
"""
"""Return first message with SEEN flag from a running idle-stream."""
while 1:
for item in self.check(timeout=timeout):
if FETCH in item:
self.log(str(item))
if FLAGS in item and rb'\Seen' in item:
return int(item.split(b' ')[1])
if FLAGS in item and rb"\Seen" in item:
return int(item.split(b" ")[1])
def done(self):
"""send idle-done to server if we are currently in idle mode."""

52
python/src/deltachat/events.py
View File

@@ -1,18 +1,19 @@
import threading
import sys
import traceback
import time
import io
import re
import os
from queue import Queue, Empty
import re
import sys
import threading
import time
import traceback
from contextlib import contextmanager
from queue import Empty, Queue
import deltachat
from .hookspec import account_hookimpl
from contextlib import contextmanager
from .capi import ffi, lib
from .message import map_system_message
from .cutil import from_optional_dc_charpointer
from .hookspec import account_hookimpl
from .message import map_system_message
class FFIEvent:
@@ -29,6 +30,7 @@ class FFIEventLogger:
"""If you register an instance of this logger with an Account
you'll get all ffi-events printed.
"""
# to prevent garbled logging
_loglock = threading.RLock()
@@ -56,9 +58,9 @@ class FFIEventLogger:
s = "{:2.2f} [{}] {}".format(elapsed, locname, message)
if os.name == "posix":
WARN = '\033[93m'
ERROR = '\033[91m'
ENDC = '\033[0m'
WARN = "\033[93m"
ERROR = "\033[91m"
ENDC = "\033[0m"
if message.startswith("DC_EVENT_WARNING"):
s = WARN + s + ENDC
if message.startswith("DC_EVENT_ERROR"):
@@ -133,7 +135,12 @@ class FFIEventTracker:
if current == expected_next:
return
elif current != previous:
raise Exception("Expected connectivity " + str(expected_next) + " but got " + str(current))
raise Exception(
"Expected connectivity "
+ str(expected_next)
+ " but got "
+ str(current)
)
self.get_matching("DC_EVENT_CONNECTIVITY_CHANGED")
@@ -195,6 +202,7 @@ class EventThread(threading.Thread):
With each Account init this callback thread is started.
"""
def __init__(self, account) -> None:
self.account = account
super(EventThread, self).__init__(name="events")
@@ -244,8 +252,12 @@ class EventThread(threading.Thread):
lib.dc_event_unref(event)
ffi_event = FFIEvent(name=evt_name, data1=data1, data2=data2)
with self.swallow_and_log_exception("ac_process_ffi_event {}".format(ffi_event)):
self.account._pm.hook.ac_process_ffi_event(account=self, ffi_event=ffi_event)
with self.swallow_and_log_exception(
"ac_process_ffi_event {}".format(ffi_event)
):
self.account._pm.hook.ac_process_ffi_event(
account=self, ffi_event=ffi_event
)
for name, kwargs in self._map_ffi_event(ffi_event):
hook = getattr(self.account._pm.hook, name)
info = "call {} kwargs={} failed".format(name, kwargs)
@@ -259,8 +271,9 @@ class EventThread(threading.Thread):
except Exception as ex:
logfile = io.StringIO()
traceback.print_exception(*sys.exc_info(), file=logfile)
self.account.log("{}\nException {}\nTraceback:\n{}"
.format(info, ex, logfile.getvalue()))
self.account.log(
"{}\nException {}\nTraceback:\n{}".format(info, ex, logfile.getvalue())
)
def _map_ffi_event(self, ffi_event: FFIEvent):
name = ffi_event.name
@@ -282,7 +295,10 @@ class EventThread(threading.Thread):
yield res
yield "ac_outgoing_message", dict(message=msg)
elif msg.is_in_fresh():
yield map_system_message(msg) or ("ac_incoming_message", dict(message=msg))
yield map_system_message(msg) or (
"ac_incoming_message",
dict(message=msg),
)
elif name == "DC_EVENT_MSG_DELIVERED":
msg = account.get_message_by_id(ffi_event.data2)
yield "ac_message_delivered", dict(message=msg)

3
python/src/deltachat/hookspec.py
View File

@@ -2,7 +2,6 @@
import pluggy
account_spec_name = "deltachat-account"
account_hookspec = pluggy.HookspecMarker(account_spec_name)
account_hookimpl = pluggy.HookimplMarker(account_spec_name)
@@ -19,6 +18,7 @@ class PerAccount:
Hooks are generally not allowed to block/last long as this
blocks overall event processing on the python side.
"""
@classmethod
def _make_plugin_manager(cls):
pm = pluggy.PluginManager(account_spec_name)
@@ -89,6 +89,7 @@ class Global:
plugin manager instance.
"""
_plugin_manager = None
@classmethod

108
python/src/deltachat/message.py
View File

@@ -2,13 +2,13 @@
import os
import re
from . import props
from .cutil import from_dc_charpointer, from_optional_dc_charpointer, as_dc_charpointer
from .capi import lib, ffi
from . import const
from datetime import datetime, timezone
from typing import Optional
from . import const, props
from .capi import ffi, lib
from .cutil import as_dc_charpointer, from_dc_charpointer, from_optional_dc_charpointer
class Message(object):
"""Message object.
@@ -16,6 +16,7 @@ class Message(object):
You obtain instances of it through :class:`deltachat.account.Account` or
:class:`deltachat.chat.Chat`.
"""
def __init__(self, account, dc_msg):
self.account = account
assert isinstance(self.account._dc_context, ffi.CData)
@@ -32,16 +33,22 @@ class Message(object):
c = self.get_sender_contact()
typ = "outgoing" if self.is_outgoing() else "incoming"
return "<Message {} sys={} {} id={} sender={}/{} chat={}/{}>".format(
typ, self.is_system_message(), repr(self.text[:10]),
self.id, c.id, c.addr, self.chat.id, self.chat.get_name())
typ,
self.is_system_message(),
repr(self.text[:10]),
self.id,
c.id,
c.addr,
self.chat.id,
self.chat.get_name(),
)
@classmethod
def from_db(cls, account, id):
assert id > 0
return cls(account, ffi.gc(
lib.dc_get_msg(account._dc_context, id),
lib.dc_msg_unref
))
return cls(
account, ffi.gc(lib.dc_get_msg(account._dc_context, id), lib.dc_msg_unref)
)
@classmethod
def new_empty(cls, account, view_type):
@@ -54,10 +61,12 @@ class Message(object):
view_type_code = view_type
else:
view_type_code = get_viewtype_code_from_name(view_type)
return Message(account, ffi.gc(
lib.dc_msg_new(account._dc_context, view_type_code),
lib.dc_msg_unref
))
return Message(
account,
ffi.gc(
lib.dc_msg_new(account._dc_context, view_type_code), lib.dc_msg_unref
),
)
def create_chat(self):
"""create or get an existing chat (group) object for this message.
@@ -87,8 +96,12 @@ class Message(object):
@props.with_doc
def html(self) -> str:
"""html text of this messages (might be empty if not an html message)."""
return from_optional_dc_charpointer(
lib.dc_get_msg_html(self.account._dc_context, self.id)) or ""
return (
from_optional_dc_charpointer(
lib.dc_get_msg_html(self.account._dc_context, self.id)
)
or ""
)
def has_html(self):
"""return True if this message has an html part, False otherwise."""
@@ -153,14 +166,14 @@ class Message(object):
The text is multiline and may contain eg. the raw text of the message.
"""
return from_dc_charpointer(lib.dc_get_msg_info(self.account._dc_context, self.id))
return from_dc_charpointer(
lib.dc_get_msg_info(self.account._dc_context, self.id)
)
def continue_key_transfer(self, setup_code):
"""extract key and use it as primary key for this account."""
res = lib.dc_continue_key_transfer(
self.account._dc_context,
self.id,
as_dc_charpointer(setup_code)
self.account._dc_context, self.id, as_dc_charpointer(setup_code)
)
if res == 0:
raise ValueError("could not decrypt")
@@ -238,6 +251,7 @@ class Message(object):
:returns: email-mime message object (with headers only, no body).
"""
import email.parser
mime_headers = lib.dc_get_mime_headers(self.account._dc_context, self.id)
if mime_headers:
s = ffi.string(ffi.gc(mime_headers, lib.dc_str_unref))
@@ -257,6 +271,7 @@ class Message(object):
:returns: :class:`deltachat.chat.Chat` object
"""
from .chat import Chat
chat_id = lib.dc_msg_get_chat_id(self._dc_msg)
return Chat(self.account, chat_id)
@@ -267,12 +282,12 @@ class Message(object):
Usually used to impersonate someone else.
"""
return from_optional_dc_charpointer(
lib.dc_msg_get_override_sender_name(self._dc_msg))
lib.dc_msg_get_override_sender_name(self._dc_msg)
)
def set_override_sender_name(self, name):
"""set different sender name for a message."""
lib.dc_msg_set_override_sender_name(
self._dc_msg, as_dc_charpointer(name))
lib.dc_msg_set_override_sender_name(self._dc_msg, as_dc_charpointer(name))
def get_sender_chat(self):
"""return the 1:1 chat with the sender of this message.
@@ -287,6 +302,7 @@ class Message(object):
:returns: :class:`deltachat.chat.Contact` instance
"""
from .contact import Contact
contact_id = lib.dc_msg_get_from_id(self._dc_msg)
return Contact(self.account, contact_id)
@@ -300,8 +316,7 @@ class Message(object):
else:
# load message from db to get a fresh/current state
dc_msg = ffi.gc(
lib.dc_get_msg(self.account._dc_context, self.id),
lib.dc_msg_unref
lib.dc_get_msg(self.account._dc_context, self.id), lib.dc_msg_unref
)
return lib.dc_msg_get_state(dc_msg)
@@ -332,23 +347,23 @@ class Message(object):
def is_outgoing(self):
"""Return True if Message is outgoing."""
return self._msgstate in (
const.DC_STATE_OUT_PREPARING, const.DC_STATE_OUT_PENDING,
const.DC_STATE_OUT_FAILED, const.DC_STATE_OUT_MDN_RCVD,
const.DC_STATE_OUT_DELIVERED)
const.DC_STATE_OUT_PREPARING,
const.DC_STATE_OUT_PENDING,
const.DC_STATE_OUT_FAILED,
const.DC_STATE_OUT_MDN_RCVD,
const.DC_STATE_OUT_DELIVERED,
)
def is_out_preparing(self):
"""Return True if Message is outgoing, but its file is being prepared.
"""
"""Return True if Message is outgoing, but its file is being prepared."""
return self._msgstate == const.DC_STATE_OUT_PREPARING
def is_out_pending(self):
"""Return True if Message is outgoing, but is pending (no single checkmark).
"""
"""Return True if Message is outgoing, but is pending (no single checkmark)."""
return self._msgstate == const.DC_STATE_OUT_PENDING
def is_out_failed(self):
"""Return True if Message is unrecoverably failed.
"""
"""Return True if Message is unrecoverably failed."""
return self._msgstate == const.DC_STATE_OUT_FAILED
def is_out_delivered(self):
@@ -410,13 +425,13 @@ class Message(object):
# some code for handling DC_MSG_* view types
_view_type_mapping = {
'text': const.DC_MSG_TEXT,
'image': const.DC_MSG_IMAGE,
'gif': const.DC_MSG_GIF,
'audio': const.DC_MSG_AUDIO,
'video': const.DC_MSG_VIDEO,
'file': const.DC_MSG_FILE,
'sticker': const.DC_MSG_STICKER,
"text": const.DC_MSG_TEXT,
"image": const.DC_MSG_IMAGE,
"gif": const.DC_MSG_GIF,
"audio": const.DC_MSG_AUDIO,
"video": const.DC_MSG_VIDEO,
"file": const.DC_MSG_FILE,
"sticker": const.DC_MSG_STICKER,
}
@@ -424,14 +439,17 @@ def get_viewtype_code_from_name(view_type_name):
code = _view_type_mapping.get(view_type_name)
if code is not None:
return code
raise ValueError("message typecode not found for {!r}, "
"available {!r}".format(view_type_name, list(_view_type_mapping.keys())))
raise ValueError(
"message typecode not found for {!r}, "
"available {!r}".format(view_type_name, list(_view_type_mapping.keys()))
)
#
# some helper code for turning system messages into hook events
#
def map_system_message(msg):
if msg.is_system_message():
res = parse_system_add_remove(msg.text)
@@ -448,7 +466,7 @@ def map_system_message(msg):
def extract_addr(text):
m = re.match(r'.*\((.+@.+)\)', text)
m = re.match(r".*\((.+@.+)\)", text)
if m:
text = m.group(1)
text = text.rstrip(".")
@@ -467,7 +485,7 @@ def parse_system_add_remove(text):
# Group left by some one (tmp1@x.org).
# Group left by tmp1@x.org.
text = text.lower()
m = re.match(r'member (.+) (removed|added) by (.+)', text)
m = re.match(r"member (.+) (removed|added) by (.+)", text)
if m:
affected, action, actor = m.groups()
return action, extract_addr(affected), extract_addr(actor)

1
python/src/deltachat/props.py
View File

@@ -9,6 +9,7 @@ def with_doc(f):
# https://github.com/devpi/devpi/blob/master/common/devpi_common/types.py
def cached(f):
"""returns a cached property that is calculated by function f"""
def get(self):
try:
return self._property_cache[f]

10
python/src/deltachat/provider.py
View File

@@ -16,7 +16,9 @@ class Provider(object):
def __init__(self, account, addr) -> None:
provider = ffi.gc(
lib.dc_provider_new_from_email(account._dc_context, as_dc_charpointer(addr)),
lib.dc_provider_new_from_email(
account._dc_context, as_dc_charpointer(addr)
),
lib.dc_provider_unref,
)
if provider == ffi.NULL:
@@ -26,14 +28,14 @@ class Provider(object):
@property
def overview_page(self) -> str:
"""URL to the overview page of the provider on providers.delta.chat."""
return from_dc_charpointer(
lib.dc_provider_get_overview_page(self._provider))
return from_dc_charpointer(lib.dc_provider_get_overview_page(self._provider))
@property
def get_before_login_hints(self) -> str:
"""Should be shown to the user on login."""
return from_dc_charpointer(
lib.dc_provider_get_before_login_hint(self._provider))
lib.dc_provider_get_before_login_hint(self._provider)
)
@property
def status(self) -> int:

149
python/src/deltachat/testplugin.py
View File

@@ -1,56 +1,63 @@
from __future__ import print_function
import os
import sys
import io
import subprocess
import queue
import threading
import fnmatch
import io
import os
import pathlib
import queue
import subprocess
import sys
import threading
import time
import weakref
from queue import Queue
from typing import List, Callable
from typing import Callable, List
import pytest
import requests
import pathlib
from . import Account, const, account_hookimpl, get_core_info
from .events import FFIEventLogger, FFIEventTracker
from _pytest._code import Source
import deltachat
from . import Account, account_hookimpl, const, get_core_info
from .events import FFIEventLogger, FFIEventTracker
def pytest_addoption(parser):
group = parser.getgroup("deltachat testplugin options")
group.addoption(
"--liveconfig", action="store", default=None,
"--liveconfig",
action="store",
default=None,
help="a file with >=2 lines where each line "
"contains NAME=VALUE config settings for one account"
"contains NAME=VALUE config settings for one account",
)
group.addoption(
"--ignored", action="store_true",
"--ignored",
action="store_true",
help="Also run tests marked with the ignored marker",
)
group.addoption(
"--strict-tls", action="store_true",
"--strict-tls",
action="store_true",
help="Never accept invalid TLS certificates for test accounts",
)
group.addoption(
"--extra-info", action="store_true",
help="show more info on failures (imap server state, config)"
"--extra-info",
action="store_true",
help="show more info on failures (imap server state, config)",
)
group.addoption(
"--debug-setup", action="store_true",
help="show events during configure and start io phases of online accounts"
"--debug-setup",
action="store_true",
help="show events during configure and start io phases of online accounts",
)
def pytest_configure(config):
cfg = config.getoption('--liveconfig')
cfg = config.getoption("--liveconfig")
if not cfg:
cfg = os.getenv('DCC_NEW_TMP_EMAIL')
cfg = os.getenv("DCC_NEW_TMP_EMAIL")
if cfg:
config.option.liveconfig = cfg
@@ -113,19 +120,21 @@ def pytest_configure(config):
def pytest_report_header(config, startdir):
info = get_core_info()
summary = ['Deltachat core={} sqlite={} journal_mode={}'.format(
info['deltachat_core_version'],
info['sqlite_version'],
info['journal_mode'],
)]
summary = [
"Deltachat core={} sqlite={} journal_mode={}".format(
info["deltachat_core_version"],
info["sqlite_version"],
info["journal_mode"],
)
]
cfg = config.option.liveconfig
if cfg:
if "?" in cfg:
url, token = cfg.split("?", 1)
summary.append('Liveconfig provider: {}?<token ommitted>'.format(url))
summary.append("Liveconfig provider: {}?<token ommitted>".format(url))
else:
summary.append('Liveconfig file: {}'.format(cfg))
summary.append("Liveconfig file: {}".format(cfg))
return summary
@@ -135,8 +144,8 @@ def testprocess(request):
class TestProcess:
""" A pytest session-scoped instance to help with managing "live" account configurations.
"""
"""A pytest session-scoped instance to help with managing "live" account configurations."""
def __init__(self, pytestconfig):
self.pytestconfig = pytestconfig
self._addr2files = {}
@@ -150,11 +159,13 @@ class TestProcess:
"""
liveconfig_opt = self.pytestconfig.getoption("--liveconfig")
if not liveconfig_opt:
pytest.skip("specify DCC_NEW_TMP_EMAIL or --liveconfig to provide live accounts")
pytest.skip(
"specify DCC_NEW_TMP_EMAIL or --liveconfig to provide live accounts"
)
if not liveconfig_opt.startswith("http"):
for line in open(liveconfig_opt):
if line.strip() and not line.strip().startswith('#'):
if line.strip() and not line.strip().startswith("#"):
d = {}
for part in line.split():
name, value = part.split("=")
@@ -170,14 +181,21 @@ class TestProcess:
except IndexError:
res = requests.post(liveconfig_opt)
if res.status_code != 200:
pytest.fail("newtmpuser count={} code={}: '{}'".format(
index, res.status_code, res.text))
pytest.fail(
"newtmpuser count={} code={}: '{}'".format(
index, res.status_code, res.text
)
)
d = res.json()
config = dict(addr=d["email"], mail_pw=d["password"])
print("newtmpuser {}: addr={}".format(index, config["addr"]))
self._configlist.append(config)
yield config
pytest.fail("more than {} live accounts requested.".format(MAX_LIVE_CREATED_ACCOUNTS))
pytest.fail(
"more than {} live accounts requested.".format(
MAX_LIVE_CREATED_ACCOUNTS
)
)
def cache_maybe_retrieve_configured_db_files(self, cache_addr, db_target_path):
db_target_path = pathlib.Path(db_target_path)
@@ -230,10 +248,15 @@ def data(request):
# because we are run from a dev-setup with pytest direct,
# through tox, and then maybe also from deltachat-binding
# users like "deltabot".
self.paths = [os.path.normpath(x) for x in [
self.paths = [
os.path.normpath(x)
for x in [
os.path.join(os.path.dirname(request.fspath.strpath), "data"),
os.path.join(os.path.dirname(__file__), "..", "..", "..", "test-data")
]]
os.path.join(
os.path.dirname(__file__), "..", "..", "..", "test-data"
),
]
]
def get_path(self, bn):
"""return path of file or None if it doesn't exist."""
@@ -257,6 +280,7 @@ class ACSetup:
and io & imap initialization phases. From tests, use the higher level
public ACFactory methods instead of its private helper class.
"""
CONFIGURING = "CONFIGURING"
CONFIGURED = "CONFIGURED"
IDLEREADY = "IDLEREADY"
@@ -275,10 +299,13 @@ class ACSetup:
"""add an already configured account."""
assert account.is_configured()
self._account2state[account] = self.CONFIGURED
self.log("added already configured account", account, account.get_config("addr"))
self.log(
"added already configured account", account, account.get_config("addr")
)
def start_configure(self, account, reconfigure=False):
"""add an account and start its configure process."""
class PendingTracker:
@account_hookimpl
def ac_configure_completed(this, success):
@@ -375,8 +402,7 @@ class ACFactory:
self._finalizers = []
self._accounts = []
self._acsetup = ACSetup(testprocess, self.init_time)
self._preconfigured_keys = ["alice", "bob", "charlie",
"dom", "elena", "fiona"]
self._preconfigured_keys = ["alice", "bob", "charlie", "dom", "elena", "fiona"]
self.set_logging_default(False)
request.addfinalizer(self.finalize)
@@ -426,7 +452,9 @@ class ACFactory:
# we need to use fixed database basename for maybe_cache_* functions to work
path = self.tmpdir.mkdir(logid).join("dc.db")
if try_cache_addr:
self.testprocess.cache_maybe_retrieve_configured_db_files(try_cache_addr, path)
self.testprocess.cache_maybe_retrieve_configured_db_files(
try_cache_addr, path
)
ac = Account(path.strpath, logging=self._logging)
ac._logid = logid # later instantiated FFIEventLogger needs this
ac._evtracker = ac.add_account_plugin(FFIEventTracker(ac))
@@ -448,8 +476,12 @@ class ACFactory:
except IndexError:
pass
else:
fname_pub = self.data.read_path("key/{name}-public.asc".format(name=keyname))
fname_sec = self.data.read_path("key/{name}-secret.asc".format(name=keyname))
fname_pub = self.data.read_path(
"key/{name}-public.asc".format(name=keyname)
)
fname_sec = self.data.read_path(
"key/{name}-secret.asc".format(name=keyname)
)
if fname_pub and fname_sec:
account._preconfigure_keypair(addr, fname_pub, fname_sec)
return True
@@ -461,11 +493,16 @@ class ACFactory:
ac = self.get_unconfigured_account()
acname = ac._logid
addr = "{}@offline.org".format(acname)
ac.update_config(dict(
addr=addr, displayname=acname, mail_pw="123",
configured_addr=addr, configured_mail_pw="123",
ac.update_config(
dict(
addr=addr,
displayname=acname,
mail_pw="123",
configured_addr=addr,
configured_mail_pw="123",
configured="1",
))
)
)
self._preconfigure_key(ac, addr)
self._acsetup.init_logging(ac)
return ac
@@ -531,8 +568,10 @@ class ACFactory:
sys.executable,
"-u",
fn,
"--email", bot_cfg["addr"],
"--password", bot_cfg["mail_pw"],
"--email",
bot_cfg["addr"],
"--password",
bot_cfg["mail_pw"],
bot_ac.db_path,
]
if ffi:
@@ -545,7 +584,7 @@ class ACFactory:
stderr=subprocess.STDOUT, # combine stdout/stderr in one stream
bufsize=0, # line buffering
close_fds=True, # close all FDs other than 0/1/2
universal_newlines=True # give back text
universal_newlines=True, # give back text
)
bot = BotProcess(popen, addr=bot_cfg["addr"])
self._finalizers.append(bot.kill)
@@ -599,7 +638,9 @@ class BotProcess:
# we read stdout as quickly as we can in a thread and make
# the (unicode) lines available for readers through a queue.
self.stdout_queue = queue.Queue()
self.stdout_thread = t = threading.Thread(target=self._run_stdout_thread, name="bot-stdout-thread")
self.stdout_thread = t = threading.Thread(
target=self._run_stdout_thread, name="bot-stdout-thread"
)
t.daemon = True
t.start()
@@ -622,7 +663,9 @@ class BotProcess:
self.popen.wait(timeout=timeout)
def fnmatch_lines(self, pattern_lines):
patterns = [x.strip() for x in Source(pattern_lines.rstrip()).lines if x.strip()]
patterns = [
x.strip() for x in Source(pattern_lines.rstrip()).lines if x.strip()
]
for next_pattern in patterns:
print("+++FNMATCH:", next_pattern)
ignored = []

14
python/src/deltachat/tracker.py
View File

@@ -1,8 +1,7 @@
from queue import Queue
from threading import Event
from .hookspec import account_hookimpl, Global
from .hookspec import Global, account_hookimpl
class ImexFailed(RuntimeError):
@@ -20,12 +19,17 @@ class ImexTracker:
elif ffi_event.name == "DC_EVENT_IMEX_FILE_WRITTEN":
self._imex_events.put(ffi_event.data2)
def wait_progress(self, target_progress, progress_upper_limit=1000, progress_timeout=60):
def wait_progress(
self, target_progress, progress_upper_limit=1000, progress_timeout=60
):
while True:
ev = self._imex_events.get(timeout=progress_timeout)
if isinstance(ev, int) and ev >= target_progress:
assert ev <= progress_upper_limit, \
str(ev) + " exceeded upper progress limit " + str(progress_upper_limit)
assert ev <= progress_upper_limit, (
str(ev)
+ " exceeded upper progress limit "
+ str(progress_upper_limit)
)
return ev
if ev == 0:
return None

14
python/tests/auditwheels.py
View File

@@ -1,10 +1,8 @@
import os
import platform
import subprocess
import sys
if __name__ == "__main__":
assert len(sys.argv) == 2
workspacedir = sys.argv[1]
@@ -13,5 +11,13 @@ if __name__ == "__main__":
if relpath.startswith("deltachat"):
p = os.path.join(workspacedir, relpath)
subprocess.check_call(
["auditwheel", "repair", p, "-w", workspacedir,
"--plat", "manylinux2014_" + arch])
[
"auditwheel",
"repair",
p,
"-w",
workspacedir,
"--plat",
"manylinux2014_" + arch,
]
)

10
python/tests/package_wheels.py
View File

@@ -1,8 +1,6 @@
import os
import sys
import subprocess
import sys
if __name__ == "__main__":
assert len(sys.argv) == 2
@@ -10,6 +8,10 @@ if __name__ == "__main__":
# pip wheel will build in an isolated tmp dir that does not have git
# history so setuptools_scm can not automatically determine a
# version there. So pass in the version through an env var.
version = subprocess.check_output(["python", "setup.py", "--version"]).strip().split(b"\n")[-1]
version = (
subprocess.check_output(["python", "setup.py", "--version"])
.strip()
.split(b"\n")[-1]
)
os.environ["SETUPTOOLS_SCM_PRETEND_VERSION"] = version.decode("ascii")
subprocess.check_call(("pip wheel . -w %s" % wheelhousedir).split())

32
python/tests/stress_test_db.py
View File

@@ -1,9 +1,9 @@
import time
import threading
import pytest
import os
from queue import Queue, Empty
import threading
import time
from queue import Empty, Queue
import pytest
import deltachat
@@ -41,7 +41,9 @@ def test_db_busy_error(acfactory, tmpdir):
# each replier receives all events and sends report events to receive_queue
repliers = []
for acc in accounts:
replier = AutoReplier(acc, log=log, num_send=500, num_bigfiles=5, report_func=report_func)
replier = AutoReplier(
acc, log=log, num_send=500, num_bigfiles=5, report_func=report_func
)
acc.add_account_plugin(replier)
repliers.append(replier)
@@ -63,9 +65,11 @@ def test_db_busy_error(acfactory, tmpdir):
elif report_type == ReportType.message_echo:
continue
else:
raise ValueError("{} unknown report type {}, args={}".format(
raise ValueError(
"{} unknown report type {}, args={}".format(
addr, report_type, report_args
))
)
)
alive_count -= 1
replier.log("shutting down")
replier.account.shutdown()
@@ -89,8 +93,7 @@ class AutoReplier:
self.addr = self.account.get_self_contact().addr
self._thread = threading.Thread(
name="Stats{}".format(self.account),
target=self.thread_stats
name="Stats{}".format(self.account), target=self.thread_stats
)
self._thread.setDaemon(True)
self._thread.start()
@@ -116,11 +119,16 @@ class AutoReplier:
self.current_sent += 1
# we are still alive, let's send a reply
if self.num_bigfiles and self.current_sent % (self.num_send / self.num_bigfiles) == 0:
if (
self.num_bigfiles
and self.current_sent % (self.num_send / self.num_bigfiles) == 0
):
message.chat.send_text("send big file as reply to: {}".format(message.text))
msg = message.chat.send_file(self.account.bigfile)
else:
msg = message.chat.send_text("got message id {}, small text reply".format(message.id))
msg = message.chat.send_text(
"got message id {}, small text reply".format(message.id)
)
assert msg.text
self.log("message-sent: {}".format(msg))
self.report_func(self, ReportType.message_echo)

13
python/tests/test_0_complex_or_slow.py
View File

@@ -1,4 +1,5 @@
import sys
import pytest
@@ -215,7 +216,9 @@ def test_fetch_existing(acfactory, lp, mvbox_move):
chat.send_text("message text")
assert_folders_configured(ac1)
lp.sec("wait until the bcc_self message arrives in correct folder and is marked seen")
lp.sec(
"wait until the bcc_self message arrives in correct folder and is marked seen"
)
assert idle1.wait_for_seen()
assert_folders_configured(ac1)
@@ -254,7 +257,9 @@ def test_fetch_existing_msgs_group_and_single(acfactory, lp):
acfactory.bring_accounts_online()
lp.sec("receive a message")
ac2.create_group_chat("group name", contacts=[ac1]).send_text("incoming, unencrypted group message")
ac2.create_group_chat("group name", contacts=[ac1]).send_text(
"incoming, unencrypted group message"
)
ac1._evtracker.wait_next_incoming_message()
lp.sec("send out message with bcc to ourselves")
@@ -277,7 +282,7 @@ def test_fetch_existing_msgs_group_and_single(acfactory, lp):
assert len(chats) == 4 # two newly created chats + self-chat + device-chat
group_chat = [c for c in chats if c.get_name() == "group name"][0]
assert group_chat.is_group()
private_chat, = [c for c in chats if c.get_name() == ac1_ac2_chat.get_name()]
(private_chat,) = [c for c in chats if c.get_name() == ac1_ac2_chat.get_name()]
assert not private_chat.is_group()
group_messages = group_chat.get_messages()
@@ -378,7 +383,7 @@ def test_ephemeral_timer(acfactory, lp):
lp.sec("ac1: check that ephemeral timer is set for chat")
assert chat1.get_ephemeral_timer() == 60
chat1_summary = chat1.get_summary()
assert chat1_summary["ephemeral_timer"] == {'Enabled': {'duration': 60}}
assert chat1_summary["ephemeral_timer"] == {"Enabled": {"duration": 60}}
lp.sec("ac2: receive system message about ephemeral timer modification")
ac2._evtracker.get_matching("DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED")

174
python/tests/test_1_online.py
View File

@@ -1,10 +1,11 @@
import os
import sys
import queue
import sys
from datetime import datetime, timezone
from imap_tools import AND, U
import pytest
from imap_tools import AND, U
from deltachat import const
from deltachat.hookspec import account_hookimpl
from deltachat.message import Message
@@ -34,8 +35,12 @@ def test_basic_imap_api(acfactory, tmpdir):
def test_configure_generate_key(acfactory, lp):
# A slow test which will generate new keys.
acfactory.remove_preconfigured_keys()
ac1 = acfactory.new_online_configuring_account(key_gen_type=str(const.DC_KEY_GEN_RSA2048))
ac2 = acfactory.new_online_configuring_account(key_gen_type=str(const.DC_KEY_GEN_ED25519))
ac1 = acfactory.new_online_configuring_account(
key_gen_type=str(const.DC_KEY_GEN_RSA2048)
)
ac2 = acfactory.new_online_configuring_account(
key_gen_type=str(const.DC_KEY_GEN_ED25519)
)
acfactory.bring_accounts_online()
chat = acfactory.get_accepted_chat(ac1, ac2)
@@ -78,7 +83,7 @@ def test_export_import_self_keys(acfactory, tmpdir, lp):
assert len(export_files) == 2
for x in export_files:
assert x.startswith(dir.strpath)
key_id, = ac1._evtracker.get_info_regex_groups(r".*xporting.*KeyId\((.*)\).*")
(key_id,) = ac1._evtracker.get_info_regex_groups(r".*xporting.*KeyId\((.*)\).*")
ac1._evtracker.consume_events()
lp.sec("exported keys (private and public)")
@@ -86,8 +91,9 @@ def test_export_import_self_keys(acfactory, tmpdir, lp):
lp.indent(dir.strpath + os.sep + name)
lp.sec("importing into existing account")
ac2.import_self_keys(dir.strpath)
key_id2, = ac2._evtracker.get_info_regex_groups(
r".*stored.*KeyId\((.*)\).*", check_error=False)
(key_id2,) = ac2._evtracker.get_info_regex_groups(
r".*stored.*KeyId\((.*)\).*", check_error=False
)
assert key_id2 == key_id
@@ -243,7 +249,9 @@ def test_mvbox_sentbox_threads(acfactory, lp):
ac1 = acfactory.new_online_configuring_account(mvbox_move=True, sentbox_watch=True)
lp.sec("ac2: start without mvbox/sentbox threads")
ac2 = acfactory.new_online_configuring_account(mvbox_move=False, sentbox_watch=False)
ac2 = acfactory.new_online_configuring_account(
mvbox_move=False, sentbox_watch=False
)
lp.sec("ac2 and ac1: waiting for configuration")
acfactory.bring_accounts_online()
@@ -465,7 +473,10 @@ def test_moved_markseen(acfactory, lp):
ac2.mark_seen_messages([msg])
uid = idle2.wait_for_seen()
assert len([a for a in ac2.direct_imap.conn.fetch(AND(seen=True, uid=U(uid, "*")))]) == 1
assert (
len([a for a in ac2.direct_imap.conn.fetch(AND(seen=True, uid=U(uid, "*")))])
== 1
)
def test_message_override_sender_name(acfactory, lp):
@@ -689,7 +700,7 @@ def test_gossip_encryption_preference(acfactory, lp):
msg = ac1._evtracker.wait_next_incoming_message()
assert msg.text == "first message"
assert not msg.is_encrypted()
res = "End-to-end encryption preferred:\n{}".format(ac2.get_config('addr'))
res = "End-to-end encryption preferred:\n{}".format(ac2.get_config("addr"))
assert msg.chat.get_encryption_info() == res
lp.sec("ac2 learns that ac3 prefers encryption")
ac2.create_chat(ac3)
@@ -701,7 +712,7 @@ def test_gossip_encryption_preference(acfactory, lp):
lp.sec("ac3 does not know that ac1 prefers encryption")
ac1.create_chat(ac3)
chat = ac3.create_chat(ac1)
res = "No encryption:\n{}".format(ac1.get_config('addr'))
res = "No encryption:\n{}".format(ac1.get_config("addr"))
assert chat.get_encryption_info() == res
msg = chat.send_text("not encrypted")
msg = ac1._evtracker.wait_next_incoming_message()
@@ -766,7 +777,7 @@ def test_send_first_message_as_long_unicode_with_cr(acfactory, lp):
def test_no_draft_if_cant_send(acfactory):
"""Tests that no quote can be set if the user can't send to this chat"""
ac1, = acfactory.get_online_accounts(1)
(ac1,) = acfactory.get_online_accounts(1)
device_chat = ac1.get_device_chat()
msg = Message.new_empty(ac1, "text")
device_chat.set_draft(msg)
@@ -795,7 +806,9 @@ def test_dont_show_emails(acfactory, lp):
acfactory.bring_accounts_online()
ac1.stop_io()
ac1.direct_imap.append("Drafts", """
ac1.direct_imap.append(
"Drafts",
"""
From: ac1 <{}>
Subject: subj
To: alice@example.org
@@ -803,8 +816,13 @@ def test_dont_show_emails(acfactory, lp):
Content-Type: text/plain; charset=utf-8
message in Drafts that is moved to Sent later
""".format(ac1.get_config("configured_addr")))
ac1.direct_imap.append("Sent", """
""".format(
ac1.get_config("configured_addr")
),
)
ac1.direct_imap.append(
"Sent",
"""
From: ac1 <{}>
Subject: subj
To: alice@example.org
@@ -812,8 +830,13 @@ def test_dont_show_emails(acfactory, lp):
Content-Type: text/plain; charset=utf-8
message in Sent
""".format(ac1.get_config("configured_addr")))
ac1.direct_imap.append("Spam", """
""".format(
ac1.get_config("configured_addr")
),
)
ac1.direct_imap.append(
"Spam",
"""
From: unknown.address@junk.org
Subject: subj
To: {}
@@ -821,8 +844,13 @@ def test_dont_show_emails(acfactory, lp):
Content-Type: text/plain; charset=utf-8
Unknown message in Spam
""".format(ac1.get_config("configured_addr")))
ac1.direct_imap.append("Junk", """
""".format(
ac1.get_config("configured_addr")
),
)
ac1.direct_imap.append(
"Junk",
"""
From: unknown.address@junk.org
Subject: subj
To: {}
@@ -830,7 +858,10 @@ def test_dont_show_emails(acfactory, lp):
Content-Type: text/plain; charset=utf-8
Unknown message in Junk
""".format(ac1.get_config("configured_addr")))
""".format(
ac1.get_config("configured_addr")
),
)
ac1.set_config("scan_all_folders_debounce_secs", "0")
lp.sec("All prepared, now let DC find the message")
@@ -849,7 +880,9 @@ def test_dont_show_emails(acfactory, lp):
assert ac1.direct_imap.get_uid_by_message_id("spam.message@junk.org")
ac1.stop_io()
lp.sec("'Send out' the draft, i.e. move it to the Sent folder, and wait for DC to display it this time")
lp.sec(
"'Send out' the draft, i.e. move it to the Sent folder, and wait for DC to display it this time"
)
ac1.direct_imap.select_folder("Drafts")
uid = ac1.direct_imap.get_uid_by_message_id("aepiors@example.org")
ac1.direct_imap.conn.move(uid, "Sent")
@@ -884,7 +917,9 @@ def test_no_old_msg_is_fresh(acfactory, lp):
assert ac1.create_chat(ac2).count_fresh_messages() == 1
assert len(list(ac1.get_fresh_messages())) == 1
lp.sec("Send a message from ac1_clone to ac2 and check that ac1 marks the first message as 'noticed'")
lp.sec(
"Send a message from ac1_clone to ac2 and check that ac1 marks the first message as 'noticed'"
)
ac1_clone.create_chat(ac2).send_text("Hi back")
ev = ac1._evtracker.get_matching("DC_EVENT_MSGS_NOTICED")
@@ -1154,7 +1189,7 @@ def test_send_and_receive_image(acfactory, lp, data):
def test_import_export_online_all(acfactory, tmpdir, data, lp):
ac1, = acfactory.get_online_accounts(1)
(ac1,) = acfactory.get_online_accounts(1)
lp.sec("create some chat content")
chat1 = ac1.create_contact("some1@example.org", name="some1").create_chat()
@@ -1180,7 +1215,10 @@ def test_import_export_online_all(acfactory, tmpdir, data, lp):
assert len(messages) == 3
assert messages[0].text == "msg1"
assert messages[1].filemime == "image/png"
assert os.stat(messages[1].filename).st_size == os.stat(original_image_path).st_size
assert (
os.stat(messages[1].filename).st_size
== os.stat(original_image_path).st_size
)
ac.set_config("displayname", "new displayname")
assert ac.get_config("displayname") == "new displayname"
@@ -1326,7 +1364,9 @@ def test_set_get_contact_avatar(acfactory, data, lp):
assert open(received_path, "rb").read() == open(p, "rb").read()
lp.sec("ac2: send back message")
msg3 = msg2.create_chat().send_text("yes, i received your avatar -- how do you like mine?")
msg3 = msg2.create_chat().send_text(
"yes, i received your avatar -- how do you like mine?"
)
assert msg3.is_encrypted()
lp.sec("ac1: wait for receiving message and avatar from ac2")
@@ -1371,11 +1411,17 @@ def test_add_remove_member_remote_events(acfactory, lp):
@account_hookimpl
def ac_member_added(self, chat, contact, message):
in_list.put(EventHolder(action="added", chat=chat, contact=contact, message=message))
in_list.put(
EventHolder(action="added", chat=chat, contact=contact, message=message)
)
@account_hookimpl
def ac_member_removed(self, chat, contact, message):
in_list.put(EventHolder(action="removed", chat=chat, contact=contact, message=message))
in_list.put(
EventHolder(
action="removed", chat=chat, contact=contact, message=message
)
)
ac2.add_account_plugin(InPlugin())
@@ -1387,8 +1433,9 @@ def test_add_remove_member_remote_events(acfactory, lp):
ev = in_list.get()
assert ev.action == "chat-modified"
assert chat.is_promoted()
assert sorted(x.addr for x in chat.get_contacts()) == \
sorted(x.addr for x in ev.chat.get_contacts())
assert sorted(x.addr for x in chat.get_contacts()) == sorted(
x.addr for x in ev.chat.get_contacts()
)
lp.sec("ac1: add address2")
# note that if the above create_chat() would not
@@ -1528,10 +1575,14 @@ def test_connectivity(acfactory, lp):
ac1.start_io()
ac1._evtracker.wait_for_connectivity(const.DC_CONNECTIVITY_CONNECTING)
ac1._evtracker.wait_for_connectivity_change(const.DC_CONNECTIVITY_CONNECTING, const.DC_CONNECTIVITY_CONNECTED)
ac1._evtracker.wait_for_connectivity_change(
const.DC_CONNECTIVITY_CONNECTING, const.DC_CONNECTIVITY_CONNECTED
)
lp.sec("Test that after calling start_io(), maybe_network() and waiting for `all_work_done()`, " +
"all messages are fetched")
lp.sec(
"Test that after calling start_io(), maybe_network() and waiting for `all_work_done()`, "
+ "all messages are fetched"
)
ac1.direct_imap.select_config_folder("inbox")
with ac1.direct_imap.idle() as idle1:
@@ -1543,18 +1594,26 @@ def test_connectivity(acfactory, lp):
assert len(msgs) == 1
assert msgs[0].text == "Hi"
lp.sec("Test that the connectivity changes to WORKING while new messages are fetched")
lp.sec(
"Test that the connectivity changes to WORKING while new messages are fetched"
)
ac2.create_chat(ac1).send_text("Hi 2")
ac1._evtracker.wait_for_connectivity_change(const.DC_CONNECTIVITY_CONNECTED, const.DC_CONNECTIVITY_WORKING)
ac1._evtracker.wait_for_connectivity_change(const.DC_CONNECTIVITY_WORKING, const.DC_CONNECTIVITY_CONNECTED)
ac1._evtracker.wait_for_connectivity_change(
const.DC_CONNECTIVITY_CONNECTED, const.DC_CONNECTIVITY_WORKING
)
ac1._evtracker.wait_for_connectivity_change(
const.DC_CONNECTIVITY_WORKING, const.DC_CONNECTIVITY_CONNECTED
)
msgs = ac1.create_chat(ac2).get_messages()
assert len(msgs) == 2
assert msgs[1].text == "Hi 2"
lp.sec("Test that the connectivity doesn't flicker to WORKING if there are no new messages")
lp.sec(
"Test that the connectivity doesn't flicker to WORKING if there are no new messages"
)
ac1.maybe_network()
while 1:
@@ -1563,7 +1622,9 @@ def test_connectivity(acfactory, lp):
break
ac1._evtracker.get_matching("DC_EVENT_CONNECTIVITY_CHANGED")
lp.sec("Test that the connectivity doesn't flicker to WORKING if the sender of the message is blocked")
lp.sec(
"Test that the connectivity doesn't flicker to WORKING if the sender of the message is blocked"
)
ac1.create_contact(ac2).block()
ac1.direct_imap.select_config_folder("inbox")
@@ -1594,10 +1655,12 @@ def test_fetch_deleted_msg(acfactory, lp):
See https://github.com/deltachat/deltachat-core-rust/issues/2429.
"""
ac1, = acfactory.get_online_accounts(1)
(ac1,) = acfactory.get_online_accounts(1)
ac1.stop_io()
ac1.direct_imap.append("INBOX", """
ac1.direct_imap.append(
"INBOX",
"""
From: alice <alice@example.org>
Subject: subj
To: bob@example.com
@@ -1606,7 +1669,8 @@ def test_fetch_deleted_msg(acfactory, lp):
Content-Type: text/plain; charset=utf-8
Deleted message
""")
""",
)
ac1.direct_imap.delete("1:*", expunge=False)
ac1.start_io()
@@ -1626,7 +1690,10 @@ def test_fetch_deleted_msg(acfactory, lp):
if ev.name == "DC_EVENT_MSGS_CHANGED":
pytest.fail("A deleted message was shown to the user")
if ev.name == "DC_EVENT_INFO" and "INBOX: Idle entering wait-on-remote state" in ev.data2:
if (
ev.name == "DC_EVENT_INFO"
and "INBOX: Idle entering wait-on-remote state" in ev.data2
):
break # DC is done with reading messages
@@ -1888,11 +1955,26 @@ def test_group_quote(acfactory, lp):
assert received_reply.quote.id == out_msg.id
@pytest.mark.parametrize("folder,move,expected_destination,", [
("xyz", False, "xyz"), # Test that emails are recognized in a random folder but not moved
("xyz", True, "DeltaChat"), # ...emails are found in a random folder and moved to DeltaChat
("Spam", False, "INBOX"), # ...emails are moved from the spam folder to the Inbox
])
@pytest.mark.parametrize(
"folder,move,expected_destination,",
[
(
"xyz",
False,
"xyz",
), # Test that emails are recognized in a random folder but not moved
(
"xyz",
True,
"DeltaChat",
), # ...emails are found in a random folder and moved to DeltaChat
(
"Spam",
False,
"INBOX",
), # ...emails are moved from the spam folder to the Inbox
],
)
# Testrun.org does not support the CREATE-SPECIAL-USE capability, which means that we can't create a folder with
# the "\Junk" flag (see https://tools.ietf.org/html/rfc6154). So, we can't test spam folder detection by flag.
def test_scan_folders(acfactory, lp, folder, move, expected_destination):

25
python/tests/test_2_increation.py
View File

@@ -2,9 +2,9 @@ from __future__ import print_function
import os.path
import shutil
from filecmp import cmp
import pytest
from filecmp import cmp
def wait_msg_delivered(account, msg_list):
@@ -38,7 +38,7 @@ class TestOnlineInCreation:
lp.sec("Creating in-creation file outside of blobdir")
assert tmpdir.strpath != ac1.get_blobdir()
src = tmpdir.join('file.txt').ensure(file=1)
src = tmpdir.join("file.txt").ensure(file=1)
with pytest.raises(Exception):
chat.prepare_message_file(src.strpath)
@@ -48,11 +48,11 @@ class TestOnlineInCreation:
lp.sec("Creating file outside of blobdir")
assert tmpdir.strpath != ac1.get_blobdir()
src = tmpdir.join('file.txt')
src = tmpdir.join("file.txt")
src.write("hello there\n")
chat.send_file(src.strpath)
blob_src = os.path.join(ac1.get_blobdir(), 'file.txt')
blob_src = os.path.join(ac1.get_blobdir(), "file.txt")
assert os.path.exists(blob_src), "file.txt not copied to blobdir"
def test_forward_increation(self, acfactory, data, lp):
@@ -63,7 +63,7 @@ class TestOnlineInCreation:
lp.sec("create a message with a file in creation")
orig = data.get_path("d.png")
path = os.path.join(ac1.get_blobdir(), 'd.png')
path = os.path.join(ac1.get_blobdir(), "d.png")
with open(path, "x") as fp:
fp.write("preparing")
prepared_original = chat.prepare_message_file(path)
@@ -85,19 +85,22 @@ class TestOnlineInCreation:
assert prepared_original.is_out_preparing()
shutil.copyfile(orig, path)
chat.send_prepared(prepared_original)
assert prepared_original.is_out_pending() or prepared_original.is_out_delivered()
assert (
prepared_original.is_out_pending() or prepared_original.is_out_delivered()
)
lp.sec("check that both forwarded and original message are proper.")
wait_msgs_changed(ac1, [(chat2.id, forwarded_id), (chat.id, prepared_original.id)])
wait_msgs_changed(
ac1, [(chat2.id, forwarded_id), (chat.id, prepared_original.id)]
)
fwd_msg = ac1.get_message_by_id(forwarded_id)
assert fwd_msg.is_out_pending() or fwd_msg.is_out_delivered()
lp.sec("wait for both messages to be delivered to SMTP")
wait_msg_delivered(ac1, [
(chat2.id, forwarded_id),
(chat.id, prepared_original.id)
])
wait_msg_delivered(
ac1, [(chat2.id, forwarded_id), (chat.id, prepared_original.id)]
)
lp.sec("wait1 for original or forwarded messages to arrive")
received_original = ac2._evtracker.wait_next_incoming_message()

75
python/tests/test_3_offline.py
View File

@@ -1,32 +1,50 @@
from __future__ import print_function
import pytest
import os
import time
from deltachat import const, Account
from deltachat.message import Message
from deltachat.hookspec import account_hookimpl
from deltachat.capi import ffi, lib
from deltachat.cutil import iter_array
from datetime import datetime, timedelta, timezone
import pytest
@pytest.mark.parametrize("msgtext,res", [
("Member Me (tmp1@x.org) removed by tmp2@x.org.",
("removed", "tmp1@x.org", "tmp2@x.org")),
("Member With space (tmp1@x.org) removed by tmp2@x.org.",
("removed", "tmp1@x.org", "tmp2@x.org")),
("Member With space (tmp1@x.org) removed by Another member (tmp2@x.org).",
("removed", "tmp1@x.org", "tmp2@x.org")),
("Member With space (tmp1@x.org) removed by me",
("removed", "tmp1@x.org", "me")),
("Group left by some one (tmp1@x.org).",
("removed", "tmp1@x.org", "tmp1@x.org")),
("Group left by tmp1@x.org.",
("removed", "tmp1@x.org", "tmp1@x.org")),
("Member tmp1@x.org added by tmp2@x.org.", ("added", "tmp1@x.org", "tmp2@x.org")),
from deltachat import Account, const
from deltachat.capi import ffi, lib
from deltachat.cutil import iter_array
from deltachat.hookspec import account_hookimpl
from deltachat.message import Message
@pytest.mark.parametrize(
"msgtext,res",
[
(
"Member Me (tmp1@x.org) removed by tmp2@x.org.",
("removed", "tmp1@x.org", "tmp2@x.org"),
),
(
"Member With space (tmp1@x.org) removed by tmp2@x.org.",
("removed", "tmp1@x.org", "tmp2@x.org"),
),
(
"Member With space (tmp1@x.org) removed by Another member (tmp2@x.org).",
("removed", "tmp1@x.org", "tmp2@x.org"),
),
(
"Member With space (tmp1@x.org) removed by me",
("removed", "tmp1@x.org", "me"),
),
(
"Group left by some one (tmp1@x.org).",
("removed", "tmp1@x.org", "tmp1@x.org"),
),
("Group left by tmp1@x.org.", ("removed", "tmp1@x.org", "tmp1@x.org")),
(
"Member tmp1@x.org added by tmp2@x.org.",
("added", "tmp1@x.org", "tmp2@x.org"),
),
("Member nothing bla bla", None),
("Another unknown system message", None),
])
],
)
def test_parse_system_add_remove(msgtext, res):
from deltachat.message import parse_system_add_remove
@@ -274,7 +292,11 @@ class TestOfflineChat:
assert d["archived"] == chat.is_archived()
# assert d["param"] == chat.param
assert d["color"] == chat.get_color()
assert d["profile_image"] == "" if chat.get_profile_image() is None else chat.get_profile_image()
assert (
d["profile_image"] == ""
if chat.get_profile_image() is None
else chat.get_profile_image()
)
assert d["draft"] == "" if chat.get_draft() is None else chat.get_draft()
def test_group_chat_creation_with_translation(self, ac1):
@@ -424,11 +446,14 @@ class TestOfflineChat:
assert os.path.exists(msg.filename)
assert msg.filemime == "image/png"
@pytest.mark.parametrize("typein,typeout", [
@pytest.mark.parametrize(
"typein,typeout",
[
(None, "application/octet-stream"),
("text/plain", "text/plain"),
("image/png", "image/png"),
])
],
)
def test_message_file(self, ac1, chat1, data, lp, typein, typeout):
lp.sec("sending file")
fn = data.get_path("r.txt")
@@ -629,6 +654,6 @@ class TestOfflineChat:
lp.sec("check message count of only system messages (without daymarkers)")
dc_array = ffi.gc(
lib.dc_get_chat_msgs(ac1._dc_context, chat.id, const.DC_GCM_INFO_ONLY, 0),
lib.dc_array_unref
lib.dc_array_unref,
)
assert len(list(iter_array(dc_array, lambda x: x))) == 2

35
python/tests/test_4_lowlevel.py
View File

@@ -1,24 +1,25 @@
import os
from queue import Queue
from deltachat import capi, cutil, const
from deltachat import register_global_plugin
from deltachat import capi, const, cutil, register_global_plugin
from deltachat.capi import ffi, lib
from deltachat.hookspec import global_hookimpl
from deltachat.capi import ffi
from deltachat.capi import lib
from deltachat.testplugin import ACSetup, create_dict_from_files_in_path, write_dict_to_dir
from deltachat.testplugin import (
ACSetup,
create_dict_from_files_in_path,
write_dict_to_dir,
)
# from deltachat.account import EventLogger
class TestACSetup:
def test_cache_writing(self, tmp_path):
base = tmp_path.joinpath("hello")
base.mkdir()
d1 = base.joinpath("dir1")
d1.mkdir()
d1.joinpath("file1").write_bytes(b'content1')
d1.joinpath("file1").write_bytes(b"content1")
d2 = d1.joinpath("dir2")
d2.mkdir()
d2.joinpath("file2").write_bytes(b"123")
@@ -42,7 +43,9 @@ class TestACSetup:
pc.bring_online()
assert pc._account2state[acc] == pc.IDLEREADY
def test_two_accounts_one_waited_all_started(self, monkeypatch, acfactory, testprocess):
def test_two_accounts_one_waited_all_started(
self, monkeypatch, acfactory, testprocess
):
pc = ACSetup(init_time=0.0, testprocess=testprocess)
monkeypatch.setattr(pc, "init_imap", lambda *args, **kwargs: None)
monkeypatch.setattr(pc, "_onconfigure_start_io", lambda *args, **kwargs: None)
@@ -103,6 +106,7 @@ def test_dc_close_events(tmpdir, acfactory):
def dc_account_after_shutdown(self, account):
assert account._dc_context is None
shutdowns.put(account)
register_global_plugin(ShutdownPlugin())
assert hasattr(ac1, "_dc_context")
ac1.shutdown()
@@ -168,7 +172,12 @@ def test_provider_info_none():
lib.dc_context_new(ffi.NULL, ffi.NULL, ffi.NULL),
lib.dc_context_unref,
)
assert lib.dc_provider_new_from_email(ctx, cutil.as_dc_charpointer("email@unexistent.no")) == ffi.NULL
assert (
lib.dc_provider_new_from_email(
ctx, cutil.as_dc_charpointer("email@unexistent.no")
)
== ffi.NULL
)
def test_get_info_open(tmpdir):
@@ -178,8 +187,8 @@ def test_get_info_open(tmpdir):
lib.dc_context_unref,
)
info = cutil.from_dc_charpointer(lib.dc_get_info(ctx))
assert 'deltachat_core_version' in info
assert 'database_dir' in info
assert "deltachat_core_version" in info
assert "database_dir" in info
def test_logged_hook_failure(acfactory):

4
python/tox.ini
View File

@@ -36,10 +36,14 @@ skipsdist = True
skip_install = True
deps =
flake8
isort
black
# pygments required by rst-lint
pygments
restructuredtext_lint
commands =
isort --check --profile black src/deltachat examples/ tests/
black --check src/deltachat examples/ tests/
flake8 src/deltachat
flake8 tests/ examples/
rst-lint --encoding 'utf-8' README.rst