def _handle_uploaded_file(file_name, file, manager):
base_name, extension = os.path.splitext(file_name)
if extension == '.csv':
csv_player = CsvPlayer(dbm=manager,
submission_handler=SubmissionHandler(manager),
parser=CsvParser())
response = csv_player.accept(file)
elif extension == '.xls':
xls_player = XlsPlayer(dbm=manager,
submission_handler=SubmissionHandler(manager),
parser=XlsParser())
response = xls_player.accept(file)
else:
raise InvalidFileFormatException()
return response
def _validate_post_data(dbm, request):
form = ReporterRegistrationForm(request.POST)
message = None
success = False
form_errors = []
form_errors.extend(form.non_field_errors())
if form.is_valid():
form_errors = []
form_data = {
k: v
for (k, v) in form.cleaned_data.items() if not is_empty(v)
}
try:
entered_telephone_number = form_data.get("telephone_number")
tel_number = _get_telephone_number(entered_telephone_number)
if not helper.unique(dbm, tel_number):
raise MultipleReportersForANumberException(
entered_telephone_number)
web_player = WebPlayer(dbm, SubmissionHandler(dbm))
response = web_player.accept(
Request(message=_get_data(form_data),
transportInfo=TransportInfo(transport='web',
source='web',
destination='mangrove')))
message = get_success_msg_for_registration_using(response, "web")
success = True
except MangroveException as exception:
form_errors.append(exception.message)
success = False
return form, form_errors, message, success
def submit(request):
dbm = get_database_manager(request)
post = _get_submission(request.POST)
success = True
try:
web_player = WebPlayer(dbm, SubmissionHandler(dbm))
message = {
k: v
for (k, v) in post.get('message').items() if not is_empty(v)
}
if message.get(LOCATION_TYPE_FIELD_CODE) is not None:
message[LOCATION_TYPE_FIELD_CODE] += COUNTRY
request = Request(message=message,
transportInfo=TransportInfo(
transport=post.get('transport'),
source=post.get('source'),
destination=post.get('destination')))
response = web_player.accept(request)
if response.success:
message = get_success_msg_for_registration_using(response, "web")
else:
message = get_submission_error_message_for(response.errors)
entity_id = response.datarecord_id
except MangroveException as exception:
message = get_exception_message_for(exception=exception, channel="web")
success = False
entity_id = None
return HttpResponse(
json.dumps({
'success': success,
'message': message,
'entity_id': entity_id
}))
def setUp(self):
self.dbm = get_db_manager(database='mangrove-test')
self._create_entities()
self.player = SMSPlayer(self.dbm, SubmissionHandler(self.dbm))
self.transport = TransportInfo(transport="sms",
source="1234",
destination="5678")
initializer.run(self.dbm)
def setUp(self):
self.FORM_CODE = "QR1"
self.VALUES = {"EID": "100", "Q1": "20"}
self.dbm = Mock(spec=DatabaseManager)
self.form_model_patcher = patch(
'mangrove.transport.submissions.get_form_model_by_code')
self.form_submission_entity_patcher = patch(
'mangrove.form_model.form_model.entity')
self.SubmissionLogger_class_patcher = patch(
'mangrove.transport.submissions.SubmissionLogger', )
self.get_form_model_mock = self.form_model_patcher.start()
self.form_submission_entity_module = self.form_submission_entity_patcher.start(
)
self.SubmissionLogger_mock_class = self.SubmissionLogger_class_patcher.start(
)
self.submissionLogger = Mock(spec=SubmissionLogger)
self.SubmissionLogger_mock_class.return_value = self.submissionLogger
self.SUBMISSION_ID = "SUBMISSION_ID"
self.submissionLogger.create_submission_log.return_value = self.SUBMISSION_ID
self.form_model_mock = Mock(spec=FormModel)
self.form_model_mock.is_registration_form.return_value = False
self.form_model_mock.entity_defaults_to_reporter.return_value = False
self.form_model_mock.is_inactive.return_value = False
self.form_model_mock.is_in_test_mode.return_value = False
self.ENTITY_TYPE = ["entity_type"]
self.form_model_mock.entity_type = self.ENTITY_TYPE
entity_question = Mock()
entity_question.code = "eid"
self.form_model_mock.entity_question = entity_question
self.get_form_model_mock.return_value = self.form_model_mock
self.sms = Channel.SMS
reporter = Mock(spec=Entity)
reporter.short_code.return_value = "REP1"
self.submission_request = SubmissionRequest(form_code=self.FORM_CODE,
submission=self.VALUES,
transport=self.sms,
source="1234",
destination="5678",
reporter=reporter)
self.submission_handler = SubmissionHandler(self.dbm)
def sms(request):
_message = request.POST["message"]
_from, _to = _get_from_and_to_numbers(request)
try:
dbm = get_db_manager_for(_to)
sms_player = SMSPlayer(dbm, SubmissionHandler(dbm))
transportInfo = TransportInfo(transport=SMS,
source=_from,
destination=_to)
response = sms_player.accept(
Request(transportInfo=transportInfo, message=_message))
message = SMSResponse(response).text()
except (
SubmissionParseException,
FormModelDoesNotExistsException,
) as exception:
message = get_exception_message_for(exception=exception, channel=SMS)
log = DatawinnerLog(message=_message,
from_number=_from,
to_number=_to,
form_code=exception.data[0],
error=message)
log.save()
except NumberNotRegisteredException as exception:
message = get_exception_message_for(exception=exception, channel=SMS)
log = DatawinnerLog(message=_message,
from_number=_from,
to_number=_to,
form_code=None,
error=message)
log.save()
except MangroveException as exception:
message = get_exception_message_for(exception=exception, channel=SMS)
except Exception as exception:
logger.exception('SMS Processing failure: message')
message = get_exception_message_for(exception=exception, channel=SMS)
return HttpResponse(message)
def setUp(self):
self.FORM_CODE = "QR1"
self.VALUES = {"EID": "100", "Q1": "20"}
self.dbm = Mock(spec=DatabaseManager)
self.form_model_patcher = patch('mangrove.transport.submissions.get_form_model_by_code')
self.form_submission_entity_patcher = patch('mangrove.form_model.form_model.entity')
self.SubmissionLogger_class_patcher = patch('mangrove.transport.submissions.SubmissionLogger', )
self.get_form_model_mock = self.form_model_patcher.start()
self.form_submission_entity_module = self.form_submission_entity_patcher.start()
self.SubmissionLogger_mock_class = self.SubmissionLogger_class_patcher.start()
self.submissionLogger = Mock(spec=SubmissionLogger)
self.SubmissionLogger_mock_class.return_value = self.submissionLogger
self.SUBMISSION_ID = "SUBMISSION_ID"
self.submissionLogger.create_submission_log.return_value = self.SUBMISSION_ID
self.form_model_mock = Mock(spec=FormModel)
self.form_model_mock.is_registration_form.return_value = False
self.form_model_mock.entity_defaults_to_reporter.return_value = False
self.form_model_mock.is_inactive.return_value = False
self.form_model_mock.is_in_test_mode.return_value = False
self.ENTITY_TYPE = ["entity_type"]
self.form_model_mock.entity_type = self.ENTITY_TYPE
entity_question = Mock()
entity_question.code = "eid"
self.form_model_mock.entity_question = entity_question
self.get_form_model_mock.return_value = self.form_model_mock
self.sms = Channel.SMS
reporter = Mock(spec=Entity)
reporter.short_code.return_value = "REP1"
self.submission_request = SubmissionRequest(form_code=self.FORM_CODE, submission=self.VALUES,
transport=self.sms
, source="1234", destination="5678", reporter=reporter)
self.submission_handler = SubmissionHandler(self.dbm)
class TestSubmissions(TestCase):
def setUp(self):
self.FORM_CODE = "QR1"
self.VALUES = {"EID": "100", "Q1": "20"}
self.dbm = Mock(spec=DatabaseManager)
self.form_model_patcher = patch(
'mangrove.transport.submissions.get_form_model_by_code')
self.form_submission_entity_patcher = patch(
'mangrove.form_model.form_model.entity')
self.SubmissionLogger_class_patcher = patch(
'mangrove.transport.submissions.SubmissionLogger', )
self.get_form_model_mock = self.form_model_patcher.start()
self.form_submission_entity_module = self.form_submission_entity_patcher.start(
)
self.SubmissionLogger_mock_class = self.SubmissionLogger_class_patcher.start(
)
self.submissionLogger = Mock(spec=SubmissionLogger)
self.SubmissionLogger_mock_class.return_value = self.submissionLogger
self.SUBMISSION_ID = "SUBMISSION_ID"
self.submissionLogger.create_submission_log.return_value = self.SUBMISSION_ID
self.form_model_mock = Mock(spec=FormModel)
self.form_model_mock.is_registration_form.return_value = False
self.form_model_mock.entity_defaults_to_reporter.return_value = False
self.form_model_mock.is_inactive.return_value = False
self.form_model_mock.is_in_test_mode.return_value = False
self.ENTITY_TYPE = ["entity_type"]
self.form_model_mock.entity_type = self.ENTITY_TYPE
entity_question = Mock()
entity_question.code = "eid"
self.form_model_mock.entity_question = entity_question
self.get_form_model_mock.return_value = self.form_model_mock
self.sms = Channel.SMS
reporter = Mock(spec=Entity)
reporter.short_code.return_value = "REP1"
self.submission_request = SubmissionRequest(form_code=self.FORM_CODE,
submission=self.VALUES,
transport=self.sms,
source="1234",
destination="5678",
reporter=reporter)
self.submission_handler = SubmissionHandler(self.dbm)
def tearDown(self):
self.form_model_patcher.stop()
self.form_submission_entity_patcher.stop()
def _valid_form_submission(self):
return FormSubmission(self.form_model_mock, {
'eid': 'CID001',
"location": "Pune"
})
def _valid_form_submission_unicode(self):
return FormSubmission(self.form_model_mock, {
'eid': u'Āgra',
"location": "Agra"
})
def _invalid_form_submission_unicode(self):
return FormSubmission(self.form_model_mock, {}, {"field": u"Āgra"})
def _valid_form_submission_with_choices(self):
return FormSubmission(self.form_model_mock, {
'eid': 'CID001',
"location": "Pune",
"favourite_colour": ['red']
})
def _empty_form_submission(self):
return FormSubmission(self.form_model_mock, {'eid': 'CID001'})
def _invalid_form_submission(self):
return FormSubmission(self.form_model_mock, {}, {"field": "Invalid"})
def test_should_return_true_if_valid_form_submission(self):
self.form_model_mock.validate_submission.return_value = self._valid_form_submission(
)
response = self.submission_handler.accept(self.submission_request)
self.assertTrue(response.success)
self.assertEqual({}, response.errors)
self.assertFalse(response.is_registration)
def test_should_save_data_record_if_valid_form_submission(self):
self.form_model_mock.validate_submission.return_value = self._valid_form_submission(
)
self.submission_handler.accept(self.submission_request)
self.assertTrue(
self.form_submission_entity_module.get_by_short_code.called)
def test_should_not_save_data_record_if_in_valid_form_submission(self):
self.form_model_mock.validate_submission.return_value = self._invalid_form_submission(
)
response = self.submission_handler.accept(self.submission_request)
self.assertEqual({"field": "Invalid"}, response.errors)
self.assertFalse(response.success)
self.assertFalse(response.is_registration)
def test_should_not_save_data_record_if_no_valid_questions_present(self):
self.form_model_mock.validate_submission.side_effect = NoQuestionsSubmittedException(
)
with self.assertRaises(NoQuestionsSubmittedException):
self.submission_handler.accept(self.submission_request)
def test_should_create_new_submission_log(self):
form_submission = self._valid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
self.submission_handler.accept(self.submission_request)
self.assertTrue(self.submissionLogger.create_submission_log.called)
def test_should_update_submission_log_on_success(self):
form_submission = self._valid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
self.submissionLogger.update_submission_log.assert_called_once_with(
submission_id=self.SUBMISSION_ID,
status=True,
errors=None,
data_record_id=response.datarecord_id,
in_test_mode=False)
def test_should_update_submission_log_on_failure(self):
form_submission = self._invalid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
self.submission_handler.accept(self.submission_request)
self.submissionLogger.update_submission_log.assert_called_once_with(
submission_id=self.SUBMISSION_ID,
status=False,
data_record_id=None,
errors=form_submission.errors,
in_test_mode=False)
def test_should_fail_submission_if_invalid_form_code(self):
self.get_form_model_mock.side_effect = FormModelDoesNotExistsException(
"INVALID_CODE")
with self.assertRaises(FormModelDoesNotExistsException):
self.submission_handler.accept(self.submission_request)
def test_should_fail_submission_if_invalid_short_code(self):
form_submission = self._valid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
self.form_submission_entity_module.get_by_short_code.side_effect = DataObjectNotFound(
"Entity", 'id', 'short_code')
with self.assertRaises(DataObjectNotFound):
self.submission_handler.accept(self.submission_request)
self.submissionLogger.update_submission_log.assert_called_once_with(
submission_id=self.SUBMISSION_ID,
status=False,
errors=u'Entity with id = short_code not found.',
in_test_mode=False)
def test_should_register_entity_if_form_submission_valid(self):
self.form_model_mock.validate_submission.return_value = self._valid_form_submission(
)
self.form_model_mock.is_registration_form.return_value = True
response = self.submission_handler.accept(self.submission_request)
self.assertTrue(response.success)
self.assertEqual({}, response.errors)
self.assertEqual("cid001", response.short_code)
self.assertTrue(response.is_registration)
self.form_submission_entity_module.create_entity.assert_called_once_with(
dbm=self.dbm,
entity_type=self.ENTITY_TYPE,
location=None,
short_code="cid001",
geometry=None)
self.submissionLogger.update_submission_log.assert_called_once_with(
submission_id=self.SUBMISSION_ID,
status=True,
errors=None,
data_record_id=response.datarecord_id,
in_test_mode=False)
def test_should_not_register_entity_if_form_submission_invalid(self):
form_submission = self._invalid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
self.form_model_mock.is_registration_form.return_value = True
response = self.submission_handler.accept(self.submission_request)
self.assertFalse(response.success)
self.assertEqual({"field": "Invalid"}, response.errors)
self.assertTrue(response.is_registration)
self.assertFalse(
self.form_submission_entity_module.create_entity.called)
self.submissionLogger.update_submission_log.assert_called_once_with(
submission_id=self.SUBMISSION_ID,
status=False,
data_record_id=None,
errors=form_submission.errors,
in_test_mode=False)
def test_should_return_expanded_response(self):
form_submission = self._valid_form_submission_with_choices()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
expected_message = form_submission.cleaned_data
self.assertEquals(expected_message, response.processed_data)
def test_should_accept_unicodes_for_valid_submission(self):
form_submission = self._valid_form_submission_unicode()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
self.assertTrue(response.success)
self.assertEqual({}, response.errors)
def test_should_accept_unicodes_for_invalid_submission(self):
form_submission = self._invalid_form_submission_unicode()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
self.assertFalse(response.success)
self.assertEqual({'field': u'Āgra'}, response.errors)
def test_should_raise_inactive_form_model_exception(self):
self.form_model_mock.is_inactive.return_value = True
with self.assertRaises(InactiveFormModelException):
self.submission_handler.accept(self.submission_request)
def test_should_log_submissions_in_test_mode(self):
self.form_model_mock.is_in_test_mode.return_value = True
self.form_model_mock.is_inactive.return_value = False
form_submission = self._valid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
self.assertTrue(response.success)
self.assertIsNotNone(response.datarecord_id)
self.assertIsNotNone(response.submission_id)
def test_should_convert_mobile_number_to_string(self):
actual_value = self.submission_handler._get_telephone_number(
u'2.66123321435e+11')
expected_value = unicode(266123321435)
self.assertEqual(expected_value, actual_value)
actual_value = self.submission_handler._get_telephone_number(
u'266123321')
expected_value = u'266123321'
self.assertEqual(expected_value, actual_value)
def test_should_strip_non_numbers_from_mobile_number(self):
actual_value = self.submission_handler._get_telephone_number(
u'26554-2123')
expected_value = u'265542123'
self.assertEqual(expected_value, actual_value)
def setUp(self):
self.dbm = get_db_manager(database='mangrove-test')
initializer.run(self.dbm)
define_type(self.dbm, ["dog"])
self.entity_type = ["healthfacility", "clinic"]
define_type(self.dbm, self.entity_type)
self.name_type = DataDictType(self.dbm,
name='Name',
slug='name',
primitive_type='string')
self.telephone_number_type = DataDictType(self.dbm,
name='telephone_number',
slug='telephone_number',
primitive_type='string')
self.entity_id_type = DataDictType(self.dbm,
name='Entity Id Type',
slug='entity_id',
primitive_type='string')
self.stock_type = DataDictType(self.dbm,
name='Stock Type',
slug='stock',
primitive_type='integer')
self.color_type = DataDictType(self.dbm,
name='Color Type',
slug='color',
primitive_type='string')
self.name_type.save()
self.telephone_number_type.save()
self.stock_type.save()
self.color_type.save()
self.entity = create_entity(
self.dbm,
entity_type=self.entity_type,
location=["India", "Pune"],
aggregation_paths=None,
short_code="cli1",
)
self.data_record_id = self.entity.add_data(
data=[("Name", "Ruby", self.name_type)],
submission=dict(submission_id="1"))
self.reporter = create_entity(
self.dbm,
entity_type=["reporter"],
location=["India", "Pune"],
aggregation_paths=None,
short_code="rep1",
)
self.reporter.add_data(data=[
(MOBILE_NUMBER_FIELD, '1234', self.telephone_number_type),
(NAME_FIELD, "Test_reporter", self.name_type)
],
submission=dict(submission_id="2"))
question1 = TextField(name="entity_question",
code="EID",
label="What is associated entity",
language="eng",
entity_question_flag=True,
ddtype=self.entity_id_type)
question2 = TextField(name="Name",
code="NAME",
label="Clinic Name",
defaultValue="some default value",
language="eng",
length=TextConstraint(4, 15),
ddtype=self.name_type)
question3 = IntegerField(name="Arv stock",
code="ARV",
label="ARV Stock",
range=NumericConstraint(min=15, max=120),
ddtype=self.stock_type)
question4 = SelectField(name="Color",
code="COL",
label="Color",
options=[("RED", 1), ("YELLOW", 2)],
ddtype=self.color_type)
self.form_model = FormModel(self.dbm,
entity_type=self.entity_type,
name="aids",
label="Aids form_model",
form_code="clinic",
type='survey',
fields=[question1, question2, question3])
self.form_model.add_field(question4)
self.form_model__id = self.form_model.save()
self.submission_handler = SubmissionHandler(self.dbm)
self.sms_player = SMSPlayer(self.dbm, self.submission_handler,
LocationTree())
def load_sms_data_for_cli001(manager):
FEB = datetime(2011, 02, 28, hour=12, minute=00, second=00, tzinfo=UTC)
MARCH = datetime(2011, 03, 01, tzinfo=UTC)
DEC_2010 = datetime(2010,
12,
28,
hour=00,
minute=00,
second=59,
tzinfo=UTC)
NOV_2010 = datetime(2010,
11,
26,
hour=23,
minute=59,
second=59,
tzinfo=UTC)
today = datetime.today()
THIS_MONTH = datetime(today.year, today.month, 5, 12, 45, 58)
PREV_MONTH = THIS_MONTH - timedelta(days=8)
tree = get_location_tree()
sms_player = SMSPlayer(manager,
SubmissionHandler(manager),
location_tree=tree)
FROM_NUMBER = '1234567890'
TO_NUMBER = '261333782943'
transport = TransportInfo(SMS, FROM_NUMBER, TO_NUMBER)
message1 = "reg +t clinic +n Clinic in Analalava +l Analalava +g -14.6333 47.7667 +d This is a Clinic in Analalava +m 987654321"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in Andapa +l Andapa +g -14.65 49.6167 +d This is a Clinic in Andapa +m 87654322"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in Antalaha +l Antalaha +g -14.8833 50.25 +d This is a Clinic in Antalaha +m 87654323"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in ANALAMANGA +l ANALAMANGA +g -18.8 47.4833 +d This is a Clinic in Antananarivo +m 87654324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in TSIMANARIRAZANA +l TSIMANARIRAZANA +g -12.35 49.3 +d This is a Clinic in Diégo–Suarez +m 87654325"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in Antsirabe +l Antsirabe +g -19.8167 47.0667 +d This is a Clinic in Antsirabe +m 87654326"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in Besalampy +l Besalampy +g -16.75 44.5 +d This is a Clinic in Besalampy +m 87654327"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n clinique à Farafangana +l Farafangana +g -22.8 47.8333 +d This is a Clinic in Farafangana +m 87654328"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in Fianarantsoa I +l Fianarantsoa I +g -21.45 47.1 +d C'est une clinique à Fianarantsoa +m 87654329"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in Sainte Marie +l Sainte Marie +g -17.0833 49.8167 +d This is a Clinic in Île Sainte–Marie +m 87654330"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "reg +t clinic +n Clinic in Mahajanga +l Mahajanga +g -15.6667 46.35 +d This is a Clinic in Mahajanga +m 87654331"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
datetime_mocker = DateTimeMocker()
datetime_mocker.set_date_time_now(FEB)
# Total number of identical records = 3
message1 = "cli001 +EID cid001 +NA Mr. Tessy +FA 58 +RD 28.02.2011 +BG c +SY ade +GPS 79.2 20.34567"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid002 +NA Mr. Adam +FA 62 +RD 15.02.2011 +BG a +SY ab +GPS 74.2678 23.3567"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid003 +NA Ms. Beth +FA 75 +RD 09.02.2011 +BG b +SY bc +GPS 18.245 29.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
datetime_mocker.set_date_time_now(MARCH)
# Total number of identical records = 4
message1 = "cli001 +EID cid004 +NA Jannita +FA 90 +RD 07.03.2011 +BG b +SY bbe +GPS 45.233 28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid005 +NA Aanda +RD 12.03.2011 +BG c +SY bd +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = 'cli001 +EID cid001 +NA Ianda (",) +FA 34 +RD 27.03.2011 +BG d +SY be +GPS 38.3452 15.3345'
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid001 +NA ànita +FA 45 +RD 07.03.2011 +BG b +SY bbe +GPS 45.233 28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid004 +NA Amanda +RD 12.03.2011 +BG c +SY bd +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = 'cli001 +EID cid005 +NA Vanda (",) +FA 34 +RD 27.03.2011 +BG d +SY be +GPS 38.3452 15.3345'
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid003 +NA ànnita +FA 80 +RD 07.03.2011 +BG b +SY bbe +GPS 45.233 28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid002 +NA Amanda +RD 12.03.2011 +BG c +SY bd +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = 'cli001 +EID cid004 +NA Panda (",) +FA 34 +RD 27.03.2011 +BG d +SY be +GPS 38.3452 15.3345'
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid005 +NA ànnita +FA 50 +RD 07.03.2011 +BG b +SY bbe +GPS 45.233 28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid003 +NA Jimanda +RD 12.03.2011 +BG c +SY bd +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = 'cli001 +EID cli10 +NA Kanda (",) +FA 64 +RD 27.03.2011 +BG d +SY be +GPS 38.3452 15.3345'
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid004 +NA ànnita +FA 30 +RD 07.03.2011 +BG b +SY bbe +GPS 45.233 28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid005 +NA Qamanda +RD 12.03.2011 +BG c +SY bd +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = 'cli001 +EID cid001 +NA Huanda (*_*) +FA 74 +RD 27.03.2011 +BG d +SY be +GPS 38.3452 15.3345'
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
datetime_mocker.set_date_time_now(DEC_2010)
# Total number of identical records = 4
message1 = "cli001 +EID cli12 +FA 47 +RD 15.12.2010 +BG d +SY ace +GPS -58.3452 19.3345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli11 +NA De'melo +FA 38 +RD 27.12.2010 +BG c +SY ba +GPS 81.672 92.33456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli13 +NA Dono`mova +FA 24 +RD 06.12.2010 +BG b +SY cd +GPS 65.23452 -28.3456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli15 +NA Aàntra +FA 89 +RD 11.12.2010 +BG a +SY bd +GPS 45.234 89.32345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
datetime_mocker.set_date_time_now(NOV_2010)
# Total number of identical records = 3
message1 = "cli001 +EID cli12 +NA ànnita +FA 90 +RD 07.11.2010 +BG b +SY bbe +GPS 45.233 28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli14 +NA Amanda +RD 12.11.2010 +BG c +SY bd +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = 'cli001 +EID cli8 +NA Kanda (",) +FA 34 +RD 27.11.2010 +BG d +SY be +GPS 38.3452 15.3345'
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli9 +NA ànnita +FA 90 +RD 17.11.2010 +BG b +SY bbe +GPS 45.233 28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cid007 +NA Amanda +RD 12.11.2010 +BG c +SY bd +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = 'cli001 +EID cli8 +NA Kanda (",) +FA 34 +RD 27.11.2010 +BG d +SY be +GPS 38.3452 15.3345'
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
datetime_mocker.set_date_time_now(PREV_MONTH)
# Total number of identical records = 4
message1 = "cli001 +EID cli9 +NA Demelo +FA 38 +RD 17.05.2011 +BG c +SY ba +GPS 19.672 92.33456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli10 +NA Zorro +FA 48 +RD 05.05.2011 +BG b +SY cd +GPS 23.23452 -28.3456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli11 +NA Aàntra +FA 98 +RD 12.05.2011 +BG a +GPS -45.234 89.32345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli12 +NA ànnita +FA 37 +RD 05.05.2011 +BG d +SY cbe +GPS -78.233 -28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli9 +NA Demelo +FA 38 +RD 17.05.2011 +BG c +SY ba +GPS 19.672 92.33456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli10 +NA Zorro +FA 48 +RD 02.05.2011 +BG b +SY cd +GPS 23.23452 -28.3456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli11 +NA Aàntra +FA 95 +RD 12.05.2011 +BG a +GPS -45.234 89.32345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli12 +NA ànnita +FA 35 +RD 09.05.2010 +BG d +SY cbe +GPS -78.233 -28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli9 +NA Demelo +FA 32 +RD 27.05.2011 +BG c +SY ba +GPS 19.672 92.33456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli10 +NA Zorro +FA 43 +RD 05.05.2011 +BG b +SY cd +GPS 23.23452 -28.3456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli11 +NA Aàntra +FA 91 +RD 12.05.2011 +BG a +GPS -45.234 89.32345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli12 +NA ànnita +FA 45 +RD 15.05.2010 +BG d +SY cbe +GPS -78.233 -28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
datetime_mocker.set_date_time_now(THIS_MONTH)
# Total number of identical records = 4
message1 = "cli001 +EID cli13 +NA Dmanda +FA 69 +RD 05.06.2011 +BG c +SY ce +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli14 +NA Vamand +FA 36 +RD 03.06.2011 +BG a +SY ace +GPS 58.3452 115.3345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli15 +NA M!lo +FA 88 +RD 02.06.2011 +SY ba +GPS 19.672 92.33456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli16 +NA K!llo +FA 88 +GPS 19.672 92.33456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli13 +NA Dmanda +FA 89 +RD 04.06.2011 +BG c +SY ce +GPS 40.2 69.3123"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli14 +NA Vamand +FA 56 +RD 01.06.2011 +BG a +SY ace +GPS 58.3452 115.3345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli15 +NA M!lo +FA 45 +RD 07.06.2011 +SY ba +GPS 19.672 92.33456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli16 +NA K!llo +FA 28 +GPS 19.672 92.33456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
datetime_mocker.end_mock()
# Total number of identical records = 3
message1 = "cli001 +EID cli17 +NA Catty +FA 78 +RD 15.06.2011 +BG b +SY dce +GPS 33.23452 -68.3456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli18 +NA àntra +FA 28 +RD 12.06.2011 +BG a +SY adb +GPS -45.234 169.32345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli9 +NA Tinnita +FA 37 +BG d +SY ace +GPS -78.233 -28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli17 +NA Catty +FA 98 +RD 25.06.2011 +BG b +SY dce +GPS 33.23452 -68.3456"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli18 +NA àntra +FA 58 +RD 22.06.2011 +BG a +SY adb +GPS -45.234 169.32345"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
message1 = "cli001 +EID cli9 +NA Tinnita +FA 27 +BG d +SY ace +GPS -78.233 -28.3324"
response = sms_player.accept(
Request(transportInfo=transport, message=message1))
class TestSubmissions(TestCase):
def setUp(self):
self.FORM_CODE = "QR1"
self.VALUES = {"EID": "100", "Q1": "20"}
self.dbm = Mock(spec=DatabaseManager)
self.form_model_patcher = patch('mangrove.transport.submissions.get_form_model_by_code')
self.form_submission_entity_patcher = patch('mangrove.form_model.form_model.entity')
self.SubmissionLogger_class_patcher = patch('mangrove.transport.submissions.SubmissionLogger', )
self.get_form_model_mock = self.form_model_patcher.start()
self.form_submission_entity_module = self.form_submission_entity_patcher.start()
self.SubmissionLogger_mock_class = self.SubmissionLogger_class_patcher.start()
self.submissionLogger = Mock(spec=SubmissionLogger)
self.SubmissionLogger_mock_class.return_value = self.submissionLogger
self.SUBMISSION_ID = "SUBMISSION_ID"
self.submissionLogger.create_submission_log.return_value = self.SUBMISSION_ID
self.form_model_mock = Mock(spec=FormModel)
self.form_model_mock.is_registration_form.return_value = False
self.form_model_mock.entity_defaults_to_reporter.return_value = False
self.form_model_mock.is_inactive.return_value = False
self.form_model_mock.is_in_test_mode.return_value = False
self.ENTITY_TYPE = ["entity_type"]
self.form_model_mock.entity_type = self.ENTITY_TYPE
entity_question = Mock()
entity_question.code = "eid"
self.form_model_mock.entity_question = entity_question
self.get_form_model_mock.return_value = self.form_model_mock
self.sms = Channel.SMS
reporter = Mock(spec=Entity)
reporter.short_code.return_value = "REP1"
self.submission_request = SubmissionRequest(form_code=self.FORM_CODE, submission=self.VALUES,
transport=self.sms
, source="1234", destination="5678", reporter=reporter)
self.submission_handler = SubmissionHandler(self.dbm)
def tearDown(self):
self.form_model_patcher.stop()
self.form_submission_entity_patcher.stop()
def _valid_form_submission(self):
return FormSubmission(self.form_model_mock, {'eid': 'CID001', "location": "Pune"})
def _valid_form_submission_unicode(self):
return FormSubmission(self.form_model_mock, {'eid': u'Āgra', "location": "Agra"})
def _invalid_form_submission_unicode(self):
return FormSubmission(self.form_model_mock, {}, {"field": u"Āgra"})
def _valid_form_submission_with_choices(self):
return FormSubmission(self.form_model_mock,
{'eid': 'CID001', "location": "Pune", "favourite_colour": ['red']})
def _empty_form_submission(self):
return FormSubmission(self.form_model_mock, {'eid': 'CID001'})
def _invalid_form_submission(self):
return FormSubmission(self.form_model_mock, {}, {"field": "Invalid"})
def test_should_return_true_if_valid_form_submission(self):
self.form_model_mock.validate_submission.return_value = self._valid_form_submission()
response = self.submission_handler.accept(self.submission_request)
self.assertTrue(response.success)
self.assertEqual({}, response.errors)
self.assertFalse(response.is_registration)
def test_should_save_data_record_if_valid_form_submission(self):
self.form_model_mock.validate_submission.return_value = self._valid_form_submission()
self.submission_handler.accept(self.submission_request)
self.assertTrue(self.form_submission_entity_module.get_by_short_code.called)
def test_should_not_save_data_record_if_in_valid_form_submission(self):
self.form_model_mock.validate_submission.return_value = self._invalid_form_submission()
response = self.submission_handler.accept(self.submission_request)
self.assertEqual({"field": "Invalid"}, response.errors)
self.assertFalse(response.success)
self.assertFalse(response.is_registration)
def test_should_not_save_data_record_if_no_valid_questions_present(self):
self.form_model_mock.validate_submission.side_effect = NoQuestionsSubmittedException()
with self.assertRaises(NoQuestionsSubmittedException):
self.submission_handler.accept(self.submission_request)
def test_should_create_new_submission_log(self):
form_submission = self._valid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
self.submission_handler.accept(self.submission_request)
self.assertTrue(self.submissionLogger.create_submission_log.called)
def test_should_update_submission_log_on_success(self):
form_submission = self._valid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
self.submissionLogger.update_submission_log.assert_called_once_with(submission_id=self.SUBMISSION_ID,
status=True, errors=None,
data_record_id=response.datarecord_id,
in_test_mode=False)
def test_should_update_submission_log_on_failure(self):
form_submission = self._invalid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
self.submission_handler.accept(self.submission_request)
self.submissionLogger.update_submission_log.assert_called_once_with(submission_id=self.SUBMISSION_ID,
status=False,
data_record_id=None,
errors=form_submission.errors,
in_test_mode=False)
def test_should_fail_submission_if_invalid_form_code(self):
self.get_form_model_mock.side_effect = FormModelDoesNotExistsException("INVALID_CODE")
with self.assertRaises(FormModelDoesNotExistsException):
self.submission_handler.accept(self.submission_request)
def test_should_fail_submission_if_invalid_short_code(self):
form_submission = self._valid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
self.form_submission_entity_module.get_by_short_code.side_effect = DataObjectNotFound("Entity", 'id',
'short_code')
with self.assertRaises(DataObjectNotFound):
self.submission_handler.accept(self.submission_request)
self.submissionLogger.update_submission_log.assert_called_once_with(submission_id=self.SUBMISSION_ID,
status=False,
errors=u'Entity with id = short_code not found.'
,
in_test_mode=False)
def test_should_register_entity_if_form_submission_valid(self):
self.form_model_mock.validate_submission.return_value = self._valid_form_submission()
self.form_model_mock.is_registration_form.return_value = True
response = self.submission_handler.accept(self.submission_request)
self.assertTrue(response.success)
self.assertEqual({}, response.errors)
self.assertEqual("cid001", response.short_code)
self.assertTrue(response.is_registration)
self.form_submission_entity_module.create_entity.assert_called_once_with(dbm=self.dbm, entity_type=self
.ENTITY_TYPE,
location=None,
short_code="cid001", geometry=None)
self.submissionLogger.update_submission_log.assert_called_once_with(submission_id=self.SUBMISSION_ID,
status=True, errors=None,
data_record_id=response.datarecord_id,
in_test_mode=False)
def test_should_not_register_entity_if_form_submission_invalid(self):
form_submission = self._invalid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
self.form_model_mock.is_registration_form.return_value = True
response = self.submission_handler.accept(self.submission_request)
self.assertFalse(response.success)
self.assertEqual({"field": "Invalid"}, response.errors)
self.assertTrue(response.is_registration)
self.assertFalse(self.form_submission_entity_module.create_entity.called)
self.submissionLogger.update_submission_log.assert_called_once_with(submission_id=self.SUBMISSION_ID,
status=False,
data_record_id=None,
errors=form_submission.errors,
in_test_mode=False)
def test_should_return_expanded_response(self):
form_submission = self._valid_form_submission_with_choices()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
expected_message = form_submission.cleaned_data
self.assertEquals(expected_message, response.processed_data)
def test_should_accept_unicodes_for_valid_submission(self):
form_submission = self._valid_form_submission_unicode()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
self.assertTrue(response.success)
self.assertEqual({}, response.errors)
def test_should_accept_unicodes_for_invalid_submission(self):
form_submission = self._invalid_form_submission_unicode()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
self.assertFalse(response.success)
self.assertEqual({'field': u'Āgra'}, response.errors)
def test_should_raise_inactive_form_model_exception(self):
self.form_model_mock.is_inactive.return_value = True
with self.assertRaises(InactiveFormModelException):
self.submission_handler.accept(self.submission_request)
def test_should_log_submissions_in_test_mode(self):
self.form_model_mock.is_in_test_mode.return_value = True
self.form_model_mock.is_inactive.return_value = False
form_submission = self._valid_form_submission()
self.form_model_mock.validate_submission.return_value = form_submission
response = self.submission_handler.accept(self.submission_request)
self.assertTrue(response.success)
self.assertIsNotNone(response.datarecord_id)
self.assertIsNotNone(response.submission_id)
def test_should_convert_mobile_number_to_string(self):
actual_value = self.submission_handler._get_telephone_number(u'2.66123321435e+11')
expected_value = unicode(266123321435)
self.assertEqual(expected_value, actual_value)
actual_value = self.submission_handler._get_telephone_number(u'266123321')
expected_value = u'266123321'
self.assertEqual(expected_value, actual_value)
def test_should_strip_non_numbers_from_mobile_number(self):
actual_value = self.submission_handler._get_telephone_number(u'26554-2123')
expected_value = u'265542123'
self.assertEqual(expected_value, actual_value)
