report.html

self = <test_url_city_check.TestUrlCityVerification object at 0x0000025BE11ECD60>
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 0x0000025BE1410430>
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 0x0000025BE1466B20>
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 0x0000025BE1516850>
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 0x0000025BE15334C0>
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 0x0000025BE157AD00>
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 0x0000025BE1588A30>
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 0x0000025BE15BF3A0>
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 0x0000025BE1687CA0>
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 0x0000025BE145C610>
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 0x0000025BE155ADF0>
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 0x0000025BE16EADF0>
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 0x0000025BE16FD4C0>
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 0x0000025BE1656850>
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 0x0000025BE16560A0>
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 0x0000025BE1664910>
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 0x0000025BE173B9D0>
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 0x0000025BE1717970>
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 0x0000025BE17A7370>
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 0x0000025BE171ED90>
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 0x0000025BE1710340>
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 0x0000025BE177FA30>
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 0x0000025BE176A850>
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 0x0000025BE1778A90>
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 0x0000025BE1782790>
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 0x0000025BE178D490>
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 0x0000025BE1719C10>
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 0x0000025BE17789A0>
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 0x0000025BE14B3F70>
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 0x0000025BE14BDEB0>
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 0x0000025BE17F2B50>
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 0x0000025BE17F2BE0>
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 0x0000025BE18668E0>
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 0x0000025BE18C6B20>, 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