· 6 years ago · Apr 20, 2020, 03:34 PM
1import json
2import string
3import random
4import operator
5import datetime
6import requests
7import time
8
9import pytest
10import hypothesis.strategies as st
11from hypothesis import given, settings, HealthCheck
12
13from utils import (
14 add_video_to_db,
15 get_db_data,
16 remove_filter_prefix,
17 empty_get_video_response_factory,
18 collect_query_result,
19 generate_private_key,
20 _update_provider,
21 _update_video,
22 _is_filter_empty,
23 _DATE_FORMAT_STR
24)
25from models import Video, VideoProvider, User
26from tests.common import get_response
27
28
29_VIDEO_DATA = {
30 "date_created": "2018-01-01 12:23",
31 "finder_user_id": "Karen Cheng",
32 "category_main": "Animals",
33 "category_sub": "cute",
34 "source_url": "djiceman107@hotmail.co.uk",
35 "video_title": "Cat with bike",
36 "note_credit": "notes regarding crediting the source",
37 "original_video_title": "Cute cat riding bike",
38 "video_editor": "u3qwerfgdf324234",
39 "video_status": "Approved",
40 "video_caption": "Look at this cute cate riding bike!",
41 "video_credit": "",
42 "note_video": "Rare animal video",
43 "note_video_editor": "Team alpha",
44 "note_extra": "very good quality",
45 "note_optional": "https://www.youtube.com/1234567",
46 "channel_name": "Cats and Dogs",
47 "provider_url": "https://www.catsanddogs.com",
48 "video_reference_url": "https://www.catsanddogs.com/docs/cats",
49 "video_provider_contact": "djiceman107@hotmail.co.uk",
50 "permission_seeker": "Ivan Bergoff",
51 "contact_method": "email",
52 "date_contact": "2018-03-01 13:56",
53 "status_contact": "negotiation",
54 "date_approved": "2018-03-01 14:24",
55 "use": "",
56 "status_pick": True,
57 "status_relationship": "good relationship",
58 "source_type": "",
59 "tag": "",
60 "date_added": "2017-03-01 13:56",
61 "credit_requirement": "",
62 "rate_per_video": "",
63 "status_payment": False,
64 "status_library": True,
65 "post_url": "",
66 "share_url_ntd": "",
67 "share_url_life": "",
68 "status_sendback": True,
69 "status_video": "",
70 "date_login": "2018-02-09 13:56",
71 "login_person": "",
72 "date_fbschedule": "2018-12-01 13:56",
73 "new_video_title": ""
74}
75
76_VIDEO_PROVIDER_DATA = {
77 "channel_name": "Rammstein",
78 "provider_url": "https://www.youtube.com/results?search_query=rammstein",
79 "status_relationship": "Connected",
80 "category_provider": "Unknown",
81 "credit_requirement": "Minimum credit requirements",
82 "date_added": "2018-01-01 16:14",
83 "edit_requirement": "",
84 "date_cancel": "2018-06-01 13:56",
85 "reason_cancel": "",
86 "note_login": "",
87 "youtube_channel_subscribed": True,
88 "youtube_channel_name": "YouTube Rammstein",
89 "youtube_channel_url": "https://www.youtube.com/Rammstein",
90 "facebook_channel_name": "Facebook Rammstein",
91 "facebook_channel_url": "https://www.facebook.com/Rammstein",
92 "instagram_channel_name": "Insta Rammstein",
93 "instagram_channel_url": "https://www.instagram.com/Rammstein",
94 "channel_link": "",
95 "credit_requirement": "",
96 "forbidden_video": "",
97 "contact_info": "rammstein@mail.com",
98 "provider_contact": "",
99 "provider_agreement": "",
100 "note_provider": "",
101 "date_signed": "2017-01-01 16:14"
102}
103
104# to add new filters
105_POSSIBLE_VIDEO_FILTERS = [
106 #'video_id',
107 'date_created_range',
108 'finder_user_id',
109 'category',
110 'source_url',
111 'permission_seeker',
112 'video_status',
113 'status_contact'
114]
115
116# to add new filters
117_POSSIBLE_PROVIDER_FILTERS = [
118 #'video_provider_video_provider_id',
119 'video_provider_channel_name',
120 'video_provider_contact_info',
121 'video_provider_provider_url',
122 'video_provider_youtube_channel_name',
123 'video_provider_facebook_channel_name',
124 'video_provider_instagram_channel_name'
125]
126
127_POSSIBLE_FILTERS = _POSSIBLE_VIDEO_FILTERS + _POSSIBLE_PROVIDER_FILTERS
128
129
130def _db_date_to_response_date(db_data):
131 """Convert datetime objcts to their string representation.
132
133 The conversion is according to the given format.
134 This is necessary because the date and time in the
135 response are represented like string.
136 """
137 for field, value in db_data.items():
138 try:
139 db_data[field] = _to_date_str(db_data[field])
140 except AttributeError:
141 pass
142
143 return db_data
144
145
146def test_auth_basic(app_fixture, dbsession, auth_header):
147
148 r = get_response('/status', None, auth_header, app_fixture)
149 assert r['status'] == 'ok'
150
151 # make two consecutive requests for just in case
152 for i in range(2):
153 time.sleep(5)
154 r = get_response('/status', None, auth_header, app_fixture)
155 assert r and 'message' in r and 'Unauthorized' in r['message']
156
157
158def _auth_header(app_fixture):
159 r = get_response('/login', {'email':'rado@sto.net', 'password':'hashed'}, {'content-type': 'application/json'}, app_fixture)
160 # todo: Check if this is a clean use of fixture because we execute operation and even assert the result.
161 assert r['response']['user']['authentication_token']
162
163 token = r['response']['user']['authentication_token']
164 return {'Authentication-Token': token}
165
166
167def test_add_video_job(app_fixture, dbsession, auth_header):
168
169 data = {
170 "video": _VIDEO_DATA,
171 "video_provider": _VIDEO_PROVIDER_DATA
172 }
173
174 result = get_response('/add-video-job', data, auth_header, app_fixture)
175
176 assert result
177 assert result.get('success')
178 assert result.get('new_video_id')
179 assert result.get('new_video_provider_id')
180
181
182def test_get_video_simplest_query(app_fixture, dbsession, auth_header):
183
184 video_provider, video = add_video_to_db(_VIDEO_DATA, _VIDEO_PROVIDER_DATA)
185
186 request_data = {
187 "filters": {
188 "video_id": video.video_id,
189 }
190 }
191
192 # don't call get_db_data but put manually all model's fields and check against them
193 # this way we will test indicectly get_db_data because it is used in get_video api
194 video_db_data = get_db_data(video)
195 provider_db_data = get_db_data(video_provider, 'video_provider')
196
197 video_db_data.update(provider_db_data)
198 video_db_data = _db_date_to_response_date(video_db_data)
199
200 expected_response_data = {
201 "videos": {
202 video.video_id: {
203 **video_db_data
204 }
205 }
206 }
207
208 result = get_response('/get-video', request_data, auth_header, app_fixture)
209
210 assert result == expected_response_data
211
212
213def test_get_video_single_filter_query(app_fixture, dbsession, auth_header):
214
215 video_provider, video = add_video_to_db(_VIDEO_DATA, _VIDEO_PROVIDER_DATA)
216
217 for filter_ in _POSSIBLE_FILTERS:
218
219 # remove when ready with plain filters
220 if filter_ == 'date_created_range':
221 continue
222
223 elif filter_ == 'category':
224 value = getattr(video, 'category_main')
225
226
227 # use mapping for provider, it is more explicit
228 elif 'provider' in filter_:
229 model_field_name = filter_.replace('video_provider_', '', 1)
230 value = getattr(video_provider, model_field_name)
231
232 else:
233 value = getattr(video, filter_)
234
235 request_data = {
236 "filters": {
237 filter_: value,
238 }
239 }
240
241 #print(request_data)
242
243 # don't call get_db_data but put manually all model's fields and check against them
244 # this way we will test indicectly get_db_data because it is used in get_video api
245 video_db_data = get_db_data(video)
246 provider_db_data = get_db_data(video_provider, 'video_provider')
247
248 video_db_data.update(provider_db_data)
249 video_db_data = _db_date_to_response_date(video_db_data)
250
251 video_db_data['video_id'] = video.video_id
252
253 expected_response_data = {
254 "videos": {
255 video.video_id: {
256 **video_db_data
257 }
258 }
259 }
260
261 result = get_response('/get-video', request_data, auth_header, app_fixture)
262
263 assert result == expected_response_data
264
265
266def test_get_video_empty_filter(app_fixture, dbsession, auth_header):
267 video_provider, video = add_video_to_db(_VIDEO_DATA, _VIDEO_PROVIDER_DATA)
268 video_provider_2, video_2 = add_video_to_db(_VIDEO_DATA, _VIDEO_PROVIDER_DATA)
269
270 request_data = {
271 "filters": {
272 "video_id": "",
273 "date_created_range": "",
274 "finder_user_id": "Karen Cheng",
275 "category": "Animals",
276 "source": "",
277 "video_provider_provider_url": "https://www.youtube.com/results?search_query=rammstein",
278 "video_provider_channel_name": "Rammstein"
279 }
280 }
281
282 video_db_data = get_db_data(video)
283 video_db_data.update(get_db_data(video_provider, 'video_provider'))
284 video_db_data = _db_date_to_response_date(video_db_data)
285
286 video2_db_data = get_db_data(video_2)
287 video2_db_data.update(get_db_data(video_provider_2, 'video_provider'))
288 video2_db_data = _db_date_to_response_date(video2_db_data)
289
290 expected_response_data = {
291 "videos": {
292 video.video_id: {
293 **video_db_data
294 },
295 video_2.video_id: {
296 **video2_db_data
297 }
298 }
299 }
300
301 result = get_response('/get-video', request_data, auth_header, app_fixture)
302
303 assert result == expected_response_data
304
305
306@st.composite
307def printable_text(draw, size=None):
308 """Generates printable strings or None."""
309 texts = st.text(string.ascii_uppercase + string.digits, min_size=size, max_size=size)
310 return draw(texts)
311
312
313@st.composite
314def text_or_none(draw):
315 text = st.one_of([printable_text(size=None), printable_text(size=50)])
316 return draw(text)
317
318
319@st.composite
320def video_editor_id(draw):
321 return 'u' + draw(printable_text(size=15))
322
323
324@st.composite
325def video_provider_strategy(draw):
326 data = draw(st.fixed_dictionaries(dict(
327 channel_name=printable_text(size=50),
328 provider_url=printable_text(size=50),
329 provider_contact=printable_text(size=50),
330 contact_info=printable_text(size=20),
331 status_relationship=text_or_none(),
332 category_provider=text_or_none(),
333 credit_requirement=text_or_none(),
334 date_added=st.datetimes(min_value=_MIN_DATE, max_value=_MAX_DATE),
335 youtube_channel_subscribed=st.booleans(),
336 youtube_channel_name=text_or_none(),
337 youtube_channel_url=text_or_none(),
338 facebook_channel_name=text_or_none(),
339 facebook_channel_url=text_or_none(),
340 instagram_channel_name=text_or_none(),
341 instagram_channel_url=text_or_none(),
342 channel_link=text_or_none(),
343 edit_requirement=text_or_none()
344 )))
345 return data
346
347
348providers = st.lists(elements=video_provider_strategy(), min_size=3, max_size=3)
349
350
351_MIN_DATE = datetime.datetime(2018, 1, 1)
352_MAX_DATE = datetime.datetime(2019, 1, 1)
353
354
355@st.composite
356def video_strategy(draw, for_db=True):
357 data = draw(st.fixed_dictionaries(dict(
358 date_created=st.datetimes(min_value=_MIN_DATE, max_value=_MAX_DATE) if for_db else \
359 st.datetimes(min_value=_MIN_DATE, max_value=_MAX_DATE).map(_to_date_str),
360 finder_user_id=printable_text(size=16),
361 category_main=printable_text(size=50),
362 category_sub=printable_text(size=20),
363 source_url=printable_text(size=50),
364 video_title=printable_text(size=20),
365 original_video_title=text_or_none(),
366 video_editor=video_editor_id(),
367 video_status=text_or_none(),
368 video_caption=text_or_none(),
369 note_video=text_or_none(),
370 note_credit=text_or_none(),
371 note_video_editor=text_or_none(),
372 note_extra=text_or_none(),
373 note_optional=text_or_none(),
374 channel_name=text_or_none(),
375 provider_url=text_or_none(),
376 video_reference_url=text_or_none(),
377 video_provider_contact=text_or_none(),
378 permission_seeker=text_or_none(),
379 contact_method=text_or_none(),
380 date_contact=st.datetimes(min_value=_MIN_DATE, max_value=_MAX_DATE) if for_db else \
381 st.datetimes(min_value=_MIN_DATE, max_value=_MAX_DATE).map(_to_date_str),
382 status_contact =text_or_none(),
383 date_approved=st.datetimes(min_value=_MIN_DATE, max_value=_MAX_DATE) if for_db else \
384 st.datetimes(min_value=_MIN_DATE, max_value=_MAX_DATE).map(_to_date_str),
385 status_pick=st.booleans(),
386 status_relationship=text_or_none()
387 )))
388 return data
389
390
391videos = st.lists(elements=video_strategy(), min_size=3, max_size=3)
392
393selected_filters = st.lists(elements=st.sampled_from(_POSSIBLE_FILTERS), min_size=len(_POSSIBLE_FILTERS)/2, max_size=len(_POSSIBLE_FILTERS), unique=True)
394
395
396@given(data=st.data(), providers_data=providers, videos_data=videos, filters=selected_filters, use_wildcard=st.booleans())
397@settings(max_examples=10, suppress_health_check=[HealthCheck.too_slow])
398def test_get_video_complex(data, providers_data, videos_data, filters, use_wildcard, app_fixture, dbsession, auth_header):
399
400 video_objects, provider_objects = _create_model_objects(providers_data, videos_data)
401 # select a provider and its videos, to get values from them and to have positive results
402 # so maybe videos_data and video_objects are not needed?
403 current_provider = provider_objects[0]
404 videos = current_provider.videos
405
406 video_query_start_date = data.draw(st.datetimes(min_value=_MIN_DATE, max_value=_MAX_DATE))
407 video_query_end_date = data.draw(st.datetimes(min_value=video_query_start_date, max_value=_MAX_DATE))
408
409 request_data, all_query_attrs = _fill_filters(filters, current_provider, videos, use_wildcard, video_query_start_date, video_query_end_date)
410 query_result = dbsession.query(Video, VideoProvider).join(VideoProvider).filter(*all_query_attrs)
411
412 expected_response = empty_get_video_response_factory()
413 expected_response['videos'] = collect_query_result(query_result)
414
415 # in result we receive date in a particular string fromat because of jsonify call in flask api
416 # so we need to unify this
417 for video_id, video_data in expected_response['videos'].items():
418 video_data = _db_date_to_response_date(video_data)
419
420 result = get_response('/get-video', request_data, auth_header, app_fixture)
421
422 #print(result['videos'], expected_response['videos'])
423 assert result == expected_response
424
425
426def test_update_video(app_fixture, dbsession, auth_header):
427
428 video_provider, video = add_video_to_db(_VIDEO_DATA, _VIDEO_PROVIDER_DATA)
429 video_provider_2, video_2 = add_video_to_db(_VIDEO_DATA, _VIDEO_PROVIDER_DATA)
430 new_provider_key = generate_private_key('p')
431 new_video_key = generate_private_key('v')
432
433 request_data = {
434 "update": {
435 video.video_id: {
436 'video_id': new_video_key,
437 "category_main": "Animals",
438 "source_url": "http://youtube.com/somevideo",
439 "video_provider_channel_name": "Bicycle",
440 "video_provider_provider_contact": "0987654321",
441 "video_provider_id": new_provider_key,
442 "date_created": "1900-01-01",
443 "video_provider_youtube_channel_name": "Wild Animals",
444 "video_provider_facebook_channel_url": "www.facebook/wild-life",
445 "video_provider_instagram_channel_name": "www.instagram/wild-life",
446 "note_credit": "full credit",
447 "channel_name": "YouTube Chanel",
448 "video_provider_youtube_channel_subscribed": False
449 },
450
451 video_2.video_id: {
452 "video_title": "Blue Bicycle",
453 "finder_user_id": "Ivan",
454 "category_main": "Bicycles",
455 "category_sub": "Tricycles",
456 "video_reference_url": "http://video_refrence.com",
457 "permission_seeker": "Mark Hamil",
458 "date_approved": "1920-11-11 00:00",
459 "original_video_title": "Different Bicycles"
460 }
461 }
462 }
463
464 result = get_response('/update-video', request_data, auth_header, app_fixture)
465
466 query_1 = dbsession.query(Video, VideoProvider).join(VideoProvider.videos).filter(Video.video_id == new_video_key)
467 video_1_data = collect_query_result(query_1)
468 test_data_1 = video_1_data[new_video_key]
469
470 assert test_data_1['video_id'] == new_video_key
471 assert test_data_1["category_main"] == "Animals"
472 assert test_data_1["source_url"] == "http://youtube.com/somevideo"
473 assert test_data_1["date_created"] == datetime.datetime.strptime("1900-01-01 00:00", "%Y-%m-%d %H:%M")
474 assert test_data_1["category_sub"] == "cute"
475 assert test_data_1["video_provider_id"] == new_provider_key
476 assert test_data_1["note_credit"] == "full credit"
477 assert test_data_1["channel_name"] == "YouTube Chanel"
478
479 assert test_data_1["video_provider_channel_name"] == "Bicycle"
480 assert test_data_1["video_provider_provider_contact"] == "0987654321"
481 assert test_data_1["video_provider_contact_info"] == "rammstein@mail.com"
482 assert test_data_1["video_provider_provider_url"] == "https://www.youtube.com/results?search_query=rammstein"
483 assert test_data_1["video_provider_video_provider_id"] == new_provider_key
484 assert test_data_1["video_provider_youtube_channel_name"] == "Wild Animals"
485 assert test_data_1["video_provider_facebook_channel_url"] == "www.facebook/wild-life"
486 assert test_data_1["video_provider_instagram_channel_name"] == "www.instagram/wild-life"
487 assert not test_data_1["video_provider_youtube_channel_subscribed"]
488
489 query_2 = dbsession.query(Video, VideoProvider).join(VideoProvider.videos).filter(Video.video_id == video_2.video_id)
490 video_2_data = collect_query_result(query_2)
491 test_data_2 = video_2_data[video_2.video_id]
492
493 assert test_data_2["video_title"] == "Blue Bicycle"
494 assert test_data_2["finder_user_id"] == "Ivan"
495 assert test_data_2["date_created"] == datetime.datetime.strptime("2018-01-01 12:23", "%Y-%m-%d %H:%M")
496 assert test_data_2["category_main"] == "Bicycles"
497 assert test_data_2["category_sub"] == "Tricycles"
498 assert test_data_2["video_reference_url"] == "http://video_refrence.com"
499 assert test_data_2["permission_seeker"] == "Mark Hamil"
500 assert test_data_2["date_approved"] == datetime.datetime.strptime( "1920-11-11 00:00", "%Y-%m-%d %H:%M")
501 assert test_data_2["original_video_title"] == "Different Bicycles"
502
503 assert test_data_2["video_provider_channel_name"] == "Bicycle"
504 assert test_data_2["video_provider_contact_info"] == "rammstein@mail.com"
505 assert test_data_2["video_provider_provider_url"] == "https://www.youtube.com/results?search_query=rammstein"
506 assert test_data_2["video_provider_provider_contact"] == "0987654321"
507
508 expected_response = dict(updated=sorted(list(request_data["update"].keys())))
509
510 assert result == expected_response
511
512
513@st.composite
514def video_provider_fields_strategy(draw):
515 data = draw(st.fixed_dictionaries(dict(
516 video_provider_channel_name=printable_text(size=50),
517 video_provider_provider_url=printable_text(size=50),
518 video_provider_provider_contact=printable_text(size=50),
519 video_provider_contact_info=printable_text(size=20),
520 video_provider_status_relationship=printable_text(size=20),
521 video_provider_category_provider=printable_text(size=20),
522 video_provider_credit_requirement=printable_text(size=20),
523 video_provider_date_added=st.datetimes(
524 min_value=_MIN_DATE, max_value=_MAX_DATE).map(_to_date_str),
525 video_provider_youtube_channel_subscribed=st.booleans(),
526 video_provider_youtube_channel_name=printable_text(size=20),
527 video_provider_youtube_channel_url=printable_text(size=20),
528 video_provider_facebook_channel_name=printable_text(size=20),
529 video_provider_facebook_channel_url=printable_text(size=20),
530 video_provider_instagram_channel_name=printable_text(size=20),
531 video_provider_instagram_channel_url=printable_text(size=20),
532 video_provider_edit_requirement=printable_text(size=20)
533 )))
534 return data
535
536
537@st.composite
538def fields_values_to_update_strategy(draw):
539 fields_to_values = {}
540 video_fields_data = draw(video_strategy(for_db=False))
541 provider_fields_data = draw(video_provider_fields_strategy())
542 fields_to_values.update(provider_fields_data)
543 fields_to_values.update(video_fields_data)
544 fields_to_values.update(dict(video_id=generate_private_key('v'),
545 video_provider_id=generate_private_key('p')))
546
547 for i in range(random.randrange(len(fields_to_values))):
548 fields_to_values.popitem()
549
550 return fields_to_values
551
552
553fields_to_update = st.lists(elements=fields_values_to_update_strategy(), min_size=3, max_size=3)
554
555
556@given(providers_data=providers, videos_data=videos, updates=fields_to_update)
557@settings(max_examples=10, suppress_health_check=[HealthCheck.too_slow])
558def test_update_video_complex(providers_data, videos_data, updates, dbsession, app_fixture, auth_header):
559
560 video_objects, provider_objects = _create_model_objects(providers_data, videos_data)
561
562 request_data = {"update": {}}
563 videos_to_update = dbsession.query(Video.video_id).limit(1).all()
564
565 for video_id, update_data in zip(videos_to_update, updates):
566 request_data['update'][video_id[0]] = update_data
567
568 result = get_response('/update-video', request_data, auth_header, app_fixture)
569
570 query_result = dbsession.query(Video, VideoProvider).join(VideoProvider.videos)
571 db_data = collect_query_result(query_result)
572
573 for video_id, updated_fields in request_data['update'].items():
574
575 if 'video_id' in updated_fields: video_id = updated_fields['video_id']
576 db_data[video_id] = _db_date_to_response_date(db_data[video_id])
577
578 for column, value in updated_fields.items():
579 assert db_data[video_id][column] == value
580
581 expected_response = dict(updated=sorted(list(request_data["update"].keys())))
582
583 assert result == expected_response
584
585
586def test_search_video_single_field(app_fixture, dbsession, auth_header):
587
588 video_provider, video = add_video_to_db(_VIDEO_DATA, _VIDEO_PROVIDER_DATA)
589
590 request_data = {
591 'fields': [
592 'original_video_title',
593 ],
594 'search_query': 'cute cat',
595 'limit': 1
596 }
597
598 video_db_data = get_db_data(video)
599 provider_db_data = get_db_data(video_provider, 'video_provider')
600
601 video_db_data.update(provider_db_data)
602 video_db_data = _db_date_to_response_date(video_db_data)
603
604 expected_result = {
605 'videos': {
606 video.video_id: {
607 **video_db_data
608 }
609 }
610 }
611
612 result = get_response('/search', request_data, auth_header, app_fixture)
613
614 assert result == expected_result
615
616
617@given(data=st.data(), providers_data=providers, videos_data=videos, filters=selected_filters,
618 limit=st.integers(min_value=1, max_value=12), search_query=printable_text(size=20))
619@settings(max_examples=11, suppress_health_check=[HealthCheck.too_slow])
620def test_search_video_complex(data, providers_data, videos_data, filters, limit, search_query, app_fixture, dbsession, auth_header):
621
622 # assume is too slow
623 try:
624 filters.remove('date_created_range')
625 except ValueError:
626 pass
627
628 # assume is too slow
629 try:
630 filters.remove('category')
631 except ValueError:
632 pass
633
634 video_objects, provider_objects = _create_model_objects(providers_data, videos_data)
635
636 # set the 'search_query' to random column in every video or provider
637 # to have positive result
638 query = dbsession.query(Video, VideoProvider).join(VideoProvider.videos)
639 for video, video_provider in query:
640 filter_ = data.draw(st.sampled_from(filters))
641 _prepare_videos_providers(video, video_provider, filter_, search_query, dbsession)
642
643 dbsession.commit()
644
645 query_result = dbsession.query(Video, VideoProvider).join(VideoProvider.videos).limit(limit)
646
647 expected_result = {
648 'videos': {}
649 }
650
651 expected_result['videos'] = collect_query_result(query_result)
652
653 for video_id, video_data in expected_result['videos'].items():
654 video_data = _db_date_to_response_date(video_data)
655
656 request_data = {
657 'fields': filters,
658 'search_query': search_query,
659 'limit': limit
660 }
661
662 result = get_response('/search', request_data, auth_header, app_fixture)
663
664
665 assert result == expected_result
666
667
668def _prepare_videos_providers(video, video_provider, column, value, dbsession):
669
670 if 'video_provider_' in column and column != "video_provider_contact":
671 _update_provider(video_provider, column, value)
672 else:
673 _update_video(video, column, value)
674
675
676def _fill_filters(filters, current_provider, videos, use_wildcard, video_start_date, video_end_date):
677 #print(filters)
678
679 request_data = {
680 'filters': {}
681 }
682
683 provider_query_attrs, provider_reqeust_data = _provider_query_attrs(filters, current_provider, use_wildcard)
684 request_data['filters'].update(provider_reqeust_data)
685
686 video_query_attrs, video_reqeust_data = _video_query_attrs(filters, videos, video_start_date, video_end_date)
687 request_data['filters'].update(video_reqeust_data)
688
689 all_query_attrs = video_query_attrs + provider_query_attrs
690
691 return request_data, all_query_attrs
692
693
694def _provider_query_attrs(filters, current_provider, use_wildcard):
695 provider_query_attrs = []
696 request_data = {}
697
698 for filter_name in filters:
699
700 if 'provider' in filter_name and filter_name != 'video_provider_contact':
701 model_field_name = remove_filter_prefix(filter_name)
702 value = getattr(current_provider, model_field_name)
703
704 # emty filters are tested separately in a simple test
705 # todo: find better way to exclude empty filters
706 if _is_filter_empty(value):
707 continue
708
709 if model_field_name == 'channel_name' and use_wildcard:
710 value = '%{}%'.format(value[10:20])
711 provider_query_attrs.append(getattr(VideoProvider, model_field_name).like(value))
712 request_data[filter_name] = value
713
714 continue
715
716 provider_query_attrs.append(operator.eq(getattr(VideoProvider, model_field_name), value))
717 request_data[filter_name] = value
718
719 return provider_query_attrs, request_data
720
721
722def _video_query_attrs(filters, videos, start_date, end_date):
723 video_query_attrs = []
724 request_data = {}
725
726 for filter_name in filters:
727
728 if 'provider' in filter_name and filter_name != 'video_provider_contact':
729 continue
730
731 if 'date_created_range' == filter_name:
732
733 start_date = start_date.strftime('%Y-%m-%d')
734 end_date = end_date.strftime('%Y-%m-%d')
735
736 value = '{} - {}'.format(start_date, end_date)
737
738 video_query_attrs.append(operator.ge(getattr(Video, 'date_created'), start_date))
739 video_query_attrs.append(operator.le(getattr(Video, 'date_created'), end_date))
740
741 request_data[filter_name] = value
742
743 continue
744
745 model_field_name = filter_name
746 if 'category' == filter_name:
747 model_field_name = 'category_main'
748
749 elif 'source' == filter_name:
750 model_field_name = 'source_url'
751
752 # remove [0] and call with single video
753 value = getattr(videos[0], model_field_name)
754
755 # emty filters are tested separately in a simple test
756 # todo: find better way to exclude empty filters
757 if _is_filter_empty(value):
758 continue
759
760 video_query_attrs.append(operator.eq(getattr(Video, model_field_name), value))
761
762 request_data[filter_name] = value
763
764 return video_query_attrs, request_data
765
766
767def _create_model_objects(providers_data, videos_data):
768 video_objects = []
769 provider_objects = []
770
771 for i, provider in enumerate(providers_data):
772
773 start_video_index = i*3
774
775 for video in videos_data[start_video_index:start_video_index+3]:
776 provider_object, video_object = add_video_to_db(video, provider)
777 video_objects.append(video_object)
778 provider_objects.append(provider_object)
779
780 return video_objects, provider_objects
781
782
783def _to_date_str(datetimeobject):
784 return datetimeobject.strftime(_DATE_FORMAT_STR)
785
786
787def test_gen_keys():
788 key1 = generate_private_key('v')
789 key2 = generate_private_key('v')
790 assert key1 != key2