← Back to branch summary

~tomasgroth/openlp/portable-path

« back to all changes in this revision

Viewing changes to tests/functional/openlp_core/ui/media/test_vlcplayer.py

  • Committer: Tomas Groth
  • Date: 2019-04-30 19:02:42 UTC
  • mfrom: (2829.2.32 openlp)
  • Revision ID: tomasgroth@yahoo.dk-20190430190242-6zwjk8724tyux70m
trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/functional/openlp_core/ui/media/test_vlcplayer.py
4
4
###############################################################################
5
5
# OpenLP - Open Source Lyrics Projection                                      #
6
6
# --------------------------------------------------------------------------- #
7
 
# Copyright (c) 2008-2018 OpenLP Developers                                   #
 
7
# Copyright (c) 2008-2019 OpenLP Developers                                   #
8
8
# --------------------------------------------------------------------------- #
9
9
# This program is free software; you can redistribute it and/or modify it     #
10
10
# under the terms of the GNU General Public License as published by the Free  #
26
26
import sys
27
27
from datetime import timedelta
28
28
from unittest import TestCase, skip
29
 
from unittest.mock import MagicMock, patch, call
 
29
from unittest.mock import MagicMock, call, patch
30
30
 
31
31
from openlp.core.common.registry import Registry
32
32
from openlp.core.ui.media import MediaState, MediaType
138
138
        mocked_vlc = MagicMock()
139
139
        mocked_vlc.Instance.return_value = mocked_instance
140
140
        mocked_get_vlc.return_value = mocked_vlc
141
 
        mocked_display = MagicMock()
142
 
        mocked_display.has_audio = False
143
 
        mocked_display.controller.is_live = True
144
 
        mocked_display.size.return_value = (10, 10)
 
141
        mocked_output_display = MagicMock()
 
142
        mocked_controller = MagicMock()
 
143
        mocked_controller.is_live = True
 
144
        mocked_output_display.size.return_value = (10, 10)
145
145
        vlc_player = VlcPlayer(None)
146
146
 
147
147
        # WHEN: setup() is run
148
 
        vlc_player.setup(mocked_display)
 
148
        vlc_player.setup(mocked_output_display, mocked_controller)
149
149
 
150
150
        # THEN: The VLC widget should be set up correctly
151
 
        assert mocked_display.vlc_widget == mocked_qframe
 
151
        assert mocked_output_display.vlc_widget == mocked_qframe
152
152
        mocked_qframe.setFrameStyle.assert_called_with(1)
153
153
        mocked_settings.value.assert_called_with('advanced/hide mouse')
154
 
        mocked_vlc.Instance.assert_called_with('--no-video-title-show --no-audio --no-video-title-show '
155
 
                                               '--mouse-hide-timeout=0')
156
 
        assert mocked_display.vlc_instance == mocked_instance
 
154
        mocked_vlc.Instance.assert_called_with('--no-video-title-show --mouse-hide-timeout=0')
 
155
        assert mocked_output_display.vlc_instance == mocked_instance
157
156
        mocked_instance.media_player_new.assert_called_with()
158
 
        assert mocked_display.vlc_media_player == mocked_media_player_new
159
 
        mocked_display.size.assert_called_with()
 
157
        assert mocked_output_display.vlc_media_player == mocked_media_player_new
 
158
        mocked_output_display.size.assert_called_with()
160
159
        mocked_qframe.resize.assert_called_with((10, 10))
161
160
        mocked_qframe.raise_.assert_called_with()
162
161
        mocked_qframe.hide.assert_called_with()
188
187
        mocked_vlc = MagicMock()
189
188
        mocked_vlc.Instance.return_value = mocked_instance
190
189
        mocked_get_vlc.return_value = mocked_vlc
191
 
        mocked_display = MagicMock()
192
 
        mocked_display.has_audio = True
193
 
        mocked_display.controller.is_live = True
194
 
        mocked_display.size.return_value = (10, 10)
 
190
        mocked_output_display = MagicMock()
 
191
        mocked_controller = MagicMock()
 
