report.html

self = <test_page_section_check.TestPageSectionCheck object at 0x0000017A74B0E520>
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 0x0000017A74B0E970>
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 0x0000017A74B0ED30>
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 0x0000017A74B0EDF0>
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 0x0000017A74B0EEB0>
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 0x0000017A74B0EF70>
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 0x0000017A74B33070>
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 0x0000017A74B33130>
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 0x0000017A74B331F0>
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 0x0000017A74B332B0>
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 0x0000017A74B334F0>
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 0x0000017A74B33670>
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 0x0000017A74B33730>
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 0x0000017A74B337F0>
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 0x0000017A74B338B0>
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 0x0000017A74B33AF0>
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 0x0000017A74B33BB0>
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 0x0000017A74B33C70>
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 0x0000017A74B33D30>
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 0x0000017A74B33DF0>
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 0x0000017A74B33F70>
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 0x0000017A74B3E070>
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 0x0000017A74B3E130>
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 0x0000017A74B3E2B0>
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 0x0000017A74B3E370>
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 0x0000017A74B3E430>
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 0x0000017A74B3E4F0>
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 0x0000017A74B3E5B0>
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 0x0000017A74B3E670>
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 0x0000017A74B3E730>
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 0x0000017A74B3E7F0>
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 0x0000017A74B3E8B0>
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 0x0000017A74B3E970>
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 0x0000017A74B3EA30>
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 0x0000017A74B3EAF0>
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 0x0000017A74B3EBB0>
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 0x0000017A74B3EC70>
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 0x0000017A74B3ED30>
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 0x0000017A74B3EDF0>
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 0x0000017A74B3EEB0>
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 0x0000017A74B3EF70>
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 0x0000017A74B4D070>
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 0x0000017A74B4D130>
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 0x0000017A74B4D1F0>
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 0x0000017A74B4D2B0>
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 0x0000017A74B4D370>
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 0x0000017A74B4D430>
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 0x0000017A74B4D4F0>
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 0x0000017A74B4D5B0>
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 0x0000017A74B4D670>
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 0x0000017A74B4D730>
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 0x0000017A74B4D7F0>
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 0x0000017A74B4D8B0>
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 0x0000017A74B4D970>
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 0x0000017A74B4DA30>
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 0x0000017A74B4DAF0>
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 0x0000017A74B4DBB0>
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 0x0000017A74B4DC70>
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 0x0000017A74B4DD30>
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 0x0000017A74B4DDF0>
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 0x0000017A74B4DEB0>
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 0x0000017A74B4DF70>
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 0x0000017A74B59070>
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 0x0000017A74B59130>
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 0x0000017A74B591F0>
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 0x0000017A74B595E0>
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 0x0000017A74B59760>
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 0x0000017A74B59820>
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 0x0000017A74B59A60>
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 0x0000017A74B59CA0>
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 0x0000017A74B59F10>
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 0x0000017A74B59FD0>
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 0x0000017A74B710D0>
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 0x0000017A74B71190>
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 0x0000017A74B71250>
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 0x0000017A74B71310>
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 0x0000017A74B713D0>
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 0x0000017A74B71490>
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 0x0000017A74B71550>
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 0x0000017A74B71610>
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 0x0000017A74B716D0>
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 0x0000017A74B71790>
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 0x0000017A74B71850>
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 0x0000017A74B71910>
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 0x0000017A74B719D0>
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 0x0000017A74B71B50>
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 0x0000017A74B71C10>
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 0x0000017A74B71CD0>
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 0x0000017A74B71E50>
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 0x0000017A74B71F10>
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 0x0000017A74B71FD0>
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 0x0000017A74B7C0D0>
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 0x0000017A74B7C190>
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 0x0000017A74B7C970>
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 0x0000017A74B7CDF0>
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 0x0000017A74B7CEB0>
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 0x0000017A74B7CF70>
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 0x0000017A74B90070>
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 0x0000017A74B90130>
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 0x0000017A74B902B0>
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 0x0000017A74B905B0>
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 0x0000017A74B59EB0>
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 0x0000017A74B90760>
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 0x0000017A74B908E0>
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 0x0000017A74B90C10>
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 0x0000017A74B90CD0>
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 0x0000017A74B90D90>
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 0x0000017A74B90F10>
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 0x0000017A74BA0310>
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 0x0000017A74BA03D0>
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 0x0000017A74BA0610>
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 0x0000017A74BA0880>
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()

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:940: in subdomain_section_present
self.btn_sticky_alumni_reviews_section_btn.click()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_alumni_reviews_section_btn'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_alumni_reviews_section_btn

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_alumni_reviews_section_btn on url https://pg-p.ctme.caltech.edu/cloud-computing-certification-online-course#programCurriculum is not visible

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

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:953: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_program_highlights_section_btn_text'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_program_highlights_section_btn_text

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_program_highlights_section_btn_text on url https://pg-p.ctme.caltech.edu/full-stack-web-development-certification-course#ProgramHighlights is not visible

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

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:953: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_program_highlights_section_btn_text'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_program_highlights_section_btn_text

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_program_highlights_section_btn_text on url https://bootcamp-sl.discover.online.purdue.edu/ai-machine-learning-certification-course#ProgramHighlights is not visible

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

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:953: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_program_highlights_section_btn_text'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_program_highlights_section_btn_text

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_program_highlights_section_btn_text on url https://bootcamp-sl.discover.online.purdue.edu/data-analytics-certification-course#ProgramHighlights is not visible

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

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:953: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_program_highlights_section_btn_text'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_program_highlights_section_btn_text

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_program_highlights_section_btn_text on url https://bootcamp-sl.discover.online.purdue.edu/data-science-certification-course#ProgramHighlights is not visible

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

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:953: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_program_highlights_section_btn_text'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_program_highlights_section_btn_text

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_program_highlights_section_btn_text on url https://bootcamp-sl.discover.online.purdue.edu/business-analysis-certification-course#ProgramHighlights is not visible

