1333 行
33 KiB
Python
1333 行
33 KiB
Python
import pytest
|
|
|
|
from yandex_music import (
|
|
Account,
|
|
AdParams,
|
|
Album,
|
|
AlbumEvent,
|
|
Artist,
|
|
ArtistEvent,
|
|
AutoRenewable,
|
|
Best,
|
|
Block,
|
|
BlockEntity,
|
|
CaseForms,
|
|
Chart,
|
|
ChartInfo,
|
|
ChartInfoMenu,
|
|
ChartInfoMenuItem,
|
|
ChartItem,
|
|
Client,
|
|
Counts,
|
|
Cover,
|
|
CustomWave,
|
|
Day,
|
|
Description,
|
|
DiscreteScale,
|
|
Enum,
|
|
Event,
|
|
GeneratedPlaylist,
|
|
Icon,
|
|
Id,
|
|
Images,
|
|
InvocationInfo,
|
|
Label,
|
|
LicenceTextPart,
|
|
Link,
|
|
Lyrics,
|
|
MadeFor,
|
|
Major,
|
|
MetaData,
|
|
MixLink,
|
|
Normalization,
|
|
Pager,
|
|
PassportPhone,
|
|
Permissions,
|
|
PersonalPlaylistsData,
|
|
PlayContext,
|
|
PlayContextsData,
|
|
PlayCounter,
|
|
Playlist,
|
|
PlaylistAbsence,
|
|
PlaylistId,
|
|
Plus,
|
|
Price,
|
|
Product,
|
|
Promotion,
|
|
Ratings,
|
|
RenewableRemainder,
|
|
Restrictions,
|
|
RotorSettings,
|
|
SearchResult,
|
|
Sequence,
|
|
Settings,
|
|
Shot,
|
|
ShotData,
|
|
ShotType,
|
|
Station,
|
|
StationResult,
|
|
Status,
|
|
Subscription,
|
|
Tag,
|
|
Title,
|
|
Track,
|
|
TrackId,
|
|
TrackPosition,
|
|
TrackShort,
|
|
TrackShortOld,
|
|
TrackWithAds,
|
|
User,
|
|
Value,
|
|
Video,
|
|
VideoSupplement,
|
|
Vinyl,
|
|
StationData,
|
|
AlertButton,
|
|
Alert,
|
|
NonAutoRenewable,
|
|
PoetryLoverMatch,
|
|
Deactivation,
|
|
Operator,
|
|
Contest,
|
|
OpenGraphData,
|
|
Brand,
|
|
Context,
|
|
Deprecation,
|
|
TrackLyrics,
|
|
LyricsMajor,
|
|
R128,
|
|
LyricsInfo,
|
|
)
|
|
from . import (
|
|
TestAccount,
|
|
TestAdParams,
|
|
TestAlbum,
|
|
TestArtist,
|
|
TestAutoRenewable,
|
|
TestBest,
|
|
TestBlock,
|
|
TestBlockEntity,
|
|
TestCaseForms,
|
|
TestChart,
|
|
TestChartInfo,
|
|
TestChartInfoMenuItem,
|
|
TestCounts,
|
|
TestCover,
|
|
TestCustomWave,
|
|
TestDay,
|
|
TestDescription,
|
|
TestDiscreteScale,
|
|
TestEnum,
|
|
TestEvent,
|
|
TestGeneratedPlaylist,
|
|
TestIcon,
|
|
TestId,
|
|
TestImages,
|
|
TestInvocationInfo,
|
|
TestLabel,
|
|
TestLicenceTextPart,
|
|
TestLink,
|
|
TestLyrics,
|
|
TestMajor,
|
|
TestMetaData,
|
|
TestMixLink,
|
|
TestNormalization,
|
|
TestPager,
|
|
TestPassportPhone,
|
|
TestPermissions,
|
|
TestPersonalPlaylistsData,
|
|
TestPlayContext,
|
|
TestPlayCounter,
|
|
TestPlaylist,
|
|
TestPlaylistAbsence,
|
|
TestPlaylistId,
|
|
TestPlus,
|
|
TestPrice,
|
|
TestProduct,
|
|
TestPromotion,
|
|
TestRatings,
|
|
TestRenewableRemainder,
|
|
TestRotorSettings,
|
|
TestSearchResult,
|
|
TestSequence,
|
|
TestSettings,
|
|
TestShot,
|
|
TestShotData,
|
|
TestShotType,
|
|
TestStation,
|
|
TestStationResult,
|
|
TestStatus,
|
|
TestSubscription,
|
|
TestTag,
|
|
TestTitle,
|
|
TestTrack,
|
|
TestTrackId,
|
|
TestTrackPosition,
|
|
TestTrackShort,
|
|
TestTrackShortOld,
|
|
TestTrackWithAds,
|
|
TestUser,
|
|
TestValue,
|
|
TestVideo,
|
|
TestVideoSupplement,
|
|
TestVinyl,
|
|
TestArtistEvent,
|
|
TestStationData,
|
|
TestAlertButton,
|
|
TestAlert,
|
|
TestNonAutoRenewable,
|
|
TestPoetryLoverMatch,
|
|
TestDeactivation,
|
|
TestOperator,
|
|
TestContest,
|
|
TestOpenGraphData,
|
|
TestBrand,
|
|
TestContext,
|
|
TestDeprecation,
|
|
TestLyricsMajor,
|
|
TestTrackLyrics,
|
|
TestR128,
|
|
TestLyricsInfo,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def artist_factory(cover, counts, ratings, link, description):
|
|
class ArtistFactory:
|
|
def get(self, popular_tracks, decomposed=None):
|
|
return Artist(
|
|
TestArtist.id,
|
|
TestArtist.error,
|
|
TestArtist.reason,
|
|
TestArtist.name,
|
|
cover,
|
|
TestArtist.various,
|
|
TestArtist.composer,
|
|
TestArtist.genres,
|
|
TestArtist.og_image,
|
|
TestArtist.op_image,
|
|
TestArtist.no_pictures_from_search,
|
|
counts,
|
|
TestArtist.available,
|
|
ratings,
|
|
[link],
|
|
TestArtist.tickets_available,
|
|
TestArtist.likes_count,
|
|
popular_tracks,
|
|
TestArtist.regions,
|
|
decomposed,
|
|
TestArtist.full_names,
|
|
TestArtist.hand_made_description,
|
|
description,
|
|
TestArtist.countries,
|
|
TestArtist.en_wikipedia_link,
|
|
TestArtist.db_aliases,
|
|
TestArtist.aliases,
|
|
TestArtist.init_date,
|
|
TestArtist.end_date,
|
|
TestArtist.ya_money_id,
|
|
)
|
|
|
|
return ArtistFactory()
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def artist(artist_factory, track_without_artists_and_albums, artist_decomposed):
|
|
return artist_factory.get([track_without_artists_and_albums], artist_decomposed)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def artist_without_nested_artist(artist_factory, track_without_artists_and_albums):
|
|
return artist_factory.get([track_without_artists_and_albums])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def artist_without_tracks(artist_factory):
|
|
return artist_factory.get([])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def artist_decomposed(artist_without_nested_artist):
|
|
return [' & ', artist_without_nested_artist]
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_factory(major, normalization, user, meta_data, poetry_lover_match, r_128, lyrics_info):
|
|
class TrackFactory:
|
|
def get(self, artists, albums, track_without_nested_tracks=None):
|
|
return Track(
|
|
TestTrack.id,
|
|
TestTrack.title,
|
|
TestTrack.available,
|
|
artists,
|
|
albums,
|
|
TestTrack.available_for_premium_users,
|
|
TestTrack.lyrics_available,
|
|
[poetry_lover_match],
|
|
TestTrack.best,
|
|
TestTrack.real_id,
|
|
TestTrack.og_image,
|
|
TestTrack.type,
|
|
TestTrack.cover_uri,
|
|
major,
|
|
TestTrack.duration_ms,
|
|
TestTrack.storage_dir,
|
|
TestTrack.file_size,
|
|
track_without_nested_tracks,
|
|
track_without_nested_tracks,
|
|
normalization,
|
|
TestTrack.error,
|
|
TestTrack.can_publish,
|
|
TestTrack.state,
|
|
TestTrack.desired_visibility,
|
|
TestTrack.filename,
|
|
user,
|
|
meta_data,
|
|
TestTrack.regions,
|
|
TestTrack.available_as_rbt,
|
|
TestTrack.content_warning,
|
|
TestTrack.explicit,
|
|
TestTrack.preview_duration_ms,
|
|
TestTrack.available_full_without_permission,
|
|
TestTrack.version,
|
|
TestTrack.remember_position,
|
|
TestTrack.background_video_uri,
|
|
TestTrack.short_description,
|
|
TestTrack.is_suitable_for_children,
|
|
TestTrack.track_source,
|
|
TestTrack.available_for_options,
|
|
r_128,
|
|
lyrics_info,
|
|
TestTrack.track_sharing_flag,
|
|
)
|
|
|
|
return TrackFactory()
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track(track_factory, artist, album, track_without_nested_tracks):
|
|
return track_factory.get([artist], [album], track_without_nested_tracks)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_without_artists(track_factory, album):
|
|
return track_factory.get([], [album])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_without_albums(track_factory, artist):
|
|
return track_factory.get([artist], [])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_without_artists_and_albums(track_factory):
|
|
return track_factory.get([], [])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_without_nested_tracks(artist, album, track_factory):
|
|
return track_factory.get([artist], [album])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def lyrics_major():
|
|
return LyricsMajor(
|
|
TestLyricsMajor.id,
|
|
TestLyricsMajor.name,
|
|
TestLyricsMajor.pretty_name,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_lyrics(lyrics_major):
|
|
return TrackLyrics(
|
|
TestTrackLyrics.download_url,
|
|
TestTrackLyrics.lyric_id,
|
|
TestTrackLyrics.external_lyric_id,
|
|
TestTrackLyrics.writer,
|
|
lyrics_major,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def album_factory(label, track_position):
|
|
class AlbumFactory:
|
|
def get(self, artists, volumes, albums=None, deprecation=None):
|
|
return Album(
|
|
TestAlbum.id,
|
|
TestAlbum.error,
|
|
TestAlbum.title,
|
|
TestAlbum.track_count,
|
|
artists,
|
|
[label],
|
|
TestAlbum.available,
|
|
TestAlbum.available_for_premium_users,
|
|
TestAlbum.version,
|
|
TestAlbum.cover_uri,
|
|
TestAlbum.content_warning,
|
|
TestAlbum.original_release_year,
|
|
TestAlbum.genre,
|
|
TestAlbum.text_color,
|
|
TestAlbum.short_description,
|
|
TestAlbum.description,
|
|
TestAlbum.is_premiere,
|
|
TestAlbum.is_banner,
|
|
TestAlbum.meta_type,
|
|
TestAlbum.storage_dir,
|
|
TestAlbum.og_image,
|
|
TestAlbum.buy,
|
|
TestAlbum.recent,
|
|
TestAlbum.very_important,
|
|
TestAlbum.available_for_mobile,
|
|
TestAlbum.available_partially,
|
|
TestAlbum.bests,
|
|
albums,
|
|
TestAlbum.prerolls,
|
|
volumes,
|
|
TestAlbum.year,
|
|
TestAlbum.release_date,
|
|
TestAlbum.type,
|
|
track_position,
|
|
TestAlbum.regions,
|
|
TestAlbum.available_as_rbt,
|
|
TestAlbum.lyrics_available,
|
|
TestAlbum.remember_position,
|
|
albums,
|
|
TestAlbum.duration_ms,
|
|
TestAlbum.explicit,
|
|
TestAlbum.start_date,
|
|
TestAlbum.likes_count,
|
|
deprecation,
|
|
TestAlbum.available_regions,
|
|
TestAlbum.available_for_options,
|
|
)
|
|
|
|
return AlbumFactory()
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def album(album_factory, artist_without_tracks, track_without_albums, album_without_nested_albums, deprecation):
|
|
return album_factory.get(
|
|
[artist_without_tracks], [[track_without_albums]], [album_without_nested_albums], deprecation
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def album_without_tracks(album_factory, artist_without_tracks):
|
|
return album_factory.get([artist_without_tracks], [])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def album_without_nested_albums(album_factory, artist_without_tracks, track_without_albums):
|
|
return album_factory.get([artist_without_tracks], [[track_without_albums]])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def playlist_factory(
|
|
user,
|
|
cover,
|
|
made_for,
|
|
track_short,
|
|
play_counter,
|
|
playlist_absence,
|
|
artist,
|
|
track_id,
|
|
contest,
|
|
open_graph_data,
|
|
brand,
|
|
custom_wave,
|
|
pager,
|
|
):
|
|
class PlaylistFactory:
|
|
def get(self, similar_playlists, last_owner_playlists):
|
|
return Playlist(
|
|
user,
|
|
cover,
|
|
made_for,
|
|
play_counter,
|
|
playlist_absence,
|
|
TestPlaylist.uid,
|
|
TestPlaylist.kind,
|
|
TestPlaylist.title,
|
|
TestPlaylist.track_count,
|
|
TestPlaylist.tags,
|
|
TestPlaylist.revision,
|
|
TestPlaylist.snapshot,
|
|
TestPlaylist.visibility,
|
|
TestPlaylist.collective,
|
|
TestPlaylist.url_part,
|
|
TestPlaylist.created,
|
|
TestPlaylist.modified,
|
|
TestPlaylist.available,
|
|
TestPlaylist.is_banner,
|
|
TestPlaylist.is_premiere,
|
|
TestPlaylist.duration_ms,
|
|
TestPlaylist.og_image,
|
|
TestPlaylist.og_title,
|
|
TestPlaylist.og_description,
|
|
TestPlaylist.image,
|
|
cover,
|
|
contest,
|
|
TestPlaylist.background_color,
|
|
TestPlaylist.text_color,
|
|
TestPlaylist.id_for_from,
|
|
TestPlaylist.dummy_description,
|
|
TestPlaylist.dummy_page_description,
|
|
cover,
|
|
cover,
|
|
open_graph_data,
|
|
brand,
|
|
TestPlaylist.metrika_id,
|
|
TestPlaylist.coauthors,
|
|
[artist],
|
|
[track_id],
|
|
[track_short],
|
|
TestPlaylist.prerolls,
|
|
TestPlaylist.likes_count,
|
|
similar_playlists,
|
|
last_owner_playlists,
|
|
TestPlaylist.generated_playlist_type,
|
|
TestPlaylist.animated_cover_uri,
|
|
TestPlaylist.ever_played,
|
|
TestPlaylist.description,
|
|
TestPlaylist.description_formatted,
|
|
TestPlaylist.playlist_uuid,
|
|
TestPlaylist.type,
|
|
TestPlaylist.ready,
|
|
TestPlaylist.is_for_from,
|
|
TestPlaylist.regions,
|
|
custom_wave,
|
|
pager,
|
|
)
|
|
|
|
return PlaylistFactory()
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def playlist(playlist_factory, playlist_without_nested_playlists):
|
|
return playlist_factory.get([playlist_without_nested_playlists], [playlist_without_nested_playlists])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def playlist_without_nested_playlists(playlist_factory):
|
|
return playlist_factory.get([], [])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def generated_playlist(playlist):
|
|
return GeneratedPlaylist(
|
|
TestGeneratedPlaylist.type,
|
|
TestGeneratedPlaylist.ready,
|
|
TestGeneratedPlaylist.notify,
|
|
playlist,
|
|
TestGeneratedPlaylist.description,
|
|
TestGeneratedPlaylist.preview_description,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def client():
|
|
return Client()
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def tag():
|
|
return Tag(TestTag.id_, TestTag.value, TestTag.name, TestTag.og_description, TestTag.og_image)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def brand():
|
|
return Brand(
|
|
TestBrand.image,
|
|
TestBrand.background,
|
|
TestBrand.reference,
|
|
TestBrand.pixels,
|
|
TestBrand.theme,
|
|
TestBrand.playlist_theme,
|
|
TestBrand.button,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_with_ads(track):
|
|
return TrackWithAds(TestTrackWithAds.type, track)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def day(event, track_with_ads, track):
|
|
return Day(TestDay.day, [event], [track_with_ads], [track])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_short():
|
|
return TrackShort(TestTrackShort.id, TestTrackShort.timestamp, TestTrackShort.album_id)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_short_old(track_id):
|
|
return TrackShortOld(track_id, TestTrackShortOld.timestamp)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def video():
|
|
return Video(
|
|
TestVideo.title,
|
|
TestVideo.cover,
|
|
TestVideo.embed_url,
|
|
TestVideo.provider,
|
|
TestVideo.provider_video_id,
|
|
TestVideo.youtube_url,
|
|
TestVideo.thumbnail_url,
|
|
TestVideo.duration,
|
|
TestVideo.text,
|
|
TestVideo.html_auto_play_video_player,
|
|
TestVideo.regions,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def vinyl():
|
|
return Vinyl(
|
|
TestVinyl.url,
|
|
TestVinyl.title,
|
|
TestVinyl.year,
|
|
TestVinyl.price,
|
|
TestVinyl.media,
|
|
TestVinyl.offer_id,
|
|
TestVinyl.artist_ids,
|
|
TestVinyl.picture,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def play_context(track_short_old):
|
|
return PlayContext(
|
|
TestPlayContext.client_, TestPlayContext.context, TestPlayContext.context_item, [track_short_old]
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def play_contexts_data(track_short_old):
|
|
return PlayContextsData([track_short_old])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def enum(value):
|
|
return Enum(TestEnum.type, TestEnum.name, [value])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def icon():
|
|
return Icon(TestIcon.background_color, TestIcon.image_url)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def cover():
|
|
return Cover(
|
|
TestCover.type,
|
|
TestCover.uri,
|
|
TestCover.items_uri,
|
|
TestCover.dir,
|
|
TestCover.version,
|
|
TestCover.custom,
|
|
TestCover.is_custom,
|
|
TestCover.copyright_name,
|
|
TestCover.copyright_cline,
|
|
TestCover.prefix,
|
|
TestCover.error,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def open_graph_data(cover):
|
|
return OpenGraphData(TestOpenGraphData.title, TestOpenGraphData.description, cover)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def meta_data():
|
|
return MetaData(
|
|
TestMetaData.album,
|
|
TestMetaData.volume,
|
|
TestMetaData.year,
|
|
TestMetaData.number,
|
|
TestMetaData.genre,
|
|
TestMetaData.lyricist,
|
|
TestMetaData.version,
|
|
TestMetaData.composer,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def licence_text_part():
|
|
return LicenceTextPart(TestLicenceTextPart.text, TestLicenceTextPart.url)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def link():
|
|
return Link(TestLink.title, TestLink.href, TestLink.type, TestLink.social_network)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def invocation_info():
|
|
return InvocationInfo(
|
|
TestInvocationInfo.hostname, TestInvocationInfo.req_id, TestInvocationInfo.exec_duration_millis
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def settings(product, price):
|
|
return Settings([product], [product], TestSettings.web_payment_url, TestSettings.promo_codes_enabled, price)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def counts():
|
|
return Counts(TestCounts.tracks, TestCounts.direct_albums, TestCounts.also_albums, TestCounts.also_tracks)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def description():
|
|
return Description(TestDescription.text, TestDescription.uri)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def deprecation():
|
|
return Deprecation(TestDeprecation.target_album_id, TestDeprecation.status, TestDeprecation.done)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def pager():
|
|
return Pager(TestPager.total, TestPager.page, TestPager.per_page)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def artist_event(artist, track):
|
|
return ArtistEvent(artist, [track], [artist], TestArtistEvent.subscribed)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def album_event(album, track):
|
|
return AlbumEvent(album, [track])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def video_supplement():
|
|
return VideoSupplement(
|
|
TestVideoSupplement.cover,
|
|
TestVideoSupplement.provider,
|
|
TestVideoSupplement.title,
|
|
TestVideoSupplement.provider_video_id,
|
|
TestVideoSupplement.url,
|
|
TestVideoSupplement.embed_url,
|
|
TestVideoSupplement.embed,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def ratings():
|
|
return Ratings(TestRatings.month, TestRatings.week, TestRatings.day)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def made_for(user, case_forms):
|
|
return MadeFor(user, case_forms)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def play_counter():
|
|
return PlayCounter(TestPlayCounter.value, TestPlayCounter.description, TestPlayCounter.updated)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def playlist_absence():
|
|
return PlaylistAbsence(TestPlaylistAbsence.kind, TestPlaylistAbsence.reason)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def results(playlist):
|
|
return [playlist]
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def context():
|
|
return Context(TestContext.type_, TestContext.id_, TestContext.description)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def case_forms():
|
|
return CaseForms(
|
|
TestCaseForms.nominative,
|
|
TestCaseForms.genitive,
|
|
TestCaseForms.dative,
|
|
TestCaseForms.accusative,
|
|
TestCaseForms.instrumental,
|
|
TestCaseForms.prepositional,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def lyrics():
|
|
return Lyrics(
|
|
TestLyrics.id,
|
|
TestLyrics.lyrics,
|
|
TestLyrics.full_lyrics,
|
|
TestLyrics.has_rights,
|
|
TestLyrics.show_translation,
|
|
TestLyrics.text_language,
|
|
TestLyrics.url,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def poetry_lover_match():
|
|
return PoetryLoverMatch(TestPoetryLoverMatch.begin, TestPoetryLoverMatch.end, TestPoetryLoverMatch.line)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def images():
|
|
return Images(TestImages._208x208, TestImages._300x300)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def normalization():
|
|
return Normalization(TestNormalization.gain, TestNormalization.peak)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def mix_link():
|
|
return MixLink(
|
|
TestMixLink.title,
|
|
TestMixLink.url,
|
|
TestMixLink.url_scheme,
|
|
TestMixLink.text_color,
|
|
TestMixLink.background_color,
|
|
TestMixLink.background_image_uri,
|
|
TestMixLink.cover_white,
|
|
TestMixLink.cover_uri,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def title():
|
|
return Title(TestTitle.title, TestTitle.full_title)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def personal_playlists_data():
|
|
return PersonalPlaylistsData(TestPersonalPlaylistsData.is_wizard_passed)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def promotion():
|
|
return Promotion(
|
|
TestPromotion.promo_id,
|
|
TestPromotion.title,
|
|
TestPromotion.subtitle,
|
|
TestPromotion.heading,
|
|
TestPromotion.url,
|
|
TestPromotion.url_scheme,
|
|
TestPromotion.text_color,
|
|
TestPromotion.gradient,
|
|
TestPromotion.image,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def discrete_scale(value):
|
|
return DiscreteScale(TestDiscreteScale.type, TestDiscreteScale.name, value, value)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def major():
|
|
return Major(TestMajor.id, TestMajor.name)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def permissions():
|
|
return Permissions(TestPermissions.until, TestPermissions.values, TestPermissions.default)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def auto_renewable(product, user):
|
|
return AutoRenewable(
|
|
TestAutoRenewable.expires,
|
|
TestAutoRenewable.vendor,
|
|
TestAutoRenewable.vendor_help_url,
|
|
product,
|
|
TestAutoRenewable.finished,
|
|
user,
|
|
TestAutoRenewable.product_id,
|
|
TestAutoRenewable.order_id,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def passport_phone():
|
|
return PassportPhone(TestPassportPhone.phone)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def renewable_remainder():
|
|
return RenewableRemainder(TestRenewableRemainder.days)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def user():
|
|
return User(
|
|
TestUser.uid,
|
|
TestUser.login,
|
|
TestUser.name,
|
|
TestUser.display_name,
|
|
TestUser.full_name,
|
|
TestUser.sex,
|
|
TestUser.verified,
|
|
TestUser.regions,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def account(passport_phone):
|
|
return Account(
|
|
TestAccount.now,
|
|
TestAccount.service_available,
|
|
TestAccount.region,
|
|
TestAccount.uid,
|
|
TestAccount.login,
|
|
TestAccount.full_name,
|
|
TestAccount.second_name,
|
|
TestAccount.first_name,
|
|
TestAccount.display_name,
|
|
TestAccount.hosted_user,
|
|
TestAccount.birthday,
|
|
[passport_phone],
|
|
TestAccount.registered_at,
|
|
TestAccount.has_info_for_app_metrica,
|
|
TestAccount.child,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def plus():
|
|
return Plus(TestPlus.has_plus, TestPlus.is_tutorial_completed)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def price():
|
|
return Price(TestPrice.amount, TestPrice.currency)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def subscription(renewable_remainder, auto_renewable, operator, non_auto_renewable):
|
|
return Subscription(
|
|
renewable_remainder,
|
|
[auto_renewable],
|
|
[auto_renewable],
|
|
TestSubscription.had_any_subscription,
|
|
[operator],
|
|
non_auto_renewable,
|
|
TestSubscription.can_start_trial,
|
|
TestSubscription.mcdonalds,
|
|
TestSubscription.end,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def non_auto_renewable():
|
|
return NonAutoRenewable(TestNonAutoRenewable.start, TestNonAutoRenewable.end)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def deactivation():
|
|
return Deactivation(TestDeactivation.method, TestDeactivation.instructions)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def operator(deactivation):
|
|
return Operator(
|
|
TestOperator.product_id,
|
|
TestOperator.phone,
|
|
TestOperator.payment_regularity,
|
|
[deactivation],
|
|
TestOperator.title,
|
|
TestOperator.suspended,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def rotor_settings():
|
|
return RotorSettings(
|
|
TestRotorSettings.language,
|
|
TestRotorSettings.diversity,
|
|
TestRotorSettings.mood,
|
|
TestRotorSettings.energy,
|
|
TestRotorSettings.mood_energy,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def product(price, licence_text_part):
|
|
return Product(
|
|
TestProduct.product_id,
|
|
TestProduct.type,
|
|
TestProduct.common_period_duration,
|
|
TestProduct.duration,
|
|
TestProduct.trial_duration,
|
|
price,
|
|
TestProduct.feature,
|
|
TestProduct.debug,
|
|
TestProduct.plus,
|
|
TestProduct.cheapest,
|
|
TestProduct.title,
|
|
TestProduct.family_sub,
|
|
TestProduct.fb_image,
|
|
TestProduct.fb_name,
|
|
TestProduct.family,
|
|
TestProduct.features,
|
|
TestProduct.description,
|
|
TestProduct.available,
|
|
TestProduct.trial_available,
|
|
TestProduct.trial_period_duration,
|
|
TestProduct.intro_period_duration,
|
|
price,
|
|
TestProduct.start_period_duration,
|
|
price,
|
|
[licence_text_part],
|
|
TestProduct.vendor_trial_available,
|
|
TestProduct.button_text,
|
|
TestProduct.button_additional_text,
|
|
TestProduct.payment_method_types,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def playlist_id():
|
|
return PlaylistId(TestPlaylistId.uid, TestPlaylistId.kind)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def contest():
|
|
return Contest(
|
|
TestContest.contest_id, TestContest.status, TestContest.can_edit, TestContest.sent, TestContest.withdrawn
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session', params=[True, False])
|
|
def label(request):
|
|
if request.param:
|
|
return Label(TestLabel.id, TestLabel.name)
|
|
|
|
return TestLabel.another_representation_of_label
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_position():
|
|
return TrackPosition(TestTrackPosition.volume, TestTrackPosition.index)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def status(account, permissions, subscription, plus, station_data, alert):
|
|
return Status(
|
|
account,
|
|
permissions,
|
|
TestStatus.advertisement,
|
|
subscription,
|
|
TestStatus.cache_limit,
|
|
TestStatus.subeditor,
|
|
TestStatus.subeditor_level,
|
|
plus,
|
|
TestStatus.default_email,
|
|
TestStatus.skips_per_hour,
|
|
TestStatus.station_exists,
|
|
station_data,
|
|
alert,
|
|
TestStatus.premium_region,
|
|
TestStatus.experiment,
|
|
TestStatus.pretrial_active,
|
|
TestStatus.userhash,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def station_data():
|
|
return StationData(TestStationData.name)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def alert_button():
|
|
return AlertButton(TestAlertButton.text, TestAlertButton.bg_color, TestAlertButton.text_color, TestAlertButton.uri)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def alert(alert_button):
|
|
return Alert(
|
|
TestAlert.alert_id,
|
|
TestAlert.text,
|
|
TestAlert.bg_color,
|
|
TestAlert.text_color,
|
|
TestAlert.alert_type,
|
|
alert_button,
|
|
TestAlert.close_button,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def chart(track_id):
|
|
return Chart(
|
|
TestChart.position, TestChart.progress, TestChart.listeners, TestChart.shift, TestChart.bg_color, track_id
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def event(track, artist_event, album_event):
|
|
return Event(
|
|
TestEvent.id,
|
|
TestEvent.type,
|
|
TestEvent.type_for_from,
|
|
TestEvent.title,
|
|
[track],
|
|
[artist_event],
|
|
[album_event],
|
|
TestEvent.message,
|
|
TestEvent.device,
|
|
TestEvent.tracks_count,
|
|
TestEvent.genre,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def chart_info_menu_item():
|
|
return ChartInfoMenuItem(TestChartInfoMenuItem.title, TestChartInfoMenuItem.url, TestChartInfoMenuItem.selected)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def chart_info_menu(chart_info_menu_item):
|
|
return ChartInfoMenu([chart_info_menu_item])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def chart_info(playlist, chart_info_menu):
|
|
return ChartInfo(
|
|
TestChartInfo.id,
|
|
TestChartInfo.type,
|
|
TestChartInfo.type_for_from,
|
|
TestChartInfo.title,
|
|
chart_info_menu,
|
|
playlist,
|
|
TestChartInfo.chart_description,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def track_id():
|
|
return TrackId(TestTrackId.id, TestTrackId.track_id, TestTrackId.album_id, TestTrackId.from_)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def value():
|
|
return Value(TestValue.value, TestValue.name)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def id_():
|
|
return Id(TestId.type, TestId.tag)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def sequence(track):
|
|
return Sequence(TestSequence.type, track, TestSequence.liked)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def station(id_, icon, restrictions):
|
|
return Station(
|
|
id_,
|
|
TestStation.name,
|
|
icon,
|
|
icon,
|
|
icon,
|
|
TestStation.id_for_from,
|
|
restrictions,
|
|
restrictions,
|
|
TestStation.full_image_url,
|
|
TestStation.mts_full_image_url,
|
|
id_,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def shot_type():
|
|
return ShotType(TestShotType.id, TestShotType.title)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def shot_data(shot_type):
|
|
return ShotData(TestShotData.cover_uri, TestShotData.mds_url, TestShotData.shot_text, shot_type)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def shot(shot_data):
|
|
return Shot(TestShot.order, TestShot.played, shot_data, TestShot.shot_id, TestShot.status)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def chart_item(track, chart):
|
|
return ChartItem(track, chart)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def station_result(station, rotor_settings, ad_params):
|
|
return StationResult(
|
|
station,
|
|
rotor_settings,
|
|
rotor_settings,
|
|
ad_params,
|
|
TestStationResult.explanation,
|
|
TestStationResult.prerolls,
|
|
TestStationResult.rup_title,
|
|
TestStationResult.rup_description,
|
|
TestStationResult.custom_name,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def ad_params():
|
|
return AdParams(
|
|
TestAdParams.partner_id,
|
|
TestAdParams.category_id,
|
|
TestAdParams.page_ref,
|
|
TestAdParams.target_ref,
|
|
TestAdParams.other_params,
|
|
TestAdParams.ad_volume,
|
|
TestAdParams.genre_id,
|
|
TestAdParams.genre_name,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def restrictions(enum, discrete_scale):
|
|
return Restrictions(enum, enum, discrete_scale, discrete_scale, enum)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def results(
|
|
track,
|
|
artist,
|
|
album,
|
|
playlist,
|
|
video,
|
|
generated_playlist,
|
|
promotion,
|
|
chart_item,
|
|
play_context,
|
|
mix_link,
|
|
personal_playlists_data,
|
|
play_contexts_data,
|
|
user,
|
|
):
|
|
return {
|
|
1: track,
|
|
2: artist,
|
|
3: album,
|
|
4: playlist,
|
|
5: video,
|
|
6: generated_playlist,
|
|
7: promotion,
|
|
8: chart_item,
|
|
9: play_context,
|
|
10: mix_link,
|
|
11: personal_playlists_data,
|
|
12: play_contexts_data,
|
|
13: user,
|
|
14: album,
|
|
15: track,
|
|
}
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def types():
|
|
return {
|
|
1: 'track',
|
|
2: 'artist',
|
|
3: 'album',
|
|
4: 'playlist',
|
|
5: 'video',
|
|
6: 'personal-playlist',
|
|
7: 'promotion',
|
|
8: 'chart-item',
|
|
9: 'play-context',
|
|
10: 'mix-link',
|
|
11: 'personal-playlists',
|
|
12: 'play-contexts',
|
|
13: 'user',
|
|
14: 'podcast',
|
|
15: 'podcast_episode',
|
|
}
|
|
|
|
|
|
@pytest.fixture(scope='session', params=[1, 2, 3, 4, 5, 13, 14, 15])
|
|
def result_with_type(request, results, types):
|
|
return results[request.param], types[request.param]
|
|
|
|
|
|
@pytest.fixture(scope='session', params=[1, 2, 3, 4, 5, 13, 14, 15])
|
|
def best(request, results, types):
|
|
return Best(types[request.param], results[request.param], TestBest.text)
|
|
|
|
|
|
@pytest.fixture(scope='session', params=[1, 2, 3, 4, 5, 13, 14, 15])
|
|
def best_with_result(request, results, types):
|
|
return Best(types[request.param], results[request.param], TestBest.text), results[request.param]
|
|
|
|
|
|
@pytest.fixture(scope='session', params=[3, 4, 6, 7, 8, 9, 10])
|
|
def block_entity(request, results, types):
|
|
return BlockEntity(TestBlockEntity.id, types[request.param], results[request.param])
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def block(block_entity, data_with_type):
|
|
data, type_ = data_with_type
|
|
|
|
return Block(
|
|
TestBlock.id, type_, TestBlock.type_for_from, TestBlock.title, [block_entity], TestBlock.description, data
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session', params=[11, 12])
|
|
def data(request, results):
|
|
return results[request.param]
|
|
|
|
|
|
@pytest.fixture(scope='session', params=[11, 12])
|
|
def data_with_type(request, results, types):
|
|
return results[request.param], types[request.param]
|
|
|
|
|
|
@pytest.fixture(scope='session', params=[1, 2, 3, 4, 5])
|
|
def search_result_with_results_and_type(request, types, results):
|
|
return (
|
|
SearchResult(
|
|
types[request.param],
|
|
TestSearchResult.total,
|
|
TestSearchResult.per_page,
|
|
TestSearchResult.order,
|
|
[results[request.param]],
|
|
),
|
|
[results[request.param]],
|
|
types[request.param],
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def custom_wave():
|
|
return CustomWave(TestCustomWave.title, TestCustomWave.animation_url, TestCustomWave.position)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def r_128():
|
|
return R128(TestR128.i, TestR128.tp)
|
|
|
|
|
|
@pytest.fixture(scope='session')
|
|
def lyrics_info():
|
|
return LyricsInfo(TestLyricsInfo.has_available_sync_lyrics, TestLyricsInfo.has_available_text_lyrics)
|