192
        mocked_controller.is_live = True
 
193
        mocked_output_display.size.return_value = (10, 10)
195
194
        vlc_player = VlcPlayer(None)
196
195
 
197
196
        # WHEN: setup() is run
198
 
        vlc_player.setup(mocked_display)
 
197
        vlc_player.setup(mocked_output_display, mocked_controller)
199
198
 
200
199
        # THEN: The VLC instance should be created with the correct options
201
200
        mocked_vlc.Instance.assert_called_with('--no-video-title-show --mouse-hide-timeout=0')
226
225
        mocked_vlc = MagicMock()
227
226
        mocked_vlc.Instance.return_value = mocked_instance
228
227
        mocked_get_vlc.return_value = mocked_vlc
229
 
        mocked_display = MagicMock()
230
 
        mocked_display.has_audio = False
231
 
        mocked_display.controller.is_live = True
232
 
        mocked_display.size.return_value = (10, 10)
 
228
        mocked_output_display = MagicMock()
 
229
        mocked_controller = MagicMock()
 
230
        mocked_controller.is_live = True
 
231
        mocked_output_display.size.return_value = (10, 10)
233
232
        vlc_player = VlcPlayer(None)
234
233
 
235
234
        # WHEN: setup() is run
236
 
        vlc_player.setup(mocked_display)
 
235
        vlc_player.setup(mocked_output_display, mocked_controller)
237
236
 
238
237
        # THEN: The VLC instance should be created with the correct options
239
 
        mocked_vlc.Instance.assert_called_with('--no-video-title-show --no-audio --no-video-title-show')
 
238
        mocked_vlc.Instance.assert_called_with('--no-video-title-show')
240
239
 
241
240
    @patch('openlp.core.ui.media.vlcplayer.is_win')
242
241
    @patch('openlp.core.ui.media.vlcplayer.is_macosx')
263
262
        mocked_vlc = MagicMock()
264
263
        mocked_vlc.Instance.return_value = mocked_instance
265
264
        mocked_get_vlc.return_value = mocked_vlc
266
 
        mocked_display = MagicMock()
267
 
        mocked_display.has_audio = False
268
 
        mocked_display.controller.is_live = True
269
 
        mocked_display.size.return_value = (10, 10)
 
265
        mocked_output_display = MagicMock()
 
266
        mocked_controller = MagicMock()
 
267
        mocked_controller.is_live = True
 
268
        mocked_output_display.size.return_value = (10, 10)
270
269
        vlc_player = VlcPlayer(None)
271
270
 
272
271
        # WHEN: setup() is run
273
 
        vlc_player.setup(mocked_display)
 
272
        vlc_player.setup(mocked_output_display, mocked_controller)
274
273
 
275
274
        # THEN: set_hwnd should be called
276
275
        mocked_media_player_new.set_hwnd.assert_called_with(2)
300
299
        mocked_vlc = MagicMock()
301
300
        mocked_vlc.Instance.return_value = mocked_instance
302
301
        mocked_get_vlc.return_value = mocked_vlc
303
 
        mocked_display = MagicMock()
304
 
        mocked_display.has_audio = False
305
 
        mocked_display.controller.is_live = True
306
 
        mocked_display.size.return_value = (10, 10)
 
302
        mocked_output_display = MagicMock()
 
303
        mocked_controller = MagicMock()
 
304
        mocked_controller.is_live = True
 
305
        mocked_output_display.size.return_value = (10, 10)
307
306
        vlc_player = VlcPlayer(None)
308
307
 
309
308
        # WHEN: setup() is run
310
 
        vlc_player.setup(mocked_display)
 
309
        vlc_player.setup(mocked_output_display, mocked_controller)
311
310
 
312
311
        # THEN: set_nsobject should be called
313
312
        mocked_media_player_new.set_nsobject.assert_called_with(2)
353
352
        mocked_normcase.side_effect = lambda x: x
354
353
        mocked_vlc = MagicMock()
355
354
        mocked_get_vlc.return_value = mocked_vlc
356
 
        mocked_controller = MagicMock()
