1 | # Project imports |
||
2 | from imp import load_source |
||
3 | import mock |
||
4 | import os |
||
5 | import sys |
||
6 | import shutil |
||
7 | |||
8 | from click.testing import CliRunner |
||
9 | from nose.plugins.skip import SkipTest |
||
10 | from nose.tools import assert_raises |
||
11 | from six import text_type, unichr as six_unichr |
||
12 | from tempfile import gettempdir |
||
13 | |||
14 | sys.path.insert(0, os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))) |
||
15 | sys.path.insert(0, os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))))) |
||
16 | |||
17 | import helper |
||
18 | elodie = load_source('elodie', os.path.abspath('{}/../../elodie.py'.format(os.path.dirname(os.path.realpath(__file__))))) |
||
19 | |||
20 | from elodie.config import load_config |
||
21 | from elodie.localstorage import Db |
||
22 | from elodie.media.audio import Audio |
||
23 | from elodie.media.photo import Photo |
||
24 | from elodie.media.text import Text |
||
25 | from elodie.media.video import Video |
||
26 | |||
27 | os.environ['TZ'] = 'GMT' |
||
28 | |||
29 | def test_import_file_text(): |
||
30 | temporary_folder, folder = helper.create_working_folder() |
||
31 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
32 | |||
33 | origin = '%s/valid.txt' % folder |
||
34 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
35 | |||
36 | helper.reset_dbs() |
||
37 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
38 | helper.restore_dbs() |
||
39 | |||
40 | shutil.rmtree(folder) |
||
41 | shutil.rmtree(folder_destination) |
||
42 | |||
43 | assert helper.path_tz_fix(os.path.join('2016-04-Apr','London','2016-04-07_11-15-26-valid-sample-title.txt')) in dest_path, dest_path |
||
44 | |||
45 | def test_import_file_audio(): |
||
46 | temporary_folder, folder = helper.create_working_folder() |
||
47 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
48 | |||
49 | origin = '%s/audio.m4a' % folder |
||
50 | shutil.copyfile(helper.get_file('audio.m4a'), origin) |
||
51 | |||
52 | helper.reset_dbs() |
||
53 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
54 | helper.restore_dbs() |
||
55 | |||
56 | shutil.rmtree(folder) |
||
57 | shutil.rmtree(folder_destination) |
||
58 | |||
59 | assert helper.path_tz_fix(os.path.join('2016-01-Jan','Houston','2016-01-04_05-28-15-audio.m4a')) in dest_path, dest_path |
||
60 | |||
61 | def test_import_file_photo(): |
||
62 | temporary_folder, folder = helper.create_working_folder() |
||
63 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
64 | |||
65 | origin = '%s/plain.jpg' % folder |
||
66 | shutil.copyfile(helper.get_file('plain.jpg'), origin) |
||
67 | |||
68 | helper.reset_dbs() |
||
69 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
70 | helper.restore_dbs() |
||
71 | |||
72 | shutil.rmtree(folder) |
||
73 | shutil.rmtree(folder_destination) |
||
74 | |||
75 | assert helper.path_tz_fix(os.path.join('2015-12-Dec','Unknown Location','2015-12-05_00-59-26-plain.jpg')) in dest_path, dest_path |
||
76 | |||
77 | def test_import_file_video(): |
||
78 | temporary_folder, folder = helper.create_working_folder() |
||
79 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
80 | |||
81 | origin = '%s/video.mov' % folder |
||
82 | shutil.copyfile(helper.get_file('video.mov'), origin) |
||
83 | |||
84 | helper.reset_dbs() |
||
85 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
86 | helper.restore_dbs() |
||
87 | |||
88 | shutil.rmtree(folder) |
||
89 | shutil.rmtree(folder_destination) |
||
90 | |||
91 | assert helper.path_tz_fix(os.path.join('2015-01-Jan','California','2015-01-19_12-45-11-video.mov')) in dest_path, dest_path |
||
92 | |||
93 | View Code Duplication | def test_import_file_path_utf8_encoded_ascii_checkmark(): |
|
0 ignored issues
–
show
Duplication
introduced
by
Loading history...
|
|||
94 | temporary_folder, folder = helper.create_working_folder() |
||
95 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
96 | |||
97 | origin = text_type(folder)+u'/unicode\u2713filename.txt' |
||
98 | # encode the unicode string to ascii |
||
99 | origin = origin.encode('utf-8') |
||
100 | |||
101 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
102 | |||
103 | helper.reset_dbs() |
||
104 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
105 | helper.restore_dbs() |
||
106 | |||
107 | shutil.rmtree(folder) |
||
108 | shutil.rmtree(folder_destination) |
||
109 | |||
110 | assert helper.path_tz_fix(os.path.join('2016-04-Apr','London',u'2016-04-07_11-15-26-unicode\u2713filename-sample-title.txt')) in dest_path, dest_path |
||
111 | |||
112 | View Code Duplication | def test_import_file_path_unicode_checkmark(): |
|
0 ignored issues
–
show
|
|||
113 | temporary_folder, folder = helper.create_working_folder() |
||
114 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
115 | |||
116 | origin = text_type(folder)+u'/unicode\u2713filename.txt' |
||
117 | |||
118 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
119 | |||
120 | helper.reset_dbs() |
||
121 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
122 | helper.restore_dbs() |
||
123 | |||
124 | shutil.rmtree(folder) |
||
125 | shutil.rmtree(folder_destination) |
||
126 | |||
127 | assert helper.path_tz_fix(os.path.join('2016-04-Apr','London',u'2016-04-07_11-15-26-unicode\u2713filename-sample-title.txt')) in dest_path, dest_path |
||
128 | |||
129 | View Code Duplication | def test_import_file_path_utf8_encoded_ascii_latin_nbsp(): |
|
0 ignored issues
–
show
|
|||
130 | temporary_folder, folder = helper.create_working_folder() |
||
131 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
132 | |||
133 | origin = text_type(folder)+u'/unicode'+six_unichr(160)+u'filename.txt' |
||
134 | # encode the unicode string to ascii |
||
135 | origin = origin.encode('utf-8') |
||
136 | |||
137 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
138 | |||
139 | helper.reset_dbs() |
||
140 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
141 | helper.restore_dbs() |
||
142 | |||
143 | shutil.rmtree(folder) |
||
144 | shutil.rmtree(folder_destination) |
||
145 | |||
146 | assert helper.path_tz_fix(os.path.join('2016-04-Apr','London',u'2016-04-07_11-15-26-unicode\xa0filename-sample-title.txt')) in dest_path, dest_path |
||
147 | |||
148 | View Code Duplication | def test_import_file_path_unicode_latin_nbsp(): |
|
0 ignored issues
–
show
|
|||
149 | temporary_folder, folder = helper.create_working_folder() |
||
150 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
151 | |||
152 | origin = text_type(folder)+u'/unicode'+six_unichr(160)+u'filename.txt' |
||
153 | |||
154 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
155 | |||
156 | helper.reset_dbs() |
||
157 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
158 | helper.restore_dbs() |
||
159 | |||
160 | shutil.rmtree(folder) |
||
161 | shutil.rmtree(folder_destination) |
||
162 | |||
163 | assert helper.path_tz_fix(os.path.join('2016-04-Apr','London',u'2016-04-07_11-15-26-unicode\xa0filename-sample-title.txt')) in dest_path, dest_path |
||
164 | |||
165 | View Code Duplication | def test_import_file_allow_duplicate_false(): |
|
0 ignored issues
–
show
|
|||
166 | temporary_folder, folder = helper.create_working_folder() |
||
167 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
168 | |||
169 | origin = '%s/valid.txt' % folder |
||
170 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
171 | |||
172 | helper.reset_dbs() |
||
173 | dest_path1 = elodie.import_file(origin, folder_destination, False, False, False) |
||
174 | dest_path2 = elodie.import_file(origin, folder_destination, False, False, False) |
||
175 | helper.restore_dbs() |
||
176 | |||
177 | shutil.rmtree(folder) |
||
178 | shutil.rmtree(folder_destination) |
||
179 | |||
180 | assert dest_path1 is not None |
||
181 | assert dest_path2 is None |
||
182 | |||
183 | View Code Duplication | def test_import_file_allow_duplicate_true(): |
|
0 ignored issues
–
show
|
|||
184 | temporary_folder, folder = helper.create_working_folder() |
||
185 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
186 | |||
187 | origin = '%s/valid.txt' % folder |
||
188 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
189 | |||
190 | helper.reset_dbs() |
||
191 | dest_path1 = elodie.import_file(origin, folder_destination, False, False, True) |
||
192 | dest_path2 = elodie.import_file(origin, folder_destination, False, False, True) |
||
193 | helper.restore_dbs() |
||
194 | |||
195 | shutil.rmtree(folder) |
||
196 | shutil.rmtree(folder_destination) |
||
197 | |||
198 | assert dest_path1 is not None |
||
199 | assert dest_path2 is not None |
||
200 | assert dest_path1 == dest_path2 |
||
201 | |||
202 | View Code Duplication | def test_import_file_send_to_trash_false(): |
|
0 ignored issues
–
show
|
|||
203 | temporary_folder, folder = helper.create_working_folder() |
||
204 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
205 | |||
206 | origin = '%s/valid.txt' % folder |
||
207 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
208 | |||
209 | helper.reset_dbs() |
||
210 | dest_path1 = elodie.import_file(origin, folder_destination, False, False, False) |
||
211 | assert os.path.isfile(origin), origin |
||
212 | helper.restore_dbs() |
||
213 | |||
214 | shutil.rmtree(folder) |
||
215 | shutil.rmtree(folder_destination) |
||
216 | |||
217 | assert dest_path1 is not None |
||
218 | |||
219 | View Code Duplication | def test_import_file_send_to_trash_true(): |
|
0 ignored issues
–
show
|
|||
220 | raise SkipTest("Temporarily disable send2trash test gh-230") |
||
221 | |||
222 | temporary_folder, folder = helper.create_working_folder() |
||
223 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
224 | |||
225 | origin = '%s/valid.txt' % folder |
||
226 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
227 | |||
228 | helper.reset_dbs() |
||
229 | dest_path1 = elodie.import_file(origin, folder_destination, False, True, False) |
||
230 | assert not os.path.isfile(origin), origin |
||
231 | helper.restore_dbs() |
||
232 | |||
233 | shutil.rmtree(folder) |
||
234 | shutil.rmtree(folder_destination) |
||
235 | |||
236 | assert dest_path1 is not None |
||
237 | |||
238 | View Code Duplication | def test_import_destination_in_source(): |
|
0 ignored issues
–
show
|
|||
239 | temporary_folder, folder = helper.create_working_folder() |
||
240 | folder_destination = '{}/destination'.format(folder) |
||
241 | os.mkdir(folder_destination) |
||
242 | |||
243 | origin = '%s/plain.jpg' % folder |
||
244 | shutil.copyfile(helper.get_file('plain.jpg'), origin) |
||
245 | |||
246 | helper.reset_dbs() |
||
247 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
248 | helper.restore_dbs() |
||
249 | |||
250 | shutil.rmtree(folder) |
||
251 | |||
252 | assert dest_path is None, dest_path |
||
253 | |||
254 | View Code Duplication | def test_import_destination_in_source_gh_287(): |
|
0 ignored issues
–
show
|
|||
255 | temporary_folder, folder = helper.create_working_folder() |
||
256 | folder_destination = '{}-destination'.format(folder) |
||
257 | os.mkdir(folder_destination) |
||
258 | |||
259 | origin = '%s/video.mov' % folder |
||
260 | shutil.copyfile(helper.get_file('video.mov'), origin) |
||
261 | |||
262 | helper.reset_dbs() |
||
263 | dest_path = elodie.import_file(origin, folder_destination, False, False, False) |
||
264 | helper.restore_dbs() |
||
265 | |||
266 | shutil.rmtree(folder) |
||
267 | |||
268 | assert dest_path is not None, dest_path |
||
269 | |||
270 | View Code Duplication | def test_import_invalid_file_exit_code(): |
|
0 ignored issues
–
show
|
|||
271 | temporary_folder, folder = helper.create_working_folder() |
||
272 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
273 | |||
274 | # use a good and bad |
||
275 | origin_invalid = '%s/invalid.jpg' % folder |
||
276 | shutil.copyfile(helper.get_file('invalid.jpg'), origin_invalid) |
||
277 | |||
278 | origin_valid = '%s/valid.jpg' % folder |
||
279 | shutil.copyfile(helper.get_file('plain.jpg'), origin_valid) |
||
280 | |||
281 | helper.reset_dbs() |
||
282 | runner = CliRunner() |
||
283 | result = runner.invoke(elodie._import, ['--destination', folder_destination, origin_invalid, origin_valid]) |
||
284 | helper.restore_dbs() |
||
285 | |||
286 | shutil.rmtree(folder) |
||
287 | shutil.rmtree(folder_destination) |
||
288 | |||
289 | assert result.exit_code == 1, result.exit_code |
||
290 | |||
291 | View Code Duplication | def test_update_location_on_audio(): |
|
0 ignored issues
–
show
|
|||
292 | temporary_folder, folder = helper.create_working_folder() |
||
293 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
294 | |||
295 | origin = '%s/audio.m4a' % folder |
||
296 | shutil.copyfile(helper.get_file('audio.m4a'), origin) |
||
297 | |||
298 | audio = Audio(origin) |
||
299 | metadata = audio.get_metadata() |
||
300 | |||
301 | helper.reset_dbs() |
||
302 | status = elodie.update_location(audio, origin, 'Sunnyvale, CA') |
||
303 | helper.restore_dbs() |
||
304 | |||
305 | audio_processed = Audio(origin) |
||
306 | metadata_processed = audio_processed.get_metadata() |
||
307 | |||
308 | shutil.rmtree(folder) |
||
309 | shutil.rmtree(folder_destination) |
||
310 | |||
311 | assert status == True, status |
||
312 | assert metadata['latitude'] != metadata_processed['latitude'], metadata_processed['latitude'] |
||
313 | assert helper.isclose(metadata_processed['latitude'], 37.36883), metadata_processed['latitude'] |
||
314 | assert helper.isclose(metadata_processed['longitude'], -122.03635), metadata_processed['longitude'] |
||
315 | |||
316 | View Code Duplication | def test_update_location_on_photo(): |
|
0 ignored issues
–
show
|
|||
317 | temporary_folder, folder = helper.create_working_folder() |
||
318 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
319 | |||
320 | origin = '%s/plain.jpg' % folder |
||
321 | shutil.copyfile(helper.get_file('plain.jpg'), origin) |
||
322 | |||
323 | photo = Photo(origin) |
||
324 | metadata = photo.get_metadata() |
||
325 | |||
326 | helper.reset_dbs() |
||
327 | status = elodie.update_location(photo, origin, 'Sunnyvale, CA') |
||
328 | helper.restore_dbs() |
||
329 | |||
330 | photo_processed = Photo(origin) |
||
331 | metadata_processed = photo_processed.get_metadata() |
||
332 | |||
333 | shutil.rmtree(folder) |
||
334 | shutil.rmtree(folder_destination) |
||
335 | |||
336 | assert status == True, status |
||
337 | assert metadata['latitude'] != metadata_processed['latitude'] |
||
338 | assert helper.isclose(metadata_processed['latitude'], 37.36883), metadata_processed['latitude'] |
||
339 | assert helper.isclose(metadata_processed['longitude'], -122.03635), metadata_processed['longitude'] |
||
340 | |||
341 | View Code Duplication | def test_update_location_on_text(): |
|
0 ignored issues
–
show
|
|||
342 | temporary_folder, folder = helper.create_working_folder() |
||
343 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
344 | |||
345 | origin = '%s/text.txt' % folder |
||
346 | shutil.copyfile(helper.get_file('text.txt'), origin) |
||
347 | |||
348 | text = Text(origin) |
||
349 | metadata = text.get_metadata() |
||
350 | |||
351 | helper.reset_dbs() |
||
352 | status = elodie.update_location(text, origin, 'Sunnyvale, CA') |
||
353 | helper.restore_dbs() |
||
354 | |||
355 | text_processed = Text(origin) |
||
356 | metadata_processed = text_processed.get_metadata() |
||
357 | |||
358 | shutil.rmtree(folder) |
||
359 | shutil.rmtree(folder_destination) |
||
360 | |||
361 | assert status == True, status |
||
362 | assert metadata['latitude'] != metadata_processed['latitude'] |
||
363 | assert helper.isclose(metadata_processed['latitude'], 37.36883), metadata_processed['latitude'] |
||
364 | assert helper.isclose(metadata_processed['longitude'], -122.03635), metadata_processed['longitude'] |
||
365 | |||
366 | View Code Duplication | def test_update_location_on_video(): |
|
0 ignored issues
–
show
|
|||
367 | temporary_folder, folder = helper.create_working_folder() |
||
368 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
369 | |||
370 | origin = '%s/video.mov' % folder |
||
371 | shutil.copyfile(helper.get_file('video.mov'), origin) |
||
372 | |||
373 | video = Video(origin) |
||
374 | metadata = video.get_metadata() |
||
375 | |||
376 | helper.reset_dbs() |
||
377 | status = elodie.update_location(video, origin, 'Sunnyvale, CA') |
||
378 | helper.restore_dbs() |
||
379 | |||
380 | video_processed = Video(origin) |
||
381 | metadata_processed = video_processed.get_metadata() |
||
382 | |||
383 | shutil.rmtree(folder) |
||
384 | shutil.rmtree(folder_destination) |
||
385 | |||
386 | assert status == True, status |
||
387 | assert metadata['latitude'] != metadata_processed['latitude'] |
||
388 | assert helper.isclose(metadata_processed['latitude'], 37.36883), metadata_processed['latitude'] |
||
389 | assert helper.isclose(metadata_processed['longitude'], -122.03635), metadata_processed['longitude'] |
||
390 | |||
391 | View Code Duplication | def test_update_time_on_audio(): |
|
0 ignored issues
–
show
|
|||
392 | temporary_folder, folder = helper.create_working_folder() |
||
393 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
394 | |||
395 | origin = '%s/audio.m4a' % folder |
||
396 | shutil.copyfile(helper.get_file('audio.m4a'), origin) |
||
397 | |||
398 | audio = Audio(origin) |
||
399 | metadata = audio.get_metadata() |
||
400 | |||
401 | helper.reset_dbs() |
||
402 | status = elodie.update_time(audio, origin, '2000-01-01 12:00:00') |
||
403 | helper.restore_dbs() |
||
404 | |||
405 | audio_processed = Audio(origin) |
||
406 | metadata_processed = audio_processed.get_metadata() |
||
407 | |||
408 | shutil.rmtree(folder) |
||
409 | shutil.rmtree(folder_destination) |
||
410 | |||
411 | assert status == True, status |
||
412 | assert metadata['date_taken'] != metadata_processed['date_taken'] |
||
413 | assert metadata_processed['date_taken'] == helper.time_convert((2000, 1, 1, 12, 0, 0, 5, 1, 0)), metadata_processed['date_taken'] |
||
414 | |||
415 | View Code Duplication | def test_update_time_on_photo(): |
|
0 ignored issues
–
show
|
|||
416 | temporary_folder, folder = helper.create_working_folder() |
||
417 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
418 | |||
419 | origin = '%s/plain.jpg' % folder |
||
420 | shutil.copyfile(helper.get_file('plain.jpg'), origin) |
||
421 | |||
422 | photo = Photo(origin) |
||
423 | metadata = photo.get_metadata() |
||
424 | |||
425 | helper.reset_dbs() |
||
426 | status = elodie.update_time(photo, origin, '2000-01-01 12:00:00') |
||
427 | helper.restore_dbs() |
||
428 | |||
429 | photo_processed = Photo(origin) |
||
430 | metadata_processed = photo_processed.get_metadata() |
||
431 | |||
432 | shutil.rmtree(folder) |
||
433 | shutil.rmtree(folder_destination) |
||
434 | |||
435 | assert status == True, status |
||
436 | assert metadata['date_taken'] != metadata_processed['date_taken'] |
||
437 | assert metadata_processed['date_taken'] == helper.time_convert((2000, 1, 1, 12, 0, 0, 5, 1, 0)), metadata_processed['date_taken'] |
||
438 | |||
439 | View Code Duplication | def test_update_time_on_text(): |
|
0 ignored issues
–
show
|
|||
440 | temporary_folder, folder = helper.create_working_folder() |
||
441 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
442 | |||
443 | origin = '%s/text.txt' % folder |
||
444 | shutil.copyfile(helper.get_file('text.txt'), origin) |
||
445 | |||
446 | text = Text(origin) |
||
447 | metadata = text.get_metadata() |
||
448 | |||
449 | helper.reset_dbs() |
||
450 | status = elodie.update_time(text, origin, '2000-01-01 12:00:00') |
||
451 | helper.restore_dbs() |
||
452 | |||
453 | text_processed = Text(origin) |
||
454 | metadata_processed = text_processed.get_metadata() |
||
455 | |||
456 | shutil.rmtree(folder) |
||
457 | shutil.rmtree(folder_destination) |
||
458 | |||
459 | assert status == True, status |
||
460 | assert metadata['date_taken'] != metadata_processed['date_taken'] |
||
461 | assert metadata_processed['date_taken'] == helper.time_convert((2000, 1, 1, 12, 0, 0, 5, 1, 0)), metadata_processed['date_taken'] |
||
462 | |||
463 | View Code Duplication | def test_update_time_on_video(): |
|
0 ignored issues
–
show
|
|||
464 | temporary_folder, folder = helper.create_working_folder() |
||
465 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
466 | |||
467 | origin = '%s/video.mov' % folder |
||
468 | shutil.copyfile(helper.get_file('video.mov'), origin) |
||
469 | |||
470 | video = Video(origin) |
||
471 | metadata = video.get_metadata() |
||
472 | |||
473 | helper.reset_dbs() |
||
474 | status = elodie.update_time(video, origin, '2000-01-01 12:00:00') |
||
475 | helper.restore_dbs() |
||
476 | |||
477 | video_processed = Video(origin) |
||
478 | metadata_processed = video_processed.get_metadata() |
||
479 | |||
480 | shutil.rmtree(folder) |
||
481 | shutil.rmtree(folder_destination) |
||
482 | |||
483 | assert status == True, status |
||
484 | assert metadata['date_taken'] != metadata_processed['date_taken'] |
||
485 | assert metadata_processed['date_taken'] == helper.time_convert((2000, 1, 1, 12, 0, 0, 5, 1, 0)), metadata_processed['date_taken'] |
||
486 | |||
487 | def test_update_with_directory_passed_in(): |
||
488 | temporary_folder, folder = helper.create_working_folder() |
||
489 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
490 | |||
491 | origin = '%s/valid.txt' % folder |
||
492 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
493 | |||
494 | helper.reset_dbs() |
||
495 | runner = CliRunner() |
||
496 | result = runner.invoke(elodie._import, ['--destination', folder_destination, folder]) |
||
497 | runner2 = CliRunner() |
||
498 | result = runner2.invoke(elodie._update, ['--album', 'test', folder_destination]) |
||
499 | helper.restore_dbs() |
||
500 | |||
501 | updated_file_path = "{}/2016-04-Apr/test/2016-04-07_11-15-26-valid-sample-title.txt".format(folder_destination) |
||
502 | updated_file_exists = os.path.isfile(updated_file_path) |
||
503 | |||
504 | shutil.rmtree(folder) |
||
505 | shutil.rmtree(folder_destination) |
||
506 | |||
507 | assert updated_file_exists, updated_file_path |
||
508 | |||
509 | View Code Duplication | def test_update_invalid_file_exit_code(): |
|
0 ignored issues
–
show
|
|||
510 | temporary_folder, folder = helper.create_working_folder() |
||
511 | temporary_folder_destination, folder_destination = helper.create_working_folder() |
||
512 | |||
513 | # use a good and bad |
||
514 | origin_invalid = '%s/invalid.jpg' % folder |
||
515 | shutil.copyfile(helper.get_file('invalid.jpg'), origin_invalid) |
||
516 | |||
517 | origin_valid = '%s/valid.jpg' % folder |
||
518 | shutil.copyfile(helper.get_file('plain.jpg'), origin_valid) |
||
519 | |||
520 | helper.reset_dbs() |
||
521 | runner = CliRunner() |
||
522 | result = runner.invoke(elodie._update, ['--album', 'test', origin_invalid, origin_valid]) |
||
523 | helper.restore_dbs() |
||
524 | |||
525 | shutil.rmtree(folder) |
||
526 | shutil.rmtree(folder_destination) |
||
527 | |||
528 | assert result.exit_code == 1, result.exit_code |
||
529 | |||
530 | def test_regenerate_db_invalid_source(): |
||
531 | runner = CliRunner() |
||
532 | result = runner.invoke(elodie._generate_db, ['--source', '/invalid/path']) |
||
533 | assert result.exit_code == 1, result.exit_code |
||
534 | |||
535 | def test_regenerate_valid_source(): |
||
536 | temporary_folder, folder = helper.create_working_folder() |
||
537 | |||
538 | origin = '%s/valid.txt' % folder |
||
539 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
540 | |||
541 | helper.reset_dbs() |
||
542 | runner = CliRunner() |
||
543 | result = runner.invoke(elodie._generate_db, ['--source', folder]) |
||
544 | db = Db() |
||
545 | helper.restore_dbs() |
||
546 | |||
547 | shutil.rmtree(folder) |
||
548 | |||
549 | assert result.exit_code == 0, result.exit_code |
||
550 | assert '3c19a5d751cf19e093b7447297731124d9cc987d3f91a9d1872c3b1c1b15639a' in db.hash_db, db.hash_db |
||
551 | |||
552 | def test_regenerate_valid_source_with_invalid_files(): |
||
553 | temporary_folder, folder = helper.create_working_folder() |
||
554 | |||
555 | origin_valid = '%s/valid.txt' % folder |
||
556 | shutil.copyfile(helper.get_file('valid.txt'), origin_valid) |
||
557 | origin_invalid = '%s/invalid.invalid' % folder |
||
558 | shutil.copyfile(helper.get_file('invalid.invalid'), origin_invalid) |
||
559 | |||
560 | helper.reset_dbs() |
||
561 | runner = CliRunner() |
||
562 | result = runner.invoke(elodie._generate_db, ['--source', folder]) |
||
563 | db = Db() |
||
564 | helper.restore_dbs() |
||
565 | |||
566 | shutil.rmtree(folder) |
||
567 | |||
568 | assert result.exit_code == 0, result.exit_code |
||
569 | assert '3c19a5d751cf19e093b7447297731124d9cc987d3f91a9d1872c3b1c1b15639a' in db.hash_db, db.hash_db |
||
570 | assert 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' not in db.hash_db, db.hash_db |
||
571 | |||
572 | def test_verify_ok(): |
||
573 | temporary_folder, folder = helper.create_working_folder() |
||
574 | |||
575 | origin = '%s/valid.txt' % folder |
||
576 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
577 | |||
578 | helper.reset_dbs() |
||
579 | runner = CliRunner() |
||
580 | runner.invoke(elodie._generate_db, ['--source', folder]) |
||
581 | result = runner.invoke(elodie._verify) |
||
582 | helper.restore_dbs() |
||
583 | |||
584 | shutil.rmtree(folder) |
||
585 | |||
586 | assert 'Success 1' in result.output, result.output |
||
587 | assert 'Error 0' in result.output, result.output |
||
588 | |||
589 | def test_verify_error(): |
||
590 | temporary_folder, folder = helper.create_working_folder() |
||
591 | |||
592 | origin = '%s/valid.txt' % folder |
||
593 | shutil.copyfile(helper.get_file('valid.txt'), origin) |
||
594 | |||
595 | helper.reset_dbs() |
||
596 | runner = CliRunner() |
||
597 | runner.invoke(elodie._generate_db, ['--source', folder]) |
||
598 | with open(origin, 'w') as f: |
||
599 | f.write('changed text') |
||
600 | result = runner.invoke(elodie._verify) |
||
601 | helper.restore_dbs() |
||
602 | |||
603 | shutil.rmtree(folder) |
||
604 | |||
605 | assert origin in result.output, result.output |
||
606 | assert 'Error 1' in result.output, result.output |
||
607 | |||
608 | def test_cli_debug_import(): |
||
609 | runner = CliRunner() |
||
610 | # import |
||
611 | result = runner.invoke(elodie._import, ['--destination', '/does/not/exist', '/does/not/exist']) |
||
612 | assert "Could not find /does/not/exist\n" not in result.output, result.output |
||
613 | result = runner.invoke(elodie._import, ['--destination', '/does/not/exist', '--debug', '/does/not/exist']) |
||
614 | assert "Could not find /does/not/exist\n" in result.output, result.output |
||
615 | |||
616 | def test_cli_debug_update(): |
||
617 | runner = CliRunner() |
||
618 | # update |
||
619 | result = runner.invoke(elodie._update, ['--location', 'foobar', '/does/not/exist']) |
||
620 | assert "Could not find /does/not/exist\n" not in result.output, result.output |
||
621 | result = runner.invoke(elodie._update, ['--location', 'foobar', '--debug', '/does/not/exist']) |
||
622 | assert "Could not find /does/not/exist\n" in result.output, result.output |
||
623 |