summaryrefslogtreecommitdiffstats
path: root/bitbake/lib/bb/tests/event.py
blob: 9229b63d4796ef92a8d60b82e476e3bf27643844 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
#
# BitBake Tests for the Event implementation (event.py)
#
# Copyright (C) 2017 Intel Corporation
#
# SPDX-License-Identifier: GPL-2.0-only
#

import unittest
import bb
import logging
import bb.compat
import bb.event
import importlib
import threading
import time
import pickle
from unittest.mock import Mock
from unittest.mock import call
from bb.msg import BBLogFormatter


class EventQueueStubBase(object):
    """ Base class for EventQueueStub classes """
    def __init__(self):
        self.event_calls = []
        return

    def _store_event_data_string(self, event):
        if isinstance(event, logging.LogRecord):
            formatter = BBLogFormatter("%(levelname)s: %(message)s")
            self.event_calls.append(formatter.format(event))
        else:
            self.event_calls.append(bb.event.getName(event))
        return


class EventQueueStub(EventQueueStubBase):
    """ Class used as specification for UI event handler queue stub objects """
    def __init__(self):
        super(EventQueueStub, self).__init__()

    def send(self, event):
        super(EventQueueStub, self)._store_event_data_string(event)


class PickleEventQueueStub(EventQueueStubBase):
    """ Class used as specification for UI event handler queue stub objects
        with sendpickle method """
    def __init__(self):
        super(PickleEventQueueStub, self).__init__()

    def sendpickle(self, pickled_event):
        event = pickle.loads(pickled_event)
        super(PickleEventQueueStub, self)._store_event_data_string(event)


class UIClientStub(object):
    """ Class used as specification for UI event handler stub objects """
    def __init__(self):
        self.event = None


