def browser(logger, request):
selected_browser = request.config.getoption('--browser')
if selected_browser not in ('firefox', 'chrome'):
raise ValueError(
f'--browser option can only be "firefox" or "chrome", received "{selected_browser}"'
)
executor = request.config.getoption('--executor')
browser_logger = logging.getLogger('Browser')
logger.info(f'Starting {selected_browser.capitalize()}')
browser = EventFiringWebDriver(
webdriver.Remote(
command_executor=f'http://{executor}:4444/wd/hub',
desired_capabilities={
'browserName': selected_browser,
'loggingPrefs': {
'browser': 'ALL'
},
'acceptInsecureCerts': True,
},
),
EventListener(browser_logger),
)
browser.implicitly_wait(request.config.getoption('--time'))
browser.get(request.config.getoption('--url'))
# Ожидание на случай первоначальной установки
WebDriverWait(browser, 100).until(EC.visibility_of_element_located(HEADER))
failed = request.session.testsfailed
yield browser
if request.session.testsfailed > failed:
browser.save_screenshot(
f'screenshots/{datetime.now().strftime("%d-%m-%Y %H-%M-%S")}.png')
browser.quit()
class EnvironmentSetup(unittest.TestCase):
PAGE_LOAD_TIME = 20
IMPLICITLY_WAIT = 10
log = cl.customLogger(logging.DEBUG)
def setUp(self):
self.log.debug("Properties initialization")
self.prop = Property()
try:
self.dic_prop = self.prop.load_property_files("/Users/user/PycharmProjects/BGETest/config/config.properties")
self.log.debug("Properties successfully loaded.")
self.log.debug(self.dic_prop)
except FileNotFoundError as err:
self.log.error("config.properties file not found!!!")
raise ValueError("There is no config.properties file in the project directory" + str(err))
browserName = self.dic_prop.get("browser", "chrome")
if browserName.lower() == "firefox":
self.driver = webdriver.Firefox()
self.log.debug("Object for firefox is created - " + str(self.driver))
elif browserName.lower() == "chrome":
self.driver = webdriver.Chrome()
self.log.debug("Object for chrome is created - " + str(self.driver))
elif browserName.lower() == "safari":
self.driver = webdriver.Safari()
self.log.debug("Object for safari is created - " + str(self.driver))
else:
raise ValueError("Unknown browser, please check the config.properties file")
self.eventListener = WebEventListener()
self.driver = EventFiringWebDriver(self.driver, self.eventListener)
self.driver.maximize_window()
self.driver.delete_all_cookies()
self.log.debug("Cookies are successfully deleted")
self.driver.set_page_load_timeout(self.PAGE_LOAD_TIME)
self.driver.implicitly_wait(self.IMPLICITLY_WAIT)
self.driver.get(self.dic_prop.get("url"))
self.longMessage = False
self.log.debug(self.id())
self.screenshot = ScreenShot(self.driver)
try:
self.screenshotName = "./results/{}.png".format(str(self.id()).split('.')[3])
except IndexError:
self.screenshotName = "./results/{}.png".format(str(self.id()).split('.')[2])
def tearDown(self):
if self.driver is not None:
self.driver.close()
self.driver.quit()
class MainTest(unittest.TestCase):
@classmethod
def setUpClass(self):
driver = Config().browser()
print("Run started at:" + str(datetime.datetime.utcnow()))
self.ef_driver = EventFiringWebDriver(driver, ScreenshotListener())
self.ef_driver.maximize_window()
def assert_element_text(self, xpath, expected_text):
"""
Compare expected text with observed value from web element
:param xpath: xpath to element with text to be observed
:param expected_text: text what we expecting to be found
:return: None
"""
element = self.ef_driver.find_element_by_xpath(xpath)
return self.assertEqual(
element.text, expected_text,
f'Expected message differ from {expected_text}')
def assert_element_contains_innerText(self, selector, expected_text):
"""
Compare expected text with observed value from web elements
:param selector: css_selector to list with elements to be observed
:param expected_text: text what we expecting to be found in element from the list
:return: assertions for every element
"""
elements = self.ef_driver.find_elements_by_css_selector(selector)
for element in elements:
return self.assertIn(
element.get_attribute('innerText'), expected_text,
f'Expected message differ from {expected_text}')
def assert_title(self, url, expected_text):
self.ef_driver.get(url)
actual_title = self.ef_driver.title
self.assertEqual(
expected_text, actual_title,
f'Expected {expected_text} differ from actual driver,')
def go_driver_give_that_page(self, driver, url, page_object):
tested_page = page_object(driver)
driver.get(url)
return tested_page
@classmethod
def tearDownClass(self):
self.ef_driver.close()
if (self.ef_driver != None):
print("Test environment destroyed.")
print("Run completed at: " + str(datetime.datetime.utcnow()))
"""
def get_browser(self):
if self.remote and self.host is None:
self.host = "127.0.0.1"
if self.remote and self.port is None:
self.port = "4444"
if self.browser == "chrome":
desired_capabilities = DesiredCapabilities.CHROME.copy()
options = webdriver.ChromeOptions()
options.add_argument("--start-maximized")
options.add_argument("--ignore-certificate-errors")
if self.remote:
try:
driver = webdriver.Remote(desired_capabilities=desired_capabilities,
options=options,
command_executor="http://" + self.host + ":" + self.port + "/wd/hub")
except Exception:
logging.exception("WebDriver Host is not available")
raise ConnectionError("WebDriver Host is not available")
else:
driver = webdriver.Chrome(executable_path=ChromeDriverManager().install(), options=options)
elif self.browser == "firefox":
desired_capabilities = DesiredCapabilities.FIREFOX.copy()
options = webdriver.FirefoxOptions()
if self.remote:
try:
driver = webdriver.Remote(desired_capabilities=desired_capabilities,
options=options,
command_executor="http://" + self.host + ":" + self.port + "/wd/hub")
except Exception:
logging.exception("WebDriver Host is not available")
raise ConnectionError("WebDriver Host is not available")
else:
driver = webdriver.Firefox(executable_path=GeckoDriverManager().install(), options=options)
else:
raise Exception("Provide valid browser name")
driver.maximize_window()
try:
urlopen(self.base_url)
except Exception:
driver.quit()
raise Exception("Target host is not available")
w_driver = EventFiringWebDriver(driver, WebDriverListener())
w_driver.get(self.base_url)
return w_driver
def start_browser(browser_name, url):
web_driver = None
if browser_name == "chrome":
web_driver = webdriver.Chrome(
executable_path=".\\resources\\drivers\\chromedriver")
elif browser_name == "firefox":
web_driver = webdriver.Firefox(
executable_path=".\\resources\\drivers\\geckodriver")
driver = EventFiringWebDriver(web_driver, MyListener())
driver.implicitly_wait(properties.get_implicit_wait())
driver.maximize_window()
driver.get(url)
return driver
def browser(logger, request):
selected_browser = request.config.getoption('--browser')
browser = EventFiringWebDriver(
webdriver.Remote(
command_executor=f'http://{env.str("SELENOID_HOST")}:4444/wd/hub',
desired_capabilities={
'browserName': selected_browser,
'acceptInsecureCerts': True
},
),
EventListener(logging.getLogger('Browser')),
)
request.addfinalizer(browser.quit)
browser.get(f'http://{env.str("PRESTASHOP_HOST")}')
# Ожидание на случай первоначальной установки
WebDriverWait(browser, 100).until(EC.visibility_of_element_located(HEADER))
return browser
def main():
num = 1
url = "https://tinder.com/app/login"
profile = webdriver.FirefoxProfile("")
driver = webdriver.Firefox(firefox_profile=profile)
driver = EventFiringWebDriver(driver, MyListener())
driver.get(url)
time.sleep(5)
driver.refresh()
time.sleep(5)
while num < 10000:
num = num + 1
driver.find_element_by_tag_name("body").send_keys(Keys.RIGHT)
#wait = WebDriverWait(driver, 20)
wait = WebDriverWait(driver, 100000)
element = wait.until(
expected_conditions.visibility_of_element_located(
(By.CSS_SELECTOR, "button.button:nth-child(5)")))
element.click()
time.sleep(0.5)
print(num)
driver.close()
print("in highlight method")
driver = element._parent
def apply_style(s):
driver.execute_script("arguments[0].setAttribute('style', arguments[1]);",
element, s)
original_style = element.get_attribute('style')
apply_style("background: yellow; border: 2px solid red;")
time.sleep(.3)
apply_style(original_style)
plain_driver = webdriver.Chrome(executable_path=ChromeDriverManager().install())
#plain_driver=webdriver.Chrome(executable_path="C:/Users/shaik/PycharmProjects/drivers/chromedriver_win32/chromedriver.exe")
driver=EventFiringWebDriver(plain_driver, EventListener())
driver.get("https://fs2.formsite.com/meherpavan/form2/index.html?1537702596407")
driver.maximize_window()
time.sleep(2)
male_radio=driver.find_element_by_id("RESULT_RadioButton-7_0")
print("Is Male radio button selected or not :",male_radio.is_selected())
print("Is Male radio button visible or not :",male_radio.is_displayed())
time.sleep(2)
wait=WebDriverWait(driver,10)
#wait.until(expected_conditions.element_to_be_clickable(male_radio))
if male_radio.is_selected():
print("radio button is already selected")
else:
print("radio button is NOT selected")
highlight(male_radio)
#male_radio.click()
driver.execute_script("arguments[0].click();", male_radio)
class LostHatSmokeTests(BaseTestClass):
@classmethod
def setUpClass(self):
self.base_url = 'https://autodemo.testoneo.com/en/'
self.login_url = self.base_url + 'login'
self.clothes_product_url = self.base_url + '3-clothes'
self.accessories_product_url = self.base_url + '6-accessories'
self.art_product_url = self.base_url + '9-art'
driver = webdriver.Chrome(executable_path=r"C:\Personal_Belongings\Python\Chromedriver\chromedriver.exe")
self.ef_driver = EventFiringWebDriver(driver, ScreenshotListener())
@screenshot_decorator
def test_base_page_title(self):
expected_title = 'Lost Hat'
self.assert_title(self.base_url, expected_title)
@screenshot_decorator
def test_product_clothes_page_title(self):
expected_title = 'Clothes'
self.assert_title(self.clothes_product_url, expected_title)
@screenshot_decorator
def test_product_accessories_page_title(self):
expected_title = 'Accessories'
self.assert_title(self.accessories_product_url, expected_title)
@screenshot_decorator
def test_product_art_page_title(self):
expected_title = 'Art'
self.assert_title(self.art_product_url, expected_title)
@screenshot_decorator
def test_login_page_title(self):
expected_title = 'Login'
self.assert_title(self.login_url, expected_title)
def get_page_title(self, url):
self.ef_driver.get(url)
return self.ef_driver.title
def assert_title(self, url, expected_title):
actual_title = self.get_page_title(url)
self.assertEqual(expected_title, actual_title,
f'Expected {expected_title} differ from actual title {actual_title} on page: {url}')
@screenshot_decorator
def test_search_bar_existance(self):
driver = self.ef_driver
driver.get(self.base_url)
search_bar_xpath = '//*[@id="search_widget"]/form'
element_existance = oh.check_exists_by_xpath(driver, search_bar_xpath)
self.assertEqual(True, element_existance, f'Element with xpath: {search_bar_xpath} does not exist on the page with url: {driver.current_url}')
@screenshot_decorator
def test_search_bar_phrase_input(self):
driver = self.ef_driver
driver.get(self.base_url)
minimum_expected_elements = 5
search_bar_xpath = '//*[@name="s"]'
product_list_xpath = '//*[@class="product-miniature js-product-miniature"]'
search_bar_element = driver.find_element_by_xpath(search_bar_xpath)
search_bar_element.send_keys('mug')
search_bar_element.send_keys(Keys.ENTER)
product_list_element = driver.find_elements_by_xpath(product_list_xpath)
self.assertLessEqual(minimum_expected_elements, len(product_list_element), f"Expected number {minimum_expected_elements} isn't less or equal than actual number of elements found: {len(product_list_element)}")
def wait_for_presence_of_element(name, by, waittime=10):
wait = WebDriverWait(ef_driver, waittime)
try:
return wait.until(
EC.presence_of_element_located((getattr(By, by), name)))
except:
print("da lief was schief")
google = "https://www.google.de/"
dominion_url = "https://dominion.games/"
browser = webdriver.Firefox()
browser.implicitly_wait(10) #seconds
ef_driver = EventFiringWebDriver(browser, GamelogListener())
ef_driver.get(dominion_url)
# ef_driver.implicitly_wait(15)
try:
username_input = wait_for_presence_of_element("username-input", "ID")
username_input.clear()
username_input.send_keys("schlafi")
except:
print("Da kam nix! :(")
try:
passwd_input = wait_for_presence_of_element("password", "NAME")
passwd_input.clear()
passwd_input.send_keys("ganxta89")
print("login form filled")
ef_driver.implicitly_wait(5)
class Browser(Container, HasWindow, Waitable):
def __init__(self, browser='chrome', *args, **kwargs):
"""
Creates a nerodia.browser.Browser instance
:param browser: firefox, ie, chrome, remote or Selenium WebDriver instance
:type browser: selenium.webdriver.remote.webdriver.WebDriver or str
:param args: args passed to the underlying driver
:param kwargs: kwargs passed to the underlying driver
"""
if isinstance(browser, six.string_types[0]):
module = import_module('selenium.webdriver.{}.webdriver'.format(
browser.lower()))
caps = Capabilities(browser, **kwargs)
self.driver = module.WebDriver(**caps.kwargs)
elif isinstance(browser, WebDriver):
self.driver = browser
else:
raise TypeError(
'A browser name or WebDriver instance must be supplied, '
'got {}'.format(type(browser)))
if 'listener' in kwargs:
self.driver = EventFiringWebDriver(self.driver,
kwargs.get('listener'))
self.after_hooks = AfterHooks(self)
self.current_frame = None
self.closed = False
self.default_context = True
self._original_window = None
@property
def wd(self):
return self.driver
@staticmethod
def start(url, browser='chrome', *args, **kwargs):
"""
Creates a Browser instance
:param url: url to navigate to after starting browser
:type url: str
:param browser: firefox, ie, chrome, remote or Selenium WebDriver instance
:type browser: selenium.webdriver.remote.webdriver.WebDriver or str
:param args: args passed to the underlying driver
:param kwargs: kwargs passed to the underlying driver
"""
b = Browser(browser, *args, **kwargs)
b.goto(url)
return b
def __repr__(self):
from selenium.common.exceptions import UnexpectedAlertPresentException
try:
return '#<{}:0x{:x} url={!r} title={!r}>'.format(
self.__class__.__name__,
self.__hash__() * 2, self.url, self.title)
except UnexpectedAlertPresentException:
return '#<{}:0x{:x} alert=True>'.format(self.__class__.__name__,
self.__hash__() * 2)
except: # noqa
return '#<{}:0x{:x} closed={}>'.format(self.__class__.__name__,
self.__hash__() * 2,
self.closed)
selector_string = __repr__
def goto(self, uri):
"""
Goes to the given URL
:param uri: the URL
:type uri: str
:return: the url you end up at
:rtype: str
"""
scheme = urlparse(uri).scheme
if scheme == '' or '.' in scheme:
uri = 'http://{}'.format(uri)
self.driver.get(uri)
self.after_hooks.run()
return uri
def back(self):
""" Navigates back in history """
self.driver.back()
self.after_hooks.run()
def forward(self):
""" Navigates forward in history """
self.driver.forward()
self.after_hooks.run()
@property
def url(self):
"""
Returns the URL of the current page
:rtype: str
"""
self.assert_exists()
return self.driver.current_url
@property
def title(self):
"""
Returns the title of the current page
:rtype: str
"""
return self.driver.title
def close(self):
""" Closes the browser """
if not self.closed:
self.driver.quit()
self.closed = True
quit = close
@property
def cookies(self):
"""
Handles cookies
:rtype: nerodia.cookies.Cookies
"""
return Cookies(self.driver)
@property
def name(self):
"""
Returns the browser name
:rtype: str
"""
return self.driver.name
@property
def text(self):
"""
Returns the text of the page body
:return:
"""
return self.body().text
@property
def html(self):
"""
Returns HTML code of the current page
:rtype: str
"""
return self.driver.page_source
@property
def alert(self):
"""
Handles Javascript alerts, confirms and prompts
:rtype: nerodia.alert.Alert
"""
return Alert(self)
def refresh(self):
""" Refreshes the current page """
self.driver.refresh()
self.after_hooks.run()
def wait(self, timeout=5):
"""
Waits until the readyState of document is complete, raises a TimeoutException if timeout is
exceeded
:param timeout: time to wait
:type timeout: int
"""
return self.wait_until(
lambda b: b.ready_state == "complete",
timeout=timeout,
message="waiting for document.readyState == 'complete'")
@property
def ready_state(self):
"""
Returns the readyState of the document
:rtype: str
"""
return self.execute_script('return document.readyState;')
@property
def status(self):
"""
Returns the text of the status bar
:return:
"""
return self.execute_script('return window.status;')
def execute_script(self, script, *args):
"""
Executes JavaScript snippet
:param script: Javascript Snippet to execute
:type script: str
:param args: Arguments will be available in the given script in the 'arguments' pseudo-array
:return: result of script
"""
from .elements.element import Element
args = [e.wd if isinstance(e, Element) else e for e in args]
returned = self.driver.execute_script(script, *args)
return self._wrap_elements_in(self, returned)
def send_keys(self, *args):
"""
Sends sequence of keystrokes to currently active element
:param args: keystrokes
"""
self.driver.switch_to.active_element.send_keys(*args)
@property
def screenshot(self):
"""
Handles screenshots of current pages
:rtype: nerodia.screenshot.Screenshot
"""
from .screenshot import Screenshot
return Screenshot(self.driver)
@property
def exist(self):
"""
True if browser is not closed and False otherwise
:rtype: bool
"""
return not self.closed and self.window().present
exists = exist
@property
def browser(self):
return self
def assert_exists(self):
self._ensure_context()
if self.window().present:
return
raise NoMatchingWindowFoundException('browser window was closed')
# private
def _ensure_context(self):
if self.closed:
raise Error('browser was closed')
if not self.default_context:
self.driver.switch_to.default_content()
self.default_context = True
@staticmethod
def _wrap_elements_in(scope, obj):
if isinstance(obj, WebElement):
return Browser._wrap_element(scope, obj)
elif isinstance(obj, list):
return [Browser._wrap_elements_in(scope, e) for e in obj]
elif isinstance(obj, dict):
for k, v in obj.items():
obj[k] = Browser._wrap_elements_in(scope, v)
return obj
else:
return obj
@staticmethod
def _wrap_element(scope, element):
from .elements.html_elements import HTMLElement
klass = nerodia.element_class_for(
element.tag_name.lower()) or HTMLElement
return klass(scope, {'element': element})
from selenium import webdriver
from time import sleep
from selenium.webdriver.support.event_firing_webdriver import EventFiringWebDriver
from Weblistner.listener import MyListeners
driver = webdriver.Chrome()
event_driver = EventFiringWebDriver(driver, MyListeners())
event_driver.implicitly_wait(10)
event_driver.get("https://demo.actitime.com/login.do")
class SeletiounTestMixin(unittest.TestCase):
BASE_EXT_QUERIES = {
'app-main': "Ext.ComponentQuery.query('app-main')",
'error_msg':
"Ext.ComponentQuery.query('messagebox[title=Error]{isVisible()}')",
'confirm_msg': "Ext.ComponentQuery.query('messagebox:visible')",
'cofirm_msg_btn':
"Ext.ComponentQuery.query('messagebox:visible button[text=Yes]')[0]",
'is_masked': "Ext.getBody().isMasked()"
}
def setUp(self):
options = webdriver.ChromeOptions()
options.add_argument('headless')
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")
self.driver = EventFiringWebDriver(
webdriver.Chrome(chrome_options=options), ScreenshotListener())
self.driver.set_page_load_timeout(10)
self.driver.set_script_timeout(10)
self.driver.maximize_window()
self.driver.get(self.get_host())
self.wait_content_is_ready()
def wait_content_is_ready(self):
self.wait_js(
"document.readyState=='complete' && window.Ext != undefined && window.Ext.ComponentQuery != undefined && {app-main}.length>0 && {app-main}[0].rendered"
.format(**self.BASE_EXT_QUERIES), 'View is not rendered!')
def wait_js(self, query, error, timeout=20, silent=False):
try:
WebDriverWait(self.driver, timeout).until(
lambda _: self.driver.execute_script("return %s" % query),
error)
except TimeoutException as e:
if not silent:
self.driver._listener.on_exception(e,
self.driver.wrapped_driver)
raise e
def wait_while_load_mask(self, silent=False):
self.wait_js("!Ext.getBody().isMasked()",
'Loading takes too much time.',
silent=silent)
def click_by_id(self, dom_id):
element = self.driver.find_element_by_id(dom_id)
builder = ActionChains(self.driver)
builder.move_to_element(element).click(element).perform()
def click_component(self, query):
cmp_id = self.driver.execute_script("return %s.id" % query)
self.driver.find_element_by_id(cmp_id).click()
def get_host(self):
return "http://127.0.0.1:%s" % TORNADO_PORT
def open_page(self, relative_url):
self.driver.get("%s/%s" % (self.get_host(), relative_url))
self.wait_content_is_ready()
def refresh_page(self):
self.driver.get(self.driver.current_url)
self.wait_content_is_ready()
def tearDown(self):
self.driver.close()
self.driver.quit()
#****** Listener class ******
class EventListener(AbstractEventListener):
def on_exception(self, exception, wdriver):
print("exception raised and listener caught **###@@@ ", exception)
wdriver.get_screenshot_as_file("error_screenshot.png")
wdriver.close()
plain_driver = webdriver.Chrome(
executable_path=
"C:/Users/shaik/PycharmProjects/drivers/chromedriver_win32/chromedriver.exe"
)
driver = EventFiringWebDriver(plain_driver, EventListener())
driver.get("https://www.expedia.com/")
time.sleep(5)
#driver.implicitly_wait(5)
driver.maximize_window()
try:
if driver.find_element(By.ID, "tab-flight-tab-hp").is_displayed():
driver.find_element(By.ID, "tab-flight-tab-hp").click()
else:
driver.find_element(
By.XPATH, "//li/a[@aria-controls='wizard-flight-pwa'").click()
except:
print("exception in identifying object")
driver.find_element(By.ID, "flight-origin-hp-flight").send_keys("CHI")
driver.find_element(By.ID, "flight-destination-hp-flight").send_keys("NYC")
driver.find_element(By.ID,
def parse_seasons(driver, player_dict):
edge_ef_driver = EventFiringWebDriver(driver, LiquipediaNavListener())
season_titles = []
link_texts = []
seasons = []
# quick hack for cleaning the list... bottom of page contains redundant links!
link_elements = edge_ef_driver.find_elements_by_partial_link_text("RLCS Season")
for link_element in link_elements:
if '-' in link_element.wrapped_element.text:
# Get season title
season_title = link_element.wrapped_element.text
season_titles.append(season_title)
link_texts.append(link_element.get_attribute("href"))
season_num = 0
for link in link_texts:
is_final = "Finals" == season_titles[season_num].split('-')[1].strip()
edge_ef_driver.get(link)
time.sleep(20)
# Get teams
teamcards = edge_ef_driver.find_elements_by_class_name("teamcard")
team_dict = parse_teams(teamcards, season_titles[season_num], player_dict)
# Get matches
matches = []
if not is_final:
# Group stage
tables = edge_ef_driver.find_elements_by_class_name("matchlist table table-bordered collapsible")
for table in tables:
table_entries = table.find_elements_by_class_name("match-row")
event = table.find_elements_by_tag_name("th").wrapped_element.text
for match in table_entries:
team1 = team_dict.get(
table_entries[0].find_element_by_tag_name("span").get_attribute("data-highlightingclass"))
team2 = team_dict.get(
table_entries[3].find_element_by_tag_name("span").get_attribute("data-highlightingclass"))
team1_wins = table_entries[1].wrapped_element.text.lstrip()
team2_wins = table_entries[2].wrapped_element.text.lstrip()
if not team1_wins == "W" and not team1_wins == "FF":
for num in range(int(team1_wins)):
matches.append(Match(team1=team1, team2=team2, victor=team1,
season_title=season_titles[season_num], event=event))
for num in range(int(team2_wins)):
matches.append(Match(team1=team1, team2=team2, victor=team2,
season_title=season_titles[season_num], event=event))
# Playoffs
bracket_web_elements = edge_ef_driver.find_elements_by_class_name("bracket-column-matches")
bracket_headers = [bracket.find_elements_by_class_name("bracket-header") for bracket in bracket_web_elements]
if re.search(r"Season [789]", season_titles[season_num]):
bracket_tuples = make_brackets(bracket_web_elements, bracket_headers, True)
else:
bracket_tuples = make_brackets(bracket_web_elements, bracket_headers, False)
get_bracket_matches(season_titles[season_num], team_dict, bracket_tuples, matches)
else:
bracket_web_elements = edge_ef_driver.find_elements_by_class_name("bracket-column-matches")
bracket_headers = [bracket.find_elements_by_class_name("bracket-header") for bracket in bracket_web_elements]
bracket_tuples = make_brackets(bracket_web_elements, bracket_headers, False)
get_bracket_matches(season_titles[season_num], team_dict, bracket_tuples, matches)
season = Season(season_titles[season_num], player_dict, set(list(team_dict.values())), matches)
seasons.append(season)
edge_ef_driver.back()
season_num += 1
time.sleep(5)
return seasons
