def test_uniqueness(self): """ Tests if the uniqueness of the model is handled properly :return: None """ media_list, user = self.generate_sample_media_list() standard_kwargs = media_list.__json__(False) standard_kwargs.pop("id") standard_kwargs["service"] = media_list.service standard_kwargs["media_type"] = media_list.media_type try: duplicate = MediaList(**standard_kwargs) db.session.add(duplicate) db.session.commit() self.fail() except IntegrityError: db.session.rollback() for key, value in [("name", "ABABABABA"), ("user_id", self.generate_sample_user(True)[0].id), ("service", ListService.ANIMEPLANET), ("media_type", MediaType.ANIME)]: kwargs = dict(standard_kwargs) kwargs[key] = value generated = MediaList(**kwargs) db.session.add(generated) db.session.commit()
def generate_sample_media_list(self) -> Tuple[MediaList, User]: """ Generates a sample media item :return: The media list and the associated user """ user = self.generate_sample_user(True)[0] media_list = MediaList(name="ABC", user=user, service=ListService.ANILIST, media_type=MediaType.MANGA) db.session.add(media_list) db.session.commit() return media_list, user
def test_hashing(self): """ Tests using the model objects as keys in a dictionary :return: None """ media_list, user = self.generate_sample_media_list() media_list_2 = MediaList(name="XYZ", user=user, service=ListService.ANILIST, media_type=MediaType.MANGA) db.session.add(media_list_2) db.session.commit() mapping = {media_list: 100, media_list_2: 200} self.assertEqual(mapping[media_list], 100) self.assertEqual(mapping[media_list_2], 200)
def test_equality(self): """ Tests checking equality for model objects :return: None """ media_list, user = self.generate_sample_media_list() media_list_2 = MediaList(name="XYZ", user=user, service=ListService.ANILIST, media_type=MediaType.MANGA) db.session.add(media_list_2) db.session.commit() self.assertEqual(media_list, media_list) self.assertNotEqual(media_list, media_list_2) self.assertNotEqual(media_list, 100)
def test_uniqueness(self): """ Tests if the uniqueness of the model is handled properly :return: None """ media_list_item, media_list, media_user_state, \ user, media_item, media_id = \ self.generate_sample_media_list_item() standard_kwargs = media_list_item.__json__(False) standard_kwargs.pop("id") media_list_kwargs = media_list.__json__(False) media_list_kwargs.pop("id") media_list_kwargs["service"] = ListService.KITSU media_list_kwargs["media_type"] = MediaType.ANIME new_media_list = MediaList(**media_list_kwargs) db.session.add(new_media_list) db.session.commit() media_user_state_kwargs = media_user_state.__json__(False) media_user_state_kwargs.pop("id") media_user_state_kwargs["user_id"] = \ self.generate_sample_user(True)[0].id media_user_state_kwargs["consuming_state"] \ = media_user_state.consuming_state new_media_user_state = MediaUserState(**media_user_state_kwargs) db.session.add(new_media_user_state) db.session.commit() try: duplicate = MediaListItem(**standard_kwargs) db.session.add(duplicate) db.session.commit() self.fail() except IntegrityError: db.session.rollback() for key, value in [("media_list_id", new_media_list.id), ("media_user_state_id", new_media_user_state.id)]: kwargs = dict(standard_kwargs) kwargs[key] = value generated = MediaListItem(**kwargs) db.session.add(generated) db.session.commit()
def generate_sample_media_list_item( self ) -> Tuple[MediaListItem, MediaList, MediaUserState, User, MediaItem, MediaId]: """ Generates a media list item :return: The media list item, media list, media user state, user, media item and media id """ user = self.generate_sample_user(True)[0] media_item = MediaItem( media_type=MediaType.MANGA, media_subtype=MediaSubType.MANGA, english_title="Fly Me to the Moon", romaji_title="Tonikaku Cawaii", cover_url="https://s4.anilist.co/file/anilistcdn/media/manga/" "cover/medium/nx101177-FjjD5UWB3C3t.png", latest_release=None, releasing_state=ReleasingState.RELEASING) media_id = MediaId(media_item=media_item, service_id="101177", service=ListService.ANILIST, media_type=media_item.media_type, media_subtype=media_item.media_subtype) media_user_state = MediaUserState( media_id=media_id, user=user, progress=10, score=75, consuming_state=ConsumingState.CURRENT) media_list = MediaList(name="ABC", user=user, service=ListService.ANILIST, media_type=MediaType.MANGA) media_list_item = MediaListItem(media_list=media_list, media_user_state=media_user_state) db.session.add(media_item) db.session.add(media_id) db.session.add(media_user_state) db.session.add(media_list) db.session.add(media_list_item) db.session.commit() return media_list_item, media_list, media_user_state, \ user, media_item, media_id
def do_media_item_inserts(): """ Preforms media item insertions :return: None """ # Prepare existing DB content media_items: Dict[Tuple, MediaItem] = { x.identifier_tuple: x for x in MediaItem.query.all() } media_ids: List[MediaId] = MediaId.query\ .options(db.joinedload(MediaId.media_item)) \ .options(db.joinedload(MediaId.media_user_states)) \ .all() media_service_items: \ Dict[ListService, Dict[MediaType, Dict[str, MediaId]]] = \ {x: {y: {} for y in MediaType} for x in ListService} for media_id in media_ids: service = media_id.service media_type = media_id.media_item.media_type service_id = media_id.service_id media_service_items[service][media_type][service_id] = media_id media_lists: Dict[Tuple, MediaList] = { x.identifier_tuple: x for x in MediaList.query.options(db.joinedload(MediaList.media_list_items)) .all() } # Add media list items, ids and user states while len(media_item_queue) > 0: queued = media_item_queue.pop(0) params, service, service_ids, user_state_params, list_params = queued service_id = service_ids.get(service) if service_id is None: app.logger.error(f"Missing service ID for service {service}") media_type = params["media_type"] app.logger.debug(f"Inserting {params['romaji_title']} into database") if service_id in media_service_items[service]: media_id = media_service_items[service][media_type][service_id] media_item = media_id.media_item media_item.update(MediaItem(**params)) else: generated = MediaItem(**params) identifier = generated.identifier_tuple existing = media_items.get(identifier) if existing is None: media_item = generated db.session.add(media_item) media_items[identifier] = media_item else: media_item = existing media_item.update(generated) # Insert Media IDs for extra_service, extra_id in service_ids.items(): associated = media_service_items[extra_service][media_type].get( extra_id ) if associated is None: media_id = MediaId( media_item=media_item, service=extra_service, service_id=extra_id ) db.session.add(media_id) db.session.commit() media_service_items[extra_service][media_type][extra_id] \ = media_id elif associated.media_item.id != media_item.id: associated.media_item_id = media_item.id # Insert User States if user_state_params is not None: media_id = media_service_items[service][media_type][service_id] user_state_params["media_id_id"] = media_id.id generated = MediaUserState(**user_state_params) existing_user_states = { x.user_id: x for x in media_id.media_user_states } user_id = user_state_params["user_id"] existing_user_state = existing_user_states.get(user_id) if existing_user_state is None: db.session.add(generated) user_state = generated db.session.commit() else: existing_user_state.update(generated) user_state = existing_user_state if list_params is not None: generated = MediaList(**list_params) identifier = generated.identifier_tuple existing_list = media_lists.get(identifier) if existing_list is None: db.session.add(generated) db.session.commit() media_list = generated media_lists[identifier] = media_list else: existing_list.update(generated) media_list = existing_list media_list_item_ids = [ x.media_user_state_id for x in media_list.media_list_items ] if user_state.id not in media_list_item_ids: list_item = MediaListItem( media_list_id=media_list.id, media_user_state_id=user_state.id ) db.session.add(list_item)