report.html

self = <test_page_section_check.TestPageSectionCheck object at 0x000001AAEF1842B0>
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 0x000001AAEF184700>
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 0x000001AAEF184A00>
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 0x000001AAEF184AC0>
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 0x000001AAEF184B80>
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 0x000001AAEF184C40>
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 0x000001AAEF184D00>
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 0x000001AAEF184F40>
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 0x000001AAEF1A8100>
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 0x000001AAEF1A81C0>
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 0x000001AAEF1A8280>
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 0x000001AAEF1A8340>
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 0x000001AAEF1A8580>
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 0x000001AAEF1A8640>
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 0x000001AAEF1A8700>
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 0x000001AAEF1A87C0>
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 0x000001AAEF1A8880>
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 0x000001AAEF1A8940>
value = 'https://www.simplilearn.com/cyber-security/cism-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 0x000001AAEF1A8A00>
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 0x000001AAEF1A8AC0>
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 0x000001AAEF1A8B80>
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 0x000001AAEF1A8D00>
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 0x000001AAEF1A8DC0>
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 0x000001AAEF1A8E80>
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 0x000001AAEF1A8F40>
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 0x000001AAEF1B3040>
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 0x000001AAEF1B3100>
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 0x000001AAEF1B31C0>
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 0x000001AAEF1B3280>
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 0x000001AAEF1B3340>
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 0x000001AAEF1B3400>
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 0x000001AAEF1B34C0>
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 0x000001AAEF1B3580>
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 0x000001AAEF1B3640>
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 0x000001AAEF1B3700>
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 0x000001AAEF1B37C0>
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 0x000001AAEF1B3880>
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 0x000001AAEF1B3940>
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 0x000001AAEF1B3A00>
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 0x000001AAEF1B3AC0>
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 0x000001AAEF1B3B80>
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 0x000001AAEF1B3C40>
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 0x000001AAEF1B3D00>
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 0x000001AAEF1B3DC0>
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 0x000001AAEF1B3E80>
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 0x000001AAEF1B3F40>
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 0x000001AAEF1C2040>
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 0x000001AAEF1C2100>
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 0x000001AAEF1C21C0>
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 0x000001AAEF1C2280>
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 0x000001AAEF1C2340>
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 0x000001AAEF1C2400>
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 0x000001AAEF1C24C0>
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 0x000001AAEF1C2580>
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 0x000001AAEF1C2970>
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 0x000001AAEF1C2AF0>
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 0x000001AAEF1C2BB0>
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 0x000001AAEF1C2DF0>
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 0x000001AAEF1D1070>
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 0x000001AAEF1D1280>
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 0x000001AAEF1D1310>
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 0x000001AAEF1D13D0>
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 0x000001AAEF1D1490>
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 0x000001AAEF1D1550>
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 0x000001AAEF1D1610>
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 0x000001AAEF1D16D0>
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 0x000001AAEF1D1790>
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 0x000001AAEF1D1850>
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 0x000001AAEF1D1910>
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 0x000001AAEF1D19D0>
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 0x000001AAEF1D1A90>
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 0x000001AAEF1D1B50>
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 0x000001AAEF1D1C10>
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 0x000001AAEF1D1CD0>
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 0x000001AAEF1D1E50>
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 0x000001AAEF1D1F10>
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 0x000001AAEF1D1FD0>
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 0x000001AAEF1E5190>
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 0x000001AAEF1E5250>
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 0x000001AAEF1E5310>
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 0x000001AAEF1E53D0>
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 0x000001AAEF1E5490>
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 0x000001AAEF1E5BE0>
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 0x000001AAEF1F80A0>
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 0x000001AAEF1F8160>
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 0x000001AAEF1F8220>
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 0x000001AAEF1F82E0>
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 0x000001AAEF1F8460>
value = 'https://www.simplilearn.com/pgp-business-analytics-certification-course\n'

@pytest.mark.test_details("SLUB-T0000","high","Page Section Check","Prince")
@pytest.mark.parametrize("value",pgnew_program_read_csv())
def test_check_page_section_for_PG_new_template_program_url(self,value):
#self._test_add_rows_in_csv()
count=0
#with open("Pg_new_template_prod.txt")as url_file:
filename = "Report.csv"
#count = 0
#for city_url in url_file:
city_url = value.rstrip('\n')
pytest.driver.get(city_url)
time.sleep(2)
> missing_section = pg_university_load.pg_new_template_section_present()

