import collections import datetime import logging import time from operator import itemgetter import allure from assertpy import assert_that from selenium.webdriver import ActionChains from ui_automation_framework.core import BasePage, TestStatus from ui_automation_framework.utils import AppConfig, CoreConfig from ui_automation_framework.utils import logger as cl from app.api_client import ApiClient from app.mysql_db_client_custom import MySqlClient from app.src.pages.add_track_popup import AddTrackPopup from app.src.pages.left_navigation_panel import LeftNavigationPanel from app.src.pages.login_page import LoginPage from app.src.pages.track_page import TrackPage class TrackComparisonPage(BasePage): log = cl.Logger(logging.DEBUG) def __init__(self, driver): super().__init__(driver) self.driver = driver self.track_comparison_page = self.get_page_locators("TrackComparisonPage", "comparison_elements.json") self.api_client = ApiClient() self.left_panel = LeftNavigationPanel(self.driver) self.loginPage = LoginPage(self.driver) self.add_track_popup = AddTrackPopup(self.driver) self.trackPage = TrackPage(self.driver) self.ts = TestStatus(self.driver) self.sql_client = MySqlClient() def is_tab_selected(self, locator, locator_type): attr_value = self.get_attribute_value(locator, locator_type, attribute="data-selected") self.ts.markFinal(attr_value == "selected", "{} tab is selected".format(locator)) @allure.step("Comparison Tool page is opened") def comparison_page_is_opened(self): add_button = self.wait_for_element_visible(*self.locator(self.track_comparison_page, "add_track_button")) is_add_track_button_displayed = self.is_element_displayed(element=add_button) is_no_track_text_1 = self.is_element_displayed(*self.locator(self.track_comparison_page, "no_track_text_1")) is_no_track_text_2 = self.is_element_displayed(*self.locator(self.track_comparison_page, "no_track_text_1")) self.left_panel.is_comparison_tab_selected() self.is_title_displayed() self.ts.markFinal( is_add_track_button_displayed == is_no_track_text_1 == is_no_track_text_2 == True, "comparison page opened with no tracks added", ) @allure.step("Comparison Tool title is displayed") def is_title_displayed(self): title = self.wait_for_element_visible(*self.locator(self.track_comparison_page, "title")) is_title_displ = self.is_element_displayed(element=title) self.ts.markFinal(is_title_displ, "title is displayed") @allure.step("Comparison Tool - verify add track button layout") def is_button_layout_changed_after_hover(self): button = self.wait_for_element_visible(*self.locator(self.track_comparison_page, "add_track_button")) color_before_hover = button.value_of_css_property("background-color") self.log.info("color before hover: {}".format(color_before_hover)) ActionChains(self.driver).move_to_element(button).perform() color_after_hover = button.value_of_css_property("background-color") self.log.info("color after hover: {}".format(color_after_hover)) return color_before_hover != color_after_hover @allure.step("Comparison Tool - click first add track button") def click_add_first_track_button(self): add_track = self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "add_track_button")) self.click_element(element=add_track) self.log.info("add first track button") @allure.step("Comparison Tool - click add card button") def click_add_second_track_button(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "add_track_button_second")) add_track_second = self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "add_track_button_second")) self.click_element(element=add_track_second) self.log.info("click add second track button") @allure.step("Comparison Tool - track is added to comparison") def is_track_added(self, track_name): added_element = f"//a[contains(@href, '/track/')]/*[text()='{track_name[0]}']" added_track = self.wait_for_element_visible(added_element, "xpath") added = self.is_element_displayed(element=added_track) self.log.info(f"track is added to comparison: {added}") return added @allure.step("Comparison Tool - remove all track through api with worker") def remove_tracks_if_present_with_worker(self, market): user_email = self.loginPage.get_user_email_with_worker() self.api_client.remove_all_track_from_comparison_page(market, user_email) @allure.step("Comparison Tool - get count of added tracks") def get_count_of_added_tracks(self): added_elements = "//a[contains(@href, '/track/')]" self.wait_for_element_visible(added_elements, "xpath") count = len(self.get_elements(added_elements, "xpath")) self.log.info("count of added tracks is: {}".format(count)) return count @allure.step("Comparison Tool - add card button is displayed") def is_add_card_displayed(self, displayed=True): is_displayed = self.is_element_displayed(*self.locator(self.track_comparison_page, "add_track_button_second")) if displayed: self.ts.markFinal(is_displayed, "add card button is displayed: {}".format(is_displayed)) else: self.ts.markFinal(is_displayed == False, "add card button is displayed: {}".format(is_displayed)) self.log.info("add card button is displayed: {}".format(is_displayed)) @allure.step("Comparison Tool - verify hover over playlist tab") def hover_over_playlist_details_tab_and_verify_highlighted(self): self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.driver.execute_script( "arguments[0].scrollIntoView(true);", self.get_element(*self.locator(self.track_comparison_page, "playlist-details-tab")), ) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist-details-tab")) tab = self.get_element(*self.locator(self.track_comparison_page, "playlist-details-tab")) color_before_hover = tab.value_of_css_property("background-color") self.log.info("color before hover: {}".format(color_before_hover)) ActionChains(self.driver).move_to_element(tab).perform() color_after_hover = tab.value_of_css_property("background-color") self.log.info("color after hover: {}".format(color_after_hover)) self.ts.markFinal( color_after_hover != color_before_hover, "color after hover is changed: {}".format(color_after_hover != color_before_hover), ) @allure.step("Comparison Tool - open playlist details section") def open_playlist_details(self): self.scroll_to_playlist_support() self.page_has_loaded() self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.click_element(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.page_has_loaded() self.is_tab_selected(*self.locator(self.track_comparison_page, "playlist-details-tab")) @allure.step("Comparison Tool - open stream details section") def open_stream_details(self): self.scroll_to_playlist_support() self.page_has_loaded() self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "stream-details-tab")) self.click_element(*self.locator(self.track_comparison_page, "stream-details-tab")) self.page_has_loaded() self.is_tab_selected(*self.locator(self.track_comparison_page, "stream-details-tab")) @allure.step("Comparison Tool - playlist details header is displayed") def playlist_details_is_header_displayed(self): return self.is_element_displayed(*self.locator(self.track_comparison_page, "playlist-details-header")) @allure.step("Comparison Tool - get track streams performance timeline") def get_track_streams_performance_timeline(self): self.scroll_to_track_streams_performance() self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "track_streams_performance-days")) elements = self.get_elements(*self.locator(self.track_comparison_page, "track_streams_performance-days")) timeline = [] for e in elements: timeline.append(str(self.get_text(element=e)).lower()) self.log.info("timeline in track streams perofmance is: {}".format(timeline)) return timeline @allure.step("Comparison Tool - wait for stream performance chart visible") def wait_for_stream_performance_graph_visible(self): self.wait_for_element_visible(*self.locator(self.track_comparison_page, "track_streams_performance-days")) def scroll_to_track_streams_performance(self): self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "comparison-tool-performance-title")) self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-performance-title")) @allure.step("Comparison Tool - get playlist details timeline") def get_playlist_details_timeline(self): self.scroll_to_playlist_support() self.open_playlist_details() self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist-details-column-header")) elements = self.get_elements(*self.locator(self.track_comparison_page, "playlist-details-column-header")) timeline = [] for e in elements: timeline.append(str(self.get_text(element=e)).lower()) self.log.info("timeline in playlist details is: {}".format(timeline)) is_order_displayed = self.is_element_displayed(*self.locator(self.track_comparison_page, "playlist_details_order-header")) self.ts.markFinal(is_order_displayed, "# column header is displayed: {}".format(is_order_displayed)) return timeline def scroll_to_playlist_support(self): self.driver.execute_script( "arguments[0].scrollIntoView(false);", self.get_element(*self.locator(self.track_comparison_page, "playlist-details-tab")), ) self.page_has_loaded() @allure.step("Comparison Tool - get playlist details positions") def get_playlist_details_positions(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist_details_position")) positions = [] elements = self.get_elements(*self.locator(self.track_comparison_page, "playlist_details_position")) for e in elements: positions.append(int(self.get_text(element=e))) self.log.info("positions: {}".format(positions)) return positions @allure.step("Comparison Tool - get playlist details art count") def get_playlist_details_art_count(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist_details_art")) elements = self.get_elements(*self.locator(self.track_comparison_page, "playlist_details_art")) self.log.info("art count: {}".format(len(elements))) return len(elements) @allure.step("Comparison Tool - get playlist details names") def get_playlist_details_names(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.page_has_loaded() titles = [] self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist_details_title")) self.page_has_loaded() time.sleep(5) elements = self.get_elements(*self.locator(self.track_comparison_page, "playlist_details_title")) for e in elements: titles.append(str(self.get_text(element=e)).strip().replace(" ", " ")) self.log.info("names: {}".format(titles)) return titles @allure.step("Comparison Tool - get spotify icons count") def get_spotify_icons_count(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist_details_spotify_icon")) elements = self.get_elements(*self.locator(self.track_comparison_page, "playlist_details_spotify_icon")) self.log.info("spotify icons count count: {}".format(len(elements))) return len(elements) @allure.step("Comparison Tool - get apple icons count") def get_apple_icons_count(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist_details_apple_icon")) elements = self.get_elements(*self.locator(self.track_comparison_page, "playlist_details_apple_icon")) self.log.info("apple icons count count: {}".format(len(elements))) return len(elements) @allure.step("Comparison Tool - get track lines count") def get_track_lines_count(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "playlist-details-tab")) self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist_details_tracks")) elements = self.get_elements(*self.locator(self.track_comparison_page, "playlist_details_tracks")) self.log.info("spotify icons count count: {}".format(len(elements))) return len(elements) @allure.step("Comparison Tool - get track track card identifier color") def get_track_card_identifier_color_by_id(self, id): self.scroll_to_element("//div[@id='comparison-tool-card-{}-indicator']/div".format(id), "xpath") self.page_has_loaded() self.wait_for_element_visible("//div[@id='comparison-tool-card-{}-indicator']/div".format(id), "xpath") color = self.get_element("//div[@id='comparison-tool-card-{}-indicator']/div".format(id), "xpath").value_of_css_property("background-color") self.log.info("track card identifier color is: {}".format(color)) return color @allure.step("Comparison Tool - get track line color") def get_track_line_name_color(self, id): locator = "(//div[contains(@id, 'track-{}')]/div/div/div/span)[1]" self.scroll_to_element(locator.format(id[2]), "xpath") self.page_has_loaded() self.wait_for_element_visible(locator.format(id[2]), "xpath") color = self.get_element(locator.format(id[2]), "xpath").value_of_css_property("color") text = self.get_text(locator.format(id[2]), "xpath") self.ts.markFinal(text == id[0], "track name is displayed on track line") self.log.info("color of track line name is: {}".format(color)) return color @allure.step("Comparison Tool - get track line color") def get_track_line_color(self, id): locator = "(//div[contains(@id, 'track-{}')]/div/div/div)[1]" self.scroll_to_element(locator.format(id), "xpath") self.page_has_loaded() self.wait_for_element_visible(locator.format(id), "xpath") color = self.get_element(locator.format(id), "xpath").value_of_css_property("background-color") self.log.info("color of track line name is: {}".format(color)) return color @allure.step("Comparison Tool - get tooltip from track line") def get_text_in_track_line_tooltip(self): self.wait_for_element_visible(locator="//*[text()='Period']", locator_type="xpath") self.scroll_to_element(locator="//*[text()='Period']", locator_type="xpath") locator = "//*[@id='playlist-support-row-1-track-1']/*/*/*[2]" element = self.wait_for_element_visible(locator=locator, locator_type="xpath") ActionChains(self.driver).move_to_element(to_element=element).perform() tool = self.wait_for_element_visible(locator="playlist-support-row-1-track-1-tooltip") text = self.get_text(element=tool) self.log.info("tooltip text: {}".format(text)) return text @allure.step("Comparison Tool - select period") def select_period_from_dd(self, period): self.wait_for_element_visible(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) current_period = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) if current_period != period: self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) self.click_element(period, *self.locator(self.track_comparison_page, "comparison-tool-period-dd")) source = f"//*[@id='comparison-tool-period-dd']/..//*[text()='{period}']" self.click_on_element_js(self.get_element(source, "xpath")) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) chosen_period = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) self.page_has_loaded() self.ts.markFinal(chosen_period == period, "chosen period is: {}".format(period)) @allure.step("Comparison Tool - get expected timeline") def get_expected_timeline(self, period): timeline = [] if period == "28 Days": timeline = ["1st fri", "day 4", "day 8", "day 12", "day 16", "day 20", "day 24", "day 28"] elif period == "14 Days": timeline = ["1st fri", "day 2", "day 4", "day 6", "day 8", "day 10", "day 12", "day 14"] elif period == "8 Weeks": timeline = ["1st fri", "week 1", "week 2", "week 3", "week 4", "week 5", "week 6", "week 7", "week 8"] elif period == "12 Weeks": timeline = ["1st fri", "week 2", "week 4", "week 6", "week 8", "week 10", "week 12"] elif period == "6 Months": timeline = ["1st fri", "month 1", "month 2", "month 3", "month 4", "month 5", "month 6"] elif period == "1 Year": timeline = ["1st fri", "month 2", "month 4", "month 6", "month 8", "month 10", "month 12"] else: self.log.info("wrong period selected") self.log.info("expected timeline is: {}".format(timeline)) return timeline @allure.step("Comparison Tool - select dsp from dd") def select_dsp_from_dd(self, dd, dsp): dsp_current = self.wait_for_element_visible("comparison-tool-{}-dsp-dd".format(dd), "id") current_dsp = self.get_text(element=dsp_current) if current_dsp != dsp: self.scroll_to_element("comparison-tool-{}-dsp-dd".format(dd), "id") item = self.get_element("comparison-tool-{}-dsp-dd".format(dd), "id") self.click_on_element_js(element=item) source = "//*[@id='comparison-tool-{}-dsp-dd']/..//*[text()='{}']".format(dd, dsp) source = self.get_element(source, "xpath") self.click_on_element_js(element=source) chosen_dsp = self.get_text("comparison-tool-{}-dsp-dd".format(dd), "id") self.ts.markFinal(chosen_dsp == dsp, "chosen period in dsp: {} is: {}".format(dd, chosen_dsp)) @allure.step("Comparison Tool - select market from dd") def select_market_from_dd(self, market): current_market = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) if market != current_market: self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) self.click_element(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) source = f"//*[@id='comparison-tool-market-dd']/..//*[text()='{market}']" self.click_on_element_js(self.get_element(source, "xpath")) chosen_dsp = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) self.page_has_loaded() self.ts.markFinal(chosen_dsp == market, "chosen market is : {}".format(market)) @allure.step("Comparison Tool - verify dsp values in dd") def verify_all_dsp_from_dd(self, dd, expected_values): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) values_locator = "//*[@id='comparison-tool-{}-dsp-dd']/div/div/div/div".format(dd) values_dsp = [] for e in self.get_elements(values_locator, "xpath"): text = self.get_text(element=e) if len(text) > 0: values_dsp.append(text) chosen_dsp = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) is_bolder = self.get_element("//*[@id='comparison-tool-{}-dsp-dd']/div/div/div/div/b[text()='{}']".format(dd, chosen_dsp), "xpath") is_bold_displayed = self.is_element_present(element=is_bolder) self.ts.markFinal(is_bold_displayed, "chosen dsp is displayed in bold") self.ts.markFinal( values_dsp == expected_values, f"dropdown list in {dd} dsp is correct, values: {values_dsp}\n expected: {expected_values}", ) @allure.step("Comparison Tool - select playlist support dsp") def playlist_details_select_dsp_from_dd(self, dsp): self.open_playlist_details() self.select_dsp_from_dd("support", dsp) @allure.step("Comparison Tool - select performance dsp") def track_performance_select_dsp_from_dd(self, dsp): self.select_dsp_from_dd("performance", dsp) @allure.step("Comparison Tool - select country dsp") def country_select_dsp_from_dd(self, dsp): self.open_stream_details() self.select_dsp_from_dd("country", dsp) @allure.step("Comparison Tool - select engagement dsp") def by_engagement_select_dsp_from_dd(self, dsp): self.open_stream_details() self.select_dsp_from_dd("engagement", dsp) @allure.step("Comparison Tool - select audience dsp") def audience_select_dsp_from_dd(self, dsp): self.open_stream_details() self.select_dsp_from_dd("audience", dsp) @allure.step("Comparison Tool - get current dsp in dd") def get_current_dsp(self, dd): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) chosen_dsp = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) return chosen_dsp @allure.step("Comparison Tool - verify dsp dd items hover") def verify_dsp_dd_hover(self, dd): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) self.click_element(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) chosen_dsp = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) source = "//*[@id='comparison-tool-{}-dsp-dd']/div/div/div/div/b[text()='{}']".format(dd, chosen_dsp) dsp_element = self.get_element(source, "xpath") color_before_hover = dsp_element.value_of_css_property("color") ActionChains(self.driver).move_to_element(to_element=dsp_element).perform() color_after_hover = dsp_element.value_of_css_property("color") self.click_element(*self.locator(self.track_comparison_page, "comparison-tool-{}-dsp-dd".format(dd))) self.log.info("color before hover: {}, after hover: {}".format(color_before_hover, color_after_hover)) self.ts.markFinal(color_before_hover != color_after_hover, "dsp item in dd is highlighted") @allure.step("Comparison Tool - get current market from dd") def get_selected_market(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) chosen_market = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) return chosen_market @allure.step("sticky headers are displayed") def verify_sticky_headers_displayed(self): self.wait_for_element_visible(*self.locator(self.track_comparison_page, "comparison-tool-sticky-header")) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist-details-sticky-header")) first_header_displayed = self.is_sticky_header_displayed() second_header_displayed = self.is_element_displayed(*self.locator(self.track_comparison_page, "playlist-details-column-header")) self.ts.markFinal(first_header_displayed == second_header_displayed == True, "both sticky headers are displayed") @allure.step("sticky header is displayed") def is_sticky_header_displayed(self): first_header_displayed = self.is_element_displayed(*self.locator(self.track_comparison_page, "comparison-tool-sticky-header")) return first_header_displayed @allure.step("click back to top button") def click_back_to_top_button(self): e = self.get_element(*self.locator(self.track_comparison_page, "back_to_top")) self.wait_for_element_visible(e) color_before_hover = e.value_of_css_property("box-shadow") self.log.info("color before hover: {}".format(color_before_hover)) ActionChains(self.driver).move_to_element(e).perform() color_after_hover = e.value_of_css_property("box-shadow") self.log.info("color after hover: {}".format(color_after_hover)) self.ts.markFinal(color_before_hover != color_after_hover, "color of back button is changed after hover") self.wait_for_element_visible(*self.locator(self.track_comparison_page, "back_to_top")) self.click_element(*self.locator(self.track_comparison_page, "back_to_top")) self.wait_for_element_not_visible(*self.locator(self.track_comparison_page, "back_to_top")) @allure.step("scroll to last row") def scroll_to_last_row(self): self.page_has_loaded() all_rows = self.get_elements("//*[contains(@id, 'playlist-support-row')]", "xpath") ActionChains(self.driver).move_to_element(all_rows[-1]).perform() self.page_has_loaded() @allure.step("add track to comparison") def add_card_to_comparison(self, track_name): self.click_add_second_track_button() self.add_track_popup.add_track_to_comparison(track_name) @allure.step("verify info icon and tooltip") def verify_info_icon_and_tooltip_for(self, tab, tooltip_text): locator_icon = self.is_icon_displayed(tab) tooltip_locator = "{}{}".format(locator_icon, "-tooltip") ActionChains(self.driver).move_to_element(to_element=self.get_element(locator_icon)).perform() tooltip_element = self.get_element(tooltip_locator) text = self.get_text(element=tooltip_element).replace("\n", "") self.log.info("tooltip text: {}".format(text)) self.ts.markFinal(text == tooltip_text, f"tooltip text for {tab} tooltip is correct \ntext: {text}\n expected: {tooltip_text}") @allure.step("verify info icon") def is_icon_displayed(self, tab): if tab == "support": self.open_playlist_details() locator_icon = "comparison-tool-{}-hint-icon".format(tab) self.wait_for_element_visible(locator_icon) icon_is_displayed = self.is_element_displayed(locator_icon) self.ts.markFinal(icon_is_displayed, "info icon in {} is displayed".format(tab)) return locator_icon @allure.step("remove all tracks from ui") def remove_all_tracks_ui(self): self.page_has_loaded() self.scroll_to_element(*self.locator(self.track_comparison_page, "remove_track_icons")) remove_icons = self.get_elements(*self.locator(self.track_comparison_page, "remove_track_icons")) for e in remove_icons: self.click_element(element=e) self.wait_for_element_not_visible(e) self.page_has_loaded() @allure.step("verify count of added tracks") def verify_added_tracks_count(self, param): self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "card_indicators")) count = len(self.get_elements(*self.locator(self.track_comparison_page, "card_indicators"))) self.ts.markFinal(count == param, "count of added tracks is: {}".format(count)) @allure.step("get playlist ids from db - spotify") def get_playlist_ids_spotify_from_db(self, isrcs, exit_dates, period): resp = self.sql_client.get_playlist_ids_spotify(isrcs=isrcs, exit_dates=exit_dates, period=period) self.log.info("spotify db ids are: {}".format(resp)) return resp @allure.step("get playlist ids from db for market - spotify") def get_playlist_ids_spotify_from_db_for_market(self, isrcs, exit_dates, period, market): resp = self.sql_client.get_playlist_ids_spotify_for_market(isrcs=isrcs, exit_dates=exit_dates, period=period, market=market) self.log.info("spotify db ids are: {}".format(resp)) return resp @allure.step("get playlist ids from db - apple") def get_playlist_ids_apple_from_db(self, isrcs, exit_dates, period): resp = self.sql_client.get_playlist_ids_apple(isrcs=isrcs, exit_dates=exit_dates, period=period) self.log.info("apple db ids are: {}".format(resp)) return resp @allure.step("get playlist ids from db for market - apple") def get_playlist_ids_apple_from_db_for_market(self, isrcs, exit_dates, period, market): resp = self.sql_client.get_playlist_ids_apple_for_market(isrcs=isrcs, exit_dates=exit_dates, period=period, market=market) self.log.info("apple db ids are: {}".format(resp)) return resp @allure.step("get playlist ids api") def get_playlists_from_api_get(self, tracks, apple_spotify, period, param): user_email = self.loginPage.get_user_email_with_worker() resp = self.api_client.get_playlist_ids_with_period_tracks(apple_spotify=apple_spotify, track=tracks, period=period, user=user_email, param_name=param) if param in ["streams"]: for i in range(0, len(resp)): resp[i] = int(resp[i]) self.log.info("{} {} ids are: {}".format(apple_spotify, param, resp)) return resp @allure.step("get playlist ids api - local market") def get_playlists_from_local_market_api_get(self, tracks, apple_spotify, period, param, market): user_email = self.loginPage.get_user_email_with_worker() resp = self.api_client.get_playlist_ids_with_period_tracks_for_market(apple_spotify=apple_spotify, track=tracks, period=period, user=user_email, param_name=param, market=market) self.log.info("{} {} ids are: {}".format(apple_spotify, param, resp)) return resp @allure.step("get playlist ids api - local market with token") def get_playlists_from_local_market_api_get_with_token(self, tracks, apple_spotify, period, param, market, token): resp = self.api_client.get_playlist_ids_with_period_tracks_for_market_with_token(apple_spotify=apple_spotify, track=tracks, period=period, token_s=token, param_name=param, market=market) self.log.info("{} {} ids are: {}".format(apple_spotify, param, resp)) return resp @allure.step("remove track by added order") def remove_track(self, track_added): self.page_has_loaded() locator = "comparison-tool-card-{}-close-icon".format(track_added) self.scroll_to_element(locator, "id") self.click_element(locator) self.wait_for_element_not_visible(locator=locator, locator_type="id") self.page_has_loaded() @allure.step("remove track icon verify layout") def remove_icon_verify_layout(self, track_added): self.page_has_loaded() locator = "//*[contains(@id, 'comparison-tool-card-{}-close-icon')]/parent::*".format(track_added) self.scroll_to_element(locator, "xpath") e = self.get_element(locator, "xpath") color_before = e.value_of_css_property("background-color") ActionChains(self.driver).move_to_element(to_element=e).perform() color_after = e.value_of_css_property("background-color") self.ts.markFinal( color_before != color_after, "layout changed after hover: before: {}, after: {}".format(color_before, color_after), ) @allure.step("playlist support - get displayed tracks") def get_playlist_tracks(self): locator = "//*[contains(@id, 'track')]/div/div/div/span" elements = self.get_elements(locator, "xpath") tracks = set() for e in elements: tracks.add(str(self.get_text(element=e))) self.log.info("displayed tracks in playlist support: {}".format(tracks)) return tracks @allure.step("playlist support - get spotify playlists ids from db") def get_spotify_playlist_ids_spotify_from_db_for_track(self, isrc, exit_date, period, country): names_db = self.sql_client.get_playlist_ids_spotify_for_track(isrc=isrc, exit_date=exit_date, period=period, country=country) self.log.info("spotify plasylist ids from db for track: {track}: {names_db}".format(track=isrc, names_db=names_db)) return names_db @allure.step("playlist support - get values from api for market") def get_playlists_from_local_market_for_track_api_get(self, apple_spotify, period, track, param, market): values_api = self.api_client.get_playlist_ids_with_period_for_track_for_market(apple_spotify=apple_spotify, track=track, period=period, param_name=param, market=market) if param in ["streams"]: for i in range(0, len(values_api)): values_api[i] = int(values_api[i]) self.log.info("{apple_spotify} values: {param} from api are: {values_api}".format(apple_spotify=apple_spotify, param=param, values_api=values_api)) return values_api @allure.step("playlist support - get spotify values from db for 7 days sorted for column") def get_spotify_7days_sorted_from_db_column(self, isrc, track_date, period, market, column): values_db = self.sql_client.get_spotify_playlist_sorting_7days_column(isrc=isrc, exit_date=track_date, period=period, country=market, column=column) self.log.info("spotify values from db for column: {column}: {values_db}".format(column=column, values_db=values_db)) return values_db @allure.step("playlist support - get apple values from db for market") def get_playlist_ids_apple_from_db_for_track(self, isrc, track_date, period, market): names_db = self.sql_client.get_playlist_ids_apple_for_track(isrc=isrc, exit_date=track_date, period=period, country=market) self.log.info("apple plasylist ids from db for track: {track}: {names_db}".format(track=isrc, names_db=names_db)) return names_db @allure.step("playlist support - get apple values from db for 7 days sorted for column") def get_7days_sorted_from_db_apple_column(self, isrc, track_date, period, market, column): values_db = self.sql_client.get_apple_playlist_sorting_7days_column(isrc=isrc, exit_date=track_date, period=period, country=market, column=column) self.log.info("apple values from db for column: {column}: {values_db}".format(column=column, values_db=values_db)) return values_db @allure.step("playlist support - calculate combined names from api") def calculate_combined_names(self, spotify_names, spotify_streams, apple_names, apple_streams): spotify_dict = dict(zip(spotify_names, spotify_streams)) apple_dict = dict(zip(apple_names, apple_streams)) spotify_dict.update(apple_dict) self.log.info("combined dict: {}".format(spotify_dict)) sorted_combined = collections.OrderedDict(sorted(spotify_dict.items(), key=itemgetter(1), reverse=True)) self.log.info("sorted combined: {}".format(sorted_combined)) names_combined = list(map(itemgetter(0), sorted_combined.items())) self.log.info("api name combined: {}".format(names_combined)) return names_combined @allure.step("playlist support - scan track performance tooltips text") def get_tooltip_info_track_performance(self, param=365 * 2): self.wait_for_stream_performance_graph_visible() e = self.get_element(*self.locator(self.track_comparison_page, "track_stream_performance_chart")) height = int(e.size["height"]) width = int(e.size["width"]) + 1 self.log.info("height: {height}, width: {width}".format(height=height, width=width)) step = int(width / param) self.log.info("step: {step}".format(step=step)) tooltips = [] for t in range(0, width, step): e = self.get_element(*self.locator(self.track_comparison_page, "track_stream_performance_chart")) ActionChains(self.driver).move_to_element_with_offset(to_element=e, xoffset=t, yoffset=height).perform() self.get_element(*self.locator(self.track_comparison_page, "tooltip")) text = str(self.get_text(*self.locator(self.track_comparison_page, "tooltip"))) if text not in [None, "None", ["None"], [None]]: if text.strip() not in tooltips: tooltips.append(text.strip()) self.log.info("tooltip text: {}".format(text)) self.log.info("track performance tooltip content: {}".format(tooltips)) return sorted(set(tooltips)) @allure.step("playlist support - get streams count from db for apple playlist id and market") def get_streams_count_for_apple_playlist_db(self, playlist_id, market): count = self.sql_client.get_streams_for_apple_playlist_with_id(playlist_id, market) self.log.info("apple streams count for id: {id} from db is: {count}".format(id=playlist_id, count=count)) return count @allure.step("playlist support - playlist param from api") def get_playlist_param_from_api_get(self, apple_spotify, period, track, param): user_email = self.loginPage.get_user_email_with_worker() resp = self.api_client.get_playlist_ids_with_period_track(apple_spotify=apple_spotify, track=track, period=period, user=user_email, param_name=param) self.log.info("{} {} ids are: {}".format(apple_spotify, param, resp)) return resp @allure.step("playlist support - get tooltip info for track and title") def get_tooltip_info_for_track_and_title(self, track_index, title_index, param, title_name): self.log.info("title index is {}".format(title_index)) if title_index > 2: self.scroll_to_element("playlist-support-row-{title_index}-playlist-title".format(title_index=(title_index - 2)), "id") self.wait_for_element_visible("playlist-support-row-{title_index}-playlist-title".format(title_index=title_index), "id") tracks = self.get_elements( "//*[@id='playlist-support-row-{row}-track-{track}']/div/div/*".format(row=title_index, track=track_index), "xpath", ) text_arr = [] for track in tracks: ActionChains(self.driver).move_to_element(to_element=track).perform() self.wait_for_element_visible("//*[contains(@id, 'tooltip-{param}')]".format(param=param), "xpath", timeout=2) text = self.get_text("//*[contains(@id, 'tooltip-{param}')]".format(param=param), "xpath") if text not in [None, "None", [None], ["None"]]: if param in ["added", "removed"]: text = datetime.datetime.strptime(text, self.trackPage.get_date_format_from_locale()).date() if text not in text_arr: text_arr.append(text) self.log.info("tooltip text: {}".format(text)) return text_arr @allure.step("playlist support - get date for track with playlist in db") def get_date_for_track_with_playlist(self, column, id, isrc): value = self.sql_client.get_value_for_track_with_playlist(column=column, id=id, isrc=isrc) self.log.info("{column} is {value}".format(column=column, value=value)) return value @allure.step("playlist support - get apple top 250 from db") def select_playlists_ids_for_28_days_top_250_apple(self, isrc, exit_date, period): value = self.sql_client.select_playlists_ids_for_28_days_top_250_apple(isrc=isrc, exit_date=exit_date, period=period) self.log.info("playlists ids from db are: {}".format(value)) return value @allure.step("playlist support - get date from api") def get_api_first_last_date_for_dsp(self, date, dsp, isrc): value = self.api_client.get_first_last_date_for_isrc(isrc=isrc) date_value = value[date][dsp][isrc] self.log.info("{date} for {dsp} for {isrc} from api: {date_value}".format(date=date, dsp=dsp, isrc=isrc, date_value=date_value)) return date_value @allure.step("playlist support - get all spotify playlists ids for global market for isrc and period") def select_all_spotify_playlists_ids_for_period_db(self, isrc, exit_date, period): values = self.sql_client.select_all_spotify_playlists_ids_for_period(isrc=isrc, exit_date=exit_date, period=period) self.log.info("playlists ids from db : {}".format(values)) return values @allure.step("playlist support - get get custom playlists from spotify from db") def get_custom_playlists_spotify_db(self): values = self.sql_client.select_custom_playlists_spotify() self.log.info("custom playlists from db: {}".format(values)) return values @allure.step("read values from file") def read_from_file(self, param): file = open("app/src/data/{param}.txt".format(param=param)) list = file.readlines() ids = [] for i in list: ids.append(str(i).rstrip()) self.log.info("ids from file: {}".format(ids)) return ids @allure.step("playlist support - get dates for track history db") def get_dates_for_track_history_spotify(self, id, isrc, column): dates = self.sql_client.select_dates_for_track_history_spotify(id=id, isrc=isrc, column=column) self.log.info("{column} for {isrc} and {id}: {dates}".format(column=column, isrc=isrc, id=id, dates=dates)) return dates @allure.step("playlist support - get spotify streams from db") def get_spotify_streams_db(self, ids): values = self.sql_client.get_spotify_streams(ids=ids) self.log.info("streams from db: {}".format(values)) return values @allure.step("playlist support - get track history for playlist for country and store and isrc from db") def get_apple_playlists_track_belongs_to_db(self, country, store, isrc, column, id=""): values = self.sql_client.select_apple_playlists_track_belongs_to(id=id, country=country, store=store, isrc=isrc, column=column) self.log.info("values: {}".format(values)) return values @allure.step("playlist support - get track history for playlist for country and store and isrc from db") def get_selected_apple_track_history_in_playlist_db(self, store, isrc, column, id=""): values = self.sql_client.select_apple_track_history_in_playlist(id=id, store=store, isrc=isrc, column=column) self.log.info("values: {}".format(values)) return values @allure.step("playlist support - playlist names from top 200 spotify from db") def get_playlist_name_from_top_200_spotify(self, id, country): values = self.sql_client.select_playlist_name_from_top_200_spotify(id=id, country=country) self.log.info("values: {}".format(values)) return values @allure.step("playlist support - get dates of track in playlist spotify from db") def get_dates_track_in_playlist(self, track_id, playlist_id): values = self.sql_client.select_dates_track_in_playlist_db(track_id=track_id, playlist_id=playlist_id) self.log.info("values: {}".format(values)) return values @allure.step("playlist support - get track history spotify for playlist for country and store and isrc from db") def get_spotify_playlists_track_belongs_to_db(self, country, isrc): values = self.sql_client.select_spotify_playlists_track_belongs_to(country=country, isrc=isrc) self.log.info("values: {}".format(values)) return values @allure.step("playlist support - playlist ids from top 250 apple from db") def select_playlists_ids_top_250_apple(self, country, id): values = self.sql_client.select_playlist_name_from_top_250_apple(id=id, country=country) self.log.info("values: {}".format(values)) return values @allure.step("playlist support - is empty") def empty_playlist_support_displayed(self): self.open_playlist_details() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "playlist_support_empty")) no_playlists = self.is_element_present(*self.locator(self.track_comparison_page, "playlist_support_empty")) self.ts.markFinal(no_playlists, "empty playlist support section is displayed") @allure.step("track performance - get tooltip day after ff") def get_tooltip_day_after_ff(self, day, tooltips): tooltip = "" for t in tooltips: if "Days after First Friday: {day}".format(day=day) in t: tooltip = t self.log.info("tooltip for day {} is: {}".format(day, tooltip)) return tooltip @allure.step("track performance - get first date for all dsps") def get_api_first_date_all_dsp(self, isrc): value = self.api_client.get_first_last_date_for_isrc(isrc=isrc) self.log.info("full response: {}".format(value)) dates = [] for d in ["amazon", "spotify", "apple"]: date_str = value["first_stream_date"][d][isrc] dates.append(datetime.datetime.strptime(date_str, "%Y-%m-%d").date()) self.log.info("dates for isrcs: {} are: {}".format(isrc, dates)) self.log.info("min date is: {}".format(min(dates))) return min(dates) @allure.step("track performance - get tooltips with text") def get_tooltips_with_text(self, text, tooltips): elements = [] for t in tooltips: if text in t: elements.append(t) return elements @allure.step("track performance - get all sections witn n/a") def get_all_section_with_na(self): self.open_stream_details() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "empty_section")) elements = self.get_elements(*self.locator(self.track_comparison_page, "empty_section")) return elements def select_source_from_dd(self, param, dd): current_source = self.get_text("comparison-tool-{}-source-dd".format(dd), "id") if current_source != param: self.scroll_to_element("comparison-tool-{}-source-dd".format(dd), "id") self.wait_for_element_clickable("comparison-tool-{}-source-dd".format(dd), "id") self.click_on_element_js(self.get_element("comparison-tool-{}-source-dd".format(dd), "id")) source = "//*[@id='comparison-tool-{}-source-dd']/..//*[text()='{}']".format(dd, param) self.click_on_element_js(self.get_element(source, "xpath")) chosen_dsp = self.get_text("comparison-tool-{}-source-dd".format(dd), "id") self.page_has_loaded() self.ts.markFinal(chosen_dsp == param, "chosen source in : {} is: {}".format(dd, chosen_dsp)) @allure.step("comparison tool - country select source") def country_select_source(self, param): current_source = self.country_get_current_source() if current_source != param: self.select_source_from_dd(param, "country") @allure.step("comparison tool - track performance select source") def track_performance_select_source(self, param): self.select_source_from_dd(param, "performance") @allure.step("comparison tool - track performance get legend streams") def get_track_performance_legend_streams(self): self.wait_for_stream_performance_graph_visible() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "legend_streams")) elements = self.get_elements(*self.locator(self.track_comparison_page, "legend_streams")) streams = [str(self.get_text(element=e)).replace(",", "") for e in elements] self.log.info("streams in legend: {}".format(streams)) return streams @allure.step("comparison tool - track performance is displayed empty") def empty_track_performance_displayed(self): self.wait_for_element_visible(*self.locator(self.track_comparison_page, "empty_track_performance")) no_playlists = self.is_element_present(*self.locator(self.track_comparison_page, "empty_track_performance")) self.ts.markFinal(no_playlists, "empty track performance section is displayed") @allure.step("comparison tool - By DSP get tooltips") def by_dsp_get_tooltips(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "by_dsp_chart")) elements = self.get_elements( locator="//*[@id='comparison-tool-dsp-chart']/..//*[contains(@class," "'highcharts-point')]", locator_type="xpath", ) tooltips = [] for t in elements: t = self.get_elements( locator="//*[@id='comparison-tool-dsp-chart']/..//*[contains(@class,'highcharts-point')]", locator_type="xpath", )[elements.index(t)] ActionChains(self.driver).move_to_element(to_element=t).perform() text = str(self.get_text(*self.locator(self.track_comparison_page, "tooltip"))) if text not in ["", None, "None", ["None"], [None]]: if text.strip() not in tooltips: tooltips.append(text.strip()) self.log.info("tooltip text: {}".format(text)) self.log.info("By DSP tooltip content: {}".format(tooltips)) return tooltips @allure.step("comparison tool - By DSP get tooltips parsed") def by_dsp_get_tooltips_parsed(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "by_dsp_chart")) elements = self.get_elements( locator="//*[@id='comparison-tool-dsp-chart']/..//*[contains(@class, 'highcharts-point')]", locator_type="xpath", ) tooltips = [] for t in elements: t = self.get_elements( locator="//*[@id='comparison-tool-dsp-chart']/..//*[contains(@class,'highcharts-point')]", locator_type="xpath", )[elements.index(t)] ActionChains(self.driver).move_to_element(to_element=t).perform() main_locator = "comparison-tool-dsp-chart-tooltip-{}" text = str(self.get_text(*self.locator(self.track_comparison_page, "tooltip"))) if text not in ["", None, "None", ["None"], [None]]: spotify_name = "0" spotify_color = "0" spotify_value = "0" apple_name = "0" apple_color = "0" apple_value = "0" amazon_name = "0" amazon_value = "0" amazon_color = "0" track_name = str(self.get_text(main_locator.format("track-name"))) track_date = str(self.get_text(main_locator.format("track-date"))) if len(self.get_elements(main_locator.format("spotify-name"))) > 0: spotify_name = str(self.get_text(main_locator.format("spotify-name"))) spotify_color = self.get_element(main_locator.format("spotify-color")).value_of_css_property("background-color") spotify_value = str(self.get_text(main_locator.format("spotify-value"))) if len(self.get_elements(main_locator.format("apple-name"))) > 0: apple_name = str(self.get_text(main_locator.format("apple-name"))) apple_color = self.get_element(main_locator.format("apple-color")).value_of_css_property("background-color") apple_value = str(self.get_text(main_locator.format("apple-value"))) if len(self.get_elements(main_locator.format("amazon-name"))) > 0: amazon_name = str(self.get_text(main_locator.format("amazon-name"))) amazon_value = str(self.get_text(main_locator.format("amazon-value"))) amazon_color = self.get_element(main_locator.format("amazon-color")).value_of_css_property("background-color") total = str(self.get_text(main_locator.format("total"))) total_value = str(self.get_text(main_locator.format("total-value"))) tooltip = { "track_name": track_name, "track_date": track_date, "spotify_name": spotify_name, "apple_name": apple_name, "amazon_name": amazon_name, "spotify_value": spotify_value, "apple_value": apple_value, "amazon_value": amazon_value, "spotify_color": spotify_color, "apple_color": apple_color, "amazon_color": amazon_color, "total": total, "total_value": total_value, } if tooltip not in ["", None, "None", ["None"], [None]]: if tooltip not in tooltips: tooltips.append(tooltip) self.log.info("tooltip text: {}".format(tooltip)) self.log.info("By DSP tooltip content: {}".format(tooltips)) return tooltips @allure.step("comparison tool - By DSP get table values") def get_by_dsp_table_values(self): self.page_has_loaded() names_locator = "//*[contains(@id, 'comparison-tool-dsp-table-cell-name-')]" self.scroll_to_element(names_locator, "xpath") self.wait_for_element_visible(names_locator, "xpath") names_el = self.get_elements(names_locator, "xpath") spotify_el = self.get_elements("//*[contains(@id, 'comparison-tool-dsp-table-cell-spotify-total-')]/*/*/*[1]", "xpath") apple_el = self.get_elements("//*[contains(@id, 'comparison-tool-dsp-table-cell-apple-total-')]/*/*/*[1]", "xpath") amazon_el = self.get_elements("//*[contains(@id, 'comparison-tool-dsp-table-cell-amazon-total-')]/*/*/*[1]", "xpath") spotify_percentage = self.get_elements("//*[contains(@id, 'comparison-tool-dsp-table-cell-spotify-total-')]/*/*/*[2]", "xpath") apple_percentage = self.get_elements("//*[contains(@id, 'comparison-tool-dsp-table-cell-apple-total-')]/*/*/*[2]", "xpath") amazon_percentage = self.get_elements("//*[contains(@id, 'comparison-tool-dsp-table-cell-amazon-total-')]/*/*/*[2]", "xpath") total_el = self.get_elements("//*[contains(@id, 'comparison-tool-dsp-table-cell-total-')]/*/*/*[1]", "xpath") order = self.get_elements("//*[contains(@id, 'comparison-tool-dsp-table-cell-position-')]", "xpath") names = [self.get_text(element=t) for t in names_el] spotify = [self.get_text(element=t) for t in spotify_el] apple = [self.get_text(element=t) for t in apple_el] amazon = [self.get_text(element=t) for t in amazon_el] spotify_p = [int(str(self.get_text(element=t)).replace("%", "").replace("N/A", "0").replace("None", "0")) for t in spotify_percentage] apple_p = [int(str(self.get_text(element=t)).replace("%", "").replace("N/A", "0").replace("None", "0")) for t in apple_percentage] amazon_p = [int(str(self.get_text(element=t)).replace("%", "").replace("N/A", "0").replace("None", "0")) for t in amazon_percentage] total = [self.get_text(element=t) for t in total_el] order = [int(self.get_text(element=t)) for t in order] values = dict( zip( [ "name", "spotify", "apple", "amazon", "spotify_percentage", "apple_percentage", "amazon_percentage", "total", "order", ], [names, spotify, apple, amazon, spotify_p, apple_p, amazon_p, total, order], ) ) self.log.info("By DSP table values: {}".format(values)) return values @allure.step("comparison tool - get release track hint") def get_release_hint_with_track_index(self, param): locator = "//*[@id='comparison-tool-card-{}-indicator']/..//*[contains(text(), 'RELEASED')]".format(param) self.scroll_to_element(locator, "xpath") e = self.wait_for_element_visible(locator, "xpath") ActionChains(self.driver).move_to_element(to_element=e).perform() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "tooltip"), timeout=0.5) text = str(self.get_text(*self.locator(self.track_comparison_page, "tooltip"))) self.log.info("hint text is: {}".format(text)) return text @allure.step("comparison tool - get release date") def get_release_date_with_track_index(self, param): locator = "//*[@id='comparison-tool-card-{}-indicator']/..//*[contains(text(), 'RELEASED')]".format(param) self.scroll_to_element(locator, "xpath") e = self.wait_for_element_visible(locator, "xpath") text = datetime.datetime.strptime(str(self.get_text(element=e)).split(" ")[1], self.trackPage.get_date_format_from_locale()).date() self.log.info("release date is: {}".format(text)) return text @allure.step("comparison tool - By Engagement get tooltips") def by_engagement_get_graph_tooltips(self): self.page_has_loaded() self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "engagement_chart")) chart = self.get_elements(*self.locator(self.track_comparison_page, "engagement_chart")) tooltips = [] for e in chart: self.wait_for_element_visible(*self.locator(self.track_comparison_page, "engagement_chart")) e = self.get_elements(*self.locator(self.track_comparison_page, "engagement_chart"))[chart.index(e)] ActionChains(self.driver).move_to_element(to_element=e).perform() tool = self.wait_for_element_visible(*self.locator(self.track_comparison_page, "tooltip"), timeout=2) text = self.get_text(element=tool) self.log.info("tooltip text: {}".format(text)) tooltips.append(text) self.log.info("By Engagement tooltip content: {}".format(tooltips)) return sorted(set(tooltips)) @allure.step("comparison tool - By Engagement get tooltips parsed") def by_engagement_get_graph_tooltips_parsed(self): self.page_has_loaded() self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "engagement_chart")) chart = self.get_elements(*self.locator(self.track_comparison_page, "engagement_chart")) tooltips = [] for t in chart: t = self.get_elements(*self.locator(self.track_comparison_page, "engagement_chart"))[chart.index(t)] ActionChains(self.driver).move_to_element(to_element=t).perform() main_locator = "comparison-tool-engagement-chart-tooltip-{}" text = str(self.get_text(*self.locator(self.track_comparison_page, "tooltip"))) if text not in ["", None, "None", ["None"], [None]]: track_name = str(self.get_text(main_locator.format("track-name"))) track_date = str(self.get_text(main_locator.format("track-date"))) lean_forward_count = int(str(self.get_text(main_locator.format("0-value"))).split(" ")[0].replace(",", "")) lean_back_count = int(str(self.get_text(main_locator.format("1-value"))).split(" ")[0].replace(",", "")) lean_forward_percent = int(str(self.get_text(main_locator.format("0-value"))).split(" ")[1].replace("(", "").replace(")", "").replace("%", "")) lean_back_percent = int(str(self.get_text(main_locator.format("1-value"))).split(" ")[1].replace("(", "").replace(")", "").replace("%", "")) total_value = int(str(self.get_text(main_locator.format("total-value"))).replace(",", "")) tooltip = { "track_name": track_name, "track_date": track_date, "lean_forward_count": lean_forward_count, "lean_back_count": lean_back_count, "lean_forward_percent": lean_forward_percent, "lean_back_percent": lean_back_percent, "total": total_value, } if tooltip not in ["", None, "None", ["None"], [None]]: if tooltip not in tooltips: tooltips.append(tooltip) self.log.info("tooltip text: {}".format(tooltip)) self.log.info("By DSP tooltip content: {}".format(tooltips)) return tooltips @allure.step("comparison tool - By Engagement get table values") def get_by_engagement_table_values(self): self.page_has_loaded() names_locator = "//*[contains(@id, 'comparison-tool-engagement-table-cell-name-')]" self.scroll_to_element(names_locator, "xpath") self.wait_for_element_visible(names_locator, "xpath") order = self.get_elements("//*[contains(@id, 'comparison-tool-engagement-table-cell-position-')]/*/*[1]", "xpath") names_el = self.get_elements(names_locator, "xpath") forward_el = self.get_elements("//*[contains(@id, 'comparison-tool-engagement-table-cell-lean-forward-')]/*/*/*[1]", "xpath") back_el = self.get_elements("//*[contains(@id, 'comparison-tool-engagement-table-cell-lean-back-')]/*/*/*[1]", "xpath") forward_p = self.get_elements("//*[contains(@id, 'comparison-tool-engagement-table-cell-lean-forward-')]/*/*/*[2]", "xpath") back_p = self.get_elements("//*[contains(@id, 'comparison-tool-engagement-table-cell-lean-back-')]/*/*/*[2]", "xpath") total_el = self.get_elements("//*[contains(@id, 'comparison-tool-engagement-table-cell-total-')]/*/*/*", "xpath") order = [int(str(self.get_text(element=t))) for t in order] names = [self.get_text(element=t) for t in names_el] forward = [self.get_text(element=t) for t in forward_el] back = [self.get_text(element=t) for t in back_el] total = [self.get_text(element=t) for t in total_el] track_name = [self.get_text(element=t) for t in names_el] lean_forward_count = [float(str(self.get_text(element=t)).replace("k", "").replace("M", "").replace("B", "").replace("N/A", "0")) for t in forward_el] lean_back_count = [float(str(self.get_text(element=t).replace("k", "").replace("M", "").replace("B", "").replace("N/A", "0"))) for t in back_el] lean_forward_percent = [int(str(self.get_text(element=t)).replace("%", "").replace("N/A", "0")) for t in forward_p] lean_back_percent = [int(str(self.get_text(element=t)).replace("%", "").replace("N/A", "0")) for t in back_p] values = dict( zip( [ "order", "name", "forward", "back", "total", "track_name", "lean_forward_count", "lean_back_count", "lean_forward_percent", "lean_back_percent", ], [ order, names, forward, back, total, track_name, lean_forward_count, lean_back_count, lean_forward_percent, lean_back_percent, ], ) ) return values @allure.step("comparison tool - By Country get values from column by track index") def country_get_values_by_track_index(self, param): self.page_has_loaded() locator_el = "//*[contains(@id, 'comparison-tool-country-table-cell-track-{}-row-')]/*".format(param) self.scroll_to_element(locator_el, "xpath") elements = self.get_elements(locator_el, "xpath") values = [self.get_text(element=e) for e in elements] return values @allure.step("comparison tool - By Country get track name in header by index") def country_get_track_name_by_index(self, param): loc = "comparison-tool-country-table-cell-track-{}-row".format(param) self.scroll_to_element(locator=loc, locator_type="id") e = self.wait_for_element_visible(locator=loc, locator_type="id") return self.get_text(element=e) @allure.step("comparison tool - By Country get values from column - countries by track index") def country_get_values_by_track_index_countries(self, param): self.page_has_loaded() locator_el = "//*[contains(@id,'comparison-tool-country-table-cell-track-{}-row-')]/*/*/*[1]".format(param) self.scroll_to_element(*self.locator(self.track_comparison_page, "country_title")) self.wait_for_element_visible(locator_el, "xpath") elements = self.get_elements(locator_el, "xpath") values = [self.get_text(element=e) for e in elements] self.log.info("countries values By Country: {}".format(values)) return values @allure.step("comparison tool - By Country get values from column - count by track index") def country_get_values_by_track_index_count(self, param): self.page_has_loaded() locator_el = "//*[contains(@id,'comparison-tool-country-table-cell-track-{}-row-')]/*/*/*[2]/*[1]".format(param) self.scroll_to_element(*self.locator(self.track_comparison_page, "country_title")) elements = self.get_elements(locator_el, "xpath") values = [] if len(elements) > 0: values = [str(self.get_text(element=e)).replace("M", "").replace("k", "") for e in elements] self.log.info("values for track with index{} : {}".format(param, values)) return values @allure.step("comparison tool - By Country get values from column - percentage by track index") def country_get_values_by_track_index_percentage(self, param): self.page_has_loaded() locator_el = "//*[contains(@id,'comparison-tool-country-table-cell-track-{}-row-')]/*/*/*[2]/*[3]".format(param) self.scroll_to_element(*self.locator(self.track_comparison_page, "country_title")) elements = self.get_elements(locator_el, "xpath") values = [] if len(elements) > 0: values = [int(str(self.get_text(element=e)).replace("%", "")) for e in elements] self.log.info("percentage values By Country: {}".format(values)) return values @allure.step("comparison tool - By Country verify available source") def verify_source_values(self, param, dd="country"): expected_dsps = [] if param == AppConfig.get("dsp")["spotify"]: expected_dsps = [ AppConfig.get("source")["all"], "Album Page", "Artist Page", "Chart", "Collection", "Daily Mix", "Discover Weekly", "Other", "Playlists", "Play Queue", "Radio", "Release Radar", "Search", ] elif param == AppConfig.get("dsp")["apple"]: expected_dsps = [ AppConfig.get("source")["all"], "Discovery", "Library", "Other", "Search", "MusicKit", "External", "Now Playing", "Voice", ] elif param == AppConfig.get("dsp")["amazon"]: expected_dsps = [ AppConfig.get("source")["all"], "User Playlist", AppConfig.get("source")["station"], "Playlists", "Search", "Album", "Artist", "Songs", ] elif param == AppConfig.get("dsp")["total_streams"]: expected_dsps = [AppConfig.get("source")["all"]] loc = "//*[@id='comparison-tool-{}-source-dd']/div/div/*".format(dd) loc_dsp = "comparison-tool-{}-source-dd".format(dd) self.scroll_to_element(loc_dsp, "id") self.click_on_element_js(self.get_element(loc_dsp, "id")) elements = self.get_elements(locator=loc, locator_type="xpath") available_dsps = [self.get_text(element=e) for e in elements] self.click_on_element_js(self.get_element(loc_dsp, "id")) self.ts.markFinal(expected_dsps == available_dsps, f"all source are displayed: {available_dsps}\n expected: {expected_dsps}") @allure.step("comparison tool - By Country get percentage for tracks by index") def country_get_percentage_for_tracks(self, param): percentage = [] for p in range(1, param + 1): percentage.append(self.country_get_values_by_track_index_percentage(p)) return percentage @allure.step("comparison tool - By Country verify dsp dropdown") def country_verify_dsp_values(self): expected_dsps = [ AppConfig.get("dsp")["total_streams"], AppConfig.get("dsp")["spotify"], AppConfig.get("dsp")["apple"], AppConfig.get("dsp")["amazon"], ] loc_dsp = "comparison-tool-country-dsp-dd" loc = f"//*[@id='{loc_dsp}']/div/div/*" self.scroll_to_element(loc_dsp, "id") self.click_on_element_js(self.get_element(loc_dsp, "id")) elements = self.get_elements(locator=loc, locator_type="xpath") available_dsps = [self.get_text(element=e) for e in elements] self.click_on_element_js(self.get_element(loc_dsp, "id")) assert_that(expected_dsps).is_equal_to(available_dsps) @allure.step("comparison tool - By Country get current source") def country_get_current_source(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-country-source-dd")) chosen_source = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-country-source-dd")) return chosen_source @allure.step("comparison tool - By Country is source active") def is_country_source_active(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-country-source-dd")) color = self.get_element(*self.locator(self.track_comparison_page, "comparison-tool-country-source-dd")).value_of_css_property("background-color") return color != "rgba(248, 248, 251, 1)" @allure.step("comparison tool - By Country get current dsp") def country_get_current_dsp(self): current_dsp = self.get_text("comparison-tool-country-dsp-dd", "id") return current_dsp @allure.step("comparison tool - By Country verify hints") def country_verify_hints(self, track): icon_hint = "% shows a track's streams relative to all markets filtered by selected DSP and Source." self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "country_hint_icon")) icon = self.wait_for_element_visible(*self.locator(self.track_comparison_page, "country_hint_icon")) ActionChains(self.driver).move_to_element(to_element=icon).perform() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "country_hint_tooltip")) hint_icon_text = str(self.get_text(*self.locator(self.track_comparison_page, "country_hint_tooltip"))) country_name = self.wait_for_element_visible(locator="//*[@id='comparison-tool-country-table-cell-track-1-row-1']/*/*/*[1]", locator_type="xpath") ActionChains(self.driver).move_to_element(to_element=country_name).perform() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "country_hint_tooltip"), timeout=0.5) country_name_text = str(self.get_text(*self.locator(self.track_comparison_page, "country_hint_tooltip"))) streams_name = self.wait_for_element_visible(locator="//*[@id='comparison-tool-country-table-cell-track-1-row-1']/*/*/*[2]/*/*", locator_type="xpath") ActionChains(self.driver).move_to_element(to_element=streams_name).perform() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "country_hint_tooltip"), timeout=0.5) streams_name_text = str(self.get_text(*self.locator(self.track_comparison_page, "country_hint_tooltip"))).replace(",", "") self.scroll_to_element(locator="comparison-tool-country-table-cell-track-1-row", locator_type="id") track_name = self.wait_for_element_visible(locator="comparison-tool-country-table-cell-track-1-row", locator_type="id") ActionChains(self.driver).move_to_element(to_element=track_name).perform() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "country_hint_tooltip"), timeout=0.5) track_name_text = str(self.get_text(locator="//div[text()='{}']".format(self.get_text(element=track_name)), locator_type="xpath")) self.log.info("hint_icon_text: {}".format(hint_icon_text)) self.log.info("track_name_text: {}".format(track_name_text)) self.log.info("country_name_text: {}".format(country_name_text)) self.log.info("streams_name_text: {}".format(streams_name_text)) self.ts.markFinal(hint_icon_text == icon_hint, "hint for i icon in country is: {}".format(hint_icon_text)) self.ts.markFinal(track_name_text == track.name, "track name in tooltip is: {}".format(track_name_text)) self.ts.markFinal( country_name_text == self.get_text(element=country_name), "country in tooltip is: {}".format(country_name_text), ) self.ts.markFinal(streams_name_text.isdigit(), "streams in tooltip is digit") @allure.step("comparison tool - By Country no data displayed") def country_verify_no_data(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "country_no_data")) displayed = self.is_element_displayed(*self.locator(self.track_comparison_page, "country_no_data")) self.ts.markFinal(displayed, "country - no data is displayed") @allure.step("comparison tool - get track history for spotify with range") def get_dates_for_track_history_spotify_range(self, id, isrc, first_date, column): dates = self.sql_client.select_dates_for_track_history_spotify_with_range(id=id, isrc=isrc, first_date=first_date, column=column) self.log.info(f"{isrc} and {id}: {dates}") return dates @allure.step("open and switch to tab") def open_new_tab(self): self.driver.execute_script("window.open('');") @allure.step("switch to tab") def switch_to_tab(self, tab): self.driver.switch_to.window(self.driver.window_handles[tab - 1]) @allure.step("close current tab") def close_current_tab(self): self.driver.close() @allure.step("get end date for track for period") def get_end_date_for_track_period(self, period, track): end_date = (datetime.datetime.strptime(track.dates.first_date, "%Y-%m-%d") + datetime.timedelta(days=period)).date() last_stream_date = self.api_client.get_first_last_date_for_isrc(isrc=track.isrc)["last_stream_date"]["spotify"] if end_date > datetime.datetime.strptime(last_stream_date, "%Y-%m-%d").date(): end_date = last_stream_date self.log.info("last date is: {}".format(end_date)) return end_date @allure.step("Comparison - compare By Country table with track page - countries chart") def compare_countries_in_track_csv_and_comparison(self, periods, dsp, track, market, source=AppConfig.get("source")["all"]): self.open_new_tab() url_open = "{base}/spotify/track/{id}?market={market}&str_gr_tab=2&str_gr_region=rtm&str_gr_dsp=1&str_gr_start_date={start}&str_gr_end_date={end}" for period in periods: self.switch_to_tab(2) end_date = self.get_end_date_for_track_period(period=period["count"], track=track) self.open_url(url_open.format(base=CoreConfig.ENV_BASE_URL, id=track.id, market=market["url"], start=track.dates.f_date, end=end_date)) self.switch_to_tab(1) self.select_period_from_dd(period["name"]) self.country_select_dsp_from_dd(dsp) if dsp != AppConfig.get("dsp")["total_streams"]: self.country_select_source(source) streams_val = self.country_get_values_by_track_index_count(1) streams = [float(s) for s in streams_val] self.switch_to_tab(2) self.trackPage.select_dsp(dsp) if dsp != AppConfig.get("dsp")["total_streams"]: self.trackPage.change_source_value(source) self.trackPage.is_graph_period_displayed() self.trackPage.click_export() self.trackPage.click_export_as_csv() streams_csv = self.trackPage.read_file(track=track, dsp=dsp, tab="Countries", sources=source) assert_that(streams).described_as(f"{period} {dsp} {source}").is_equal_to(streams_csv) self.close_current_tab() self.switch_to_tab(1) self.left_panel.sign_out() @allure.step("Comparison - login and open comparison with market") def login_and_open_comparison(self, market, track): self.remove_tracks_if_present_with_worker(market["market"]) user = self.loginPage.get_user_email_with_worker() token = self.api_client.authorize(user=user) self.api_client.add_track_to_comparison(token=token, market=market["market"], isrc=track.isrc, id=track.id) self.loginPage.login_with_worker() self.loginPage.is_logged_in() self.left_panel.open_comparison_page() self.trackPage.select_market(market["name"]) self.select_market_from_dd(market["name"]) @allure.step("Comparison - By DSP verify table headers") def by_dsp_verify_table_headers(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) self.by_dsp_verify_title() order = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_dsp_order_header")) track_name = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_dsp_track_name_title")) spotify = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_dsp_spotify_title")) apple = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_dsp_apple_title")) amazon = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_dsp_amazon_title")) total = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_dsp_total_title")) self.ts.markFinal( order == track_name == spotify == apple == amazon == total == True, "By DSP headers in table displayed correctly ", ) @allure.step("Comparison - By DSP verify title") def by_dsp_verify_title(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) title = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_dsp_title")) self.ts.markFinal(title, "By DSP title is displayed correctly ") @allure.step("Comparison - By DSP verify track name tooltip") def by_dsp_verify_track_name_tooltip(self, param): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) name = self.get_element(locator=("comparison-tool-dsp-table-cell-name-{}".format(param)), locator_type="id") table_name = self.get_text(element=name) ActionChains(self.driver).move_to_element(to_element=name).perform() tooltip = self.get_element(locator=("//div[text()='{}']".format(table_name)), locator_type="xpath") tooltip_name = self.get_text(element=tooltip) self.ts.markFinal( table_name == tooltip_name, "tooltip contains full name of track, name: {}, tooltip: {}".format(table_name, tooltip_name), ) @allure.step("Comparison - By DSP click on track name") def by_dsp_click_on_track_name_and_verify_track_page(self, param): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) name = self.get_text(locator="comparison-tool-dsp-table-cell-name-{}".format(param)) self.click_element(locator="comparison-tool-dsp-table-cell-name-{}".format(param)) title = self.trackPage.get_track_title() self.ts.markFinal(name == title, "correct track page is opened, name: {}, title: {}".format(name, title)) @allure.step("Comparison - By DSP verify headers background change after hover") def by_dsp_hover_headers_and_verify_background(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) self.wait_for_element_visible("//*[contains(@id, 'comparison-tool-dsp-table-cell-name-')]", "xpath") for l in [ "by_dsp_track_name_title", "by_dsp_spotify_title", "by_dsp_apple_title", "by_dsp_amazon_title", "by_dsp_total_title", ]: e = self.get_element(*self.locator(self.track_comparison_page, l)) color_before_hover = e.value_of_css_property("background-color") ActionChains(self.driver).move_to_element(e).perform() color_after_hover = e.value_of_css_property("background-color") self.ts.markFinal( color_before_hover != color_after_hover, "By DSP: background color of hesder is changed, before: {}, after: {}".format(color_before_hover, color_after_hover), ) @allure.step("Comparison - By DSP click on each column") def by_dsp_click_on_each_column(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) self.wait_for_element_visible("//*[contains(@id, 'comparison-tool-dsp-table-cell-name-')]", "xpath") for l in [ "by_dsp_track_name_title", "by_dsp_spotify_title", "by_dsp_apple_title", "by_dsp_amazon_title", "by_dsp_total_title", ]: table_content_before = self.get_by_dsp_table_values() self.click_on_element_js(self.get_element(*self.locator(self.track_comparison_page, l))) table_content_after = self.get_by_dsp_table_values() self.ts.markFinal(table_content_before != table_content_after, "columns are sortable by: {}".format(l)) @allure.step("Comparison - By DSP verify tooltip by streams") def verify_tooltip_for_streams(self, column, index): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) e = self.wait_for_element_visible( locator="//*[@id='comparison-tool-dsp-table-cell-{column}-total-" "{index}']/*/*/*[1]".format(column=column, index=index), locator_type="xpath", ) ActionChains(self.driver).move_to_element(to_element=e).perform() tooltip = int(str(self.get_text(*self.locator(self.track_comparison_page, "tooltip"))).replace(",", "")) rounded_tooltip = self.trackPage.apply_rounding(tooltip) table_value = float(str(self.get_text(element=e)).replace("M", "").replace("k", "")) self.ts.markFinal(table_value == rounded_tooltip, "tooltip for streams contains correct value") @allure.step("Comparison - By DSP sort by default") def by_dsp_sort_by_default(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) self.wait_for_element_clickable(self.get_element(*self.locator(self.track_comparison_page, "by_dsp_order_header"))) self.click_on_element_js(self.get_element(*self.locator(self.track_comparison_page, "by_dsp_order_header"))) @allure.step("Comparison - By DSP verify no data is displayed") def by_dsp_verify_no_data_displayed(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) no_data = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_dsp_no_data")) self.ts.markFinal(no_data, "no data i By DSP table") @allure.step("Comparison - By DSP table sort by column") def by_dsp_sort_by_column(self, column): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) self.wait_for_element_visible("//*[contains(@id, 'comparison-tool-dsp-table-cell-name-')]", "xpath") self.click_on_element_js(self.get_element(*self.locator(self.track_comparison_page, "by_dsp_{}_title".format(column)))) @allure.step("Comparison - By DSP graph get added tracks") def by_dsp_graph_get_added_tracks(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) elements = self.get_elements(*self.locator(self.track_comparison_page, "by_dsp_graph_names")) names = [self.get_text(element=e) for e in elements] self.log.info("names in by dsp graph are: {}".format(names)) return names @allure.step("Comparison - By DSP graph get added tracks") def by_dsp_graph_get_scale(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) elements = self.get_elements(*self.locator(self.track_comparison_page, "by_dsp_graph_scale")) scales = [int(str(self.get_text(element=e)).replace("M", "").replace("k", "")) for e in elements] return scales @allure.step("Comparison - By DSP verify graph legend") def be_dsp_verify_legend(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) elements = self.get_elements(*self.locator(self.track_comparison_page, "by_dsp_graph_legend")) colors = self.get_elements(*self.locator(self.track_comparison_page, "by_dsp_graph_legend_color")) legends = [self.get_text(element=e) for e in elements] col_expected = ["rgba(29, 185, 84, 1)", "rgba(255, 60, 129, 1)", "rgba(64, 26, 255, 1)"] col_values = [e.value_of_css_property("color") for e in colors] self.log.info("colors: {}".format(col_values)) self.ts.markFinal( legends == [AppConfig.get("dsp")["spotify"], AppConfig.get("dsp")["apple"], AppConfig.get("dsp")["amazon"]], "legend is correct", ) self.ts.markFinal(col_values == col_expected, "colors of legend are correct") @allure.step("Comparison - By DSP verify tooltip") def by_dsp_verify_tooltip(self, tooltip, track): self.ts.markFinal(tooltip["track_name"] == track.name, "track name is in tooltip") self.ts.markFinal( [tooltip["spotify_name"], tooltip["apple_name"], tooltip["amazon_name"]] == [AppConfig.get("dsp")["spotify"], AppConfig.get("dsp")["apple"], AppConfig.get("dsp")["amazon"]], "dsps are displayed in tooltip", ) self.ts.markFinal(tooltip["total"] == "Total", "total is displayed") self.ts.markFinal( [tooltip["spotify_color"], tooltip["apple_color"], tooltip["amazon_color"]] == ["rgba(29, 185, 84, 1)", "rgba(255, 60, 129, 1)", "rgba(64, 26, 255, 1)"], "colors are correct", ) @allure.step("Comparison - By DSP get tooltip for track") def by_dsp_get_tooltip_for_track(self, tooltips, track): tooltip_with_track = {} for t in tooltips: if track.name == t["track_name"]: tooltip_with_track = t self.log.info("tooltip is: {}".format(tooltip_with_track)) return tooltip_with_track @allure.step("Comparison - By DSP graph verify no data") def by_dsp_verify_graph_no_data(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "by_dsp_title")) graph_no_data = self.wait_for_element_visible(*self.locator(self.track_comparison_page, "by_dsp_graph_no_data")) self.ts.markFinal(self.is_element_displayed(element=graph_no_data), "no data in By DSP graph") @allure.step("Comparison - get added tracks") def get_added_tracks(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "added_tracks")) elements = self.get_elements(*self.locator(self.track_comparison_page, "added_tracks")) names = [self.get_text(element=e) for e in elements] return names @allure.step("Comparison -By Engagement verify title") def by_engagement_verify_title(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) title = self.get_text(*self.locator(self.track_comparison_page, "engagement_title")) self.ts.markFinal(title == "By Engagement", "By Engagement title is correct: {}".format(title)) @allure.step("Comparison -By Engagement graph verify no data") def by_engagement_graph_verify_no_data(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "by_engagement_no_data")) no_data = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_no_data")) self.ts.markFinal(no_data, "By Engagement - no data in graph") @allure.step("Comparison -By Engagement table verify no data") def get_by_engagement_table_verify_no_data(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) no_data = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_table_no_data")) self.ts.markFinal(no_data, "By Engagement - no data in table") @allure.step("Comparison -By Engagement graph verify coloring") def by_engagement_graph_verify_coloring(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) sticky_header_icons = self.get_elements(*self.locator(self.track_comparison_page, "sticky_header_icons")) header_colors = [str(e.value_of_css_property("color")).replace(" ", "") for e in sticky_header_icons] self.wait_for_element_visible(*self.locator(self.track_comparison_page, "engagement_chart")) chart = self.get_elements(*self.locator(self.track_comparison_page, "engagement_chart")) by_engagement_colors = [] for e in chart: self.wait_for_element_visible(*self.locator(self.track_comparison_page, "engagement_chart")) e = self.get_elements(*self.locator(self.track_comparison_page, "engagement_chart"))[chart.index(e)] by_engagement_colors.append(e.get_attribute("fill")) self.ts.markFinal( all(c in by_engagement_colors for c in header_colors), "colors in by engagement graph are correct: header: {}, graph: {}".format(header_colors, by_engagement_colors), ) @allure.step("Comparison -By Engagement graph verify titles") def by_engagement_graph_verify_titles(self, count): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) forward = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_lean_forward")) back = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_lean_back")) percentage = self.get_elements(*self.locator(self.track_comparison_page, "by_engagement_percentage")) self.ts.markFinal(forward == back == True, "Lean back and forward titles are displayed") self.ts.markFinal(len(percentage) / 2 == count, "percentage is displayed for tracks count: {}".format(len(percentage) / 2)) @allure.step("Comparison -By Engagement graph verify titles") def by_engagement_graph_verify_tooltip_structure(self): tooltips = self.by_engagement_get_graph_tooltips() self.ts.markFinal(("Lean Forward" and "Lean Back" and "Total") in tooltips[0], "tooltip structure is correct") @allure.step("Comparison -By Engagement graph verify titles") def track_performance_get_legend_tracks(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-performance-title")) self.page_has_loaded() self.wait_for_element_visible(*self.locator(self.track_comparison_page, "stream_performance_legend_tracks")) tracks = self.get_elements(*self.locator(self.track_comparison_page, "stream_performance_legend_tracks")) values = [self.get_text(element=e) for e in tracks] self.log.info(f"track names in legend: {values}") return values @allure.step("Comparison - playlist details - get displayed tracks") def pd_get_displayed_tracks(self): self.scroll_to_playlist_support() tracks = self.get_elements(*self.locator(self.track_comparison_page, "playlist_support_tracks")) values = [self.get_text(element=e) for e in tracks] return set(values) @allure.step("Comparison - open track page from track card by index") def open_track_page_from_track_card(self, track): self.page_has_loaded() added_element = "//a[contains(@href, '/track/')][.='{}']".format(track.name) self.scroll_to_element(added_element, "xpath") self.click_element(added_element, "xpath") @allure.step("Comparison - scroll to track performance legend") def scroll_to_track_streams_performance_legend(self): self.wait_for_element_visible(*self.locator(self.track_comparison_page, "stream_performance_legend_tracks")) self.scroll_to_element(*self.locator(self.track_comparison_page, "stream_performance_legend_tracks")) @allure.step("Comparison - verify sticky header content") def verify_sticky_header_content(self, tracks, market, period): icons = self.get_elements(*self.locator(self.track_comparison_page, "sticky_header_icons")) self.wait_for_element_visible(*self.locator(self.track_comparison_page, "sticky_header_tracks")) tracks_header = self.get_elements(*self.locator(self.track_comparison_page, "sticky_header_tracks")) tracks_header_text = [self.get_text(element=e) for e in tracks_header] market_header = self.get_text(*self.locator(self.track_comparison_page, "sticky_header_market")) period_header = self.get_text(*self.locator(self.track_comparison_page, "sticky_header_period")) ActionChains(self.driver).move_to_element(to_element=self.get_elements(*self.locator(self.track_comparison_page, "sticky_header_tracks"))[0]).perform() track_tooltip = self.get_text(*self.locator(self.track_comparison_page, "tooltip")) ActionChains(self.driver).move_to_element(to_element=self.get_element(*self.locator(self.track_comparison_page, "sticky_header_market"))).perform() expected_tracks_text = [str(t.name).upper() for t in tracks] market_tooltip = self.get_text(*self.locator(self.track_comparison_page, "tooltip")) self.ts.markFinal(len(icons) == len(tracks), "circles displayed for tracks: {}".format(len(icons))) self.ts.markFinal( tracks_header_text == expected_tracks_text, "tracks are displayed in sticky header: {}, expected: {}".format(tracks_header_text, expected_tracks_text), ) self.ts.markFinal(market == market_header, "market is : {}".format(market_header)) self.ts.markFinal(period == period_header, "period is: {}".format(period_header)) self.ts.markFinal( track_tooltip == tracks[0].name, "tooltip displayed track name: {}, expected: {}".format(track_tooltip, tracks[0].name), ) self.ts.markFinal( market_tooltip == market_header, "tooltip display full market name: {}, expected: {}".format(market_tooltip, market_header), ) @allure.step("Comparison - By Engagement table is displayed") def by_engagement_verify_table_is_displayed(self, displayed=True): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) table = self.get_elements(*self.locator(self.track_comparison_page, "engagement_table")) if displayed: self.ts.markFinal(len(table) > 0, "by engagement table is displayed") else: self.ts.markFinal(len(table) == 0, "by engagement table is not displayed") @allure.step("Comparison - By Engagement verify table columns") def by_engagement_verify_table_columns(self): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) self.by_engagement_verify_title() order = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_order_header")) track_name = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_track_name_title")) spotify = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_lean-forward_title")) apple = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_lean-back_title")) total = self.is_element_displayed(*self.locator(self.track_comparison_page, "by_engagement_total_title")) self.ts.markFinal( order == track_name == spotify == apple == total == True, "By Engagement headers in table displayed correctly ", ) @allure.step("Comparison - By Engagement verify track name tooltip") def by_engagement_verify_track_name_tooltip(self, param): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) name = self.get_element(locator=("comparison-tool-engagement-table-cell-name-{}".format(param)), locator_type="id") table_name = self.get_text(element=name) ActionChains(self.driver).move_to_element(to_element=name).perform() tooltip = self.get_element(locator=("//div[text()='{}']".format(table_name)), locator_type="xpath") tooltip_name = self.get_text(element=tooltip) self.ts.markFinal( table_name == tooltip_name, "tooltip contains full name of track, name: {}, tooltip: {}".format(table_name, tooltip_name), ) @allure.step("Comparison - By Engagement table - open track page from table") def by_engagement_click_on_track_name_and_verify_track_page(self, param): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) name = self.get_text(locator="comparison-tool-engagement-table-cell-name-{}".format(param)) self.click_element(locator="comparison-tool-engagement-table-cell-name-{}".format(param)) title = self.trackPage.get_track_title() self.ts.markFinal(name == title, "correct track page is opened, name: {}, title: {}".format(name, title)) @allure.step("Comparison - By Engagement table sort by column") def by_engagement_sort_by_column_and_verify(self, column): self.scroll_to_element(*self.locator(self.track_comparison_page, "engagement_title")) self.wait_for_element_clickable(f"//*[contains(@id, 'comparison-tool-engagement-table-cell-{column}-')]", "xpath") self.wait_for_element_clickable("comparison-tool-engagement-table-cell-{}".format(column), "id") e = self.wait_for_element_visible("comparison-tool-engagement-table-cell-{}".format(column), "id") self.click_on_element_js(element=e) @allure.step("Comparison - verify chosen period in dd") def verify_chosen_period(self, period): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) current_period = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) self.ts.markFinal(current_period == period, "chosen period is: {}".format(current_period)) @allure.step("Comparison - verify track card") def verify_track_card(self, param, track_expected): self.scroll_to_element("//div[@id='comparison-tool-card-{}-indicator']/div".format(param), "xpath") indicator = self.is_element_displayed("comparison-tool-card-{}-indicator".format(param), "id") remove = self.is_element_displayed("comparison-tool-card-{}-close-icon".format(param), "id") track = self.get_text("(//a[contains(@href, '/track/')])[{}]".format(param), "xpath") artist = self.get_text("//*[@id='comparison-tool-card-{}']/..//*[contains(@href, '/artist/')]".format(param), "xpath") release_date = str(self.get_release_date_with_track_index(param)) self.ts.markFinal(indicator == remove == True, "indicator and remove icons displayed for track in track card") self.ts.markFinal(track == track_expected.name, "track name is: {}".format(track)) self.ts.markFinal(artist in track_expected.artist, "track artist is : {}".format(artist)) self.ts.markFinal(release_date == track_expected.dates.release, "release date is : {}".format(release_date)) @allure.step("Comparison - open artist page from track card") def open_artist_page_from_track_card(self, param): self.page_has_loaded() added_element = "(//*[contains(@href, '/artist/')])[{}]".format(param) self.scroll_to_element(added_element, "xpath") self.click_element(added_element, "xpath") url = self.get_url() self.ts.markFinal("artist" in url, "artist page is opened") @allure.step("Comparison - verify sony label") def verify_sony_label_is_displayed(self, param, present=True): sony = self.is_element_displayed("//*[@id='comparison-tool-card-{}']/..//*[text()='SONY']".format(param), "xpath") if present: self.ts.markFinal(sony, "sony label is displayed") else: self.ts.markFinal(sony == False, "sony label is not displayed") @allure.step("Comparison - verify track card hover name and artist") def track_card_verify_hover(self, param, track_expected): self.scroll_to_element("//div[@id='comparison-tool-card-{}-indicator']/div".format(param), "xpath") track = self.get_element("(//a[contains(@href, '/track/')])[{}]".format(param), "xpath") artist = self.get_element("(//a[contains(@href, '/artist/')])[{}]".format(param), "xpath") ActionChains(self.driver).move_to_element(to_element=track).perform() track_tool = self.get_text("comparison-tool-card-{}-tooltip-name".format(param)) ActionChains(self.driver).move_to_element(to_element=artist).perform() artist_tool = str(self.get_text("comparison-tool-card-{}-tooltip-artists".format(param))).strip() self.ts.markFinal(track_tool == track_expected.name, "track name in tooltip: {}".format(track_tool)) self.ts.markFinal( artist_tool.replace(" ", "").replace("\xa0", "").split(",") == track_expected.artist.replace(" ", "").replace("\xa0", "").split(","), "artist name in tooltip: {}, expected: {}".format( artist_tool.replace(" ", "").replace("\xa0", "").split(","), track_expected.artist.replace(" ", "").replace("\xa0", "").split(","), ), ) @allure.step("Comparison - get sricky header colors") def get_sticky_header_colors(self): sticky_header_icons = self.get_elements(*self.locator(self.track_comparison_page, "sticky_header_icons")) header_colors = [str(e.value_of_css_property("color")).replace(" ", "") for e in sticky_header_icons] return header_colors @allure.step("Comparison - track performance verify legend") def track_performance_verify_legend(self, tracks): self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-performance-title")) captions_el = self.get_elements(locator="//*[text()='Streams in Period']", locator_type="xpath") for t in tracks: track_index = list(tracks).index(t) card_color = self.get_track_card_identifier_color_by_id(track_index + 1) legend_track_color = self.tp_get_track_color_by_index(track_index) caption = captions_el[track_index] track_name = self.track_performance_get_legend_tracks()[track_index] streams = self.get_track_performance_legend_streams()[track_index] self.ts.markFinal(isinstance(int(streams), int) or streams == "N/A", "streams are displayed: {}".format(streams)) self.ts.markFinal(str(track_name).lower() == str(t.name).lower(), "track name is: {}".format(track_name)) self.ts.markFinal(self.is_element_displayed(element=caption), "caption is displayed") self.ts.markFinal(card_color == legend_track_color, "card: {}, legend: {}".format(card_color, legend_track_color)) @allure.step("Comparison - track performance get track color by index") def tp_get_track_color_by_index(self, param): self.scroll_to_element(*self.locator(self.track_comparison_page, "tp_legend_colors")) colors_el = self.get_elements(*self.locator(self.track_comparison_page, "tp_legend_colors")) colors = [c.value_of_css_property("color") for c in colors_el] return colors[param] @allure.step("Comparison - track performance verify default dsp, source, period") def verify_default_dsp_source_period(self): dd = "performance" dsp = self.get_current_dsp(dd) source = self.get_text("comparison-tool-{}-source-dd".format(dd), "id") self.verify_chosen_period(AppConfig.get("periods")["28d"]["name"]) self.ts.markFinal(source == AppConfig.get("source")["all"], "source is: {}".format(source)) self.ts.markFinal(dsp == AppConfig.get("dsp")["spotify"], "current dsp is: {}".format(dsp)) @allure.step("Comparison - track performance section is displayed") def is_tp_title_displayed(self): tp_displayed = self.is_element_displayed(*self.locator(self.track_comparison_page, "comparison-tool-performance-title")) self.ts.markFinal(tp_displayed, "tp section is displayed") @allure.step("Comparison - track performance verify axises") def tp_verify_axises(self): self.wait_for_element_visible(*self.locator(self.track_comparison_page, "stream_count")) y_axis = self.is_element_displayed(*self.locator(self.track_comparison_page, "stream_count")) current_timeline = self.get_playlist_details_timeline() self.ts.markFinal(current_timeline == AppConfig.get("periods")["28d"]["timeline"], "timeline is displayed for 28 days") self.ts.markFinal(y_axis, "y axis for tp section is displayed") @allure.step("Comparison - verify market, period, dsp, source dropdowns hover and layout") def verify_market_period_dsp_source_hover(self): market = self.get_selected_market() period = self.get_text(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) dsp = self.get_text("comparison-tool-{}-dsp-dd".format("performance"), "id") source = self.get_text("comparison-tool-{}-source-dd".format("performance"), "id") self.scroll_to_element(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) self.wait_for_element_clickable(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) self.click_element(*self.locator(self.track_comparison_page, "comparison-tool-market-dd")) m = f"//*[@id='comparison-tool-market-dd']/..//b[text()='{market}']" m_el = self.get_element(locator=m, locator_type="xpath") m_color_before = m_el.value_of_css_property("color") ActionChains(self.driver).move_to_element(to_element=m_el).perform() m_color_after = m_el.value_of_css_property("color") bold_m = self.is_element_displayed(element=m_el) self.click_element(*self.locator(self.track_comparison_page, "comparison-tool-period-dd")) p = f"//*[@id='comparison-tool-period-dd']/..//b[text()='{period}']" p_el = self.get_element(locator=p, locator_type="xpath") p_color_before = p_el.value_of_css_property("color") ActionChains(self.driver).move_to_element(to_element=p_el).perform() p_color_after = p_el.value_of_css_property("color") bold_p = self.is_element_displayed(locator=p, locator_type="xpath") self.click_on_element_js(self.get_element("comparison-tool-{}-dsp-dd".format("performance"), "id")) d = "//*[@id='comparison-tool-{}-dsp-dd']/..//b[text()='{}']".format("performance", dsp) d_el = self.get_element(locator=d, locator_type="xpath") d_color_before = d_el.value_of_css_property("color") ActionChains(self.driver).move_to_element(to_element=d_el).perform() d_color_after = d_el.value_of_css_property("color") bold_d = self.is_element_displayed(locator=d, locator_type="xpath") self.click_on_element_js(self.get_element("comparison-tool-{}-source-dd".format("performance"), "id")) s = "//*[@id='comparison-tool-{}-source-dd']/..//b[text()='{}']".format("performance", source) s_el = self.get_element(locator=s, locator_type="xpath") s_color_before = s_el.value_of_css_property("color") ActionChains(self.driver).move_to_element(to_element=s_el).perform() s_color_after = s_el.value_of_css_property("color") bold_s = self.is_element_displayed(locator=s, locator_type="xpath") self.ts.markFinal(bold_m, "chosen market is bold in dropdown") self.ts.markFinal(bold_p, "chosen period is bold in dropdown") self.ts.markFinal(bold_d, "chosen dsp is bold in dropdown") self.ts.markFinal(bold_s, "chosen source is bold in dropdown") self.ts.markFinal(m_color_after != m_color_before, "m color is changed: {}, {}".format(m_color_before, m_color_after)) self.ts.markFinal(d_color_after != d_color_before, "d color is changed: {}, {}".format(d_color_before, d_color_after)) self.ts.markFinal(s_color_after != s_color_before, "s color is changed: {}, {}".format(s_color_before, s_color_after)) self.ts.markFinal(p_color_after != p_color_before, "p color is changed: {}, {}".format(p_color_before, p_color_after))