357
 
        mocked_controller.media_info.volume = 100
358
 
        mocked_controller.media_info.media_type = MediaType.Video
359
 
        mocked_controller.media_info.file_info.absoluteFilePath.return_value = media_path
 
355
        mocked_display = MagicMock()
 
356
        mocked_display.media_info.volume = 100
 
357
        mocked_display.media_info.media_type = MediaType.Video
 
358
        mocked_display.media_info.file_info.absoluteFilePath.return_value = media_path
360
359
        mocked_vlc_media = MagicMock()
361
360
        mocked_media = MagicMock()
362
361
        mocked_media.get_duration.return_value = 10000
363
 
        mocked_display = MagicMock()
364
 
        mocked_display.controller = mocked_controller
365
362
        mocked_display.vlc_instance.media_new_path.return_value = mocked_vlc_media
366
363
        mocked_display.vlc_media_player.get_media.return_value = mocked_media
367
364
        vlc_player = VlcPlayer(None)
368
365
 
369
366
        # WHEN: A video is loaded into VLC
370
367
        with patch.object(vlc_player, 'volume') as mocked_volume:
371
 
            result = vlc_player.load(mocked_display)
 
368
            result = vlc_player.load(mocked_display, media_path)
372
369
 
373
370
        # THEN: The video should be loaded
374
371
        mocked_normcase.assert_called_with(media_path)
392
389
        mocked_normcase.side_effect = lambda x: x
393
390
        mocked_vlc = MagicMock()
394
391
        mocked_get_vlc.return_value = mocked_vlc
395
 
        mocked_controller = MagicMock()
396
 
        mocked_controller.media_info.volume = 100
397
 
        mocked_controller.media_info.media_type = MediaType.CD
398
 
        mocked_controller.media_info.file_info.absoluteFilePath.return_value = media_path
399
 
        mocked_controller.media_info.title_track = 1
 
392
        mocked_display = MagicMock()
 
393
        mocked_display.media_info.volume = 100
 
394
        mocked_display.media_info.media_type = MediaType.CD
 
395
        mocked_display.media_info.title_track = 1
400
396
        mocked_vlc_media = MagicMock()
401
397
        mocked_media = MagicMock()
402
398
        mocked_media.get_duration.return_value = 10000
403
 
        mocked_display = MagicMock()
404
 
        mocked_display.controller = mocked_controller
405
399
        mocked_display.vlc_instance.media_new_location.return_value = mocked_vlc_media
406
400
        mocked_display.vlc_media_player.get_media.return_value = mocked_media
407
401
        mocked_subitems = MagicMock()
412
406
 
413
407
        # WHEN: An audio CD is loaded into VLC
414
408
        with patch.object(vlc_player, 'volume') as mocked_volume, \
415
 
                patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait:
416
 
            result = vlc_player.load(mocked_display)
 
409
                patch.object(vlc_player, 'media_state_wait'):
 
410
            result = vlc_player.load(mocked_display, media_path)
417
411
 
418
412
        # THEN: The video should be loaded
419
413
        mocked_normcase.assert_called_with(media_path)
437
431
        mocked_normcase.side_effect = lambda x: x
438
432
        mocked_vlc = MagicMock()
439
433
        mocked_get_vlc.return_value = mocked_vlc
440
 
        mocked_controller = MagicMock()
441
 
        mocked_controller.media_info.volume = 100
442
 
        mocked_controller.media_info.media_type = MediaType.CD
443
 
        mocked_controller.media_info.file_info.absoluteFilePath.return_value = media_path
444
 
        mocked_controller.media_info.title_track = 1
 
434
        mocked_display = MagicMock()
 
435
        mocked_display.media_info.volume = 100
 
436
        mocked_display.media_info.media_type = MediaType.CD
 
437
        mocked_display.media_info.file_info.absoluteFilePath.return_value = media_path
 
438
        mocked_display.media_info.title_track = 1
445
439
        mocked_vlc_media = MagicMock()
446
440
        mocked_media = MagicMock()
