1 """Test Processes module."""
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
10 class TestsSansDB(TestCaseSansDB):
11 """Module tests not requiring DB setup."""
12 checked_class = Process
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,
22 class TestsWithDB(TestCaseWithDB):
23 """Module tests requiring DB setup."""
24 checked_class = Process
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]:
33 def p_of_conditions(self) -> tuple[Process, list[Condition],
34 list[Condition], list[Condition]]:
35 """Return Process and its three Condition sets."""
37 c1, c2, c3 = Condition(None), Condition(None), Condition(None)
38 for c in [c1, c2, c3]:
40 assert isinstance(c1.id_, int)
41 assert isinstance(c2.id_, int)
42 assert isinstance(c3.id_, int)
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)])
53 return p, set_1, set_2, set_3
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))
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()
69 assert isinstance(p.id_, int)
70 for row in self.db_conn.row_where(self.checked_class.table_name,
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))
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,
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_,
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,
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)
160 def test_Process_conditions(self) -> None:
161 """Test setting Process.conditions/enables/disables."""
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])
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])
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])
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)
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,
218 def setUp(self) -> None:
221 self.p1.save(self.db_conn)
223 def test_remove(self) -> None:
224 """Test .remove and unsetting of owner's .explicit_steps entry."""
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([])
236 class TestsWithServer(TestCaseWithServer):
237 """Module tests against our HTTP server/handler (and database)."""
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},
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',
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')
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)
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_)
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)
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
404 self.check_get('/process?id=1&step_to=2', 404)
405 self.check_get('/process?id=1&has_step=2', 404)
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),
419 def procstep_as_dict(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."""
426 'owner_id': owner_id,
427 'step_process_id': step_process_id,
428 'parent_step_id': parent_step_id}
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
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,
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,
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)