report.html

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF1D06D90>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:81: 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 value of count is : 2

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF1F54160>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

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

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF1FE0940>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

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

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF1F67D60>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

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

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF20CFDF0>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:81: 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 value of count is : 1

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF20C7B50>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

test_prod\test_url_city_check.py:81: 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 value of count is : 2

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF2136AC0>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

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

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF2130C10>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

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

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF2181E50>, 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()
print("value of count is :", count)
if count >= 1:
> pytest.fail(f"Missing city, hence failed")
E Failed: Missing city, hence failed

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

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF1F2B130>, 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:131: 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 0x0000026EF21A2160>, 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:131: 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 0x0000026EF21B28B0>, 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:131: 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 0x0000026EF21D5BB0>, 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:131: 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 0x0000026EF2231220>, value = '/cyber-security/security-architect-bundle'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/cyber-security/security-architect-bundle, missing values: ['Bangalore', 'Chennai', 'Hyderabad', 'Mumbai', 'Pune', 'Kolkata', 'Delhi', 'Ahmedabad', 'Bhubaneshwar'] in UI key: https://www.simplilearn.com/cyber-security/security-architect-bundle, missing values: [''] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF21DB610>, value = '/it-hardware-and-networking/network-architect-bundle'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/it-hardware-and-networking/network-architect-bundle, missing values: ['Bangalore', 'Chennai', 'Delhi', 'Kolkata', 'Mumbai', 'Pune', 'Ahmedabad'] in UI key: https://www.simplilearn.com/it-hardware-and-networking/network-architect-bundle, missing values: [''] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF22788E0>, value = '/mobile-and-software-development/technical-architect-bundle'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/mobile-and-software-development/technical-architect-bundle, missing values: ['Chennai', 'Delhi', 'Mumbai', 'Pune'] in UI key: https://www.simplilearn.com/mobile-and-software-development/technical-architect-bundle, missing values: [''] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF220DE80>, value = '/quality-management/lean-six-sigma-certification-training-all-in-one-bundle'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: 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 0x0000026EF21F9C10>, value = '/big-data-and-analytics/senior-data-scientist-masters-program-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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/big-data-and-analytics/senior-data-scientist-masters-program-training, missing values: [''] in UI key: https://www.simplilearn.com/big-data-and-analytics/senior-data-scientist-masters-program-training, missing values: ['Ahmedabad', 'Aurangabad', 'Bangalore', 'Bhilai', 'Bhopal', 'Bhubaneshwar', 'Chandigarh', 'Chennai', 'Cochin', 'Coimbatore', 'Dehra Dun', 'Delhi', 'Faridabad', 'Ghaziabad', 'Gorakhpur', 'Guntur', 'Gurgaon', 'Guwahati', 'Hyderabad', 'Jaipur', 'Kanpur', 'Khammam', 'Kolkata', 'Lucknow', 'Madurai', 'Mumbai', 'Mysore', 'Nagpur', 'Noida', 'Patna', 'Pondicherry', 'Pune', 'Ranchi', 'Shimoga', 'Surat', 'Thane', 'Thiruvananthapuram', 'Tiruchchirappalli', 'Tirupati', 'Trichur', 'Vadodara', 'Visakhapatnam', 'Warangal'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF220CFD0>, value = '/advanced-digital-marketing-certification-training-course'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/advanced-digital-marketing-certification-training-course, missing values: [''] in UI key: https://www.simplilearn.com/advanced-digital-marketing-certification-training-course, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Ernakulam', 'Hyderabad', 'Indore', 'Kolkata', 'Mumbai', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF221FF70>, value = '/cloud-solutions-architect-masters-program-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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/cloud-solutions-architect-masters-program-training, missing values: [''] in UI key: https://www.simplilearn.com/cloud-solutions-architect-masters-program-training, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Hyderabad', 'Kolkata', 'Mumbai', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF22C6670>, value = '/devops-engineer-masters-program-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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/devops-engineer-masters-program-certification-training, missing values: [''] in UI key: https://www.simplilearn.com/devops-engineer-masters-program-certification-training, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Kolkata', 'Mumbai', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF229E040>, value = '/pmp-plus-bundle-masters-program'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/pmp-plus-bundle-masters-program, missing values: [''] in UI key: https://www.simplilearn.com/pmp-plus-bundle-masters-program, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Kolkata', 'Mumbai', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF22DBF40>, value = '/artificial-intelligence-masters-program-training-course'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/artificial-intelligence-masters-program-training-course, missing values: [''] in UI key: https://www.simplilearn.com/artificial-intelligence-masters-program-training-course, missing values: ['Ahmedabad', 'Aurangabad', 'Bangalore', 'Bhopal', 'Bhubaneshwar', 'Calicut', 'Chandigarh', 'Chennai', 'Cochin', 'Coimbatore', 'Delhi', 'Ernakulam', 'Hyderabad', 'Jaipur', 'Kolkata', 'Lucknow', 'Madurai', 'Mangalore', 'Mumbai', 'Nagpur', 'Nashik', 'Noida', 'Patna', 'Pondicherry', 'Pune', 'Shimoga', 'Vadodara', 'Visakhapatnam'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF228D7C0>, value = '/digital-project-manager-masters-program-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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/digital-project-manager-masters-program-certification-training, missing values: [''] in UI key: https://www.simplilearn.com/digital-project-manager-masters-program-certification-training, missing values: ['Ahmedabad', 'Bangalore', 'Bhopal', 'Bhubaneshwar', 'Chandigarh', 'Chennai', 'Coimbatore', 'Delhi', 'Ernakulam', 'Gurgaon', 'Hyderabad', 'Indore', 'Jaipur', 'Kolkata', 'Lucknow', 'Mumbai', 'Mysore', 'Noida', 'Pune', 'Thiruvananthapuram'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF22BF040>, value = '/cyber-security-expert-master-program-training-course'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/cyber-security-expert-master-program-training-course, missing values: [''] in UI key: https://www.simplilearn.com/cyber-security-expert-master-program-training-course, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Kolkata', 'Meerut', 'Mumbai', 'Noida', 'Pune', 'Tirupati'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF22C7A30>, value = '/big-data-engineer-masters-certification-training-course'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/big-data-engineer-masters-certification-training-course, missing values: [''] in UI key: https://www.simplilearn.com/big-data-engineer-masters-certification-training-course, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Kolkata', 'Mumbai', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF2287EE0>, value = '/data-analyst-masters-certification-training-course'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/data-analyst-masters-certification-training-course, missing values: [''] in UI key: https://www.simplilearn.com/data-analyst-masters-certification-training-course, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Cochin', 'Delhi', 'Gurgaon', 'Hyderabad', 'Jaipur', 'Jodhpur', 'Kolhapur', 'Kolkata', 'Lucknow', 'Mangalore', 'Mumbai', 'Noida', 'Pune', 'Rajkot'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF21F3700>, value = '/business-analyst-certification-training-course'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/business-analyst-certification-training-course, missing values: [''] in UI key: https://www.simplilearn.com/business-analyst-certification-training-course, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Coimbatore', 'Delhi', 'Gurgaon', 'Hyderabad', 'Jaipur', 'Kolkata', 'Lucknow', 'Mumbai', 'Noida', 'Pune', 'Vijayawada'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF2287DF0>, value = '/aws-cloud-architect-certification-training-course'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/aws-cloud-architect-certification-training-course, missing values: [''] in UI key: https://www.simplilearn.com/aws-cloud-architect-certification-training-course, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Kolkata', 'Mumbai', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF1FE0400>, value = '/azure-cloud-architect-certification-training-course'
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", master_program_read_csv())
def test_create_json_from_DB_for_classroom_course_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_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:179: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/azure-cloud-architect-certification-training-course, missing values: ['Patna'] in UI

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF233BD30>, value = '/full-stack-web-developer-mean-stack-certification-training'
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:225: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/full-stack-web-developer-mean-stack-certification-training, missing values: [''] in UI key: https://www.simplilearn.com/full-stack-web-developer-mean-stack-certification-training, missing values: ['Bangalore', 'Chandigarh', 'Chennai', 'Delhi', 'Gurgaon', 'Hyderabad', 'Indore', 'Jaipur', 'Kolkata', 'Mumbai', 'Noida', 'Pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x0000026EF2356A30>, 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:225: 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 0x0000026EF22EEB80>, 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:275: 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 0x0000026EF2389220>, 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:275: 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