← Back to branch summary

~alisonken1/openlp/pjlink2-f

« back to all changes in this revision

Viewing changes to tests/functional/openlp_plugins/songs/test_songbeamerimport.py

  • Committer: Tim Bentley
  • Author(s): Tomas Groth
  • Date: 2017-05-17 20:30:47 UTC
  • mfrom: (2587.3.78 chords)
  • Revision ID: tim.bentley@gmail.com-20170517203047-o11dl9bfu3re2tu0
Added support for chords in Chord Pro format (using brackets), with support for chord transposing and 3 different notations.
Added support for import of song in ChordPro file format
Added support for importing chords and verseorder from songbeamer.
Add support for export and import of chords in openlyrics
Added support for importing chords from opensong.
Added support for importing chords from videopsalm.
Added support for printing chords.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/functional/openlp_plugins/songs/test_songbeamerimport.py
42
42
        self.importer_module_name = 'songbeamer'
43
43
        super(TestSongBeamerFileImport, self).__init__(*args, **kwargs)
44
44
 
45
 
    def test_song_import(self):
46
 
        """
47
 
        Test that loading an OpenSong file works correctly on various files
48
 
        """
 
45
    @patch('openlp.plugins.songs.lib.importers.songbeamer.Settings')
 
46
    def test_song_import(self, mocked_settings):
 
47
        """
 
48
        Test that loading an SongBeamer file works correctly on various files
 
49
        """
 
50
        # Mock out the settings - always return False
 
51
        mocked_returned_settings = MagicMock()
 
52
        mocked_returned_settings.value.side_effect = lambda value: True if value == 'songs/enable chords' else False
 
53
        mocked_settings.return_value = mocked_returned_settings
 
54
        self.file_import([os.path.join(TEST_PATH, 'Amazing Grace.sng')],
 
55
                         self.load_external_result_data(os.path.join(TEST_PATH, 'Amazing Grace.json')))
49
56
        self.file_import([os.path.join(TEST_PATH, 'Lobsinget dem Herrn.sng')],
50
57
                         self.load_external_result_data(os.path.join(TEST_PATH, 'Lobsinget dem Herrn.json')))
 
58
        self.file_import([os.path.join(TEST_PATH, 'When I Call On You.sng')],
 
59
                         self.load_external_result_data(os.path.join(TEST_PATH, 'When I Call On You.json')))
51
60
 
52
61
    def test_cp1252_encoded_file(self):
53
62
        """
66
75
        Create the registry
67
76
        """
68
77
        Registry.create()
 
78
        self.song_import_patcher = patch('openlp.plugins.songs.lib.importers.songbeamer.SongImport')
 
79
        self.song_import_patcher.start()
 
80
        mocked_manager = MagicMock()
 
81
        self.importer = SongBeamerImport(mocked_manager, filenames=[])
 
82
 
 
83
    def tearDown(self):
 
84
        """
 
85
        Clean up
 
86
        """
 
87
        self.song_import_patcher.stop()
69
88
 
70
89
    def test_create_importer(self):
71
90
        """
85
104
        """
86
105
        Test SongBeamerImport.do_import handles different invalid import_source values
87
106
        """
88
 
        # GIVEN: A mocked out SongImport class, and a mocked out "manager"
89
 
        with patch('openlp.plugins.songs.lib.importers.songbeamer.SongImport'):
90
 
            mocked_manager = MagicMock()
91
 
            mocked_import_wizard = MagicMock()
92
 
            importer = SongBeamerImport(mocked_manager, filenames=[])
93
 
            importer.import_wizard = mocked_import_wizard
94
 
            importer.stop_import_flag = True
95
 
 
96
 
            # WHEN: Import source is not a list
97
 
            for source in ['not a list', 0]:
98
 
                importer.import_source = source
99
 
 
100
 
                # THEN: do_import should return none and the progress bar maximum should not be set.
101
 
                self.assertIsNone(importer.do_import(), 'do_import should return None when import_source is not a list')
102
 
                self.assertEqual(mocked_import_wizard.progress_bar.setMaximum.called, False,
103
 
                                 'setMaxium on import_wizard.progress_bar should not have been called')
 
107
        # GIVEN: A mocked out import wizard
 
108
        mocked_import_wizard = MagicMock()
 
109
        self.importer.import_wizard = mocked_import_wizard
 
110
        self.importer.stop_import_flag = True
 
111
 
 
112
        # WHEN: Import source is not a list
 
113
        for source in ['not a list', 0]:
 
114
            self.importer.import_source = source
 
115
 
 
116
            # THEN: do_import should return none and the progress bar maximum should not be set.
 
117
            self.assertIsNone(self.importer.do_import(),
 
118
                              'do_import should return None when import_source is not a list')
 
119
            self.assertEqual(mocked_import_wizard.progress_bar.setMaximum.called, False,
 
120
                             'setMaxium on import_wizard.progress_bar should not have been called')
104
121
 
105
122
    def test_valid_import_source(self):
106
123
        """
