def convert_answers_to_data(answer_store, questionnaire_json, routing_path):
"""
Convert answers into the data format below
"data": {
"001": "01-01-2016",
"002": "30-03-2016"
}
:param answer_store: questionnaire answers
:param questionnaire_json: The survey json
:param routing_path: the path followed in the questionnaire
:return: data in a formatted form
"""
data = OrderedDict()
for location in routing_path:
answers_in_block = answer_store.filter(location=location)
block_json = SchemaHelper.get_block(questionnaire_json, location.block_id)
answer_schema_list = SchemaHelper.get_answers_by_id_for_block(block_json)
for answer in answers_in_block:
answer_schema = answer_schema_list[answer['answer_id']]
value = answer['value']
if answer_schema is not None and value is not None:
if answer_schema['type'] != 'Checkbox' or any('q_code' not in option for option in answer_schema['options']):
data[answer_schema['q_code']] = _get_answer_data(data, answer_schema['q_code'], value)
else:
data.update(_get_checkbox_answer_data(answer_schema, value))
return data
def test_get_form_deserialises_month_year_dates(self):
survey = load_schema_file("test_dates.json")
block_json = SchemaHelper.get_block(survey, "date-block")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(
block_json, location,
AnswerStore([{
'answer_id': 'month-year-answer',
'group_id': 'a23d36db-6b07-4ce0-94b2-a843369511e3',
'group_instance': 0,
'block_id': 'date-block',
'value': '05/2015',
'answer_instance': 0,
}]), error_messages)
self.assertTrue(hasattr(form, "month-year-answer"))
month_year_field = getattr(form, "month-year-answer")
self.assertEquals(month_year_field.data, {
'month': '5',
'year': '2015',
})
def test_form_date_range_populates_data(self):
with self.test_request_context():
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
error_messages = SchemaHelper.get_messages(survey)
data = {
'period-from-day': '01',
'period-from-month': '3',
'period-from-year': '2016',
'period-to-day': '31',
'period-to-month': '3',
'period-to-year': '2016'
}
expected_form_data = {
'csrf_token': '',
'period-from': {
'day': '01',
'month': '3',
'year': '2016'
},
'period-to': {
'day': '31',
'month': '3',
'year': '2016'
}
}
form = generate_form(block_json, data, error_messages)
self.assertEqual(form.data, expected_form_data)
def setUp(self):
super().setUp()
survey = load_schema_file("census_household.json")
self.block_json = SchemaHelper.get_block(survey,
'household-composition')
self.error_messages = SchemaHelper.get_messages(survey)
def test_post_form_for_radio_other_selected(self):
with self.test_request_context():
survey = load_schema_file("test_radio.json")
block_json = SchemaHelper.get_block(survey, 'radio-mandatory')
location = Location('radio', 0, 'radio-mandatory')
error_messages = SchemaHelper.get_messages(survey)
answer_store = AnswerStore([{
'answer_id': 'radio-mandatory-answer',
'block_id': 'radio-mandatory',
'value': 'Other',
'answer_instance': 0,
}, {
'answer_id': 'other-answer-mandatory',
'block_id': 'block-1',
'value': 'Other text field value',
'answer_instance': 0,
}])
radio_answer = SchemaHelper.get_first_answer_for_block(block_json)
text_answer = 'other-answer-mandatory'
form, _ = post_form_for_location(
block_json, location, answer_store,
MultiDict({
'{answer_id}'.format(answer_id=radio_answer['id']):
'Other',
'{answer_id}'.format(answer_id=text_answer):
'Other text field value',
}), error_messages)
other_text_field = getattr(form, 'other-answer-mandatory')
self.assertEqual(other_text_field.data, 'Other text field value')
def test_generate_relationship_form_errors_are_correctly_mapped(self):
with self.test_request_context():
survey = load_schema_file("test_relationship_household.json")
block_json = SchemaHelper.get_block(survey, 'relationships')
error_messages = SchemaHelper.get_messages(survey)
answer = SchemaHelper.get_first_answer_for_block(block_json)
generated_form = generate_relationship_form(
block_json, 3, None, error_messages=error_messages)
form = generate_relationship_form(
block_json,
3, {
'csrf_token': generated_form.csrf_token.current_token,
'{answer_id}-0'.format(answer_id=answer['id']): '1',
'{answer_id}-1'.format(answer_id=answer['id']): '3',
},
error_messages=error_messages)
form.validate()
mapped_errors = form.map_errors()
message = "Not a valid choice"
self.assertTrue(
self._error_exists(answer['id'], message, mapped_errors))
def test_generate_relationship_form_creates_form_from_data(self):
with self.test_request_context():
survey = load_schema_file("test_relationship_household.json")
block_json = SchemaHelper.get_block(survey, 'relationships')
error_messages = SchemaHelper.get_messages(survey)
answer = SchemaHelper.get_first_answer_for_block(block_json)
form = generate_relationship_form(
block_json,
3, {
'{answer_id}-0'.format(answer_id=answer['id']):
'Husband or Wife',
'{answer_id}-1'.format(answer_id=answer['id']):
'Brother or Sister',
'{answer_id}-2'.format(answer_id=answer['id']):
'Relation - other',
},
error_messages=error_messages)
self.assertTrue(hasattr(form, answer['id']))
expected_form_data = [
'Husband or Wife', 'Brother or Sister', 'Relation - other'
]
self.assertEqual(form.data[answer['id']], expected_form_data)
def test_post_form_for_household_composition(self):
survey = load_schema_file("census_household.json")
block_json = SchemaHelper.get_block(survey, 'household-composition')
location = Location('who-lives-here', 0, 'household-composition')
error_messages = SchemaHelper.get_messages(survey)
form, _ = post_form_for_location(
block_json, location, AnswerStore(), {
'household-0-first-name': 'Joe',
'household-0-last-name': '',
'household-1-first-name': 'Bob',
'household-1-last-name': 'Seymour',
}, error_messages)
self.assertEqual(len(form.household.entries), 2)
self.assertEqual(form.household.entries[0].data, {
'first-name': 'Joe',
'middle-names': '',
'last-name': ''
})
self.assertEqual(form.household.entries[1].data, {
'first-name': 'Bob',
'middle-names': '',
'last-name': 'Seymour'
})
def setUp(self):
self.app = create_app()
self.app.config['SERVER_NAME'] = "test"
self.app_context = self.app.app_context()
self.app_context.push()
survey = load_schema_file("census_household.json")
self.block_json = SchemaHelper.get_block(survey, 'household-composition')
self.error_messages = SchemaHelper.get_messages(survey)
def test_form_ids_match_block_answer_ids(self):
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json, {}, error_messages)
for answer in SchemaHelper.get_answers_for_block(block_json):
self.assertTrue(hasattr(form, answer['id']))
def test_option_has_other(self):
with self.test_request_context():
survey = load_schema_file("test_checkbox.json")
block_json = SchemaHelper.get_block(survey, "mandatory-checkbox")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json, {}, error_messages)
self.assertFalse(
form.option_has_other("mandatory-checkbox-answer", 1))
self.assertTrue(
form.option_has_other("mandatory-checkbox-answer", 6))
def test_generate_relationship_form_creates_empty_form(self):
survey = load_schema_file("test_relationship_household.json")
block_json = SchemaHelper.get_block(survey, 'relationships')
error_messages = SchemaHelper.get_messages(survey)
answer = SchemaHelper.get_first_answer_for_block(block_json)
form = generate_relationship_form(block_json,
3, {},
error_messages=error_messages)
self.assertTrue(hasattr(form, answer['id']))
self.assertEqual(len(form.data[answer['id']]), 3)
def test_generate_month_year_date_form_creates_empty_form(self):
survey = load_schema_file("test_dates.json")
block_json = SchemaHelper.get_block(survey, 'date-block')
error_messages = SchemaHelper.get_messages(survey)
answers = SchemaHelper.get_answers_by_id_for_block(block_json)
form = get_month_year_form(answers['month-year-answer'],
error_messages=error_messages)
self.assertFalse(hasattr(form, 'day'))
self.assertTrue(hasattr(form, 'month'))
self.assertTrue(hasattr(form, 'year'))
def test_get_other_answer_invalid(self):
with self.test_request_context():
survey = load_schema_file("test_checkbox.json")
block_json = SchemaHelper.get_block(survey, "mandatory-checkbox")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json,
{"other-answer-mandatory": "Some data"},
error_messages)
field = form.get_other_answer("mandatory-checkbox-answer", 4)
self.assertEqual(None, field)
def test_answer_with_child_inherits_mandatory_from_parent(self):
with self.test_request_context():
survey = load_schema_file("test_radio.json")
block_json = SchemaHelper.get_block(survey, "radio-mandatory")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json,
{'radio-mandatory-answer': 'Other'},
error_messages)
child_field = getattr(form, 'other-answer-mandatory')
self.assertIsInstance(child_field.validators[0], ResponseRequired)
def test_get_parent_options_for_block(self):
survey = load_schema_file("test_checkbox.json")
block_json = SchemaHelper.get_block(survey, 'mandatory-checkbox')
parent_options = SchemaHelper.get_parent_options_for_block(block_json)
expected = {
'mandatory-checkbox-answer': {
'index': 6,
'child_answer_id': 'other-answer-mandatory'
}
}
self.assertEqual(parent_options, expected)
def test_answer_with_child_inherits_mandatory_from_parent(self):
survey = load_schema_file("test_radio.json")
block_json = SchemaHelper.get_block(survey, "block-1")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json,
{'ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c': 'Other'},
error_messages)
child_field = getattr(form, 'other-answer-mandatory')
self.assertIsInstance(child_field.validators[0],
validators.InputRequired)
def test_get_form_for_household_relationship(self):
with self.test_request_context():
survey = load_schema_file("census_household.json")
block_json = SchemaHelper.get_block(survey,
'household-relationships')
location = Location('who-lives-here-relationship', 0,
'household-relationships')
error_messages = SchemaHelper.get_messages(survey)
answer_store = AnswerStore([{
'group_id': 'who-lives-here-relationship',
'group_instance': 0,
'answer_id': 'first-name',
'block_id': 'household-composition',
'value': 'Joe',
'answer_instance': 0,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 0,
'answer_id': 'last-name',
'block_id': 'household-composition',
'value': 'Bloggs',
'answer_instance': 0,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 1,
'answer_id': 'first-name',
'block_id': 'household-composition',
'value': 'Jane',
'answer_instance': 1,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 1,
'answer_id': 'last-name',
'block_id': 'household-composition',
'value': 'Bloggs',
'answer_instance': 1,
}])
form, _ = get_form_for_location(block_json, location, answer_store,
error_messages)
answer = SchemaHelper.get_first_answer_for_block(block_json)
self.assertTrue(hasattr(form, answer['id']))
field_list = getattr(form, answer['id'])
# With two people, we need to define 1 relationship
self.assertEqual(len(field_list.entries), 1)
def test_post_form_for_household_relationship(self):
with self.test_request_context():
survey = load_schema_file("census_household.json")
block_json = SchemaHelper.get_block(survey,
'household-relationships')
location = Location('who-lives-here-relationship', 0,
'household-relationships')
error_messages = SchemaHelper.get_messages(survey)
answer_store = AnswerStore([{
'answer_id': 'first-name',
'block_id': 'household-composition',
'value': 'Joe',
'answer_instance': 0,
}, {
'answer_id': 'last-name',
'block_id': 'household-composition',
'value': 'Bloggs',
'answer_instance': 0,
}, {
'answer_id': 'first-name',
'block_id': 'household-composition',
'value': 'Jane',
'answer_instance': 1,
}, {
'answer_id': 'last-name',
'block_id': 'household-composition',
'value': 'Bloggs',
'answer_instance': 1,
}])
answer = SchemaHelper.get_first_answer_for_block(block_json)
form, _ = post_form_for_location(
block_json, location, answer_store,
MultiDict(
{'{answer_id}-0'.format(answer_id=answer['id']): '3'}),
error_messages)
self.assertTrue(hasattr(form, answer['id']))
field_list = getattr(form, answer['id'])
# With two people, we need to define 1 relationship
self.assertEqual(len(field_list.entries), 1)
# Check the data matches what was passed from request
self.assertEqual(field_list.entries[0].data, "3")
def test_answer_errors_are_mapped(self):
survey = load_schema_file("1_0112.json")
block_json = SchemaHelper.get_block(survey, "total-retail-turnover")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json,
{'total-retail-turnover-answer': "-1"},
error_messages)
form.validate()
answer_errors = form.answer_errors('total-retail-turnover-answer')
self.assertIn(
"The value cannot be negative. Please correct your answer.",
answer_errors)
def test_form_errors_are_correctly_mapped(self):
survey = load_schema_file("1_0112.json")
block_json = SchemaHelper.get_block(survey, "total-retail-turnover")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json, {}, error_messages)
form.validate()
mapped_errors = form.map_errors()
message = "Please provide a value, even if your value is 0."
self.assertTrue(
self._error_exists('total-retail-turnover-answer', message,
mapped_errors))
def test_form_subfield_errors_are_correctly_mapped(self):
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json, {}, error_messages)
message = "Please provide an answer to continue."
form.validate()
mapped_errors = form.map_errors()
self.assertTrue(self._error_exists('period-to', message,
mapped_errors))
self.assertTrue(
self._error_exists('period-from', message, mapped_errors))
def test_get_form_for_household_composition(self):
survey = load_schema_file("census_household.json")
block_json = SchemaHelper.get_block(survey, 'household-composition')
location = Location('who-lives-here', 0, 'household-composition')
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(block_json, location, AnswerStore(),
error_messages)
self.assertTrue(hasattr(form, "household"))
self.assertEquals(len(form.household.entries), 1)
first_field_entry = form.household[0]
self.assertTrue(hasattr(first_field_entry, "first-name"))
self.assertTrue(hasattr(first_field_entry, "middle-names"))
self.assertTrue(hasattr(first_field_entry, "last-name"))
def test_get_form_deserialises_dates(self):
with self.test_request_context():
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
location = Location('rsi', 0, 'reporting-period')
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(
block_json, location,
AnswerStore([{
'answer_id': 'period-from',
'group_id': 'rsi',
'group_instance': 0,
'block_id': 'reporting-period',
'value': '01/05/2015',
'answer_instance': 0,
}, {
'answer_id': 'period-to',
'group_id': 'rsi',
'group_instance': 0,
'block_id': 'reporting-period',
'value': '01/09/2017',
'answer_instance': 0,
}]), error_messages)
self.assertTrue(hasattr(form, "period-to"))
self.assertTrue(hasattr(form, "period-from"))
period_to_field = getattr(form, "period-to")
period_from_field = getattr(form, "period-from")
self.assertEqual(period_from_field.data, {
'day': '01',
'month': '5',
'year': '2015',
})
self.assertEqual(period_to_field.data, {
'day': '01',
'month': '9',
'year': '2017',
})
def test_get_form_for_block_location(self):
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(block_json, location, AnswerStore(),
error_messages)
self.assertTrue(hasattr(form, "period-to"))
self.assertTrue(hasattr(form, "period-from"))
period_from_field = getattr(form, "period-from")
period_to_field = getattr(form, "period-to")
self.assertIsInstance(period_from_field.day.validators[0],
DateRequired)
self.assertIsInstance(period_to_field.day.validators[0], DateRequired)
def test_answer_with_child_errors_are_correctly_mapped(self):
survey = load_schema_file("test_radio.json")
block_json = SchemaHelper.get_block(survey, "block-1")
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json,
{'ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c': 'Other'},
error_messages)
form.validate()
mapped_errors = form.map_errors()
message = "This field is mandatory."
self.assertTrue(
self._error_exists("ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c", message,
mapped_errors))
self.assertFalse(
self._error_exists("other-answer-mandatory", message,
mapped_errors))
def test_answer_with_child_errors_are_correctly_mapped(self):
with self.test_request_context():
survey = load_schema_file("test_radio.json")
block_json = SchemaHelper.get_block(survey, 'radio-mandatory')
error_messages = SchemaHelper.get_messages(survey)
form = generate_form(block_json,
{'radio-mandatory-answer': 'Other'},
error_messages)
form.validate()
mapped_errors = form.map_errors()
message = "This field is mandatory."
self.assertTrue(
self._error_exists("radio-mandatory-answer", message,
mapped_errors))
self.assertFalse(
self._error_exists("other-answer-mandatory", message,
mapped_errors))
def test_post_form_for_block_location(self):
with self.test_request_context():
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = post_form_for_location(
block_json, location, AnswerStore(), {
'period-from-day': '1',
'period-from-month': '05',
'period-from-year': '2015',
'period-to-day': '1',
'period-to-month': '09',
'period-to-year': '2017',
}, error_messages)
self.assertTrue(hasattr(form, "period-to"))
self.assertTrue(hasattr(form, "period-from"))
period_to_field = getattr(form, "period-to")
period_from_field = getattr(form, "period-from")
self.assertIsInstance(period_from_field.month.validators[0],
DateRequired)
self.assertIsInstance(period_to_field.month.validators[0],
DateRequired)
self.assertEqual(period_from_field.data, {
'day': '1',
'month': '05',
'year': '2015',
})
self.assertEqual(period_to_field.data, {
'day': '1',
'month': '09',
'year': '2017',
})
def test_get_form_deserialises_lists(self):
survey = load_schema_file("test_checkbox.json")
block_json = SchemaHelper.get_block(survey, "block-1")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(
block_json, location,
AnswerStore([{
'answer_id': 'ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c',
'group_id': '14ba4707-321d-441d-8d21-b8367366e761',
'group_instance': 0,
'block_id': 'block-1',
'value': ['Cheese', 'Ham'],
'answer_instance': 0,
}]), error_messages)
self.assertTrue(hasattr(form, "ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c"))
checkbox_field = getattr(form, "ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c")
self.assertEquals(checkbox_field.data, ['Cheese', 'Ham'])
def test_date_range_to_precedes_from_raises_question_error(self):
with self.test_request_context():
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
error_messages = SchemaHelper.get_messages(survey)
data = {
'period-from-day': '25',
'period-from-month': '12',
'period-from-year': '2016',
'period-to-day': '24',
'period-to-month': '12',
'period-to-year': '2016'
}
expected_form_data = {
'csrf_token': '',
'period-from': {
'day': '25',
'month': '12',
'year': '2016'
},
'period-to': {
'day': '24',
'month': '12',
'year': '2016'
}
}
form = generate_form(block_json, data, error_messages)
expected_message = "The 'period to' date cannot be before the 'period from' date."
form.validate()
self.assertEqual(form.data, expected_form_data)
self.assertEqual(form.question_errors['reporting-period-question'],
expected_message)
