Exemplo n.º 1
0
 def _convert_case_export(self, export_file_name):
     saved_export_schema = SavedExportSchema.wrap(self.get_json(export_file_name))
     with mock.patch(
             'corehq.apps.export.models.new.CaseExportDataSchema.generate_schema_from_builds',
             return_value=self.schema):
         instance, meta = convert_saved_export_to_export_instance(self.domain, saved_export_schema)
     return instance, meta
    def test_repeat_conversion(self, _):
        saved_export_schema = SavedExportSchema.wrap(self.get_json('repeat'))
        with mock.patch(
                'corehq.apps.export.models.new.FormExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        self.assertEqual(instance.name, 'Repeat Tester')
        table = instance.get_table([PathNode(name='form'), PathNode(name='repeat', is_repeat=True)])
        self.assertEqual(table.label, 'Repeat: question1')
        self.assertTrue(table.selected)

        index, column = table.get_column(
            [PathNode(name='form'),
             PathNode(name='repeat', is_repeat=True),
             PathNode(name='question2')],
            'ExportItem',
            None
        )
        self.assertEqual(column.label, 'Question Two')
        self.assertEqual(column.selected, True)

        index, column = table.get_column(
            [PathNode(name='number')],
            'ExportItem',
            None
        )
        self.assertEqual(column.selected, True)
Exemplo n.º 3
0
 def setUp(self):
     self.db = get_db('couchexport')
     self.custom_export = SavedExportSchema.wrap({
         'type':
         'demo',
         'default_format':
         Format.JSON,
         'index':
         json.dumps(['test_custom']),
         'tables': [{
             'index':
             '#',
             'display':
             'Export',
             'columns': [{
                 'index': 'multi',
                 'display': 'Split',
                 'doc_type': 'SplitColumn',
                 'options': ['a', 'b', 'c', 'd']
             }],
         }]
     })
     self.custom_export.filter_function = SerializableFunction()
     self.schema = [{
         '#export_tag': ['string'],
         'tag': 'string',
         'multi': 'string'
     }]
    def test_basic_conversion(self, _):

        saved_export_schema = SavedExportSchema.wrap(self.get_json('basic'))
        with mock.patch(
                'corehq.apps.export.models.new.FormExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        self.assertEqual(instance.split_multiselects, False)
        self.assertEqual(instance.transform_dates, True)
        self.assertEqual(instance.name, 'Tester')
        self.assertEqual(instance.export_format, 'csv')
        self.assertEqual(instance.is_deidentified, False)
        self.assertEqual(instance.include_errors, False)

        table = instance.get_table(MAIN_TABLE)
        self.assertEqual(table.label, 'My Forms')

        index, column = table.get_column(
            [PathNode(name='form'), PathNode(name='question1')],
            'ExportItem',
            None,
        )
        self.assertEqual(column.label, 'Question One')
        self.assertEqual(column.selected, True)
    def test_system_property_conversion(self, _):
        saved_export_schema = SavedExportSchema.wrap(self.get_json('system_properties'))
        with mock.patch(
                'corehq.apps.export.models.new.FormExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        self.assertEqual(instance.name, 'System Properties')

        # Check for first repeat table
        table = instance.get_table(MAIN_TABLE)
        self.assertEqual(table.label, 'Forms')

        expected_paths = [
            ([PathNode(name='xmlns')], None, True),
            ([PathNode(name='form'), PathNode(name='meta'), PathNode(name='userID')], None, True),
            ([PathNode(name='form'), PathNode(name='case'), PathNode(name='@case_id')], None, True),
            (
                [PathNode(name='form'), PathNode(name='case'), PathNode(name='@case_id')],
                CASE_NAME_TRANSFORM,
                True
            ),
        ]
        for path, transform, selected in expected_paths:
            index, column = table.get_column(path, 'ExportItem', transform)
            self.assertEqual(column.selected, selected, '{} selected is not {}'.format(path, selected))
Exemplo n.º 6
0
    def _convert_export(self, mock_path, export_file_name, force=False):
        saved_export_schema = SavedExportSchema.wrap(self.get_json(export_file_name))

        with mock.patch.object(SavedExportSchema, "save", return_value="False Save"):
            with mock.patch(mock_path, return_value=self.schema):
                instance, meta = convert_saved_export_to_export_instance(
                    self.domain, saved_export_schema, force_convert_columns=force
                )

        return instance, meta
 def test_stock_conversion(self, _):
     saved_export_schema = SavedExportSchema.wrap(self.get_json('stock'))
     with mock.patch(
             'corehq.apps.export.models.new.CaseExportDataSchema.generate_schema_from_builds',
             return_value=self.schema):
         instance = convert_saved_export_to_export_instance(self.domain, saved_export_schema)
     table = instance.get_table(MAIN_TABLE)
     path = [PathNode(name='stock')]
     index, column = table.get_column(path, 'ExportItem', None)
     self.assertTrue(column.selected)
    def test_repeat_conversion(self):
        saved_export_schema = SavedExportSchema.wrap(self.get_json('repeat'))
        with mock.patch(
                'corehq.apps.export.models.new.FormExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance = convert_saved_export_to_export_instance(saved_export_schema)

        self.assertEqual(instance.name, 'Repeat Tester')
        table = instance.get_table(['data', 'repeat'])
        self.assertEqual(table.display_name, 'Repeat: question1')

        column = table.get_column(['data', 'repeat', 'question2'])
        self.assertEqual(column.label, 'Question Two')
        self.assertEqual(column.selected, True)
Exemplo n.º 9
0
    def _convert_export(self, mock_path, export_file_name, force=False):
        saved_export_schema = SavedExportSchema.wrap(self.get_json(export_file_name))

        with mock.patch.object(SavedExportSchema, 'save', return_value='False Save'):
            with mock.patch(
                    mock_path,
                    return_value=self.schema):
                instance, meta = convert_saved_export_to_export_instance(
                    self.domain,
                    saved_export_schema,
                    force_convert_columns=force,
                )

        return instance, meta
Exemplo n.º 10
0
def migrate_domain(domain, dryrun=False):
    from couchexport.models import SavedExportSchema
    export_count = stale_get_export_count(domain)
    metas = []
    if export_count:
        for old_export in with_progress_bar(stale_get_exports_json(domain),
                                            length=export_count,
                                            prefix=domain):
            try:
                _, migration_meta = convert_saved_export_to_export_instance(
                    domain, SavedExportSchema.wrap(old_export), dryrun=dryrun)
            except Exception, e:
                print 'Failed parsing {}: {}'.format(old_export['_id'], e)
            else:
                metas.append(migration_meta)
Exemplo n.º 11
0
 def setUp(self):
     self.db = get_db('couchexport')
     self.custom_export = SavedExportSchema.wrap({
         'type': 'demo',
         'default_format': Format.JSON,
         'index': json.dumps(['test_custom']),
         'tables': [{
             'index': '#',
             'display': 'Export',
             'columns': [
                 {'index': 'multi', 'display': 'Split', 'doc_type': 'SplitColumn', 'options': ['a', 'b', 'c', 'd']}
             ],
         }]
     })
     self.custom_export.filter_function = SerializableFunction()
     self.schema = [{'#export_tag': [u'string'], 'tag': u'string', 'multi': u'string'}]
    def test_transform_conversion(self, _):
        saved_export_schema = SavedExportSchema.wrap(self.get_json('deid_transforms'))
        with mock.patch(
                'corehq.apps.export.models.new.FormExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        table = instance.get_table(MAIN_TABLE)

        index, column = table.get_column(
            [PathNode(name='form'), PathNode(name='deid_id')], 'ExportItem', None
        )
        self.assertEqual(column.deid_transform, DEID_ID_TRANSFORM)

        index, column = table.get_column(
            [PathNode(name='form'), PathNode(name='deid_date')], 'ExportItem', None
        )
        self.assertEqual(column.deid_transform, DEID_DATE_TRANSFORM)
    def test_basic_conversion(self, _):
        saved_export_schema = SavedExportSchema.wrap(self.get_json('case'))
        with mock.patch(
                'corehq.apps.export.models.new.CaseExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        self.assertEqual(instance.transform_dates, True)
        self.assertEqual(instance.name, 'Case Example')
        self.assertEqual(instance.export_format, 'csv')
        self.assertEqual(instance.is_deidentified, False)

        table = instance.get_table(MAIN_TABLE)
        self.assertEqual(table.label, 'Cases')
        self.assertTrue(table.selected)

        index, column = table.get_column([PathNode(name='DOB')], 'ExportItem', None)
        self.assertEqual(column.label, 'DOB Saved')
        self.assertEqual(column.selected, True)
Exemplo n.º 14
0
    def test_convert_form_export_stock_basic(self, _, __):
        saved_export_schema = SavedExportSchema.wrap(self.get_json('stock_form_export'))
        with mock.patch(
                'corehq.apps.export.models.new.FormExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance, _ = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        table = instance.get_table(MAIN_TABLE)
        index, column = table.get_column(
            [
                PathNode(name='form'),
                PathNode(name='transfer:questionid'),
                PathNode(name='entry'),
                PathNode(name='@id'),
            ],
            'StockItem',
            None,
        )
        self.assertTrue(column.selected)
    def test_case_history_conversion(self, _):
        saved_export_schema = SavedExportSchema.wrap(self.get_json('case_history'))
        with mock.patch(
                'corehq.apps.export.models.new.CaseExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        table = instance.get_table(CASE_HISTORY_TABLE)
        self.assertEqual(table.label, 'Case History')

        expected_paths = [
            ([PathNode(name='actions', is_repeat=True), PathNode(name='action_type')], True),
            ([PathNode(name='number')], True),
            ([PathNode(name='actions', is_repeat=True), PathNode(name='server_date')], True),
            ([PathNode(name='actions', is_repeat=True), PathNode(name='xform_name')], True),
        ]

        for path, selected in expected_paths:
            index, column = table.get_column(path, 'ExportItem', None)
            self.assertEqual(column.selected, selected, '{} selected is not {}'.format(path, selected))
Exemplo n.º 16
0
def migrate_domain(domain, dryrun=False, force_convert_columns=False):
    from couchexport.models import SavedExportSchema
    export_count = stale_get_export_count(domain)
    metas = []
    if export_count:
        for old_export in with_progress_bar(
                stale_get_exports_json(domain),
                length=export_count,
                prefix=domain):
            try:
                _, migration_meta = convert_saved_export_to_export_instance(
                    domain,
                    SavedExportSchema.wrap(old_export),
                    dryrun=dryrun,
                    force_convert_columns=force_convert_columns,
                )
            except Exception, e:
                print 'Failed parsing {}: {}'.format(old_export['_id'], e)
                raise e
            else:
                metas.append(migration_meta)
    def test_parent_case_conversion(self, _):
        saved_export_schema = SavedExportSchema.wrap(self.get_json('parent_case'))
        with mock.patch(
                'corehq.apps.export.models.new.CaseExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        table = instance.get_table(PARENT_CASE_TABLE)
        self.assertEqual(table.label, 'Parent Cases')
        self.assertTrue(table.selected)

        expected_paths = [
            ([PathNode(name='indices', is_repeat=True), PathNode(name='referenced_id')], True),
            ([PathNode(name='indices', is_repeat=True), PathNode(name='referenced_type')], False),
            ([PathNode(name='indices', is_repeat=True), PathNode(name='relationship')], True),
            ([PathNode(name='indices', is_repeat=True), PathNode(name='doc_type')], True),
        ]

        for path, selected in expected_paths:
            index, column = table.get_column(path, 'ExportItem', None)
            self.assertEqual(column.selected, selected, '{} selected is not {}'.format(path, selected))
Exemplo n.º 18
0
    def test_single_node_repeats(self, _, __):
        """
        This test ensures that if a repeat only receives one entry, that the selection
        will still be migrated.
        """
        saved_export_schema = SavedExportSchema.wrap(self.get_json('single_node_repeat'))
        with mock.patch(
                'corehq.apps.export.models.new.FormExportDataSchema.generate_schema_from_builds',
                return_value=self.schema):
            instance, _ = convert_saved_export_to_export_instance(self.domain, saved_export_schema)

        table = instance.get_table([PathNode(name='form'), PathNode(name='repeat', is_repeat=True)])
        index, column = table.get_column(
            [
                PathNode(name='form'),
                PathNode(name='repeat', is_repeat=True),
                PathNode(name='single_answer'),
            ],
            'ExportItem',
            None
        )
        self.assertTrue(column.selected)