447
441
        mocked_media.get_duration.return_value = 10000
448
 
        mocked_display = MagicMock()
449
 
        mocked_display.controller = mocked_controller
450
442
        mocked_display.vlc_instance.media_new_location.return_value = mocked_vlc_media
451
443
        mocked_display.vlc_media_player.get_media.return_value = mocked_media
452
444
        mocked_subitems = MagicMock()
457
449
 
458
450
        # WHEN: An audio CD is loaded into VLC
459
451
        with patch.object(vlc_player, 'volume') as mocked_volume, \
460
 
                patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait:
461
 
            result = vlc_player.load(mocked_display)
 
452
                patch.object(vlc_player, 'media_state_wait'):
 
453
            result = vlc_player.load(mocked_display, media_path)
462
454
 
463
455
        # THEN: The video should be loaded
464
456
        mocked_normcase.assert_called_with(media_path)
482
474
        mocked_normcase.side_effect = lambda x: x
483
475
        mocked_vlc = MagicMock()
484
476
        mocked_get_vlc.return_value = mocked_vlc
485
 
        mocked_controller = MagicMock()
486
 
        mocked_controller.media_info.volume = 100
487
 
        mocked_controller.media_info.media_type = MediaType.CD
488
 
        mocked_controller.media_info.file_info.absoluteFilePath.return_value = media_path
489
 
        mocked_controller.media_info.title_track = 1
 
477
        mocked_display = MagicMock()
 
478
        mocked_display.media_info.volume = 100
 
479
        mocked_display.media_info.media_type = MediaType.CD
 
480
        mocked_display.media_info.file_info.absoluteFilePath.return_value = media_path
 
481
        mocked_display.media_info.title_track = 1
490
482
        mocked_vlc_media = MagicMock()
491
483
        mocked_media = MagicMock()
492
484
        mocked_media.get_duration.return_value = 10000
493
 
        mocked_display = MagicMock()
494
 
        mocked_display.controller = mocked_controller
495
485
        mocked_display.vlc_instance.media_new_location.return_value = mocked_vlc_media
496
486
        mocked_display.vlc_media_player.get_media.return_value = mocked_media
497
487
        mocked_subitems = MagicMock()
501
491
        vlc_player = VlcPlayer(None)
502
492
 
503
493
        # WHEN: An audio CD is loaded into VLC
504
 
        with patch.object(vlc_player, 'volume') as mocked_volume, \
505
 
                patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait:
506
 
            result = vlc_player.load(mocked_display)
 
494
        with patch.object(vlc_player, 'volume'), patch.object(vlc_player, 'media_state_wait'):
 
495
            result = vlc_player.load(mocked_display, media_path)
507
496
 
508
497
        # THEN: The video should be loaded
509
498
        mocked_normcase.assert_called_with(media_path)
612
601
        mocked_threading.Thread.return_value = mocked_thread
613
602
        mocked_vlc = MagicMock()
614
603
        mocked_get_vlc.return_value = mocked_vlc
615
 
        mocked_controller = MagicMock()
616
 
        mocked_controller.media_info.start_time = 0
617
 
        mocked_controller.media_info.media_type = MediaType.Video
618
 
        mocked_controller.media_info.volume = 100
 
604
        mocked_display = MagicMock()
619
605
        mocked_media = MagicMock()
620
606
        mocked_media.get_duration.return_value = 50000
621
 
        mocked_display = MagicMock()
622
 
        mocked_display.controller = mocked_controller
623
 
        mocked_display.vlc_media_player.get_media.return_value = mocked_media
 
607
        mocked_output_display = MagicMock()
 
608
        mocked_output_display.media_info.start_time = 0
 
609
        mocked_output_display.media_info.media_type = MediaType.Video
 
610
        mocked_output_display.media_info.volume = 100
 
611
        mocked_output_display.vlc_media_player.get_media.return_value = mocked_media
624
612
        vlc_player = VlcPlayer(None)
625
 
        vlc_player.set_state(MediaState.Paused, mocked_display)
 
