report.html

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934C94FE50>
value = '/agile-and-scrum/agile-and-scrum-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/agile-and-scrum/agile-and-scrum-certification-training, missing values: [''] in UI key: https://www.simplilearn.com/agile-and-scrum/agile-and-scrum-certification-training, missing values: ['Ahmedabad', 'Bangalore', 'Bhopal', 'Chennai', 'Delhi', 'Gurgaon', 'Hyderabad', 'Kolkata', 'Lucknow', 'Mumbai', 'Pune', 'Thiruvananthapuram', 'Vadodara', 'Vijayawada'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CB5ED90>
value = '/project-management/prince2-foundation-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/project-management/prince2-foundation-certification-training, missing values: ['Bhopal', 'Hyderabad', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CC37160>
value = '/digital-marketing/search-engine-optimization-seo-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/digital-marketing/search-engine-optimization-seo-certification-training, missing values: ['Kanpur', 'Agra'] in UI

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CC40340>
value = '/cyber-security/ceh-certification'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/cyber-security/ceh-certification, missing values: ['Bhubaneshwar'] in UI

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CCB7A30>
value = '/big-data-and-analytics/apache-spark-scala-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/big-data-and-analytics/apache-spark-scala-certification-training, missing values: ['Ahmedabad', 'Chennai', 'Kolkata', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CC96820>
value = '/salesforce/salesforce-platform-developer-1-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/salesforce/salesforce-platform-developer-1-certification-training, missing values: ['Ahmedabad'] in UI key: https://www.simplilearn.com/salesforce/salesforce-platform-developer-1-certification-training, missing values: ['Delhi', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CBF3820>
value = '/node-js-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/node-js-certification-training, missing values: ['Ahmedabad', 'Bangalore', 'Delhi', 'Mumbai', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CCECF10>
value = '/microsoft-azure-administrator-associate-certification-training-course'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/microsoft-azure-administrator-associate-certification-training-course, missing values: ['Kolkata', 'Pune', 'Ahmedabad'] in UI

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CD12C10>
value = '/docker-certified-associate-dca-certification-training-course'
testdata = {'db_type': 'mysql', 'query_to_fetch_course_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", course_read_csv())
def test_create_json_from_DB_for_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('course_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("course_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:80: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/docker-certified-associate-dca-certification-training-course, missing values: ['Bangalore', 'Chennai', 'Pondicherry', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CC264F0>
value = '/quality-management/lean-six-sigma-certification-training-all-in-one-bundle'
testdata = {'db_type': 'mysql', 'query_to_fetch_master_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=2 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", master_program_read_csv())
def test_create_json_from_DB_for_masters_program_url(self, value, testdata):
x={}
df = pd.read_csv('master_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_master_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
#city_name = [ i.capitalize() for i in city_name]
city_name = [item.lower() for item in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("master_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
cities = [item.lower() for item in cities]
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:130: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/quality-management/lean-six-sigma-certification-training-all-in-one-bundle, missing values: [''] in UI key: https://www.simplilearn.com/quality-management/lean-six-sigma-certification-training-all-in-one-bundle, missing values: ['ahmedabad', 'bangalore', 'chennai', 'delhi', 'kolkata', 'mumbai', 'pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CCAD790>
value = '/devops-engineer-masters-program-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_master_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=2 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", master_program_read_csv())
def test_create_json_from_DB_for_masters_program_url(self, value, testdata):
x={}
df = pd.read_csv('master_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_master_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
#city_name = [ i.capitalize() for i in city_name]
city_name = [item.lower() for item in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("master_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
cities = [item.lower() for item in cities]
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:130: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/devops-engineer-masters-program-certification-training, missing values: ['visakhapatnam'] in UI

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CD7F6D0>
value = '/artificial-intelligence-masters-program-training-course'
testdata = {'db_type': 'mysql', 'query_to_fetch_master_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=2 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", master_program_read_csv())
def test_create_json_from_DB_for_masters_program_url(self, value, testdata):
x={}
df = pd.read_csv('master_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_master_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
#city_name = [ i.capitalize() for i in city_name]
city_name = [item.lower() for item in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("master_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
cities = [item.lower() for item in cities]
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:130: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/artificial-intelligence-masters-program-training-course, missing values: ['shimoga'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934C8A4B50>
value = '/business-analyst-certification-training-course'
testdata = {'db_type': 'mysql', 'query_to_fetch_master_url_city': "Select distinct json_extract(s.params, '$.city_name') as city ...ct_type=2 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", master_program_read_csv())
def test_create_json_from_DB_for_masters_program_url(self, value, testdata):
x={}
df = pd.read_csv('master_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_master_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
#city_name = [ i.capitalize() for i in city_name]
city_name = [item.lower() for item in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("master_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
cities = [item.lower() for item in cities]
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:130: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/business-analyst-certification-training-course, missing values: ['cochin'] in UI

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CE54820>
value = '/agile-and-scrum/csm-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_classroom_course_url_city': "Select distinct json_extract(s.params, '$.city_name'...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", classroom_program_read_csv())
def test_create_json_from_DB_for_classroom_course_program_url(self, value, testdata):
x={}
df = pd.read_csv('classroom_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_classroom_course_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("classroom_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:178: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/agile-and-scrum/csm-certification-training, missing values: ['Cochin'] in UI

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CDF8AF0>
value = '/java-full-stack-developer-certification-training-course'
testdata = {'db_type': 'mysql', 'query_to_fetch_cohort_masters_url_city': "Select distinct json_extract(s.params, '$.city_name') ...ct_type=2 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", cohort_master_read_csv())
def test_create_json_from_DB_for_cohort_masters_program_url(self, value, testdata):
x={}
df = pd.read_csv('cohort_master_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_cohort_masters_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
city_name = [ i.capitalize() for i in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("cohort_master_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:224: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/java-full-stack-developer-certification-training-course, missing values: ['Delhi', 'Kolkata', 'Mumbai', 'Jaipur', 'Gurgaon', 'Indore'] in UI

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CBBFBE0>
value = '/pgp-cyber-security-certification-training-course'
testdata = {'db_type': 'mysql', 'query_to_fetch_PG_program_url_city': "Select distinct json_extract(s.params, '$.city_name') as c...ct_type=2 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", PG_program_read_csv())
def test_create_json_from_DB_for_PG_program_url(self, value, testdata):
x={}
df = pd.read_csv('PG_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_PG_program_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
#city_name = [ i.capitalize() for i in city_name]
city_name = [item.lower() for item in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("PG_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
cities = [item.lower() for item in cities]
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:274: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/pgp-cyber-security-certification-training-course, missing values: ['bangalore', 'delhi', 'hyderabad', 'mumbai', 'pune', 'chennai', 'ahmedabad', 'kolkata', 'bhopal', 'bhubaneshwar', 'gurgaon', 'mysore', 'visakhapatnam', 'dhaka', 'tirupati', 'imphal'] in UI key: https://www.simplilearn.com/pgp-cyber-security-certification-training-course, missing values: [''] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000002934CF20040>, value = '/data-engineering-bootcamp'
testdata = {'db_type': 'mysql', 'query_to_fetch_PG_program_url_city': "Select distinct json_extract(s.params, '$.city_name') as c...ct_type=2 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

@pytest.mark.test_details("SLUB-T23850","high","Url City Verification","Prince")
@pytest.mark.parametrize("value", PG_program_read_csv())
def test_create_json_from_DB_for_PG_program_url(self, value, testdata):
x={}
df = pd.read_csv('PG_program_city_url.csv', on_bad_lines='skip')
data = df[df['url']==value]
status_value = data['linkable_id'].values[0]
query_to_fetch_page_city_name = testdata['query_to_fetch_PG_program_url_city'].replace('val_city',str(value)).replace('val_linkable',str(status_value))
query_to_store_city = db_helper.get_prod_data(query_to_fetch_page_city_name,testdata['db_type'])
city_name = list(map(itemgetter('city'), query_to_store_city))
city_name = [item.replace('"', '') for item in city_name]
#returns string where the first character is upper case, and the rest is lower case
#city_name = [ i.capitalize() for i in city_name]
city_name = [item.lower() for item in city_name]
#returns blank quotes if city list is empty for URL else city names
if not city_name:
city_name.append("")
else:
city_name
city_url="https://www.simplilearn.com"+value
x[city_url]=city_name
with open('url_new_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
with open("PG_program_city_url.csv") as csvFile:
reader = csv.DictReader(csvFile)
#for row in reader:
cities=[]
url = "https://www.simplilearn.com"+value
pytest.driver.get(url)
time.sleep(2)
cities=pg_university_load.check_city_present(url)
cities = [item.lower() for item in cities]
x[url]=cities
with open('url_cities.json', 'w') as outfile:
outfile.truncate(0)
json.dump(x, outfile, indent=4)
count = self.url_city_json_comparison_new()
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:274: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/data-engineering-bootcamp, missing values: [''] in UI key: https://www.simplilearn.com/data-engineering-bootcamp, missing values: ['ahmedabad', 'bangalore', 'chennai', 'delhi', 'kolkata', 'mumbai', 'pune'] in DB