def do_func(*arg):
n = Settings().n
i = 0
now = datetime.datetime.now()
log(
log_path,
"A\t开始时间：{}\t{}".format(now.strftime('%Y-%m-%d %H:%M:%S'),
func.__name__))
while True:
log(
log_path,
"C\t{}{} 方法第{}次开始执行~~~".format(" ☆ ", func.__name__,
i + 1))
try:
func(*arg)
break
except AssertionError as e:
log(
log_path, "E\t{}{} 执行过程中出现了断言异常，具体信息为：\n\t{}".format(
" ☆ ", func.__name__, str(e)))
i += 1
except:
log(
log_path, "F\t{}{} 执行过程中出现了其他异常，具体信息为：\n\t{}".format(
" ☆ ", func.__name__, traceback.format_exc()))
i += 1
if i == n:
break
# lg.log("出现非断言异常，即将进行一次重试！速度将会根据配置文件放慢执行！！！！")
log(log_path, "D\t{}{} 方法执行结束~~~".format(" ☆ ", func.__name__))
now = datetime.datetime.now()
log(
log_path,
"B\t结束时间：{}\t{}\n".format(now.strftime('%Y-%m-%d %H:%M:%S'),
func.__name__))
class Test_NAME(unittest.TestCase):
def setUp(self):
self.he = Home_element()
self.le = Log_in_element()
self.st = Settings()
self.sc = Shopping_cart_element()
self.so = Submit_order_element()
self.bs = Backstage()
self.uc = User_center_element()
self.driver = SeleniumDriver(type=None)
self.driver.Wait()
self.base_url = self.st.base_url
@log_decorator(Settings().log)
def test_NAME(self):
# 调用函数
he = self.he
le = self.le
st = self.st
sc = self.sc
so = self.so
bs = self.bs
uc = self.uc
# 打开网页
driver = self.driver
driver.open(self.base_url)
# 执行测试内容
pass
def tearDown(self):
self.driver.quit()
class Log_in_element():
he = Home_element()
st = Settings()
'''
登录界面元素
'''
LOG_IN_USERNAME = [By.NAME, "username"]
LOG_IN_USERPASSWD = [By.NAME, "password"]
LOG_IN_IMTY_BUTTON = [By.NAME, "submit"]
def log_in(self, driver, user):
'''
前段登录
'''
# 实例化首页元素
he = self.he
# 打开前段
driver.open(self.st.base_url)
# 点击登录 //*[@id='ECS_MEMBERZONE']/a[1]/img
try:
driver.find_element(he.LOG_IN_BUTTON).click()
except:
he.quit(driver)
sleep(1)
driver.find_element(he.LOG_IN_BUTTON).click()
print("|---------------------------------------|")
print("| 这是一个登录安全漏洞！大BUG！！！！！ |")
print("|---------------------------------------|")
# 输入用户名 name="username"
driver.find_element(self.LOG_IN_USERNAME).send_keys(user['name'])
# 输入密码 name="password"
driver.find_element(self.LOG_IN_USERPASSWD).send_keys(user['password'])
# 点击立即登录 name="submit"
driver.find_element(self.LOG_IN_IMTY_BUTTON).click()
def setUp(self):
self.he = Home_element()
self.le = Log_in_element()
self.st = Settings()
self.sc = Shopping_cart_element()
self.so = Submit_order_element()
self.bs = Backstage()
self.uc = User_center_element()
self.driver = SeleniumDriver(type=None)
self.driver.Wait()
self.base_url = self.st.base_url
def __init__(self, type=None):
'''
初始化指定的浏览器驱动
'''
# 得到webdriver
self.driver = Chrome_flash()
# self.driver = WebDriver(command_executor='http://172.31.23.143:4444/wd/hub',
# desired_capabilities=DesiredCapabilities.CHROME)
# 实例化基本配置
st = Settings()
# 获取放慢速度
if type is None:
self.speed = st.speed_default
else:
self.speed = st.speed_down
log(self.log_path, "G\t初始化指定的浏览器驱动~~~")
class Test_Log(unittest.TestCase):
def setUp(self):
self.st = Settings()
self.driver = SeleniumDriver(type=None)
self.driver.Wait()
self.base_url = "http://baidu.com"
@log_decorator(Settings().log)
def test_log(self):
# 调用函数
st = self.st
# 打开网页
driver = self.driver
driver.open(self.base_url)
def tearDown(self):
self.driver.quit()
def setUp(self):
self.st = Settings()
self.driver = SeleniumDriver(type=None)
self.driver.Wait()
self.base_url = "http://baidu.com"
class Submit_order_element():
'''
提交订单页面
'''
uc = User_center_element()
st = Settings()
SUBMIT_ORDER_BUTTON = [By.XPATH, "//input[@type='image']"]
DELIVERY_METHOD_LIST = [By.XPATH, "//table[@id='shippingTable']/tbody/tr"]
DELIVERY_METHOD = [By.NAME, "shipping"]
PAY_METHOD_LIST = [By.XPATH, "//table[@id='paymentTable']/tbody/tr"]
PAY_METHOD = [By.NAME, "payment"]
ORDER_NUMBER = [By.XPATH, "//font[@style='color:red']"]
def submit_order_button(self, driver, method=None, pay=None):
'''
尝试去点击配送方式
如果没有 则填写地址
'''
uc = self.uc
st = self.st
# 尝试是否需要添加地址
try:
# 输入地址
uc.add_shipping_address(driver)
except:
pass
# 点击配送方式
self.delivery_method(driver, method)
# 点击付款方式
self.pay_method(driver, pay)
# 尝试找到 提交订单 input type="image"
driver.find_element(self.SUBMIT_ORDER_BUTTON).click()
# 导出订单号 font style="color:red"
order_number = driver.find_element(self.ORDER_NUMBER).text
print("订单号：{}".format(order_number))
return order_number
def delivery_method(self, driver, method='城际快递'):
# id="shippingTable" /tbody/tr
method_list = driver.find_elements(self.DELIVERY_METHOD_LIST)
method_number = 0
if method == '城际快递':
method_number = 1
elif method == '申通快递':
method_number = 2
elif method == '邮局平邮':
method_number = 3
elif method == '随机' or method == None:
method_number = 0
else:
print("请输入正确配送方式：城际快递、申通快递、邮局平邮")
# 选择
if method_number != 0:
method_list[method_number].find_element(
*self.DELIVERY_METHOD).click()
else:
n = randint(1, 3)
method_list[n].find_element(*self.DELIVERY_METHOD).click()
def pay_method(self, driver, pay='余额支付'):
# paymentTable
# id="shippingTable" /tbody/tr
method_list = driver.find_elements(self.PAY_METHOD_LIST)
method_number = 0
if pay == '余额支付':
method_number = 1
elif pay == '货到付款':
method_number = 3
elif pay == '随机' or pay == None:
method_number = 0
else:
print("请输入正确配送方式：余额支付、货到付款")
# 选择
if method_number != 0:
method_list[method_number].find_element(*self.PAY_METHOD).click()
else:
a = [1, 3]
n = random.sample(a, 1)
n = n[0]
method_list[n].find_element(*self.PAY_METHOD).click()
class Backstage():
st = Settings()
# 后台界面切换
FRAME_MAIN = "main-frame"
FRAME_ABOVE = "header-frame"
FRAME_MENU = "menu-frame"
BACKSTAGE_ADMIN_NAME = [By.NAME, "username"]
BACKSTAGE_ADMIN_PASSWORD = [By.NAME, "password"]
BACKSTAGE_ADMIN_BUTTON = [By.CLASS_NAME, "button"]
PENDING_ORDER = [By.LINK_TEXT, "待发货订单:"]
BACKSTAGE_VIEW_ORDER = [By.LINK_TEXT, "查看"]
GENERATE_A_SHIPPING_ORDER = [By.NAME, "ship"]
CONFIRM_GENERATE_INVOICE = [By.NAME, "delivery_confirmed"]
ORDER_SEARCH = [By.NAME, "order_sn"]
SELECT_ORDER_STATUS = [By.NAME, 'status']
BACKSTAGE_SEARCH = [By.XPATH, "//input[@value=' 搜索 ']"]
BACKSTAGE_GO_SHIP = [By.NAME, "to_delivery"]
BACKSTAGE_SHIP = [By.NAME, "delivery_confirmed"]
SUCCESSFUL_OPERATION = [
By.XPATH, "/html/body/div[1]/div/table/tbody/tr[1]/td[2]"
]
SHIPPED = [By.XPATH, "//div[@id='listDiv']/table[1]/tbody/tr[3]/td[7]"]
UNREVIEWED_COMMENT = [By.LINK_TEXT, "未审核评论:"]
COMMENT_SEARCH = [By.NAME, "keyword"]
SEE_DETAILS = [By.LINK_TEXT, "查看详情"]
BY_COMMENT_BUTTON = [By.CSS_SELECTOR, "input.button"]
ENTER_A_COMMENT = [By.NAME, "content"]
REPLY_TO_COMMENT_CONFIRMATION = [By.NAME, "submit"]
def log_in_backstage(self, driver):
try:
driver.open(self.st.admin_url)
# 输入用户名 name="username"
driver.find_element(self.BACKSTAGE_ADMIN_NAME).send_keys(
self.st.Admin['name'])
# 输入密码 name="password"
driver.find_element(self.BACKSTAGE_ADMIN_PASSWORD).send_keys(
self.st.Admin['password'])
# 点击进入管理中心 class="button"
driver.find_element(self.BACKSTAGE_ADMIN_BUTTON).click()
except:
print("|---------------------------------------|")
print("| 这是一个登录安全漏洞！大BUG！！！！！ |")
print("|---------------------------------------|")
def generate_a_shipping_order(self, driver, order_number):
'''
后台 生成发货订单
'''
self.frame_main(driver)
# 点击 a标签 待发货订单:
driver.find_element(self.PENDING_ORDER).click()
# 搜索 name="order_sn" 输入 order_number
self.order_search(driver, order_number)
# 点击查看 a 查看
driver.find_element(self.BACKSTAGE_VIEW_ORDER).click()
try:
# 点击 生成发货订单 name="ship"
driver.find_element(self.GENERATE_A_SHIPPING_ORDER).click()
# 点击 确认生成发货单 name="delivery_confirmed"
driver.find_element(self.CONFIRM_GENERATE_INVOICE).click()
sleep(2)
# 断言 操作成功
try:
text = driver.find_element(self.SUCCESSFUL_OPERATION).text
TestCase.assertEqual(TestCase(), "操作成功", text, "确认生成发货单 断言失败！")
except:
print("确认生成发货单 未找到成功信息~~~~~")
except:
print("已完成 确认生成发货单 跳过确认生成发货单")
def order_search(self, driver, order_number):
# 搜索 name="order_sn" 输入 order_number
driver.find_element(self.ORDER_SEARCH).send_keys(order_number)
# 搜索 订单状态 select name="status"
select_order_status = driver.find_element(self.SELECT_ORDER_STATUS)
order_status = Select(select_order_status)
order_status.select_by_visible_text("请选择...")
# 点击 搜索 input value=" 搜索 "
driver.find_element(self.BACKSTAGE_SEARCH).click()
sleep(1)
def ship(self, driver, order_number):
'''
后台 发货
'''
# 尝试搜索
try:
# 点击 去发货 name="to_delivery"
driver.find_element(self.BACKSTAGE_GO_SHIP).click()
# 点击 查看
driver.find_element(self.BACKSTAGE_VIEW_ORDER).click()
# 点击 发货 name="delivery_confirmed"
driver.find_element(self.BACKSTAGE_SHIP).click()
except:
self.frame_main(driver)
# 点击 a标签 待发货订单:
driver.find_element(self.PENDING_ORDER).click()
self.order_search(driver, order_number)
# 断言 操作成功
try:
text = driver.find_element(self.SUCCESSFUL_OPERATION).text
TestCase.assertEqual(TestCase(), "操作成功", text, "发货操作 断言失败！")
except:
print("发货操作 未找到成功信息~~~~~")
# 再断言 name="order_sn"
self.order_search(driver, order_number)
try:
# //div[@id="listDiv"]/table[1]/tbody/tr[3]/td[7]
text = driver.find_element(self.SHIPPED)
TestCase.assertEqual(TestCase(), "已发货", text, "发货单列表 断言失败！")
except:
print("发货单列表 未找到成功信息~~~~~")
def review_comments(self, driver, comment_user, comment_admin=None):
'''
:说明:
: 审核评论，如果没有通过，则评论+通过；
: 如果通过了，则禁止显示
:return: 管理员评论 or 订单状态
: comment_admin_str
: comment_status
'''
# 切换子界面
self.frame_main(driver)
# 点击 未评审
driver.find_element(self.UNREVIEWED_COMMENT).click()
# 按评论搜索
driver.find_element(self.COMMENT_SEARCH).send_keys(comment_user)
# 点击确认
driver.find_element(self.BACKSTAGE_SEARCH).click()
sleep(1)
# 点击 查看详情
driver.find_element(self.SEE_DETAILS).click()
# 点击 允许显示
comment_status = driver.find_element(
self.BY_COMMENT_BUTTON).get_attribute("value")
user_name = driver.find_element_by_xpath(
"/html/body/div[1]/table/tbody/tr[1]/td/a/b").text
product_name = driver.find_element_by_xpath(
"/html/body/div[1]/table/tbody/tr[1]/td/b").text
driver.find_element(self.BY_COMMENT_BUTTON).click()
# 切回界面
self.quit_frame(driver)
# 切换子界面
self.frame_main(driver)
# 输入评论
if comment_admin:
comment_admin_str = comment_admin
else:
comment_admin_str = str(time())
driver.find_element(self.ENTER_A_COMMENT).send_keys(comment_admin_str)
# 点击 确认
driver.find_element(self.REPLY_TO_COMMENT_CONFIRMATION).click()
if comment_status == "禁止显示":
print("已禁止显示 {}的评论：{}".format(user_name, comment_user))
return product_name, user_name, comment_status, comment_admin_str
def frame_main(self, driver):
driver.switch_to_frame(self.FRAME_MAIN)
def frame_above(self, driver):
driver.switch_to_frame(self.FRAME_ABOVE)
def frame_menu(self, driver):
driver.switch_to_frame(self.FRAME_MENU)
def quit_frame(self, driver):
driver.switch_to_default_content()
def return_purchase(self, driver, order_number, comment=None):
self.find_order(driver, order_number)
# 点击退货 name = order_number
return_purchase = driver.find_element_by_name("return")
text = return_purchase.get_attribute("value")
if text == "退货":
return_purchase.click()
else:
print("订单{}：目前状态为：订单未完成，不能退货".format(order_number))
self.quit_frame(driver)
self.frame_main(driver)
if comment:
comment_str = str(comment)
else:
comment_str = str(time())
# name="action_note"
driver.find_element_by_name("action_note").send_keys(comment_str)
driver.find_element_by_name("submit").click()
# /html/body/div[1]/div/table/tbody/tr[1]/td[2]
prompt = driver.find_element(self.SUCCESSFUL_OPERATION).text
TestCase.assertEqual(TestCase(), "操作成功", prompt, "退货操作断言失败！")
def find_order(self, driver, order_number):
self.frame_main(driver)
# 点击 a标签 待发货订单:
driver.find_element(self.PENDING_ORDER).click()
# 搜索 name="order_sn" 输入 order_number
self.order_search(driver, order_number)
# 点击查看 a 查看
driver.find_element(self.BACKSTAGE_VIEW_ORDER).click()
class SeleniumDriver(object):
log_path = Settings().log
def __init__(self, type=None):
'''
初始化指定的浏览器驱动
'''
# 得到webdriver
self.driver = Chrome_flash()
# self.driver = WebDriver(command_executor='http://172.31.23.143:4444/wd/hub',
# desired_capabilities=DesiredCapabilities.CHROME)
# 实例化基本配置
st = Settings()
# 获取放慢速度
if type is None:
self.speed = st.speed_default
else:
self.speed = st.speed_down
log(self.log_path, "G\t初始化指定的浏览器驱动~~~")
# 初始化等待
def Wait(self):
driver = self.driver
# 设置元素识别超时时间
driver.implicitly_wait(15)
# 设置页面加载超时时间
driver.set_page_load_timeout(15)
# 设置异步脚本加载超时时间
driver.set_script_timeout(15)
log(self.log_path, "G\t加载初始化等等~~~")
def open(self, base_url):
# 调用webdriver真正相应的方法
self.driver.get(base_url)
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t打开网页：{}~~~".format(base_url))
def quit(self):
# 调用webdriver真正相应的方法
self.driver.quit()
log(self.log_path, "G\t退出当前网页网页~~~")
def find_element_by_id(self, ID):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 ID = {}".format(ID))
# 返回找到的元素对象
return self.driver.find_element_by_id(ID)
def find_element_by_name(self, name):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 NAME = {}".format(name))
# 返回找到的元素对象
return self.driver.find_element_by_name(name)
def find_element_by_class_name(self, class_name):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 CLASS_NAME = {}".format(class_name))
# 返回找到的元素对象
return self.driver.find_element_by_class_name(class_name)
def find_element_by_tag_name(self, tag_name):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 TAG_NAME = {}".format(tag_name))
# 返回找到的元素对象
return self.driver.find_element_by_tag_name(tag_name)
def find_element_by_link_text(self, link_text):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 LINK_NAME = {}".format(link_text))
# 返回找到的元素对象
return self.driver.find_element_by_link_text(link_text)
def find_element_by_partial_link_text(self, partial_link_text):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 PARTIAL_LINK_NAME = {}".format(partial_link_text))
# 返回找到的元素对象
return self.driver.find_element_by_partial_link_text(partial_link_text)
def find_element_by_xpath(self, xpath):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 XPATH = {}".format(xpath))
# 返回找到的元素对象
return self.driver.find_element_by_xpath(xpath)
def find_element_by_css_selector(self, css_selector):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 CSS_SELECTOR = {}".format(css_selector))
# 返回找到的元素对象
return self.driver.find_element_by_css_selector(css_selector)
def find_element(self, By):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在定位 {} = {}".format(*By))
# 返回找到的元素对象
return self.driver.find_element(*By)
'''
列表
'''
def find_elements_by_id(self, ID):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 ID = {}".format(ID))
# 返回找到的元素对象
return self.driver.find_elements_by_id(ID)
def find_elements_by_name(self, name):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 NAME = {}".format(name))
# 返回找到的元素对象
return self.driver.find_elements_by_name(name)
def find_elements_by_class_name(self, class_name):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 CLASS_NAME = {}".format(class_name))
# 返回找到的元素对象
return self.driver.find_elements_by_class_name(class_name)
def find_elements_by_tag_name(self, tag_name):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 TAG_NAME = {}".format(tag_name))
# 返回找到的元素对象
return self.driver.find_elements_by_tag_name(tag_name)
def find_elements_by_link_text(self, link_text):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 LINK_NAME = {}".format(link_text))
# 返回找到的元素对象
return self.driver.find_elements_by_link_text(link_text)
def find_elements_by_partial_link_text(self, partial_link_text):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 PARTIAL_LINK_NAME = {}".format(partial_link_text))
# 返回找到的元素对象
return self.driver.find_elements_by_partial_link_text(partial_link_text)
def find_elements_by_xpath(self, xpath):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 XPATH = {}".format(xpath))
# 返回找到的元素对象
return self.driver.find_elements_by_xpath(xpath)
def find_elements_by_css_selector(self, css_selector):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 CSS_SELECTOR = {}".format(css_selector))
# 返回找到的元素对象
return self.driver.find_elements_by_css_selector(css_selector)
def find_elements(self, By):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t正在列表定位 {} = {}".format(*By))
# 返回找到的元素对象
return self.driver.find_elements(*By)
def switch_to_frame(self, frame):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t切换内置窗口至 {}".format(frame))
# 返回找到的元素对象
return self.driver.switch_to.frame(frame)
def switch_to_default_content(self):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t切会主窗口")
# 返回找到的元素对象
return self.driver.switch_to.default_content()
def switch_to_alert(self):
# 调用webdriver真正相应的方法
# 加个等待时间
sleep(self.speed)
log(self.log_path, "G\t弹出窗口点击 确认")
# 返回找到的元素对象
return self.driver.switch_to_alert()