def test_put_note(self):
with app.app_context():
try:
data = {'new_note_name': 'new_note_name'}
resp = self.app.put('/api/notes/1',
data=data,
content_type='multipart/form-data')
data = json.loads(resp.data)
self.assertEqual(data['result'], True)
self.assertEqual(resp.status_code, 200)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_post_clause(self):
with app.app_context():
try:
data = {
'note_id': 1,
'title': '특별한 날',
'contents': '특별한 날에 대한 설명'
}
resp = self.app.post('/api/clauses',
data=data,
content_type='multipart/form-data')
data = json.loads(resp.data)
self.assertIsNotNone(data['clause_id'])
self.assertEqual(resp.status_code, 200)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_update_note_name(self):
with app.app_context():
try:
sqlalchemy_orm.update_data_to_db(Notes, {'note_id' : 1}, {'note_name' : '새로운 노트 이름'})
result = sqlalchemy_orm.get_item_from_db(Notes, {'note_id' : 1})
result = result[0]
self.assertEqual(result['note_name'], '새로운 노트 이름')
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_update_clauses(self):
with app.app_context():
try:
sqlalchemy_orm.update_data_to_db(Clauses, {'note_id' : 1, 'clause_id' : 2}, {'title': '바뀐 제목', 'contents' : "바뀐 내용"})
result = sqlalchemy_orm.get_item_from_db(Clauses, {'note_id' : 1, 'clause_id':2})
result = result[0]
self.assertEqual(result['title'], '바뀐 제목')
self.assertEqual(result['contents'], '바뀐 내용')
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_delete_db(self):
with app.app_context():
try:
db = sqlalchemy_orm.drop_db(False)
table_names = db.engine.table_names()
self.assertEqual(table_names, [])
self.assertEqual(len(table_names), 0)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_update_clausePoints(self):
with app.app_context():
try:
sqlalchemy_orm.update_data_to_db(ClausePoints, {'clause_id' : 3}, {'imp' : 1, 'und' : 2})
result = sqlalchemy_orm.get_item_from_db(ClausePoints, {'clause_id' : 3})
result = result[0]
self.assertEqual(result['imp'], 1)
self.assertEqual(result['und'], 2)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_create_db(self):
with app.app_context():
try:
db = sqlalchemy_orm.create_db(False)
table_names = db.engine.table_names()
self.assertIn('notes', table_names)
self.assertIn('clauses', table_names)
self.assertIn('clause_points', table_names)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_delete_multiple_note(self):
with app.app_context():
try:
sqlalchemy_orm.delete_data_from_db(Notes, {'note_id': [1, 2]})
# Check if result is empty
note_result = sqlalchemy_orm.get_item_from_db(
Notes, {'note_id': [1, 2]})
self.assertEqual(note_result, [])
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_delete_clause(self):
with app.app_context():
try:
sqlalchemy_orm.delete_data_from_db(Clauses, {'clause_id': 11})
clause_result = sqlalchemy_orm.get_item_from_db(
Clauses, {'clause_id': 11})
clause_point_result = sqlalchemy_orm.get_item_from_db(
ClausePoints, {'clause_id': 11})
# Check if result is empty
self.assertEqual(clause_result, [])
self.assertEqual(clause_point_result, [])
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_delete_clause(self):
with app.app_context():
try:
resp = self.app.delete('/api/clauses/2')
data = json.loads(resp.data)
self.assertEqual(resp.status_code, 200)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_get_notes(self):
with app.app_context():
try:
resp = self.app.get('/api/notes')
data = json.loads(resp.data)
self.assertIsInstance(data['notes'], list)
self.assertNotEqual(len(data['notes']), 0)
self.assertEqual(resp.status_code, 200)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def delete(self, note_id):
if isinstance(note_id, str):
if not note_id.isdigit():
return custom_error.BadRequestError().to_dict(), 400
note_id = int(note_id)
if note_id < 1:
return custom_error.BadRequestError().to_dict(), 400
try:
deleted_note = sqlalchemy_orm.delete_note_and_related_data_from_db(
note_id)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
else:
# 존재하지 않은 노트에 대한 처리
if not deleted_note:
return custom_error.BadRequestError().to_dict(), 400
return {'result': True}, 200
def get(self, **args):
try:
for key, value in request.args.items():
args[key] = value
except HTTPException:
error_message = util.traceback_custom_error()
response = custom_error.HTTPRequestError(error_message).to_dict()
return response, 400
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
try:
result = sqlalchemy_orm.get_item_from_db(
sqlalchemy_orm.ClausePoints, args)
if not result:
raise custom_error.BadRequestError
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except custom_error.BadRequestError:
response = custom_error.BadRequestError().to_dict()
return response, 400
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
else:
return {'note_id': args['note_id'], 'clause_points': result}, 200
def delete(self, clause_id):
if isinstance(clause_id, str):
if not clause_id.isdigit():
return custom_error.BadRequestError().to_dict(), 400
clause_id = int(clause_id)
try:
result = sqlalchemy_orm.delete_data_from_db(
sqlalchemy_orm.Clauses, {'clause_id': clause_id})
if not result:
raise custom_error.BadRequestError
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except custom_error.SQLAlchemyNotInsertError:
return custom_error.SQLAlchemyNotInsertError().to_dict(), 500
except custom_error.BadRequestError:
return custom_error.BadRequestError().to_dict(), 500
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
try:
result = result[0]
clause_id = getattr(result, 'clause_id')
return {'clause_id': clause_id}, 200
except AttributeError:
error_message = util.traceback_custom_error()
custom_error.AttributeError(error_message).to_dict()
return {'clause_id': None}, 201
def test_insert_clausePoints_db(self):
with app.app_context():
try:
clausePoints = sqlalchemy_orm.ClausePoints
# column = ['clause_id', 'note_id', 'imp', 'und']
clausepoints_id = sqlalchemy_orm.insert_data_to_db(
"ClausePoints", clausePoints(1, 1))
self.assertIsNotNone(clausepoints_id)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_put_clausepoint(self):
with app.app_context():
try:
data = {'imp': 1, 'und': 1}
resp = self.app.put('/api/clausePoints/1',
data=data,
content_type='multipart/form-data')
data = json.loads(resp.data)
self.assertEqual(resp.status_code, 200)
self.assertIsNotNone(data['clause_point'])
self.assertNotEqual(len(data['clause_point']), 0)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_insert_note_db(self):
with app.app_context():
try:
Notes = sqlalchemy_orm.Notes
note_id = sqlalchemy_orm.insert_data_to_db(
'Notes', Notes('test_title_1'))
self.assertIsNotNone(note_id)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_insert_clause_db(self):
with app.app_context():
try:
Clauses = sqlalchemy_orm.Clauses
clauses_id = sqlalchemy_orm.insert_data_to_db(
'Clauses', Clauses(1, "test_clause_1", "test_content_1"))
self.assertIsNotNone(clauses_id)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def put(self, clause_id):
try:
update_data = {}
for key, value in request.form.items():
update_data[key] = value
except HTTPException:
error_message = util.traceback_custom_error()
response = custom_error.HTTPRequestError(error_message).to_dict()
return response, 400
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
try:
clause_point = sqlalchemy_orm.update_data_to_db(
sqlalchemy_orm.ClausePoints, {'clause_id': clause_id},
update_data)
if not clause_point:
raise custom_error.BadRequestError
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except custom_error.BadRequestError:
response = custom_error.BadRequestError().to_dict()
return response, 400
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
else:
return {'clause_id': clause_id, 'clause_point': clause_point}, 200
def test_post_note(self):
with app.app_context():
try:
data = {
'studi_material':
open('../studi/uploads/studi_test_file.csv', 'rb')
}
resp = self.app.post('/api/notes',
data=data,
content_type='multipart/form-data')
data = json.loads(resp.data)
self.assertEqual(data['result'], True)
self.assertEqual(resp.status_code, 200)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_select_clauses_by_note_id(self):
with app.app_context():
try:
result = sqlalchemy_orm.get_item_from_db(
Clauses, {'note_id': 1})
self.assertIsNotNone(result)
self.assertIsInstance(result, list)
self.assertNotEqual(len(result), 0)
self.assertEqual(result[0]['note_id'], 1)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def test_select_all_notes(self):
with app.app_context():
try:
result = None
result = sqlalchemy_orm.get_all_data_from_db(Notes)
self.assertIsNotNone(result)
self.assertIsInstance(result, list)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def get(self):
try:
result = sqlalchemy_orm.get_all_data_from_db(sqlalchemy_orm.Notes)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
else:
if result:
return {'notes': result}, 200
return {'notes': []}, 201
def test_get_clausepoints(self):
with app.app_context():
try:
# update for testing
sqlalchemy_orm.update_data_to_db(sqlalchemy_orm.ClausePoints,
{'clause_id': 7}, {
'imp': 0,
'und': 1
})
sqlalchemy_orm.update_data_to_db(sqlalchemy_orm.ClausePoints,
{'clause_id': 6}, {
'imp': 1,
'und': 1
})
sqlalchemy_orm.update_data_to_db(sqlalchemy_orm.ClausePoints,
{'clause_id': 5}, {
'imp': 1,
'und': 1
})
params = {'imp': 1, 'und': 1}
resp = self.app.get('/api/notes/2/clausePoints',
query_string=params)
data = json.loads(resp.data)
self.assertEqual(resp.status_code, 200)
self.assertIsNotNone(data['clause_points'])
self.assertNotEqual(len(data['clause_points']), 0)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
def post(self):
try:
note_id = request.form['note_id']
title = request.form['title']
contents = request.form['contents']
if not note_id or not title or not contents:
return custom_error.BadRequestError().to_dict(), 400
if isinstance(note_id, str):
if not note_id.isdigit():
return custom_error.BadRequestError().to_dict(), 400
note_id = int(note_id)
if note_id < 1:
return custom_error.BadRequestError().to_dict(), 400
new_clause_id = sqlalchemy_orm.insert_data_to_db('Clauses', \
sqlalchemy_orm.Clauses(note_id, \
title, \
contents))
if not new_clause_id:
raise custom_error.SQLAlchemyNotInsertError
except HTTPException:
error_message = util.traceback_custom_error()
response = custom_error.HTTPRequestError(error_message).to_dict()
return response, 400
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except custom_error.SQLAlchemyNotInsertError:
return custom_error.SQLAlchemyNotInsertError().to_dict(), 500
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
else:
return {
'clause_id': new_clause_id,
'title': title,
'contents': contents
}, 200
def post(self):
try:
request_file = request.files['studi_material']
file_name = request_file.filename.split('/').pop()
except HTTPException:
error_message = util.traceback_custom_error()
response = custom_error.HTTPRequestError(error_message).to_dict()
return response, 400
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 400
# Cross-site scripting (XSS)
if file_name[-3:] != "csv":
return custom_error.NotCSVFileError(file_name).to_dict(), 400
try:
csvfile = request_file.read().decode("utf-8").splitlines()
# empty csv file
if not csvfile:
return custom_error.CSVError(
'csv file is empty'.format(csvfile)).to_dict(), 400
note = csv.DictReader(csvfile)
except csv.Error:
error_message = util.traceback_custom_error()
return custom_error.CSVError(error_message).to_dict(), 400
try:
new_note_id = upload.save_csv_contents_to_db(
file_name[:-4], note, True)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
else:
return {'result': True}, 200
def put(self, note_id):
if isinstance(note_id, str):
if not note_id.isdigit():
return custom_error.BadRequestError().to_dict(), 400
note_id = int(note_id)
if note_id < 1:
return custom_error.BadRequestError().to_dict(), 400
try:
new_note_name = request.form['new_note_name']
except HTTPException:
error_message = util.traceback_custom_error()
response = custom_error.HTTPRequestError(error_message).to_dict()
return response, 400
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 400
# note_name is not empty
if not new_note_name:
return custom_error.BadRequestError().to_dict(), 400
try:
sqlalchemy_orm.update_data_to_db(sqlalchemy_orm.Notes,
{'note_id': note_id},
{'note_name': new_note_name})
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
else:
return {'result': True}, 200
def get(self, clause_id):
if isinstance(clause_id, str):
if not clause_id.isdigit():
return custom_error.BadRequestError().to_dict(), 400
clause_id = int(clause_id)
if clause_id < 1:
return custom_error.BadRequestError().to_dict(), 400
try:
result = sqlalchemy_orm.get_item_from_db(sqlalchemy_orm.Clauses,
{'clause_id': clause_id})
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
response = custom_error.SQLAlchemyError(error_message).to_dict()
return response, 500
except:
error_message = util.traceback_custom_error()
response = custom_error.UnExpectedError(error_message).to_dict()
return response, 500
if result:
return {'clause': result}, 200
return {'clause': []}, 201
def test_insert_csv_to_db(self):
with app.app_context():
if os.path.exists('../studi/uploads/studi_test_files.csv'):
try:
note_id = upload.insert_csv_to_db()
self.assertIsNotNone(note_id)
except sqlalchemy.exc.SQLAlchemyError:
error_message = util.traceback_custom_error()
error = custom_error.SQLAlchemyError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except AssertionError:
error_message = util.traceback_custom_error()
error = custom_error.AssertionError(error_message)
error.set_logger(logger)
error.to_dict()
raise
except:
error_message = util.traceback_custom_error()
error = custom_error.UnExpectedError(error_message)
error.set_logger(logger)
error.to_dict()
raise
