report.html

self = <test_page_section_check.TestPageSectionCheck object at 0x0000022EFF69A460>
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 0x0000022EFF69A8B0>
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 0x0000022EFF69AC70>
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 0x0000022EFF69AD30>
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 0x0000022EFF69ADF0>
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 0x0000022EFF69AEB0>
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 0x0000022EFF69AF70>
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 0x0000022EFF6BE070>
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 0x0000022EFF6BE130>
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 0x0000022EFF6BE1F0>
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 0x0000022EFF6BE430>
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 0x0000022EFF6BE5B0>
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 0x0000022EFF6BE670>
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 0x0000022EFF6BE730>
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 0x0000022EFF6BE7F0>
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 0x0000022EFF6BEA30>
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 0x0000022EFF6BEAF0>
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 0x0000022EFF6BEBB0>
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 0x0000022EFF6BEC70>
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 0x0000022EFF6BED30>
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 0x0000022EFF6BEEB0>
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 0x0000022EFF6BEF70>
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 0x0000022EFF6CD070>
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 0x0000022EFF6CD1F0>
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 0x0000022EFF6CD2B0>
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 0x0000022EFF6CD370>
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 0x0000022EFF6CD430>
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 0x0000022EFF6CD4F0>
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 0x0000022EFF6CD5B0>
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 0x0000022EFF6CD670>
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 0x0000022EFF6CD730>
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 0x0000022EFF6CD7F0>
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 0x0000022EFF6CD8B0>
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 0x0000022EFF6CD970>
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 0x0000022EFF6CDA30>
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 0x0000022EFF6CDAF0>
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 0x0000022EFF6CDBB0>
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 0x0000022EFF6CDC70>
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 0x0000022EFF6CDD30>
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 0x0000022EFF6CDDF0>
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 0x0000022EFF6CDEB0>
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 0x0000022EFF6CDF70>
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 0x0000022EFF6D8070>
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 0x0000022EFF6D8130>
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 0x0000022EFF6D81F0>
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 0x0000022EFF6D82B0>
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 0x0000022EFF6D8370>
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 0x0000022EFF6D8430>
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 0x0000022EFF6D84F0>
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 0x0000022EFF6D85B0>
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 0x0000022EFF6D8670>
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 0x0000022EFF6D8730>
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 0x0000022EFF6D87F0>
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 0x0000022EFF6D88B0>
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 0x0000022EFF6D8970>
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 0x0000022EFF6D8A30>
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 0x0000022EFF6D8AF0>
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 0x0000022EFF6D8BB0>
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 0x0000022EFF6D8C70>
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 0x0000022EFF6D8D30>
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 0x0000022EFF6D8DF0>
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 0x0000022EFF6D8EB0>
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 0x0000022EFF6D8F70>
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 0x0000022EFF6E5070>
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 0x0000022EFF6E5130>
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 0x0000022EFF6E5520>
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 0x0000022EFF6E56A0>
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 0x0000022EFF6E5760>
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 0x0000022EFF6E59A0>
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 0x0000022EFF6E5BE0>
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 0x0000022EFF6E5E50>
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 0x0000022EFF6E5F10>
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 0x0000022EFF6E5FD0>
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 0x0000022EFF6FB0D0>
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 0x0000022EFF6FB190>
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 0x0000022EFF6FB250>
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 0x0000022EFF6FB310>
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 0x0000022EFF6FB3D0>
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 0x0000022EFF6FB490>
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 0x0000022EFF6FB550>
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 0x0000022EFF6FB610>
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 0x0000022EFF6FB6D0>
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 0x0000022EFF6FB790>
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 0x0000022EFF6FB850>
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 0x0000022EFF6FB910>
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 0x0000022EFF6FBA90>
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 0x0000022EFF6FBB50>
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 0x0000022EFF6FBC10>
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 0x0000022EFF6FBD90>
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 0x0000022EFF6FBE50>
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 0x0000022EFF6FBF10>
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 0x0000022EFF6FBFD0>
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 0x0000022EFF7070D0>
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 0x0000022EFF707340>
value = 'https://www.simplilearn.com/global-mba-program-online-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",degree_program_read_csv())
def test_check_page_section_for_degree_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("degree_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.degree_page_section_present()
if len(missing_section)>=1:
rows = [['Degree 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 = [['Degree 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:172: Failed

self = <test_page_section_check.TestPageSectionCheck object at 0x0000022EFF7077F0>
value = 'https://www.simplilearn.com/pgp-ai-machine-learning-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 0x0000022EFF7078B0>
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 0x0000022EFF707970>
value = 'https://www.simplilearn.com/pgp-data-engineering-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 0x0000022EFF707A30>
value = 'https://www.simplilearn.com/pgp-cloud-computing-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 0x0000022EFF707D30>
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 0x0000022EFF707DF0>
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 0x0000022EFF707EB0>
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 0x0000022EFF707F70>
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 0x0000022EFF71C070>
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 0x0000022EFF71C130>
value = 'https://www.simplilearn.com/pgp-business-analytics-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 0x0000022EFF71C1F0>
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 0x0000022EFF71C2B0>
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 0x0000022EFF71C4F0>
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 0x0000022EFF71C5B0>
value = 'https://www.simplilearn.com/data-engineering-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 0x0000022EFF6E5CD0>
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 0x0000022EFF71C6A0>
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 0x0000022EFF71C760>
value = 'https://www.simplilearn.com/hr-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 0x0000022EFF71C820>
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 0x0000022EFF71CB50>
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 0x0000022EFF71CC10>
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 0x0000022EFF71CCD0>
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 0x0000022EFF71CD90>
value = 'https://www.simplilearn.com/pgp-digital-transformation-certification-training-course\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 0x0000022EFF71CE50>
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 0x0000022EFF71CF10>
value = 'https://www.simplilearn.com/applied-machine-learning-program\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 0x0000022EFF72D250>
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 0x0000022EFF72D310>
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 0x0000022EFF72D3D0>
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 0x0000022EFF72D550>
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 0x0000022EFF72D7C0>
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 0x0000022EFF72D880>
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 0x0000022EFF72D940>
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 0x0000022EFF72D790>
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 0x0000022EFF72DA30>
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 0x0000022EFF72DAF0>
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 0x0000022EFF72DBB0>
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 0x0000022EFF72DC70>
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 0x0000022EFF72DD30>
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 0x0000022EFF72DDF0>
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 0x0000022EFF72DEB0>
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 0x0000022EFF72DF70>
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 0x0000022EFF73D070>
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 0x0000022EFF73D130>
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 0x0000022EFF73D1F0>
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 0x0000022EFF73D2B0>
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 0x0000022EFF73D370>
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 0x0000022EFF73D430>
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 0x0000022EFF73D4F0>
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 0x0000022EFF73D5B0>
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 0x0000022EFF73D670>
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 0x0000022EFF73D8E0>
value = 'https://www.simplilearn.com/java-full-stack-developer-certification-training-course\n'

@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

self = <test_page_section_check.TestPageSectionCheck object at 0x0000022EFF73DA60>
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