report.html

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F424BC3A0>
value = 'https://www.simplilearn.com/agile-and-scrum/agile-and-scrum-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4265ADF0>
value = 'https://www.simplilearn.com/big-data-and-analytics/big-data-and-hadoop-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F426828B0>
value = 'https://www.simplilearn.com/quality-management/lean-six-sigma-black-belt-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427238B0>
value = 'https://www.simplilearn.com/quality-management/lean-management-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427335B0>
value = 'https://www.simplilearn.com/salesforce/salesforce-developer-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42689DC0>
value = 'https://www.simplilearn.com/digital-marketing/search-engine-optimization-seo-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42709970>
value = 'https://www.simplilearn.com/digital-marketing/social-media-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42754400>
value = 'https://www.simplilearn.com/digital-marketing/pay-per-click-ppc-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F426EE400>
value = 'https://www.simplilearn.com/digital-marketing/content-marketing-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42772580>
value = 'https://www.simplilearn.com/digital-marketing/conversion-optimization-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427574F0>
value = 'https://www.simplilearn.com/salesforce/salesforce-administrator-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427366D0>
value = 'https://www.simplilearn.com/salesforce/salesforce-administrator-and-developer-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427E7B50>
value = 'https://www.simplilearn.com/big-data-and-analytics/data-scientist-certification-sas-r-excel-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427F3970>
value = 'https://www.simplilearn.com/quality-management/lean-six-sigma-green-belt-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427915E0>
value = 'https://www.simplilearn.com/mobile-and-software-development/python-development-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427E0E80>
value = 'https://www.simplilearn.com/big-data-and-analytics/big-data-and-hadoop-administrator-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427FAD90>
value = 'https://www.simplilearn.com/big-data-and-analytics/mongodb-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42803FD0>
value = 'https://www.simplilearn.com/apache-kafka-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4276C370>
value = 'https://www.simplilearn.com/digital-marketing/email-marketing-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4282B640>
value = 'https://www.simplilearn.com/digital-marketing/kpi-analysis-and-techniques-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42796910>
value = 'https://www.simplilearn.com/big-data-and-analytics/apache-spark-scala-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42840820>
value = 'https://www.simplilearn.com/agile-and-scrum/agile-scrum-master-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4281B910>
value = 'https://www.simplilearn.com/cloud-computing/aws-technical-essential-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42794AC0>
value = 'https://www.simplilearn.com/salesforce/salesforce-platform-developer-1-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428605B0>
value = 'https://www.simplilearn.com/big-data-and-analytics/python-for-data-science-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42820370>
value = 'https://www.simplilearn.com/cloud-computing/aws-developer-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4284BA60>
value = 'https://www.simplilearn.com/cloud-computing/aws-sysops-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42859AC0>
value = 'https://www.simplilearn.com/mobile-and-software-development/java-javaee-soa-development-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428905E0>
value = 'https://www.simplilearn.com/digital-marketing/digital-analytics-foundation-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428519D0>
value = 'https://www.simplilearn.com/cloud-computing/microsoft-azure-fundamentals-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428AA070>
value = 'https://www.simplilearn.com/tableau-training-and-data-visualization-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42872280>
value = 'https://www.simplilearn.com/angular-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4288A2B0>
value = 'https://www.simplilearn.com/selenium-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428D2B80>
value = 'https://www.simplilearn.com/node-js-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428DDCD0>
value = 'https://www.simplilearn.com/ccsp-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428E7B80>
value = 'https://www.simplilearn.com/react-js-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428F2340>
value = 'https://www.simplilearn.com/ansible-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429053D0>
value = 'https://www.simplilearn.com/sql-database-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4290D310>
value = 'https://www.simplilearn.com/dot-net-programming-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428B3700>
value = 'https://www.simplilearn.com/comptia-security-plus-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428A7580>
value = 'https://www.simplilearn.com/power-bi-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428DC3D0>
value = 'https://www.simplilearn.com/deep-learning-course-with-tensorflow-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4275A280>
value = 'https://www.simplilearn.com/artificial-intelligence-introduction-for-beginners-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429314C0>
value = 'https://www.simplilearn.com/microsoft-azure-administrator-associate-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F428F6190>
value = 'https://www.simplilearn.com/it-service-management/itil-foundation-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4293A3D0>
value = 'https://www.simplilearn.com/introduction-to-cyber-security-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42909E80>
value = 'https://www.simplilearn.com/introduction-to-data-analytics-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429477F0>
value = 'https://www.simplilearn.com/natural-language-processing-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42947760>
value = 'https://www.simplilearn.com/microsoft-azure-architect-design-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4292B1F0>
value = 'https://www.simplilearn.com/iot-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42968DC0>
value = 'https://www.simplilearn.com/pyspark-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42975BB0>
value = 'https://www.simplilearn.com/itil-4-managing-professional-transition-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429309D0>
value = 'https://www.simplilearn.com/itil-specialist-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42995FD0>
value = 'https://www.simplilearn.com/certified-kubernetes-administrator-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4299FDC0>
value = 'https://www.simplilearn.com/itil-strategist-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F426AB790>
value = 'https://www.simplilearn.com/digital-strategy-for-brand-marketing-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4296E640>
value = 'https://www.simplilearn.com/itil-specialist-high-velocity-it-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4297E280>
value = 'https://www.simplilearn.com/itil-specialist-drive-stakeholder-value-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429973A0>
value = 'https://www.simplilearn.com/jenkins-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429884C0>
value = 'https://www.simplilearn.com/docker-certified-associate-dca-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429A7B20>
value = 'https://www.simplilearn.com/google-cloud-architect-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429AE2E0>
value = 'https://www.simplilearn.com/prince2-agile-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429B7850>
value = 'https://www.simplilearn.com/aws-big-data-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F426A8160>
value = 'https://www.simplilearn.com/introduction-to-business-analysis\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429D21C0>
value = 'https://www.simplilearn.com/cyber-security/cobit-certification-training'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",read_csv())
def test_check_page_section_for_certificate_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("certificate_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.certificate_page_section_present()
if len(missing_section)>=1:
rows = [['Certificate Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Certificate Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:68: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429A3E20>
value = 'https://www.simplilearn.com/agile-and-scrum/certified-scrum-developer-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",classroom_program_read_csv())
def test_check_page_section_for_classroom_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("classroom_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.classroom_page_section_present()
if len(missing_section)>=1:
rows = [['Classroom Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Classroom Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:103: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429BCFD0>
value = 'https://www.simplilearn.com/kanban-system-design-kmp1-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",classroom_program_read_csv())
def test_check_page_section_for_classroom_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("classroom_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.classroom_page_section_present()
if len(missing_section)>=1:
rows = [['Classroom Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Classroom Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:103: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429CC640>
value = 'https://www.simplilearn.com/certified-agile-coaching-icp-acc-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",classroom_program_read_csv())
def test_check_page_section_for_classroom_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("classroom_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.classroom_page_section_present()
if len(missing_section)>=1:
rows = [['Classroom Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Classroom Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:103: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F4290DBB0>
value = 'https://www.simplilearn.com/advanced-certified-scrum-master-a-csm-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",classroom_program_read_csv())
def test_check_page_section_for_classroom_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("classroom_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.classroom_page_section_present()
if len(missing_section)>=1:
rows = [['Classroom Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Classroom Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:103: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429F4190>
value = 'https://www.simplilearn.com/professional-scrum-master-2-psm-ii-certification'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",classroom_program_read_csv())
def test_check_page_section_for_classroom_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("classroom_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.classroom_page_section_present()
if len(missing_section)>=1:
rows = [['Classroom Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Classroom Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
print("value of count is :", count)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:103: Failed
------------------------------Captured stdout call------------------------------
value of count is : 1

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429CD190>
value = 'https://www.simplilearn.com/advanced-digital-marketing-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429CD820>
value = 'https://www.simplilearn.com/cyber-security/security-architect-bundle\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A691C0>
value = 'https://www.simplilearn.com/it-hardware-and-networking/network-architect-bundle\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429E5CA0>
value = 'https://www.simplilearn.com/mobile-and-software-development/technical-architect-bundle\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429E1070>
value = 'https://www.simplilearn.com/digital-marketing/social-media-viral-marketing-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A83F10>
value = 'https://www.simplilearn.com/business-productivity-tools/microsoft-excel-2013-certification-training-online-bundle\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A8E160>
value = 'https://www.simplilearn.com/quality-management/lean-six-sigma-certification-training-all-in-one-bundle\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A623A0>
value = 'https://www.simplilearn.com/finance-management/complete-financial-modeling-career-advancement-certification-training-bundle\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A25FD0>
value = 'https://www.simplilearn.com/big-data-and-analytics/senior-data-scientist-masters-program-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A36F10>
value = 'https://www.simplilearn.com/digital-marketing/seo-specialist-masters-program-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A413A0>
value = 'https://www.simplilearn.com/cloud-solutions-architect-masters-program-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A8A0D0>
value = 'https://www.simplilearn.com/devops-engineer-masters-program-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A5A5E0>
value = 'https://www.simplilearn.com/pmp-plus-bundle-masters-program\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A57850>
value = 'https://www.simplilearn.com/pmp-renewal-pack-to-earn-pdus-masters-program\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42AE6580>
value = 'https://www.simplilearn.com/artificial-intelligence-masters-program-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A23B50>
value = 'https://www.simplilearn.com/cyber-security-expert-master-program-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42B0B6D0>
value = 'https://www.simplilearn.com/big-data-engineer-masters-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42A531C0>
value = 'https://www.simplilearn.com/data-analyst-masters-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42AE3D30>
value = 'https://www.simplilearn.com/aws-cloud-architect-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427AA8B0>
value = 'https://www.simplilearn.com/azure-cloud-architect-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427B6FD0>
value = 'https://www.simplilearn.com/itil-managing-professional-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427C3F40>
value = 'https://www.simplilearn.com/azure-devops-solutions-expert-masters-program\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427D7DC0>
value = 'https://www.simplilearn.com/data-science-and-artificial-intelligence-masters-program'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",master_program_read_csv())
def test_check_page_section_for_master_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Master_program_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.master_page_section_present()
if len(missing_section)>=1:
rows = [['Master Program',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Master Program',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:137: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F429E53D0>
value = 'https://www.simplilearn.com/pgp-data-analytics-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427A4E20>
value = 'https://www.simplilearn.com/pgp-cloud-computing-professional-certificate-program\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427A4DC0>
value = 'https://www.simplilearn.com/cloud-computing-bootcamp-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42B70A30>
value = 'https://www.simplilearn.com/coding-bootcamp\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42B7AFA0>
value = 'https://www.simplilearn.com/ai-for-decision-making-program\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42B85F10>
value = 'https://www.simplilearn.com/business-analytics-certification-bootcamp-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427C2EE0>
value = 'https://www.simplilearn.com/umn-cloud-computing-bootcamp-program\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427C1040>
value = 'https://www.simplilearn.com/umn-blockchain-developer-bootcamp-program\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42B789A0>
value = 'https://www.simplilearn.com/business-analytics-bootcamp\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42B8CA30>
value = 'https://www.simplilearn.com/digital-marketing-bootcamp-program\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42BCD400>
value = 'https://www.simplilearn.com/marketing-analytics-certification-online-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42BBB550>
value = 'https://www.simplilearn.com/digital-marketing-training-online'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_new_template_section_present()
if len(missing_section)>=1:
rows = [['PG New Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG New Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:207: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42BB9D00>
value = 'https://www.simplilearn.com/pgp-project-management-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgold_program_read_csv())
def test_check_page_section_for_PG_old_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_old_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_old_template_section_present()
if len(missing_section)>=1:
rows = [['PG Old Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG Old Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:241: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42BAA280>
value = 'https://www.simplilearn.com/pgp-cyber-security-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgold_program_read_csv())
def test_check_page_section_for_PG_old_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_old_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_old_template_section_present()
if len(missing_section)>=1:
rows = [['PG Old Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG Old Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:241: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42BF8A60>
value = 'https://www.simplilearn.com/pgp-lean-six-sigma-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgold_program_read_csv())
def test_check_page_section_for_PG_old_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_old_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_old_template_section_present()
if len(missing_section)>=1:
rows = [['PG Old Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG Old Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:241: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42BDDC70>
value = 'https://www.simplilearn.com/pgp-design-thinking-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgold_program_read_csv())
def test_check_page_section_for_PG_old_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_old_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_old_template_section_present()
if len(missing_section)>=1:
rows = [['PG Old Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG Old Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:241: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42BE30D0>
value = 'https://www.simplilearn.com/data-science-bootcamp\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgold_program_read_csv())
def test_check_page_section_for_PG_old_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_old_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_old_template_section_present()
if len(missing_section)>=1:
rows = [['PG Old Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG Old Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:241: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42BE93A0>
value = 'https://www.simplilearn.com/ai-machine-learning-bootcamp\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgold_program_read_csv())
def test_check_page_section_for_PG_old_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_old_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_old_template_section_present()
if len(missing_section)>=1:
rows = [['PG Old Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG Old Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:241: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C30700>
value = 'https://www.simplilearn.com/blockchain-developer-certification-bootcamp\t\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgold_program_read_csv())
def test_check_page_section_for_PG_old_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_old_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_old_template_section_present()
if len(missing_section)>=1:
rows = [['PG Old Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG Old Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:241: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C14160>
value = 'https://www.simplilearn.com/cybersecurity-bootcamp'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgold_program_read_csv())
def test_check_page_section_for_PG_old_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_old_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.pg_old_template_section_present()
if len(missing_section)>=1:
rows = [['PG Old Template',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['PG Old Template',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:241: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C14310>
value = 'https://pg-p.ctme.caltech.edu/cloud-computing-certification-online-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C63BB0>
value = 'https://pg-p.ctme.caltech.edu/full-stack-web-development-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C74370>
value = 'https://bootcamp-sl.discover.online.purdue.edu/ai-machine-learning-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C76220>
value = 'https://bootcamp-sl.discover.online.purdue.edu/data-analytics-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C4D7F0>
value = 'https://bootcamp-sl.discover.online.purdue.edu/data-science-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C5A490>
value = 'https://bootcamp-sl.discover.online.purdue.edu/business-analysis-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C67610>
value = 'https://bootcamp-sl.discover.online.purdue.edu/digital-supply-chain-management-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C6A2B0>
value = 'https://bootcamp-sl.discover.online.purdue.edu/digital-marketing-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C6A2E0>
value = 'https://bootcamp-sl.discover.online.purdue.edu/digital-marketing-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F427B04C0>
value = 'https://bootcamp.umass.edu/project-management-online-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42CA0700>
value = 'https://bootcamp.umass.edu/lean-six-sigma-certification-training-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42CBB670>
value = 'https://bootcamp.umass.edu/digital-marketing-certification\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42CAF4F0>
value = 'https://ecourses.spjimr.org/data-science-for-business-decisions-certification\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C7E700>
value = 'https://ecourses.spjimr.org/professional-brand-strategy-certification-online\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42C61880>
value = 'https://onlinebootcamp.umn.edu/business-analytics-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42CDA430>
value = 'https://onlinebootcamp.umn.edu/pg-business-analytics-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42CA41C0>
value = 'https://onlinebootcamp.umn.edu/cloud-computing-certification-training\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42ADFFA0>
value = 'https://onlinebootcamp.umn.edu/blockchain-developer-certification\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42ABA550>
value = 'https://certifications.spjain.org/product-management-course-online\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42CC4160>
value = 'https://sl-onlinetraining.wharton.upenn.edu/ai-program-for-business\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42AC3D90>
value = 'https://sl-onlinetraining.xpro.mit.edu/executive-leadership-program'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",subdomain_program_read_csv())
def test_check_page_section_for_subdomain_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("urls_list_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
try:
pytest.driver.get(city_url)
time.sleep(2)
except:
logging.info(f'Page load failed for {city_url}')
missing_section = pg_university_load.subdomain_section_present()
if len(missing_section)>=1:
rows = [['Subdomain',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Subdomain',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:278: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000023F42AD2C10>
value = 'https://www.simplilearn.com/automation-testing-training-course-placement-guarantee'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",jg_program_read_csv())
def test_check_page_section_for_job_guarantee_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("job_guarantee_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
missing_section = pg_university_load.job_guarantee_section_present()
if len(missing_section)>=1:
rows = [['Job Guarantee',city_url,'Fail',missing_section]]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
count = count+1
else:
rows = [['Job Guarantee',city_url,'Pass','NA']]
with open(filename, 'a', newline='\n') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerows(rows)
if count>=1:
> pytest.fail(f"Missing section, hence failed")
E Failed: Missing section, hence failed

test_prod\test_page_section_check.py:313: Failed
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_pricing_section_btn_text on url https://www.simplilearn.com/automation-testing-training-course-placement-guarantee#pricing is not visible INFO  setup:university_master_page.py:1038 No Text present for Pricing section