def test_register(self):
for row in CsvFileManager4().read('testdata.csv'):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
#这两种方法没有任何区别，但是后面这中方法扩展性更高，便于框架封装
#driver.find_element_by_name("username")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
# driver.find_element(By.CLASS_NAME,"reg_btn").click()
#在for循环中执行测试用例，虽然解决批量执行问题，但是如果第一行测试用例执行失败，后续的用例不会继续执行
#异常情况，输入完邮箱后，按tab键，检查提示信息是否都是“信息通过验证！”
#如果页面上提示的信息是“通过信息验证！”，那么测试通过，否则失败
check_tip = driver.find_element(
By.CSS_SELECTOR,
"form > ul > li:nth-child(1) > div > span").text
print(check_tip)
#其中check_tip是执行用例时，从网页抓取的信息
#“通过信息验证！”是来自于手工测试用例，是测试用例执行前的期望结果
# if check_tip =="通过信息验证！":
# print("测试通过")
# else:
# print("测试失败")
#这样通过if...else语句就可以自动判断测试用例的执行通过情况了
#断言的写法
self.assertEqual("通过信息验证！", check_tip)
class RegisterTest2(unittest.TestCase):
#3.声明一个变量，读取CSV文件的测试数据
data_table = CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit()
#4.为test_register方法添加装饰器@ddt.data(),data_table是一个list类型，包含很多元素，在data_table前面增加*号，表示调用 @ddt.data()方法时，我们传入的不是列表，而是单独传的列表中的每个元素，所以*表示把列表中的每个元素都单独看成一个参数
#假如一个方法需要的参数数量不固定时，可以使用这种方法
@ddt.data(*data_table)
#5.给方法添加一个参数row,取第一列数据，那么应该是row[1]
#使用ddt方法，相当于把循环写在了方法的外面，好处是，每次循环都相当于重新执行了这个方法，这样断言就不会阻塞后面的测试用例了
def test_register(self, row):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
check_tip = driver.find_element(
By.CSS_SELECTOR, " form> ul > li:nth-child(1) > div > span").text
self.assertEqual("用户名不低于三位，使用中文、数字、字母皆可！", check_tip)
class RegisterTest2(MyTestCase):
#3，声明一个变量
data_table = CsvFileManager4().read("test_data.csv")
# @classmethod
# def setUpClass(cls):
# cls.driver=webdriver.Chrome()
# cls.driver.implicitly_wait(10)
# cls.driver.maximize_window()
# @classmethod
# def tearDownClass(cls):
# time.sleep(30)
# cls.driver.quit()
@ddt.data(*data_table)
def test_register(self, row):
driver = self.driver
driver.get("http://localhost:8001/index.php?m=user&c=public&a=reg")
driver.find_element_by_name('username').send_keys(row[0])
driver.find_element_by_name('password').send_keys(row[1])
driver.find_element_by_name('userpassword2').send_keys(row[2])
driver.find_element_by_name('mobile_phone').send_keys(row[3])
driver.find_element_by_name('email').send_keys(row[4])
driver.find_element_by_class_name('reg_btn').click()
dic_pit = driver.find_element_by_css_selector(
'form.registerform.sign > ul > li:nth-child(1) > div > span').text
print(dic_pit)
class RegisterTest2(unittest.TestCase):
#3.声明一个变量 读取CSV文件的测试数据
data_teble = CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit()
#4.为test_register方法添加装饰器@ddt.data
#data_teble是一个list类型，包含很多元素，在data_table前加*，表示调用ddt.data()方法时，我们传入的不是列表，而是列表中的每个元素
#所以*的作用是，把列表中的每个单独元素都单独看做成 一个参数
@ddt.data(*data_teble)
def test_register(self, row):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, 'userpassword2').send_keys(row[2])
driver.find_element(By.NAME, 'mobile_phone').send_keys(row[3])
driver.find_element(By.NAME, 'email').send_keys(row[4])
check_tip = driver.find_elements(
By.CSS_SELECTOR, " form > ul > li:nth-child(1) > div > span").text
print(check_tip)
self.assertEqual("通过信息验证！", check_tip)
class RegisterTest2(unittest.TestCase):
#3.声明一个变量，读取csv文件的测试数据
data_table = CsvFileManager4().read('testdata.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(20)
cls.driver.quit()
#4.为test_register2方法添加装饰器@ddt.dataddt.data(),指定测试数据
#data_table是一个list类型，包含很多元素，在data_table前面加一个星号，表示调用ddt.data方法时我们传入的不是列表，而是单独传的列表中的某一个元素
#所以星号的作用是把列表中的每个元素都单独看成一个参数
#假如一个方法需要的参数数量不固定，我们可以用这种方法
@ddt.data(*data_table)
#5.给方法添加一个参数row
#若想取第一列数据，那么应该是row[1]
#使用ddt的方法相当于把循环写在方法的外面，好处是每次循环都相当于重新执行这个方法，这样就不会阻塞测试用例了
def test_register(self,row):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
check_tip = driver.find_element(By.CSS_SELECTOR, "form > ul > li:nth-child(1) > div > span").text
def test_register(self):
for row in CsvFileManager4().read('test_data.csv'):
driver = self.driver
driver.get('http://localhost/index.php?m=user&c=public&a=reg')
#find_element(By.NAME,'username') == driver.find_element_by_name('username')
#这两种方法没有任何区别 但是后面的这种方法扩展性更好 便于框架封装
driver.find_element(By.NAME, 'username').send_keys(row[0])
driver.find_element(By.NAME, 'password').send_keys(row[1])
driver.find_element(By.NAME, 'userpassword2').send_keys(row[2])
driver.find_element(By.NAME, 'mobile_phone').send_keys(row[3])
driver.find_element(By.NAME, 'email').send_keys(row[4])
driver.find_element_by_name('username').submit()
#在for循环中执行测试用例 虽然解决了批量执行的问题
#但是，想想一下 如果第一行数据就报错了 那么后面还执行吗
#考虑异常情况，输入完邮箱后 按tab键 检查提示信息是否都是通过信息验证
#怎么验证 如果页面提示信息是通过信息验证 那么测试通过 否则测试失败
check_tip = driver.find_element_by_css_selector(
'form.registerform.sign > ul > li:nth-child(1) > div > span'
).text
print(check_tip)
#其中check_tip是执行用例时，从网页上抓取的信息
#通过信息验证 是来自于手工测试用例 是测试用例执行前的期望结果
#if check_tip == '通过信息验证!':
#print('测试通过')
#else:
#print('测试失败')
#这样通过if...else语句 就可以自动判断测试用例的执行情况
self.assertEqual('用户名不低于三位，使用中文、数字、字母皆可！', check_tip)
def test_register(self):
for row in CsvFileManager4().read('test_data.csv'):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
# driver.find_element_by_name("username") == driver.find_element(By.NAME, "username")
# 这两种方法，没有任何区别， 但是后面的这种方法扩展性更好，便于框架封装
# driver.find_element_by_name("username")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
# driver.find_element(By.CLASS_NAME, "reg_btn").click()
# 在for循环中执行测试用例,虽然解决批量执行的问题
# 但是,想想一下,如果第一行测试用例执行失败, 后续的测试用例还会不会执行
# 考虑异常情况, 输入完邮箱后,按tab键, 检查提示信息是否都是"通过信息验证！"
# 怎么验证? 如果页面上提示的信息是"通过信息验证！", 那么,测试通过, 否则测试失败
check_tip = driver.find_element(By.CSS_SELECTOR, "form.registerform.sign > ul > li:nth-child(1) > div > span").text
print(check_tip)
# 其中check_tip是执行用例时,从网页上抓取的实际结果
# "通过信息验证！"是来自于手工测试用例,是测试用例执行前的期望结果
# if check_tip == "通过信息验证！":
# print("测试通过")
# else:
# print("测试失败")
# 这样通过if...else语句,就可以自动判断测试用例的执行情况
# 断言的写法
self.assertEqual("用户名不低于三位，使用中文、数字、字母皆可！222", check_tip)
class RegisterTest2(unittest.TestCase):
data_table = CsvFileManager4().read("test_data.csv")
#3.声明一个变量，读取csv文件的测试数据
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit
#4.为test_register方法添加装饰器@ddt.data,指定测试数据data_table
#data_table是一个list类型，包含很多元素
#在data_table前面加一个星号，表示调用ddt.data()方法时
#我们传入的不是列表，而是单独传的列表中的每个元素
#所以星号的作用就是，把列表中每个元素，都单独看成一个参数
#假如，一个方法需要的参数数量，我们可以用这种方法
@ddt.data(*data_table)
#5.给方法添加一个参数row
#如果想取第一列数据，那么应该是row[1]
#使用ddt的方法，相当于把循环写在了方法的外面
#好处是，每次循环，都相当于重新执行了这个方法
#这样断言就不会阻塞后面的测试用例了
def test_register(self, row):
print("haha")
def test_register(self):
for row in CsvFileManager4().read('test_data.csv'):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
# 这两种方法没有任何区别，但是后面的这种方法扩展性更好，便于框架封装
# driver.find_element(By.NAME)== driver.find_element_by_name("username")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
#driver.find_element(By.CLASS_NAME,"reg_btn").click()
#在for循环中执行测试用例，虽然解决了批量执行的问题，但是如果第一行测试用例执行失败，后续的测试用例还会不会执行
#考虑异常情况，输入完邮箱后，按tab键，检查提示信息是否都是“通过信息验证”
#怎么验证？如果页面上提示的信息是“通过信息验证！”，那么测试通过，否则测试失败 body > div.w1180 > div > div.reg_main > div.reg_left.fl > form > ul > li:nth-child(1) > div > span
check_tip = driver.find_element(
By.CSS_SELECTOR,
" form.registerform sign > ul > li:nth-child(1) > div > span"
).text
print(check_tip)
#其中check_tip是执行用例时，从网页上抓取的实际结果
#“通过信息验证”是来自手工测试用例，是在测试用例执行前的期望结果
# if check_tip=="通过信息验证！":
# print("测试通过")
# else:
# print("测试失败")
#这样通过if……else语句，就可以自动判断测试用例的执行情况
self.assertEqual("通过信息验证!", check_tip)
def test_register(self):
for row in CsvFileManager4().read("test_data.csv"):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
#find_element_by_name等于find_element(By.NAME,"name")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
# 在for循环中执行测试用例,虽然解决批量执行的问题
#输入完邮箱后按tab键,检查提示信息是否都是"通过信息验证"
#如果页面上提示的信息是"通过信息验证",那么测试通过,否则测试失败
check_tip = driver.find_element(
By.CSS_SELECTOR,
"form > ul > li:nth-child(1) > div > span").text
print(check_tip)
# check_tip是执行用例时从网页上抓取的信息
#"通过信息验证"是期望结果
# if check_tip=="通过信息验证":
# print("测试通过")
# else:
# print("测试失败")
#断言的写法
self.assertEqual("通过信息验证", check_tip)
#不应该用for循环的方式执行不同的测试数据
#因为在方法中写了for循环虽然执行了多次,但是unittest仍然认为它是一条测试用例,一旦断言失败,就会终止 这条测试用例,所以应该采用ddt框架实现数据驱动
driver.find_element(By.CLASS_NAME, "reg_btn").click()
def test_regiser(self):
driver = self.driver
driver.get("http://localhost:8001/")
driver.find_element_by_link_text("注册").click()
driver.switch_to.window(driver.window_handles[-1])
for row in CsvFileManager4().read("test_data.csv"):
driver.find_element_by_name('username').send_keys(row[0])
driver.find_element_by_name('password').send_keys(row[1])
driver.find_element_by_name('userpassword2').send_keys(row[2])
driver.find_element_by_name('mobile_phone').send_keys(row[3])
driver.find_element_by_name('email').send_keys(row[4])
driver.find_element_by_class_name('reg_btn').click()
class RegisterTest(MyTestCase):
data_table = CsvFileManager4().read("test_data.csv")
@ddt.data(*data_table)
def test_register(self,row):
sql = 'select * from hd_user order by id desc;'
#数据库验证，测试的正常情况
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg") # 这两种方法，没有任何区别，但是后面的这种方法扩展性更好，便于框架封装
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
driver.find_element(By.CLASS_NAME, "reg_btn").click()
time.sleep(2)
new_record = DBConnection().execute_sql_command(sql)
self.assertEqual(row[0],new_record[1])
class LoginTest(MyTestCase):
list = CsvFileManager4().read("test_data1.csv")
#这时，这个类不需要再写setup和teardow方法了.
@ddt.data(*list)
def test_login2(self, row):
# def login_info(self,username='******',passwrod='123456'):
ff = LoginPage(self.driver)
ff.open()
ff.input_name(row[0])
ff.input_password(row[1])
ff.click_login_button()
time.sleep(3)
try:
member_conter_page = MemberCenterPage(self.driver)
welcomeTxt = member_conter_page.get_webcome_link_text()
except Exception as e:
return print(e)
self.assertEqual(welcomeTxt, "您好 %s" % row[0])
class RegisterTest2(unittest.TestCase):
# 3.声明一个变量,读取csv文件的测试数据
data_table = CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit()
# 4.为test_register方法添加装饰器@ddt.data,指定测试数据data_table
# data_table是一个list类型,包含很多元素
# 在data_table前面加一个*表示调用ddt.data方法是,我们传入的不是列表而是单独传的列表中的某一个元素
# 所以*的作用就是,把列表中每个元素,都单独看成一个参数
# 假如一个方法需要的参数数量不固定,我们可以用这种方法
@ddt.data(*data_table)
# 5.给方法添加一个参数row
# 如果想取第一列数据,那么应该是row[0]
# 使用ddt的方法,相当于把循环卸载了方法的外面,好处是,每次循环,都相当于重新执行这个方法
# 这样断言就不会阻塞后面的测试用例了
def test_register(self,row):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, 'username').send_keys(row[0])
driver.find_element(By.NAME, 'password').send_keys(row[1])
driver.find_element(By.NAME, 'userpassword2').send_keys(row[2])
driver.find_element(By.NAME, 'mobile_phone').send_keys(row[3])
driver.find_element(By.NAME, 'email').send_keys(row[4])
driver.find_element(By.CLASS_NAME, 'reg_btn').click()
time.sleep(3)
check_tip = driver.find_element(By.CSS_SELECTOR, 'body > div.w1180 > div > div.reg_main > div.reg_left.fl > form > ul > li:nth-child(6) > p > input').text
# 断言写法
self.assertEqual("请输入", check_tip)
def test_register(self):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
def test_register(self):
for row in CsvFileManager4().read('test_data.csv'):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
# driver.find_element(By.CLASS_NAME,"reg_btn").click()
check_tip = driver.find_element(
By.CSS_SELECTOR,
"form > ul > li:nth-child(1) > div > span").text
print(check_tip)
# if check_tip=="通过信息验证!":
# print("测试通过")
# else:
# print("测试失败")
self.assertEquals("通过信息验证!", check_tip)
class RegisterTest2(unittest.TestCase):
# 3.声明一个变量,读取csv文件的测试数据
data_table = CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit()
# 4. 为test_register方法添加装饰器@ddt.data, 指定测试数据data_table
# data_table是一个list类型, 包含很多元素
# 在data_table前面加一个星号,表示调用ddt.data()方法时
# 我们传入的不是列表, 而是单独传的列表中的每个元素
# 所以,星号的作用就是. 把列表中每个元素, 都单独看成一个参数
# 假如, 一个方法需要的参数数量不固定,我们可以用这种方法
@ddt.data(*data_table)
# 5.给方法添加一个参数row
# 如果想去第一列数据,那么应该是row[1]
# 使用ddt的方法,相当于把循环写在了方法的外面
# 好处是, 每次循环, 都相当于重新执行这个方法
# 这样断言就不会阻塞后面的测试用例了
def test_register(self, row):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
check_tip = driver.find_element(
By.CSS_SELECTOR,
"form.registerform.sign > ul > li:nth-child(1) > div > span").text
self.assertEqual("222用户名不低于三位，使用中文、数字、字母皆可！222", check_tip)
def test_register(self):
for row in CsvFileManager4().read('test_data.csv'):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
# driver.find_element_by_name("username")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, 'userpassword2').send_keys(row[2])
driver.find_element(By.NAME, 'mobile_phone').send_keys(row[3])
driver.find_element(By.NAME, 'email').send_keys(row[4])
# driver.find_element(By.LINK_TEXT, '注册').click()
check_tip = driver.find_elements(
By.CSS_SELECTOR,
" form > ul > li:nth-child(1) > div > span").text
print(check_tip)
if check_tip == "通过信息验证！":
print("测试通过")
else:
print("测试失败")
self.assertEqual("通过信息验证！", check_tip)
class RegisterTest2(unittest.TestCase):
#3.声明一个变量，读取CSV文件的测试数据
data_table = CsvFileManager4().reader('testdata.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit()
#4.为test_register方法添加装饰@ddt.data,指定测试数据
#data_table是一个list类型，包含很多元素
#在data_table前面加一个星号，表示调用ddt.date（）方法时，我们传入的不是列表，而是单独传列表中的每个元素
#所以，星号的作用就是，把列表中每个元素，都单独看成一个参数
#假如一个方法需要的参数数量不固定，我们可以用这种方法
@ddt.data(*data_table)
#5.给方法添加一个参数，row
#如果想取第一列数据，那么应该是row[1]
def test_register(self, row):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, "username").send_keys([row[0]])
# driver.find_element_by_name("username").send_keys([row[0]])
driver.find_element(By.NAME, "password").send_keys([row[1]])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
check_tip = driver.find_element(
By.CSS_SELECTOR,
"form.registerform.sign > ul > li:nth-child(1) >div > span").text
print(check_tip)
class RegisterTest2(unittest.TestCase):
#3.声明一个变量 读取csv文件的测试数据
data_table = CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(10)
cls.driver.quit()
#4.为test_register方法添加装饰@ddt.data 指定测试数据data_table
#data_table是一个list类型 包含很多元素
#在data_table前面加一个星号 表示调用ddt.data（）方法时
#我们传入的不是列表 而是单独传的列表中的每个元素
#所以星号的作用是把一个列表中的所有元素都单独看成一个参数
#假如一个方法需要的参数数量不固定，我们可以用这种方法
@ddt.data(*data_table)
#5.给方法添加一个参数row
#如果想取第一列数据 那么应该是row[1]
#使用ddt的方法 相当于把循环写在了方法外面
#好处是，每次循环都相当与重新执行这个方法
#这样断言就不会阻塞后面的测试用例了
def test_register(self, row):
driver = self.driver
driver.get('http://localhost/index.php?m=user&c=public&a=reg')
driver.find_element(By.NAME, 'username').send_keys(row[0])
driver.find_element(By.NAME, 'password').send_keys(row[1])
driver.find_element(By.NAME, 'userpassword2').send_keys(row[2])
driver.find_element(By.NAME, 'mobile_phone').send_keys(row[3])
driver.find_element(By.NAME, 'email').send_keys(row[4])
driver.find_element_by_name('username').submit()
check_tip = driver.find_element_by_css_selector(
'form.registerform.sign > ul > li:nth-child(1) > div > span').text
self.assertEqual('通过信息验证！', check_tip)
class RegisterTest2(unittest.TestCase):
#3/声明一个变量 ,读取csv文件的测试数据
data_table = CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver =webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit()
#为test_register 方法 添加装饰器 @ddt.data,指定测试数据
#data_table 是一个list 类型,包含很多元素
#在data_table 前面加一个* 号表示调用 ddt.data()方法时
#我们传入的不是列表,而是单独传的列表中的每一个元素
#所以*号的作用就是 把列表中的每个元素 都单独看成一个参数
#假如 一个方法需要的参数数点不固定,我们可以用这种方法
@ddt.data(*data_table)
#5/给方法添加一个参数, row
#如果想取第一列数据,那么应该是row([1])
def test_register(self,ros):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
# find_elemrnt()
# driver.find_element_by_name("username")=driver.find_element(By.NAME,"username")
# 这两种方法没有任何区别,但是后面这中方法扩展性更好,便于框架封装
driver.find_element(By.NAME, "username").send_keys(ros[0])
driver.find_element(By.NAME, "password").send_keys(ros[1])
driver.find_element(By.NAME, "userpassword2").send_keys(ros[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(ros[3])
driver.find_element(By.NAME, "email").send_keys(ros[4])
check_tip = driver.find_element(By.CSS_SELECTOR," body > div.w1180 > div > div.reg_main > div.reg_left.fl > form > ul > li:nth-child(1) > div > span").text
self.assertEqual("用户名不低于三位，使用中文、数字、字母皆可！", check_tip)
def test_register(self):
for row in CsvFileManager4().read('test_data.csv'):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, 'username').send_keys(row[0])
#driver.find_element_by_name()与上边的一样,没有任何区别,但是第一种方法扩展性更好,便于我们的框架封装
driver.find_element(By.NAME, 'password').send_keys(row[1])
driver.find_element(By.NAME, 'userpassword2').send_keys(row[2])
driver.find_element(By.NAME, 'mobile_phone').send_keys(row[3])
driver.find_element(By.NAME, 'email').send_keys(row[4])
driver.find_element(By.CLASS_NAME, 'reg_btn').click()
# 在for循环中执行测试用例,虽然解决批量执行的问题,但是如果第一行测试用例执行失败,后续的测试用例还会不会执行
# 异常情况,输入完邮箱后,按tab键,检查提示信息是否都是通过信息验证状态
# 如果页面上提示的心事是通过信息验证,那么就认为测试用例成功了,否则失败
check_tip = driver.find_element(
By.CSS_SELECTOR,
'body > div.w1180 > div > div.reg_main > div.reg_left.fl > form > ul > li:nth-child(6) > p > input'
).text
# 断言写法
self.assertEqual("请输入", check_tip)
class RegisterTest2(unittest.TestCase):
# 3 声明一个变量，读取csv文件的测试数据
data_table=CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver=webdriver.Chrome()
cls.driver.implicitly_wait(5)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(10)
cls.driver.quit()
# 4 为test_register方法添加装饰器@ddt.data,为这个方法指定测试数据
# data_table是一个list类型，其中包含很多数据
# 在data_table前面加一个*，表示调用ddt.data方法时，传入的不是列表，而是单独传入某一个元素
# 所以*作用是：把列表中所有元素都单独看做一个参数
# 假如一个方法需要的数量不固定，我们可以用这种方法
@ddt.data(*data_table)
# 5 给方法添加一个参数row
# 取第一列数据，那么应该是row[1]
# 使用ddt方法，相当于把循环写在了方法的外面，好处是：每次循环都相当于重新执行了这个方法
# 这样断言就不会阻塞后续的测试用例了
def test_register(self,row):
driver=self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, 'username').send_keys(row[0])
driver.find_element(By.NAME, 'password').send_keys(row[1])
driver.find_element(By.NAME, 'userpassword2').send_keys(row[2])
driver.find_element(By.NAME, 'mobile_phone').send_keys(row[3])
driver.find_element(By.NAME, 'email').send_keys(row[4])
check_tip = driver.find_element(By.CSS_SELECTOR,
'form.registerform.sign > ul > li:nth-child(1) > div > span').text
self.assertEqual(check_tip,'通过信息验证！')
def test_register(self):
for row in CsvFileManager4().reader('testdata.csv'):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
#这两种方法没有任何区别，但是后面的 driver.find_element_by_name("username")扩展性更好，便于框架封装
driver.find_element(By.NAME, "username")
driver.find_element_by_name("username").send_keys([row[0]])
driver.find_element(By.NAME, "password").send_keys([row[1]])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
check_tip = driver.find_element(
By.CSS_SELECTOR,
"form.registerform.sign > ul > li:nth-child(1) >div > span"
).text
print(check_tip)
'''
if check_tip == "通过信息验证":
print("passed")
else:
print("error")
'''
self.assertEqual("通过信息验证!", check_tip)
def test_register(self):
for row in CsvFileManager4().read('test_data.csv'):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
#find_element(),下面两种方法没有任何区别，但是第二种方法扩展性更好，便于数据库封装
#driver.find_element_by_name("username")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
#driver.find_element(By.CLASS_NAME,"reg_btn").click()
#for循环中执行测试用例，虽然解决了批量执行的问题，但是如果第一行数据就失败了，后续的测试用还会不会被执行 考虑异常情况输入完邮箱后，按tab键，检查提示信息是否都是“通过信息验证”
check_tip = driver.find_element(
By.CSS_SELECTOR,
" form> ul > li:nth-child(1) > div > span").text
print(check_tip)
#其中check_tip是执行用历史从网页上抓取的实际结果，“通过信息验证”是来自与手工测试用，是在测试用例执行前的期望结果，
#if check_tip=="通过信息验证":
# print("测试通过")
#else:
# print("测试失败")
# #通过if else语句可以自动判断测试用例的执行情况
self.assertEqual("通过信息验证", check_tip)
class RegisterTest2(unittest.TestCase):
#声明一个变量,读取csv文件的测试数据
data_table = CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(10)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit()
#4.为test_register方法添加装饰器@ddt.data
#data_table是一个list类型,包含很多元素
#在data_table前面加一个*星号,表示调用ddt.data()方法时
#我们传入的不是列表.而是单独传的列表中的每个元素
#所以,星号的作用就是.把列表中的每个元素都单独看做一个参数
@ddt.data(*data_table)
#5.给方法添加一个参数row
#如果想取第一列数据,应该是row[1]
def test_register(self, row):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
check_tip = driver.find_element(
By.CSS_SELECTOR, "form > ul > li:nth-child(1) > div > span").text
self.assertEquals("用户名不低于三位，使用中文、数字、字母皆可！", check_tip)
class RegisterTest2(unittest.TestCase):
#3.声明一个变量，读取csv文件数据
data_table = CsvFileManager4().read('test_data.csv')
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.implicitly_wait(20)
cls.driver.maximize_window()
@classmethod
def tearDownClass(cls):
time.sleep(30)
cls.driver.quit()
#4.为test_register2方法添加装饰器@ddt.data,指定测试数据data_table
#@ddt.data是一个list类型，包含很多元素
#在data_table前面加一个星号*，表示调用ddt.data()方法时我们传入的不是列表，而是单独传的列表中的每个元素
#所以星号的作用就是把列表中的每个元素，都单独看成一个参数
@ddt.data(*data_table)
#5.给方法添加一个参数row
#如果想取第一列数据，那么应该是row[1]
#使用ddt方法相当于把循环写在了方法外面，每次循环，相当于重新执行这个方法，这样断言就不会阻塞后面的测试用例
def test_register2(self,row):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
driver.find_element(By.NAME, 'username').send_keys(row[0])
driver.find_element(By.NAME, 'password').send_keys(row[1])
driver.find_element(By.NAME, 'userpassword2').send_keys(row[2])
driver.find_element(By.NAME, 'mobile_phone').send_keys(row[3])
driver.find_element(By.NAME, 'email').send_keys(row[4])
# driver.find_element(By.LINK_TEXT,'注册').click()
check_tip = driver.find_element(By.CSS_SELECTOR, 'form > ul > li:nth-child(1) > div > span').text
print(check_tip)
self.assertEqual("通过信息验证！", check_tip)
def test_register(self):
for row in CsvFileManager4().read("test_data.csv"):
driver = self.driver
driver.get("http://localhost/index.php?m=user&c=public&a=reg")
#这两种方法，没有任何区别，但是后面的这种方法扩展性更好，便于框架封装
driver.find_element(By.NAME, "username").send_keys(row[0])
driver.find_element(By.NAME, "password").send_keys(row[1])
driver.find_element(By.NAME, "userpassword2").send_keys(row[2])
driver.find_element(By.NAME, "mobile_phone").send_keys(row[3])
driver.find_element(By.NAME, "email").send_keys(row[4])
driver.find_element(By.CLASS_NAME, "reg_btn").click()
# driver.find_element_by_name("username")
#在for循环中执行测试用例，虽然解决批量执行的问题
#但是，想一下，如果第一行测试用例执行失败，后续的测试用例还会不会执行
#考虑异常情况，输入完邮箱后，按tab键，检查提示信息是否都是“通过信息验证”
#怎么验证？如果页面上提示的信息是“通过信息验证！”，那么测试通过，否则测试失败
check_tip = driver.find_element(
By.CSS_SELECTOR,
"form.registerform.sign > ul > li:nth-child(1) > div > span"
).text
print(check_tip)
self.assertEqual("用户名不低于三位，使用中文、数字、字母皆可！", check_tip)