report.html

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

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

test_prod\test_url_city_check.py:82: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/quality-management/lean-management-training, missing values: ['Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Kolkata', 'Mumbai', 'Pune'] in UI key: https://www.simplilearn.com/quality-management/lean-management-training, missing values: [''] in DB

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

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

test_prod\test_url_city_check.py:82: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/salesforce/salesforce-developer-training, missing values: ['Bangalore', 'Pune', 'Chennai', 'Mumbai', 'Delhi', 'Kolkata'] in UI key: https://www.simplilearn.com/salesforce/salesforce-developer-training, missing values: [''] in DB

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

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

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

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

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

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

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

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

test_prod\test_url_city_check.py:82: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/salesforce/salesforce-administrator-training, missing values: ['Bangalore', 'Pune', 'Chennai', 'Mumbai', 'Delhi', 'Kolkata', 'Ahmedabad'] in UI key: https://www.simplilearn.com/salesforce/salesforce-administrator-training, missing values: [''] in DB

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

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

test_prod\test_url_city_check.py:82: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/salesforce/salesforce-administrator-and-developer-training, missing values: ['Bangalore', 'Hyderabad', 'Pune', 'Chennai', 'Mumbai', 'Gurgaon', 'Delhi', 'Kolkata', 'Ahmedabad', 'Surat', 'Jaipur', 'Nagpur', 'Visakhapatnam', 'Coimbatore'] in UI key: https://www.simplilearn.com/salesforce/salesforce-administrator-and-developer-training, missing values: [''] in DB

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

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

test_prod\test_url_city_check.py:82: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/big-data-and-analytics/big-data-and-hadoop-administrator-certification-training, missing values: ['Hyderabad'] in UI key: https://www.simplilearn.com/big-data-and-analytics/big-data-and-hadoop-administrator-certification-training, missing values: ['Anantapur', 'Mysore'] in DB

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

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

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

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

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

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

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

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

test_prod\test_url_city_check.py:82: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/selenium-certification-training, missing values: ['Mumbai', 'Delhi', 'Kolkata', 'Gurgaon', 'Coimbatore', 'Ahmedabad'] in UI

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

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

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

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

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

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

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

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

test_prod\test_url_city_check.py:82: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/introduction-to-data-analytics-training-course, missing values: ['Ahmedabad', 'Anantapur', 'Chandigarh', 'Cochin', 'Ghaziabad', 'Hyderabad', 'Jaipur', 'Kolkata', 'Lucknow', 'Mysore', 'Noida', 'Shimla', 'Thiruvananthapuram', 'Vijayawada'] in DB

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

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

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

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

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

test_prod\test_url_city_check.py:82: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/introduction-to-business-analysis, missing values: [''] in UI key: https://www.simplilearn.com/introduction-to-business-analysis, 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 0x000001EB81F10910>
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:132: 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 0x000001EB81F10F10>
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:132: 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 0x000001EB81F245B0>
value = '/agile-and-scrum/csm-certification-training'
testdata = {'db_type': 'mysql', 'query_to_fetch_classroom_course_url_city': "Select distinct json_extract(s.params, '$.city_name'...ct_type=1 and json_extract(s.params, '$.country_id')='6' and (s.url like 'val_city%' or s.linkable_id= val_linkable);"}

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

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

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

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

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

self = <test_url_city_check.TestUrlCityVerification object at 0x000001EB81F34220>
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:226: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/java-full-stack-developer-certification-training-course, missing values: [''] in UI key: https://www.simplilearn.com/java-full-stack-developer-certification-training-course, missing values: ['Ahmedabad', 'Bangalore', 'Bhopal', 'Bhubaneshwar', 'Chennai', 'Hyderabad', 'Lucknow', 'Nagpur', 'Pune', 'Visakhapatnam'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000001EB81F34C40>
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:276: 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 0x000001EB81F34E80>
value = '/pgp-digital-marketing-certification-program'
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:276: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/pgp-digital-marketing-certification-program, missing values: ['ahmedabad', 'bangalore', 'chennai', 'kolkata', 'mumbai', 'delhi', 'pune'] in UI key: https://www.simplilearn.com/pgp-digital-marketing-certification-program, missing values: [''] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000001EB81F4C700>
value = '/blockchain-developer-certification-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:276: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/blockchain-developer-certification-bootcamp, missing values: [''] in UI key: https://www.simplilearn.com/blockchain-developer-certification-bootcamp, missing values: ['ahmedabad', 'bangalore', 'chennai', 'delhi', 'gurgaon', 'hyderabad', 'indore', 'jaipur', 'kolkata', 'mumbai', 'nagpur', 'pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000001EB81F4CA00>
value = '/business-analytics-certification-bootcamp-training'
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:276: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/business-analytics-certification-bootcamp-training, missing values: [''] in UI key: https://www.simplilearn.com/business-analytics-certification-bootcamp-training, missing values: ['ahmedabad', 'bangalore', 'bhubaneshwar', 'chennai', 'coimbatore', 'delhi', 'gurgaon', 'kolkata', 'mumbai', 'pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000001EB81F4CAC0>
value = '/pgp-business-analytics-certification-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:276: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/pgp-business-analytics-certification-course, missing values: ['bhubaneshwar', 'chandigarh', 'thiruvananthapuram', 'jammu'] in UI key: https://www.simplilearn.com/pgp-business-analytics-certification-course, missing values: ['coimbatore', 'gurgaon', 'hyderabad', 'jaipur', 'lucknow', 'noida', 'vijayawada'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000001EB81F4CC40>
value = '/umn-blockchain-developer-bootcamp-program'
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:276: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/umn-blockchain-developer-bootcamp-program, missing values: [''] in UI key: https://www.simplilearn.com/umn-blockchain-developer-bootcamp-program, missing values: ['ahmedabad', 'bangalore', 'chennai', 'delhi', 'gurgaon', 'hyderabad', 'indore', 'jaipur', 'kolkata', 'mumbai', 'nagpur', 'pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000001EB81F4CE80>
value = '/business-analytics-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:276: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/business-analytics-bootcamp, missing values: [''] in UI key: https://www.simplilearn.com/business-analytics-bootcamp, missing values: ['ahmedabad', 'bangalore', 'bhubaneshwar', 'chennai', 'coimbatore', 'delhi', 'gurgaon', 'kolkata', 'mumbai', 'pune'] in DB

self = <test_url_city_check.TestUrlCityVerification object at 0x000001EB81F551C0>
value = '/artificial-intelligence-masters-program-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:276: Failed
------------------------------Captured stdout call------------------------------
key: https://www.simplilearn.com/artificial-intelligence-masters-program-training-course, missing values: ['gurgaon'] in DB