def test_get_media_multiple_users(self):
"""
'testname1': ['testmedianame1', 'testmedianame2', 'testmedianame3']
'testname2': ['testmedianame4', 'testmedianame1']
"""
user1 = User('testname1', 'P@ssw0rd')
user2 = User('testname2', 'P@ssw0rd')
db.session.add(user1)
db.session.add(user2)
db.session.commit()
media1 = Media('testmedianame1', user1.id)
media2 = Media('testmedianame2', user1.id)
media3 = Media('testmedianame3', user1.id)
media4 = Media('testmedianame4', user2.id)
media5 = Media('testmedianame1', user2.id)
db.session.add(media1)
db.session.add(media2)
db.session.add(media3)
db.session.add(media4)
db.session.add(media5)
db.session.commit()
user1_media_list = sorted(get_media('testname1'), key=lambda media: media.medianame)
self.assertListEqual(user1_media_list, [media1, media2, media3])
user2_media_list = sorted(get_media('testname2'), key=lambda media: media.medianame)
self.assertListEqual(user2_media_list, [media5, media4])
def test_get_media_list_filtered_by_consumed_state(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media1 = Media('testmedianame1', user.id, consumed_state='finished')
media2 = Media('testmedianame2', user.id, consumed_state='not started')
media3 = Media('testmedianame3', user.id, consumed_state='started')
media4 = Media('testmedianame4', user.id, consumed_state='finished')
media5 = Media('testmedianame5', user.id, consumed_state='started')
db.session.add(media1)
db.session.add(media2)
db.session.add(media3)
db.session.add(media4)
db.session.add(media5)
db.session.commit()
not_started_media_list = sorted(get_media('testname', consumed_state='not started'),
key=lambda media: media.medianame)
started_media_list = sorted(get_media('testname', consumed_state='started'),
key=lambda media: media.medianame)
finished_media_list = sorted(get_media('testname', consumed_state='finished'),
key=lambda media: media.medianame)
self.assertListEqual(not_started_media_list, [media2])
self.assertListEqual(started_media_list, [media3, media5])
self.assertListEqual(finished_media_list, [media1, media4])
def get(self):
df = DatafeedResourceLibrary()
teams = df.getHallOfFameTeams()
if teams:
media_to_update = []
for team in teams:
team_reference = Media.create_reference(
'team', team['team_id'])
video_foreign_key = team['video']
if video_foreign_key:
media_to_update.append(
Media(id=Media.render_key_name(MediaType.YOUTUBE_VIDEO,
video_foreign_key),
media_type_enum=MediaType.YOUTUBE_VIDEO,
media_tag_enum=[MediaTag.CHAIRMANS_VIDEO],
references=[team_reference],
year=team['year'],
foreign_key=video_foreign_key))
presentation_foreign_key = team['presentation']
if presentation_foreign_key:
media_to_update.append(
Media(id=Media.render_key_name(
MediaType.YOUTUBE_VIDEO, presentation_foreign_key),
media_type_enum=MediaType.YOUTUBE_VIDEO,
media_tag_enum=[MediaTag.CHAIRMANS_PRESENTATION],
references=[team_reference],
year=team['year'],
foreign_key=presentation_foreign_key))
essay_foreign_key = team['essay']
if essay_foreign_key:
media_to_update.append(
Media(id=Media.render_key_name(MediaType.EXTERNAL_LINK,
essay_foreign_key),
media_type_enum=MediaType.EXTERNAL_LINK,
media_tag_enum=[MediaTag.CHAIRMANS_ESSAY],
references=[team_reference],
year=team['year'],
foreign_key=essay_foreign_key))
MediaManipulator.createOrUpdate(media_to_update)
else:
logging.info("No Hall of Fame teams found")
teams = []
template_values = {
'teams': teams,
}
if 'X-Appengine-Taskname' not in self.request.headers: # Only write out if not in taskqueue
path = os.path.join(
os.path.dirname(__file__),
'../templates/datafeeds/hall_of_fame_teams_get.html')
self.response.out.write(template.render(path, template_values))
def setUp(self):
app = webapp2.WSGIApplication([
webapp2.Route(r'/<team_key:>/<year:>',
ApiTeamMediaController,
methods=['GET'])
],
debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc254",
name="very long name",
team_number=254,
nickname="Teh Chezy Pofs",
city="Greenville",
state_prov="SC",
country="USA",
)
self.team.put()
self.cdmedia = Media(
key=ndb.Key('Media', 'cdphotothread_39894'),
details_json=
u'{"image_partial": "fe3/fe38d320428adf4f51ac969efb3db32c_l.jpg"}',
foreign_key=u'39894',
media_type_enum=1,
references=[ndb.Key('Team', 'frc254')],
year=2014)
self.cdmedia.put()
self.cddetails = dict()
self.cddetails[
"image_partial"] = "fe3/fe38d320428adf4f51ac969efb3db32c_l.jpg"
self.ytmedia = Media(key=ndb.Key('Media', 'youtube_aFZy8iibMD0'),
details_json=None,
foreign_key=u'aFZy8iibMD0',
media_type_enum=0,
references=[ndb.Key('Team', 'frc254')],
year=2014)
self.ytmedia.put()
def test_get_media_multiple_elements(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media1 = Media('testmedianame1', user.id)
media2 = Media('testmedianame2', user.id)
db.session.add(media1)
db.session.add(media2)
db.session.commit()
media_list = sorted(get_media('testname'), key=lambda media: media.medianame)
self.assertListEqual(media_list, [media1, media2])
def test_update_media_order(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id, order=9)
db.session.add(media)
db.session.commit()
response = self.client.put('/user/testname/media',
data=json.dumps({
'id': media.id,
'order': 88890
}),
content_type='application/json')
body = json.loads(response.get_data(as_text=True))
self.assertEqual(response.status_code, 200)
self.assertTrue(body['success'])
self.assertEqual(body['data'], {
'id': 1,
'name': 'testmedianame',
'medium': 'other',
'consumed_state': 'not started',
'description': '',
'order': 88890
})
media_list = Media.query.filter_by(medianame='testmedianame').all()
self.assertEqual(len(media_list), 1)
self.assertEqual(media_list, [media])
self.assertEqual(media_list[0].order, 88890)
def parse(self, response):
"""
Parse team avatar from FMSAPI
"""
# Get team avatar
current_page = response['pageCurrent']
total_pages = response['pageTotal']
teams = response['teams']
avatars = []
keys_to_delete = set()
for teamData in teams:
team_number = teamData['teamNumber']
foreign_key = "avatar_{}_frc{}".format(self.year, team_number)
media_key = ndb.Key(
'Media', Media.render_key_name(MediaType.AVATAR, foreign_key))
if not teamData['encodedAvatar']:
keys_to_delete.add(media_key)
continue
else:
encoded_avatar = teamData['encodedAvatar']
avatar = Media(
key=media_key,
details_json=json.dumps({'base64Image': encoded_avatar}),
foreign_key=foreign_key,
media_type_enum=MediaType.AVATAR,
references=[ndb.Key('Team', "frc{}".format(team_number))],
year=self.year)
avatars.append(avatar)
return (avatars, keys_to_delete, (current_page < total_pages))
def post(self):
self._require_admin()
media_dict = MediaParser.partial_media_dict_from_url(
self.request.get('media_url').strip())
if media_dict is not None:
year_str = self.request.get('year')
if year_str == '':
year = None
else:
year = int(year_str.strip())
media = Media(
id=Media.render_key_name(media_dict['media_type_enum'],
media_dict['foreign_key']),
foreign_key=media_dict['foreign_key'],
media_type_enum=media_dict['media_type_enum'],
details_json=media_dict.get('details_json', None),
year=year,
references=[
Media.create_reference(self.request.get('reference_type'),
self.request.get('reference_key'))
],
)
MediaManipulator.createOrUpdate(media)
self.redirect(self.request.get('originating_url'))
def _process_request(self, request, event_key):
try:
video_list = json.loads(request.body)
except Exception:
self._errors = json.dumps({"Error": "Invalid JSON. Please check input."})
self.abort(400)
return
if not isinstance(video_list, list) or not video_list:
self._errors = json.dumps({"Error": "Invalid JSON. Please check input."})
self.abort(400)
return
media_to_put = []
event_reference = Media.create_reference('event', self.event.key_name)
for youtube_id in video_list:
media = Media(
id=Media.render_key_name(MediaType.YOUTUBE_VIDEO, youtube_id),
foreign_key=youtube_id,
media_type_enum=MediaType.YOUTUBE_VIDEO,
details_json=None,
private_details_json=None,
year=self.event.year,
references=[event_reference],
preferred_references=[],
)
media_to_put.append(media)
MediaManipulator.createOrUpdate(media_to_put)
def test_get_media(self):
container = Container()
media1 = Media("file_path", False)
container.media.append(media1)
show1 = Show("path", "showname")
media2 = Media("file_path2", False)
container.containers.append(show1)
show1.media.append(media2)
self.assertTrue(
testutils.compare_media(media1, container.get_media(media1.id())))
self.assertIsNone(container.get_media(media2.id()))
self.assertIsNone(container.get_media("foobar"))
def post(self, user, **kwargs):
"""Base endpoint"""
file = request.files["file"]
try:
media = Media(file=file)
media.user_id = user.id
except InvalidMediaTypeException as e:
return {"message": str(e)}, 400
optimized_file_names = media.optimize()
for file_name in optimized_file_names:
upload(file_name)
os.remove(file_name)
media.url = CDN_URI.format(optimized_file_names[0])
media.url_optimized = CDN_URI.format(optimized_file_names[1])
if len(optimized_file_names) is 3:
media.url_poster = CDN_URI.format(optimized_file_names[2])
media.showcase = request.args.get("showcase") is not None
try:
media.save()
except Exception as e:
capture_exception(e)
return {
"message":
"An unexpected error occoured while writing to the database"
}, 400
return media.to_dict(), 201
def test_media_model(fake):
media = Media(
media_id=fake.pystr(),
title=fake.pystr(),
description=fake.pystr()
)
assert str(media) == media.title
assert repr(media) == f'{media.media_id}: {media.title}'
def test_get_media_with_specific_medium(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media1 = Media('testmedianame1', user.id, medium='other', consumed_state='not started')
media2 = Media('testmedianame2', user.id, medium='film', consumed_state='finished')
media3 = Media('testmedianame3', user.id, medium='literature')
media4 = Media('testmedianame4', user.id, medium='audio', consumed_state='not started')
media5 = Media('testmedianame5', user.id, medium='film', consumed_state='started')
media6 = Media('testmedianame6', user.id, medium='film', consumed_state='finished')
media7 = Media('testmedianame7', user.id, medium='audio')
db.session.add(media1)
db.session.add(media2)
db.session.add(media3)
db.session.add(media4)
db.session.add(media5)
db.session.add(media6)
db.session.add(media7)
db.session.commit()
other_media_list = sorted(get_media('testname', medium='other'),
key=lambda media: media.medianame)
film_media_list = sorted(get_media('testname', medium='film'),
key=lambda media: media.medianame)
audio_media_list = sorted(get_media('testname', medium='audio'),
key=lambda media: media.medianame)
literature_media_list = sorted(get_media('testname', medium='literature'),
key=lambda media: media.medianame)
self.assertListEqual(other_media_list, [media1])
self.assertListEqual(film_media_list, [media2, media5, media6])
self.assertListEqual(audio_media_list, [media4, media7])
self.assertListEqual(literature_media_list, [media3])
def test_get_media(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media1 = Media('testmedianame1', user.id, medium='film', consumed_state='started')
media2 = Media('testmedianame2', user.id)
db.session.add(media1)
db.session.add(media2)
db.session.commit()
response = self.client.get('/user/testname/media')
body = json.loads(response.get_data(as_text=True))
self.assertEqual(response.status_code, 200)
self.assertTrue(body['success'])
self.assertListEqual(sorted(body['data'], key=lambda media: media['name']),
[media1.as_dict(), media2.as_dict()])
def test_add_media_with_medium_type_other(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id, medium='other')
db.session.add(media)
db.session.commit()
self.assertEqual(media.medium, 'other')
def test_add_media_with_description(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id, description='some description')
db.session.add(media)
db.session.commit()
self.assertEqual(media.description, 'some description')
def test_add_media_with_specific_order(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id, order=23)
db.session.add(media)
db.session.commit()
self.assertEqual(media.order, 23)
def add_media(userid, medianame, medium='other', consumed_state='not started', description='', order=0):
"""
add_media creates a new media record with the given medianame and assigns the media to the user with the given
username
"""
media = Media(medianame, userid, medium, consumed_state, description, order)
db.session.add(media)
db.session.commit()
return media
def getList(reply, fun):
try:
data = json.loads(reply.readAll().data().decode('utf-8'))
MediaList.medias = []
for item in data:
MediaList.addMedia(
Media(item['id'], item['filename'], item['timestamp']))
fun.emit()
except Exception as e:
print(e)
pass
def test_construct_media_with_invalid_medium(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
with self.assertRaises(ValueError) as e:
media = Media('testmedianame', user.id, medium='asdf')
self.assertEqual(
str(e.exception),
'medium must be one of these values: {}'.format(mediums))
def test_get_media(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id)
db.session.add(media)
db.session.commit()
media_list = sorted(get_media('testname'), key=lambda media: media.medianame)
self.assertEqual(media_list, [media])
def create_media(cls, suggestion, team_reference, preferred_references=[]):
media_type_enum = suggestion.contents['media_type_enum']
return Media(
id=Media.render_key_name(media_type_enum, suggestion.contents['foreign_key']),
foreign_key=suggestion.contents['foreign_key'],
media_type_enum=media_type_enum,
details_json=suggestion.contents.get('details_json', None),
private_details_json=suggestion.contents.get('private_details_json', None),
year=int(suggestion.contents['year']) if not suggestion.contents.get('is_social', False) else None,
references=[team_reference],
preferred_references=preferred_references,
)
def test_update_multiple_media_with_one_media_not_owned_by_user(self):
user1 = User('testname1', 'P@ssw0rd')
user2 = User('testname2', 'pass123')
db.session.add(user1)
db.session.add(user2)
db.session.commit()
media1 = Media('testmedianame1', user2.id)
media2 = Media('testmedianame2', user1.id)
media3 = Media('testmedianame3', user2.id)
db.session.add(media1)
db.session.add(media2)
db.session.add(media3)
db.session.commit()
response = self.client.put('/user/testname2/media',
data=json.dumps([
{'id': 1, 'order': 2},
# this media isn't owned by the testname2 user
{'id': 2, 'description': 'something'},
{'id': 3}
]),
content_type='application/json')
body = json.loads(response.get_data(as_text=True))
self.assertEqual(response.status_code, 401)
self.assertFalse(body['success'])
self.assertEqual(body['message'], 'logged in user doesn\'t have media with given id')
media1_list = Media.query.filter_by(medianame='testmedianame1').all()
media2_list = Media.query.filter_by(medianame='testmedianame2').all()
media3_list = Media.query.filter_by(medianame='testmedianame3').all()
self.assertEqual(len(media1_list), 1)
self.assertEqual(len(media2_list), 1)
self.assertEqual(len(media3_list), 1)
self.assertEqual(media1_list[0].order, 0)
self.assertEqual(media2_list[0].description, '')
self.assertEqual(media2_list[0].user, 1)
def test_remove_media(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id)
db.session.add(media)
db.session.commit()
self.assertIn(media, db.session)
remove_media(media.id)
self.assertFalse(media in db.session)
def test_get_media_by_id(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id)
db.session.add(media)
db.session.commit()
returned_media = get_media_by_id(media.id)
self.assertEqual(returned_media, media)
self.assertEqual(returned_media.id, media.id)
self.assertEqual(returned_media.medianame, media.medianame)
def test_update_multiple_media_with_one_mistyped(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media1 = Media('testmedianame1', user.id)
media2 = Media('testmedianame2', user.id)
media3 = Media('testmedianame3', user.id)
db.session.add(media1)
db.session.add(media2)
db.session.add(media3)
db.session.commit()
response = self.client.put('/user/testname/media',
data=json.dumps([
{'id': 1, 'description': 'hello world'},
{'id': 2, 'medium': 3},
{'id': 3, 'order': 3}
]),
content_type='application/json')
body = json.loads(response.get_data(as_text=True))
self.assertEqual(response.status_code, 422)
self.assertFalse(body['success'])
self.assertEqual(body['message'],
'medium parameter must be \'film\', \'audio\', \'literature\', or \'other\'')
media1_list = Media.query.filter_by(medianame='testmedianame1').all()
media2_list = Media.query.filter_by(medianame='testmedianame2').all()
media3_list = Media.query.filter_by(medianame='testmedianame3').all()
self.assertEqual(len(media1_list), 1)
self.assertEqual(len(media2_list), 1)
self.assertEqual(len(media3_list), 1)
self.assertEqual(media1_list[0].description, '')
self.assertEqual(media2_list[0].medium, 'other')
self.assertEqual(media3_list[0].order, 0)
def test_update_media_order(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id, order=2)
db.session.add(media)
db.session.commit()
self.assertEqual(media.order, 2)
media.order = 34
db.session.commit()
self.assertEqual(media.order, 34)
def test_update_media_order_property(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id)
db.session.add(media)
db.session.commit()
self.assertEqual(media.order, 0)
returned_media = update_media(media.id, order=52)
self.assertEqual(returned_media, media)
self.assertEqual(media.order, 52)
def test_add_finished_media(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media = Media('testmedianame', user.id, consumed_state='finished')
db.session.add(media)
db.session.commit()
self.assertIn(media, db.session)
self.assertEqual(media.medianame, 'testmedianame')
self.assertEqual(media.user, user.id)
self.assertEqual(media.medium, 'other')
self.assertEqual(media.consumed_state, 'finished')
self.assertEqual(media.order, 0)
def test_get_media_with_specific_medium_and_specific_consumed_state(self):
user = User('testname', 'P@ssw0rd')
db.session.add(user)
db.session.commit()
media1 = Media('testmedianame1', user.id, consumed_state='finished', medium='film')
media2 = Media('testmedianame2', user.id, medium='other')
media3 = Media('testmedianame3', user.id, consumed_state='not started', medium='film')
media4 = Media('testmedianame4', user.id, medium='film')
media5 = Media('testmedianame5', user.id, consumed_state='started')
db.session.add(media1)
db.session.add(media2)
db.session.add(media3)
db.session.add(media4)
db.session.add(media5)
db.session.commit()
response = self.client.get('/user/testname/media?consumed-state=not-started&medium=film')
body = json.loads(response.get_data(as_text=True))
self.assertEqual(response.status_code, 200)
self.assertTrue(body['success'])
self.assertEqual(sorted(body['data'], key=lambda media: media['name']),
[media3.as_dict(), media4.as_dict()])
