Finished the removal of .increation files

python/src/deltachat/account.py

@@ -109,6 +109,14 @@ class Account(object):
         self.check_is_configured()
         return from_dc_charpointer(lib.dc_get_info(self._dc_context))
 
+    def get_blobdir(self):
+        """ return the directory for files.
+
+        All sent files are copied to this directory if necessary.
+        Place files there directly to avoid copying.
+        """
+        return from_dc_charpointer(lib.dc_get_blobdir(self._dc_context))
+
     def get_self_contact(self):
         """ return this account's identity as a :class:`deltachat.chatting.Contact`.
 

python/src/deltachat/chatting.py

@@ -152,6 +152,40 @@ class Chat(object):
         msg_id = lib.dc_send_msg(self._dc_context, self.id, msg._dc_msg)
         return Message.from_db(self._dc_context, msg_id)
 
+    def prepare_file(self, path, mime_type=None, view_type="file"):
+        """ prepare a message for sending and return the resulting Message instance.
+
+        To actually send the message, call :meth:`send_prepared`.
+        The file must be inside the blob directory.
+
+        :param path: path to the file.
+        :param mime_type: the mime-type of this file, defaults to auto-detection.
+        :param view_type: passed to :meth:`MessageType.new`.
+        :raises: ValueError if message can not be prepared/chat does not exist.
+        :returns: the resulting :class:`Message` instance
+        """
+        path = as_dc_charpointer(path)
+        mtype = as_dc_charpointer(mime_type)
+        msg = Message.new(self._dc_context, view_type)
+        msg.set_file(path, mtype)
+        msg_id = lib.dc_prepare_msg(self._dc_context, self.id, msg._dc_msg)
+        if msg_id == 0:
+            raise ValueError("message could not be prepared, does chat exist?")
+        return Message.from_db(self._dc_context, msg_id)
+
+    def send_prepared(self, message):
+        """ send a previously prepared message.
+
+        :param message: a :class:`Message` instance previously returned by
+                        :meth:`prepare_file`.
+        :raises: ValueError if message can not be sent.
+        :returns: a :class:`deltachat.chatting.Message` instance with updated state
+        """
+        msg_id = lib.dc_send_msg(self._dc_context, 0, message._dc_msg)
+        if msg_id == 0:
+            raise ValueError("message could not be sent")
+        return message.from_db(self._dc_context, msg_id)
+
     def get_messages(self):
         """ return list of messages in this chat.
 

python/src/deltachat/const.py

@@ -31,7 +31,9 @@ DC_STATE_UNDEFINED = 0
 DC_STATE_IN_FRESH = 10
 DC_STATE_IN_NOTICED = 13
 DC_STATE_IN_SEEN = 16
+DC_STATE_OUT_DRAFT = 19
 DC_STATE_OUT_PENDING = 20
+DC_STATE_OUT_PREPARING = 21
 DC_STATE_OUT_FAILED = 24
 DC_STATE_OUT_DELIVERED = 26
 DC_STATE_OUT_MDN_RCVD = 28
@@ -52,6 +54,7 @@ DC_EVENT_SMTP_MESSAGE_SENT = 103
 DC_EVENT_WARNING = 300
 DC_EVENT_ERROR = 400
 DC_EVENT_ERROR_NETWORK = 401
+DC_EVENT_ERROR_SELF_NOT_IN_GROUP = 410
 DC_EVENT_MSGS_CHANGED = 2000
 DC_EVENT_INCOMING_MSG = 2005
 DC_EVENT_MSG_DELIVERED = 2010
@@ -66,6 +69,8 @@ DC_EVENT_SECUREJOIN_INVITER_PROGRESS = 2060
 DC_EVENT_SECUREJOIN_JOINER_PROGRESS = 2061
 DC_EVENT_GET_STRING = 2091
 DC_EVENT_HTTP_GET = 2100
+DC_EVENT_FILE_COPIED = 2055
+DC_EVENT_IS_OFFLINE = 2081
 # end const generated
 
 

python/src/deltachat/message.py

