class ServerChan(object):
def __init__(self):
self.log = Log().get_logger()
self.host = 'https://sc.ftqq.com/'
self.sckey = 'SCU36505Te655df39dfe25061e9d9cbfa1a4faf925bfce30131860.send'
def send(self):
url = ''.join([self.host, self.sckey])
# text：消息标题，最长为256，必填。
# desp：消息内容，最长64Kb，可空，支持MarkDown。
text = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
params = {'text': text, 'desp': 'good'}
r = requests.request('post', url=url, params=params) # get或post皆可
if r.json()['errno'] == 0:
self.log.info('发送成功')
else:
self.log.info('发送失败：%s' % r.json()['errmsg'])
def timeing(self):
scheduler = BlockingScheduler()
scheduler.add_job(func=self.send,
trigger='cron',
day_of_week='0-6',
second='*/5')
scheduler.start()
def __init__(self, excel_path, sheet_name="Sheet1"):
self.data = xlrd.open_workbook(excel_path) # 根据路径打开一个文件
self.table = self.data.sheet_by_name(sheet_name) # 根据表名打开表
self.keys = self.table.row_values(0) # 获取第一行作为字典的key值
self.rowNum = self.table.nrows # 获取总行数
self.colNum = self.table.ncols # 获取总列数
self.log = Log("读取excel").get_logger()
def setUp(self):
self.logger = Log()
self.logger.info(
'############################### START ###############################'
)
self.dr = basepage(global_parameter.browser)
self.dr.max_window()
class ReadExcel(object):
# 参数excel_path是文件的绝对路径，sheet_name是表名
def __init__(self, excel_path, sheet_name="Sheet1"):
self.data = xlrd.open_workbook(excel_path) # 根据路径打开一个文件
self.table = self.data.sheet_by_name(sheet_name) # 根据表名打开表
self.keys = self.table.row_values(0) # 获取第一行作为字典的key值
self.rowNum = self.table.nrows # 获取总行数
self.colNum = self.table.ncols # 获取总列数
self.log = Log("读取excel").get_logger()
# 获取整张表的数据（数据装在列表中,列表的每个子元素是字典类型数据）
def get_dict_data(self):
if self.rowNum <= 1:
self.log.error('xlsx表的总行数小于1')
else:
r = [] # 定义列表变量，把读取的每行数据拼接到此列表中
for row in range(1, self.rowNum): # 对行进行循环读取数据，从第二行开始
s = {} # 定义字典变量
s['rowNum'] = row + 1 # 存储行数，从第二行开始读，行数等于下标加1
values = self.table.row_values(row) # 获取行的数据
for col in range(0, self.colNum): # 对列进行循环读取数据
cell_value = values[col]
if isinstance(cell_value, (int, float)): # 判断读取数据是否是整型或浮点型
cell_value = int(cell_value) # 是，数据转换为整数
s[self.keys[col]] = str(
cell_value).strip() # 获取到单元格数据(去掉头尾空格)和key组成键对值
r.append(s) # 把获取到行的数据装入r列表中
return r # 返回整个表的数据
def test_frame():
log = Log("UI测试").get_logger()
driver = webdriver.Ie()
# driver = webdriver.Edge()
# driver = webdriver.Firefox()
# driver = webdriver.Chrome()
driver.set_window_size(1100, 600) # 设置窗口大小
# driver.maximize_window()
"""
163邮箱登录的例子来用新的switch_to方法写一下，并通过观察，
我们发现进入这个页面后焦点直接就定位到输入框里了，所以我们可以通过active_element()来定位。
"""
# 进入163邮箱首页
driver.get("http://mail.163.com/")
time.sleep(2)
# 切换到包含登录框的frame下
driver.switch_to.frame("x-URS-iframe") # 根据frame的id切换到frame
# driver.switch_to.parent_frame() # 可以切换到上一层的frame，对于层层嵌套的frame很有用
time.sleep(2)
# 通过定位输当前焦点元素，并再次输入数据
driver.switch_to.active_element.send_keys("123")
# driver.find_element_by_css_selector('form>div>div>div>input').send_keys("123")
log.info(driver.title) # 打印原页面title
time.sleep(2)
driver.quit()
def setUpClass(self):
self.logger = Log()
self.logger.info(
'############################### START ###############################'
)
self.driver = browser.select_browser(globalparam.browser)
# self.driver.implicitly_wait(10)
Page(self.driver).max_window()
class ThreadingStudy(object):
def __init__(self):
self.log = Log().get_logger()
def test(self, t=0):
print('thread %s is running...' % threading.current_thread().name)
for i in range(5):
time.sleep(2)
self.log.info(t)
print('thread %s is ended...' % threading.current_thread().name)
def __init__(self, url):
self.log = Log().get_logger()
self.url = url
# 启动浏览器
self.driver = webdriver.Ie()
# self.driver = webdriver.Edge()
# self.driver = webdriver.Firefox()
# self.driver = webdriver.Chrome()
self.driver.get(self.url)
self.driver.maximize_window()
def test_api(self, data_test):
api = TestApi(url=data_test['url'],
key=data_test['key'],
connent=data_test['coneent'],
fangshi=data_test['fangshi'])
Log(r'输入参数：url:%s,key:%s,参数:%s,请求方式：%s' %
(data_test['url'], data_test['key'], data_test['coneent'],
data_test['fangshi']))
apijson = api.getJson()
Log(r"结果返回码%s" % apijson)
qingwang = (data_test['assert'])
self.assertEqual(apijson, qingwang, msg="预期和实际的不一致")
def __init__(self, url):
self.log = Log().get_logger()
self.url = url
# 启动浏览器
# self.driver = webdriver.Ie()
# self.driver = webdriver.Edge()
# self.driver = webdriver.Firefox()
self.driver = webdriver.Chrome(
'C:/Program Files (x86)/Google/Chrome/Application/chromedriver.exe'
)
self.driver.get(self.url)
self.driver.maximize_window()
class Pdf(object):
def __init__(self):
self.log = Log().get_logger()
self.path = r'C:\AProjectCode\Python\python3_interface\study_case\data\开发指南.pdf'
# self.path = r'C:\AProjectCode\Python\python3_interface\study_case\data\a.pdf'
self.out_path = r'C:\AProjectCode\Python\python3_interface\study_case\data\aa.txt'
def read(self):
with open(self.path, 'rb') as fp: # 以二进制读模式打开
praser = PDFParser(fp) # 用文件对象来创建一个pdf文档分析器
retstr = StringIO()
doc = PDFDocument() # 创建一个PDF文档
praser.set_document(doc) # 连接分析器 与文档对象
doc.set_parser(praser) # 获取解析内容
doc.initialize() # 提供初始化密码，如果没有密码就创建一个空的字符串
if not doc.is_extractable: # 检测文档是否提供txt转换
self.log.info("文档不可以进行txt转换")
else:
rsrcmgr = PDFResourceManager() # 创建PDf 资源管理器 来管理共享资源
laparams = LAParams() # 创建一个PDF设备对象
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr,
device) # 创建一个PDF解释器对象
with open(self.out_path, 'w', encoding='utf-8') as f:
# 循环遍历列表，每次处理一个page的内容
for page in doc.get_pages(): # doc.get_pages() 获取page列表
interpreter.process_page(page)
layout = device.get_result() # 接受该页面的LTPage对象
# 这里layout是一个LTPage对象 里面存放着 这个page解析出的各种对象 一般包括LTTextBox, LTFigure, LTImage, LTTextBoxHorizontal 等等 想要获取文本就获得对象的text属性，
for x in layout:
if hasattr(x, 'get_text'):
results = x.get_text()
self.log.info(results)
f.write(results)
def read2(self):
pdfFile = open(
r'C:\AProjectCode\Python\python3_interface\study_case\data\开发指南.pdf',
'rb')
retstr = io.StringIO()
laparams = LAParams()
rsrcmgr = PDFResourceManager()
device = TextConverter(rsrcmgr, retstr, laparams=laparams)
process_pdf(rsrcmgr,
device,
pdfFile,
pagenos=set(),
maxpages=0,
password='',
check_extractable=True)
device.close()
print(retstr.getvalue())
pdfFile.close()
def __init__(self):
self.log = Log().get_logger()
# 打开数据库连接
self.conn = pymysql.connect(
host='192.168.1.9',
port=3307,
user='******',
password='******',
database='artest', # 数据库不存在话会抛异常
charset='utf8')
# self.cursor = self.conn.cursor() # 游标默认获取的数据是元祖类型
self.cursor = self.conn.cursor(
cursor=pymysql.cursors.DictCursor) # 游标设置为字典类型
class JVMStart(object):
def __init__(self):
self.log = Log("jvm初始化").get_logger()
"""
启动Java虚拟机
"""
def start_jvm(self, jar_list):
# 获得默认jvm路径
jvm_path = jpype.getDefaultJVMPath()
# self.log.info(jvm_path)
# 你的java扩展包的路径
ext_classpath = ''
# 判断系统类型,Linux系统使用“ ：”分隔
sysstr = platform.system()
if sysstr == "Windows":
# java扩展包的路径或class文件所在文件夹路径，注意：class文件路径是它所在的上级文件夹
ext_classpath = config.sdk_path
for name in jar_list:
ext_classpath += ';' + config.sdk_path + '%s' % name
elif sysstr == "Linux":
ext_classpath = config.sdk_path + 'sdk'
for name in jar_list:
ext_classpath = ':' + config.sdk_path + '%s' % name
# self.log.info("系统类型：" + sysstr)
# 判断 JVM 是否已启动
if not jpype.isJVMStarted():
# 启动Java虚拟机，并加载jar包
jpype.startJVM(jvm_path, '-ea', '-Djava.class.path=%s' % ext_classpath)
jpype.java.lang.System.out.println("startJVM success!")
if jpype.isJVMStarted():
return True
else:
return False
else:
return True
"""
关闭Java虚拟机
"""
def shutdown_jvm(self):
if jpype.isJVMStarted():
self.log.info("关闭jvm")
jpype.shutdownJVM()
class MyTest(unittest.TestCase,Page):
@classmethod
def setUpClass(self):
self.logger = Log()
self.logger.info('############################### START ###############################')
self.driver = browser.select_browser(globalparam.browser)
# self.driver.implicitly_wait(10)
Page(self.driver).max_window()
@classmethod
def tearDownClass(self):
self.driver.quit()
self.logger.info('############################### End ###############################')
class RedisStudy(object):
def __init__(self):
self.log = Log().get_logger()
def study(self):
# 1、一般连接方式
r = redis.Redis(host='127.0.0.1', port=6379, db=0)
r.set('name', 'zhangsan0') # 添加
self.log.info(r.get('name')) # 获取
# 2、连接池
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
r.set('name', 'zhangsan2') # 添加
self.log.info(r.get('name')) # 获取
class MyTest(unittest.TestCase):
"""
The base class is for all testcases.
"""
def setUp(self):
self.logger = Log()
self.logger.info(
'############################### START ###############################'
)
self.dr = basepage(global_parameter.browser)
self.dr.max_window()
def tearDown(self):
# self.dr.quit()
self.logger.info(
'############################### End ###############################'
)
class airTicketClass(unittest.TestCase):
log =Log()
def setUp(self):
self.log.info("开始测试")
self.driver = webdriver.Chrome()
self.driver.maximize_window()
def tearDown(self):
self.log.info("测试完成")
def __init__(self):
self.log = Log().get_logger()
"""
1、连接MongoDB
连接MongoDB我们需要使用PyMongo库里面的MongoClient，一般来说传入MongoDB的IP及端口即可，第一个参数为地址host，
第二个参数为端口port，端口如果不传默认是27017。
"""
# self.client = pymongo.MongoClient(host='localhost', port=27017,username='******',password='******')
self.client = pymongo.MongoClient('mongodb://*****:*****@localhost:27017/') # 可以达到同样的连接效果。
"""
2、指定数据库
MongoDB分为一个个数据库，需要指定要操作哪个数据库，在这里我以test数据库为例进行说明
注意: 在 MongoDB 中，如果数据库不存在，数据库只有在内容插入后才会创建! 就是说，数据库创建后要创建集合(数据表)
并插入一个文档(记录)，数据库才会真正创建。集合创建同理。
"""
self.db = self.client.testdb
# self.db = self.client['testdb'] # 两种方式是等价的。
"""
2.2、读取 MongoDB 中的所有数据库，并判断指定的数据库是否存在
"""
dblist = self.client.list_database_names()
if "testdb" in dblist:
self.log.info("数据库已存在！")
else:
self.log.info("数据库不存在！")
"""
3、指定集合
每个数据库又包含了许多集合Collection，也就类似与关系型数据库中的表，下一步需要指定要操作的集合，
在这里我们指定一个集合名称为students，学生集合。还是和指定数据库类似，指定集合也有两种方式。
"""
self.collection = self.db.students
# self.collection = self.db['students']
collist = self.db.list_collection_names()
if "students" in collist: # 判断 sites 集合是否存在
self.log.info("集合已存在！")
else:
self.log.info("集合不存在！")
class PdfJar(object):
def __init__(self):
self.log = Log().get_logger()
self.path = r'C:\AProjectCode\Python\python3_interface\study_case\data\开发指南.pdf'
self.out_path = r'C:\AProjectCode\Python\python3_interface\study_case\data\开发指南.txt'
def startJvm(self):
return JVMStart().start_jvm(['pdfbox-app-2.0.12.jar'])
def get_java_objecj(self):
self.file = JClass("java.io.File")
self.FileOutputStream = JClass("java.io.FileOutputStream")
self.OutputStreamWriter = JClass("java.io.OutputStreamWriter")
self.Writer = JClass("java.io.Writer")
self.PDDocument = JClass("org.apache.pdfbox.pdmodel.PDDocument")
self.PDFTextStripper = JClass("org.apache.pdfbox.text.PDFTextStripper")
def get_txt(self):
try:
self.get_java_objecj()
input = self.file(self.path) # 转换文件为File类型
document = self.PDDocument.load(input) # 加载pdf文件
outputStream = self.FileOutputStream(self.out_path)
output = self.OutputStreamWriter(outputStream, 'UTF-8') # 文件输出流
stripper = self.PDFTextStripper() # PDFTextStripper来提取文本
stripper.setSortByPosition(False) # 设置是否排序
stripper.setStartPage(1) # 设置起始页
stripper.setEndPage(100000) # 设置结束页
stripper.writeText(document,
output) # 调用PDFTextStripper的writeText提取并输出文本
self.log.info(stripper.getText(document)) # 直接获取text
output.close() # 关闭输出流
document.close()
except Exception as e:
self.log.error('出现异常：%s' % e)
def shutdownJVM(self):
JVMStart().shutdown_jvm()
class airTicketClassRemote(unittest.TestCase):
log =Log()
def setUp(self):
self.log.info("开始测试")
self.driver = webdriver.Remote(command_executor=HOST,
desired_capabilities={'platform': 'ANY',
'browserName': 'chrome',
'version': '',
'javascriptEnabled': True
}
)
self.driver.maximize_window()
def tearDown(self):
self.log.info("测试完成")
def get_case(path1):
all_case = []
open = xlrd.open_workbook(path1) #打开xlsx
me = open.sheets()[0] #打开xlsx的第一个table
nrows = me.nrows
Log("打开测试用例!")
# for循环遍历case
for i in range(1, nrows):
all_case.append({
"id": me.cell(i, 0).value,
'key': me.cell(i, 2).value,
'coneent': me.cell(i, 3).value,
'url': me.cell(i, 4).value,
'name': me.cell(i, 1).value,
'fangshi': me.cell(i, 5).value,
'assert': me.cell(i, 6).value
})
return all_case
def test_alert():
log = Log("UI测试").get_logger()
driver = webdriver.Firefox()
driver.set_window_size(960, 540) # 设置窗口大小
driver.get('http://sahitest.com/demo/promptTest.htm')
time.sleep(2)
driver.find_element_by_name('b1').click()
# a1 = driver.switch_to.alert # 通过switch_to.alert切换到alert
a1 = Alert(driver) # 直接实例化Alert对象
time.sleep(2)
log.info(a1.text) # 获取alert文本内容，对有信息显示的alert框
a1.send_keys('send some words to alert!') # 往prompt型alert中传入字符串
time.sleep(2)
a1.accept() # 等同于点击“确认”或“OK”
# a1.dismiss() # 等同于点击“取消”或“Cancel”
log.info(driver.find_element_by_name('t1').get_attribute('value'))
driver.quit()
def test_window():
log = Log("UI测试").get_logger()
driver = webdriver.Firefox()
driver.set_window_size(960, 540) # 设置窗口大小
driver.get('http://sahitest.com/demo/index.htm')
time.sleep(2)
current_window = driver.current_window_handle # 获取当前窗口的handle name
time.sleep(5)
driver.find_element_by_link_text(
'Window Open Test With Title').click() # 新窗口打开另一个网页
# driver.find_element_by_link_text('Window Open Test').click() # 新窗口打开另一个网页
time.sleep(2)
all_windows = driver.window_handles # 获取所有窗口handle name
# 切换window，如果window不是当前window，则切换到该window
for window in all_windows:
if window != current_window:
driver.switch_to.window(window) # 只能通过window的handle name来切换窗口
"""
如果打开多个浏览器句柄和标签页的对应关系：
标签页顺序（按照打开顺序）：1,2,3,4,5
对应的句柄 ：0,4,3,2,1
"""
# driver.switch_to.window(driver.window_handles[2])
log.info(driver.title) # 打印当前页面title
driver.close()
time.sleep(5)
driver.switch_to.window(
current_window) # 关闭新窗口之后，driver并不会自动跳转回原窗口，而是需要你switch回来
log.info(driver.title) # 打印原页面title
driver.quit()
def __init__(self):
self.log = Log("jvm初始化").get_logger()
def __init__(self):
self.log = Log().get_logger()
def setUpClass(cls):
cls.log = Log('测试').get_logger()
def setUpClass(cls):
cls.log = Log("cookie测试").get_logger()
cls.url = base.get_url("cookies/set")
pass
def test_webdriver():
log = Log("UI测试").get_logger()
driver = webdriver.Ie()
# driver = webdriver.Firefox() # 获取浏览器驱动对象
driver.set_window_size(960, 540) # 设置窗口大小
driver.get('https://www.baidu.com/') # 打开一个网页
# driver.find_element_by_id('kw').clear() # 清除文本
"""HTMl的属性定位,属性要唯一才能定位到"""
# driver.find_element_by_id('kw').send_keys('王春玲') # 根据html属性id定位元素，模拟按键输入
# driver.find_element_by_name('wd').send_keys('王春玲') # 根据html属性name定位元素，模拟按键输入
# driver.find_element_by_class_name('s_ipt').send_keys('王春玲') # 根据html属性id定位元素，模拟按键输入
# driver.find_element_by_tag_name('input').send_keys('王春玲') # 根据标签input定位，这里定位不到，因为页面有多个input
# driver.find_element_by_link_text('贴吧').click() # 根据标签对之间的文本信息定位，如：<a>贴吧</a>
# driver.find_element_by_partial_link_text('一个很长').click() # 根据标签对之间的部分文本信息定位，如：<a>一个很长很长的文本</a>
"""XPath定位"""
# driver.find_element_by_xpath('/html/body/div/div/div[4]/div/div/from/span/input').send_keys('王春玲') # ，绝对路径定位
# driver.find_element_by_xpath('//input[@id="kw"]').send_keys('王春玲') # XPath定位，根据元素属性id,还可以其他属性，//表示当前页面某目录
# driver.find_element_by_xpath('//*[@id="kw"]').send_keys('王春玲') # XPath定位，根据元素属性，不指定标签名，用*替代
# driver.find_element_by_xpath("//form[@id='form']/span/input").send_keys('王春玲') # XPath定位，上级和属性组合，
# driver.find_element_by_xpath('//input[@id="kw" and @class="s_ipt"]').send_keys('王春玲') # 多个属性组合
"""CSS定位,属性要唯一才能定位到"""
# driver.find_element_by_css_selector(".s_ipt").send_keys('王春玲') # css的class属性，注意：.代表class类型的
# driver.find_element_by_css_selector("#kw").send_keys('王春玲') # css的id属性，注意：#代表id类型的
# driver.find_element_by_css_selector("input").send_keys('王春玲') # 标签名定位，这里定位不到，不唯一
driver.find_element_by_css_selector("span>input").send_keys('王春玲') # 父子关系
"""
显式等待和隐式等待:
显式等待的等待时间是固定的，固定了10s就必须等待10s,隐式等待的等待时间是个范围，例如最大10s,那么如果在3s的
时候程序达到预期的结果，那么就不在继续后面的7秒，直接进入下一步操作，而如果超出10s还没有相应，
程序就会报出相应的错误。
"""
"""
implicitly_wait()隐式等待，用来设置超时，一般把implicitly_wait()方法调用在加载测试地址后，等待所测试的应用程序加载。
如果 WebDriver没有在 DOM中找到元素，将继续等待，超出设定时间后则抛出找不到元素的异常。
即当查找元素或元素并没有立即出现的时候，隐式等待将等待一段时间再查找 DOM，默认的时间是0
一旦设置了隐式等待，则它存在整个 WebDriver 对象实例的声明周期中，隐式的等到会让一个正常响应的应用的测试变慢，
它将会在寻找每个元素的时候都进行等待，这样会增加整个测试执行的时间。
"""
# driver.implicitly_wait(30)
# driver.find_element_by_id('kw').submit() # 提交输入框的内容,功能与click类似
# driver.find_element_by_id('su').click() # 点击元素
driver.find_element_by_xpath('//*[@id="su"]').click() # 点击元素
# size = driver.find_element_by_id('kw').size # 获取元素的大小
# text = driver.find_element_by_id('cp').text # 获取元素的文本
# attribute = driver.find_element_by_id('kw').get_attribute() # 获取元素的属性值
# print(size)
# driver.get_screenshot_as_file(Config.project_path + r'\test_data\a.png') # 截屏
# time.sleep(3) #睡眠3秒
# driver.back() # 返回上一个网页
# time.sleep(3)
# driver.refresh() # 刷新当前页面
# driver.forward() # 前进
# driver.maximize_window() # 设置窗口最大化
# driver.minimize_window() # 设置窗口最小化
time.sleep(1)
log.info(driver.title) # 获取标题
driver.quit() # 退出浏览器
import time
import os.path
import sys
sys.path.append('/home/selenium_python')
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import TimeoutException
from public.log import Log
from config import globalparam
success = "SUCCESS "
fail = "FAIL "
logger = Log()
class Page():
"""
页面基础类，用于所有页面的继承
"""
ai_url = "http://www.cmread.com"
def __init__(self, selenium_driver, base_url=ai_url, parent=None):
self.base_url = base_url
self.driver = selenium_driver
# self.timeout = 30
self.parent = parent
from public.log import Log
from selenium import webdriver
from chromeoptions.ChromeOptions import Options
log = Log()
def open_browser(browser_type):
# 添加异常处理机制 增加代码的健壮性
try:
if browser_type == "Chrome":
log.info("chrome浏览器启动中")
driver = webdriver.Chrome(options=Options().conf_option())
else:
log.info("非chrome浏览器启动中")
driver = getattr(webdriver, browser_type)()
except:
log.info("未识别到浏览器对象，默认调用Chrome浏览器")
driver = webdriver.Chrome(options=Options().conf_option())
return driver
class Browser():
def __init__(self, broweser_type):
'''初始化浏览器，推荐使用Chrome浏览器'''
self.driver = open_browser(broweser_type)
self.driver.implicitly_wait(10)