class EventHandlingTest(unittest.TestCase):
    """ Event handling test class """


    def setUp(self):
        self._test_process = Mock()
        ui_client1 = UIClientStub()
        ui_client2 = UIClientStub()
        self._test_ui1 = Mock(wraps=ui_client1)
        self._test_ui2 = Mock(wraps=ui_client2)
        importlib.reload(bb.event)

    def _create_test_handlers(self):
        """ Method used to create a test handler ordered dictionary """
        test_handlers = bb.compat.OrderedDict()
        test_handlers["handler1"] = self._test_process.handler1
        test_handlers["handler2"] = self._test_process.handler2
        return test_handlers

    def test_class_handlers(self):
        """ Test set_class_handlers and get_class_handlers methods """
        test_handlers = self._create_test_handlers()
        bb.event.set_class_handlers(test_handlers)
        self.assertEqual(test_handlers,
                         bb.event.get_class_handlers())

    def test_handlers(self):
        """ Test set_handlers and get_handlers """
        test_handlers = self._create_test_handlers()
        bb.event.set_handlers(test_handlers)
        self.assertEqual(test_handlers,
                         bb.event.get_handlers())

    def test_clean_class_handlers(self):
        """ Test clean_class_handlers method """
        cleanDict = bb.compat.OrderedDict()
        self.assertEqual(cleanDict,
                         bb.event.clean_class_handlers())

    def test_register(self):
        """ Test register method for class handlers """
        result = bb.event.register("handler", self._test_process.handler)
        self.assertEqual(result, bb.event.Registered)
        handlers_dict = bb.event.get_class_handlers()
        self.assertIn("handler", handlers_dict)

    def test_already_registered(self):
        """ Test detection of an already registed class handler """
        bb.event.register("handler", self._test_process.handler)
        handlers_dict = bb.event.get_class_handlers()
        self.assertIn("handler", handlers_dict)
        result = bb.event.register("handler", self._test_process.handler)
        self.assertEqual(result, bb.event.AlreadyRegistered)

    def test_register_from_string(self):
        """ Test register method receiving code in string """
        result = bb.event.register("string_handler", "    return True")
        self.assertEqual(result, bb.event.Registered)
        handlers_dict = bb.event.get_class_handlers()
        self.assertIn("string_handler", handlers_dict)

    def test_register_with_mask(self):
        """ Test register method with event masking """
        mask = ["bb.event.OperationStarted",
                "bb.event.OperationCompleted"]
        result = bb.event.register("event_handler",
                                   self._test_process.event_handler,
                                   mask)
        self.assertEqual(result, bb.event.Registered)
        handlers_dict = bb.event.get_class_handlers()
        self.assertIn("event_handler", handlers_dict)

    def test_remove(self):
        """ Test remove method for class handlers """
        test_handlers = self._create_test_handlers()
        bb.event.set_class_handlers(test_handlers)
        count = len(test_handlers)
        bb.event.remove("handler1", None)
        test_handlers = bb.event.get_class_handlers()
        self.assertEqual(len(test_handlers), count - 1)
        with self.assertRaises(KeyError):
            bb.event.remove("handler1", None)

    def test_execute_handler(self):
        """ Test execute_handler method for class handlers """
        mask = ["bb.event.OperationProgress"]
        result = bb.event.register("event_handler",
                                   self._test_process.event_handler,
                                   mask)
        self.assertEqual(result, bb.event.Registered)
        event = bb.event.OperationProgress(current=10, total=100)
        bb.event.execute_handler("event_handler",
                                 self._test_process.event_handler,
                                 event,
                                 None)
        self._test_process.event_handler.assert_called_once_with(event)

    def test_fire_class_handlers(self):
        """ Test fire_class_handlers method """
        mask = ["bb.event.OperationStarted"]
        result = bb.event.register("event_handler1",
                                   self._test_process.event_handler1,
                                   mask)
        self.assertEqual(result, bb.event.Registered)
        result = bb.event.register("event_handler2",
                                   self._test_process.event_handler2,
                                   "*")
        self.assertEqual(result, bb.event.Registered)
        event1 = bb.event.OperationStarted()
        event2 = bb.event.OperationCompleted(total=123)
        bb.event.fire_class_handlers(event1, None)
        bb.event.fire_class_handlers(event2, None)
        bb.event.fire_class_handlers(event2, None)
        expected_event_handler1 = [call(event1)]
        expected_event_handler2 = [call(event1),
                                   call(event2),
                                   call(event2)]
        self.assertEqual(self._test_process.event_handler1.call_args_list,
                         expected_event_handler1)
        self.assertEqual(self._test_process.event_handler2.call_args_list,
                         expected_event_handler2)

    def test_class_handler_filters(self):
        """ Test filters for class handlers """
        mask = ["bb.event.OperationStarted"]
        result = bb.event.register("event_handler1",
                                   self._test_process.event_handler1,
                                   mask)
        self.assertEqual(result, bb.event.Registered)
        result = bb.event.register("event_handler2",
                                   self._test_process.event_handler2,
                                   "*")
        self.assertEqual(result, bb.event.Registered)
        bb.event.set_eventfilter(
            lambda name, handler, event, d :
            name == 'event_handler2' and
            bb.event.getName(event) == "OperationStarted")
        event1 = bb.event.OperationStarted()
        event2 = bb.event.OperationCompleted(total=123)
        bb.event.fire_class_handlers(event1, None)
        bb.event.fire_class_handlers(event2, None)
        bb.event.fire_class_handlers(event2, None)
        expected_event_handler1 = []
        expected_event_handler2 = [call(event1)]
        self.assertEqual(self._test_process.event_handler1.call_args_list,
                         expected_event_handler1)
        self.assertEqual(self._test_process.event_handler2.call_args_list,
                         expected_event_handler2)

    def test_change_handler_event_mapping(self):
        """ Test changing the event mapping for class handlers """
        event1 = bb.event.OperationStarted()
        event2 = bb.event.OperationCompleted(total=123)

        # register handler for all events
        result = bb.event.register("event_handler1",
                                   self._test_process.event_handler1,
                                   "*")
        self.assertEqual(result, bb.event.Registered)
        bb.event.fire_class_handlers(event1, None)
        bb.event.fire_class_handlers(event2, None)
        expected = [call(event1), call(event2)]
        self.assertEqual(self._test_process.event_handler1.call_args_list,
                         expected)

        # unregister handler and register it only for OperationStarted
        bb.event.remove("event_handler1",
                        self._test_process.event_handler1)
        mask = ["bb.event.OperationStarted"]
        result = bb.event.register("event_handler1",
                                   self._test_process.event_handler1,
                                   mask)
        self.assertEqual(result, bb.event.Registered)
        bb.event.fire_class_handlers(event1, None)
        bb.event.fire_class_handlers(event2, None)
        expected = [call(event1), call(event2), call(event1)]
        self.assertEqual(self._test_process.event_handler1.call_args_list,
                         expected)

        # unregister handler and register it only for OperationCompleted
        bb.event.remove("event_handler1",
                        self._test_process.event_handler1)
        mask = ["bb.event.OperationCompleted"]
        result = bb.event.register("event_handler1",
                                   self._test_process.event_handler1,
                                   mask)
        self.assertEqual(result, bb.event.Registered)
        bb.event.fire_class_handlers(event1, None)
        bb.event.fire_class_handlers(event2, None)
        expected = [call(event1), call(event2), call(event1), call(event2)]
        self.assertEqual(self._test_process.event_handler1.call_args_list,
                         expected)

    def test_register_UIHhandler(self):
        """ Test register_UIHhandler method """
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        self.assertEqual(result, 1)

    def test_UIHhandler_already_registered(self):
        """ Test registering an UIHhandler already existing """
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        self.assertEqual(result, 1)
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        self.assertEqual(result, 2)

    def test_unregister_UIHhandler(self):
        """ Test unregister_UIHhandler method """
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        self.assertEqual(result, 1)
        result = bb.event.unregister_UIHhandler(1)
        self.assertIs(result, None)

    def test_fire_ui_handlers(self):
        """ Test fire_ui_handlers method """
        self._test_ui1.event = Mock(spec_set=EventQueueStub)
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        self.assertEqual(result, 1)
        self._test_ui2.event = Mock(spec_set=PickleEventQueueStub)
        result = bb.event.register_UIHhandler(self._test_ui2, mainui=True)
        self.assertEqual(result, 2)
        event1 = bb.event.OperationStarted()
        bb.event.fire_ui_handlers(event1, None)
        expected = [call(event1)]
        self.assertEqual(self._test_ui1.event.send.call_args_list,
                         expected)
        expected = [call(pickle.dumps(event1))]
        self.assertEqual(self._test_ui2.event.sendpickle.call_args_list,
                         expected)

    def test_ui_handler_mask_filter(self):
        """ Test filters for UI handlers """
        mask = ["bb.event.OperationStarted"]
        debug_domains = {}
        self._test_ui1.event = Mock(spec_set=EventQueueStub)
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        bb.event.set_UIHmask(result, logging.INFO, debug_domains, mask)
        self._test_ui2.event = Mock(spec_set=PickleEventQueueStub)
        result = bb.event.register_UIHhandler(self._test_ui2, mainui=True)
        bb.event.set_UIHmask(result, logging.INFO, debug_domains, mask)

        event1 = bb.event.OperationStarted()
        event2 = bb.event.OperationCompleted(total=1)

        bb.event.fire_ui_handlers(event1, None)
        bb.event.fire_ui_handlers(event2, None)
        expected = [call(event1)]
        self.assertEqual(self._test_ui1.event.send.call_args_list,
                         expected)
        expected = [call(pickle.dumps(event1))]
        self.assertEqual(self._test_ui2.event.sendpickle.call_args_list,
                         expected)

    def test_ui_handler_log_filter(self):
        """ Test log filters for UI handlers """
        mask = ["*"]
        debug_domains = {'BitBake.Foo': logging.WARNING}

        self._test_ui1.event = EventQueueStub()
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        bb.event.set_UIHmask(result, logging.ERROR, debug_domains, mask)
        self._test_ui2.event = PickleEventQueueStub()
        result = bb.event.register_UIHhandler(self._test_ui2, mainui=True)
        bb.event.set_UIHmask(result, logging.ERROR, debug_domains, mask)

        event1 = bb.event.OperationStarted()
        bb.event.fire_ui_handlers(event1, None)   # All events match

        event_log_handler = bb.event.LogHandler()
        logger = logging.getLogger("BitBake")
        logger.addHandler(event_log_handler)
        logger1 = logging.getLogger("BitBake.Foo")
        logger1.warning("Test warning LogRecord1") # Matches debug_domains level
        logger1.info("Test info LogRecord")        # Filtered out
        logger2 = logging.getLogger("BitBake.Bar")
        logger2.error("Test error LogRecord")      # Matches filter base level
        logger2.warning("Test warning LogRecord2") # Filtered out
        logger.removeHandler(event_log_handler)

        expected = ['OperationStarted',
                    'WARNING: Test warning LogRecord1',
                    'ERROR: Test error LogRecord']
        self.assertEqual(self._test_ui1.event.event_calls, expected)
        self.assertEqual(self._test_ui2.event.event_calls, expected)

    def test_fire(self):
        """ Test fire method used to trigger class and ui event handlers """
        mask = ["bb.event.ConfigParsed"]
        result = bb.event.register("event_handler1",
                                   self._test_process.event_handler1,
                                   mask)

        self._test_ui1.event = Mock(spec_set=EventQueueStub)
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        self.assertEqual(result, 1)

        event1 = bb.event.ConfigParsed()
        bb.event.fire(event1, None)
        expected = [call(event1)]
        self.assertEqual(self._test_process.event_handler1.call_args_list,
                         expected)
        self.assertEqual(self._test_ui1.event.send.call_args_list,
                         expected)

    def test_fire_from_worker(self):
        """ Test fire_from_worker method """
        self._test_ui1.event = Mock(spec_set=EventQueueStub)
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        self.assertEqual(result, 1)
        event1 = bb.event.ConfigParsed()
        bb.event.fire_from_worker(event1, None)
        expected = [call(event1)]
        self.assertEqual(self._test_ui1.event.send.call_args_list,
                         expected)

    def test_worker_fire(self):
        """ Test the triggering of bb.event.worker_fire callback """
        bb.event.worker_fire = Mock()
        event = bb.event.Event()
        bb.event.fire(event, None)
        expected = [call(event, None)]
        self.assertEqual(bb.event.worker_fire.call_args_list, expected)

    def test_print_ui_queue(self):
        """ Test print_ui_queue method """
        event1 = bb.event.OperationStarted()
        event2 = bb.event.OperationCompleted(total=123)
        bb.event.fire(event1, None)
        bb.event.fire(event2, None)
        event_log_handler = bb.event.LogHandler()
        logger = logging.getLogger("BitBake")
        logger.addHandler(event_log_handler)
        logger.info("Test info LogRecord")
        logger.warning("Test warning LogRecord")
        with self.assertLogs("BitBake", level="INFO") as cm:
            bb.event.print_ui_queue()
        logger.removeHandler(event_log_handler)
        self.assertEqual(cm.output,
                         ["INFO:BitBake:Test info LogRecord",
                          "WARNING:BitBake:Test warning LogRecord"])

    def _set_threadlock_test_mockups(self):
        """ Create UI event handler mockups used in enable and disable
            threadlock tests """
        def ui1_event_send(event):
            if type(event) is bb.event.ConfigParsed:
                self._threadlock_test_calls.append("w1_ui1")
            if type(event) is bb.event.OperationStarted:
                self._threadlock_test_calls.append("w2_ui1")
            time.sleep(2)

        def ui2_event_send(event):
            if type(event) is bb.event.ConfigParsed:
                self._threadlock_test_calls.append("w1_ui2")
            if type(event) is bb.event.OperationStarted:
                self._threadlock_test_calls.append("w2_ui2")
            time.sleep(2)

        self._threadlock_test_calls = []
        self._test_ui1.event = EventQueueStub()
        self._test_ui1.event.send = ui1_event_send
        result = bb.event.register_UIHhandler(self._test_ui1, mainui=True)
        self.assertEqual(result, 1)
        self._test_ui2.event = EventQueueStub()
        self._test_ui2.event.send = ui2_event_send
        result = bb.event.register_UIHhandler(self._test_ui2, mainui=True)
        self.assertEqual(result, 2)

    def _set_and_run_threadlock_test_workers(self):
        """ Create and run the workers used to trigger events in enable and
            disable threadlock tests """
        worker1 = threading.Thread(target=self._thread_lock_test_worker1)
        worker2 = threading.Thread(target=self._thread_lock_test_worker2)
        worker1.start()
        time.sleep(1)
        worker2.start()
        worker1.join()
        worker2.join()

    def _thread_lock_test_worker1(self):
        """ First worker used to fire the ConfigParsed event for enable and
            disable threadlocks tests """
        bb.event.fire(bb.event.ConfigParsed(), None)

    def _thread_lock_test_worker2(self):
        """ Second worker used to fire the OperationStarted event for enable
            and disable threadlocks tests """
        bb.event.fire(bb.event.OperationStarted(), None)

    def test_enable_threadlock(self):
        """ Test enable_threadlock method """
        self._set_threadlock_test_mockups()
        bb.event.enable_threadlock()
        self._set_and_run_threadlock_test_workers()
        # Calls to UI handlers should be in order as all the registered
        # handlers for the event coming from the first worker should be
        # called before processing the event from the second worker.
        self.assertEqual(self._threadlock_test_calls,
                         ["w1_ui1", "w1_ui2", "w2_ui1", "w2_ui2"])


    def test_disable_threadlock(self):
        """ Test disable_threadlock method """
        self._set_threadlock_test_mockups()
        bb.event.disable_threadlock()
        self._set_and_run_threadlock_test_workers()
        # Calls to UI handlers should be intertwined together. Thanks to the
        # delay in the registered handlers for the event coming from the first
        # worker, the event coming from the second worker starts being
        # processed before finishing handling the first worker event.
        self.assertEqual(self._threadlock_test_calls,
                         ["w1_ui1", "w2_ui1", "w1_ui2", "w2_ui2"])


