def test_answers_can_be_imported_from_xml(self):
        surv = Survey(name="data")

        surv.add_child(
            create_survey_element_from_dict(
                {"type": "text", "name": "name", "label": "Name"}
            )
        )
        surv.add_child(
            create_survey_element_from_dict(
                {
                    "type": "integer",
                    "name": "users_per_month",
                    "label": "Users per month",
                }
            )
        )
        surv.add_child(
            create_survey_element_from_dict(
                {"type": "gps", "name": "geopoint", "label": "gps"}
            )
        )
        surv.add_child(
            create_survey_element_from_dict({"type": "imei", "name": "device_id"})
        )

        instance = surv.instantiate()
        import_xml = self.config.get(
            self.cls_name, "test_answers_can_be_imported_from_xml"
        )
        instance.import_from_xml(import_xml)

 def test_simple_survey_answering(self):
     surv = Survey(name=u"Water")
     q = create_survey_element_from_dict({u"type":u"text", u"name":u"color", u"label": u"Color"})
     q2 = create_survey_element_from_dict({u"type":u"text", u"name":u"feeling", u"label": u"Feeling"})
     
     surv.add_child(q)
     surv.add_child(q2)
     i = SurveyInstance(surv)
     
     i.answer(name=u"color", value=u"blue")
     self.assertEquals(i.answers()[u'color'], u"blue")
     
     i.answer(name=u"feeling", value=u"liquidy")
     self.assertEquals(i.answers()[u'feeling'], u"liquidy")