613
        vlc_player.set_state(MediaState.Paused, mocked_output_display)
626
614
 
627
615
        # WHEN: play() is called
628
616
        with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait, \
629
617
                patch.object(vlc_player, 'volume') as mocked_volume:
630
618
            mocked_media_state_wait.return_value = True
631
 
            result = vlc_player.play(mocked_display)
 
619
            result = vlc_player.play(mocked_display, mocked_output_display)
632
620
 
633
621
        # THEN: A bunch of things should happen to play the media
634
622
        mocked_thread.start.assert_called_with()
635
 
        mocked_volume.assert_called_with(mocked_display, 100)
 
623
        mocked_volume.assert_called_with(mocked_output_display, 100)
636
624
        assert MediaState.Playing == vlc_player.get_live_state()
637
 
        mocked_display.vlc_widget.raise_.assert_called_with()
 
625
        mocked_output_display.vlc_widget.raise_.assert_called_with()
638
626
        assert result is True, 'The value returned from play() should be True'
639
627
 
640
628
    @patch('openlp.core.ui.media.vlcplayer.threading')
650
638
        mocked_get_vlc.return_value = mocked_vlc
651
639
        mocked_controller = MagicMock()
652
640
        mocked_controller.media_info.start_time = 0
653
 
        mocked_display = MagicMock()
654
 
        mocked_display.controller = mocked_controller
 
641
        mocked_output_display = MagicMock()
655
642
        vlc_player = VlcPlayer(None)
656
 
        vlc_player.set_state(MediaState.Paused, mocked_display)
 
643
        vlc_player.set_state(MediaState.Paused, mocked_output_display)
657
644
 
658
645
        # WHEN: play() is called
659
646
        with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait, \
660
 
                patch.object(vlc_player, 'volume') as mocked_volume:
 
647
                patch.object(vlc_player, 'volume'):
661
648
            mocked_media_state_wait.return_value = False
662
 
            result = vlc_player.play(mocked_display)
 
649
            result = vlc_player.play(mocked_controller, mocked_output_display)
663
650
 
664
651
        # THEN: A thread should be started, but the method should return False
665
652
        mocked_thread.start.assert_called_with()
677
664
        mocked_vlc = MagicMock()
678
665
        mocked_get_vlc.return_value = mocked_vlc
679
666
        mocked_controller = MagicMock()
680
 
        mocked_controller.media_info.start_time = 0
681
 
        mocked_controller.media_info.end_time = 50
682
 
        mocked_controller.media_info.media_type = MediaType.DVD
683
 
        mocked_controller.media_info.volume = 100
684
 
        mocked_controller.media_info.title_track = 1
685
 
        mocked_controller.media_info.audio_track = 1
686
 
        mocked_controller.media_info.subtitle_track = 1
687
 
        mocked_display = MagicMock()
688
 
        mocked_display.controller = mocked_controller
 
667
        mocked_output_display = MagicMock()
 
668
        mocked_output_display.media_info.start_time = 0
 
669
        mocked_output_display.media_info.end_time = 50
 
670
        mocked_output_display.media_info.media_type = MediaType.DVD
 
671
        mocked_output_display.media_info.volume = 100
 
672
        mocked_output_display.media_info.title_track = 1
 
673
        mocked_output_display.media_info.audio_track = 1
 
674
        mocked_output_display.media_info.subtitle_track = 1
689
675
        vlc_player = VlcPlayer(None)
690
 
        vlc_player.set_state(MediaState.Paused, mocked_display)
 
676
        vlc_player.set_state(MediaState.Paused, mocked_output_display)
691
677
 
692
678
        # WHEN: play() is called
693
 
        with patch.object(vlc_player, 'media_state_wait', return_value=True) as mocked_media_state_wait, \
 
679
        with patch.object(vlc_player, 'media_state_wait', return_value=True), \
694
680
                patch.object(vlc_player, 'volume') as mocked_volume, \
695
681
                patch.object(vlc_player, 'get_live_state', return_value=MediaState.Loaded):
696
 
            result = vlc_player.play(mocked_display)
 
