Multi process test use now generator instead of sequence to describe the test, making easier to implement test logic and storage of intermediate results

test/mp_sync_test.py

@@ -9,46 +9,39 @@ python3.4 mp_sync_test.py
 
 """
 
-stored_message = []
-
-def store_message(res, action):
-    stored_message.append(res)
-
-def print_res(res, action):
-    print(res)
-
 from multipEp import *
 
-   #("instance name", [instance_action_func, [args], {kwargs}], result_func),
+#("instance name", [instance_action_func, [args], {kwargs}], result_func),
-   #(manager_action_func, [args], {kwargs}, result_func),
+#(manager_action_func, [args], {kwargs}, result_func),
-scenario0 = [
+
-    ("GroupA1", [create_account, ["some.one@some.where", "Some One"]]),
+def scenario0():
-    ("SoloA", [create_account, ["some.other@else.where", "Some Other"]]),
+    for action in [
-    # key exchange
+        ("GroupA1", [create_account, ["some.one@some.where", "Some One"]]),
-    ("SoloA", [send_message, ["some.other@else.where", "some.one@some.where", 
+        ("SoloA", [create_account, ["some.other@else.where", "Some Other"]]),
-                              "Hey Bro", "Heeeey Brooooo"]]),
+        # key exchange
-    ("GroupA1", [send_message, ["some.one@some.where", "some.other@else.where",
+        ("SoloA", [send_message, ["some.other@else.where",
-                                "Yo Dude", "Yooooo Duuuude"]]),
+                                  "some.one@some.where", 
-    ("SoloA", [encrypted_message, ["some.other@else.where", 
+                                  "Hey Bro", "Heeeey Brooooo"]]),
+        ("GroupA1", [send_message, ["some.one@some.where",
+                                    "some.other@else.where",
+                                    "Yo Dude", "Yooooo Duuuude"]])
+    ] : yield action
+
+    enc_msg = yield ("SoloA", [encrypted_message, ["some.other@else.where", 
                                    "some.one@some.where", 
-                                   "read this", "this is a secret message"]], store_message),
+                                   "read this", "this is a secret message"]])
-    ("GroupA1", [decrypt_message, [stored_message]], expect([6])), 
+    for action in [
-    (flush_all_mails,),
+        ("GroupA1", [decrypt_message, [enc_msg]], expect(6)),
-    ("GroupA2", [create_account, ["some.one@some.where", "Some One"]]),
+        (flush_all_mails,),
-    (cycle_until_no_change, ["GroupA1", "GroupA2"], expect(4)),
+        ("GroupA2", [create_account, ["some.one@some.where", "Some One"]]),
-    ("GroupA2", [decrypt_message, [stored_message]], expect([6])), 
+        (cycle_until_no_change, ["GroupA1", "GroupA2"], expect(4)),
-    ("GroupA3", [create_account, ["some.one@some.where", "Some One"]]),
+        ("GroupA2", [decrypt_message, [enc_msg]], expect(6)), 
-    (cycle_until_no_change, ["GroupA1", "GroupA2", "GroupA3"], expect(3)),
+        ("GroupA3", [create_account, ["some.one@some.where", "Some One"]]),
-    # force consume messages
+        (cycle_until_no_change, ["GroupA1", "GroupA2", "GroupA3"], expect(3)),
-    # ("GroupA3", [None, None, None, -60*15]),
+        # force consume messages
-    ("GroupA3", [decrypt_message, [stored_message]], expect([6])) 
+        # ("GroupA3", [None, None, None, -60*15]),
-] 
+        ("GroupA3", [decrypt_message, [enc_msg]], expect(6)) 
-
+    ] : yield action
-scenario1 = [
-   #("instance name", [func, [args], {kwargs}]),
-    ("B", [send_message, ["some.other@else.where", "some.one@some.where", "Hey Bro", "Heeeey Brooooo"]]),
-    ("A", [send_message, ["some.one@some.where", "some.other@else.where", "Hey Bro", "Heeeey Brooooo"]]),
-] 
 
 if __name__ == "__main__":
     run_scenario(scenario0)

test/multipEp.py

@@ -57,19 +57,16 @@ def send_message(from_address, to_address, shortmsg, longmsg):
     msg = _encrypted_message(from_address, to_address, shortmsg, longmsg)
     _send_message(to_address, msg)
 
-def decrypt_message(msgs):
+def decrypt_message(msgstr):
-    res = []
+    msg = pEp.incoming_message(msgstr)
-    for msgstr in msgs:
+    printi("--- decrypt()")
-        msg = pEp.incoming_message(msgstr)
+    msg.recv = int(time.time())
-        printi("--- decrypt()")
+    printmsg(msg)
-        msg.recv = int(time.time())
+    msg2, keys, rating, consumed, flags = msg.decrypt()
-        printmsg(msg)
+    printi("->-", rating, "->-")
-        msg2, keys, rating, consumed, flags = msg.decrypt()
+    printmsg(msg2)
-        res.append(rating)
+    printi("---")
-        printi("->-", rating, "->-")
+    return rating
-        printmsg(msg2)
-        printi("---")
-    return res
 
 def printi(*args):
     global indent
@@ -109,7 +106,7 @@ def execute_order(order, handler):
     printheader("DECRYPT messages")
     # decrypt every non-consumed message for all instance accounts
     for own_address in own_addresses:
-        msgs_for_me = msgs_folders[own_address]
+        msgs_for_me = msgs_folders.get(own_address, [])
         for msgstr in msgs_for_me:
             msg = pEp.incoming_message(msgstr)
             printi("--- decrypt()")
@@ -206,6 +203,7 @@ def pEp_instance_run(iname, conn, _msgs_folders, _handshakes_seen, _handshakes_v
         if order is None:
             break
 
+        print(order)
         res = execute_order(order, handler)
 
         conn.send(res)
@@ -270,20 +268,28 @@ def run_scenario(scenario):
         handshakes_seen = manager.list()
         handshakes_validated = manager.list()
 
-        for action in scenario:
+        sc = scenario()
-            res = None
+        try:
-            output = None
+            action = next(sc)
-            if len(action) > 1 and type(action[-1]) == types.FunctionType:
+            while True:
-                output = action[-1]
+                res = None
-                action = action[:-1]
+                output = None
+                if len(action) > 1 and type(action[-1]) == types.FunctionType:
+                    output = action[-1]
+                    action = action[:-1]
 
-            if type(action[0]) == str:
+                print(action)
-                res = run_instance_action(action)
+                if type(action[0]) == str:
-            else:
+                    res = run_instance_action(action)
-                res = run_manager_action(action)
+                else:
+                    res = run_manager_action(action)
+
+                if output is not None:
+                    output(res, action)
+
+                action = sc.send(res)
+        except StopIteration: pass
 
-            if output is not None:
-                output(res, action)
 
         if "wait_for_debug" in sys.argv:
             input("#"*80 + "\n" +