@@ -232,6 +232,11 @@ class MessageState(object):
         """
         return self._msgstate == const.DC_STATE_IN_SEEN
 
+    def is_out_preparing(self):
+        """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).
         """

python/tests/conftest.py

@@ -130,3 +130,10 @@ def wait_successful_IMAP_SMTP_connection(account):
         if evt_name == "DC_EVENT_SMTP_CONNECTED":
             smtp_ok = True
     print("** IMAP and SMTP logins successful", account)
+
+def wait_msgs_changed(account, chat_id, msg_id = None):
+    ev = account._evlogger.get_matching("DC_EVENT_MSGS_CHANGED")
+    assert ev[1] == chat_id
+    if msg_id is not None:
+        assert ev[2] == msg_id
+    return ev[2]

python/tests/test_increation.py

@@ -0,0 +1,67 @@
+from __future__ import print_function
+import pytest
+import os
+import shutil
+from filecmp import cmp
+from deltachat import const
+#from datetime import datetime, timedelta
+from conftest import wait_configuration_progress, wait_successful_IMAP_SMTP_connection, wait_msgs_changed
+
+class TestInCreation:
+    def test_forward_increation(self, acfactory, data, lp):
+        ac1 = acfactory.get_online_configuring_account()
+        ac2 = acfactory.get_online_configuring_account()
+        wait_configuration_progress(ac1, 1000)
+        wait_configuration_progress(ac2, 1000)
+
+        blobdir = ac1.get_blobdir()
+
+        c2 = ac1.create_contact(email = ac2.get_config("addr"))
+        chat = ac1.create_chat_by_contact(c2)
+        assert chat.id >= const.DC_CHAT_ID_LAST_SPECIAL
+        wait_msgs_changed(ac1, 0, 0) # why no chat id?
+
+        lp.sec("create a message with a file in creation")
+        path = os.path.join(blobdir, "d.png")
+        open(path, 'a').close()
+        prepared_original = chat.prepare_file(path)
+        assert prepared_original.get_state().is_out_preparing()
+
+        lp.sec("forward the message while still in creation")
+        chat2 = ac1.create_group_chat("newgroup")
+        chat2.add_contact(c2)
+        wait_msgs_changed(ac1, 0, 0) # why not chat id?
+        ac1.forward_messages([prepared_original], chat2)
+        forwarded_id = wait_msgs_changed(ac1, chat2.id)
+        forwarded_msg = ac1.get_message_by_id(forwarded_id)
+        assert forwarded_msg.get_state().is_out_preparing()
+
+        lp.sec("finish creating the file and send it")
+        shutil.copy(data.get_path("d.png"), path)
+        sent_original = chat.send_prepared(prepared_original)
+        assert sent_original.id == prepared_original.id
+        assert sent_original.get_state().is_out_pending()
+        wait_msgs_changed(ac1, chat.id, sent_original.id)
+
+        lp.sec("expect the forwarded message to be sent now too")
+        wait_msgs_changed(ac1, chat2.id, forwarded_id)
+        assert ac1.get_message_by_id(forwarded_id).get_state().is_out_pending()
+
+        lp.sec("wait for the messages to be delivered to SMTP")
+        ev = ac1._evlogger.get_matching("DC_EVENT_MSG_DELIVERED")
+        assert ev[1] == chat.id
+        assert ev[2] == sent_original.id
+        ev = ac1._evlogger.get_matching("DC_EVENT_MSG_DELIVERED")
+        assert ev[1] == chat2.id
+        assert ev[2] == forwarded_id
+
+        lp.sec("wait for both messages to arrive")
+        ev1 = ac2._evlogger.get_matching("DC_EVENT_MSGS_CHANGED")
+        assert ev1[1] >= const.DC_CHAT_ID_LAST_SPECIAL
+        received_original = ac2.get_message_by_id(ev1[2])
+        assert cmp(received_original.filename, path, False)
+        ev2 = ac2._evlogger.get_matching("DC_EVENT_MSGS_CHANGED")
+        assert ev2[1] >= const.DC_CHAT_ID_LAST_SPECIAL
+        assert ev2[1] != ev1[1]
+        received_copy = ac2.get_message_by_id(ev2[2])
+        assert cmp(received_copy.filename, path, False)