report.html

self = <test_url_city_check.TestUrlCityVerification object at 0x00000257CC9ECD00>
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 0x00000257CCC10190>
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 0x00000257CCC5A610>
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 0x00000257CCD42C40>
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 0x00000257CCD135B0>
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 0x00000257CCD36CA0>
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 0x00000257CCDEDE50>
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 0x00000257CCD9A400>
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 0x00000257CCE88D90>
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 0x00000257CCDE3220>
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 0x00000257CCCD3490>
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 0x00000257CC935D00>
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 0x00000257CCCF54C0>
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 0x00000257CCF09850>
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 0x00000257CCF09E50>
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 0x00000257CCF03670>
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 0x00000257CCE52220>
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 0x00000257CCE49310>
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 0x00000257CCE69370>
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 0x00000257CCE5DD30>
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 0x00000257CCE5F310>
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 0x00000257CCF59910>
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 0x00000257CCEF9280>
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 0x00000257CCF73FA0>
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 0x00000257CCEEA790>
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 0x00000257CCED6F10>
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 0x00000257CCED6070>
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 0x00000257CCF29940>
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 0x00000257CCF297F0>
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 0x00000257CD03AE50>
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 0x00000257CCFFC2E0>
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 0x00000257CCFD7EB0>
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 0x00000257CD04F880>
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 0x00000257CCC93B20>, 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