def xls2xform_convert(
    xlsform_path, xform_path, validate=True, pretty_print=True, enketo=False
):
    warnings = []

    json_survey = xls2json.parse_file_to_json(xlsform_path, warnings=warnings)
    survey = builder.create_survey_element_from_dict(json_survey)
    # Setting validate to false will cause the form not to be processed by
    # ODK Validate.
    # This may be desirable since ODK Validate requires launching a subprocess
    # that runs some java code.
    survey.print_xform_to_file(
        xform_path,
        validate=validate,
        pretty_print=pretty_print,
        warnings=warnings,
        enketo=enketo,
    )
    output_dir = os.path.split(xform_path)[0]
    if has_external_choices(json_survey):
        itemsets_csv = os.path.join(output_dir, "itemsets.csv")
        choices_exported = sheet_to_csv(xlsform_path, itemsets_csv, "external_choices")
        if not choices_exported:
            warnings.append(
                "Could not export itemsets.csv, perhaps the "
                "external choices sheet is missing."
            )
        else:
            logger.info("External choices csv is located at: %s", itemsets_csv)
    return warnings

 def test_answers_can_be_imported_from_xml(self):
     surv = Survey(name=u"data")
     
     surv.add_child(create_survey_element_from_dict({ \
                             u'type':u'text', u'name':u'name', u"label": u"Name"}))
     surv.add_child(create_survey_element_from_dict({ \
                             u'type':u'integer', u'name':u'users_per_month', u"label": u"Users per month"}))
     surv.add_child(create_survey_element_from_dict({ \
                             u'type':u'gps', u'name':u'geopoint', u'label': u'gps'}))
     surv.add_child(create_survey_element_from_dict({ \
                             u'type':u'imei', u'name':u'device_id'}))
     
     instance = surv.instantiate()
     instance.import_from_xml(u"""
     <?xml version='1.0' ?><data id="build_WaterSimple_1295821382"><name>JK Resevoir</name><users_per_month>300</users_per_month><geopoint>40.783594633609184 -73.96436698913574 300.0 4.0</geopoint></data>
     """.strip())

 def test_specify_other(self):
     excel_reader = SurveyReader("pyxform/tests/specify_other.xls")
     d = excel_reader.to_dict()
     survey = create_survey_element_from_dict(d)
     expected_dict = {
         u'name': 'specify_other',
         u'type': u'survey',
         u'children': [
             {
                 u'name': u'sex',
                 u'label': {u'English': u'What sex are you?'},
                 u'type': u'select one',
                 u'children': [
                     {
                         u'name': u'male',
                         u'label': {u'English': u'Male'}
                         },
                     {
                         u'name': u'female',
                         u'label': {u'English': u'Female'}
                         },
                     {
                         u'name': u'other',
                         u'label': u'Other'
                         }
                     ]
                 },
             {
                 u'name': u'sex_other',
                 u'bind': {u'relevant': u"selected(../sex, 'other')"},
                 u'label': u'Specify other.',
                 u'type': u'text'}
             ]
         }
     self.assertEqual(survey.to_dict(), expected_dict)

    def test_include_json(self):            
        excel_reader = SurveyReader("pyxform/tests/include_json.xls")
        d = excel_reader.to_dict()
        survey_in = create_survey_element_from_dict(d)

        for k, v in survey_in.to_dict().items():
            if k!="name": self.assertEqual(v, self.survey_out_dict[k])

    def test_include(self):
        excel_reader = SurveyReader("pyxform/tests/include.xls")
        d = excel_reader.to_dict()
        survey = create_survey_element_from_dict(d)
        expected_dict = {
            u'name': 'include',
            u'type': u'survey',
            u'children': [
                {
                    u'name': u'name',
                    u'label': {u'English': u"What's your name?"},
                    u'type': u'text'
                    },
                    {
                        u'name': u'good_day',
                        u'label': {u'english': u'have you had a good day today?'},
                        u'type': u'select one',
                        u'children': [
                            {
                                u'name': u'yes',
                                u'label': {u'english': u'yes'}
                                },
                            {
                                u'name': u'no',
                                u'label': {u'english': u'no'}
                                }
                            ]}]}

        self.assertEqual(survey.to_dict(), expected_dict)

    def render(self, data, *args, **kwargs):
        charset = 'utf-8'
        root_node = 'xforms'
        xmlns = "http://openrosa.org/xforms/xformsList"

        if 'detail' in data.keys():
            stream = StringIO()

            xml = SimplerXMLGenerator(stream, charset)
            xml.startDocument()
            xml.startElement(root_node, {'xmlns': xmlns})

            for key, value in six.iteritems(data):
                xml.startElement(key, {})
                xml.characters(smart_text(value))
                xml.endElement(key)

            xml.endElement(root_node)
            xml.endDocument()
            return stream.getvalue()
        else:
            json = self.transform_to_xform_json(data)
            survey = create_survey_element_from_dict(json)
            xml = survey.xml()
            fix_languages(xml)
            xml = xml.toxml()

            xml = self.insert_version_attribute(xml,
                                                data.get('id_string'),
                                                data.get('version'))
            xml = self.insert_uuid_bind(xml, data.get('id_string'))

            return xml

    def test_select_one_question_multilingual(self):
        """
        Test the lowest common denominator of question types.
        """
        simple_select_one_json = {
            "label": {"f": "ftext", "e": "etext"},
            "type": "select one",
            "name": "qname",
            "choices": [
                {"label": {"f": "fa", "e": "ea"}, "name": "a"},
                {"label": {"f": "fb", "e": "eb"}, "name": "b"},
            ],
        }

        # I copied the response in, since this is not our method of testing
        # valid return values.
        expected_select_one_control_xml = self.config.get(
            self.cls_name, "test_select_one_question_multilingual_control"
        )

        expected_select_one_binding_xml = self.config.get(
            self.cls_name, "test_select_one_question_multilingual_binding"
        )

        q = create_survey_element_from_dict(simple_select_one_json)
        self.s.add_child(q)
        self.assertEqual(ctw(q.xml_control()), expected_select_one_control_xml)

        if TESTING_BINDINGS:
            self.assertEqual(ctw(q.xml_binding()), expected_select_one_binding_xml)

 def test_select_one_question_multilingual(self):
     """
     Test the lowest common denominator of question types.
     """
     simple_select_one_json = {
         u"label" : {u"f": u"ftext",u"e": u"etext"},
         u"type" : u"select one",
         u"name" : u"qname",
         u"choices" : [
             {u"label": {u"f": u"fa",u"e": u"ea"},u"name": u"a"},
             {u"label": {u"f": u"fb",u"e": u"eb"},u"name": u"b"}
             ]
         }
     
     # I copied the response in, since this is not our method of testing
     # valid return values.
     expected_select_one_control_xml = u"""<select1 ref="/test/qname"><label ref="jr:itext('/test/qname:label')"/><item><label ref="jr:itext('/test/qname/a:label')"/><value>a</value></item><item><label ref="jr:itext('/test/qname/b:label')"/><value>b</value></item></select1>"""
     
     expected_select_one_binding_xml = u"""
     <bind nodeset="/test/qname" type="select1"/>
     """.strip()
     
     q = create_survey_element_from_dict(simple_select_one_json)
     self.s.add_child(q)
     self.assertEqual(ctw(q.xml_control()), expected_select_one_control_xml)
     
     if TESTING_BINDINGS:
         self.assertEqual(ctw(q.xml_binding()), expected_select_one_binding_xml)

    def test_simple_integer_question_type_multilingual(self):
        """
        not sure how integer questions should show up.
        """
        simple_integer_question = {
            u"label": {u"f": u"fc", u"e": u"ec"},
            u"type": u"integer",
            u"name": u"integer_q",
            u"attributes": {}
            }

        expected_integer_control_xml = u"""
        <input ref="/test/integer_q"><label ref="jr:itext('/test/integer_q:label')"/></input>
        """.strip()
        
        expected_integer_binding_xml = u"""
        <bind nodeset="/test/integer_q" type="int"/>
        """.strip()
        
        q = create_survey_element_from_dict(simple_integer_question)
        
        self.s.add_child(q)
        
        self.assertEqual(ctw(q.xml_control()), expected_integer_control_xml)
        
        if TESTING_BINDINGS:
            self.assertEqual(ctw(q.xml_binding()), expected_integer_binding_xml)

    def test_simple_integer_question_type_multilingual(self):
        """
        not sure how integer questions should show up.
        """
        simple_integer_question = {
            "label": {"f": "fc", "e": "ec"},
            "type": "integer",
            "name": "integer_q",
            "attributes": {},
        }

        expected_integer_control_xml = self.config.get(
            self.cls_name, "test_simple_integer_question_type_multilingual_control"
        )

        expected_integer_binding_xml = self.config.get(
            self.cls_name, "test_simple_integer_question_type_multilingual_binding"
        )

        q = create_survey_element_from_dict(simple_integer_question)

        self.s.add_child(q)

        self.assertEqual(ctw(q.xml_control()), expected_integer_control_xml)

        if TESTING_BINDINGS:
            self.assertEqual(ctw(q.xml_binding()), expected_integer_binding_xml)

    def test_simple_select_all_question_multilingual(self):
        """
        not sure how select all questions should show up...
        """
        simple_select_all_question = {
            u"label": {u"f": u"f choisit", u"e": u"e choose"},
            u"type": u"select all that apply",
            u"name": u"select_all_q",
            u"choices": [
                {u"label": {u"f": u"ff", u"e": u"ef"}, u"name": u"f"},
                {u"label": {u"f": u"fg", u"e": u"eg"}, u"name": u"g"},
                {u"label": {u"f": u"fh", u"e": u"eh"}, u"name": u"h"}
                ]
            }

        expected_select_all_control_xml = u"""<select ref="/test/select_all_q"><label ref="jr:itext('/test/select_all_q:label')"/><hint>Select all that apply.</hint><item><label ref="jr:itext('/test/select_all_q/f:label')"/><value>f</value></item><item><label ref="jr:itext('/test/select_all_q/g:label')"/><value>g</value></item><item><label ref="jr:itext('/test/select_all_q/h:label')"/><value>h</value></item></select>"""
        
        expected_select_all_binding_xml = u"""
<bind nodeset="/test/select_all_q" type="select"/>
        """.strip()
        
        q = create_survey_element_from_dict(simple_select_all_question)
        self.s.add_child(q)
        self.assertEqual(ctw(q.xml_control()), expected_select_all_control_xml)
        
        if TESTING_BINDINGS:
            self.assertEqual(ctw(q.xml_binding()), expected_select_all_binding_xml)

    def test_question_type_string(self):
        simple_string_json = {
            "label": {
                "French": "Nom du travailleur agricole:",
                "English": "Name of Community Agricultural Worker",
            },
            "type": "text",
            "name": "enumerator_name",
        }

        q = create_survey_element_from_dict(simple_string_json)

        expected_string_control_xml = self.config.get(
            self.cls_name, "test_question_type_string_control"
        )

        expected_string_binding_xml = self.config.get(
            self.cls_name, "test_question_type_string_binding"
        )

        self.s.add_child(q)
        self.assertEqual(ctw(q.xml_control()), expected_string_control_xml)

        if TESTING_BINDINGS:
            self.assertEqual(ctw(q.xml_binding()), expected_string_binding_xml)

    def test_simple_select_all_question_multilingual(self):
        """
        not sure how select all questions should show up...
        """
        simple_select_all_question = {
            "label": {"f": "f choisit", "e": "e choose"},
            "type": "select all that apply",
            "name": "select_all_q",
            "choices": [
                {"label": {"f": "ff", "e": "ef"}, "name": "f"},
                {"label": {"f": "fg", "e": "eg"}, "name": "g"},
                {"label": {"f": "fh", "e": "eh"}, "name": "h"},
            ],
        }

        expected_select_all_control_xml = self.config.get(
            self.cls_name, "test_simple_select_all_question_multilingual_control"
        )

        expected_select_all_binding_xml = self.config.get(
            self.cls_name, "test_simple_select_all_question_multilingual_binding"
        )

        q = create_survey_element_from_dict(simple_select_all_question)
        self.s.add_child(q)
        self.assertEqual(ctw(q.xml_control()), expected_select_all_control_xml)

        if TESTING_BINDINGS:
            self.assertEqual(ctw(q.xml_binding()), expected_select_all_binding_xml)

    def test_simple_phone_number_question_type_multilingual(self):
        """
        not sure how phone number questions should show up.
        """
        simple_phone_number_question = {
            u"label": {u"f": u"fe", u"e": u"ee"},
            u"type": u"phone number",
            u"name": u"phone_number_q",
        }

        expected_phone_number_control_xml = self.config.get(
            self.cls_name,
            "test_simple_phone_number_question_type_multilingual_control")

        expected_phone_number_binding_xml = self.config.get(
            self.cls_name,
            "test_simple_phone_number_question_type_multilingual_binding")

        q = create_survey_element_from_dict(simple_phone_number_question)
        self.s.add_child(q)
        self.assertEqual(ctw(q.xml_control()),
                         expected_phone_number_control_xml)

        if TESTING_BINDINGS:
            self.assertEqual(ctw(q.xml_binding()),
                             expected_phone_number_binding_xml)

    def to_xform( self, data, options=None ):
        options = options or {}
        data    = self.to_simple( data, options )

        if 'manifest' in data:
            # Return the xform manifest
            return self.to_manifest( data )
        elif 'objects' in data:
            # Return the formList representation of our objects if they are
            # present.
            return self.to_formList( data.get( 'objects', [] ) )
        elif 'id' in data:
            # Accessing a single repo object! Convert completely into the
            # xform format.
            xform = {}
            xform[ 'name' ] = data.get( 'name' )
            # TODO: Fix pyxform to handle this correctly. #  data.get( 'type' )
            xform[ 'type' ] = 'survey'
            xform[ 'default_language' ] = data.get( 'default_language', 'default' )
            xform[ 'children' ] = data.get( 'children' )

            return create_survey_element_from_dict( xform )._to_pretty_xml()
        else:
            raise Exception( data )

        return None

 def test_answers_can_be_imported_from_xml(self):
     surv = Survey(name=u"data")
     
     surv.add_child(create_survey_element_from_dict({
         u'type': u'text', u'name': u'name', u"label": u"Name"}))
     surv.add_child(create_survey_element_from_dict({
         u'type': u'integer', u'name': u'users_per_month',
         u"label": u"Users per month"}))
     surv.add_child(create_survey_element_from_dict({
         u'type': u'gps', u'name': u'geopoint', u'label': u'gps'}))
     surv.add_child(create_survey_element_from_dict({
         u'type': u'imei', u'name': u'device_id'}))
     
     instance = surv.instantiate()
     import_xml = self.config.get(
         self.cls_name, "test_answers_can_be_imported_from_xml")
     instance.import_from_xml(import_xml)

    def create_from_form(self, xls_form=None, original_file=None,
                         project=None):
        try:
            with transaction.atomic():
                errors = []
                instance = self.model(
                    xls_form=xls_form,
                    original_file=original_file,
                    project=project
                )
                json = parse_file_to_json(instance.xls_form.file.name)
                has_default_language = (
                    'default_language' in json and
                    json['default_language'] != 'default'
                )
                if (has_default_language and
                   not check_for_language(json['default_language'])):
                    raise InvalidXLSForm(
                        ["Default language code '{}' unknown".format(
                            json['default_language']
                        )]
                    )
                is_multilingual = multilingual_label_check(json['children'])
                if is_multilingual and not has_default_language:
                    raise InvalidXLSForm(["Multilingual XLS forms must have "
                                          "a default_language setting"])
                instance.default_language = json['default_language']
                if instance.default_language == 'default':
                    instance.default_language = ''
                instance.filename = json.get('name')
                instance.title = json.get('title')
                instance.id_string = json.get('id_string')

                survey = create_survey_element_from_dict(json)
                xml_form = survey.xml()
                fix_languages(xml_form)

                instance.save()

                project.current_questionnaire = instance.id
                project.save()

                create_children(
                    children=json.get('children'),
                    errors=errors,
                    project=project,
                    default_language=instance.default_language,
                    kwargs={'questionnaire': instance}
                )

                # all these errors handled by PyXForm so turning off for now
                # if errors:
                #     raise InvalidXLSForm(errors)

                return instance

        except PyXFormError as e:
            raise InvalidXLSForm([str(e)])

    def test_create_table_from_dict(self):
        d = {
            u"type" : u"loop",
            u"name" : u"my_loop",
            u"label" : {u"English" : u"My Loop"},
            u"columns" : [
                {
                    u"name" : u"col1",
                    u"label" : {u"English" : u"column 1"},
                    },
                {
                    u"name" : u"col2",
                    u"label" : {u"English" : u"column 2"},
                    },
                ],
            u"children" : [
                {
                    u"type": u"integer",
                    u"name": u"count",
                    u"label": {u"English": u"How many are there in this group?"}
                    },
                ]
            }
        g = create_survey_element_from_dict(d)

        expected_dict = {
            u'name': u'my_loop',
            u'label': {u'English': u'My Loop'},
            u'type' : u'group',
            u'children': [
                {
                    u'name': u'col1',
                    u'label': {u'English': u'column 1'},
                    u'type' : u'group',
                    u'children': [
                        {
                            u'name': u'count',
                            u'label': {u'English': u'How many are there in this group?'},
                            u'type': u'integer'
                            }
                        ]
                    },
                {
                    u'name': u'col2',
                    u'label': {u'English': u'column 2'},
                    u'type' : u'group',
                    u'children': [
                        {
                            u'name': u'count',
                            u'label': {u'English': u'How many are there in this group?'},
                            u'type': u'integer'
                            }
                        ]
                    }
                ]
            }

        self.assertEqual(g.to_dict(), expected_dict)