def test_converter_checkboxes_with_q_codes_and_empty_other_value(
fake_questionnaire_store, ):
routing_path = RoutingPath(["crisps"], section_id="food")
fake_questionnaire_store.answer_store = AnswerStore([
Answer("crisps-answer", ["Ready salted", "Other"]).to_dict(),
Answer("other-answer-mandatory", "").to_dict(),
])
question = {
"id":
"crisps-question",
"answers": [{
"id":
"crisps-answer",
"type":
"Checkbox",
"options": [
{
"label": "Ready salted",
"value": "Ready salted",
"q_code": "1"
},
{
"label": "Sweet chilli",
"value": "Sweet chilli",
"q_code": "2"
},
{
"label": "Cheese and onion",
"value": "Cheese and onion",
"q_code": "3",
},
{
"label": "Other",
"q_code": "4",
"description": "Choose any other flavour",
"value": "Other",
"detail_answer": {
"mandatory": True,
"id": "other-answer-mandatory",
"label": "Please specify other",
"type": "TextField",
},
},
],
}],
}
questionnaire = make_schema("0.0.1", "section-1", "favourite-food",
"crisps", question)
# When
answer_object = convert_answers(QuestionnaireSchema(questionnaire),
fake_questionnaire_store, routing_path)
# Then
assert len(answer_object["data"]) == 2
assert answer_object["data"]["1"] == "Ready salted"
assert answer_object["data"]["4"] == "Other"
def test_month_year_date_answer(fake_questionnaire_store):
full_routing_path = [RoutingPath(["date-block"], section_id="section-1")]
answers = AnswerStore(
[
Answer("single-date-answer", "01-01-1990").to_dict(),
Answer("month-year-answer", "01-1990").to_dict(),
]
)
fake_questionnaire_store.answer_store = answers
questionnaire = make_schema(
"0.0.3",
"section-1",
"date-group",
"date-block",
{
"id": "month-year-question",
"answers": [{"id": "month-year-answer", "type": "MonthYearDate"}],
},
)
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
assert len(answer_object["data"]["answers"]) == 1
assert answer_object["data"]["answers"][0].value == "01-1990"
def test_answer_source_not_on_path_non_repeating_section(is_answer_on_path):
schema = get_mock_schema()
location = Location(section_id="test-section", block_id="test-block")
if is_answer_on_path:
schema.get_block_for_answer_id = Mock(
return_value={"id": "block-on-path"})
answer_id = "answer-on-path"
expected_result = True
else:
schema.get_block_for_answer_id = Mock(
return_value={"id": "block-not-on-path"})
answer_id = "answer-not-on-path"
expected_result = False
answer = Answer(answer_id=answer_id, value="Yes")
rule_evaluator = get_rule_evaluator(
schema=schema,
answer_store=AnswerStore([answer.to_dict()]),
location=location,
routing_path_block_ids=["block-on-path"],
)
assert (rule_evaluator.evaluate(
rule={
Operator.EQUAL: [
"Yes",
{
"source": "answers",
"identifier": "answer-on-path"
},
]
}) == expected_result)
def test_answer_source_with_routing_path_block_ids_outside_repeat(
is_answer_on_path):
schema = get_mock_schema()
location = Location(section_id="test-section", block_id="test-block")
if is_answer_on_path:
schema.get_block_for_answer_id = Mock(
return_value={"id": f"block-on-path"})
answer_id = "answer-on-path"
expected_result = "Yes"
else:
schema.get_block_for_answer_id = Mock(
return_value={"id": f"block-not-on-path"})
answer_id = "answer-not-on-path"
expected_result = None
answer = Answer(answer_id=answer_id, value="Yes")
value_source_resolver = get_value_source_resolver(
schema=schema,
answer_store=AnswerStore([answer.to_dict()]),
list_store=ListStore([{
"name": "some-list",
"items": get_list_items(3)
}]),
location=location,
list_item_id=location.list_item_id,
routing_path_block_ids=["block-on-path"],
)
assert (value_source_resolver.resolve({
"source": "answers",
"identifier": "answer-on-path"
}) == expected_result)
def test_convert_answers_to_payload_0_0_3(fake_questionnaire_store):
full_routing_path = [
RoutingPath(["about you", "where you live"], section_id="household-section")
]
fake_questionnaire_store.answer_store = AnswerStore(
[
Answer("name", "Joe Bloggs", None).to_dict(),
Answer("address", "62 Somewhere", None).to_dict(),
]
)
questionnaire = {
"survey_id": "021",
"data_version": "0.0.3",
"sections": [
{
"id": "household-section",
"groups": [
{
"id": "personal details",
"blocks": [
{
"id": "about you",
"type": "Question",
"question": {
"id": "crisps-question",
"answers": [{"id": "name", "type": "TextField"}],
},
}
],
},
{
"id": "household",
"blocks": [
{
"id": "where you live",
"type": "Question",
"question": {
"id": "crisps-question",
"answers": [{"id": "address", "type": "TextField"}],
},
}
],
},
],
}
],
}
# When
answer_object = convert_answers(
QuestionnaireSchema(questionnaire), fake_questionnaire_store, full_routing_path
)
# Then
assert len(answer_object["data"]["answers"]) == 2
assert answer_object["data"]["answers"][0].value == "Joe Bloggs"
assert answer_object["data"]["answers"][1].value, "62 Somewhere"
def fake_questionnaire_store():
storage = Mock()
storage.get_user_data = Mock(return_value=("{}", "ce_sid", 1, None))
questionnaire_store = QuestionnaireStore(storage)
questionnaire_store.submitted_at = SUBMITTED_AT
questionnaire_store.metadata = {"tx_id": "123456789", "ru_name": "Apple"}
questionnaire_store.answer_store = AnswerStore(
[
Answer("name-answer", "John Smith", None).to_dict(),
Answer("address-answer", "NP10 8XG", None).to_dict(),
]
)
return questionnaire_store
def test_unit_answer(fake_questionnaire_store):
full_routing_path = [
RoutingPath(["unit-block"], section_id="section-1", list_item_id=None)
]
fake_questionnaire_store.answer_store = AnswerStore(
[Answer("unit-answer", 10).to_dict()])
question = {
"id": "unit-question",
"answers": [{
"id": "unit-answer",
"type": "Unit",
"q_code": "1"
}],
}
questionnaire = make_schema("0.0.1", "section-1", "unit-block",
"unit-block", question)
# When
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
# Then
assert len(answer_object["data"]) == 1
assert answer_object["data"]["1"] == "10"
def test_textarea_answer(fake_questionnaire_store):
full_routing_path = [RoutingPath(["textarea-block"], section_id="section-1")]
answers = AnswerStore(
[Answer("textarea-answer", "This is an example text!").to_dict()]
)
fake_questionnaire_store.answer_store = answers
questionnaire = make_schema(
"0.0.3",
"section-1",
"textarea-group",
"textarea-block",
{
"id": "textarea-question",
"answers": [{"id": "textarea-answer", "type": "TextArea"}],
},
)
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
assert len(answer_object["data"]["answers"]) == 1
assert answer_object["data"]["answers"][0].value == "This is an example text!"
def test_answer_without_qcode(fake_questionnaire_store):
fake_questionnaire_store.answer_store = AnswerStore(
[Answer("GHI", "String test + !").to_dict()])
question = {
"id": "question-2",
"answers": [{
"id": "GHI",
"type": "TextField"
}]
}
questionnaire = make_schema("0.0.1", "section-1", "group-1", "block-1",
question)
full_routing_path = [
RoutingPath(["block-1"], section_id="section-1", list_item_id=None)
]
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
assert not answer_object["data"]
def test_unit_answer(fake_questionnaire_store):
full_routing_path = [RoutingPath(["unit-block"], section_id="section-1")]
answers = AnswerStore([Answer("unit-answer", 10).to_dict()])
fake_questionnaire_store.answer_store = answers
questionnaire = make_schema(
"0.0.3",
"section-1",
"unit-group",
"unit-block",
{
"id": "unit-question",
"answers": [{
"id": "unit-answer",
"type": "Unit"
}]
},
)
answer_object = convert_answers(QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path)
assert len(answer_object["data"]["answers"]) == 1
assert answer_object["data"]["answers"][0].value == 10
def test_minimum_and_maximum_offset_dates(app, value_source_resolver, rule_evaluator):
value_source_resolver.metadata = {"date": "2018-02-20"}
answer_store = AnswerStore()
test_answer_id = Answer(answer_id="date", value="2018-03-20")
answer_store.add_or_update(test_answer_id)
value_source_resolver.answer_store = answer_store
answer = {
"id": "date_answer",
"type": "Date",
"minimum": {
"value": {"identifier": "date", "source": "metadata"},
"offset_by": {"days": -10},
},
"maximum": {
"value": {"identifier": "date", "source": "answers"},
"offset_by": {"years": 1},
},
}
handler = DateHandler(answer, value_source_resolver, rule_evaluator, error_messages)
minimum_date = handler.get_date_value("minimum")
maximum_date = handler.get_date_value("maximum")
assert minimum_date == parse_datetime("2018-02-10")
assert maximum_date == parse_datetime("2019-03-20")
def test_get_referenced_offset_value_with_list_item_id(
app, value_source_resolver, rule_evaluator
):
list_item_id = "abcde"
test_answer_id = Answer(
answer_id="date", value="2018-03-20", list_item_id=list_item_id
)
location = Location(section_id="test", list_item_id=list_item_id)
answer_store = AnswerStore()
answer_store.add_or_update(test_answer_id)
value_source_resolver.answer_store = answer_store
value_source_resolver.location = location
value_source_resolver.list_item_id = list_item_id
answer = {
"maximum": {
"value": {"identifier": "date", "source": "answers"},
"offset_by": {"months": 1},
}
}
handler = DateHandler(answer, value_source_resolver, rule_evaluator, error_messages)
maximum_date = handler.get_date_value("maximum")
assert maximum_date == parse_datetime("2018-04-20")
def test_percentage_answer(fake_questionnaire_store):
routing_path = RoutingPath(["percentage-block"], section_id="section-1")
fake_questionnaire_store.answer_store = AnswerStore(
[Answer("percentage-answer", 100).to_dict()])
question = {
"id":
"percentage-question",
"answers": [{
"id": "percentage-answer",
"type": "Percentage",
"q_code": "1"
}],
}
questionnaire = make_schema("0.0.1", "section-1", "percentage-block",
"percentage-block", question)
# When
answer_object = convert_answers(QuestionnaireSchema(questionnaire),
fake_questionnaire_store, routing_path)
# Then
assert len(answer_object["data"]) == 1
assert answer_object["data"]["1"] == "100"
def test_answer_with_float(fake_questionnaire_store):
fake_questionnaire_store.answer_store = AnswerStore(
[Answer("GHI", 10.02).to_dict()])
question = {
"id": "question-2",
"answers": [{
"id": "GHI",
"type": "TextField",
"q_code": "003"
}],
}
questionnaire = make_schema("0.0.1", "section-1", "group-1", "block-1",
question)
full_routing_path = [
RoutingPath(["block-1"], section_id="section-1", list_item_id=None)
]
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
# Check the converter correctly
assert answer_object["data"]["003"] == "10.02"
def test_currency_answer(fake_questionnaire_store):
full_routing_path = [RoutingPath(["currency-block"], section_id="section-1")]
answers = AnswerStore([Answer("currency-answer", 100).to_dict()])
fake_questionnaire_store.answer_store = answers
questionnaire = make_schema(
"0.0.3",
"section-1",
"currency-group",
"currency-block",
{
"id": "currency-question",
"answers": [{"id": "currency-answer", "type": "Currency"}],
},
)
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
assert len(answer_object["data"]["answers"]) == 1
assert answer_object["data"]["answers"][0].value == 100
def test_radio_answer(fake_questionnaire_store):
full_routing_path = [RoutingPath(["radio-block"], section_id="section-1")]
answers = AnswerStore([Answer("radio-answer", "Coffee").to_dict()])
fake_questionnaire_store.answer_store = answers
questionnaire = make_schema(
"0.0.3",
"section-1",
"radio-group",
"radio-block",
{
"id": "radio-question",
"answers": [
{
"type": "Radio",
"id": "radio-answer",
"options": [
{"label": "Coffee", "value": "Coffee"},
{"label": "Tea", "value": "Tea"},
],
}
],
},
)
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
assert len(answer_object["data"]["answers"]) == 1
assert answer_object["data"]["answers"][0].value == "Coffee"
def test_get_referenced_offset_value_with_list_item_id(app, schema_mock):
list_item_id = "abcde"
answer_store = AnswerStore()
test_answer_id = Answer(answer_id="date",
value="2018-03-20",
list_item_id=list_item_id)
location = Location(section_id="test", list_item_id=list_item_id)
answer_store.add_or_update(test_answer_id)
answer = {
"maximum": {
"value": {
"identifier": "date",
"source": "answers"
},
"offset_by": {
"months": 1
},
}
}
handler = DateHandler(answer, answer_store=answer_store, location=location)
maximum_date = handler.get_date_value("maximum")
assert maximum_date == convert_to_datetime("2018-04-20")
def test_convert_payload_0_0_3_multiple_answers(fake_questionnaire_store):
full_routing_path = [RoutingPath(["crisps"], section_id="section-1")]
answers = AnswerStore(
[Answer("crisps-answer", ["Ready salted", "Sweet chilli"]).to_dict()]
)
fake_questionnaire_store.answer_store = answers
questionnaire = make_schema(
"0.0.3",
"section-1",
"favourite-food",
"crisps",
{
"id": "crisps-question",
"answers": [
{
"id": "crisps-answer",
"type": "Checkbox",
"options": [
{"label": "Ready salted", "value": "Ready salted"},
{"label": "Sweet chilli", "value": "Sweet chilli"},
{"label": "Cheese and onion", "value": "Cheese and onion"},
],
}
],
},
)
# When
answer_object = convert_answers(
QuestionnaireSchema(questionnaire), fake_questionnaire_store, full_routing_path
)
# Then
assert len(answer_object["data"]["answers"]) == 1
assert answer_object["data"]["answers"][0].value == ["Ready salted", "Sweet chilli"]
def test_dropdown_answer(fake_questionnaire_store):
full_routing_path = [RoutingPath(["dropdown-block"], section_id="section-1")]
answers = AnswerStore([Answer("dropdown-answer", "Rugby is better!").to_dict()])
fake_questionnaire_store.answer_store = answers
questionnaire = make_schema(
"0.0.3",
"section-1",
"dropdown-group",
"dropdown-block",
{
"id": "dropdown-question",
"answers": [
{
"id": "dropdown-answer",
"type": "Dropdown",
"options": [
{"label": "Liverpool", "value": "Liverpool"},
{"label": "Chelsea", "value": "Chelsea"},
{"label": "Rugby is better!", "value": "Rugby is better!"},
],
}
],
},
)
answer_object = convert_answers(
QuestionnaireSchema(questionnaire), fake_questionnaire_store, full_routing_path
)
# Then
assert len(answer_object["data"]["answers"]) == 1
assert answer_object["data"]["answers"][0].value == "Rugby is better!"
def get_default_answer(self, answer_id):
try:
answer_schema = self.get_answers_by_answer_id(answer_id)[0]
answer = Answer(answer_schema["id"], answer_schema["default"])
except (KeyError, TypeError):
return None
return answer
def test_convert_answers_to_payload_0_0_1_with_key_error(
fake_questionnaire_store):
fake_questionnaire_store.answer_store = AnswerStore([
Answer("ABC", "2016-01-01").to_dict(),
Answer("DEF", "2016-03-30").to_dict(),
Answer("GHI", "2016-05-30").to_dict(),
])
question = {
"id":
"question-1",
"answers": [
{
"id": "LMN",
"type": "TextField",
"q_code": "001"
},
{
"id": "DEF",
"type": "TextField",
"q_code": "002"
},
{
"id": "JKL",
"type": "TextField",
"q_code": "003"
},
],
}
questionnaire = make_schema("0.0.1", "section-1", "group-1", "block-1",
question)
full_routing_path = [
RoutingPath(["block-1"], section_id="section-1", list_item_id=None)
]
answer_object = convert_answers_to_payload_0_0_1(
fake_questionnaire_store.metadata,
fake_questionnaire_store.response_metadata,
fake_questionnaire_store.answer_store,
fake_questionnaire_store.list_store,
QuestionnaireSchema(questionnaire),
full_routing_path,
)
assert answer_object["002"] == "2016-03-30"
assert len(answer_object) == 1
def get_default_answer(self, answer_id: str) -> Optional[Answer]:
if answer_schemas := self.get_answers_by_answer_id(answer_id):
first_answer_schema = answer_schemas[0]
try:
return Answer(first_answer_schema["id"],
first_answer_schema["default"])
except (IndexError, KeyError, TypeError):
return None
def test_converter_q_codes_for_empty_strings(fake_questionnaire_store):
full_routing_path = [
RoutingPath(["crisps"], section_id="food", list_item_id=None)
]
fake_questionnaire_store.answer_store = AnswerStore([
Answer("crisps-answer", "").to_dict(),
Answer("other-crisps-answer", "Ready salted").to_dict(),
])
question = {
"id":
"crisps-question",
"answers": [
{
"id": "crisps-answer",
"type": "TextArea",
"options": [],
"q_code": "1"
},
{
"id": "other-crisps-answer",
"type": "TextArea",
"options": [],
"q_code": "2",
},
],
}
questionnaire = make_schema("0.0.1", "section-1", "favourite-food",
"crisps", question)
# When
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
# Then
assert len(answer_object["data"]) == 1
assert answer_object["data"]["2"] == "Ready salted"
def test_get_schema_value_answer_store(value_source_resolver, rule_evaluator):
answer_schema = {
"id": "test-range",
"label": "",
"description": "Range Test",
"mandatory": False,
"type": "Number",
"decimal_places": 2,
"maximum": {
"value": {
"identifier": "set-maximum",
"source": "answers"
}
},
"minimum": {
"value": {
"identifier": "set-minimum",
"source": "answers"
}
},
}
value_source_resolver.metadata = {
"schema_name": "test_numbers",
"language_code": "en",
}
answer_store = AnswerStore()
answer_store.add_or_update(Answer(answer_id="set-maximum", value=10))
answer_store.add_or_update(Answer(answer_id="set-minimum", value=1))
value_source_resolver.answer_store = answer_store
number_handler = NumberHandler(answer_schema, value_source_resolver,
rule_evaluator, error_messages)
maximum = number_handler.get_schema_value(answer_schema["maximum"])
minimum = number_handler.get_schema_value(answer_schema["minimum"])
assert maximum == 10
assert minimum == 1
def test_dropdown_answer(fake_questionnaire_store):
full_routing_path = [
RoutingPath(["dropdown-block"],
section_id="section-1",
list_item_id=None)
]
fake_questionnaire_store.answer_store = AnswerStore(
[Answer("dropdown-answer", "Liverpool").to_dict()])
question = {
"id":
"dropdown-question",
"answers": [{
"id":
"dropdown-answer",
"type":
"Dropdown",
"q_code":
"1",
"options": [
{
"label": "Liverpool",
"value": "Liverpool"
},
{
"label": "Chelsea",
"value": "Chelsea"
},
{
"label": "Rugby is better!",
"value": "Rugby is better!"
},
],
}],
}
questionnaire = make_schema("0.0.1", "section-1", "dropdown-block",
"dropdown-block", question)
# When
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
# Then
assert len(answer_object["data"]) == 1
assert answer_object["data"]["1"] == "Liverpool"
def fake_questionnaire_store(fake_metadata, fake_collection_metadata):
user_answer = Answer(answer_id="GHI", value=0, list_item_id=None)
storage = MagicMock()
storage.get_user_data = MagicMock(return_value=("{}", 1))
storage.add_or_update = MagicMock()
store = QuestionnaireStore(storage)
store.answer_store = AnswerStore()
store.answer_store.add_or_update(user_answer)
store.metadata = fake_metadata
store.collection_metadata = fake_collection_metadata
return store
def test_get_referenced_offset_value_for_answer_id(
app, value_source_resolver, rule_evaluator
):
answer_store = AnswerStore()
test_answer_id = Answer(answer_id="date", value="2018-03-20")
answer_store.add_or_update(test_answer_id)
value_source_resolver.answer_store = answer_store
answer = {"maximum": {"value": {"identifier": "date", "source": "answers"}}}
handler = DateHandler(answer, value_source_resolver, rule_evaluator, error_messages)
maximum_date = handler.get_date_value("maximum")
maximum_date = handler.transform_date_by_offset(maximum_date, {"months": 1})
assert maximum_date == parse_datetime("2018-04-20")
def test_answer_source_default_answer(use_default_answer):
schema = get_mock_schema()
if use_default_answer:
schema.get_default_answer = Mock(
return_value=Answer(answer_id="some-answer", value="Yes"))
else:
schema.get_default_answer = Mock(return_value=None)
value_source_resolver = get_value_source_resolver(
schema=schema,
use_default_answer=use_default_answer,
)
expected_result = "Yes" if use_default_answer else None
assert (value_source_resolver.resolve({
"source": "answers",
"identifier": "some-answer"
}) == expected_result)
def test_radio_answer(fake_questionnaire_store):
full_routing_path = [
RoutingPath(["radio-block"], section_id="section-1", list_item_id=None)
]
fake_questionnaire_store.answer_store = AnswerStore(
[Answer("radio-answer", "Coffee").to_dict()])
question = {
"id":
"radio-question",
"answers": [{
"type":
"Radio",
"id":
"radio-answer",
"q_code":
"1",
"options": [
{
"label": "Coffee",
"value": "Coffee"
},
{
"label": "Tea",
"value": "Tea"
},
],
}],
}
questionnaire = make_schema("0.0.1", "section-1", "radio-block",
"radio-block", question)
# When
answer_object = convert_answers(
QuestionnaireSchema(questionnaire),
fake_questionnaire_store,
full_routing_path,
SUBMITTED_AT,
)
# Then
assert len(answer_object["data"]) == 1
assert answer_object["data"]["1"] == "Coffee"
def test_get_referenced_offset_value_for_answer_id(app):
answer_store = AnswerStore()
test_answer_id = Answer(answer_id="date", value="2018-03-20")
answer_store.add_or_update(test_answer_id)
answer = {
"maximum": {
"value": {
"identifier": "date",
"source": "answers"
}
}
}
handler = DateHandler(answer, answer_store=answer_store)
maximum_date = handler.get_date_value("maximum")
maximum_date = handler.transform_date_by_offset(maximum_date,
{"months": 1})
assert maximum_date == convert_to_datetime("2018-04-20")
