def test_by_uri_with_multiple_repeated_tracks(self):
"""
Test deduping my id returns two distinct tracks when one duplicate is provided
"""
mock_track_one = create_dataclass_mock(SimplifiedTrack)
mock_track_one.uri = Uri('spotify:track:1')
mock_track_two = create_dataclass_mock(SimplifiedTrack)
mock_track_two.uri = Uri('spotify:track:2')
mock_track_three = create_dataclass_mock(SimplifiedTrack)
mock_track_three.uri = Uri('spotify:track:1')
mock_track_four = create_dataclass_mock(SimplifiedTrack)
mock_track_four.uri = Uri('spotify:track:2')
for track in [
mock_track_one, mock_track_two, mock_track_three,
mock_track_four
]:
self.assertTrue(hasattr(track, 'uri'))
self.assertIsInstance(track.uri, Uri)
returned_tracks = deduplicate_by_id([
mock_track_one, mock_track_two, mock_track_three, mock_track_four
],
include_malformed=False)
self.assertTrue(len(returned_tracks) == 2)
self.assertEqual(mock_track_one, returned_tracks[0])
self.assertEqual(mock_track_two, returned_tracks[1])
def __post_init__(self):
if isinstance(self.uri, str):
self.uri = Uri(self.uri)
if self.uri:
if self.uri.object_type != Uri.ObjectType.episode:
raise TypeError('provided uri not for an episode')
if isinstance(self.resume_point, ResumePoint):
self.resume_point = init_with_key_filter(ResumePoint,
self.resume_point)
if all((isinstance(i, dict) for i in self.images)):
self.images = [init_with_key_filter(Image, i) for i in self.images]
if isinstance(self.release_date, str):
if self.release_date_precision == 'year':
self.release_date = datetime.strptime(self.release_date, '%Y')
elif self.release_date_precision == 'month':
self.release_date = datetime.strptime(self.release_date,
'%Y-%m')
elif self.release_date_precision == 'day':
self.release_date = datetime.strptime(self.release_date,
'%Y-%m-%d')
def __post_init__(self):
if isinstance(self.uri, str):
self.uri = Uri(self.uri)
if self.uri:
if self.uri.object_type not in [Uri.ObjectType.artist, Uri.ObjectType.show]:
raise TypeError('provided uri not for an artist')
def get_uri(uri_in):
if isinstance(uri_in, str):
return Uri(input_string=uri_in)
if isinstance(uri_in, Uri):
return uri_in
raise TypeError(f'invalid uri type provided - {type(uri_in)}')
def __post_init__(self):
if isinstance(self.uri, str):
self.uri = Uri(self.uri)
if self.uri:
if self.uri.object_type != Uri.ObjectType.user:
raise TypeError('provided uri not for a user')
if all((isinstance(i, dict) for i in self.images)):
self.images = [init_with_key_filter(Image, i) for i in self.images]
def __post_init__(self):
if isinstance(self.uri, str):
self.uri = Uri(self.uri)
if self.uri:
if self.uri.object_type not in [
Uri.ObjectType.album, Uri.ObjectType.artist,
Uri.ObjectType.playlist
]:
raise TypeError(
'context uri must be one of album, artist, playlist')
def test_by_uri_with_two_different_tracks(self):
"""
Test deduping my id returns two distinct tracks
"""
mock_track_one = create_dataclass_mock(SimplifiedTrack)
mock_track_one.uri = Uri('spotify:track:1')
mock_track_two = create_dataclass_mock(SimplifiedTrack)
mock_track_two.uri = Uri('spotify:track:2')
self.assertTrue(hasattr(mock_track_one, 'uri'))
self.assertTrue(hasattr(mock_track_two, 'uri'))
self.assertIsInstance(mock_track_one.uri, Uri)
self.assertIsInstance(mock_track_two.uri, Uri)
returned_tracks = deduplicate_by_id([mock_track_one, mock_track_two],
include_malformed=False)
self.assertTrue(len(returned_tracks) == 2)
self.assertEqual(mock_track_one, returned_tracks[0])
self.assertEqual(mock_track_two, returned_tracks[1])
def __post_init__(self):
if isinstance(self.album_type, str):
self.album_type = SimplifiedAlbum.Type[
self.album_type.strip().lower()]
if isinstance(self.uri, str):
self.uri = Uri(self.uri)
if self.uri:
if self.uri.object_type not in [
Uri.ObjectType.album, Uri.ObjectType.show
]:
raise TypeError('provided uri not for an album')
if all((isinstance(i, dict) for i in self.artists)):
self.artists = [
init_with_key_filter(
spotframework.model.artist.SimplifiedArtist, i)
for i in self.artists
]
if all((isinstance(i, dict) for i in self.images)):
self.images = [
init_with_key_filter(spotframework.model.service.Image, i)
for i in self.images
]
if isinstance(self.release_date, str):
try:
if self.release_date_precision == 'year':
self.release_date = datetime.strptime(
self.release_date, '%Y')
elif self.release_date_precision == 'month':
self.release_date = datetime.strptime(
self.release_date, '%Y-%m')
elif self.release_date_precision == 'day':
self.release_date = datetime.strptime(
self.release_date, '%Y-%m-%d')
else:
logger.error(
f'invalid release date type {self.release_date_precision} - {self.release_date}'
)
except ValueError:
self.release_date = datetime(year=1900, month=1, day=1)
logger.error(
f'failed to parse release date for album {self.uri} {self.name} {self.artists_names} {self.release_date_precision} - {self.release_date}'
)
elif self.release_date is None and self.release_date_precision is None: # for podcasts
self.release_date = datetime(year=1900, month=1, day=1)
def test_by_uri_with_one_track(self):
"""
Test deduping my id returns one track when provided one track
"""
mock_track = create_dataclass_mock(SimplifiedTrack)
mock_track.uri = Uri('spotify:track:1')
self.assertTrue(hasattr(mock_track, 'uri'))
self.assertIsInstance(mock_track.uri, Uri)
returned_tracks = deduplicate_by_id([mock_track],
include_malformed=False)
self.assertTrue(len(returned_tracks) == 1)
self.assertEqual(mock_track, returned_tracks[0])
def __post_init__(self):
if isinstance(self.tracks, dict):
self.tracks = []
if isinstance(self.uri, str):
self.uri = Uri(self.uri)
if self.uri:
if self.uri.object_type != Uri.ObjectType.playlist:
raise TypeError('provided uri not for a playlist')
if all((isinstance(i, dict) for i in self.images)):
self.images = [init_with_key_filter(Image, i) for i in self.images]
if isinstance(self.owner, dict):
self.owner = init_with_key_filter(PublicUser, self.owner)
def __post_init__(self):
if isinstance(self.uri, str):
self.uri = Uri(self.uri)
if self.uri:
if self.uri.object_type not in [
Uri.ObjectType.track, Uri.ObjectType.episode
]:
raise TypeError('provided uri not for a track')
if all((isinstance(i, dict) for i in self.artists)):
self.artists = [
init_with_key_filter(
spotframework.model.artist.SimplifiedArtist, i)
for i in self.artists
]
def validate_uri_string(uri_string: str):
try:
uri = Uri(uri_string)
return uri
except ValueError:
return False
def test_6_components_is_local_uri(self):
with self.assertRaises(ValueError):
# all uris start with spotify
# spotify:local:{artist}:{album_title}:{track_title}:{duration_in_seconds}
Uri("spotify:_ocal:{artist}:{album_title}:{track_title}:{duration_in_seconds}")
def test_too_many_components(self):
with self.assertRaises(ValueError):
# all uris start with spotifys
Uri("spotify:test:test:test:test:test:test")
def test_equals(self):
uri_one = Uri("spotify:track:test")
uri_two = Uri("spotify:track:test")
self.assertEqual(uri_one, uri_two)
def test_start_spotify(self):
with self.assertRaises(ValueError):
# all uris start with spotify
# spotify:track:3EHhS6B2qJWup1nqUVQy1H
Uri("_potify:track:3EHhS6B2qJWup1nqUVQy1H")
def test_input_not_string(self):
with self.assertRaises(AttributeError):
Uri(7)
def test_repr(self):
uri = Uri("spotify:track:test")
self.assertEqual(repr(uri), "URI: track / test")
def test_str(self):
uri = Uri("spotify:track:test")
self.assertEqual(str(uri), "spotify:track:test")
def test_equal_object_id(self):
uri_one = Uri("spotify:track:test")
uri_two = Uri("spotify:track:tester")
self.assertNotEqual(uri_one, uri_two)
def test_equal_different_type(self):
uri_one = Uri("spotify:track:test")
uri_two = 7
self.assertNotEqual(uri_one, uri_two)