self = <test_page_section_check.TestPageSectionCheck object at 0x0000017A74BA0C70>
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 0x0000017A74BA0D30>
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 0x0000017A74BA0DF0>
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()

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:953: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_program_highlights_section_btn_text'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_program_highlights_section_btn_text

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_program_highlights_section_btn_text on url https://bootcamp-sl.discover.online.purdue.edu/digital-marketing-certification-course#ProgramHighlights is not visible

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

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:951: in subdomain_section_present
self.btn_sticky_program_highlights_section_btn.click()
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\selenium\webdriver\remote\webelement.py:80: in click
self._execute(Command.CLICK_ELEMENT)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\selenium\webdriver\remote\webelement.py:633: in _execute
return self._parent.execute(command, params)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\selenium\webdriver\remote\webdriver.py:321: in execute
self.error_handler.check_response(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <selenium.webdriver.remote.errorhandler.ErrorHandler object at 0x0000017A74D01250>
response = {'status': 400, 'value': '{"value":{"error":"element click intercepted","message":"element click intercepted: Element ...\n\\tRtlGetAppContainerNamedObjectPath [0x77977B4E+286]\\n\\tRtlGetAppContainerNamedObjectPath [0x77977B1E+238]\\n"}}'}

def check_response(self, response):
"""
Checks that a JSON response from the WebDriver does not have an error.

:Args:
- response - The JSON response from the WebDriver server as a dictionary
object.

:Raises: If the response contains an error message.
"""
status = response.get('status', None)
if status is None or status == ErrorCode.SUCCESS:
return
value = None
message = response.get("message", "")
screen = response.get("screen", "")
stacktrace = None
if isinstance(status, int):
value_json = response.get('value', None)
if value_json and isinstance(value_json, basestring):
import json
try:
value = json.loads(value_json)
if len(value.keys()) == 1:
value = value['value']
status = value.get('error', None)
if status is None:
status = value["status"]
message = value["value"]
if not isinstance(message, basestring):
value = message
message = message.get('message')
else:
message = value.get('message', None)
except ValueError:
pass

exception_class = ErrorInResponseException
if status in ErrorCode.NO_SUCH_ELEMENT:
exception_class = NoSuchElementException
elif status in ErrorCode.NO_SUCH_FRAME:
exception_class = NoSuchFrameException
elif status in ErrorCode.NO_SUCH_WINDOW:
exception_class = NoSuchWindowException
elif status in ErrorCode.STALE_ELEMENT_REFERENCE:
exception_class = StaleElementReferenceException
elif status in ErrorCode.ELEMENT_NOT_VISIBLE:
exception_class = ElementNotVisibleException
elif status in ErrorCode.INVALID_ELEMENT_STATE:
exception_class = InvalidElementStateException
elif status in ErrorCode.INVALID_SELECTOR \
or status in ErrorCode.INVALID_XPATH_SELECTOR \
or status in ErrorCode.INVALID_XPATH_SELECTOR_RETURN_TYPER:
exception_class = InvalidSelectorException
elif status in ErrorCode.ELEMENT_IS_NOT_SELECTABLE:
exception_class = ElementNotSelectableException
elif status in ErrorCode.ELEMENT_NOT_INTERACTABLE:
exception_class = ElementNotInteractableException
elif status in ErrorCode.INVALID_COOKIE_DOMAIN:
exception_class = InvalidCookieDomainException
elif status in ErrorCode.UNABLE_TO_SET_COOKIE:
exception_class = UnableToSetCookieException
elif status in ErrorCode.TIMEOUT:
exception_class = TimeoutException
elif status in ErrorCode.SCRIPT_TIMEOUT:
exception_class = TimeoutException
elif status in ErrorCode.UNKNOWN_ERROR:
exception_class = WebDriverException
elif status in ErrorCode.UNEXPECTED_ALERT_OPEN:
exception_class = UnexpectedAlertPresentException
elif status in ErrorCode.NO_ALERT_OPEN:
exception_class = NoAlertPresentException
elif status in ErrorCode.IME_NOT_AVAILABLE:
exception_class = ImeNotAvailableException
elif status in ErrorCode.IME_ENGINE_ACTIVATION_FAILED:
exception_class = ImeActivationFailedException
elif status in ErrorCode.MOVE_TARGET_OUT_OF_BOUNDS:
exception_class = MoveTargetOutOfBoundsException
elif status in ErrorCode.JAVASCRIPT_ERROR:
exception_class = JavascriptException
elif status in ErrorCode.SESSION_NOT_CREATED:
exception_class = SessionNotCreatedException
elif status in ErrorCode.INVALID_ARGUMENT:
exception_class = InvalidArgumentException
elif status in ErrorCode.NO_SUCH_COOKIE:
exception_class = NoSuchCookieException
elif status in ErrorCode.UNABLE_TO_CAPTURE_SCREEN:
exception_class = ScreenshotException
elif status in ErrorCode.ELEMENT_CLICK_INTERCEPTED:
exception_class = ElementClickInterceptedException
elif status in ErrorCode.INSECURE_CERTIFICATE:
exception_class = InsecureCertificateException
elif status in ErrorCode.INVALID_COORDINATES:
exception_class = InvalidCoordinatesException
elif status in ErrorCode.INVALID_SESSION_ID:
exception_class = InvalidSessionIdException
elif status in ErrorCode.UNKNOWN_METHOD:
exception_class = UnknownMethodException
else:
exception_class = WebDriverException
if value == '' or value is None:
value = response['value']
if isinstance(value, basestring):
if exception_class == ErrorInResponseException:
raise exception_class(response, value)
raise exception_class(value)
if message == "" and 'message' in value:
message = value['message']

screen = None
if 'screen' in value:
screen = value['screen']

stacktrace = None
if 'stackTrace' in value and value['stackTrace']:
stacktrace = []
try:
for frame in value['stackTrace']:
line = self._value_or_default(frame, 'lineNumber', '')
file = self._value_or_default(frame, 'fileName', '<anonymous>')
if line:
file = "%s:%s" % (file, line)
meth = self._value_or_default(frame, 'methodName', '<anonymous>')
if 'className' in frame:
meth = "%s.%s" % (frame['className'], meth)
msg = " at %s (%s)"
msg = msg % (meth, file)
stacktrace.append(msg)
except TypeError:
pass
if exception_class == ErrorInResponseException:
raise exception_class(response, message)
elif exception_class == UnexpectedAlertPresentException:
alert_text = None
if 'data' in value:
alert_text = value['data'].get('text')
elif 'alert' in value:
alert_text = value['alert'].get('text')
raise exception_class(message, screen, stacktrace, alert_text)
> raise exception_class(message, screen, stacktrace)
E selenium.common.exceptions.ElementClickInterceptedException: Message: element click intercepted: Element is not clickable at point (192, -2)
E (Session info: chrome=114.0.5735.134)

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\selenium\webdriver\remote\errorhandler.py:242: ElementClickInterceptedException

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

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:953: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_program_highlights_section_btn_text'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_program_highlights_section_btn_text

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_program_highlights_section_btn_text on url https://bootcamp.umass.edu/lean-six-sigma-certification-training-course#ProgramHighlights is not visible

self = <test_page_section_check.TestPageSectionCheck object at 0x0000017A74BB2070>
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 0x0000017A74BB2130>
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 0x0000017A74BB21F0>
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()

test_prod\test_page_section_check.py:265:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pages\university_master_page.py:953: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x0000017A74D01040>
loc = 'btn_sticky_program_highlights_section_btn_text'

def __getattr__(self, loc):

logging.debug(f"the current locator to be found {loc} on url {self.driver.current_url}")
if loc in self.locators.keys():
error = ""
for loc_pair in self.locators[loc]:
loc_pair[0] = selenium_helper.TYPE_OF_LOCATORS[loc_pair[0].lower()]
loc_pair = tuple(loc_pair)
try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.presence_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
#logging.warning(f"the locator {loc} on url {self.driver.current_url} is not present")
continue

try:
element = WebDriverWait(self.driver, self.timeout).until(
EC.visibility_of_element_located(loc_pair)
)
except (StaleElementReferenceException, NoSuchElementException, TimeoutException) as e:
error = e
logging.warning(f"the locator {loc} on url {self.driver.current_url} is not visible")
continue

element = self.get_web_element(*loc_pair)
element._locator = loc_pair
logging.debug(f"the locator {loc} is found!")
return element
> raise NoSuchElementException("An exception of type " + type(error).__name__ + " occurred. With Element -: " + loc)
E selenium.common.exceptions.NoSuchElementException: Message: An exception of type TimeoutException occurred. With Element -: btn_sticky_program_highlights_section_btn_text

core\page_factory.py:60: NoSuchElementException
-------------------------------Captured log call--------------------------------
WARNING  setup:page_factory.py:53 the locator btn_sticky_program_highlights_section_btn_text on url https://ecourses.spjimr.org/professional-brand-strategy-certification-online#ProgramHighlights is not visible

self = <test_page_section_check.TestPageSectionCheck object at 0x0000017A74BB22B0>
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 0x0000017A74BB2370>
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 0x0000017A74BB2430>
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 0x0000017A74BB24F0>
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 0x0000017A74BB25B0>
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 0x0000017A74BB2670>
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 0x0000017A74BB2730>
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 0x0000017A74BB2A60>
value = 'https://www.simplilearn.com/data-science-course-placement-guarantee\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 0x0000017A74BB2B20>
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