107
124
        Test SongBeamerImport.do_import handles different invalid import_source values
108
125
        """
109
 
        # GIVEN: A mocked out SongImport class, and a mocked out "manager"
110
 
        with patch('openlp.plugins.songs.lib.importers.songbeamer.SongImport'):
111
 
            mocked_manager = MagicMock()
112
 
            mocked_import_wizard = MagicMock()
113
 
            importer = SongBeamerImport(mocked_manager, filenames=[])
114
 
            importer.import_wizard = mocked_import_wizard
115
 
            importer.stop_import_flag = True
116
 
 
117
 
            # WHEN: Import source is a list
118
 
            importer.import_source = ['List', 'of', 'files']
119
 
 
120
 
            # THEN: do_import should return none and the progress bar setMaximum should be called with the length of
121
 
            #       import_source.
122
 
            self.assertIsNone(importer.do_import(),
123
 
                              'do_import should return None when import_source is a list and stop_import_flag is True')
124
 
            mocked_import_wizard.progress_bar.setMaximum.assert_called_with(len(importer.import_source))
 
126
        # GIVEN: A mocked out import wizard
 
127
        mocked_import_wizard = MagicMock()
 
128
        self.importer.import_wizard = mocked_import_wizard
 
129
        self.importer.stop_import_flag = True
 
130
 
 
131
        # WHEN: Import source is a list
 
132
        self.importer.import_source = ['List', 'of', 'files']
 
133
 
 
134
        # THEN: do_import should return none and the progress bar setMaximum should be called with the length of
 
135
        #       import_source.
 
136
        self.assertIsNone(self.importer.do_import(),
 
137
                          'do_import should return None when import_source is a list and stop_import_flag is True')
 
138
        mocked_import_wizard.progress_bar.setMaximum.assert_called_with(len(self.importer.import_source))
125
139
 
126
140
    def test_check_verse_marks(self):
127
141
        """
130
144
 
131
145
        # GIVEN: line with unnumbered verse-type
132
146
        line = 'Refrain'
133
 
        self.current_verse_type = None
 
147
        self.importer.current_verse_type = None
134
148
        # WHEN: line is being checked for verse marks
135
 
        result = SongBeamerImport.check_verse_marks(self, line)
136
 
        # THEN: we should get back true and c as self.current_verse_type
 
149
        result = self.importer.check_verse_marks(line)
 
150
        # THEN: we should get back true and c as self.importer.current_verse_type
137
151
        self.assertTrue(result, 'Versemark for <Refrain> should be found, value true')
138
 
        self.assertEqual(self.current_verse_type, 'c', '<Refrain> should be interpreted as <c>')
 
152
        self.assertEqual(self.importer.current_verse_type, 'c', '<Refrain> should be interpreted as <c>')
139
153
 
140
154
        # GIVEN: line with unnumbered verse-type and trailing space
141
155
        line = 'ReFrain '
142
 
        self.current_verse_type = None
 
156
        self.importer.current_verse_type = None
143
157
        # WHEN: line is being checked for verse marks
144
 
        result = SongBeamerImport.check_verse_marks(self, line)
145
 
        # THEN: we should get back true and c as self.current_verse_type
 
158
        result = self.importer.check_verse_marks(line)
 
159
        # THEN: we should get back true and c as self.importer.current_verse_type
146
160
        self.assertTrue(result, 'Versemark for <ReFrain > should be found, value true')
147
 
        self.assertEqual(self.current_verse_type, 'c', '<ReFrain > should be interpreted as <c>')
 
161
        self.assertEqual(self.importer.current_verse_type, 'c', '<ReFrain > should be interpreted as <c>')
148
162
 
149
163
        # GIVEN: line with numbered verse-type
150
164
        line = 'VersE 1'
151
 
        self.current_verse_type = None
 
165
        self.importer.current_verse_type = None
152
166
        # WHEN: line is being checked for verse marks
153
 
        result = SongBeamerImport.check_verse_marks(self, line)
154
 
        # THEN: we should get back true and v1 as self.current_verse_type
 
167
        result = self.importer.check_verse_marks(line)
 
168
        # THEN: we should get back true and v1 as self.importer.current_verse_type
155
169
        self.assertTrue(result, 'Versemark for <VersE 1> should be found, value true')