682
            result = vlc_player.play(mocked_controller, mocked_output_display)
697
683
 
698
684
        # THEN: A bunch of things should happen to play the media
699
685
        mocked_thread.start.assert_called_with()
700
 
        mocked_display.vlc_media_player.set_title.assert_called_with(1)
701
 
        mocked_display.vlc_media_player.play.assert_called_with()
702
 
        mocked_display.vlc_media_player.audio_set_track.assert_called_with(1)
703
 
        mocked_display.vlc_media_player.video_set_spu.assert_called_with(1)
704
 
        mocked_volume.assert_called_with(mocked_display, 100)
 
686
        mocked_output_display.vlc_media_player.set_title.assert_called_with(1)
 
687
        mocked_output_display.vlc_media_player.play.assert_called_with()
 
688
        mocked_output_display.vlc_media_player.audio_set_track.assert_called_with(1)
 
689
        mocked_output_display.vlc_media_player.video_set_spu.assert_called_with(1)
 
690
        mocked_volume.assert_called_with(mocked_output_display, 100)
705
691
        assert MediaState.Playing == vlc_player.get_live_state()
706
 
        mocked_display.vlc_widget.raise_.assert_called_with()
 
692
        mocked_output_display.vlc_widget.raise_.assert_called_with()
707
693
        assert result is True, 'The value returned from play() should be True'
708
694
 
709
695
    @patch('openlp.core.ui.media.vlcplayer.get_vlc')
938
924
        mocked_controller.media_info.end_time = 300
939
925
        mocked_controller.seek_slider.isSliderDown.return_value = False
940
926
        mocked_display = MagicMock()
941
 
        mocked_display.controller = mocked_controller
942
927
        mocked_display.vlc_media.get_state.return_value = 1
943
928
        mocked_display.vlc_media_player.get_time.return_value = 400000
944
929
        vlc_player = VlcPlayer(None)
946
931
        # WHEN: update_ui() is called
947
932
        with patch.object(vlc_player, 'stop') as mocked_stop, \
948
933
                patch.object(vlc_player, 'set_visible') as mocked_set_visible:
949
 
            vlc_player.update_ui(mocked_display)
 
934
            vlc_player.update_ui(mocked_controller, mocked_display)
950
935
 
951
936
        # THEN: Certain methods should be called
952
937
        mocked_stop.assert_called_with(mocked_display)
971
956
        mocked_controller.media_info.end_time = 300
972
957
        mocked_controller.seek_slider.isSliderDown.return_value = False
973
958
        mocked_display = MagicMock()
974
 
        mocked_display.controller = mocked_controller
975
959
        mocked_display.vlc_media.get_state.return_value = 1
976
 
        mocked_display.vlc_media_player.get_time.return_value = 400
 
960
        mocked_display.vlc_media_player.get_time.return_value = 300
977
961
        mocked_display.controller.media_info.media_type = MediaType.DVD
978
962
        vlc_player = VlcPlayer(None)
979
963
 
980
964
        # WHEN: update_ui() is called
981
 
        with patch.object(vlc_player, 'stop') as mocked_stop, \
982
 
                patch.object(vlc_player, 'set_visible') as mocked_set_visible:
983
 
            vlc_player.update_ui(mocked_display)
 
965
        with patch.object(vlc_player, 'stop') as mocked_stop:
 
966
            vlc_player.update_ui(mocked_controller, mocked_display)
984
967
 
985
968
        # THEN: Certain methods should be called
986
969
        mocked_stop.assert_called_with(mocked_display)
987
 
        assert 2 == mocked_stop.call_count
 
970
        assert 1 == mocked_stop.call_count
988
971
        mocked_display.vlc_media_player.get_time.assert_called_with()
989
 
        mocked_set_visible.assert_called_with(mocked_display, False)
990
972
        mocked_controller.seek_slider.setSliderPosition.assert_called_with(300)
991
973
        expected_calls = [call(True), call(False)]
992
974
        assert expected_calls == mocked_controller.seek_slider.blockSignals.call_args_list