class ProfilePageTest(EnvironmentSetup):
log = cl.customLogger(logging.DEBUG)
def setUp(self):
super().setUp()
page_obj = PageFactory()
self.profilePage = page_obj.createPage("profile", self.driver,
self.dic_prop)
def test_verifyProfilePageTitle(self):
title = self.profilePage.validateProfilePageTitle()
self.assertEqual(title,
"Home - Udacity",
msg="test_verifyProfilePageTitle Failed")
def test_verifyElementsOfProfilePage(self):
self.assertTrue(self.profilePage.validateHomeLink(),
msg="test_verifyElementsOfProfilePage Failed "
":: Home link not found")
self.assertTrue(self.profilePage.validateCatalogLink(),
msg="test_verifyElementsOfProfilePage Failed "
":: Catalog link not found")
self.assertTrue(self.profilePage.validateSettingsLink(),
msg="test_verifyElementsOfProfilePage Failed "
":: Settings link not found")
def test_verifyLogout(self):
self.profilePage.validateLogout()
self.screenshot.takeScreenShot(self.screenshotName)
time.sleep(2)
with self.assertRaises(StaleElementReferenceException):
self.profilePage.getHomeHeader().is_displayed()
class UserGenerator:
log = cl.customLogger(logging.DEBUG)
def __init__(self):
self._base = None
self._email = None
self._password = None
self._number = None
self._name = None
def generateName(self):
self._base = "test_user"
self._number = random.randint(100, 1000)
self._name = self._base + str(self._number)
self.log.debug("User is created - " + self._name)
return self._name
def generateEmail(self):
if self._name:
self.log.debug("New email for user is created - {}@test.com".format(self._name))
return self._name + "@test.com"
else:
return self.generateName() + "@test.com"
def generatrPassword(self):
if self._name:
self._password = self._name + "pass"
self.log.debug("New password for user is created - {}".format(self._password))
return self._password
else:
return self.generateName()
class HomePageTest(EnvironmentSetup):
log = cl.customLogger(logging.DEBUG)
def setUp(self):
super().setUp()
page_obj = PageFactory()
self.homePage = page_obj.createPage("home", self.driver, self.dic_prop)
def test_verifyHomePageTitle(self):
title = self.homePage.validatHomePageTitle()
self.assertTrue(
title == "Udacity - Free Online Classes & Nanodegrees | Udacity",
msg="test_verifyHomePageTitle Failed")
def test_verifySignInIsDisplayed(self):
self.assertTrue(self.homePage.getSignIn().is_displayed(),
msg="test_verifySignInIsDisplayed Failed")
def test_verifySignUpIsDisplayed(self):
self.assertTrue(self.homePage.getSignUp().is_displayed(),
msg="test_verifySignUpIsDisplayed Failed")
def test_verifySignInButton(self):
login = self.homePage.clickToSignIn()
self.assertIsInstance(login,
SignInPage,
msg="test_verifySignInButton Failed")
def test_verifySignUpButton(self):
register = self.homePage.clickToSignUp()
self.assertIsInstance(register,
SignUpPage,
msg="test_verifySignUpButton Failed")
class SignInPageTest(EnvironmentSetup):
log = cl.customLogger(logging.DEBUG)
def setUp(self):
super().setUp()
page_obj = PageFactory()
self.signInPage = page_obj.createPage("signin", self.driver,
self.dic_prop)
def test_verifySignInPageTitle(self):
title = self.signInPage.validateSignInPageTitle()
self.assertEqual(title,
"Sign In - Udacity",
msg="test_verifySignInPageTitle Failed")
def test_verifyValidSignIn(self):
self.signInPage.signInToUdacity()
with self.assertRaises(NoSuchElementException,
msg="test_verifyValidSignIn Failed"):
time.sleep(3)
self.screenshot.takeScreenShot(self.screenshotName)
self.signInPage.invalidSignInMessage()
def test_verifyInvalidSignIn(self):
self.signInPage.setEmail(self.dic_prop.get("invalid_email", "unknown"))
self.signInPage.setPassword(
self.dic_prop.get("invalid_password", "unknown"))
self.signInPage.clickSubmitButton()
time.sleep(5)
self.assertEqual(self.signInPage.invalidSignInMessage(),
"The email or password you entered is invalid",
msg="test_verifyInvalidSignIn Failed")
class HomePage(TestBase):
log = cl.customLogger(logging.DEBUG)
def __init__(self, driver, dict_prop):
super(HomePage, self).__init__(driver, dict_prop)
self.log.debug("Home page initialization")
self._signInButton = driver.find_element(By.XPATH, "//div[@class='normal ng-star-inserted']//a[@title='Sign In'][contains(text(),'Sign In')]")
self._signUpButton = driver.find_element(By.XPATH, "//div[@class='normal ng-star-inserted']//a[@title='Get Started'][contains(text(),'Get Started')]")
self._title = driver.title
def validatHomePageTitle(self):
self.log.debug("Page title successfully found - {}".format(self._title))
return self._title
def getSignIn(self):
return self._signInButton
def getSignUp(self):
return self._signUpButton
def clickToSignIn(self):
self._signInButton.click()
self.log.debug("Sign in button verified - {}".format(str(self._signInButton)))
self.log.debug("Loading SignInPage...")
return SignInPage(self.driver, self.dict_prop)
def clickToSignUp(self):
self._signUpButton.click()
self.log.debug("Sign un button verified - {}".format(str(self._signUpButton)))
self.log.debug("Loading SignUpPage...")
return SignUpPage(self.driver, self.dict_prop)
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 ProfilePage(TestBase):
log = cl.customLogger(logging.DEBUG)
def __init__(self, driver, dict_prop):
super(ProfilePage, self).__init__(driver, dict_prop)
self.log.debug("Profile page initialization")
time.sleep(2)
self._home = self.driver.find_element(By.XPATH, "//a[@title='Home']")
self._catalog = self.driver.find_element(By.XPATH,
"//a[@title='Catalog']")
self._settings = self.driver.find_element(By.XPATH,
"//a[@title='Settings']")
self._logoutButton = self.driver.find_element(By.XPATH,
"//a[@title='Logout']")
self._homeHeader = self.driver.find_element(
By.XPATH,
"//div[@class='_layout-module--title-area--1yynf']//div[@class='_header-module--header--1boX-']//div//h1[@aria-live='assertive'][contains(text(),'Home')]"
)
time.sleep(2)
self._title = self.driver.title
def validateProfilePageTitle(self):
self.log.debug("Page title successfully found - {}".format(
self._title))
return self._title
def validateHomeLink(self):
return self._home.is_displayed()
def validateCatalogLink(self):
return self._catalog.is_displayed()
def validateSettingsLink(self):
return self._settings.is_displayed()
def validateLogout(self):
self._logoutButton.click()
self.log.debug("Loading home page...")
def clickCatalog(self):
self._catalog.click()
def clickSettings(self):
self._settings.click()
def getHomeHeader(self):
return self._homeHeader
class SignInPage(TestBase):
log = cl.customLogger(logging.DEBUG)
def __init__(self, driver, dict_prop):
super(SignInPage, self).__init__(driver, dict_prop)
self.log.debug("SignIn page initialization")
self._user = dict_prop.get("user_email")
self._password = dict_prop.get("user_password")
self._emailTextField = driver.find_element(By.XPATH, "//input[@placeholder='Email Address']")
self._passwordTextField = driver.find_element(By.XPATH, "//input[@placeholder='Password']")
self._submitButton = driver.find_element(By.XPATH, "//div[@class='tabbed-pane_content__2C5RM']//div//div//div//button[@type='button'][contains(text(),'Sign In')]")
self._title = driver.title
def validateSignInPageTitle(self):
self.log.debug("Page title successfully found - {}".format(self._title))
return self._title
def setEmail(self, email):
self._emailTextField.send_keys(email)
def setPassword(self, password):
self._passwordTextField.send_keys(password)
def clickSubmitButton(self):
self._submitButton.click()
def invalidSignInMessage(self):
return self.driver.find_element(By.XPATH, "//div[contains(@class,'alert_error__2FgfU alert__alert__1lOTi ')]").text
def signInToUdacity(self):
self._emailTextField.send_keys(self._user)
self._passwordTextField.send_keys(self._password)
self.log.debug("Login email: {}, password: {}".format(self._user, self._password))
self._submitButton.click()
return ProfilePage(self.driver, self.dict_prop)
def _clearTextFields(self):
self._emailTextField.clear()
self._passwordTextField.clear()
self.log.debug("Email and Password textfields are successfully cleared.")
class SignUpPageTest(EnvironmentSetup):
log = cl.customLogger(logging.DEBUG)
def setUp(self):
super().setUp()
page_obj = PageFactory()
self.signUpPage = page_obj.createPage("signup", self.driver, self.dic_prop)
def test_verifySignUpPageTitle(self):
title = self.signUpPage.validateSignUpPageTitle()
self.assertEqual(title, "Sign Up - Udacity", msg="test_verifySignUpPageTitle Failed")
def test_verifyValidSignUp(self):
self.signUpPage.signUpToUdacity()
with self.assertRaises(NoSuchElementException, msg="test_verifyValidSignUp Failed"):
time.sleep(3)
self.signUpPage.invalidRegistrationMessage()
def test_verifySignUpWithInvalidEmail(self):
self.signUpPage.setEmail(self.dic_prop.get("user_email"))
self.signUpPage.setFirstName(self.dic_prop.get("invalid_first_name"))
self.signUpPage.setLastName(self.dic_prop.get("invalid_last_name"))
self.signUpPage.setPassword(self.dic_prop.get("user_password"))
self.signUpPage.setConfirmPassword(self.dic_prop.get("user_password"))
self.signUpPage.clickSubmitButton()
time.sleep(3)
self.screenshot.takeScreenShot(self.screenshotName)
self.assertEqual(self.signUpPage.invalidRegistrationMessage(), "This email is already registered",
msg="test_verifySignUpWithInvalidEmail Failed")
def test_verifySignUpWithInvalidPassword(self):
self.signUpPage.setEmail(self.dic_prop.get("user_email"))
self.signUpPage.setFirstName(self.dic_prop.get("invalid_first_name"))
self.signUpPage.setLastName(self.dic_prop.get("invalid_last_name"))
self.signUpPage.setPassword(self.dic_prop.get("invalid_password"))
self.signUpPage.setConfirmPassword(self.dic_prop.get("invalid_password"))
self.signUpPage.clickSubmitButton()
time.sleep(3)
self.screenshot.takeScreenShot(self.screenshotName)
self.assertEqual(self.signUpPage.invalidRegistrationMessage(), "Password is known to be too common.",
msg="test_verifySignUpWithInvalidPassword Failed")
class WebEventListener(AbstractEventListener):
log = cl.customLogger(logging.DEBUG)
def before_navigate_to(self, url, driver):
self.log.debug("Before navigating to: '" + str(url) + "'")
def after_navigate_to(self, url, driver):
self.log.debug("Navigated to:'" + str(url) + "'")
def before_navigate_back(self, driver):
self.log.debug("Navigating back to previous page")
def after_navigate_back(self, driver):
self.log.debug("Navigated back to previous page")
def before_navigate_forward(self, driver):
self.log.debug("Navigating forward to next page")
def after_navigate_forward(self, driver):
self.log.debug("Navigated forward to next page")
def before_find(self, by, value, driver):
self.log.debug("Trying to find Element By : " + str(by) + " value: " +
str(value))
def after_find(self, by, value, driver):
self.log.debug("Found Element By : " + str(by) + " value: " +
str(value))
def before_click(self, element, driver):
self.log.debug("Trying to click on: " + str(element))
def after_click(self, element, driver):
self.log.debug("Clicked on: " + str(element))
def before_change_value_of(self, element, driver):
self.log.debug("Value of the:" + str(element) +
" before any changes made")
def after_change_value_of(self, element, driver):
self.log.debug("Element value changed to: " + str(element))
def before_execute_script(self, script, driver):
pass
def after_execute_script(self, script, driver):
pass
def before_close(self, driver):
self.log.debug("Trying to close the browser")
def after_close(self, driver):
self.log.debug("Browser was closed")
def before_quit(self, driver):
self.log.debug("Trying to quit the browser")
def after_quit(self, driver):
self.log.debug("Test was quited")
def on_exception(self, exception, driver):
self.log.error("!!! " + str(exception))
class SignUpPage(TestBase):
log = cl.customLogger(logging.DEBUG)
def __init__(self, driver, dict_prop):
super(SignUpPage, self).__init__(driver, dict_prop)
self.log.debug("SignUp page initialization")
self._newUser = UserGenerator()
self._firstName = driver.find_element(
By.XPATH, "//input[@placeholder='First Name']")
self._lastName = driver.find_element(
By.XPATH, "//input[@placeholder='Last Name']")
self._email = driver.find_element(
By.XPATH, "//input[@placeholder='Email Address']")
self._password = driver.find_element(
By.XPATH, "//input[@placeholder='Password']")
self._confirmPassword = driver.find_element(
By.XPATH, "//input[@placeholder='Confirm Password']")
self._signUpButton = driver.find_element(
By.XPATH,
"//div[@class='tabbed-pane_content__2C5RM']//div//div//div//button[@type='button'][contains(text(),'Sign Up')]"
)
self._title = driver.title
def validateSignUpPageTitle(self):
self.log.debug("Page title successfully found - {}".format(
self._title))
return self._title
def signUpToUdacity(self):
self._clearTextFields()
self._firstName.send_keys(self._newUser.generateName())
self._lastName.send_keys(self._newUser.generateName())
self._email.send_keys(self._newUser.generateEmail())
self._password.send_keys(self._newUser.generatrPassword())
self._confirmPassword.send_keys(self._newUser.generatrPassword())
self._signUpButton.click()
self.log.debug("Loading Profile page...")
return ProfilePage(self.driver, self.dict_prop)
def setFirstName(self, firstName):
self._firstName.send_keys(firstName)
def setLastName(self, lastName):
self._lastName.send_keys(lastName)
def setEmail(self, email):
self._email.send_keys(email)
def setPassword(self, password):
self._password.send_keys(password)
def setConfirmPassword(self, password):
self._confirmPassword.send_keys(password)
def clickSubmitButton(self):
self._signUpButton.click()
def _clearTextFields(self):
self._firstName.clear()
self._lastName.clear()
self._email.clear()
self._password.clear()
self._confirmPassword.clear()
self.log.debug("Registration textfields are successfully cleared.")
def invalidRegistrationMessage(self):
return self.driver.find_element(
By.XPATH,
"//div[contains(@class,'alert_error__2FgfU alert__alert__1lOTi ')]"
).text
import logging
import unittest
import sys, os
sys.path.append(os.path.realpath('..'))
import util.Logger as cl
from scripts.ProfilePageTest import ProfilePageTest
from scripts.HomePageTest import HomePageTest
from scripts.SignInPageTest import SignInPageTest
from scripts.SignUpPageTest import SignUpPageTest
log = cl.customLogger(logging.DEBUG)
def suite():
suite = unittest.TestSuite()
suite.addTest(SignInPageTest("test_verifyValidSignIn"))
suite.addTest(ProfilePageTest("test_verifyLogout"))
suite.addTest(SignUpPageTest("test_verifyValidSignUp"))
return suite
if __name__ == "__main__":
runner = unittest.TextTestRunner(verbosity=2,
descriptions=True,
stream=sys.stdout)