156
 
        self.assertEqual(self.current_verse_type, 'v1', u'<VersE 1> should be interpreted as <v1>')
 
170
        self.assertEqual(self.importer.current_verse_type, 'v1', u'<VersE 1> should be interpreted as <v1>')
157
171
 
158
172
        # GIVEN: line with special unnumbered verse-mark (used in Songbeamer to allow usage of non-supported tags)
159
173
        line = '$$M=special'
160
 
        self.current_verse_type = None
 
174
        self.importer.current_verse_type = None
161
175
        # WHEN: line is being checked for verse marks
162
 
        result = SongBeamerImport.check_verse_marks(self, line)
163
 
        # THEN: we should get back true and o as self.current_verse_type
 
176
        result = self.importer.check_verse_marks(line)
 
177
        # THEN: we should get back true and o as self.importer.current_verse_type
164
178
        self.assertTrue(result, 'Versemark for <$$M=special> should be found, value true')
165
 
        self.assertEqual(self.current_verse_type, 'o', u'<$$M=special> should be interpreted as <o>')
 
179
        self.assertEqual(self.importer.current_verse_type, 'o', u'<$$M=special> should be interpreted as <o>')
166
180
 
167
181
        # GIVEN: line with song-text with 3 words
168
182
        line = 'Jesus my saviour'
169
 
        self.current_verse_type = None
 
183
        self.importer.current_verse_type = None
170
184
        # WHEN: line is being checked for verse marks
171
 
        result = SongBeamerImport.check_verse_marks(self, line)
172
 
        # THEN: we should get back false and none as self.current_verse_type
 
185
        result = self.importer.check_verse_marks(line)
 
186
        # THEN: we should get back false and none as self.importer.current_verse_type
173
187
        self.assertFalse(result, 'No versemark for <Jesus my saviour> should be found, value false')
174
 
        self.assertIsNone(self.current_verse_type, '<Jesus my saviour> should be interpreted as none versemark')
 
188
        self.assertIsNone(self.importer.current_verse_type,
 
189
                          '<Jesus my saviour> should be interpreted as none versemark')
175
190
 
176
191
        # GIVEN: line with song-text with 2 words
177
192
        line = 'Praise him'
178
 
        self.current_verse_type = None
 
193
        self.importer.current_verse_type = None
179
194
        # WHEN: line is being checked for verse marks
180
 
        result = SongBeamerImport.check_verse_marks(self, line)
181
 
        # THEN: we should get back false and none as self.current_verse_type
 
195
        result = self.importer.check_verse_marks(line)
 
196
        # THEN: we should get back false and none as self.importer.current_verse_type
182
197
        self.assertFalse(result, 'No versemark for <Praise him> should be found, value false')
183
 
        self.assertIsNone(self.current_verse_type, '<Praise him> should be interpreted as none versemark')
 
198
        self.assertIsNone(self.importer.current_verse_type, '<Praise him> should be interpreted as none versemark')
184
199
 
185
200
        # GIVEN: line with only a space (could occur, nothing regular)
186
201
        line = ' '
187
 
        self.current_verse_type = None
 
202
        self.importer.current_verse_type = None
188
203
        # WHEN: line is being checked for verse marks
189
 
        result = SongBeamerImport.check_verse_marks(self, line)
190
 
        # THEN: we should get back false and none as self.current_verse_type
 
204
        result = self.importer.check_verse_marks(line)
 
205
        # THEN: we should get back false and none as self.importer.current_verse_type
191
206
        self.assertFalse(result, 'No versemark for < > should be found, value false')
192
 
        self.assertIsNone(self.current_verse_type, '< > should be interpreted as none versemark')
 
207
        self.assertIsNone(self.importer.current_verse_type, '< > should be interpreted as none versemark')
193
208
 
194
209
        # GIVEN: blank line (could occur, nothing regular)
195
210
        line = ''
196
 
        self.current_verse_type = None
 
211
        self.importer.current_verse_type = None
197
212
        # WHEN: line is being checked for verse marks
198
 
        result = SongBeamerImport.check_verse_marks(self, line)
199
 
        # THEN: we should get back false and none as self.current_verse_type
 
213
        result = self.importer.check_verse_marks(line)
 
214
        # THEN: we should get back false and none as self.importer.current_verse_type
200
215
        self.assertFalse(result, 'No versemark for <> should be found, value false')
201
 
        self.assertIsNone(self.current_verse_type, '<> should be interpreted as none versemark')
 
216
        self.assertIsNone(self.importer.current_verse_type, '<> should be interpreted as none versemark')
202
217
 
203
218
    def test_verse_marks_defined_in_lowercase(self):
204
219
        """