import datetime import logging import warnings import allure import pytest from assertpy import assert_that from ui_automation_framework.utils import logger as cl from app.src.api.constants import APPLE, SPOTIFY from app.src.helpers.api_data_provider import ApiDataProvider from app.src.helpers.data_formaters import DataFormatter from app.src.helpers.test_data_helper import get_random_playlist from app.src.helpers.waiting_wrapper import wait from app.src.pages.login_page import LoginPage from app.src.pages.playlist_page import PlaylistPage from app.src.pages.playlist_placements_page import PlaylistPlacementsPage from app.src.pages.profile_page import ProfilePage from app.src.pages.search_page import SearchPage from app.src.pages.starred_page import StarredPage from app.src.pages.streams_by_markets_page import StreamsByMarketsPage from app.src.pages.track_page import TrackPage def check_vendor_in_playlist(playlist, vendor): return playlist.vendor == vendor @pytest.mark.usefixtures("set_up", "one_time_set_up", "authorized_api") class PlaylistPageTest: log = cl.Logger(logging.DEBUG) @pytest.fixture(autouse=True) def classSetup(self, authorized_api): self.api = authorized_api self.loginPage = LoginPage(self.driver, authorized_api) self.searchPage = SearchPage(self.driver, authorized_api) self.trackPage = TrackPage(self.driver, authorized_api) self.profilePage = ProfilePage(self.driver) self.playlistPage = PlaylistPage(self.driver, authorized_api) self.playlistsPage = PlaylistPlacementsPage(self.driver, authorized_api) self.starredPage = StarredPage(self.driver, authorized_api) self.streamsPage = StreamsByMarketsPage(self.driver, authorized_api) self.data_provider = ApiDataProvider(authorized_api) @allure.story("https://data-analytics.atlassian.net/browse/AG-7736") @allure.severity(allure.severity_level.CRITICAL) @allure.title("Playlist Page Header") @allure.description("Playlist header and content") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-7669" "https://data-analytics.atlassian.net/browse/AG-7667" "https://data-analytics.atlassian.net/browse/AG-7670") @pytest.mark.smoke def test_header(self): spotify_playlist_name = "Daily Lift" apple_playlist_name = "Today at Apple" spotify_position = next( filter( lambda x: x.name == spotify_playlist_name and check_vendor_in_playlist(x, SPOTIFY), self.api.apollo.get_playlist_search_results(spotify_playlist_name), ) ).position apple_position = next( filter( lambda x: x.name == apple_playlist_name and check_vendor_in_playlist(x, APPLE), self.api.apollo.get_playlist_search_results(apple_playlist_name), ) ).position self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) results = self.searchPage.get_result_playlists_title(spotify_position) self.searchPage.open_playlist_page_from_results(spotify_position) assert_that(self.playlistPage.is_playlist_page_opened_for_name(results), "Appropriate playlist is opened").is_true() self.playlistPage.click_back_button() self.searchPage.clear_search_field().open_playlist_page_from_results(1) assert_that(self.playlistPage.is_playlist_page_opened_for_name(results), "Appropriate playlist is opened").is_true() assert_that( self.playlistPage.is_personalized_playlist_page_header_displayed_first_slide(), "Playlist header is displayed", ).is_true() self.playlistPage.swipe_header_left(vendor="Spotify") assert_that( self.playlistPage.is_personalized_playlist_page_header_displayed_second_slide(), "Playlist header is displayed", ).is_true() self.playlistPage.click_back_button() self.searchPage.search_for(apple_playlist_name) results = self.searchPage.get_result_playlists_title(apple_position) self.searchPage.open_playlist_page_from_results(apple_position) assert_that(self.playlistPage.is_playlist_page_opened_for_name(results), "Appropriate playlist is opened").is_true() assert_that(self.playlistPage.is_apple_playlist_page_header_displayed_first_slide(), "Playlist header is displayed").is_true() self.playlistPage.swipe_header_left(vendor="Apple") assert_that(self.playlistPage.is_apple_playlist_page_header_displayed_second_slide(), "Playlist header is displayed").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7736") @allure.severity(allure.severity_level.NORMAL) @allure.title("Search") @allure.description("Test playlist page search") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6986, " "https://data-analytics.atlassian.net/browse/AG-6987, " "https://data-analytics.atlassian.net/browse/AG-6991") @pytest.mark.smoke def test_search(self): spotify_playlist_id, spotify_playlist_name = get_random_playlist("spotify") api_tracks_data = self.api.apollo.get_spotify_playlist_tracklist(spotify_playlist_id, "_gl", "current_position", 20)["body"]["items"][0] query_name = api_tracks_data["name"] query_artist = api_tracks_data["artists"][0] self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) playlist_title = self.searchPage.get_result_playlists_title(1) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_search_field() assert_that(self.playlistPage.is_playlists_search_screen_displayed(), "Playlists search wasn't opened").is_true() assert_that(self.playlistPage.get_playlists_search_results(), "Playlists search tracks count != 20").is_length(20) self.playlistPage.search_for_track_in_playlists(query_name) results = self.playlistPage.get_playlists_search_results() assert any(query_name in result for result in results), "Search results don't include query" self.playlistPage.clear_playlists_search_field().search_for_track_in_playlists(query_artist) results = self.playlistPage.get_playlists_search_results() assert any(query_artist in result for result in results), "Search results don't include query" self.playlistPage.clear_playlists_search_field().scroll_playlists_search_results() assert_that(self.playlistPage.is_playlists_search_screen_displayed(), "Playlists search header isn't displayed").is_true() self.playlistPage.click_playlists_search_cancel_button() assert_that(self.playlistPage.is_playlist_page_opened_for_name(playlist_title), "Appropriate playlist is opened").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7736") @allure.severity(allure.severity_level.NORMAL) @allure.title("Search") @allure.description("Test playlist page search") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6986, " "https://data-analytics.atlassian.net/browse/AG-6987, " "https://data-analytics.atlassian.net/browse/AG-6991") @pytest.mark.smoke def test_search_apple(self): market = "us" # In case the first track of the charts does not have any playlist for i in range(5): apple_test_track_data = self.data_provider.get_top_charts_apple_track_data(index=i) apple_playlist_data = self.data_provider.get_apple_playlist_data(apple_test_track_data[1], market) if apple_playlist_data: break apple_playlist_name = apple_playlist_data[0][:50] query_name = apple_test_track_data[0] query_artist_without_and = apple_test_track_data[2] query_artist_with_and = None if len(query_artist_without_and.split(",")) == 2: query_artist_with_and = " &".join(query_artist_without_and.split(",")) # in case if you have a comma, such as: 'Bad Bunny, Chencho Corleone' elif len(query_artist_without_and.split(",")) > 2: query_artist_with_and = ",".join(query_artist_without_and.split(",")[:-1]) + " &" + query_artist_without_and.split(",")[-1] playlist_position = next( filter( lambda x: x.vendor == APPLE and x.name == apple_playlist_name, self.api.apollo.get_playlist_search_results(apple_playlist_name), ) ).position self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(apple_playlist_name).open_playlist_page_from_results(playlist_position) self.playlistPage.click_search_field() assert_that(self.playlistPage.is_playlists_search_screen_displayed(), "Playlists search wasn't opened").is_true() assert_that(self.playlistPage.get_playlists_search_results(), "Playlists search tracks count != 20").is_length(20) self.playlistPage.search_for_track_in_playlists(query_name) results = self.playlistPage.get_playlists_search_results() assert any(query_name in result for result in results), "Search results don't include query" if query_artist_with_and: query_artist_name = query_artist_with_and else: query_artist_name = query_artist_without_and self.playlistPage.clear_playlists_search_field().search_for_track_in_playlists(query_artist_name) results = self.playlistPage.get_playlists_search_results() assert any(query_artist_name in result for result in results), "Search results don't include query" self.playlistPage.clear_playlists_search_field().scroll_playlists_search_results() assert_that(self.playlistPage.is_playlists_search_screen_displayed(), "Playlists search header isn't displayed").is_true() self.playlistPage.click_playlists_search_cancel_button() assert_that(self.playlistPage.is_playlist_page_opened_for_name(apple_playlist_name), "Appropriate playlist is opened").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Star/Unstar") @allure.description("User should be able to add track to the starred tracks screen") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6893") @pytest.mark.smoke def test_star_unstar_track_search(self): spotify_playlist_name = "Daily Lift" track_position_in_playlist = 1 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_search_field() playlist_track_name = self.playlistPage.get_track_name(1) self.playlistPage.swipe_track_in_tracklist(track_position_in_playlist).star_track(track_position_in_playlist).click_playlists_search_cancel_button().click_back_button().select_starred_tracks_tab() assert_that(self.starredPage.is_track_starred(playlist_track_name), "Track wasn't starred").is_true() self.starredPage.select_search_tab() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_search_field().swipe_track_in_tracklist(track_position_in_playlist).unstar_track(track_position_in_playlist).click_playlists_search_cancel_button().click_back_button().select_starred_tracks_tab() assert_that(self.starredPage.is_track_unstarred(playlist_track_name), "Track wasn't unstarred").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Star/Unstar Apple") @allure.description("User should be able to add track to the starred tracks screen") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6893") @pytest.mark.smoke def test_star_unstar_track_apple_search(self): playlist_id, apple_playlist_name = get_random_playlist("apple") track_position_in_playlist = 1 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(apple_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_search_field() playlist_track_name = self.playlistPage.get_track_name(1) self.playlistPage.swipe_track_in_tracklist(track_position_in_playlist).star_track(track_position_in_playlist).click_playlists_search_cancel_button().click_back_button().select_starred_tracks_tab() assert_that(self.starredPage.is_track_starred(playlist_track_name), "Track wasn't starred").is_true() self.starredPage.select_search_tab() self.searchPage.click_playlists_tab().search_for(apple_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_search_field().swipe_track_in_tracklist(track_position_in_playlist).unstar_track(track_position_in_playlist).click_playlists_search_cancel_button().click_back_button().select_starred_tracks_tab() assert_that(self.starredPage.is_track_unstarred(playlist_track_name), "Track wasn't unstarred").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Tracks sorting in a playlist") @allure.description("User should be able to sort palylists by date and position") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6977, " "https://data-analytics.atlassian.net/browse/AG-6979, " "https://data-analytics.atlassian.net/browse/AG-6978, " "https://data-analytics.atlassian.net/browse/AG-6980") @pytest.mark.smoke def test_sorting(self): spotify_playlist_name = "Daily Lift" self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_sorting_icon() assert_that(self.playlistPage.is_sorting_popup_opened(), "Sorting pop-up wasn't opened").is_true() self.playlistPage.select_sorting_by("Newest Adds") dates, positions = self.playlistPage.get_playlist_tracks_added_dates_and_positions() assert_that(dates, "Sorting order is not by the newest date").is_sorted() assert_that(positions, "Secondary sorting order is not by the position").is_sorted() assert_that(self.playlistPage.is_selected_sorting_title_displayed("NEWEST ADDS"), "Sorting type isn't displayed").is_true() self.playlistPage.click_sorting_icon().select_sorting_by("Position") positions = self.playlistPage.get_playlist_tracks_positions() assert_that(positions, "Sorting order is not by the position").is_sorted() assert_that(self.playlistPage.is_selected_sorting_title_displayed("POSITION"), "Sorting type isn't displayed").is_true() self.playlistPage.click_sorting_icon().select_sorting_by("Oldest Adds") dates, positions = self.playlistPage.get_playlist_tracks_added_dates_and_positions() assert_that(dates, "Sorting order is not by the oldest date").is_sorted(reverse=True) assert_that(positions, "Secondary sorting order is not by the position").is_sorted() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Tracks sorting in a playlist Apple") @allure.description("User should be able to sort palylists by date and position") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6977, " "https://data-analytics.atlassian.net/browse/AG-6979, " "https://data-analytics.atlassian.net/browse/AG-6978, " "https://data-analytics.atlassian.net/browse/AG-6980") @pytest.mark.smoke def test_sorting_apple(self): spotify_playlist_name = "Today at Apple" self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_sorting_icon() assert_that(self.playlistPage.is_sorting_popup_opened(), "Sorting pop-up wasn't opened").is_true() self.playlistPage.select_sorting_by("Newest Adds") data = self.playlistPage.get_playlist_tracks_added_dates_and_positions() dates = data[0] positions = data[1] assert_that(dates, "Sorting order is not by the newest date").is_sorted() assert_that(positions, "Secondary sorting order is not by the position").is_sorted() assert_that(self.playlistPage.is_selected_sorting_title_displayed("NEWEST ADDS"), "Sorting type isn't displayed").is_true() self.playlistPage.click_sorting_icon().select_sorting_by("Position") positions = self.playlistPage.get_playlist_tracks_positions() assert_that(positions, "Sorting order is by the position").is_sorted() assert_that(self.playlistPage.is_selected_sorting_title_displayed("POSITION"), "Sorting type isn't displayed").is_true() self.playlistPage.click_sorting_icon().select_sorting_by("Oldest Adds") data = self.playlistPage.get_playlist_tracks_added_dates_and_positions() dates = data[0] positions = data[1] assert_that(dates, "Sorting order is not by the oldest date").is_sorted(reverse=True) assert_that(positions, "Secondary sorting order is not by the position").is_sorted() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("i information icons") @allure.description("info icons should be displayed for personalized playlist") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6967, " "https://data-analytics.atlassian.net/browse/AG-6968") @pytest.mark.smoke def test_i_icon(self): spotify_playlist_name = "Daily Lift" # spotify_playlist_text = " Daily Lift By Spotify P " self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) # self.playlistPage.scroll_down() self.playlistPage.click_personalized_playlist_i_icon() assert_that(self.playlistPage.is_personalized_playlist_info_popup_shown(), "Info pop-up wasn't displayed").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Navigation to the track page and back from playlist placements spotify") @allure.description("User should be able to open the track from the playlist page and return back") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6951, " "https://data-analytics.atlassian.net/browse/AG-6952") @pytest.mark.smoke def test_navigation_to_the_track(self): spotify_playlist_name = "Daily Lift" # spotify_playlist_text = " Daily Lift By Spotify P " track_position_in_playlist = 2 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) track_name = self.playlistPage.get_track_name(track_position_in_playlist) self.playlistPage.click_track_card(track_position_in_playlist) assert_that(self.trackPage.is_track_page_opened(track_name), "Appropriate track wasn't opened").is_true() self.trackPage.close_track_page() assert_that( self.playlistPage.is_playlist_page_opened_for_name(spotify_playlist_name), "Playlist placement wasn't opened", ).is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Navigation to the track page and back from playlist placements spotify") @allure.description("User should be able to open the track from the playlist page and return back") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6951, " "https://data-analytics.atlassian.net/browse/AG-6952") @pytest.mark.smoke def test_navigation_to_the_track_apple(self): playlist_id, apple_playlist_name = get_random_playlist("apple") track_position_in_playlist = 2 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(apple_playlist_name) self.searchPage.open_playlist_page_from_results_by_text(apple_playlist_name) # self.searchPage.open_playlist_page_from_results(1) track_name = self.playlistPage.get_track_name(track_position_in_playlist) self.playlistPage.click_track_card(track_position_in_playlist) assert_that(self.trackPage.is_track_page_opened(track_name), "Appropriate track wasn't opened").is_true() self.trackPage.close_track_page() assert_that(self.playlistPage.is_playlist_page_opened_for_name(apple_playlist_name), "Playlist placement wasn't opened").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Star/Unstar") @allure.description("User should be able to add track to the starred tracks screen") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6893") @pytest.mark.smoke def test_star_unstar_track(self): spotify_playlist_name = "Daily Lift" track_position_in_playlist = 1 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) playlist_track_name = self.playlistPage.get_track_name(track_position_in_playlist) self.playlistPage.scroll_down_to_tracks().swipe_track_in_tracklist(track_position_in_playlist).star_track(track_position_in_playlist).click_back_button().select_starred_tracks_tab() assert_that(self.starredPage.is_track_starred(playlist_track_name), "Track wasn't starred").is_true() self.starredPage.select_search_tab() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.scroll_down_to_tracks().swipe_track_in_tracklist(track_position_in_playlist).unstar_track(track_position_in_playlist).click_back_button().select_starred_tracks_tab() assert_that(self.starredPage.is_track_unstarred(playlist_track_name), "Track wasn't unstarred").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Star/Unstar Apple") @allure.description("User should be able to add track to the starred tracks screen") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6893") @pytest.mark.smoke def test_star_unstar_track_apple(self): playlist_id, apple_playlist_name = get_random_playlist("apple") track_position_in_playlist = 1 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(apple_playlist_name) self.searchPage.open_playlist_page_from_results(1) playlist_track_name = self.playlistPage.get_track_name(track_position_in_playlist) self.playlistPage.scroll_down_to_tracks().swipe_track_in_tracklist(track_position_in_playlist).star_track(track_position_in_playlist).click_back_button().select_starred_tracks_tab() assert_that(self.starredPage.is_track_starred(playlist_track_name), "Track wasn't starred").is_true() self.starredPage.select_search_tab() self.searchPage.click_playlists_tab().search_for(apple_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.scroll_down_to_tracks().swipe_track_in_tracklist(track_position_in_playlist).unstar_track(track_position_in_playlist).click_back_button().select_starred_tracks_tab() assert_that(self.starredPage.is_track_unstarred(playlist_track_name), "Track wasn't unstarred").is_true() @pytest.mark.parametrize("playlist_name", ["Today's Top Hits", "Today at Apple"]) @allure.story("https://data-analytics.atlassian.net/browse/AG-8544") @allure.severity(allure.severity_level.NORMAL) @allure.title("Star/Unstar Spotify/Apple playlist") @allure.description("User should be able to add playlist to the starred playlist's screen") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-8533", "https://data-analytics.atlassian.net/browse/AG-8535") @pytest.mark.smoke def test_star_unstar_spotify_apple_playlist(self, playlist_name): self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(playlist_name) self.searchPage.swipe_playlist_on_search_results(1).star_on_search_results(1) self.searchPage.select_starred_tracks_tab() self.starredPage.click_on_playlists_tab() assert_that(self.starredPage.is_playlist_starred(playlist_name), "Playlist wasn't starred").is_true() self.starredPage.select_search_tab() self.searchPage.click_playlists_tab().search_for(playlist_name) self.searchPage.swipe_playlist_on_search_results(1).unstar_on_search_results(1) self.searchPage.select_starred_tracks_tab() self.starredPage.click_on_playlists_tab() assert_that(self.starredPage.is_playlist_starred(playlist_name), "Playlist is starred").is_false() self.starredPage.select_search_tab() self.searchPage.click_playlists_tab().search_for(playlist_name).open_playlist_page_from_results(1) self.playlistPage.star_playlist() self.playlistPage.click_back_button().select_starred_tracks_tab() self.starredPage.click_on_playlists_tab() assert_that(self.starredPage.is_playlist_starred(playlist_name), "Playlist wasn't starred").is_true() self.starredPage.select_search_tab() self.searchPage.click_playlists_tab().search_for(playlist_name).open_playlist_page_from_results(1) self.playlistPage.unstar_playlist() self.playlistPage.click_back_button().select_starred_tracks_tab() self.starredPage.click_on_playlists_tab() assert_that(self.starredPage.is_playlist_starred(playlist_name), "Playlist is starred").is_false() @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Pagination") @allure.description("User should be able to scroll tracks on the playlist screen screen") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6896" "https://data-analytics.atlassian.net/browse/AG-6876") @pytest.mark.smoke def test_pagination(self): apple_playlist_name = "Today's Hits" track_position_in_playlist = 19 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(apple_playlist_name) self.searchPage.open_playlist_page_from_results(1) assert_that(self.playlistPage.get_playlists_search_results()).is_length(20) last_track_title = self.playlistPage.get_track_name(track_position_in_playlist) self.playlistPage.scroll_down_to_tracks().scroll_down().scroll_down().scroll_down().scroll_down() new_last_track_title = self.playlistPage.get_track_name(track_position_in_playlist) assert_that(new_last_track_title).described_as("Pagination checking").is_not_equal_to(last_track_title) @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Track data for personalized playlist") @allure.description("Track data should match with the API") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6874") @pytest.mark.smoke def test_track_data_personalized(self): spotify_playlist_name = "Buen Vibe" spotify_playlist_id = "37i9dQZF1DXbT1642xPu6H" api_tracks_data = self.api.apollo.get_spotify_playlist_tracklist(spotify_playlist_id, "_gl", "current_position", 20, 0)["body"]["items"] self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) ui_tracks_data = self.playlistPage.get_playlists_search_results() for i in range(len(ui_tracks_data)): added_date = (datetime.datetime.today() - datetime.datetime.strptime(api_tracks_data[i]["added_date"], "%Y-%m-%d")).days added_date = DataFormatter.convert_days_to_years(added_date) streams_ui_info = ui_tracks_data[i].partition("Ago")[2] track_id = api_tracks_data[i]["track_id"] track_id = "5odlY52u43F5BjByhxg7wg" is_sony = self.api.gate.make_distributors_check("spotify", track_id) # is_sony = self.api.apollo.get_is_sony_go(track_id, "_gl")["body"] if is_sony[track_id] == track_id: assert_that(ui_tracks_data[i]).described_as("Sony label ").contains("SONY") start_date = self.data_provider.get_track_start_end_dates(api_tracks_data[i]["isrc"], 6)[0] end_date = self.data_provider.get_track_start_end_dates(api_tracks_data[i]["isrc"], 6)[1] track_streams_data_in_playlist = self.data_provider.get_streams_track_data_in_playlist(api_tracks_data[i]["isrc"], "spotify", spotify_playlist_id, "_gl", start_date, end_date) if track_streams_data_in_playlist: if track_streams_data_in_playlist[0] and track_streams_data_in_playlist[1]: streams_trend = round(((track_streams_data_in_playlist[0] - track_streams_data_in_playlist[1]) / track_streams_data_in_playlist[1]) * 100) streams_api = DataFormatter.round_streams(track_streams_data_in_playlist[0]) assert_that(ui_tracks_data[i], "Streams UI with API matching").contains(str(DataFormatter.round_streams_trend(abs(streams_trend)))) assert_that(ui_tracks_data[i], "Streams doesn't match API").contains(str(streams_api)) if streams_trend > 0: icon = "\ue905" elif streams_trend < 0: icon = "\ue902" else: icon = "\ue904" assert_that(streams_ui_info).contains(icon) elif track_streams_data_in_playlist[0] and not track_streams_data_in_playlist[1]: streams_api = DataFormatter.round_streams(track_streams_data_in_playlist[0]) assert_that(ui_tracks_data[i], "Streams matching with api").contains(str(streams_api)) else: assert_that(ui_tracks_data[i], "Streams matching with api").contains("N/A") if added_date: assert_that(ui_tracks_data[i]).described_as("Added date matching with api").contains(str(added_date)) else: assert_that(ui_tracks_data[i], "Added date matching with API").contains("Today") assert_that(ui_tracks_data[i]).described_as("Artist name matching").contains(api_tracks_data[i]["artists"][0]).described_as("Track name matching").contains(api_tracks_data[i]["name"]).described_as("Track position matching ").contains(str(api_tracks_data[i]["current_position"])) @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Track data for non personalized playlist") @allure.description("Track data should match with the API") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6874") @pytest.mark.smoke def test_track_data_non_personalized(self): spotify_playlist_name = "Today's Top Hits" spotify_playlist_id = "37i9dQZF1DXcBWIGoYBM5M" api_tracks_data = self.api.apollo.get_spotify_playlist_tracklist(spotify_playlist_id, "_gl", "current_position", 20)["body"]["items"] self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) ui_tracks_data = self.playlistPage.get_playlists_search_results() for i in range(len(ui_tracks_data)): added_date = (datetime.datetime.today() - datetime.datetime.strptime(api_tracks_data[i]["added_date"], "%Y-%m-%d")).days added_date = DataFormatter.convert_days_to_years(added_date) streams_ui_info = ui_tracks_data[i].partition("Ago") start_date = self.data_provider.get_track_start_end_dates(api_tracks_data[i]["isrc"], 6)[0] end_date = self.data_provider.get_track_start_end_dates(api_tracks_data[i]["isrc"], 6)[1] track_streams_data_in_playlist = self.data_provider.get_streams_track_data_in_playlist(api_tracks_data[i]["isrc"], "spotify", spotify_playlist_id, "_gl", start_date, end_date) if track_streams_data_in_playlist: if track_streams_data_in_playlist[0] and track_streams_data_in_playlist[1]: streams_trend = round(((track_streams_data_in_playlist[0] - track_streams_data_in_playlist[1]) / track_streams_data_in_playlist[1]) * 100) streams_api = DataFormatter.round_streams(track_streams_data_in_playlist[0]) assert_that(ui_tracks_data[i]).described_as("Stream trend").contains(DataFormatter.round_streams_trend(abs(streams_trend))).described_as("Stream data").contains(str(streams_api)) if streams_trend > 0: icon = "\ue905" elif streams_trend < 0: icon = "\ue902" else: icon = "\ue904" assert_that(streams_ui_info[2]).contains(icon) elif track_streams_data_in_playlist[0] and not track_streams_data_in_playlist[1]: streams_api = DataFormatter.round_streams(track_streams_data_in_playlist[0]) assert_that(ui_tracks_data[i]).contains(str(streams_api)) else: assert_that(ui_tracks_data[i]).contains("N/A") position_trend = api_tracks_data[i]["trend"] if added_date: assert_that(ui_tracks_data[i], "Added date").contains(str(added_date)) else: assert_that(ui_tracks_data[i], "Added date").contains("N/A") assert_that(ui_tracks_data[i]).described_as("Artist matching").contains(api_tracks_data[i]["artists"][0]).described_as("Track name matching").contains(api_tracks_data[i]["name"]).described_as("Track position matchingΩ").contains(str(api_tracks_data[i]["current_position"])) # Trend can be missed in case of new track if position_trend: if position_trend < 0: icon = "\ue905" elif position_trend > 0: icon = "\ue902" else: icon = "\ue904" assert_that(streams_ui_info[0]).contains(icon) @allure.story("https://data-analytics.atlassian.net/browse/AG-7088") @allure.severity(allure.severity_level.NORMAL) @allure.title("Track data for apple playlist") @allure.description("Track data should match with the API") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6874") @pytest.mark.smoke def test_track_data_apple(self): market = "us" # In case the first track of the charts does not have any playlist for i in range(5): apple_test_track_data = self.data_provider.get_top_charts_apple_track_data(index=i) apple_playlist_data = self.data_provider.get_apple_playlist_data(apple_test_track_data[1], market) if apple_playlist_data: break apple_playlist_name = apple_playlist_data[0][:50] apple_playlist_id = apple_playlist_data[1] apple_playlist_position = next( filter( lambda x: x.vendor == "apple" and x.name == apple_playlist_name, self.api.apollo.get_playlist_search_results(apple_playlist_name), ) ).position api_tracks_data = self.api.apollo.get_v1_apple_music_playlist_tracklist(apple_playlist_id, market, "current_position", 20)["body"]["items"] self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(apple_playlist_name).open_playlist_page_from_results(apple_playlist_position) ui_tracks_data = self.playlistPage.get_playlists_search_results() for i in range(len(ui_tracks_data)): if i == 13: print() added_date = (datetime.datetime.today() - datetime.datetime.strptime(api_tracks_data[i]["added_date"], "%Y-%m-%d")).days if added_date >= 365: added_date_in_years = int(added_date / 365) if added_date_in_years == 1: added_date = "1 Year Ago" else: added_date = f"{added_date_in_years} Years Ago" elif added_date == 0: added_date = "Today" elif added_date == 1: added_date = f"{added_date} Day Ago" else: added_date = f"{added_date} Days Ago" streams_ui_info = ui_tracks_data[i].partition("Ago") start_date = self.data_provider.get_track_start_end_dates(api_tracks_data[i]["isrc"], 6)[0] end_date = self.data_provider.get_track_start_end_dates(api_tracks_data[i]["isrc"], 6)[1] track_streams_data_in_playlist = self.data_provider.get_streams_track_data_in_playlist(api_tracks_data[i]["isrc"], "apple", apple_playlist_id, "us", start_date, end_date) if track_streams_data_in_playlist: if track_streams_data_in_playlist[0] and track_streams_data_in_playlist[1]: streams_trend = round(((track_streams_data_in_playlist[0] - track_streams_data_in_playlist[1]) / track_streams_data_in_playlist[1]) * 100) streams_api = DataFormatter.round_streams(track_streams_data_in_playlist[0]) assert_that(ui_tracks_data[i]).contains(str(DataFormatter.round_streams_trend(abs(streams_trend)))).contains(str(streams_api)) if streams_trend > 0: icon = "\ue905" elif streams_trend < 0: icon = "\ue902" else: icon = "\ue904" assert_that(streams_ui_info[2]).contains(icon) elif track_streams_data_in_playlist[0] and not track_streams_data_in_playlist[1]: streams_api = DataFormatter.round_streams(track_streams_data_in_playlist[0]) assert_that(ui_tracks_data[i]).contains(str(streams_api)) else: assert_that(ui_tracks_data[i]).contains("N/A") position_trend = api_tracks_data[i]["trend"] if added_date: assert_that(ui_tracks_data[i]).contains(added_date) else: assert_that(ui_tracks_data[i]).contains("N/A") assert_that(ui_tracks_data[i]).described_as("Artist name").contains(api_tracks_data[i]["artists"][0]).described_as("Track name").contains(api_tracks_data[i]["name"]).described_as("Track position").contains(str(api_tracks_data[i]["current_position"])) if position_trend is None and api_tracks_data[i]["is_new"]: warnings.warn(UserWarning("we are not able to check existence of blue dot")) continue elif position_trend is None and not api_tracks_data[i]["is_new"]: assert_that(streams_ui_info[0]).does_not_contain("\ue902", "\ue904", "\ue905") continue elif position_trend < 0: icon = "\ue905" elif position_trend > 0: icon = "\ue902" else: icon = "\ue904" assert_that(streams_ui_info[0]).contains(icon) @allure.story("https://data-analytics.atlassian.net/browse/AG-7811") @allure.severity(allure.severity_level.NORMAL) @allure.title("Extended navigation") @pytest.mark.regression def test_extended_navigation_e2e_flow(self): spotify_playlist_name = "Today's Top Hits" market = ["United States", "US", "Canada", "CA"] self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_track_card_for_sony_track(1) self.trackPage.click_select_market_button().select_market_via_search(market[0]) assert_that(self.trackPage.is_market_selected(market[1], market[0]), "Market is selected").is_true() self.trackPage.open_market_specific_market_detailed_page().open_date_picker() picker_dates = self.trackPage.get_date_picker_dates() self.trackPage.select_12_weeks_date_filter() assert_that(self.trackPage.is_12_weeks_date_filter_applied(picker_dates)).is_true() self.trackPage.open_date_picker().select_2_weeks_date_filter() assert_that(self.trackPage.is_2_weeks_date_filter_applied(picker_dates)).is_true() self.trackPage.open_combined_streams_detailed_view() assert_that(self.trackPage.is_detailed_streams_overview_opened(), "Verified detailed view is opened").is_true() self.trackPage.close_streams_overview_detailed_view() self.trackPage.scroll_to_streams_monitoring().click_audience_demographics_tile_1() assert_that(self.trackPage.is_demographics_popup_opened(), "Verified demographics popup is opened").is_true() self.trackPage.close_popup_tap_outside() self.trackPage.select_demographics_dsp("APPLE MUSIC").click_audience_demographics_tile_2() assert_that(self.trackPage.is_demographics_popup_opened(), "Verified demographics popup is opened").is_true() self.trackPage.close_popup_tap_outside() self.trackPage.select_stream_monitoring_apple_tab().select_stream_monitoring_amazon_tab().select_stream_monitoring_by_dsp_tab() self.trackPage.close_track_page() self.trackPage.click_top_5_show_all() assert_that(self.streamsPage.is_streams_by_markets_opened(), "Show all button is displayed").is_true() self.streamsPage.open_date_picker() assert_that(self.streamsPage.is_date_picker_opened(), "Verified date picker popup is opened").is_true() picker_dates = self.streamsPage.get_date_picker_dates() self.streamsPage.select_1_year_date_filter() assert_that(self.streamsPage.is_1_year_date_filter_applied_top_markets(picker_dates), "Verified filter applied").is_true() self.streamsPage.open_combined_graph_detailed() assert_that(self.streamsPage.is_detailed_combined_graph_opened(), "Verified detailed view is opened").is_true() self.streamsPage.close_combined_graph_detailed().click_top_5_show_all().open_all_markets_tab().search_for_market(market[0]).click_all_markets_card() assert_that(self.trackPage.is_market_changed(market[1]), "Verified appropriate market selected on market detailed page").is_true() self.streamsPage.close_track_page().close_track_page() self.trackPage.scroll_to_chart_placements().click_spotify_charts().close_track_page() self.trackPage.open_playlists().click_on_playlist_by_position(1) assert_that(self.playlistsPage.is_playlists_placements_page_opened(), "Playlists page wasn't opened").is_true() self.trackPage.close_track_page().close_track_page() if self.trackPage.is_lastes_adds_contains_playlists(): playlist_name = self.trackPage.get_latest_adds_playlist_title(1) self.trackPage.click_on_playlist_from_latest_adds() assert self.playlistsPage.is_playlists_placements_page_opened_for_name(playlist_name), "Appropriate playlist placements page wasn't opened" self.trackPage.close_track_page() if self.trackPage.is_top_5_contains_playlists(): playlist_name = self.trackPage.get_top_5_playlist_title() self.trackPage.click_on_playlist_from_top_5() assert self.playlistsPage.is_playlists_placements_page_opened_for_name(playlist_name), "Appropriate playlist placements page wasn't opened" @allure.story("https://data-analytics.atlassian.net/browse/AG-7832") @allure.severity(allure.severity_level.NORMAL) @allure.title("Playlists accordingly to the endpoint") @allure.description("Playlists in the search page should be displayed accordingly to the API") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-7707") @pytest.mark.smoke def test_playlist_search_accordingly_to_api(self): playlists_search_ids = self.api.apollo.get_search_history("playlist", 21)["body"]["items"] apple_ids = [item["id"] for item in playlists_search_ids if item["vendor"] == "apple"] spotify_ids = [item["id"] for item in playlists_search_ids if item["vendor"] == "spotify"] apple_params = "&".join(["id=" + id for id in apple_ids]) spotify_params = "&".join(["id=" + id for id in spotify_ids]) apple_playlist_data = self.api.gate.get_playlists_apple(apple_params)["body"] spotify_playlist_data = self.api.gate.get_playlists_spotify(spotify_params)["body"] self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab() playlists_data_ui = wait(self.searchPage.get_playlist_search_results_without_icons, waiting_for="playlists ui data") if len(apple_ids) > 0: for i in range(len(apple_playlist_data)): if not any(apple_playlist_data[i]["name"] in element for element in playlists_data_ui): raise AssertionError(f"Playlist name doesn't match with API {apple_playlist_data[i]['name']} not in {playlists_data_ui}") if apple_playlist_data[i]["owner"]: if not any(apple_playlist_data[i]["owner"] in element for element in playlists_data_ui): raise AssertionError(f"Playlist owner doesn't match with API {apple_playlist_data[i]['owner']} not in" f" {playlists_data_ui}") if len(spotify_ids) > 0: for i in range(len(spotify_playlist_data)): if not any(spotify_playlist_data[i]["name"] in element for element in playlists_data_ui): raise AssertionError(f"Playlist name doesn't match with API {spotify_playlist_data[i]['name']} not in {playlists_data_ui}") if spotify_playlist_data[i]["owner"]: if not any(spotify_playlist_data[i]["owner"] in element for element in playlists_data_ui): raise AssertionError(f"Playlist owner doesn't match with API {spotify_playlist_data[i]['owner']} not in" f" {playlists_data_ui}") @allure.story("https://data-analytics.atlassian.net/browse/AG-7832") @allure.severity(allure.severity_level.NORMAL) @allure.title("Playlists tracklist search results") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-7707") @pytest.mark.smoke def test_playlist_search_results_to_api(self): playlist_id, spotify_playlist_name = get_random_playlist("spotify") track = self.api.apollo.get_spotify_playlist_tracklist(playlist_id)["body"]["items"][0] track_query, track_isrc, track_id = track["name"], track["isrc"], track["track_id"] track_data_in_playlists = self.data_provider.get_spotify_track_data_in_playlist(track_isrc, playlist_id, "global") start_date = self.data_provider.get_track_start_end_dates(track_isrc, 6)[0] end_date = self.data_provider.get_track_start_end_dates(track_isrc, 6)[1] track_streams_data_in_playlists = self.data_provider.get_streams_track_data_in_playlist(track_isrc, "spotify", playlist_id, "_gl", start_date, end_date) playlist_position = next( filter( lambda x: x[1].id == playlist_id, enumerate(self.api.apollo.get_playlist_search_results(spotify_playlist_name), 1), ) )[0] self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(playlist_position) track_data_ui = self.playlistPage.click_search_field().search_for_track_in_playlists(track_query).get_playlists_search_results()[0] added_date_api = track_data_in_playlists.days_added streams_ui_info = track_data_ui.partition("Ago")[2] is_sony = self.api.gate.make_distributors_check("spotify", track_id) # is_sony = self.api.apollo.get_is_sony_go(track_id, "_gl")["body"] if is_sony[track_id] == track_id: assert_that(track_data_ui, "Sony labe").contains("SONY") if track_streams_data_in_playlists: if track_streams_data_in_playlists[0] and track_streams_data_in_playlists[1]: streams_trend = round(((track_streams_data_in_playlists[0] - track_streams_data_in_playlists[1]) / track_streams_data_in_playlists[1]) * 100) streams_api = DataFormatter.round_streams(track_streams_data_in_playlists[0]) assert_that(track_data_ui).contains(streams_api).contains(str(abs(streams_trend))) if streams_trend > 0: icon = "\ue905" elif streams_trend < 0: icon = "\ue902" else: icon = "\ue904" assert_that(streams_ui_info).contains(icon) elif track_streams_data_in_playlists[0] and not track_streams_data_in_playlists[1]: streams_api = DataFormatter.round_streams(track_streams_data_in_playlists[0]) assert_that(track_data_ui).contains(str(streams_api)) else: assert_that(track_data_ui).contains("N/A") position_api = track_data_in_playlists.current_position assert_that(track_data_ui).described_as("Track position").contains(str(abs(position_api))).described_as("Track name").contains(track_query).described_as("Added date").contains(added_date_api) @allure.story("https://data-analytics.atlassian.net/browse/AG-7832") @allure.severity(allure.severity_level.NORMAL) @allure.title("Playlists tracklist search results") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-7707") @pytest.mark.smoke def test_playlist_search_results_to_api_apple(self): market = "us" # In case the first track of the charts does not have any playlist for i in range(5): apple_test_track_data = self.data_provider.get_top_charts_apple_track_data(index=i) apple_playlist_data = self.data_provider.get_apple_playlist_data(apple_test_track_data[1], market) if apple_playlist_data: break apple_playlist_name = apple_playlist_data[0][:50] playlist_id = apple_playlist_data[1] track_query = apple_test_track_data[0] track_isrc = apple_test_track_data[1] self.api.apollo.get_playlist_search_results(apple_playlist_name) playlist_position = next( filter( lambda x: x.vendor == APPLE and x.name == apple_playlist_name, self.api.apollo.get_playlist_search_results(apple_playlist_name), ) ).position track_data_in_playlists = self.data_provider.get_apple_track_data_in_playlist(track_isrc, playlist_id, market) start_date = self.data_provider.get_track_start_end_dates(track_isrc, 6)[0] end_date = self.data_provider.get_track_start_end_dates(track_isrc, 6)[1] track_streams_data_in_playlists = self.data_provider.get_streams_track_data_in_playlist(track_isrc, "apple", playlist_id, market, start_date, end_date) self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(apple_playlist_name).open_playlist_page_from_results(playlist_position) track_data_ui = self.playlistPage.click_search_field().search_for_track_in_playlists(track_query).get_playlists_search_results()[0] added_date_api = str(track_data_in_playlists.days_added) track_name_api = track_query position_api = track_data_in_playlists.current_position position_trend_api = track_data_in_playlists.trend position_ui_info = track_data_ui.partition("Ago")[0] streams_ui_info = track_data_ui.partition("Ago")[2] if track_streams_data_in_playlists: if track_streams_data_in_playlists[0] and track_streams_data_in_playlists[1]: streams_trend = round(((track_streams_data_in_playlists[0] - track_streams_data_in_playlists[1]) / track_streams_data_in_playlists[1]) * 100) streams_api = DataFormatter.round_streams(track_streams_data_in_playlists[0]) assert_that(track_data_ui).described_as("Streams data ").contains(streams_api).described_as("Streams trend ").contains(str(abs(streams_trend))) if streams_trend > 0: icon = "\ue905" elif streams_trend < 0: icon = "\ue902" else: icon = "\ue904" assert_that(streams_ui_info, "Streams trend").contains(icon) elif track_streams_data_in_playlists[0] and not track_streams_data_in_playlists[1]: streams_api = DataFormatter.round_streams(track_streams_data_in_playlists[0]) assert_that(track_data_ui).contains(str(streams_api)) else: assert_that(track_data_ui).contains("N/A") assert_that(track_data_ui).described_as("Position").contains(str(abs(position_api))).described_as("Position trend ").contains(str(abs(position_trend_api))).described_as("Streams data").contains(track_name_api).described_as("Added date").contains(added_date_api) if position_trend_api < 0: icon = "\ue905" elif position_trend_api > 0: icon = "\ue902" else: icon = "\ue904" assert_that(position_ui_info, "Position trend").contains(icon) @allure.story("https://data-analytics.atlassian.net/browse/AG-7832") @allure.severity(allure.severity_level.NORMAL) @allure.title("Tracks sorting in a playlist on search") @allure.description("User should be able to sort palylists by date and position on search") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-7707") @pytest.mark.smoke def test_search_sorting(self): spotify_playlist_name = "Top Pop Hits" query = "It" self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(spotify_playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_sorting_icon() assert_that(self.playlistPage.is_sorting_popup_opened(), "Sorting pop-up wasn't opened").is_true() self.playlistPage.select_sorting_by("Newest Adds").click_search_field().search_for_track_in_playlists(query) dates, positions = self.playlistPage.get_playlist_tracks_added_dates_and_positions() assert_that(dates, "sorting order is by newest date").is_sorted() assert_that(positions).described_as("Secondary sorting is by position").is_sorted() assert_that(self.playlistPage.is_selected_sorting_title_displayed("NEWEST ADDS"), "Sorting type isn't displayed").is_true() self.playlistPage.clear_playlists_search_field() dates, positions = self.playlistPage.get_playlist_tracks_added_dates_and_positions() assert_that(dates).described_as("Sorting order is bby newest date").is_sorted() assert_that(positions, "Secondary sorting is by position").is_sorted() assert_that(self.playlistPage.is_selected_sorting_title_displayed("NEWEST ADDS"), "Sorting type isn't displayed").is_true() self.playlistPage.click_playlists_search_cancel_button().click_sorting_icon().select_sorting_by("Position").click_search_field().search_for_track_in_playlists(query) positions = self.playlistPage.get_playlist_tracks_positions() assert_that(positions).described_as("Sorting order is by position").is_sorted() assert_that(self.playlistPage.is_selected_sorting_title_displayed("POSITION"), "Sorting type isn't displayed").is_true() self.playlistPage.clear_playlists_search_field() positions = self.playlistPage.get_playlist_tracks_positions() assert_that(positions).described_as("Sorting order is by position").is_sorted() assert_that(self.playlistPage.is_selected_sorting_title_displayed("POSITION"), "Sorting type isn't displayed").is_true() self.playlistPage.click_playlists_search_cancel_button().click_sorting_icon().select_sorting_by("Oldest Adds").click_search_field().search_for_track_in_playlists(query) dates, positions = self.playlistPage.get_playlist_tracks_added_dates_and_positions() assert_that(dates).described_as("Sorting order is by oldest date").is_sorted(reverse=True) assert_that(positions).described_as("Secondary sorting is by position").is_sorted() self.playlistPage.clear_playlists_search_field() dates, positions = self.playlistPage.get_playlist_tracks_added_dates_and_positions() assert_that(dates).described_as("sorting order is by oldest date").is_sorted(reverse=True) assert_that(positions).described_as("Secondary sorting order is by the position").is_sorted() @allure.story("https://data-analytics.atlassian.net/browse/AG-7832") @allure.severity(allure.severity_level.NORMAL) @allure.title("Pagination Search") @allure.description("User should be able to scroll tracks on the playlist search screen") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-6896" "https://data-analytics.atlassian.net/browse/AG-6876") @pytest.mark.smoke def test_pagination_search(self): apple_playlist_name = "Top 100: USA" # apple_playlist_text = " Top 100: USA By SME Chart Curator " track_position_in_playlist = 19 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(apple_playlist_name) self.searchPage.open_playlist_page_from_results_by_text(apple_playlist_name) assert_that(self.playlistPage.click_search_field().get_playlists_search_results()).is_length(20) last_track_title = self.playlistPage.get_track_name(track_position_in_playlist) self.playlistPage.scroll_down_to_tracks().scroll_down().scroll_down().scroll_down().scroll_down() total_number_of_tracks_after_scroll = len(self.playlistPage.lt_playlist_tracks.texts) new_last_track_title = self.playlistPage.get_track_name(total_number_of_tracks_after_scroll) assert_that(new_last_track_title, "Pagination check").is_not_equal_to(last_track_title) @allure.story("https://data-analytics.atlassian.net/browse/AG-7832") @allure.severity(allure.severity_level.NORMAL) @allure.title("Navigation on search") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-7707") @pytest.mark.smoke def test_search_navigation(self): playlist_name = "Top Pop Hits" query = "It" track_position = 1 self.loginPage.login_as_regular_user() self.searchPage.click_playlists_tab().search_for(playlist_name) self.searchPage.open_playlist_page_from_results(1) self.playlistPage.click_search_field().search_for_track_in_playlists(query) track_name = self.playlistPage.get_track_name(track_position) self.playlistPage.click_track_card(track_position) assert_that(self.trackPage.is_track_page_opened(track_name), "Proper track page wasn't opened").is_true() self.trackPage.close_track_page() assert_that(self.playlistPage.is_initiated_search_displayed(query), "Search screen isn't displayed").is_true() @allure.story("https://data-analytics.atlassian.net/browse/AG-8261") @allure.severity(allure.severity_level.NORMAL) @allure.title("Tracklist Spotify") @allure.description("Tracklist and data") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-8214") @pytest.mark.smoke def test_tracklist_spotify(self): market = ["United States", "us"] playlist_name = "Today's Top Hits" playlist_id = "37i9dQZF1DXcBWIGoYBM5M" # playlist_data = self.data_provider.get_spotify_top_track_playlist_data(market[1]) tracklist_data = self.data_provider.get_tracklist_spotify_data_from_api(playlist_id, market[1]) self.loginPage.login_as_regular_user() self.profilePage.open_profile_screen_and_select_market(market[0]).select_search_tab() self.searchPage.click_playlists_tab().search_for(playlist_name).open_playlist_page_from_results(1) ui_tracklist_frontline_data = self.playlistPage.get_tracklist_frontline_data() ui_tracklist_sony_data = self.playlistPage.get_tracklist_sony_data() ui_tracklist_local_data = self.playlistPage.get_tracklist_local_data() assert_that(ui_tracklist_local_data, "Tracklist local data ").contains(tracklist_data[0]) assert_that(ui_tracklist_sony_data, "Tracklist sony data").contains(tracklist_data[1]) assert_that(ui_tracklist_frontline_data, "Tracklist frontline data").contains(tracklist_data[2]) @allure.story("https://data-analytics.atlassian.net/browse/AG-8261") @allure.severity(allure.severity_level.NORMAL) @allure.title("Tracklist Apple") @allure.description("Tracklist and data") @allure.testcase("https://data-analytics.atlassian.net/browse/AG-8215") @pytest.mark.smoke def test_tracklist_apple(self): market = ["United States", "us"] playlist_data = self.data_provider.get_apple_top_track_playlist_data(market[1]) tracklist_data = self.data_provider.get_tracklist_apple_data_from_api(playlist_data[1], market[1]) playlist_position = next( filter( lambda x: x.vendor == APPLE and x.name == playlist_data[0], self.api.apollo.get_playlist_search_results(playlist_data[0]), ) ).position self.loginPage.login_as_regular_user() self.profilePage.open_profile_screen_and_select_market(market[0]).select_search_tab() self.searchPage.click_playlists_tab().search_for(playlist_data[0]).open_playlist_page_from_results(playlist_position) ui_tracklist_frontline_data = self.playlistPage.get_tracklist_frontline_data() ui_tracklist_local_data = self.playlistPage.get_tracklist_local_data() assert_that(ui_tracklist_local_data, "Tracklist local data").contains(tracklist_data[0]) assert_that(ui_tracklist_frontline_data, "Tracklist frontline data").contains(tracklist_data[1])