class Login(Base_page):
page = YAML().current_page('LoginPage')
username = page['username']
password = page['password']
loginbtn = page['loginbtn']
coursepage = YAML().current_page('CourseOverViewPage')
downloadbtn = coursepage['Download']
def login_action(self, username, password):
self.wait_for_visibility_of_element_located(self.loginbtn)
self.type(self.username, username)
self.type(self.password, password)
self.clickat(self.loginbtn)
#time.sleep(WAIT_MAX_TIME)
self.wait_for_presence_of_element_located(self.downloadbtn)
time.sleep(WAIT_MINI_TIME)
def open_app_android(self,username, password):
login_page_activity = self.page["Activity"]
if self.driver.current_activity == login_page_activity:
self.login_action(username, password)
class Settings(Base_page):
def __init__(self, driver):
self.driver = driver
course_page = YAML().current_page("CourseOverViewPage")
unittitle = course_page['unittitle']
setting = course_page['settings']
settings_logout = course_page['logout']
setting_page = YAML().current_page("SettingPage")
language = setting_page['language']
language_set = setting_page['languageset']
language_back = setting_page['language_back']
def change_language_android(
self, language): # English,Español,Deutsch,Français,Italiano,简体中文
time.sleep(WAIT_TIME)
self.clickat(self.setting)
time.sleep(WAIT_MINI_TIME)
self.clickat(self.language)
languageset = self.language_set % (language)
print("language will changed for {}".format(languageset))
self.clickelement(languageset)
#self.clickat(self.language_back)
time.sleep(WAIT_TIME)
def IOS_element(self):
page_course = YAML().current_page('CourseOverViewPage')
settings = page_course['settings'].split(";")[1]
location = self.driver.find_element_by_xpath(settings)
pic = Appium_Extend(self.driver)
course, classroom, setting = pic.get_location_by_element(location, 3)
return course, classroom, setting
class Course(Base_page):
def __init__(self, driver):
self.driver = driver
course_page = YAML().current_page("CourseOverViewPage")
setting = course_page['settings']
class ManageCourse(Base_page):
def __init__(self, driver):
self.driver = driver
manage_course_page = YAML().current_page("ManageCoursePage")
Back_button = manage_course_page['Back_button']
GE_course = manage_course_page['GE_course']
BE_course = manage_course_page['BE_course']
Lessons = manage_course_page['Lessons']
Lessonall = manage_course_page['Lessonsall']
Lessonchild = manage_course_page['Lessonchild']
def change_level_on_GE(self, id):
# self.wait_for_presence_of_element_located(self.Back_button)
self.clickat(self.GE_course)
# if 6 < id <= 10:
# self.scroll(self.Lessons%(5), self.Lessons%(1))
# elif 10 <id <= 14:
# self.scroll(self.Lessons % (5), self.Lessons % (1))
# self.scroll(self.Lessons % (9), self.Lessons % (5))
# else:
# self.scroll(self.Lessons % (5), self.Lessons % (1))
# self.scroll(self.Lessons % (9), self.Lessons % (5))
# self.scroll(self.Lessons % (13), self.Lessons % (11))
if id > 6:
swipe_time = int((id - 5) / 2)
for i in range(swipe_time):
self.swipe('up')
# levelid = abs(id - 5 - 2 *(swipe_time))
# level = self.Lessons % (levelid)
#
ele = self.find_elements(self.Lessonchild)
print(ele)
for each in ele:
if str(id) in each.text:
each.click()
break
else:
print("cannot find the element")
else:
level = self.Lessons % (id)
print(level)
self.clickat(level)
time.sleep(WAIT_LONG_TIME)
class Setting(Base_page):
def __init__(self, driver):
self.driver = driver
setting_page = YAML().current_page("SettingPage")
language = setting_page['language']
sync = setting_page['sync']
logout = setting_page['logout']
def change_language(self, language):
pass
def trigger_sync(self):
self.clickelement(self.sync)
time.sleep(WAIT_TIME)
def log_out(self):
pass
class Course(Base_page):
def __init__(self, driver):
self.driver = driver
course_page = YAML().current_page("CourseOverViewPage")
setting = course_page['settings']
settings_logout = course_page['logout']
course_page_activity = course_page['Activity']
def course_overview(self):
self.wait_activity(self.course_page_activity)
self.saveScreenshot("%s.png" % (self.course_page))
def logout(self):
self.course_overview()
time.sleep(WAIT_MAX_TIME)
self.clickat(self.setting)
time.sleep(WAIT_MINI_TIME)
self.swipe('up')
time.sleep(WAIT_MAX_TIME)
self.clickelement(self.settings_logout)
time.sleep(WAIT_MINI_TIME)
class Course(Base_page):
def __init__(self, driver):
self.driver = driver
course_page = YAML().current_page("CourseOverViewPage")
setting = course_page['settings']
settings_logout = course_page['logout']
lessonall = course_page["lessonall"]
lesson1 = course_page["lessonone"]
lesson2 = course_page["lessontwo"]
lesson3 = course_page["lessonthree"]
lesson4 = course_page["lessonfour"]
lessonpl = course_page["lessonpl"]
finishedstatus = course_page["finished_status"]
lesson_page = YAML().current_page("LessonOverViewPage")
back_button = lesson_page["back_button"]
module_page = YAML().current_page("ModuleOverViewPage")
module_download = module_page["module_download"]
module_start = module_page["module_start"]
activity_skip = module_page["activity_skip_button"]
countinue_button = module_page["countinue_button"]
if PLATFORM == "Android":
course_page_activity = course_page["Activity"]
lesson_page_activity = lesson_page["Activity"]
module_page_activity = module_page["Activity"]
lesson_collapse = lesson_page["Lesson_collapse"]
change_course_btn = course_page['Change_level_button']
if PLATFORM == "IOS":
allmodules = module_page["moduleall"]
moduleseachline = module_page["moduleach"]
def course_overview_android(self):
self.wait_activity(self.course_page_activity)
self.saveScreenshot("%s.png" % (self.course_page))
def change_level_btn(self):
self.clickat(self.change_course_btn)
def logout_android(self):
self.course_overview_android()
self.clickat(self.setting)
time.sleep(WAIT_MINI_TIME)
self.swipe('up')
time.sleep(WAIT_MINI_TIME)
self.clickelement(self.settings_logout)
def pass_one_unit_android(self):
self.wait_activity(self.course_page_activity)
self.wait_for_presence_of_element_located(self.lessonall)
# lessons = self.find_elements(self.lessonall)
# lessons = self.driver.find_elements_by_id("unit_lessons_page")
# print(lessons)
for i in range(1, 5):
print("start lesson {}".format(i))
# print("lesson {}".format(lessons[i]))
self.pass_one_lesson_android(eval('self.lesson{}'.format(i)))
def pass_one_lesson_android(self, lesson):
self.clickat(lesson)
self.wait_activity(self.lesson_page_activity)
self.clickelement(self.lesson_collapse)
self.wait_for_presence_of_element_located(self.module_page["modules"])
# self.driver.wait_activity(self.module_page_activity)
elements = self.find_elements(self.module_page["modules"])
print("module number is {number}".format(number=len(elements)))
i = 1
for element in elements:
self.pass_one_module_android(element)
print("start %d module" % (i))
i = i + 1
time.sleep(WAIT_MINI_TIME)
self.clickelement(self.back_button)
def assert_lesson_passed(self, lesson):
self.wait_activity(self.course_page_activity)
self.wait_for_presence_of_element_located(self.lessonall)
if self.wait_for_presence_of_element_located(lesson):
return True
else:
return False
def pass_one_module_android(self, module):
module.click()
if self.is_element_exists(self.module_download):
self.clickelement(self.module_download)
time.sleep(WAIT_TIME)
if self.is_element_exists(self.module_download):
self.clickelement(self.module_download)
time.sleep(WAIT_TIME)
if self.is_element_exists(self.module_download):
time.sleep(WAIT_LONG_TIME)
if self.is_element_exists(self.module_download):
time.sleep(WAIT_MAX_TIME)
self.wait_for_presence_of_element_located(self.module_start)
self.clickelement(self.module_start)
self.wait_for_presence_of_element_located(self.activity_skip)
while self.is_element_exists(self.activity_skip):
self.wait_for_presence_of_element_located(self.activity_skip)
self.clickelement(self.activity_skip)
time.sleep(WAIT_MINI_TIME)
self.clickelement(self.countinue_button)
def logout_ios(self):
element = element_exist(self.driver)
self.swipe('down')
element.tap_setting()
self.swipe('down')
self.swipe('down')
time.sleep(2)
self.clickat(self.settings_logout)
def pass_one_unit_ios(self):
time.sleep(10)
lessons = self.find_elements(self.lessonall)
print(lessons)
for i in range(5):
print("start lesson {}".format(i))
print("lesson {}".format(lessons[i]))
self.pass_one_lesson_ios(lessons[i])
def pass_one_lesson_ios(self, lesson):
time.sleep(15)
self.clickat(lesson)
modules = self.find_elements(self.allmodules)
for i in range(0, len(modules) + 1, 2):
modulesline = self.find_elements(self.moduleseachline % (i))
for module in modulesline:
self.pass_one_module_ios(module)
def pass_one_module_ios(self, module):
module.click()
time.sleep(5)
if self.is_element_exists(self.module_download):
self.clickat(self.module_download)
time.sleep(15)
# if self.is_element_exists(self.module_page["arrow"]):
# self.clickat(self.module_page["arrow"])
# self.swipe('down')
#
# if self.is_element_exists(self.countinue_button):
# self.clickat(self.countinue_button)
self.clickat(self.module_start)
time.sleep(2)
while self.is_element_exists(self.activity_skip):
self.clickat(self.activity_skip)
time.sleep(2)
self.clickat(self.countinue_button)
time.sleep(2)
def logout_action(self):
if PLATFORM == "Android":
self.logout_android()
if PLATFORM == "IOS":
self.logout_ios()
def change_course_action(self):
if PLATFORM == "Android":
self.change_level_btn()
def pass_one_lesson_action(self, lesson):
if '1' in lesson:
takelesson = self.lesson1
lessonid = 1
if '2' in lesson:
takelesson = self.lesson2
lessonid = 2
if '3' in lesson:
takelesson = self.lesson3
lessonid = 3
if '4' in lesson:
takelesson = self.lesson4
lessonid = 4
if PLATFORM == "Android":
self.pass_one_lesson_android(takelesson)
assert (self.assert_lesson_passed(self.finishedstatus %
(lessonid)))
if PLATFORM == "IOS":
self.pass_one_lesson_ios(takelesson)
def pass_one_unit_action(self):
# takelesson = [self.lesson1, self.lesson2, self.lesson3, self.lesson4]
if PLATFORM == "Android":
self.pass_one_unit_android()
if PLATFORM == "IOS":
self.pass_one_unit_ios()
def check_login_success_ios(self):
# self.login.login_action(self.username, self.password)
# self.login.course_overview()
# time.sleep(8)
# self.login.logout_action()
yml = YAML()
iosfile = yml.read_yml(
"/Users/anderson/testcode/mynewthinking/autotest/pages/pages.yml")
ele = self.login.driver.find_element_by_xpath(
iosfile["IOS"]["LoginPage"]["username"])
print(ele)
self.login.driver.set_value(ele, self.username)
time.sleep(2)
ele = self.login.driver.find_element_by_xpath(
iosfile["IOS"]["LoginPage"]["password"])
print(ele)
self.login.driver.set_value(ele, self.password)
time.sleep(2)
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["loginbtn"]).click()
time.sleep(20)
# self.login.swipe('down')
# self.login.swipe('up')
# # self.login.driver.find_element_by_ios_predicate('type == "XCUIElementTypeOther" AND label == "Profile"').click()
# print(iosfile["IOS"]["LoginPage"]["settings"])
# location = self.login.driver.find_element_by_xpath(iosfile["IOS"]["LoginPage"]["settings"])
# print(location)
# print(location.size)
# pic = Appium_Extend(self.login.driver)
# a, b, c = pic.get_location_by_element(location, 3)
# print("course")
# print(a)
# print("classroom")
# print(b)
# print("setting")
# print(c)
# self.login.driver.tap(c, )
# time.sleep(2)
# self.login.driver.tap(a, )
# time.sleep(2)
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["lessonone"]).click()
time.sleep(2)
# self.login.driver.find_element_by_id(iosfile["IOS"]["LoginPage"]["backbtn"]).click()
# time.sleep(2)
# self.login.driver.tap(b, )
# time.sleep(2)
modules = self.login.driver.find_elements_by_xpath(
iosfile["IOS"]["LoginPage"]["moduleall"])
# modulesline = self.login.driver.find_elements_by_xpath(iosfile["IOS"]["LoginPage"]["moduleall"])
# mods = list(filter(lambda e: e % 2 == 0, modules))
ele = element_exist(self.login.driver)
for i in range(0, len(modules)):
modulesline = self.login.driver.find_elements_by_xpath(
iosfile["IOS"]["LoginPage"]["moduleach"] % (i))
for each in modulesline:
each.click()
if ele.is_element_exists_by_id(
iosfile["IOS"]["LoginPage"]["download"]):
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["download"]).click()
time.sleep(20)
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["startbtn"]).click()
time.sleep(2)
if ele.is_element_exists_by_id(
iosfile["IOS"]["LoginPage"]["arrow"]):
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["arrow"]).click()
self.login.swipe('down')
if ele.is_element_exists_by_id(
iosfile["IOS"]["LoginPage"]["countiune"]):
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["countiune"]).click()
if ele.is_element_exists_by_id(
iosfile["IOS"]["LoginPage"]["startbtn"]):
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["startbtn"]).click()
while ele.is_element_exists_by_id(
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["btnQApass"])):
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["btnQApass"]).click()
time.sleep(2)
self.login.driver.find_element_by_id(
iosfile["IOS"]["LoginPage"]["btnContinue"]).click()
time.sleep(2)
class Base_page():
capabilities = YAML().current_device()
if PLATFORM == 'Android':
capabilities['app'] = AppPath.get_app_filename(build_path)
capabilities['platformVersion'] = get_android_version()
capabilities['deviceName'] = get_device_name()
print(get_android_version)
print(capabilities)
# capabilities['platformName'] = 'Android'
# capabilities['platformVersion'] = '5.1'
# capabilities['deviceName'] = "192.168.56.101:5555"
# capabilities['appPackage'] = 'com.ef.core.engage.englishtown'
# capabilities['appActivity'] = 'com.ef.core.engage.ui.screens.activity.EnglishTownSplashActivity'
# capabilities['appWaitActivity'] = 'com.ef.core.engage.ui.screens.activity.EnglishTownLoginActivity'
# capabilities['app'] = '/Users/anderson/Documents/builds/engage-englishtown-uat-debug-1.5.0.apk'
# # capabilities['unicodeKeyboard'] = True
# capabilities['resetKeyboard'] = True
# capabilities['noSign'] = True
# capabilities['noReset'] = True
def __init__(self):
self.driver = webdriver.Remote('http://localhost:4723/wd/hub',
self.capabilities)
# def locator_to_by_value(self,locator):
# separator_index = locator.find(";")
# by = locator[:separator_index]
# value = locator[separator_index + 1:]
# try:
# by = locator_to_by_map[by]
# except KeyError:
# print("The by <%s> of locator <%s> is not a valid By." % (by, locator))
# return by, value
# def action_element(self, by, value):
#
# if by == 'id':
#
# try:
# element = self.driver.find_element_by_id(value)
# except NoSuchElementException:
# return False
#
# if by == 'xpath':
# try:
# element = self.driver.find_element_by_xpath(value)
# except NoSuchElementException:
# return False
#
# if by == 'name':
# try:
# element = self.driver.find_element_by_name(value)
# except NoSuchElementException:
# return False
#
# return element
#
def action_elements(self, by, value):
elements = ""
if by == 'id':
elements = self.driver.find_elements_by_id(value)
if by == 'xpath':
elements = self.driver.find_elements_by_xpath(value)
return elements
#
# def find_element(self, tag):
# key = tag.split(";")[0]
# value = tag.split(";")[1]
# if self.action_element(key, value):
# # WebDriverWait(self.driver, MAX_TIMES).until(self.action_element(key, value).is_displayed())
# return self.action_element(key, value)
#
# else:
# print("%s page cannot find %s %s" % (self, key, value))
# return False
#
def find_elements(self, tag):
key = tag.split(";")[0]
value = tag.split(";")[1]
try:
# WebDriverWait(self.driver, MAX_TIMES).until(self.action_element(key, value).is_displayed())
# if len(self.action_element(key, value)):
return self.action_elements(key, value)
except NoSuchElementException:
print("%s page cannot find %s %s" % (self, key, value))
return False
def find_element(self, tag):
loc = (locator_to_by_value(tag))
try:
#WebDriverWait(self.driver, WAIT_MAX_TIME).until(lambda driver: driver.find_element(*loc).is_displayed())
#self.wait_for_presence_of_element_located(tag)
return self.driver.find_element(*loc)
except:
print("%s page cannot find element %s " % (self, loc))
# def find_elements(self, tag):
#
# loc = (self.locator_to_by_value(tag))
# try:
# WebDriverWait(self.driver, WAIT_MAX_TIME).until(lambda driver: driver.find_elements(*loc).is_displayed())
#
# return self.driver.find_elements(*loc)
# except:
# print("%s page cannot find elements%s" % (self, loc))
def type(self, element, value):
ele = self.find_element(element)
# ele.clear()
return self.driver.set_value(ele, value)
def clickat(self, element):
return self.find_element(element).click()
def clickelement(self, element):
self.wait_for_presence_of_element_located(element)
ele = self.find_element(element)
ele.click()
def getelementtext(self, element):
text = self.find_element(element).text()
return text
def savePngName(self, name):
"""
name：自定义图片的名称
"""
day = time.strftime('%Y-%m-%d', time.localtime(time.time()))
fp = "Result/" + day + "/image/" + day
tm = self.saveTime()
type = ".png"
if os.path.exists(fp):
filename = fp + "/" + tm + "_" + name + type
# print "True"
return filename
else:
os.makedirs(fp)
filename = fp + "/" + tm + "_" + name + type
# print "False"
return filename
# 获取系统当前时间
def saveTime(self):
"""
返回当前系统时间以括号中（2014-08-29-15_21_55）展示
"""
return time.strftime('%Y-%m-%d-%H_%M_%S', time.localtime(time.time()))
# saveScreenshot:通过图片名称，进行截图保存
def saveScreenshot(self, name):
"""
快照截图
name:图片名称
"""
# 获取当前路径
# print os.getcwd()
image = self.driver.save_screenshot(self.savePngName(name))
return image
def wait_activity(self, activity, time=10):
self.driver.wait_activity(activity, time)
def is_element_exists(self, tag):
if self.find_element(tag):
return True
else:
return False
def scroll(self, origin, destination):
from_ele = self.find_element(origin)
to_ele = self.find_element(destination)
self.driver.scroll(origin_el=from_ele, destination_el=to_ele)
# driver.swipe(start_x, start_y, end_x, end_y, duration)
def swipe(self, direction, duration=500):
window_size = self.driver.get_window_size()
if (window_size and 'width' in window_size and \
window_size['width'] and window_size['width'] > 0 and \
'height' in window_size and \
window_size['height'] and window_size['height'] > 0):
width = window_size['width']
height = window_size['height']
if direction == 'down':
self.driver.swipe(width / 2, height / 4, width / 2,
height * 3 / 4, duration)
elif direction == 'up':
self.driver.swipe(width / 2, height * 3 / 4, width / 2,
height / 4, duration)
elif direction == 'left':
self.driver.swipe(width * 3 / 4, height / 2, width / 4,
height / 2, duration)
elif direction == 'right':
self.driver.swipe(width / 4, height / 2, width * 3 / 4,
height / 2, duration)
else:
return False
return True
else:
assert False, 'Fail to obtain window size for swiping! {0}'.format(
window_size)
def equals_ignore_case(self, str1, str2):
return re.match(re.escape(str1) + r'\Z', str2, re.I) is not None
# def locator_to_by_value(self, tag):
# key = tag.split(";")[0]
# value = tag.split(";")[1]
#
#
# mobile_by_properties = [member for member in inspect.getmembers(MobileBy) if member[0][:1] != '_']
# property_name = [member[0] for member in mobile_by_properties
# if self.equals_ignore_case(member[1], key)][0]
# by = eval("MobileBy.{}".format(property_name))
#
# return (by, value)
def wait(self, timeout=WAIT_MAX_TIME):
return WebDriverWait(self.driver, timeout)
def wait_until(self, method, message=None, timeout=WAIT_MAX_TIME):
return self.wait(timeout).until(method, message)
def wait_unitl_not(self, method, message=None, timeout=WAIT_MAX_TIME):
return self.wait(timeout).until_not(method, message)
def wait_for_visibility_of_element(self, element, timeout=WAIT_MAX_TIME):
return self.wait_until(EC.visibility_of(element),
"Element {} is not visible".format(element),
timeout=timeout)
def wait_for_presence_of_element_located(self, tag, timeout=WAIT_MAX_TIME):
locator_info = locator_to_by_value(tag)
return self.wait_until(
EC.presence_of_element_located(locator_info),
"Element locator (by: {0}, value: {1}) is not present".format(
locator_info[0], locator_info[1]),
timeout=timeout)
def wait_for_visibility_of_element_located(self,
tag,
timeout=WAIT_MAX_TIME):
locator_info = locator_to_by_value(tag)
return self.wait_until(
EC.visibility_of_element_located(locator_info),
"Element locator (by: {0}, value: {1}) is not visible".format(
locator_info[0], locator_info[1]),
timeout=timeout)
def wait_for_invisibility_of_element_located(self,
locator,
timeout=WAIT_MAX_TIME):
return self.wait_until(
EC.invisibility_of_element_located(locator),
"Element with locator {} is still existed".format(locator),
timeout=timeout)