def fake_questionnaire_store_no_submitted_at():
storage = Mock()
storage.get_user_data = Mock(return_value=("{}", "ce_sid", 1, None))
questionnaire_store = QuestionnaireStore(storage)
questionnaire_store.submitted_at = None
questionnaire_store.metadata = {}
questionnaire_store.answer_store = AnswerStore()
return questionnaire_store
def test_filename_uses_schema_name(
app, storage, schema, language # pylint:disable=unused-argument
):
submitted_at = datetime.now(timezone.utc)
set_storage_data(storage, submitted_at=submitted_at)
questionnaire_store = QuestionnaireStore(storage)
questionnaire_store.set_metadata({"schema_name": "test_view_submitted_response"})
pdf = ViewSubmittedResponsePDF(schema, questionnaire_store, language)
assert pdf.filename == "test_view_submitted_response.pdf"
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 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_not_enabled(storage, language):
set_storage_data(storage)
questionnaire_store = QuestionnaireStore(storage)
with pytest.raises(ViewSubmittedResponseNotEnabled):
ViewSubmittedResponse(QuestionnaireSchema({}), questionnaire_store,
language)
def test_questionnaire_store_ignores_extra_json(self):
# Given
expected = get_basic_input()
expected[
"NOT_A_LEGAL_TOP_LEVEL_KEY"] = "woop_woop_thats_the_sound_of_the_police"
self.input_data = json.dumps(expected)
# When
store = QuestionnaireStore(self.storage)
# Then
self.assertEqual(store.metadata.copy(), expected["METADATA"])
self.assertEqual(store.collection_metadata,
expected["COLLECTION_METADATA"])
self.assertEqual(store.answer_store, AnswerStore(expected["ANSWERS"]))
expected_completed_block_ids = expected["PROGRESS"][0]["block_ids"][0]
self.assertEqual(
len(
store.progress_store.get_completed_block_ids(
"a-test-section", "abc123")),
1,
)
self.assertEqual(
store.progress_store.get_completed_block_ids(
"a-test-section", "abc123")[0],
expected_completed_block_ids,
)
def test_questionnaire_store_loads_json(self):
# Given
expected = get_basic_input()
self.input_data = json.dumps(expected)
# When
store = QuestionnaireStore(self.storage)
# Then
self.assertEqual(store.metadata.copy(), expected["METADATA"])
self.assertEqual(store.collection_metadata,
expected["COLLECTION_METADATA"])
self.assertEqual(store.answer_store, AnswerStore(expected["ANSWERS"]))
expected_completed_block_ids = expected["PROGRESS"][0]["block_ids"][0]
self.assertEqual(
len(
store.progress_store.get_completed_block_ids(
"a-test-section", "abc123")),
1,
)
self.assertEqual(
store.progress_store.get_completed_block_ids(
"a-test-section", "abc123")[0],
expected_completed_block_ids,
)
def test_questionnaire_store_updates_storage(questionnaire_store, basic_input):
# Given
store = QuestionnaireStore(questionnaire_store.storage)
store.set_metadata(basic_input["METADATA"])
store.answer_store = AnswerStore(basic_input["ANSWERS"])
store.response_metadata = basic_input["RESPONSE_METADATA"]
store.progress_store = ProgressStore(basic_input["PROGRESS"])
# When
store.save()
# Then
assert basic_input == json_loads(questionnaire_store.output_data)
def test_questionnaire_store_updates_storage(self):
# Given
expected = get_basic_input()
store = QuestionnaireStore(self.storage)
store.set_metadata(expected["METADATA"])
store.answer_store = AnswerStore(expected["ANSWERS"])
store.collection_metadata = expected["COLLECTION_METADATA"]
store.progress_store = ProgressStore(expected["PROGRESS"])
# When
store.save() # See setUp - populates self.output_data
# Then
self.assertEqual(expected, json.loads(self.output_data))
def get_questionnaire_store(user_id: str, user_ik: str) -> QuestionnaireStore:
# Sets up a single QuestionnaireStore instance per request.
store = g.get("_questionnaire_store")
if store is None:
pepper = current_app.eq["secret_store"].get_secret_by_name(
"EQ_SERVER_SIDE_STORAGE_ENCRYPTION_USER_PEPPER")
storage = EncryptedQuestionnaireStorage(user_id, user_ik, pepper)
store = g._questionnaire_store = QuestionnaireStore(storage)
return store
def test_questionnaire_store_deletes(questionnaire_store, basic_input):
# Given
store = QuestionnaireStore(questionnaire_store.storage)
store.set_metadata(basic_input["METADATA"])
store.response_metadata = basic_input["RESPONSE_METADATA"]
store.answer_store = AnswerStore(basic_input["ANSWERS"])
store.progress_store = ProgressStore(basic_input["PROGRESS"])
# When
store.delete()
# Then
assert "a-test-section" not in store.progress_store
assert store.metadata.copy() == {}
assert len(store.answer_store) == 0
assert store.response_metadata == {}
def test_has_expired_no_submitted_at_return_false(storage, language, app):
with app.app_context():
set_storage_data(storage)
questionnaire_store = QuestionnaireStore(storage)
schema = QuestionnaireSchema(
{"post_submission": {
"view_response": True
}})
view_submitted_response = ViewSubmittedResponse(
schema, questionnaire_store, language)
assert view_submitted_response.has_expired is False
def test_questionnaire_store_missing_keys(questionnaire_store, basic_input):
# Given
del basic_input["PROGRESS"]
questionnaire_store.input_data = json_dumps(basic_input)
# When
store = QuestionnaireStore(questionnaire_store.storage)
# Then
assert store.metadata.copy() == basic_input["METADATA"]
assert store.response_metadata == basic_input["RESPONSE_METADATA"]
assert store.answer_store == AnswerStore(basic_input["ANSWERS"])
assert not store.progress_store.serialize()
def test_questionnaire_store_errors_on_invalid_object(questionnaire_store,
basic_input):
# Given
class NotSerializable:
pass
non_serializable_metadata = {"test": NotSerializable()}
store = QuestionnaireStore(questionnaire_store.storage)
store.set_metadata(non_serializable_metadata)
store.response_metadata = basic_input["RESPONSE_METADATA"]
store.answer_store = AnswerStore(basic_input["ANSWERS"])
store.progress_store = ProgressStore(basic_input["PROGRESS"])
# When / Then
with pytest.raises(TypeError):
store.save()
def test_questionnaire_store_deletes(self):
# Given
expected = get_basic_input()
store = QuestionnaireStore(self.storage)
store.set_metadata(expected["METADATA"])
store.collection_metadata = expected["COLLECTION_METADATA"]
store.answer_store = AnswerStore(expected["ANSWERS"])
store.progress_store = ProgressStore(expected["PROGRESS"])
# When
store.delete() # See setUp - populates self.output_data
# Then
self.assertNotIn("a-test-section", store.progress_store)
self.assertEqual(store.metadata.copy(), {})
self.assertEqual(len(store.answer_store), 0)
self.assertEqual(store.collection_metadata, {})
def get_questionnaire_store(user_id: str, user_ik: str) -> QuestionnaireStore:
# Sets up a single QuestionnaireStore instance per request.
store = g.get("_questionnaire_store")
if store is None:
secret_store = current_app.eq["secret_store"] # type: ignore
pepper = secret_store.get_secret_by_name(
"EQ_SERVER_SIDE_STORAGE_ENCRYPTION_USER_PEPPER")
storage = EncryptedQuestionnaireStorage(user_id, user_ik, pepper)
# pylint: disable=assigning-non-slot
store = g._questionnaire_store = QuestionnaireStore(storage)
return store
def test_questionnaire_store_missing_keys(self):
# Given
expected = get_basic_input()
del expected["PROGRESS"]
self.input_data = json.dumps(expected)
# When
store = QuestionnaireStore(self.storage)
# Then
self.assertEqual(store.metadata.copy(), expected["METADATA"])
self.assertEqual(store.response_metadata, expected["RESPONSE_METADATA"])
self.assertEqual(store.answer_store, AnswerStore(expected["ANSWERS"]))
self.assertEqual(store.progress_store.serialize(), [])
def setUp(self):
super().setUp()
self._application_context = self._application.app_context()
self._application_context.push()
storage = Mock()
data = {"METADATA": "test", "ANSWERS": [], "PROGRESS": []}
storage.get_user_data = Mock(
return_value=(json.dumps(data), QuestionnaireStore.LATEST_VERSION))
self.question_store = QuestionnaireStore(storage)
self.mock_context = {"block": {"question": {"title": "Testing title"}}}
def test_pdf_not_downloadable(
app, storage, schema, language # pylint:disable=unused-argument
):
submitted_at = datetime.now(timezone.utc) - timedelta(minutes=46)
set_storage_data(storage, submitted_at=submitted_at)
questionnaire_store = QuestionnaireStore(storage)
with pytest.raises(ViewSubmittedResponseExpired):
ViewSubmittedResponsePDF(
schema,
questionnaire_store,
language,
)
def test_submission_language_code_in_payload(self):
session_store = self.session_store.create("eq_session_id", "user_id",
self.session_data,
self.expires_at)
storage = Mock()
storage.get_user_data = Mock(return_value=("{}", 1))
with patch(
"app.views.handlers.submission.get_session_store",
return_value=session_store,
):
with patch("app.views.handlers.submission.convert_answers",
return_value={}):
submission_handler = SubmissionHandler(
QuestionnaireSchema({}), QuestionnaireStore(storage), {})
assert (submission_handler.get_payload()
["submission_language_code"] == "cy")
def test_questionnaire_store_errors_on_invalid_object(self):
# Given
class NotSerializable:
pass
non_serializable_metadata = {"test": NotSerializable()}
expected = get_basic_input()
store = QuestionnaireStore(self.storage)
store.set_metadata(non_serializable_metadata)
store.collection_metadata = expected["COLLECTION_METADATA"]
store.answer_store = AnswerStore(expected["ANSWERS"])
store.progress_store = ProgressStore(expected["PROGRESS"])
# When / Then
self.assertRaises(TypeError, store.save)
def test_questionnaire_store_json_loads(questionnaire_store, basic_input,
extra_basic_input):
basic_input.update(extra_basic_input)
# Given
questionnaire_store.input_data = json_dumps(basic_input)
# When
store = QuestionnaireStore(questionnaire_store.storage)
# Then
assert store.metadata.copy() == basic_input["METADATA"]
assert store.response_metadata == basic_input["RESPONSE_METADATA"]
assert store.answer_store == AnswerStore(basic_input["ANSWERS"])
assert not hasattr(store, "NOT_A_LEGAL_TOP_LEVEL_KEY")
assert not hasattr(store, "not_a_legal_top_level_key")
expected_completed_block_ids = basic_input["PROGRESS"][0]["block_ids"][0]
assert (len(
store.progress_store.get_completed_block_ids("a-test-section",
"abc123")) == 1)
assert (store.progress_store.get_completed_block_ids(
"a-test-section", "abc123")[0] == expected_completed_block_ids)
def test_questionnaire_store_raises_when_writing_to_metadata(
questionnaire_store):
store = QuestionnaireStore(questionnaire_store.storage)
with pytest.raises(TypeError):
store.metadata["no"] = "writing"
def questionnaire_store_mock():
storage = Mock()
storage.get_user_data = Mock(return_value=("{}", 1))
questionnaire_store = QuestionnaireStore(storage)
questionnaire_store.metadata = {"tx_id": "tx_id", "case_id": "case_id"}
return questionnaire_store
def test_questionnaire_store_raises_when_writing_to_metadata(self):
store = QuestionnaireStore(self.storage)
with self.assertRaises(TypeError):
store.metadata["no"] = "writing"