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