def test_should_validate_single_answer(self): with self.assertRaises(AnswerHasTooManyValuesException) as e: clinic_field = SelectField(name="clinic type", code="Q1", label="What type of clinic is it?", language="eng", options=["village", "urban"], single_select_flag=True, ddtype=self.ddtype) clinic_field.validate("vu") self.assertEqual(e.exception.message, "Answer vu for question Q1 contains more than one value.")
def test_should_escape_special_characters_from_requested_form(self): dbm = Mock() questionnaire_mock = Mock() field1 = SelectField(name='name&', label='name&', code='selectcode', instruction='instruction&', options=[{ 'text': 'option1&', 'val': 'o1' }]) questionnaire_mock.name = '<mock_name' questionnaire_mock.fields = [field1] questionnaire_mock.form_code = 'form_code' questionnaire_mock.id = 'id' questionnaire_mock.unique_id_field = None questionnaire_mock.xform = None with patch("mangrove.transport.xforms.xform.FormModel" ) as form_model_mock: form_model_mock.get.return_value = questionnaire_mock one_of_unicode_unknown_ = xform_for(dbm, "someFormId", 'rep1') expected = unicode(expected_xform_with_escaped_characters) self.assertTrue( self.checker.check_output(one_of_unicode_unknown_, expected, 0))
def test_should_replace_answer_option_values_with_options_text_when_answer_type_is_changed_from_single_select_choice_field( self): survey_response_doc = SurveyResponseDocument(values={ 'q1': 'a', }) survey_response = SurveyResponse(Mock()) survey_response._doc = survey_response_doc choice_field = SelectField(name='question one', code='q1', label='question one', options=[("one", "a"), ("two", "b"), ("three", "c"), ("four", "d")], single_select_flag=True) text_field = TextField(name='question one', code='q1', label='question one') questionnaire_form_model = Mock(spec=FormModel) questionnaire_form_model.form_code = 'test_form_code' questionnaire_form_model.fields = [text_field] questionnaire_form_model.get_field_by_code_and_rev.return_value = choice_field request_dict = construct_request_dict(survey_response, questionnaire_form_model, 'id') expected_dict = { 'q1': 'one', 'form_code': 'test_form_code', 'dsid': 'id' } self.assertEqual(request_dict, expected_dict)
def _create_form_model(self): self.entity_type = ["HealthFacility", "Clinic"] question1 = UniqueIdField('clinic', name="entity_question", code="ID", label="What is associated entity") question2 = TextField( name="question1_Name", code="Q1", label="What is your name", defaultValue="some default value", constraints=[TextLengthConstraint(5, 10), RegexConstraint("\w+")]) question3 = IntegerField( name="Father's age", code="Q2", label="What is your Father's Age", constraints=[NumericRangeConstraint(min=15, max=120)]) question4 = SelectField(name="Color", code="Q3", label="What is your favourite color", options=[("RED", 'a'), ("YELLOW", 'b')]) self.form_model = FormModelBuilder( self.manager, self.entity_type, "1").label("Aids form_model").name("aids").add_fields( question1, question2, question3, question4).build() self.form_model_id = self.form_model.id
def _create_summary_form_model(self): question1 = TextField( name="question1_Name", code="Q1", label="What is your name", defaultValue="some default value", constraints=[TextLengthConstraint(5, 10), RegexConstraint("\w+")], ddtype=self.default_ddtype) question2 = IntegerField( name="Father's age", code="Q2", label="What is your Father's Age", constraints=[NumericRangeConstraint(min=15, max=120)], ddtype=self.default_ddtype) question3 = SelectField(name="Color", code="Q3", label="What is your favourite color", options=[("RED", 1), ("YELLOW", 2)], ddtype=self.default_ddtype) self.summary_form_model = FormModel( self.manager, entity_type=["reporter"], name="aids", label="Aids form_model", form_code=FORM_CODE_2, type="survey", fields=[question1, question2, question3]) self.summary_form_model__id = self.summary_form_model.save()
def _get_cascade_questionnaire(self, cascades): fields = [] for cascade in cascades: fields.append( SelectField(cascade, cascade, "Please select", cascades[cascade], is_cascade=True)) doc = ProjectDocument() doc.xform = self._build_xform(fields=fields, field_type="cascade", cascades=cascades) questionnaire = Project.new_from_doc(DatabaseManagerStub(), doc) questionnaire.name = "q1" questionnaire.form_code = "007" questionnaire.fields.append( FieldSet(code="group_outer", name="group_outer", label="Enter the outer group details", field_set=[ FieldSet(code="repeat_outer", name="repeat_outer", label="Enter the details you wanna repeat", field_set=fields) ])) return questionnaire
def test_should_create_a_questionnaire_from_dictionary(self): #entityQ = UniqueIdField('reporter', name="What are you reporting on?", code="eid", # label="Entity being reported on", ) ageQ = IntegerField( name="What is your age?", code="AGE", label="", constraints=[NumericRangeConstraint(min=0, max=10)], required=False) placeQ = SelectField(name="Where do you live?", code="PLC", label="", options=[{ "text": "Pune" }, { "text": "Bangalore" }], single_select_flag=False, required=False) questions = [ageQ, placeQ] document = self.get_form_model_doc() questionnaire = FormModel.new_from_doc(self.manager, document) self.maxDiff = None self.assertListEqual(questionnaire.entity_type, []) self.assertEqual(questionnaire.name, "New Project") for i in range(len(questions)): self.assertEqual(questionnaire.fields[i]._to_json(), questions[i]._to_json())
def test_log_edit_of_existing_successful_submission(self): difference = SurveyResponseDifference(submitted_on=datetime(2013, 02, 23), status_changed=True) difference.changed_answers = {'q1': {'old': 23, 'new': 43}, 'q2': {'old': 'text2', 'new': 'correct text'}, 'q3': {'old': 'a', 'new': 'ab'}} original_survey_response = Mock(spec=SurveyResponse) edited_survey_response = Mock(spec=SurveyResponse) edited_survey_response.differs_from.return_value = difference project_name = 'project_name' request = Mock() form_model = Mock(spec=FormModel) int_field = IntegerField(name='question one', code='q1', label='question one') text_field = TextField(name='question two', code='q2', label='question two') choice_field = SelectField(name='question three', code='q3', label='question three', options=[("one", "a"), ("two", "b"), ("three", "c"), ("four", "d")], single_select_flag=False) form_model.get_field_by_code.side_effect = lambda x: {'q1': int_field, 'q2': text_field, 'q3': choice_field}[x] with patch('datawinners.project.views.submission_views.UserActivityLog') as activity_log: with patch( 'datawinners.project.views.submission_views.get_option_value_for_field') as get_option_value_for_field: get_option_value_for_field.return_value = {'old': u'one', 'new': u'one, two'} mock_log = Mock(spec=UserActivityLog) activity_log.return_value = mock_log log_edit_action(original_survey_response, edited_survey_response, request, project_name, form_model) expected_changed_answer_dict = { 'received_on': difference.created.strftime(SUBMISSION_DATE_FORMAT_FOR_SUBMISSION), 'status_changed': True, 'changed_answers': {'question one': {'old': 23, 'new': 43}, 'question two': {'old': 'text2', 'new': 'correct text'}, 'question three': {'old': u'one', 'new': u'one, two'}}} form_model.get_field_by_code.assert_calls_with([call('q1'), call('q2'), call('q3')]) mock_log.log.assert_called_once_with(request, action=EDITED_DATA_SUBMISSION, project=project_name, detail=json.dumps(expected_changed_answer_dict))
def test_should_return_default_language_text(self): expected_json = { "choices": [{ "text": "Lake" }, { "text": "Dam" }], "name": "type", 'parent_field_code': None, "type": "select1", "code": "T", "label": "What type?", "required": True, "instruction": "test", } field = SelectField(name="type", code="T", label="What type?", options=[{ "text": "Lake" }, { "text": "Dam" }], instruction="test", single_select_flag=True) actual_json = field._to_json_view() self.assertEqual(actual_json, expected_json)
def test_should_return_none_if_survey_response_questionnaire_is_different_from_form_model( self): survey_response_doc = SurveyResponseDocument(values={ 'q5': '23', 'q6': 'sometext', 'q7': 'ab' }) survey_response = SurveyResponse(Mock()) survey_response._doc = survey_response_doc int_field = IntegerField(name='question one', code='q1', label='question one') text_field = TextField(name='question two', code='q2', label='question two') choice_field = SelectField(name='question three', code='Q3', label='question three', options=[("one", "a"), ("two", "b"), ("three", "c"), ("four", "d")], single_select_flag=False) questionnaire_form_model = Mock(spec=FormModel) questionnaire_form_model.form_code = 'test_form_code' questionnaire_form_model.fields = [int_field, text_field, choice_field] result_dict = construct_request_dict(survey_response, questionnaire_form_model, 'id') expected_dict = { 'q1': None, 'q2': None, 'Q3': None, 'form_code': 'test_form_code', 'dsid': 'id' } self.assertEqual(expected_dict, result_dict)
def test_should_get_comma_separated_list_if_field_changed_from_choice_to_unique_id( self): search_dict = {} options = [{ 'text': 'option1', 'val': 'a' }, { 'text': 'option2', 'val': 'b' }] self.form_model.fields = [self.field1] original_field = SelectField('selectField', 'q1', 'q1', options) self.form_model.get_field_by_code_and_rev.return_value = original_field values = {'q1': 'ab', 'q2': 'wrong number', 'q3': 'wrong text'} submission_doc = SurveyResponseDocument(values=values, status="error") with patch('datawinners.search.submission_index.lookup_entity_name' ) as lookup_entity_name: lookup_entity_name.return_value = 'N/A' _update_with_form_model_fields(Mock(spec=DatabaseManager), submission_doc, search_dict, self.form_model) self.assertEquals( { '1212_q1': 'N/A', '1212_q1_unique_code': 'option1,option2', 'void': False }, search_dict)
def test_should_get_statistic_result_after_option_value_changed(self): """ Function to test getting statistic result of submissions after option value changed. question name ordered by field options ordered by count(desc),option(alphabetic) total = submission count of this question """ eid_field = TextField(label="What is associated entity?", code="EID", name="What is associatéd entity?", entity_question_flag=True, ddtype=self.ddtype) blood_type_field = SelectField(label="What is your blood group?", code="BG", name="What is your blood group?", options=[("Type 1", "a"), ("Type 2", "b")], single_select_flag=True, ddtype=self.ddtype) form_model = FormModelBuilder(self.manager, ['clinic'], form_code='cli001').add_fields( eid_field, blood_type_field).build() self.submit_data({'form_code': 'cli001', 'EID': 'cid001', 'BG': 'a'}) blood_type_field = SelectField(label="What is your blood group?", code="BG", name="What is your blood group?", options=[("O+", "a"), ("O-", "b"), ("AB", "c"), ("B+", "d")], single_select_flag=True, ddtype=self.ddtype) self._edit_fields(form_model, blood_type_field) self.submit_data({'form_code': 'cli001', 'EID': 'cid001', 'BG': 'a'}) submissions = successful_submissions(self.manager, form_model.form_code) analyzer = SubmissionAnalyzer(form_model, self.manager, self.org_id, submissions) statistics = analyzer.get_analysis_statistics() expected = [[ "What is your blood group?", field_attributes.SELECT_FIELD, 2, [["O+", 1], ['Type 1', 1], ["AB", 0], ["B+", 0], ["O-", 0]] ]] self.assertEqual(expected, statistics)
def test_should_remove_spaces_if_present_in_answer_for_multi_select(self): field = SelectField(name="color", code="Q3", label="What is your favorite color", options=[("RED", 'a'), ("YELLOW", 'b'), ('green')], single_select_flag=False, instruction="test_instruction") self.assertEqual(['RED', 'YELLOW'], field.validate('a b'))
def test_get_option_value_for_other_field_changed_to_choice_fields(self): choices = {"old": "hi", "new": "ab"} choice_field = SelectField(name='question', code='q1', label="question", options=[("one", "a"), ("two", "b"), ("three", "c"), ("four", "d")], single_select_flag=False, ) result_dict = get_option_value_for_field(choices, choice_field) expected = {"old": "hi", "new": "one, two"} self.assertEqual(expected, result_dict)
def _create_select_question(post_dict, single_select_flag, ddtype): options = [choice.get("text") for choice in post_dict["choices"]] return SelectField(name=post_dict["title"], code=post_dict["code"].strip(), label="default", options=options, single_select_flag=single_select_flag, ddtype=ddtype, instruction=post_dict.get("instruction"))
def test_select_field_creation_with_multi_select(self): select_field = SelectField( "select something", "some_code", "what do u want to select", [('opt1', 'a'), ('opt2', 'b'), ('opt3', 'c')], "Choose 1 or more answers from the list. Example: a or ab ", single_select_flag=False) select_field.value = 'opt1,opt2' choice_field = FormField().create(select_field) self.assertTrue( isinstance(choice_field.widget, forms.CheckboxSelectMultiple)) self.assertEquals(choice_field.initial, ['a', 'b']) self.assertEquals([('a', 'opt1'), ('b', 'opt2'), ('c', 'opt3')], choice_field.choices) self.assertEqual( choice_field.help_text, "Choose 1 or more answers from the list. Example: a or ab ")
def test_should_return_choices_type_as_select(self): field = SelectField(name="What's the color?", code="nam", label="naam", options=[("Red", "a"), ("Green", "b"), ("Blue", "c")], single_select_flag=False) preview = helper.get_preview_for_field(field) self.assertEqual("select", preview["type"])
def test_should_return_choices(self): field = SelectField(name="What's the color?", code="nam", label="naam", options=[("Red", "a"), ("Green", "b"), ("Blue", "c")]) preview = helper.get_preview_for_field(field) self.assertEqual("select1", preview["type"]) self.assertEqual([("Red", "a"), ("Green", "b"), ("Blue", "c")], preview["constraints"])
def _create_select_question(self, post_dict, single_select_flag, code): options = [(choice['value'].get("text"), choice['value'].get("val")) for choice in post_dict["choices"]] return SelectField(name=self._get_name(post_dict), code=code, label=post_dict["title"], options=options, single_select_flag=single_select_flag, instruction=post_dict.get("instruction"), required=post_dict.get("required"))
def create_test_fields_and_survey_for_all_fields_type(self): name = TextField('name', 'name' ,'What is your name?') degree = TextField('degree', 'degree' ,'Degree name') completed_on = DateField('completed_on', 'completed_on','Degree completion year', 'dd.mm.yyyy') education = FieldSet('education', 'education', 'Education', field_set=[degree,completed_on]) age = IntegerField('age', 'age' ,'What is your age?') opt_fav_col = [('red','Red'), ('blue','Blue'),('c','Green')] fav_col = SelectField('fav_color', 'fav_color', 'Which colors you like?', opt_fav_col) opt_pizza_col = [('yes', 'Yes'),('no','No')] pizza_fan = SelectField('pizza_fan', 'pizza_fan', 'Do you like pizza?', opt_pizza_col) other = TextField('other', 'other' ,'What else you like?') pizza_type = TextField('pizza_type', 'pizza_type' ,'Which pizza type you like?') location = GeoCodeField('location', 'location' ,'Your location?') form_fields = [name, education, age, fav_col, pizza_fan, other, pizza_type, location] # todo how required will be handled survey_response_values = {'name': 'Santa', 'pizza_type': None, 'age': '30', 'other': 'Samosa', 'location': '4.9158,11.9531', 'education': [{'completed_on': u'10.02.2014', 'degree': 'SantaSSC'}], 'pizza_fan': 'yes', 'fav_color': 'red blue'} return form_fields, survey_response_values
def test_should_convert_multiple_select_field_to_html(self): exptected_html = """<select name="color" MULTIPLE><option value="1">RED</option><option value="2">YELLOW</option><option value="3">green</option></select>""" field = SelectField(name="color", code="Q3", label="What is your favorite color", language="eng", options=[("RED", 1), ("YELLOW", 2), ('green', 3)], single_select_flag=False, ddtype=self.ddtype, instruction="test_instruction") self.assertEqual(exptected_html, field.to_html())
def setUp(self): self.form_model = MagicMock(spec=FormModel, id="1212") self.field1 = UniqueIdField(unique_id_type='clinic', name='unique_id', code="q1", label='which clinic') self.field2 = TextField('text', "q2", "enter text") self.field3 = GeoCodeField('gps', "q3", "enter gps") self.field4 = SelectField('select', 'q4', 'select multple options', [{ 'text': 'one', 'val': 'a' }, { 'text': 'two', 'val': 'b' }], single_select_flag=False) self.field5 = DateField('date', 'q5', 'enter date', 'mm.dd.yyyy') self.field6 = SelectField('select', 'single-select', 'select one option', [{ 'text': 'one', 'val': 'a' }, { 'text': 'two', 'val': 'b' }], single_select_flag=True) self.repeat_question = FieldSet(name="repeat", code="repeat-code", label="repeat-label", fieldset_type="repeat", field_set=[self.field4, self.field6]) self.group_question = FieldSet(name="group", code="group-code", label="group-label", fieldset_type="group", field_set=[self.field4, self.field6]) self.dbm = MagicMock(spec=DatabaseManager)
def test_should_return_choices(self): type = DataDictType(Mock(DatabaseManager), name="color type") field = SelectField(name="What's the color?", code="nam", label="naam", ddtype=type, options=[("Red", "a"), ("Green", "b"), ("Blue", "c")]) preview = helper.get_preview_for_field(field) self.assertEqual("select1", preview["type"]) self.assertEqual([("Red", "a"), ("Green", "b"), ("Blue", "c")], preview["constraints"])
def test_should_get_latest_field_if_no_revision_provided_and_no_snapshots( self): self.form_model.delete_field(code="Q3") field = SelectField(name="New Name", code="Q3", label="What is your favourite color", options=[("RED", 1), ("YELLOW", 2)]) self.form_model.add_field(field) self.form_model.save() updated_form = FormModel.get(self.manager, self.form_model_id) self.assertEqual("New Name", updated_form.get_field_by_code_and_rev("Q3").name)
def test_convert_survey_response_values_to_dict_format(self): survey_response_doc = SurveyResponseDocument( values={ 'q1': '23', 'q2': 'sometext', 'q3': 'a', 'geo': '2.34,5.64', 'date': '12.12.2012' }) survey_response = SurveyResponse(Mock()) survey_response._doc = survey_response_doc int_field = IntegerField(name='question one', code='q1', label='question one', ddtype=Mock(spec=DataDictType)) text_field = TextField(name='question two', code='q2', label='question two', ddtype=Mock(spec=DataDictType)) single_choice_field = SelectField(name='question three', code='q3', label='question three', options=[("one", "a"), ("two", "b"), ("three", "c"), ("four", "d")], single_select_flag=True, ddtype=Mock(spec=DataDictType)) geo_field = GeoCodeField(name='geo', code='GEO', label='geo', ddtype=Mock()) date_field = DateField(name='date', code='DATE', label='date', date_format='dd.mm.yyyy', ddtype=Mock()) questionnaire_form_model = Mock(spec=FormModel) questionnaire_form_model.form_code = 'test_form_code' questionnaire_form_model.fields = [ int_field, text_field, single_choice_field, geo_field, date_field ] request_dict = construct_request_dict(survey_response, questionnaire_form_model) expected_dict = OrderedDict({ 'q1': '23', 'q2': 'sometext', 'q3': 'a', 'GEO': '2.34,5.64', 'DATE': '12.12.2012', 'form_code': 'test_form_code' }) self.assertEqual(expected_dict, request_dict)
def _create_select_question(self, post_dict, single_select_flag, code): options = [(choice['value'].get("text"), choice['value'].get("val")) for choice in post_dict["choices"]] return SelectField(name=self._get_name(post_dict, code), code=code, label=post_dict["title"], options=options, single_select_flag=single_select_flag, instruction=post_dict.get("instruction"), required=post_dict.get("required"), parent_field_code=post_dict.get('parent_field_code'), has_other=post_dict.get('has_other'), hint=post_dict.get('hint'), constraint_message=post_dict.get('constraint_message'), appearance=post_dict.get('appearance'), default=post_dict.get('default'), xform_constraint=post_dict.get('xform_constraint'), relevant=post_dict.get('relevant'), is_cascade=post_dict.get('is_cascade'))
def setUp(self): self.dbm = Mock(spec=DatabaseManager) self.datadict_patcher = patch( "mangrove.form_model.form_model.get_or_create_data_dict") self.datadict_mock = self.datadict_patcher.start() self.ddtype_mock = Mock(spec=DataDictType) self.datadict_mock.return_value = self.ddtype_mock q1 = TextField(name="entity_question", code="ID", label="What is associated entity", language="eng", entity_question_flag=True, ddtype=self.ddtype_mock) q2 = TextField(name="question1_Name", code="Q1", label="What is your name", defaultValue="some default value", language="eng", length=TextConstraint(5, 10), ddtype=self.ddtype_mock) q3 = IntegerField(name="Father's age", code="Q2", label="What is your Father's Age", range=NumericConstraint(min=15, max=120), ddtype=self.ddtype_mock) q4 = SelectField(name="Color", code="Q3", label="What is your favourite color", options=[("RED", 1), ("YELLOW", 2)], ddtype=self.ddtype_mock) q5 = TextField(name="Desc", code="Q4", label="Description", ddtype=self.ddtype_mock) self.form_model = FormModel( self.dbm, entity_type=["XYZ"], name="aids", label="Aids form_model", form_code="1", type='survey', fields=[ # expected_short_code = "dog3" # self.assertEqual(response.short_code, expected_short_code) # b = get_by_short_code(self.dbm, expected_short_code, ["dog"]) # self.assertEqual(b.short_code, expected_short_code) q1, q2, q3, q4, q5 ])
def test_single_select_field_value_representation(self): value_mock = PropertyMock(return_value={'q4': 'b'}) type(self.survey_response).values = value_mock select_field = SelectField('name', 'q4', 'select', [{'text': 'orange', 'val': 'a'}, {'text': 'mango', 'val': 'b'}, {'text': 'apple', 'val': 'c'}]) builder = EnrichedSurveyResponseBuilder(None, self.survey_response, self.form_model, {}) dictionary = builder._create_answer_dictionary(select_field) self.assertEquals({'b': 'mango'}, dictionary.get('answer')) self.assertEquals('select', dictionary.get('label')) self.assertEquals('select1', dictionary.get('type'))
def test_should_create_multi_select_field_type_for_default_english_language( self): expected_json = { "label": "What is your favorite color", "name": "color", "choices": [{ "text": "RED", "val": 'a' }, { "text": "YELLOW", "val": 'b' }, { "text": 'green', 'val': 'green' }], "code": "Q3", "parent_field_code": None, "type": "select", "required": True, "instruction": "test_instruction", "appearance": None, "constraint_message": None, "default": None, "hint": None, "xform_constraint": None, "relevant": None, "is_cascade": False } field = SelectField(name="color", code="Q3", label="What is your favorite color", options=[("RED", 'a'), ("YELLOW", 'b'), ('green')], single_select_flag=False, instruction="test_instruction") actual_json = field._to_json() self.assertEqual(actual_json, expected_json) field.set_value(field.validate('ab')) self.assertEqual("RED,YELLOW", field.convert_to_unicode())
def test_should_return_according_value_for_select_field_case_insensitively( self): ddtype = Mock(spec=DataDictType) single_select = SelectField(label="multiple_choice_question", code="q", options=[("red", "a"), ("yellow", "b"), ('green', "c")], name="What is your favourite colour", ddtype=ddtype) multiple_answer = SelectField(label="multiple_choice_question", code="q1", single_select_flag=False, options=[("value_of_a", "a"), ("value_of_b", "b"), ("value_of_c", 'c'), ("d", "d"), ("e", "e"), ('f', "f"), ("g", "g"), ("h", "h"), ('i', "i"), ("j", "j"), ("k", "k"), ('l', "l"), ("m", "m"), ("n", "n"), ('o', "o"), ("p", "p"), ("q", "q"), ('r', "r"), ("s", "s"), ("t", "t"), ('u', "u"), ("v", "v"), ("w", "w"), ('x', "x"), ("y", "y"), ("z", "z"), ("value_of_1a", '1a'), ("value_of_1b", "1b"), ("value_of_1c", "1c"), ('1d', "1d")], name="What is your favourite colour", ddtype=ddtype) values = dict({"q": "B", "q1": "b1A1c"}) single_value = helper.get_according_value(values, single_select) multiple_value = helper.get_according_value(values, multiple_answer) self.assertEquals(single_value, "yellow") self.assertEqual(multiple_value, "value_of_b, value_of_1a, value_of_1c")
def init_form_model_fields(self): self.eid_field = TextField(label="What is associated entity?", code="EID", name="What is associatéd entity?", entity_question_flag=True, ddtype=Mock()) self.rp_field = DateField( label="Report date", code="RD", name="What is réporting date?", date_format="dd.mm.yyyy", event_time_field_flag=True, ddtype=Mock(), instruction= "Answer must be a date in the following format: day.month.year. Example: 25.12.2011" ) self.symptoms_field = SelectField(label="Zhat are symptoms?", code="SY", name="Zhat are symptoms?", options=[("Rapid weight loss", "a"), ("Dry cough", "2b"), ("Pneumonia", "c"), ("Memory loss", "d"), ("Neurological disorders ", "e")], single_select_flag=False, ddtype=Mock()) self.blood_type_field = SelectField(label="What is your blood group?", code="BG", name="What is your blood group?", options=[("O+", "a"), ("O-", "b"), ("AB", "c"), ("B+", "d")], single_select_flag=True, ddtype=Mock()) self.gps_field = GeoCodeField(name="field1_Loc", code="gps", label="Where do you stay?", ddtype=Mock())