class EventClassesTest(unittest.TestCase):
    """ Event classes test class """

    _worker_pid = 54321

    def setUp(self):
        bb.event.worker_pid = EventClassesTest._worker_pid

    def test_Event(self):
        """ Test the Event base class """
        event = bb.event.Event()
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_HeartbeatEvent(self):
        """ Test the HeartbeatEvent class """
        time = 10
        event = bb.event.HeartbeatEvent(time)
        self.assertEqual(event.time, time)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_OperationStarted(self):
        """ Test OperationStarted event class """
        msg = "Foo Bar"
        event = bb.event.OperationStarted(msg)
        self.assertEqual(event.msg, msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_OperationCompleted(self):
        """ Test OperationCompleted event class """
        msg = "Foo Bar"
        total = 123
        event = bb.event.OperationCompleted(total, msg)
        self.assertEqual(event.msg, msg)
        self.assertEqual(event.total, total)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_OperationProgress(self):
        """ Test OperationProgress event class """
        msg = "Foo Bar"
        total = 123
        current = 111
        event = bb.event.OperationProgress(current, total, msg)
        self.assertEqual(event.msg, msg + ": %s/%s" % (current, total))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ConfigParsed(self):
        """ Test the ConfigParsed class """
        event = bb.event.ConfigParsed()
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_MultiConfigParsed(self):
        """ Test MultiConfigParsed event class """
        mcdata = {"foobar": "Foo Bar"}
        event = bb.event.MultiConfigParsed(mcdata)
        self.assertEqual(event.mcdata, mcdata)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_RecipeEvent(self):
        """ Test RecipeEvent event base class """
        callback = lambda a: 2 * a
        event = bb.event.RecipeEvent(callback)
        self.assertEqual(event.fn(1), callback(1))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_RecipePreFinalise(self):
        """ Test RecipePreFinalise event class """
        callback = lambda a: 2 * a
        event = bb.event.RecipePreFinalise(callback)
        self.assertEqual(event.fn(1), callback(1))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_RecipeTaskPreProcess(self):
        """ Test RecipeTaskPreProcess event class """
        callback = lambda a: 2 * a
        tasklist = [("foobar", callback)]
        event = bb.event.RecipeTaskPreProcess(callback, tasklist)
        self.assertEqual(event.fn(1), callback(1))
        self.assertEqual(event.tasklist, tasklist)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_RecipeParsed(self):
        """ Test RecipeParsed event base class """
        callback = lambda a: 2 * a
        event = bb.event.RecipeParsed(callback)
        self.assertEqual(event.fn(1), callback(1))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_BuildBase(self):
        """ Test base class for bitbake build events """
        name = "foo"
        pkgs = ["bar"]
        failures = 123
        event = bb.event.BuildBase(name, pkgs, failures)
        self.assertEqual(event.name, name)
        self.assertEqual(event.pkgs, pkgs)
        self.assertEqual(event.getFailures(), failures)
        name = event.name = "bar"
        pkgs = event.pkgs = ["foo"]
        self.assertEqual(event.name, name)
        self.assertEqual(event.pkgs, pkgs)
        self.assertEqual(event.getFailures(), failures)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_BuildInit(self):
        """ Test class for bitbake build invocation events """
        event = bb.event.BuildInit()
        self.assertEqual(event.name, None)
        self.assertEqual(event.pkgs, [])
        self.assertEqual(event.getFailures(), 0)
        name = event.name = "bar"
        pkgs = event.pkgs = ["foo"]
        self.assertEqual(event.name, name)
        self.assertEqual(event.pkgs, pkgs)
        self.assertEqual(event.getFailures(), 0)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_BuildStarted(self):
        """ Test class for build started events """
        name = "foo"
        pkgs = ["bar"]
        failures = 123
        event = bb.event.BuildStarted(name, pkgs, failures)
        self.assertEqual(event.name, name)
        self.assertEqual(event.pkgs, pkgs)
        self.assertEqual(event.getFailures(), failures)
        self.assertEqual(event.msg, "Building Started")
        name = event.name = "bar"
        pkgs = event.pkgs = ["foo"]
        msg = event.msg = "foobar"
        self.assertEqual(event.name, name)
        self.assertEqual(event.pkgs, pkgs)
        self.assertEqual(event.getFailures(), failures)
        self.assertEqual(event.msg, msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_BuildCompleted(self):
        """ Test class for build completed events """
        total = 1000
        name = "foo"
        pkgs = ["bar"]
        failures = 123
        interrupted = 1
        event = bb.event.BuildCompleted(total, name, pkgs, failures,
                                        interrupted)
        self.assertEqual(event.name, name)
        self.assertEqual(event.pkgs, pkgs)
        self.assertEqual(event.getFailures(), failures)
        self.assertEqual(event.msg, "Building Failed")
        event2 = bb.event.BuildCompleted(total, name, pkgs)
        self.assertEqual(event2.name, name)
        self.assertEqual(event2.pkgs, pkgs)
        self.assertEqual(event2.getFailures(), 0)
        self.assertEqual(event2.msg, "Building Succeeded")
        self.assertEqual(event2.pid, EventClassesTest._worker_pid)

    def test_DiskFull(self):
        """ Test DiskFull event class """
        dev = "/dev/foo"
        type = "ext4"
        freespace = "104M"
        mountpoint = "/"
        event = bb.event.DiskFull(dev, type, freespace, mountpoint)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_MonitorDiskEvent(self):
        """ Test MonitorDiskEvent class """
        available_bytes = 10000000
        free_bytes = 90000000
        total_bytes = 1000000000
        du = bb.event.DiskUsageSample(available_bytes, free_bytes,
                                      total_bytes)
        event = bb.event.MonitorDiskEvent(du)
        self.assertEqual(event.disk_usage.available_bytes, available_bytes)
        self.assertEqual(event.disk_usage.free_bytes, free_bytes)
        self.assertEqual(event.disk_usage.total_bytes, total_bytes)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_NoProvider(self):
        """ Test NoProvider event class """
        item = "foobar"
        event1 = bb.event.NoProvider(item)
        self.assertEqual(event1.getItem(), item)
        self.assertEqual(event1.isRuntime(), False)
        self.assertEqual(str(event1), "Nothing PROVIDES 'foobar'")
        runtime = True
        dependees = ["foo", "bar"]
        reasons = None
        close_matches = ["foibar", "footbar"]
        event2 = bb.event.NoProvider(item, runtime, dependees, reasons,
                                     close_matches)
        self.assertEqual(event2.isRuntime(), True)
        expected = ("Nothing RPROVIDES 'foobar' (but foo, bar RDEPENDS"
                    " on or otherwise requires it). Close matches:\n"
                    "  foibar\n"
                    "  footbar")
        self.assertEqual(str(event2), expected)
        reasons = ["Item does not exist on database"]
        close_matches = ["foibar", "footbar"]
        event3 = bb.event.NoProvider(item, runtime, dependees, reasons,
                                     close_matches)
        expected = ("Nothing RPROVIDES 'foobar' (but foo, bar RDEPENDS"
                    " on or otherwise requires it)\n"
                    "Item does not exist on database")
        self.assertEqual(str(event3), expected)
        self.assertEqual(event3.pid, EventClassesTest._worker_pid)

    def test_MultipleProviders(self):
        """ Test MultipleProviders event class """
        item = "foobar"
        candidates = ["foobarv1", "foobars"]
        event1 = bb.event.MultipleProviders(item, candidates)
        self.assertEqual(event1.isRuntime(), False)
        self.assertEqual(event1.getItem(), item)
        self.assertEqual(event1.getCandidates(), candidates)
        expected = ("Multiple providers are available for foobar (foobarv1,"
                    " foobars)\n"
                    "Consider defining a PREFERRED_PROVIDER entry to match "
                    "foobar")
        self.assertEqual(str(event1), expected)
        runtime = True
        event2 = bb.event.MultipleProviders(item, candidates, runtime)
        self.assertEqual(event2.isRuntime(), runtime)
        expected = ("Multiple providers are available for runtime foobar "
                    "(foobarv1, foobars)\n"
                    "Consider defining a PREFERRED_RPROVIDER entry to match "
                    "foobar")
        self.assertEqual(str(event2), expected)
        self.assertEqual(event2.pid, EventClassesTest._worker_pid)

    def test_ParseStarted(self):
        """ Test ParseStarted event class """
        total = 123
        event = bb.event.ParseStarted(total)
        self.assertEqual(event.msg, "Recipe parsing Started")
        self.assertEqual(event.total, total)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ParseCompleted(self):
        """ Test ParseCompleted event class """
        cached = 10
        parsed = 13
        skipped = 7
        virtuals = 2
        masked = 1
        errors = 0
        total = 23
        event = bb.event.ParseCompleted(cached, parsed, skipped, masked,
                                        virtuals, errors, total)
        self.assertEqual(event.msg, "Recipe parsing Completed")
        expected = [cached, parsed, skipped, virtuals, masked, errors,
                    cached + parsed, total]
        actual = [event.cached, event.parsed, event.skipped, event.virtuals,
                  event.masked, event.errors, event.sofar, event.total]
        self.assertEqual(str(actual), str(expected))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ParseProgress(self):
        """ Test ParseProgress event class """
        current = 10
        total = 100
        event = bb.event.ParseProgress(current, total)
        self.assertEqual(event.msg,
                         "Recipe parsing" + ": %s/%s" % (current, total))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_CacheLoadStarted(self):
        """ Test CacheLoadStarted event class """
        total = 123
        event = bb.event.CacheLoadStarted(total)
        self.assertEqual(event.msg, "Loading cache Started")
        self.assertEqual(event.total, total)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_CacheLoadProgress(self):
        """ Test CacheLoadProgress event class """
        current = 10
        total = 100
        event = bb.event.CacheLoadProgress(current, total)
        self.assertEqual(event.msg,
                         "Loading cache" + ": %s/%s" % (current, total))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_CacheLoadCompleted(self):
        """ Test CacheLoadCompleted event class """
        total = 23
        num_entries = 12
        event = bb.event.CacheLoadCompleted(total, num_entries)
        self.assertEqual(event.msg, "Loading cache Completed")
        expected = [total, num_entries]
        actual = [event.total, event.num_entries]
        self.assertEqual(str(actual), str(expected))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_TreeDataPreparationStarted(self):
        """ Test TreeDataPreparationStarted event class """
        event = bb.event.TreeDataPreparationStarted()
        self.assertEqual(event.msg, "Preparing tree data Started")
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_TreeDataPreparationProgress(self):
        """ Test TreeDataPreparationProgress event class """
        current = 10
        total = 100
        event = bb.event.TreeDataPreparationProgress(current, total)
        self.assertEqual(event.msg,
                         "Preparing tree data" + ": %s/%s" % (current, total))
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_TreeDataPreparationCompleted(self):
        """ Test TreeDataPreparationCompleted event class """
        total = 23
        event = bb.event.TreeDataPreparationCompleted(total)
        self.assertEqual(event.msg, "Preparing tree data Completed")
        self.assertEqual(event.total, total)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_DepTreeGenerated(self):
        """ Test DepTreeGenerated event class """
        depgraph = Mock()
        event = bb.event.DepTreeGenerated(depgraph)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_TargetsTreeGenerated(self):
        """ Test TargetsTreeGenerated event class """
        model = Mock()
        event = bb.event.TargetsTreeGenerated(model)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ReachableStamps(self):
        """ Test ReachableStamps event class """
        stamps = [Mock(), Mock()]
        event = bb.event.ReachableStamps(stamps)
        self.assertEqual(event.stamps, stamps)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_FilesMatchingFound(self):
        """ Test FilesMatchingFound event class """
        pattern = "foo.*bar"
        matches = ["foobar"]
        event = bb.event.FilesMatchingFound(pattern, matches)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ConfigFilesFound(self):
        """ Test ConfigFilesFound event class """
        variable = "FOO_BAR"
        values = ["foo", "bar"]
        event = bb.event.ConfigFilesFound(variable, values)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ConfigFilePathFound(self):
        """ Test ConfigFilePathFound event class """
        path = "/foo/bar"
        event = bb.event.ConfigFilePathFound(path)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_message_classes(self):
        """ Test message event classes """
        msg = "foobar foo bar"
        event = bb.event.MsgBase(msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)
        event = bb.event.MsgDebug(msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)
        event = bb.event.MsgNote(msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)
        event = bb.event.MsgWarn(msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)
        event = bb.event.MsgError(msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)
        event = bb.event.MsgFatal(msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)
        event = bb.event.MsgPlain(msg)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_LogExecTTY(self):
        """ Test LogExecTTY event class """
        msg = "foo bar"
        prog = "foo.sh"
        sleep_delay = 10
        retries = 3
        event = bb.event.LogExecTTY(msg, prog, sleep_delay, retries)
        self.assertEqual(event.msg, msg)
        self.assertEqual(event.prog, prog)
        self.assertEqual(event.sleep_delay, sleep_delay)
        self.assertEqual(event.retries, retries)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def _throw_zero_division_exception(self):
        a = 1 / 0
        return

    def _worker_handler(self, event, d):
        self._returned_event = event
        return

    def test_LogHandler(self):
        """ Test LogHandler class """
        logger = logging.getLogger("TestEventClasses")
        logger.propagate = False
        handler = bb.event.LogHandler(logging.INFO)
        logger.addHandler(handler)
        bb.event.worker_fire = self._worker_handler
        try:
            self._throw_zero_division_exception()
        except ZeroDivisionError as ex:
            logger.exception(ex)
        event = self._returned_event
        try:
            pe = pickle.dumps(event)
            newevent = pickle.loads(pe)
        except:
            self.fail('Logged event is not serializable')
        self.assertEqual(event.taskpid, EventClassesTest._worker_pid)

    def test_MetadataEvent(self):
        """ Test MetadataEvent class """
        eventtype = "footype"
        eventdata = {"foo": "bar"}
        event = bb.event.MetadataEvent(eventtype, eventdata)
        self.assertEqual(event.type, eventtype)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ProcessStarted(self):
        """ Test ProcessStarted class """
        processname = "foo"
        total = 9783128974
        event = bb.event.ProcessStarted(processname, total)
        self.assertEqual(event.processname, processname)
        self.assertEqual(event.total, total)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ProcessProgress(self):
        """ Test ProcessProgress class """
        processname = "foo"
        progress = 243224
        event = bb.event.ProcessProgress(processname, progress)
        self.assertEqual(event.processname, processname)
        self.assertEqual(event.progress, progress)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_ProcessFinished(self):
        """ Test ProcessFinished class """
        processname = "foo"
        total = 1242342344
        event = bb.event.ProcessFinished(processname)
        self.assertEqual(event.processname, processname)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_SanityCheck(self):
        """ Test SanityCheck class """
        event1 = bb.event.SanityCheck()
        self.assertEqual(event1.generateevents, True)
        self.assertEqual(event1.pid, EventClassesTest._worker_pid)
        generateevents = False
        event2 = bb.event.SanityCheck(generateevents)
        self.assertEqual(event2.generateevents, generateevents)
        self.assertEqual(event2.pid, EventClassesTest._worker_pid)

    def test_SanityCheckPassed(self):
        """ Test SanityCheckPassed class """
        event = bb.event.SanityCheckPassed()
        self.assertEqual(event.pid, EventClassesTest._worker_pid)

    def test_SanityCheckFailed(self):
        """ Test SanityCheckFailed class """
        msg = "The sanity test failed."
        event1 = bb.event.SanityCheckFailed(msg)
        self.assertEqual(event1.pid, EventClassesTest._worker_pid)
        network_error = True
        event2 = bb.event.SanityCheckFailed(msg, network_error)
        self.assertEqual(event2.pid, EventClassesTest._worker_pid)

    def test_network_event_classes(self):
        """ Test network event classes """
        event1 = bb.event.NetworkTest()
        generateevents = False
        self.assertEqual(event1.pid, EventClassesTest._worker_pid)
        event2 = bb.event.NetworkTest(generateevents)
        self.assertEqual(event2.pid, EventClassesTest._worker_pid)
        event3 = bb.event.NetworkTestPassed()
        self.assertEqual(event3.pid, EventClassesTest._worker_pid)
        event4 = bb.event.NetworkTestFailed()
        self.assertEqual(event4.pid, EventClassesTest._worker_pid)

    def test_FindSigInfoResult(self):
        """ Test FindSigInfoResult event class """
        result = [Mock()]
        event = bb.event.FindSigInfoResult(result)
        self.assertEqual(event.result, result)
        self.assertEqual(event.pid, EventClassesTest._worker_pid)