def _test_export_one_table(self, table_name):
        optional_args = ['-c', os.path.join(self.temp_dir, str(self.year)), 
                         '-d', self.test_db,
                         '-t', table_name,
                         '--database_configuration=%s' % self.db_config_node ]
        self._call_script(self.export_from_cache_opus_path,
                          args = optional_args)
        
        self.assertTrue(self.db_server.has_database(database_name = self.test_db))
        db = OpusDatabase(database_server_configuration = self.db_config, 
                          database_name = self.test_db)
        existing_tables = db.get_tables_in_database()
        self.assertEqual( set(existing_tables), set([table_name]) )
        
        export_year = str(self.year + 100)        
        exp_dir = os.path.join(self.temp_dir, export_year)
        
        optional_args = ['-d', self.test_db, 
                         '-c', self.temp_dir, 
                         '-y', export_year,
                         '-t', table_name,
                         '--database_configuration=%s' % self.db_config_node ]
        self._call_script(self.export_to_cache_opus_path,
                          args = optional_args)

        exported_datasets = [os.path.split(f)[1] for f in glob(os.path.join(self.temp_dir, export_year) + '/*')]
        self.assertEqual( set(exported_datasets), set([table_name]))
        
        org_dir = os.path.join(self.temp_dir, str(self.year))
        self._two_caches_are_identical(org_dir, exp_dir, table_names=[table_name])

        db.close()
        self.db_server.drop_database(self.test_db)
        rmtree(exp_dir)
    def _test_export_one_table(self, table_name):
        optional_args = [
            '-c',
            os.path.join(self.temp_dir, str(self.year)), '-d', self.test_db,
            '-t', table_name,
            '--database_configuration=%s' % self.db_config_node
        ]
        self._call_script(self.export_from_cache_opus_path, args=optional_args)

        self.assertTrue(
            self.db_server.has_database(database_name=self.test_db))
        db = OpusDatabase(database_server_configuration=self.db_config,
                          database_name=self.test_db)
        existing_tables = db.get_tables_in_database()
        self.assertEqual(set(existing_tables), set([table_name]))

        export_year = str(self.year + 100)
        exp_dir = os.path.join(self.temp_dir, export_year)

        optional_args = [
            '-d', self.test_db, '-c', self.temp_dir, '-y', export_year, '-t',
            table_name,
            '--database_configuration=%s' % self.db_config_node
        ]
        self._call_script(self.export_to_cache_opus_path, args=optional_args)

        exported_datasets = [
            os.path.split(f)[1]
            for f in glob(os.path.join(self.temp_dir, export_year) + '/*')
        ]
        self.assertEqual(set(exported_datasets), set([table_name]))

        org_dir = os.path.join(self.temp_dir, str(self.year))
        self._two_caches_are_identical(org_dir,
                                       exp_dir,
                                       table_names=[table_name])

        db.close()
        self.db_server.drop_database(self.test_db)
        rmtree(exp_dir)
    def test_export_all_tables(self):
        logger.log_status("Test export all tables for %s with %s" %
                          (self.protocol, self.__class__))
        optional_args = [
            '-c',
            os.path.join(self.temp_dir, str(self.year)), '-d', self.test_db,
            '--database_configuration=%s' % self.db_config_node
        ]
        self._call_script(self.export_from_cache_opus_path, args=optional_args)

        self.assertTrue(
            self.db_server.has_database(database_name=self.test_db))
        db = OpusDatabase(database_server_configuration=self.db_config,
                          database_name=self.test_db)

        table_names = self.test_data[self.year].keys()
        existing_tables = db.get_tables_in_database()
        self.assertEqual(set(existing_tables), set(table_names))

        ## export data from db to cache
        export_year = str(self.year + 100)
        exp_dir = os.path.join(self.temp_dir, export_year)

        optional_args = [
            '-d', self.test_db, '-c', self.temp_dir, '-y', export_year,
            '--database_configuration=%s' % self.db_config_node
        ]
        self._call_script(self.export_to_cache_opus_path, args=optional_args)

        exported_datasets = [os.path.split(f)[1] for f in glob(exp_dir + '/*')]
        self.assertEqual(set(exported_datasets), set(table_names))

        org_dir = os.path.join(self.temp_dir, str(self.year))
        self._two_caches_are_identical(org_dir, exp_dir)

        db.close()
        self.db_server.drop_database(self.test_db)
        rmtree(exp_dir)
    def test_export_all_tables(self):
        logger.log_status("Test export all tables for %s with %s" % (self.protocol, self.__class__))
        optional_args = ['-c', os.path.join(self.temp_dir, str(self.year)), 
                         '-d', self.test_db, 
                         '--database_configuration=%s' % self.db_config_node ]
        self._call_script(self.export_from_cache_opus_path,
                          args = optional_args)

        
        self.assertTrue(self.db_server.has_database(database_name = self.test_db))
        db = OpusDatabase(database_server_configuration = self.db_config, 
                          database_name = self.test_db)
        
        table_names = self.test_data[self.year].keys()
        existing_tables = db.get_tables_in_database()        
        self.assertEqual( set(existing_tables), set(table_names) )

        ## export data from db to cache
        export_year = str(self.year + 100)        
        exp_dir = os.path.join(self.temp_dir, export_year)

        optional_args = ['-d', self.test_db, 
                         '-c', self.temp_dir, 
                         '-y', export_year,
                         '--database_configuration=%s' % self.db_config_node ]
        self._call_script(self.export_to_cache_opus_path,
                          args = optional_args)

        exported_datasets = [os.path.split(f)[1] for f in glob(exp_dir + '/*')]
        self.assertEqual( set(exported_datasets), set(table_names))
        
        org_dir = os.path.join(self.temp_dir, str(self.year))
        self._two_caches_are_identical(org_dir, exp_dir)

        db.close()
        self.db_server.drop_database(self.test_db)
        rmtree(exp_dir)