plomlompom.com Git - plomtask/blob - tests/processes.py

   1 """Test Processes module."""
   2 from typing import Any
   3 from tests.utils import TestCaseWithDB, TestCaseWithServer, TestCaseSansDB
   4 from plomtask.processes import Process, ProcessStep, ProcessStepsNode
   5 from plomtask.conditions import Condition
   6 from plomtask.exceptions import HandledException, NotFoundException
   7 from plomtask.todos import Todo
   8
   9
  10 class TestsSansDB(TestCaseSansDB):
  11     """Module tests not requiring DB setup."""
  12     checked_class = Process
  13
  14
  15 class TestsSansDBProcessStep(TestCaseSansDB):
  16     """Module tests not requiring DB setup."""
  17     checked_class = ProcessStep
  18     default_init_kwargs = {'owner_id': 2, 'step_process_id': 3,
  19                            'parent_step_id': 4}
  20
  21
  22 class TestsWithDB(TestCaseWithDB):
  23     """Module tests requiring DB setup."""
  24     checked_class = Process
  25
  26     def three_processes(self) -> tuple[Process, Process, Process]:
  27         """Return three saved processes."""
  28         p1, p2, p3 = Process(None), Process(None), Process(None)
  29         for p in [p1, p2, p3]:
  30             p.save(self.db_conn)
  31         return p1, p2, p3
  32
  33     def p_of_conditions(self) -> tuple[Process, list[Condition],
  34                                        list[Condition], list[Condition]]:
  35         """Return Process and its three Condition sets."""
  36         p = Process(None)
  37         c1, c2, c3 = Condition(None), Condition(None), Condition(None)
  38         for c in [c1, c2, c3]:
  39             c.save(self.db_conn)
  40         assert isinstance(c1.id_, int)
  41         assert isinstance(c2.id_, int)
  42         assert isinstance(c3.id_, int)
  43         set_1 = [c1, c2]
  44         set_2 = [c2, c3]
  45         set_3 = [c1, c3]
  46         p.set_conditions(self.db_conn, [c.id_ for c in set_1
  47                                         if isinstance(c.id_, int)])
  48         p.set_enables(self.db_conn, [c.id_ for c in set_2
  49                                      if isinstance(c.id_, int)])
  50         p.set_disables(self.db_conn, [c.id_ for c in set_3
  51                                       if isinstance(c.id_, int)])
  52         p.save(self.db_conn)
  53         return p, set_1, set_2, set_3
  54
  55     def test_Process_conditions_saving(self) -> None:
  56         """Test .save/.save_core."""
  57         p, set1, set2, set3 = self.p_of_conditions()
  58         assert p.id_ is not None
  59         r = Process.by_id(self.db_conn, p.id_)
  60         self.assertEqual(sorted(r.conditions), sorted(set1))
  61         self.assertEqual(sorted(r.enables), sorted(set2))
  62         self.assertEqual(sorted(r.disables), sorted(set3))
  63
  64     def test_from_table_row(self) -> None:
  65         """Test .from_table_row() properly reads in class from DB."""
  66         super().test_from_table_row()
  67         p, set1, set2, set3 = self.p_of_conditions()
  68         p.save(self.db_conn)
  69         assert isinstance(p.id_, int)
  70         for row in self.db_conn.row_where(self.checked_class.table_name,
  71                                           'id', p.id_):
  72             r = Process.from_table_row(self.db_conn, row)
  73             self.assertEqual(sorted(r.conditions), sorted(set1))
  74             self.assertEqual(sorted(r.enables), sorted(set2))
  75             self.assertEqual(sorted(r.disables), sorted(set3))
  76
  77     def test_Process_steps(self) -> None:
  78         """Test addition, nesting, and non-recursion of ProcessSteps"""
  79         # pylint: disable=too-many-locals
  80         # pylint: disable=too-many-statements
  81         p1, p2, p3 = self.three_processes()
  82         assert isinstance(p1.id_, int)
  83         assert isinstance(p2.id_, int)
  84         assert isinstance(p3.id_, int)
  85         steps_p1: list[ProcessStep] = []
  86         # add step of process p2 as first (top-level) step to p1
  87         s_p2_to_p1 = ProcessStep(None, p1.id_, p2.id_, None)
  88         steps_p1 += [s_p2_to_p1]
  89         p1.set_steps(self.db_conn, steps_p1)
  90         p1_dict: dict[int, ProcessStepsNode] = {}
  91         p1_dict[1] = ProcessStepsNode(p2, None, True, {})
  92         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
  93         # add step of process p3 as second (top-level) step to p1
  94         s_p3_to_p1 = ProcessStep(None, p1.id_, p3.id_, None)
  95         steps_p1 += [s_p3_to_p1]
  96         p1.set_steps(self.db_conn, steps_p1)
  97         p1_dict[2] = ProcessStepsNode(p3, None, True, {})
  98         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
  99         # add step of process p3 as first (top-level) step to p2,
 100         steps_p2: list[ProcessStep] = []
 101         s_p3_to_p2 = ProcessStep(None, p2.id_, p3.id_, None)
 102         steps_p2 += [s_p3_to_p2]
 103         p2.set_steps(self.db_conn, steps_p2)
 104         # expect it as implicit sub-step of p1's second (p3) step
 105         p2_dict = {3: ProcessStepsNode(p3, None, False, {})}
 106         p1_dict[1].steps[3] = p2_dict[3]
 107         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
 108         # add step of process p2 as explicit sub-step to p1's second sub-step
 109         s_p2_to_p1_first = ProcessStep(None, p1.id_, p2.id_, s_p3_to_p1.id_)
 110         steps_p1 += [s_p2_to_p1_first]
 111         p1.set_steps(self.db_conn, steps_p1)
 112         seen_3 = ProcessStepsNode(p3, None, False, {}, False)
 113         p1_dict[1].steps[3].seen = True
 114         p1_dict[2].steps[4] = ProcessStepsNode(p2, s_p3_to_p1.id_, True,
 115                                                {3: seen_3})
 116         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
 117         # add step of process p3 as explicit sub-step to non-existing p1
 118         # sub-step (of id=999), expect it to become another p1 top-level step
 119         s_p3_to_p1_999 = ProcessStep(None, p1.id_, p3.id_, 999)
 120         steps_p1 += [s_p3_to_p1_999]
 121         p1.set_steps(self.db_conn, steps_p1)
 122         p1_dict[5] = ProcessStepsNode(p3, None, True, {})
 123         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
 124         # add step of process p3 as explicit sub-step to p1's implicit p3
 125         # sub-step, expect it to become another p1 top-level step
 126         s_p3_to_p1_impl_p3 = ProcessStep(None, p1.id_, p3.id_, s_p3_to_p2.id_)
 127         steps_p1 += [s_p3_to_p1_impl_p3]
 128         p1.set_steps(self.db_conn, steps_p1)
 129         p1_dict[6] = ProcessStepsNode(p3, None, True, {})
 130         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
 131         self.assertEqual(p1.used_as_step_by(self.db_conn), [])
 132         self.assertEqual(p2.used_as_step_by(self.db_conn), [p1])
 133         self.assertEqual(p3.used_as_step_by(self.db_conn), [p1, p2])
 134         # # add step of process p3 as explicit sub-step to p1's first sub-step,
 135         # # expect it to eliminate implicit p3 sub-step
 136         # s_p3_to_p1_first_explicit = ProcessStep(None, p1.id_, p3.id_,
 137         #                                         s_p2_to_p1.id_)
 138         # p1_dict[1].steps = {7: ProcessStepsNode(p3, 1, True, {})}
 139         # p1_dict[2].steps[4].steps[3].seen = False
 140         # steps_p1 += [s_p3_to_p1_first_explicit]
 141         # p1.set_steps(self.db_conn, steps_p1)
 142         # self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
 143         # ensure implicit steps non-top explicit steps are shown
 144         s_p3_to_p2_first = ProcessStep(None, p2.id_, p3.id_, s_p3_to_p2.id_)
 145         steps_p2 += [s_p3_to_p2_first]
 146         p2.set_steps(self.db_conn, steps_p2)
 147         p1_dict[1].steps[3].steps[7] = ProcessStepsNode(p3, 3, False, {}, True)
 148         p1_dict[2].steps[4].steps[3].steps[7] = ProcessStepsNode(p3, 3, False,
 149                                                                  {}, False)
 150         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
 151         # ensure suppressed step nodes are hidden
 152         assert isinstance(s_p3_to_p2.id_, int)
 153         p1.set_step_suppressions(self.db_conn, [s_p3_to_p2.id_])
 154         p1_dict[1].steps[3].steps = {}
 155         p1_dict[1].steps[3].is_suppressed = True
 156         p1_dict[2].steps[4].steps[3].steps = {}
 157         p1_dict[2].steps[4].steps[3].is_suppressed = True
 158         self.assertEqual(p1.get_steps(self.db_conn), p1_dict)
 159
 160     def test_Process_conditions(self) -> None:
 161         """Test setting Process.conditions/enables/disables."""
 162         p = Process(None)
 163         p.save(self.db_conn)
 164         for target in ('conditions', 'enables', 'disables'):
 165             method = getattr(p, f'set_{target}')
 166             c1, c2 = Condition(None), Condition(None)
 167             c1.save(self.db_conn)
 168             c2.save(self.db_conn)
 169             assert isinstance(c1.id_, int)
 170             assert isinstance(c2.id_, int)
 171             method(self.db_conn, [])
 172             self.assertEqual(getattr(p, target), [])
 173             method(self.db_conn, [c1.id_])
 174             self.assertEqual(getattr(p, target), [c1])
 175             method(self.db_conn, [c2.id_])
 176             self.assertEqual(getattr(p, target), [c2])
 177             method(self.db_conn, [c1.id_, c2.id_])
 178             self.assertEqual(getattr(p, target), [c1, c2])
 179
 180     def test_remove(self) -> None:
 181         """Test removal of Processes and ProcessSteps."""
 182         super().test_remove()
 183         p1, p2, p3 = self.three_processes()
 184         assert isinstance(p1.id_, int)
 185         assert isinstance(p2.id_, int)
 186         assert isinstance(p3.id_, int)
 187         step = ProcessStep(None, p2.id_, p1.id_, None)
 188         p2.set_steps(self.db_conn, [step])
 189         step_id = step.id_
 190         with self.assertRaises(HandledException):
 191             p1.remove(self.db_conn)
 192         p2.set_steps(self.db_conn, [])
 193         with self.assertRaises(NotFoundException):
 194             assert step_id is not None
 195             ProcessStep.by_id(self.db_conn, step_id)
 196         p1.remove(self.db_conn)
 197         step = ProcessStep(None, p2.id_, p3.id_, None)
 198         p2.set_steps(self.db_conn, [step])
 199         step_id = step.id_
 200         p2.remove(self.db_conn)
 201         with self.assertRaises(NotFoundException):
 202             assert step_id is not None
 203             ProcessStep.by_id(self.db_conn, step_id)
 204         todo = Todo(None, p3, False, '2024-01-01')
 205         todo.save(self.db_conn)
 206         with self.assertRaises(HandledException):
 207             p3.remove(self.db_conn)
 208         todo.remove(self.db_conn)
 209         p3.remove(self.db_conn)
 210
 211
 212 class TestsWithDBForProcessStep(TestCaseWithDB):
 213     """Module tests requiring DB setup."""
 214     checked_class = ProcessStep
 215     default_init_kwargs = {'owner_id': 1, 'step_process_id': 2,
 216                            'parent_step_id': 3}
 217
 218     def setUp(self) -> None:
 219         super().setUp()
 220         self.p1 = Process(1)
 221         self.p1.save(self.db_conn)
 222
 223     def test_remove(self) -> None:
 224         """Test .remove and unsetting of owner's .explicit_steps entry."""
 225         p2 = Process(2)
 226         p2.save(self.db_conn)
 227         assert isinstance(self.p1.id_, int)
 228         assert isinstance(p2.id_, int)
 229         step = ProcessStep(None, self.p1.id_, p2.id_, None)
 230         self.p1.set_steps(self.db_conn, [step])
 231         step.remove(self.db_conn)
 232         self.assertEqual(self.p1.explicit_steps, [])
 233         self.check_identity_with_cache_and_db([])
 234
 235
 236 class TestsWithServer(TestCaseWithServer):
 237     """Module tests against our HTTP server/handler (and database)."""
 238
 239     def test_do_POST_process(self) -> None:
 240         """Test POST /process and its effect on the database."""
 241         self.assertEqual(0, len(Process.all(self.db_conn)))
 242         form_data = self.post_process()
 243         self.assertEqual(1, len(Process.all(self.db_conn)))
 244         self.check_post(form_data, '/process?id=FOO', 400)
 245         self.check_post(form_data | {'effort': 'foo'}, '/process?id=', 400)
 246         self.check_post({}, '/process?id=', 400)
 247         self.check_post({'title': '', 'description': ''}, '/process?id=', 400)
 248         self.check_post({'title': '', 'effort': 1.1}, '/process?id=', 400)
 249         self.check_post({'description': '', 'effort': 1.0},
 250                         '/process?id=', 400)
 251         self.assertEqual(1, len(Process.all(self.db_conn)))
 252         form_data = {'title': 'foo', 'description': 'foo', 'effort': 1.0}
 253         self.post_process(2, form_data | {'conditions': []})
 254         self.check_post(form_data | {'conditions': [1]}, '/process?id=', 404)
 255         self.check_post({'title': 'foo', 'description': 'foo',
 256                          'is_active': False},
 257                         '/condition', 302, '/condition?id=1')
 258         self.post_process(3, form_data | {'conditions': [1]})
 259         self.post_process(4, form_data | {'disables': [1]})
 260         self.post_process(5, form_data | {'enables': [1]})
 261         form_data['delete'] = ''
 262         self.check_post(form_data, '/process?id=', 404)
 263         self.check_post(form_data, '/process?id=6', 404)
 264         self.check_post(form_data, '/process?id=5', 302, '/processes')
 265
 266     def test_do_POST_process_steps(self) -> None:
 267         """Test behavior of ProcessStep posting."""
 268         # pylint: disable=too-many-statements
 269         form_data_1 = self.post_process(1)
 270         self.post_process(2)
 271         self.post_process(3)
 272         # post first (top-level) step of process 2 to process 1
 273         form_data_1['new_top_step'] = [2]
 274         self.post_process(1, form_data_1)
 275         retrieved_process = Process.by_id(self.db_conn, 1)
 276         self.assertEqual(len(retrieved_process.explicit_steps), 1)
 277         retrieved_step = retrieved_process.explicit_steps[0]
 278         retrieved_step_id = retrieved_step.id_
 279         self.assertEqual(retrieved_step.step_process_id, 2)
 280         self.assertEqual(retrieved_step.owner_id, 1)
 281         self.assertEqual(retrieved_step.parent_step_id, None)
 282         # post empty steps list to process, expect clean slate, and old step to
 283         # completely disappear
 284         form_data_1['new_top_step'] = []
 285         self.post_process(1, form_data_1)
 286         retrieved_process = Process.by_id(self.db_conn, 1)
 287         self.assertEqual(retrieved_process.explicit_steps, [])
 288         assert retrieved_step_id is not None
 289         with self.assertRaises(NotFoundException):
 290             ProcessStep.by_id(self.db_conn, retrieved_step_id)
 291         # post new first (top_level) step of process 3 to process 1
 292         form_data_1['new_top_step'] = [3]
 293         self.post_process(1, form_data_1)
 294         retrieved_process = Process.by_id(self.db_conn, 1)
 295         retrieved_step = retrieved_process.explicit_steps[0]
 296         self.assertEqual(retrieved_step.step_process_id, 3)
 297         self.assertEqual(retrieved_step.owner_id, 1)
 298         self.assertEqual(retrieved_step.parent_step_id, None)
 299         # post to process steps list without keeps, expect clean slate
 300         form_data_1['new_top_step'] = []
 301         form_data_1['steps'] = [retrieved_step.id_]
 302         self.post_process(1, form_data_1)
 303         retrieved_process = Process.by_id(self.db_conn, 1)
 304         self.assertEqual(retrieved_process.explicit_steps, [])
 305         # post to process empty steps list but keep, expect 400
 306         form_data_1['steps'] = []
 307         form_data_1['keep_step'] = [retrieved_step_id]
 308         self.check_post(form_data_1, '/process?id=1', 400, '/process?id=1')
 309         # post to process steps list with keep on non-created step, expect 400
 310         form_data_1['steps'] = [retrieved_step_id]
 311         form_data_1['keep_step'] = [retrieved_step_id]
 312         self.check_post(form_data_1, '/process?id=1', 400, '/process?id=1')
 313         # post to process steps list with keep and process ID, expect 200
 314         form_data_1[f'step_{retrieved_step_id}_process_id'] = [2]
 315         self.post_process(1, form_data_1)
 316         retrieved_process = Process.by_id(self.db_conn, 1)
 317         self.assertEqual(len(retrieved_process.explicit_steps), 1)
 318         retrieved_step = retrieved_process.explicit_steps[0]
 319         self.assertEqual(retrieved_step.step_process_id, 2)
 320         self.assertEqual(retrieved_step.owner_id, 1)
 321         self.assertEqual(retrieved_step.parent_step_id, None)
 322         # post nonsense, expect 400 and preservation of previous state
 323         form_data_1['steps'] = ['foo']
 324         form_data_1['keep_step'] = []
 325         self.check_post(form_data_1, '/process?id=1', 400, '/process?id=1')
 326         retrieved_process = Process.by_id(self.db_conn, 1)
 327         self.assertEqual(len(retrieved_process.explicit_steps), 1)
 328         retrieved_step = retrieved_process.explicit_steps[0]
 329         self.assertEqual(retrieved_step.step_process_id, 2)
 330         self.assertEqual(retrieved_step.owner_id, 1)
 331         self.assertEqual(retrieved_step.parent_step_id, None)
 332         # post to process steps list with keep and process ID, expect 200
 333         form_data_1['new_top_step'] = [3]
 334         form_data_1['steps'] = [retrieved_step.id_]
 335         form_data_1['keep_step'] = [retrieved_step.id_]
 336         self.post_process(1, form_data_1)
 337         retrieved_process = Process.by_id(self.db_conn, 1)
 338         self.assertEqual(len(retrieved_process.explicit_steps), 2)
 339         retrieved_step_0 = retrieved_process.explicit_steps[1]
 340         self.assertEqual(retrieved_step_0.step_process_id, 3)
 341         self.assertEqual(retrieved_step_0.owner_id, 1)
 342         self.assertEqual(retrieved_step_0.parent_step_id, None)
 343         retrieved_step_1 = retrieved_process.explicit_steps[0]
 344         self.assertEqual(retrieved_step_1.step_process_id, 2)
 345         self.assertEqual(retrieved_step_1.owner_id, 1)
 346         self.assertEqual(retrieved_step_1.parent_step_id, None)
 347         # post to process steps list with keeps etc., but trigger recursion
 348         form_data_1['new_top_step'] = []
 349         form_data_1['steps'] = [retrieved_step_0.id_, retrieved_step_1.id_]
 350         form_data_1['keep_step'] = [retrieved_step_0.id_, retrieved_step_1.id_]
 351         form_data_1[f'step_{retrieved_step_0.id_}_process_id'] = [2]
 352         form_data_1[f'step_{retrieved_step_1.id_}_process_id'] = [1]
 353         self.check_post(form_data_1, '/process?id=1', 400, '/process?id=1')
 354         # check previous status preserved despite failed steps setting
 355         retrieved_process = Process.by_id(self.db_conn, 1)
 356         self.assertEqual(len(retrieved_process.explicit_steps), 2)
 357         retrieved_step_0 = retrieved_process.explicit_steps[0]
 358         self.assertEqual(retrieved_step_0.step_process_id, 2)
 359         self.assertEqual(retrieved_step_0.owner_id, 1)
 360         self.assertEqual(retrieved_step_0.parent_step_id, None)
 361         retrieved_step_1 = retrieved_process.explicit_steps[1]
 362         self.assertEqual(retrieved_step_1.step_process_id, 3)
 363         self.assertEqual(retrieved_step_1.owner_id, 1)
 364         self.assertEqual(retrieved_step_1.parent_step_id, None)
 365         # post sub-step to step
 366         form_data_1[f'step_{retrieved_step_0.id_}_process_id'] = [3]
 367         form_data_1[f'new_step_to_{retrieved_step_0.id_}'] = [3]
 368         self.post_process(1, form_data_1)
 369         retrieved_process = Process.by_id(self.db_conn, 1)
 370         self.assertEqual(len(retrieved_process.explicit_steps), 3)
 371         retrieved_step_0 = retrieved_process.explicit_steps[1]
 372         self.assertEqual(retrieved_step_0.step_process_id, 2)
 373         self.assertEqual(retrieved_step_0.owner_id, 1)
 374         self.assertEqual(retrieved_step_0.parent_step_id, None)
 375         retrieved_step_1 = retrieved_process.explicit_steps[0]
 376         self.assertEqual(retrieved_step_1.step_process_id, 3)
 377         self.assertEqual(retrieved_step_1.owner_id, 1)
 378         self.assertEqual(retrieved_step_1.parent_step_id, None)
 379         retrieved_step_2 = retrieved_process.explicit_steps[2]
 380         self.assertEqual(retrieved_step_2.step_process_id, 3)
 381         self.assertEqual(retrieved_step_2.owner_id, 1)
 382         self.assertEqual(retrieved_step_2.parent_step_id, retrieved_step_1.id_)
 383
 384     def test_do_GET(self) -> None:
 385         """Test /process and /processes response codes."""
 386         self.check_get('/process', 200)
 387         self.check_get('/process?id=', 200)
 388         self.check_get('/process?id=1', 200)
 389         self.check_get_defaults('/process')
 390         self.check_get('/processes', 200)
 391
 392     def test_fail_GET_process(self) -> None:
 393         """Test invalid GET /process params."""
 394         # check for invalid IDs
 395         self.check_get('/process?id=foo', 400)
 396         self.check_get('/process?id=0', 500)
 397         # check we catch invalid base64
 398         self.check_get('/process?title_b64=foo', 400)
 399         # check failure on references to unknown processes; we create Process
 400         # of ID=1 here so we know the 404 comes from step_to=2 etc. (that tie
 401         # the Process displayed by /process to others), not from not finding
 402         # the main Process itself
 403         self.post_process(1)
 404         self.check_get('/process?id=1&step_to=2', 404)
 405         self.check_get('/process?id=1&has_step=2', 404)
 406
 407     @classmethod
 408     def GET_processes_dict(cls, procs: list[dict[str, object]]
 409                            ) -> dict[str, object]:
 410         """Return JSON of GET /processes to expect."""
 411         library = {'Process': cls.as_refs(procs)} if procs else {}
 412         d: dict[str, object] = {'processes': cls.as_id_list(procs),
 413                                 'sort_by': 'title',
 414                                 'pattern': '',
 415                                 '_library': library}
 416         return d
 417
 418     @staticmethod
 419     def procstep_as_dict(id_: int,
 420                          owner_id: int,
 421                          step_process_id: int,
 422                          parent_step_id: int | None = None
 423                          ) -> dict[str, object]:
 424         """Return JSON of Process to expect."""
 425         return {'id': id_,
 426                 'owner_id': owner_id,
 427                 'step_process_id': step_process_id,
 428                 'parent_step_id': parent_step_id}
 429
 430     def test_GET_processes(self) -> None:
 431         """Test GET /processes."""
 432         # pylint: disable=too-many-statements
 433         # test empty result on empty DB, default-settings on empty params
 434         expected = self.GET_processes_dict([])
 435         self.check_json_get('/processes', expected)
 436         # test on meaningless non-empty params (incl. entirely un-used key),
 437         # that 'sort_by' default to 'title' (even if set to something else, as
 438         # long as without handler) and 'pattern' get preserved
 439         expected['pattern'] = 'bar'  # preserved despite zero effect!
 440         url = '/processes?sort_by=foo&pattern=bar&foo=x'
 441         self.check_json_get(url, expected)
 442         # test non-empty result, automatic (positive) sorting by title
 443         post1: dict[str, Any]
 444         post2: dict[str, Any]
 445         post3: dict[str, Any]
 446         post1 = {'title': 'foo', 'description': 'oof', 'effort': 1.0}
 447         post2 = {'title': 'bar', 'description': 'rab', 'effort': 1.1}
 448         post2['new_top_step'] = 1
 449         post3 = {'title': 'baz', 'description': 'zab', 'effort': 0.9}
 450         post3['new_top_step'] = 1
 451         self.post_process(1, post1)
 452         self.post_process(2, post2)
 453         self.post_process(3, post3)
 454         post3['new_top_step'] = 2
 455         post3['keep_step'] = 2
 456         post3['steps'] = [2]
 457         post3['step_2_process_id'] = 1
 458         self.post_process(3, post3)
 459         proc1 = self.proc_as_dict(1, post1['title'],
 460                                   post1['description'], post1['effort'])
 461         proc2 = self.proc_as_dict(2, post2['title'],
 462                                   post2['description'], post2['effort'])
 463         proc3 = self.proc_as_dict(3, post3['title'],
 464                                   post3['description'], post3['effort'])
 465         proc2['explicit_steps'] = [1]
 466         proc3['explicit_steps'] = [2, 3]
 467         step1 = self.procstep_as_dict(1, 2, 1)
 468         step2 = self.procstep_as_dict(2, 3, 1)
 469         step3 = self.procstep_as_dict(3, 3, 2)
 470         expected = self.GET_processes_dict([proc2, proc3, proc1])
 471         assert isinstance(expected['_library'], dict)
 472         expected['_library']['ProcessStep'] = self.as_refs([step1, step2,
 473                                                             step3])
 474         self.check_json_get('/processes', expected)
 475         # test other sortings
 476         expected['sort_by'] = '-title'
 477         expected['processes'] = self.as_id_list([proc1, proc3, proc2])
 478         self.check_json_get('/processes?sort_by=-title', expected)
 479         expected['sort_by'] = 'effort'
 480         expected['processes'] = self.as_id_list([proc3, proc1, proc2])
 481         self.check_json_get('/processes?sort_by=effort', expected)
 482         expected['sort_by'] = '-effort'
 483         expected['processes'] = self.as_id_list([proc2, proc1, proc3])
 484         self.check_json_get('/processes?sort_by=-effort', expected)
 485         expected['sort_by'] = 'steps'
 486         expected['processes'] = self.as_id_list([proc1, proc2, proc3])
 487         self.check_json_get('/processes?sort_by=steps', expected)
 488         expected['sort_by'] = '-steps'
 489         expected['processes'] = self.as_id_list([proc3, proc2, proc1])
 490         self.check_json_get('/processes?sort_by=-steps', expected)
 491         expected['sort_by'] = 'owners'
 492         expected['processes'] = self.as_id_list([proc3, proc2, proc1])
 493         self.check_json_get('/processes?sort_by=owners', expected)
 494         expected['sort_by'] = '-owners'
 495         expected['processes'] = self.as_id_list([proc1, proc2, proc3])
 496         self.check_json_get('/processes?sort_by=-owners', expected)
 497         # test pattern matching on title
 498         expected = self.GET_processes_dict([proc2, proc3])
 499         assert isinstance(expected['_library'], dict)
 500         expected['pattern'] = 'ba'
 501         expected['_library']['ProcessStep'] = self.as_refs([step1, step2,
 502                                                             step3])
 503         self.check_json_get('/processes?pattern=ba', expected)
 504         # test pattern matching on description
 505         expected['processes'] = self.as_id_list([proc1])
 506         expected['_library'] = {'Process': self.as_refs([proc1])}
 507         expected['pattern'] = 'of'
 508         self.check_json_get('/processes?pattern=of', expected)