def testQuestionChoiceInsert(self):
survey_id = connection.execute(
survey_table.select().where(
survey_table.c.survey_title == 'test_title'
)).first().survey_id
seq_number = get_free_sequence_number(connection, survey_id)
stmt = question_insert(hint=None, allow_multiple=None,
logic={
'required': False,
'allow_other': False,
'allow_dont_know': False
},
sequence_number=seq_number,
question_title='test choice',
type_constraint_name='multiple_choice',
question_to_sequence_number=-1,
survey_id=survey_id)
question_id = connection.execute(stmt).inserted_primary_key[0]
c_stmt = question_choice_insert(question_id=question_id,
choice='test choice',
choice_number=1,
type_constraint_name='multiple_choice',
question_sequence_number=seq_number,
allow_multiple=False,
survey_id=survey_id)
choice_id = connection.execute(c_stmt).inserted_primary_key[0]
cond = question_choice_table.c.question_id == question_id
self.assertEqual(connection.execute(
question_choice_table.select().where(cond)
).first().question_choice_id, choice_id)
def testQuestionBranchInsert(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
to_question = get_questions_no_credentials(
connection, survey_id).fetchall()[-1]
q_where = question_table.select().where(
cast(cast(question_table.c.logic['allow_other'], Text),
Boolean))
from_question = connection.execute(q_where).fetchall()[0]
choice = get_choices(
connection, from_question.question_id).fetchall()[0]
from_tcn = from_question.type_constraint_name
branch_dict = {'question_choice_id': choice.question_choice_id,
'from_question_id': from_question.question_id,
'from_type_constraint': from_tcn,
'from_sequence_number':
from_question.sequence_number,
'from_allow_multiple':
from_question.allow_multiple,
'from_survey_id': survey_id,
'to_question_id': to_question.question_id,
'to_type_constraint':
to_question.type_constraint_name,
'to_sequence_number':
to_question.sequence_number,
'to_allow_multiple': to_question.allow_multiple,
'to_survey_id': survey_id}
branch_exec = connection.execute(question_branch_insert(**branch_dict))
inserted_id = branch_exec.inserted_primary_key[0]
the_branch = connection.execute(question_branch_table.select().where(
question_branch_table.c.question_branch_id ==
inserted_id)).first()
self.assertEqual(the_branch.to_question_id,
to_question.question_id)
def testQuestionSelect(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
question_id = get_questions_no_credentials(
connection, survey_id).first().question_id
question = question_select(connection, question_id)
self.assertEqual(question.question_id, question_id)
def testInsertFacility(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
q_where = question_table.select().where(
question_table.c.type_constraint_name == 'facility')
question = connection.execute(q_where).first()
question_id = question.question_id
tcn = question.type_constraint_name
seq = question.sequence_number
mul = question.allow_multiple
submission_exec = connection.execute(
submission_insert(submitter='test_submitter',
submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
answer_exec = connection.execute(answer_insert(
answer={'id': 'revisit ID', 'lon': 90, 'lat': 0},
answer_metadata={'facility_name': 'cool facility',
'facility_sector': 'health'},
question_id=question_id,
submission_id=submission_id,
survey_id=survey_id,
type_constraint_name=tcn,
is_type_exception=False,
sequence_number=seq,
allow_multiple=mul))
answer_id = answer_exec.inserted_primary_key[0]
self.assertIsNotNone(answer_id)
condition = answer_table.c.answer_id == answer_id
answer = connection.execute(
answer_table.select().where(condition)).first()
location = get_geo_json(connection, answer)['coordinates']
self.assertEqual(location, [90, 0])
facility_id = answer.answer_text
self.assertEqual(facility_id, 'revisit ID')
def testGetSubmissionsByEmail(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
for i in range(2):
connection.execute(submission_insert(
submitter='test_submitter{}'.format(i),
submitter_email='*****@*****.**', survey_id=survey_id))
submissions = get_submissions_by_email(
connection, 'test_email', survey_id=survey_id
)
self.assertEqual(submissions.rowcount, 2)
submissions = get_submissions_by_email(
connection,
'test_email',
survey_id=survey_id,
submitters=['test_submitter1']
)
self.assertEqual(submissions.rowcount, 1)
submissions = get_submissions_by_email(
connection,
'test_email',
survey_id=survey_id,
order_by='submitter', direction='desc'
)
self.assertEqual(
submissions.first()['submitter'],
'test_submitter1'
)
def testGetAnswerChoicesForChoiceId(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
q_where = question_table.select().where(
question_table.c.type_constraint_name == 'multiple_choice')
question = connection.execute(q_where).first()
question_id = question.question_id
tcn = question.type_constraint_name
seq = question.sequence_number
mul = question.allow_multiple
submission_exec = connection.execute(
submission_insert(submitter='test_submitter',
submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
choices = get_choices(connection, question_id)
the_choice = choices.first()
connection.execute(answer_choice_insert(
question_choice_id=the_choice.question_choice_id,
answer_choice_metadata={},
question_id=question_id,
submission_id=submission_id,
survey_id=survey_id, type_constraint_name=tcn, sequence_number=seq,
allow_multiple=mul))
gacfci = get_answer_choices_for_choice_id
actual_choices = gacfci(connection, the_choice.question_choice_id)
self.assertEqual(actual_choices.rowcount, 1)
def testAnswerChoiceInsertNoMetadata(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
q_where = question_table.select().where(
question_table.c.type_constraint_name == 'multiple_choice')
question = connection.execute(q_where).first()
question_id = question.question_id
tcn = question.type_constraint_name
seq = question.sequence_number
mul = question.allow_multiple
submission_exec = connection.execute(submission_insert(
submitter='test_submitter', submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
choices = get_choices(connection, question_id)
the_choice = choices.first()
exec_stmt = connection.execute(answer_choice_insert(
question_choice_id=the_choice.question_choice_id,
answer_choice_metadata=None,
question_id=question_id,
submission_id=submission_id,
survey_id=survey_id, type_constraint_name=tcn, sequence_number=seq,
allow_multiple=mul))
answer_id = exec_stmt.inserted_primary_key[0]
self.assertIsNotNone(answer_id)
def testGetAnswersForQuestion(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
q_where = question_table.select().where(
question_table.c.type_constraint_name == 'integer')
question = connection.execute(q_where).first()
question_id = question.question_id
tcn = question.type_constraint_name
seq = question.sequence_number
mul = question.allow_multiple
submission_exec = connection.execute(
submission_insert(submitter='test_submitter',
submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
connection.execute(answer_insert(answer=1, question_id=question_id,
answer_metadata={},
submission_id=submission_id,
survey_id=survey_id,
type_constraint_name=tcn,
is_type_exception=False,
sequence_number=seq,
allow_multiple=mul))
self.assertEqual(
get_answers_for_question(connection, question_id).rowcount, 1)
def testAnswerInsertNoMetadata(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
q_where = question_table.select().where(
question_table.c.type_constraint_name == 'integer')
question = connection.execute(q_where).first()
question_id = question.question_id
tcn = question.type_constraint_name
seq = question.sequence_number
mul = question.allow_multiple
submission_exec = connection.execute(
submission_insert(submitter='test_submitter',
submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
answer_exec = connection.execute(answer_insert(
answer=1, question_id=question_id,
answer_metadata=None,
submission_id=submission_id,
survey_id=survey_id,
type_constraint_name=tcn,
is_type_exception=False,
sequence_number=seq,
allow_multiple=mul))
answer_id = answer_exec.inserted_primary_key[0]
self.assertIsNotNone(answer_id)
def testDisplay(self):
survey = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first()
self.assertEqual(survey.survey_title,
display(connection,
survey.survey_id).survey_title)
self.assertRaises(SurveyDoesNotExistError, display, connection,
str(uuid.uuid4()))
def tearDown(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
to_question = get_questions_no_credentials(
connection, survey_id).fetchall()[-1]
connection.execute(question_branch_table.delete().where(
question_branch_table.c.to_question_id ==
to_question.question_id))
def testGetSurveyIdFromPrefix(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
self.assertEqual(
get_survey_id_from_prefix(connection, survey_id[:10]),
survey_id)
self.assertRaises(SurveyPrefixDoesNotIdentifyASurveyError,
get_survey_id_from_prefix, connection,
str(uuid.uuid4()))
def testGetSurveysForUserByEmail(self):
user = connection.execute(auth_user_table.select().where(
auth_user_table.c.email == 'test_email')).first()
condition = survey_table.c.auth_user_id == user.auth_user_id
surveys = connection.execute(survey_table.select().where(
condition)).fetchall()
surveys_by_email = get_surveys_by_email(connection, user.email)
self.assertEqual(len(surveys), len(surveys_by_email))
self.assertEqual(surveys[0].survey_id,
surveys_by_email[0].survey_id)
def testSurveyInsert(self):
auth_user_id = connection.execute(auth_user_table.select().where(
auth_user_table.c.email == 'test_email')).first().auth_user_id
stmt = survey_insert(survey_title='test insert',
survey_metadata=None,
auth_user_id=auth_user_id)
survey_id = connection.execute(stmt).inserted_primary_key[0]
condition = survey_table.c.survey_title == 'test insert'
get_stmt = connection.execute(
survey_table.select().where(condition)).first()
self.assertEqual(get_stmt.survey_id, survey_id)
def testInsertLocation(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
q_where = question_table.select().where(
question_table.c.type_constraint_name == 'location')
question = connection.execute(q_where).first()
question_id = question.question_id
tcn = question.type_constraint_name
seq = question.sequence_number
mul = question.allow_multiple
submission_exec = connection.execute(submission_insert(
submitter='test_submitter', submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
answer_exec = connection.execute(answer_insert(
answer={'lon': 90, 'lat': 0},
answer_metadata={},
question_id=question_id,
submission_id=submission_id,
survey_id=survey_id,
type_constraint_name=tcn,
is_type_exception=False,
sequence_number=seq,
allow_multiple=mul))
answer_id = answer_exec.inserted_primary_key[0]
self.assertIsNotNone(answer_id)
condition = answer_table.c.answer_id == answer_id
answer = connection.execute(
answer_table.select().where(condition)).first()
location = get_geo_json(connection, answer)['coordinates']
self.assertEqual(location, [90, 0])
submission_2_exec = connection.execute(
submission_insert(submitter='test_submitter',
submitter_email='*****@*****.**',
survey_id=survey_id))
submission_2_id = submission_2_exec.inserted_primary_key[0]
answer_2_exec = connection.execute(answer_insert(
answer=None, question_id=question_id,
answer_metadata={},
submission_id=submission_2_id,
survey_id=survey_id,
type_constraint_name=tcn,
is_type_exception=False,
sequence_number=seq,
allow_multiple=mul))
answer_2_id = answer_2_exec.inserted_primary_key[0]
condition_2 = answer_table.c.answer_id == answer_2_id
answer_2 = connection.execute(
answer_table.select().where(condition_2)).first()
location_2 = get_geo_json(connection, answer_2)
self.assertEqual(location_2,
{'coordinates': [], 'type': 'MultiPoint'})
def testSubmissionInsert(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
submission_exec = connection.execute(submission_insert(
submitter='test_submitter', submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
sub_exec = connection.execute(submission_table.select().where(
submission_table.c.submission_id ==
submission_id))
submission = sub_exec.first()
self.assertEqual(submission_id, submission.submission_id)
def testGetNumberOfSubmissions(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
submission_exec = connection.execute(
submission_insert(submitter='test_submitter',
submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
connection.execute(submission_table.select().where(
submission_table.c.submission_id ==
submission_id))
self.assertEqual(get_number_of_submissions(connection, survey_id), 1)
def testUpdateRecord(self):
auth_user_id = connection.execute(auth_user_table.select().where(
auth_user_table.c.email == 'test_email')).first().auth_user_id
exec_stmt = connection.execute(survey_insert(
survey_title='update me',
survey_metadata={},
auth_user_id=auth_user_id))
survey_id = exec_stmt.inserted_primary_key[0]
connection.execute(update_record(survey_table, 'survey_id', survey_id,
survey_title='updated'))
condition = survey_table.c.survey_id == survey_id
new_record = connection.execute(
survey_table.select().where(condition)).first()
self.assertEqual(new_record.survey_title, 'updated')
self.assertNotEqual(new_record.survey_last_update_time,
new_record.created_on)
connection.execute(update_record(
survey_table, 'survey_id', survey_id,
values_dict={'survey_title': 'update2'}))
new_record = connection.execute(survey_table.select().where(
condition)).first()
self.assertEqual(new_record.survey_title, 'update2')
self.assertRaises(TypeError, update_record, survey_table,
'survey_id',
survey_id,
values_dict={'survey_title': 'updated2'},
survey_title='updated3')
self.assertRaises(TypeError, update_record, survey_table,
'survey_id',
survey_id)
connection.execute(delete_record(survey_table, 'survey_id', survey_id))
if __name__ == '__main__':
unittest.main()
def testDeleteRecord(self):
auth_user_id = connection.execute(auth_user_table.select().where(
auth_user_table.c.email == 'test_email')).first().auth_user_id
exec_stmt = connection.execute(survey_insert(
survey_title='delete me',
survey_metadata={},
auth_user_id=auth_user_id))
survey_id = exec_stmt.inserted_primary_key[0]
connection.execute(delete_record(survey_table, 'survey_id', survey_id))
condition = survey_table.c.survey_id == survey_id
self.assertEqual(
connection.execute(
survey_table.select().where(condition)).rowcount,
0)
def testNoLogic(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
sequence_number = get_free_sequence_number(connection,
survey_id)
with self.assertRaises(TypeError) as exc:
question_insert(hint=None,
allow_multiple=None,
logic=None,
sequence_number=sequence_number,
question_to_sequence_number=1,
question_title='test insert',
type_constraint_name='text',
survey_id=survey_id)
self.assertEqual(str(exc.exception), 'logic must not be None')
def testGetQuestions(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
questions = get_questions(connection, survey_id,
email='test_email')
self.assertGreater(questions.rowcount, 0)
auth_user_id = get_auth_user_by_email(connection,
'test_email').auth_user_id
questions = get_questions(connection, survey_id,
auth_user_id=auth_user_id)
self.assertGreater(questions.rowcount, 0)
self.assertRaises(TypeError, get_questions, connection, survey_id)
self.assertRaises(TypeError, get_questions, connection, survey_id,
auth_user_id='',
email='')
def testGetSubmissionsWithFilter(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
q_where = question_table.select().where(
question_table.c.type_constraint_name == 'integer')
question = connection.execute(q_where).first()
question_id = question.question_id
tcn = question.type_constraint_name
seq = question.sequence_number
mul = question.allow_multiple
for i in range(2):
submission_exec = connection.execute(submission_insert(
submitter='test_submitter',
submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
connection.execute(answer_insert(
answer=i,
question_id=question_id,
submission_id=submission_id,
answer_metadata={},
survey_id=survey_id,
type_constraint_name=tcn,
is_type_exception=False,
sequence_number=seq,
allow_multiple=mul))
self.assertEqual(
len(get_submissions_by_email(
connection,
'test_email',
survey_id=survey_id
).fetchall()),
2)
f_result = get_submissions_by_email(
connection,
'test_email',
survey_id=survey_id,
filters=[
{
'question_id': question_id,
'answer_integer': 1
}
]
).fetchall()
self.assertEqual(len(f_result), 1)
def testSurveySelect(self):
user = connection.execute(auth_user_table.select().where(
auth_user_table.c.email == 'test_email')).first()
survey = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first()
self.assertEqual(survey.survey_title,
survey_select(connection, survey.survey_id,
auth_user_id=user.auth_user_id)
.survey_title)
self.assertEqual(survey.survey_title,
survey_select(connection, survey.survey_id,
email=user.email).survey_title)
self.assertRaises(TypeError, survey_select, connection,
survey.survey_id,
auth_user_id=user.auth_user_id,
email=user.email)
self.assertRaises(TypeError, survey_select, connection,
survey.survey_id)
def testSubmissionSelect(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
submission_exec = connection.execute(
submission_insert(submitter='test_submitter',
submitter_email='*****@*****.**',
survey_id=survey_id))
submission_id = submission_exec.inserted_primary_key[0]
submission = submission_select(connection, submission_id,
email='test_email')
self.assertEqual(submission_id, submission.submission_id)
user_id = connection.execute(auth_user_table.select().where(
auth_user_table.c.email == 'test_email')).first().auth_user_id
submission2 = submission_select(connection, submission_id,
auth_user_id=user_id)
self.assertEqual(submission_id,
submission2.submission_id)
self.assertRaises(TypeError, submission_select, connection,
submission_id,
auth_user_id='', email='')
self.assertRaises(TypeError, submission_select, connection,
submission_id)
def testGetEmailAddress(self):
survey = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first()
self.assertEqual(
get_email_address(connection, survey.survey_id),
'test_email')
def testGetQuestionsNoCredentials(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
questions = get_questions_no_credentials(connection, survey_id)
self.assertGreater(questions.rowcount, 0)
def testGetFreeSequenceNumber(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'test_title')).first().survey_id
self.assertEqual(
get_free_sequence_number(connection, survey_id),
11)
def testGetRequired(self):
survey_id = connection.execute(survey_table.select().where(
survey_table.c.survey_title == 'what is life')).first().survey_id
reqs = get_required(connection, survey_id)
self.assertEqual(reqs.rowcount, 2)
