class MemberManagerTest(unittest.TestCase):
# 3.调用之前写好的read()方法，获取配置中的数据
member_info = read("member_info.csv")
# print(member_info)#可以读取csv文件的数据
@classmethod
# 定义一个方法
def setUpClass(cls):
print("在执行所有方法前先执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def test_a_log_in(self):
print("登录测试")
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(Keys.TAB).send_keys("password").send_keys(Keys.TAB). \
send_keys("1234").send_keys(Keys.ENTER).perform()
@ddt.data(*member_info)
def test_b_add_member(self, row):
#data_table = read("member_info.csv")
#for row in read("member_info.csv"):
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
driver.switch_to.frame("mainFrame")
# iframe_css = "#mainFrame"
# iframe_html = driver.find_element_by_css_selector(iframe_css)
# driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.find_element_by_css_selector('[value="{0}"]'.format(
row[2])).click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
actual = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
excepted = row[0]
# if (actual == excepted):
# print("测试通过")
# else:
# print("测试失败")
self.assertEqual(actual, excepted)
# driver.switch_to.parent_frame()
driver.switch_to.default_content()
# 当程序不稳定的时候加入时间等待即可解决
time.sleep(3)
class MemberManageTest(unittest.TestCase):
#调用之前写好的read()方法，获取配置文件中的数据
member_info = read("member_info.csv")
# global driver
@classmethod
def setUpClass(cls):
print("所有方法之前执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def testa_log_in(self):
print("登录测试")
driver = self.driver
driver.get("http://localhost/index.php?m=admin&c=public&a=login")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(Keys.TAB).send_keys("password").send_keys(Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
#python中的集合前面的星号表示，表示把集合中的所有元素拆开，一个一个写
# list=["小红","小明"]
# *list="小红","小明"
#@ddt.data()测试数据来源于read()方法
#把数据表中的每一行传入方法，在方法中增加一个参数row
@ddt.data(*member_info)
def testb_add_member(self,row):
driver = self.driver
#for循环不太好，推荐使用ddt装饰器，去修饰这个方法，达到每条测试用例独立执行的目的
#ddt是数据驱动测试 data driver test
#注释掉for循环，改变代码的缩进 shift+tab 使方法中的代码比方法声明缩进4个空格
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.find_element_by_css_selector("[value='" + row[2] + "']").click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
actual = driver.find_element_by_css_selector("#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
expected = row[0]
# if actual == expected:
# print("测试通过")
# else:
# print("测试失败")
# driver.find_element_by_class_name("button_search").click()
# 切换到父框架
driver.switch_to.parent_frame()
self.assertEqual(actual, expected)
class MemberManageTest(unittest.TestCase):
#调用之前的read方法,获取配置文件中数据,memberinfo
member = read("member.csv")
# 在当前类只执行一次
@classmethod
def setUpClass(cls):
print("所有方法之前,执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
# cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def testa_log_in(self):
print("登录测试 ")
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(
Keys.TAB).send_keys("password").send_keys(
Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
@ddt.data(*member)
def testb_add_member(self, row):
#每组测试用例都是独立,不应该用for循环,上个执行失败,导致下一个不能执行,用DDT装饰器,修饰这个方法.
#for row in read("member.csv"): 4.注释FOR循环
print("添加会员")
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
# driver.switch_to.frame("mainFrame")
# 如果frame没有name属性时, 我们可以通过其他方式定位iframe标签, 把定位好的页面元素传给driver.switch_to.frame(iframe_html)方法也可以实现frame切换
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.find_element_by_css_selector('[value="{0}"]'.format(
row[2])).click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").submit()
sj = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
ex = row[0]
driver.switch_to.default_content()
time.sleep(10)
self.assertEquals(sj, ex)
class MemberManageTest(unittest.TestCase):
member_info = read("member_info.csv")
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(10)
cls.driver.quit()
def test_a_log_in(self):
print("登陆测试")
driver=self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(Keys.TAB).send_keys("password").send_keys(Keys.TAB).send_keys("1111").send_keys(Keys.ENTER).perform()
@ddt.data(*member_info)
def testb_add_member(self, row):
driver = self.driver
# for循环不太好，推荐使用ddt装饰器，去修饰这个方法，达到每条测试用例独立执行的目的
# ddt是数据驱动测试 data driver test
# 注释掉for循环，改变代码的缩进 shift+tab 使方法中的代码比方法声明缩进4个空格
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.find_element_by_css_selector("[value='" + row[2] + "']").click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
actual = driver.find_element_by_css_selector("#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
expected = row[0]
# if actual == expected:
# print("测试通过")
# else:
# print("测试失败")
# driver.find_element_by_class_name("button_search").click()
# 切换到父框架
#driver.switch_to.parent_frame()
self.assertEqual(actual, expected)
# 切换到网页的根节点
driver.switch_to.default_content()
class UnittestDemo(unittest.TestCase):
member_info = read("member_info.csv")
@classmethod
def setUpClass(cls):
print("set up class")
@classmethod
def tearDownClass(cls):
print("tear Down")
def test_log_in(self):
print("log in")
@ddt.data(*member_info)
def test_add_member(self, data):
print("add member")
print(data[0])
def test_b_add_member(self):
for row in read("member_info.csv"):
print("添加会员")
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
# 如果frame没有name属性时，我们可以通过其他方式定位iframe标签，把定位好的页面元素传给driver.switch_to.frame(iframe_html )方法也可以
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
# 切换到父框架
# driver.switch_to.parent_frame()
# 切换到网页的根节点
driver.switch_to.default_content()
driver.switch_to_frame("mainFrame")
driver.find_element_by_name("mobile_phone").send_keys("13716178592")
def test_b_add_member(self):
for row in read("member_info.csv"):
print("添加会员")
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
#如果frame没有name属性时，可以通过其他方式定位iframe标签，把定位好的页面传给driver.switch_to.frame(iframe_html)方法也可以实现frame切换
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
time.sleep(1)
driver.find_element_by_name("mobile_phone").send_keys(row[1])
time.sleep(1)
driver.find_element_by_css_selector('[value=[]]').click()
#切换到父框架
# driver.switch_to.parent_frame()
#切换到网页的根节点，（用一个就行）
driver.switch_to.default_content()
class MemberManageTest(unittest.TestCase):
#3.调用之前写好的read（）方法，获取配置文件中的数据
member_info = read("member_info.csv")
#在当前类只执行一次
@classmethod
def setUpClass(cls):
print("所有方法之前，执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
#cls.driver.maximize_window
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def test_a_log_in(self):
print("登陆测试")
driver = self.driver
self.driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(Keys.TAB).send_keys("password")\
.send_keys(Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
#python中集合前面的星号表示，表示把集合中的所有元素拆开，一个一个写
#list =[”小红“，”小明“]
#*list = ”小红“，”小明“
#星号的作用就是把一个列表拆成2个str
#加入一个方法需要接受2个参数，那么肯定不能传一个list进去
#如果list中正好也有22个元素，这时在列表前面加一个星号
#这时就不认为这时一个列表，而是2个参数了
@ddt.data(*member_info)
def testb_add_member(self, row):
#每组测试数据就是一组测试用例，每条测试用例是独立的，所以这里不推荐用for循环
#应该用ddt装饰器，去修饰方法，然后达到每条测试用例独立执行的目的
#ddt 是数据驱动测试 data driver test
#for row in read("member_info.csv"):
#print("添加会员")
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
iframe_html = driver.find_element_by_css_selector("#mainFrame")
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.find_element_by_css_selector("[value='" + row[2] + "']").click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
#切换到父框架
#driver.switch_to.parent_frame()
#切换到网页的根节点
actual = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").test
#expected 期望结果，来自于手动测试用例，需求文档
expected = row[0]
#断言类似于if else语句
#if actual == expected:
# print("测试通过")
#else:
# print("测试失败")
#断言是框架提供的，要想调用断言，那么必须加上self
driver.switch_to.default_content()
self.assertEqual(actual, expected)
class MemberManageTest(unittest.TestCase):
# 2.调用之前写好的read方法,获取配置文件中的数据
member_info = read("member_info.csv")
# 在当前类只执行一次
@classmethod
def setUpClass(cls):
print("所有方法之前,只执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def test_a_log_in(self):
print("登录测试")
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(
Keys.TAB).send_keys("password").send_keys(
Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
# *表示把集合中的所有元素拆开一个一个写
@ddt.data(*member_info
) # 4.ddt.data 测试数据来源于read方法,再把数据表中的每一行传入方法,在方法中增加一个参数row
def test_b_add_member(self, row):
print("添加会员")
driver = self.driver
# 每组测试数据就是一条测试用例,每条测试用例都应该是独立的,不能因为上一条测试用例失败导致下一组数据不能被正常执行,所以不推荐for循环
# 应该用ddt装饰器,去修饰这个方法,达到每条测试数据独立执行的目的
# data driver test 数据驱动测试,将ddt解压到selenium解压的路径下
# 3.注释掉for循环,改变代码的缩进,用快捷键shift+tab
# for row in read("member_info.csv"):
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
# driver.find_element_by_css_selector("[value='"+row[2]+"']").click()
driver.find_element_by_css_selector("[value='{0}']".format(
row[2])).click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
# 断言:assert,断言是框架提供的,要想调用断言,需要加上self. 因为测试用例类继承了框架中的TestCase类,也继承了这个类中的断言,执行测试用例之后页面上实际显示的结果与期望结果是否一致,类似于if... else... 语句,是用来做判断的
actual = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
expected = row[0]
# if actual == expected:
# print("测试通过")
# else:
# print("测试失败")
# 断言有几个特点:简短,只关注于错误的测试用例,只有断言出错的时候才会打印信息,断言报错时后面的代码将不会继续执行
# driver.switch_to.parent_frame() # 切换到父框架
driver.switch_to.default_content() #切换到根节点
self.assertEqual(actual, expected)
class MemberManageTest(unittest.TestCase):
#调用之前写好的read方法,获取配置文件中的数据。
member_info = read("member_info.csv")
driver = webdriver.Chrome()
#在当前类只执行一次
@classmethod
def setUpClass(cls):#在所有方法之前都要执行一次，setUp只是执行第一次。
print("所有方法之前，执行一次。")
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):#在所有方法执行之后都要执行一次。
time.sleep(2)
print("这是teardown")
#cls.driver.quit()
def test_alogin(self):
print("这是登录测试用例")
driver = self.driver
driver.get("http://localhost/index.php?m=admin&c=public&a=login")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(Keys.TAB).send_keys("password").send_keys(Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
#python中集合前面的星号表示，把集合中的所有元素拆开，一个一个写。
#list=["abc","bcd"]
#*list="abc","bcd"
#假如一个方法需要接收两个参数，那么肯定不能传一个list进去。
#但是如果list中正好也是两个元素，这时在列表前面加一个参数，
#这时就不认为这是一个列表，而是两个参数。
#@ddt.data()测试数据来源于read()方法
@ddt.data(*member_info)
def test_b_addmember(self,row):
#每组测试数据就是一组测试用例，每条测试用例都是独立的。不能因为上一条测试数据失败，导致下一组数据不能被正常执行。所以这里不推荐用for循环。
#应该用ddt装饰器 去修饰这个方法 达到测试用例每条独立执行的目的。ddt是数据驱动测试。data driver test
#注释掉for循环，改变代码的缩进。
#for row in read("member_info.csv"):
print("这是添加会员方法")
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
iframe_css = "#mainFrame"
#如果frame没有name属性时，我们可以通过其他定位iframe标签，把定位好的页面元素传给switch to
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.find_element_by_css_selector('[value='+'"'+ row[2]+'"' +']').click() #'[value="0"]''"[value="+row[2]+"]"'
driver.find_element_by_name("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
#此处需要加断言，只能自动运行，但是不能自动判断是否对。
actual = driver.find_element_by_css_selector("#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
expected = row[0]
#断言类似于 if 。。。else。。。。是用来做判断的。
if (actual==expected):
print ("测试通过")
else:
print("测试失败")
# 断言和if优缺点比较,断言是框架提供的，要想调用断言，那么必须加self.,因为测试用例类继承了框架中的testcase类，也继承了这个类中的断言。所以我们可以直接用断言的方法。
#断言比较简短，断言只关注错误的测试用例，只有判断为假的时候才会打印信息，正确无信息输出。断言失败，下面的代码将不再执行。
self.assertEqual(actual,expected)
#切换到父框架
driver.switch_to.parent_frame()
class MemberManagerTest(unittest.TestCase):
# 3.调用之前写好的read()方法，获取配置文件的数据
member_info = read("member_info.csv")
# global driver
# 在当前类只执行一次
@classmethod
def setUpClass(cls):
print("所有方法之前，执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
# cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
print("所有方法执行之后，执行一次")
time.sleep(20)
cls.driver.close()
# unittest中测试方法按照字母顺序执行
def test_a_log_in(self):
print("登录测试")
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(
Keys.TAB).send_keys("password").send_keys(
Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
# driver.find_element_by_name("userpass").send_keys("password")
# python中集合或列表前面的星号，表示把集合中的所有元素拆开，一个一个写
# 如，list = ["小红"，"小黑"]
# *list = "小红"，"小黑"
# 星号的作用是把一个列表拆成多个String
# 假如，一个方法需要接收两个参数，肯定不能传一个list进去
# 但是如果list中正好也是两个元素，这时在列表前面加一个星号，
# 这时就不再认为是一个列表了，可以视为两个参数
# [email protected]() 测试数据来源于read()方法
# 5.把数据表中的每一行传入方法，在方法中增加一个参数row
@ddt.data(*member_info)
def test_b_add_member(self, row):
# print("添加会员")
driver = self.driver
# 每组测试数据就是一条测试用例，每条测试用例是独立的，不能因为上一条测试用例执行失败（断言失败），导致下一组数据不能被正常执行，所以这里不推荐用for循环，
# 应该用ddt装饰器，去修饰这个方法，达到测试用例每条独立执行的目的
# ddt 数据驱动测试 data driver test
# 4.注释掉for循环，改变代码的缩进(shift+tab快捷键)，使方法中的代码比方法声明缩进4个空格
# for row in read("member_info.csv"):
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
# driver.switch_to.frame("mainframe")
# 如果frame没有name属性时，我们可通过其他方式定位iframe标签，把定位好的页面元素传给driver.switch_to.frame()方法也可以实现frame切换
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
time.sleep(2)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
# '[value='"+row[2]+"'] '== '[value="1"]'
# "[value='{0}']".format(row[2])
# driver.find_element_by_css_selector("[name='sex'][value='"+row[2]+"']").click()
driver.find_element_by_css_selector("[value='{0}']".format(
row[2])).click()
driver.find_element_by_name("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
# print("value="+row[2]+"1")
# print('[value='"+row[2]+"']')
# 之前的代码是能够自动运行，但是还不能自动判断程序运行的是否正确
# 我们自动化代码不能找人一直盯着运行，检查是否执行正确
# actual 实际结果，执行测试用例之后，页面上实际显示的结果
# 获取元素的文本
time.sleep(2)
actual = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
# datagrid-row-r1-2-0 > td:nth-child(1) > div
# expected 期望结果，来自于手动测试用例或者需求文档，配置文件
expected = row[0]
# 断言类似与if...else...语句，是用来做判断的
# if actual == expected:
# print("测试通过")
# else:
# print("测试失败")
# 切换到父框架
# driver.switch_to.parent_frame()
# 切换到网页的根节点
driver.switch_to.default_content()
# 断言叫assert，断言是框架提供的，要想调用断言，必须要加上self.，因为测试用例类继承了框架中的TestCase类，也继承了这个类中的断言，所以我们可以直接用断言方法
# 断言有几个特点：
# 1.断言更简洁
# 2.断言关注于错误的测试用例，只有断言结果出错时，才会打印信息，正确时没有任何信息提示
# 3.断言报错时，后面的代码将不会继续执行，前面的步骤失败了，后面的步骤就不需要继续尝试了，提高性能
self.assertEqual(actual, expected)
class MemberManageTest(unittest.TestCase):
#3调用之前写好的read（）方法，获取配置文件中的数据
member_info=read("member_info.csv")
global driver
@classmethod
def setUpClass(cls):
print("所有方法之前执行一次")
cls.driver=webdriver.Chrome()
cls.driver.implicitly_wait(30)
#cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
#cls.driver.quit()
def test_a_log_in(self):
print("登陆测试")
drver=self.driver
self.driver.get("http://localhost/admin.php")
self.driver.find_element_by_name("username").send_keys("admin")
self.driver.find_element_by_name("userpass").send_keys("password")
self.driver.find_element_by_name("userverify").send_keys("1234")
self.driver.find_element_by_name("userverify").submit()
#python中集合前边的星号的表示，表示把集合中的所有的元素拆开，一个一个的写
#list=["小红","小明"]
#星号的作用就是把一个列表拆成两个string
#加入一个方法接受两个参数，那么肯定不能传一个list进去
#但是如果list中正好两个元素，这时的列表的前边加一个星号
#这时就不认为这是一个list而是两个参数了
#$ddt.data,测试数据来源于read（）方法中了
#把数据的每一行传入方法，在方法里边增加一个参数row
@ddt.data(*member_info)
def test_b_add_menber(self,row):
#每组测试数据就是一条测试用例，每条测试用例都是独立的，不能因为上一条的失败导致下一条不能用
#不推荐for循环
#应该用ddt装饰器，去修饰这个方法，达到每条测试用例独立执行的目的
#ddr数据驱动测试
#注释掉所有的for循环
#for row in read("member_info.csv"):
#print("添加会员")
driver = self.driver
self.driver.find_element_by_link_text("会员管理").click()
self.driver.find_element_by_link_text("添加会员").click()
#如果frame没有name属性，我们可以通过其他方式定位iframe标签，把定位好的元素传过去
iframe_css="#mainFrame"
iframe_html=driver.find_element_by_css_selector(iframe_css)
self.driver.switch_to.frame(iframe_html)
self.driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.find_element_by_css_selector('[value="{0}"]'.format(row[2])).click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
#之前代码能够运行，但是还不能自动判断程序是否正确
#actual实际结果，执行测试用例之后页面上实际显示的结果
actual=driver.find_element_by_css_selector("##datagrid-row-r1-2-0 > td:nth-child(1) > div")
#expected期望结果，手动测试用例，需求文档，配置文件
excepted=row[0]
#断言类似于if。。else语句是用来做判断的
if actual==excepted:
print("测试通过")
else:
print("测试失败")
#断言叫做assert，断言是框架提供的，要想调用断言加上self.因为测试用例的类继承了框架中的TestCase类
#也继承了这个类中的断言
#断言有几个特点：
#1断言比较简洁
#2断言只关注于错误的测试用例，
#3只有断言出错的时候才会打印信息，正确没有任何信息
#4断言报错的时候后边的代码将不会继续执行
#
#切换到父框架
#driver.switch_to.parent_frame()
#切换到网页的根节点
driver.switch_to.default_content()
self.assertEqual(actual, excepted)
class MemberManageTest(unittest.TestCase):
#3.调用之前写好的read()方法,获取配置文件中的数据
member_info = read("member_info.csv")
# 在当前类只执行一次
@classmethod
def setUpClass(cls):
print("所有方法之前,执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def testa_log_in(self):
print("登录测试 ")
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(
Keys.TAB).send_keys("password").send_keys(
Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
# python中集合前面的星号表示, 表示把集合中的所有元素拆开,一个一个写
# list=["小红","小明"]
# *list= "小红","小明"
# 星号的作用就是把一个列表,拆成两个string
# 假如一个方法需要接收两个参数, 那么肯定不能传一个list进去
# 但是如果list中正好也是两个元素, 这时在列表前面加一个星号,
# 这时就不认为这时一个列表,而是两个参数了
# @ddt.data() 测试数据来源于read()方法
# 把数据表中的每一行传入方法
@ddt.data(*member_info)
def testb_add_member(self, row):
# 每组测试数据就是一条 测试用例, 每条测试用例应该是独立的, 不能因为上一条测试用例执行失败,导致下一组数据不能被正常执行,所以这里不推荐用for循环
# 应该用ddt装饰器, 去修饰这个方法,达到每条测试用例独立执行的目的
# ddt 是 数据驱动测试 data driver test
#4.注释掉for循环,改变代码的缩进,使方法中的代码比方法声明缩进4个空格,快捷键是shift+tab
# for row in read("member_info.csv"):
# print("添加会员")
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
# driver.switch_to.frame("mainFrame")
# 如果frame没有name属性时, 我们可以通过其他方式定位iframe标签, 把定位好的页面元素传给driver.switch_to.frame(iframe_html)方法也可以实现frame切换
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
# '[value="'+row[2]+'"]' == '[value="1"]'
# '[value="{0}"]'.format(row[2])
driver.find_element_by_css_selector('[value="{0}"]'.format(
row[2])).click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
# 之前的代码是能够自动运行, 但是还不能自动判断程序运行的是否正确
# 我们自动化代码,不能找人总是看着运行, 检查是否执行正确
# actual实际结果, 执行测试用例后, 页面上实际显示的结果
actual = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
# expected 期望结果, 来自于手动测试用例,需求文档,配置文件
expected = row[0]
# 断言类似于if...else..., 是用来做判断的
# if actual == expected:
# print("测试通过")
# else:
# print("测试失败 ")
# 断言叫assert, 断言是框架提供的, 要想调用断言, 那么必须加上self. 因为测试用例类继承了框架中的TestCase类,也继承了这个类中的断言,所以我们可以直接用断言方法
# 断言有几个特点:
# 1.断言比较简洁
# 2.断言关注于错误的测试用例, 只有断言出错的时候,才会打印信息, 正确时没有任何信息提示
# 3,断言报错时,后面的代码讲不会继续执行, 前面的步骤失败, 后面的步骤就不需继续尝试,浪费性能
# 切换到父框架
# driver.switch_to.parent_frame()
# 切换到网页的根节点
driver.switch_to.default_content()
self.assertEqual(actual, expected)
class MemberManageTest(unittest.TestCase):
#3.调用之前写好的read()方法,获取配置文件中的数据
member_info = read('member_info.csv')
#在当前类只执行一次
@classmethod
def setUpClass(cls):
print('所有方法之前,只执行一次')
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.close()
def test_a_log_in(self):
print('登陆测试用例')
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name('username').send_keys('admin')
ActionChains(driver).send_keys(
Keys.TAB).send_keys('password').send_keys(
Keys.TAB).send_keys('1234').send_keys(Keys.ENTER).perform()
#[email protected]()测试数据来源于read()方法
@ddt.data(*member_info)
def test_b_add_member(self, row):
#每组测试数据就是一个测试用例,每条测试用例都应该是独立的,所以此处不推荐用for循环
#4.注释掉for循环,改变代码的缩进,
# for row in read('member_info.csv'):
# print('添加会员')
driver = self.driver
driver.find_element_by_link_text('会员管理').click()
driver.find_element_by_link_text('添加会员').click()
iframe_css = '#mainFrame'
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name('username').send_keys('z' + row[0])
driver.find_element_by_name('mobile_phone').send_keys(row[1])
driver.find_element_by_css_selector('[value="' + row[2] + '"]').click()
driver.find_element_by_id('birthday').send_keys(row[3])
driver.find_element_by_name('email').send_keys(row[4])
driver.find_element_by_name('qq').send_keys(row[5])
driver.find_element_by_class_name('button_search').click()
#之前的代码能够自动运行但是不能自动判断程序运行是否正确,actual实际结果,expected期望结果
actual = driver.find_element_by_css_selector(
'#datagrid-row-r1-2-0 > td:nth-child(1) > div').text
expected = 'z' + row[0]
# if actual==expected:
# print("测试通过")
# else:
# print("测试失败")
#断言叫assert,断言是框架提供的,要想调用断言,必须加上self.因为测试用例继承了框架中的TestCase类,也继承了这个类中的断言,所以我们可以直接用断言方法
#断言比较简洁,只有错误时才会有提示信息,正确无任何信息,断言报错时,后面的代码将不会继续执行
self.assertEqual(actual, expected)
#由于是循环的,输入会员名后再次切换回去上个镶嵌页才能点击会员管理
#切换到父框架
driver.switch_to.parent_frame()
class MemberMangerTest(unittest.TestCase):
#3.调用之前写好的read（)方法，获取配置文件中的数据
member_info = read("member_info.csv")
# 在当前类只执行一次
@classmethod
def setUpClass(cls):
print("所有方法之前，只执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def test_a_log_in(self):
print("登录测试")
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
# ActionChains(driver).send_keys(Keys.TAB).send_keys("password") .send_keys(Keys.TAB ).send_keys("1234").send_keys(Keys.ENTER ).perform()
driver.find_element_by_name("userpass").send_keys("password")
driver.find_element_by_name("userverify").send_keys("1234")
driver.find_element_by_name("userverify").submit()
#python中集合前面的星号表示，表示把集合中的所有元素拆开一个一个写
#list=["小红"，“小明”]
#*list="小红"，“小明”
#星号的作用就是把一个列表拆成两个string
#假如一个方法需要接收两个参数，那么肯定不能传一个list进去
#但是如果list中正好也是两个元素，这时在列表前面加一个星号，这时就不认为这时一个列表而是两个参数
#[email protected]()测试数据来源于read（）方法
#把数据表中的每一行传入方法，在方法中增加一个参数row
@ddt.data(*member_info)
def test_b_add_member(self, row):
#每组测试数据就是一条测试用例，每条测试用例是独立的
# 不能因为上一条测试用例执行失败导致下一组数据不能被正常执行，所以这里不推荐用for循环
#应该用ddt装饰器去修饰这个方法，达到每条测试用例独立执行的目的
#ddt是数据驱动测试 data driver test 将ddt解压到：C:\Users\51Testing\AppData\Local\Programs\Python\Python35\Lib\site-packages
#4.注释掉for循环，改变代码的缩进，使方法中的代码比方法声明缩进四个空格，快捷键shift+tab
# for row in read("member_info.csv"):
# print("添加会员")
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
# 如果frame没有name属性时，我们可以通过其他方式定位iframe标签，把定位好的页面元素传给driver.switch_to.frame(iframe_html )方法也可以
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
#
#
#driver.find_element_by_css_selector('value="'+row[2]+'"').click()
driver.find_element_by_css_selector('[value="{0}"]'.format(
row[2])).click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
#z之前的代码是能够自动运行，但是还不能自动判断程序运行的是否正确
#自动化代码不能找人一直总是盯着运行，检查是否执行正确
#actual s实际结果，执行测试用例后，页面是实际显示的结果
actual = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
#expected 期望结果，来自手动测试用例或者需求文档，配置文件
expected = row[0]
#断言类似于if else语句，是用来做判断的
# if actual == expected :
# print("测试通过")
#else:
# print("测试失败")
#断言叫assert,断言是框架提供的，要想调用断言，那么必须加self. 因为我们的测试用例类继承了框架中的TestCase类，也继承了这个类中的断言
#所以我们可以直接用断言方法
#断言有几个特点
#1.断言比较简洁
#2.断言关注于错误的测试用例，只有断言出错的时候才会打印信息，正确没有任何信息提示
#3.断言报错时，后面的代码将不会继续执行，前面的步骤失败，后面的步骤就不需要继续尝试，浪费性能
# 切换到父框架
# driver.switch_to.parent_frame()
# 切换到网页的根节点
driver.switch_to.default_content()
self.assertEqual(actual, expected)
class MemberManagerTest2(unittest.TestCase):
#3.调用之前写好的read()方法，获取配置文件中的数据
member_info = read("member_info.csv")
#数据读出来，附上一个变量
# 在当前类只执行一次
#装饰class方法
@classmethod
# def 定义一个方法
def setUpClass(cls):
print("在所有方法之前,只执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def test_a_log_in(self):
print("登录测试")
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(
Keys.TAB).send_keys("password").send_keys(
Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
#python中集合前的星号，表示把集合中的所有元素拆开，一个一个写
#list=["小红","小马"];
#*list="小红","小马"
#星号的作用就是把一个列表，拆成连个string
#假如一个方法需要接收两个参数，那么肯定不能传一个list进去
#但是如果list中正好也是两个元素，这时在列表前面加一个*
#这时就不认为这是一个列表，而是两个参数
#5.ddt.data()测试数据来源于read()方法，然后把数据表中的每一行传入方法
# 在方法中增加一个参数row
@ddt.data(*member_info)
def test_b_add_member(self, row):
# 每组测试数据就是一条测试用例，每条测试用例应该是独立的，不能因为上一条测试用例执行失败
# 导致下一组数据不能被正常执行，所以这里不推荐用for循环
#应该用ddt装饰器，去修饰这个方法，达到每条测试用例独立执行的目的
#ddt是数据驱动测试，data driver test
#4.注释掉for循环，改变代码的缩进，使方法中的代码比方法声明缩进4个空格，快捷键是shift+TAP
#for row in read("member_info.csv"):
#print("添加会员")
driver = self.driver
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
# driver.switch_to_frame("mainFrame")
iframe_css = "#mainFrame"
# 如果frame没有name属性时，我们可以通过其他方式定位ifame标签，把定位好的页面元素传给driver.switch_to_frame(iframe_html)方法也可以实现frame切换
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
# '[value="' + row[2] + '"]'='[value="1"]'
# format是初始化
driver.find_element_by_css_selector('[value="{0}"]'.format(
row[2])).click()
# driver.find_element_by_css_selector('[value="'+row[2]+'"]').click()
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
# 之前的代码是能够自动运行，但是还不能自动判断程序运行是否正确
# 我们自动化代码，不能找人一直盯着运行，检查是否执行正确
# actual实际结果，执行测试用例后，页面上实际显示的结果
actual = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
# 获取元素的文本
# #expected期望结果，来自于手动测试用例，或者是需求文档，配置文件
expected = row[0]
# 断言类似于if...else...，用来做判断的
# if(actual == expected):#()可以不写
# print("测试通过")
# else:
# print("测试失败")
# 断言叫assert，断言是框架提供的，要想用断言，那么必须加上self
# 因为测试用例类继承了框架中的TestCase类，也继承了这个类中的断言，所以我们直接用断言
# 断言有几个特点：
# 1.断言比较简洁
# 2.断言关注于错误的测试用例，只有断言出错的时候，才会打印信息，正确时没有打印信息
# 3.断言报错时，后面的代码将不会继续执行，前面的步骤失败，后面的步骤就不需要尝试执行了，浪费性能
# for循环输入完用户名后就跳回去会员管理，所以需要切换到原来的输入用户名界面
# 切换到父框架
# driver.switch_to.parent_frame()
# 切换到网页的根节点
driver.switch_to.default_content()
# driver.switch_to.active_element#切换到鼠标所在的元素
self.assertEqual(actual, expected) # 写在切换窗口后面
time.sleep(3)
class MemberManageTest(unittest.TestCase):
#3.调用之前写好的read()方法,获取配置文件中的数据
member_info = read("member_info.csv")
#在当前类只执行一次
@classmethod
def setUpClass(cls):
print("所有方法之前,只执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
print("测试结束")
time.sleep(20)
cls.driver.quit()
def test_a_log_in(self):
print("登录测试")
driver = self.driver
driver.get("http://localhost/admin.php")
driver.find_element_by_name("username").send_keys("admin")
driver.find_element_by_name("userpass").send_keys("password")
ActionChains(driver).send_keys(Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
#python中集合前面的 星号表示把集合中的元素拆开,一个一个写
#list=["a","b"]
#*list= "a","b",一个列表,变成两个字符串
#假如一个方法需要接收两个元素,那么肯定不能传一个list进去
#但是如果list中正好也是两个元素,这时在列表前面加一个星号,这时就不是一个列表,是两个参数了
#@ddt.data()测试数据来源于read()方法
#5.把数据表中的每一行传入方法,在方法中增加一个参数row
@ddt.data(*member_info)
def test_b_add_member(self,row):
#print("添加会员")
driver = self.driver
#每组测试数据就是一条测试用例,每条测试用例应该是独立的,不能因为一条测试用例执行失败,导致下一条用例不能正常执行,所以不推荐用for循环
#应该用ddt装饰器,去修饰这个方法,达到每条测试用例独立执行的目的
#ddt是数据驱动测试,data driver test
#4.注释掉for循环
#for row in read("member_info.csv"):
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
#driver.switch_to.frame("mainFrame")
#当iframe没有name属性时,可以通过其他方式定位元素
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.find_element_by_css_selector('[value="'+row[2]+'"]').click()
#driver.find_element_by_css_selector('[value="{0}"].format(row[2])').click()
#format()格式化输出
driver.find_element_by_id("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_class_name("button_search").click()
#actual:实际结果,执行测试用例后页面上实际显示的结果
#expected:期望结果,来自于手动测试用或者需求文档或配置文件
time.sleep(3)
actual = driver.find_element_by_css_selector("#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
expected = row[0]
#断言类似于if...else...,是用来做判断的
# if expected == actual:
# print("pass")
# else:
# print("fail")
#断言是assert,断言是框架提供的,要想调用断言,必须加self.因为测试用例类继承了框架中的TestCase类,也继承了这个类的断言,所以可以直接用断言的方法
#断言有几个特点:
#1.断言比较简洁
#2.断言只关注错误的测试用例,只有断言出错的时候才会打印信息
#3.断言报错时,后面的代码不会继续执行,前面的步骤失败,后面的步骤就不需要继续尝试了
#切换到父框架
driver.switch_to.parent_frame()
self.assertEqual(expected, actual)
class MemberManageTest(unittest.TestCase):
# 3.调用之前写好的rea()方法，获取配置文件中的数据
member_info = read("goods_info.csv")
global driver
# 当前类只执行一次
@classmethod
def setUpClass(cls):
print("所有方法之前，只执行一次")
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(30)
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
def test_a_log_in(self):
print("登陆测试")
driver = self.driver
driver.get("http://localhost/admin.php")
time.sleep(3)
driver.find_element_by_name("username").send_keys("admin")
ActionChains(driver).send_keys(
Keys.TAB).send_keys("password").send_keys(
Keys.TAB).send_keys("1234").send_keys(Keys.ENTER).perform()
# python中集合前面的星号表示把集合中的所有元素拆开一个一个写
# list = ["karry","wang"]
# *list = "karry","wang"
# *的作用把列表拆成两个string
# 假如一个方法接收两个参数，不能传一个list进去
# 但是如果list中正好两个元素，这时在列表前面加*就可以传进去，这时就不认为这是一个列表，而是两个参数
# [email protected]()测试数据来源于read()方法
# 把数据表中的每一行传入方法，在方法里面增加一个参数row
@ddt.data(*member_info)
def test_b_add_member(self, row):
# print("添加会员")
driver = self.driver
# 每组测试数据就算一条测试用例，每条测试用例是独立的，不能因为上一组数据执行失败，导致下一组数据不能被正常执行，所以不推荐for循环
# 应该用ddt装饰器，取修饰方法达到用例独立执行的目的
# ddt 数据驱动测试
# for row in read("goods_info.csv"):
driver.find_element_by_link_text("会员管理").click()
driver.find_element_by_link_text("添加会员").click()
# 如果frame没有name属性时，我们可以通过其他方式定位iframe，把定位好的页面元素传给方法也可以实现切换
iframe_css = "#mainFrame"
iframe_html = driver.find_element_by_css_selector(iframe_css)
driver.switch_to.frame(iframe_html)
driver.find_element_by_name("username").send_keys(row[0])
driver.find_element_by_name("mobile_phone").send_keys(row[1])
driver.execute_script('document.getElementsByName("sex")', row[2])
# driver.find_element_by_css_selector('[value="0"]')
driver.find_element_by_name("birthday").send_keys(row[3])
driver.find_element_by_name("email").send_keys(row[4])
driver.find_element_by_name("qq").send_keys(row[5])
driver.find_element_by_css_selector('[value="提交"]').click()
# 之前代码是能够自动运行，但是还不能自动判断程序运行的是否正确，我们自动化代码不能找人一直盯着运行，检查是否执行报错
# actualz实际结果,执行测试用例之后，页面上实际显示的结果
actual = driver.find_element_by_css_selector(
"#datagrid-row-r1-2-0 > td:nth-child(1) > div").text
# expected 期望结果，来自于手动测试用例，需求文档
expected = row[0]
# 断言类似于if。。。else语句，用来做判断
# if actual == expected:
# print("测试通过")
# else:
# print("测试失败")
# 断言assert,断言是框架提供的，要想调用断言，必须加上self，因为测试用例类继承了框架中的TestCase类，也继承了这个类中的断言，所以我们可以直接使用
# 切换到父框架
driver.switch_to.parent_frame()
# 切换到网页的根节点
# driver.switch_to.default_content()
# 断言有几个特点：
# 1.断言简短
# 2.断言只关注错误的测试用例，只有判断为假才有报错信息
# 3.断言报错时，后面代码将不会继续执行，前面步骤失败，后面步骤就不需要尝试了
self.assertEqual(actual, expected)