test_prod\test_page_section_check.py:194:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>

def pg_new_template_section_present(self):
missing_section=[]
selenium_helper.scroll_page("4000")
time.sleep(3)

if selenium_helper.is_locator_present(self.locators['btn_sticky_faq_section_btn'],10)==False:
missing_section.append("FAQs")
else:
self.btn_sticky_faq_section_btn.click()
time.sleep(1)
text1=self.btn_sticky_faq_section_btn_text.text
#logging.info(f"Section is {text1}")
if text1 in 'FAQs':
assert True

if selenium_helper.is_locator_present(self.locators['btn_sticky_overview_section_btn'],10)==False:
missing_section.append("Overview")
else:
self.btn_sticky_overview_section_btn.click()
time.sleep(1)
text2=self.btn_sticky_overview_section_btn_text.text
#logging.info(f"Section is {text2}")
text2=text2.split()[1]
if text2 in 'Overview':
assert True

if selenium_helper.is_locator_present(self.locators['btn_sticky_program_advantage_section_btn'],10)==False:
missing_section.append("Program Advantage")
else:
self.btn_sticky_program_advantage_section_btn.click()
time.sleep(1)
text3=self.btn_sticky_program_advantage_section_btn_text.text
#logging.info(f"Section is {text3}")
if text3 in 'Advantage':
assert True

if selenium_helper.is_locator_present(self.locators['btn_sticky_program_details_section_btn'],10)==False:
missing_section.append("Program Details")
else:
self.btn_sticky_program_details_section_btn.click()
time.sleep(1)
text4=self.btn_sticky_program_details_section_btn_text.text
#logging.info(f"Section is {text4}")
if text4 in 'Details':
assert True

if selenium_helper.is_locator_present(self.locators['btn_sticky_program_advisors_section_btn'],10)==False:
missing_section.append("Program Advisors")
else:
self.btn_sticky_program_advisors_section_btn.click()
time.sleep(1)
text5=self.btn_sticky_program_advisors_section_btn_text.text
#logging.info(f"Section is {text5}")
if text5 in 'Advisor':
assert True

> if text4 in 'Learning Path':
E UnboundLocalError: local variable 'text4' referenced before assignment

pages\university_master_page.py:784: UnboundLocalError

self = <test_page_section_check.TestPageSectionCheck object at 0x000001AAEF1F8520>
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 0x000001AAEF1F8A60>
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 0x000001AAEF1F8F10>
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 0x000001AAEF1F8FD0>
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 0x000001AAEF2080D0>
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 0x000001AAEF208250>
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 0x000001AAEF208610>
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 0x000001AAEF2086D0>
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 0x000001AAEF208910>
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 0x000001AAEF208B80>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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/cloud-computing-certification-online-course#ProgramHighlights is not visible

self = <test_page_section_check.TestPageSectionCheck object at 0x000001AAEF208C40>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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 0x000001AAEF208D00>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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 0x000001AAEF208DC0>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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 0x000001AAEF208E80>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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 0x000001AAEF208F40>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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 0x000001AAEF218040>
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 0x000001AAEF218100>
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 0x000001AAEF2181C0>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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 0x000001AAEF218280>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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/project-management-online-certification-course#ProgramHighlights is not visible

self = <test_page_section_check.TestPageSectionCheck object at 0x000001AAEF218340>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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 0x000001AAEF218400>
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 0x000001AAEF2184C0>
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 0x000001AAEF218580>
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:956: in subdomain_section_present
text5=self.btn_sticky_program_highlights_section_btn_text.text
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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 0x000001AAEF218640>
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 0x000001AAEF218700>
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 0x000001AAEF2187C0>
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 0x000001AAEF218880>
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 0x000001AAEF218940>
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()

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

self = <pages.university_master_page.UniversityMasterPage object at 0x000001AAEF23D3D0>
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://certifications.spjain.org/product-management-course-online#ProgramHighlights is not visible

self = <test_page_section_check.TestPageSectionCheck object at 0x000001AAEF218A00>
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 0x000001AAEF218AC0>
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 0x000001AAEF218DF0>
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 0x000001AAEF218EB0>
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