Index: main/waeup.kofa/trunk/src/waeup/kofa/students/tests/test_batching.py
===================================================================
--- main/waeup.kofa/trunk/src/waeup/kofa/students/tests/test_batching.py	(revision 7887)
+++ main/waeup.kofa/trunk/src/waeup/kofa/students/tests/test_batching.py	(revision 7933)
@@ -16,5 +16,5 @@
 ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 ##
-"""Unit tests for students-related data importers.
+"""Unit tests for students-related data processors.
 """
 import os
@@ -95,10 +95,10 @@
     '\n')[0].split(',')
 
-class StudentImporterTest(FunctionalTestCase):
+class StudentProcessorTest(FunctionalTestCase):
 
     layer = FunctionalLayer
 
     def setUp(self):
-        super(StudentImporterTest, self).setUp()
+        super(StudentProcessorTest, self).setUp()
         # Setup a sample site for each test
         app = University()
@@ -124,5 +124,5 @@
         self.app['students'].addStudent(student)
         self.student = self.app['students'][student.student_id]
-        self.importer = StudentProcessor()
+        self.processor = StudentProcessor()
         self.workdir = tempfile.mkdtemp()
         self.csv_file = os.path.join(self.workdir, 'sample_student_data.csv')
@@ -139,5 +139,5 @@
 
     def tearDown(self):
-        super(StudentImporterTest, self).tearDown()
+        super(StudentProcessorTest, self).tearDown()
         shutil.rmtree(self.workdir)
         shutil.rmtree(self.dc_root)
@@ -147,43 +147,43 @@
     def test_interface(self):
         # Make sure we fulfill the interface contracts.
-        assert verifyObject(IBatchProcessor, self.importer) is True
+        assert verifyObject(IBatchProcessor, self.processor) is True
         assert verifyClass(
             IBatchProcessor, StudentProcessor) is True
 
     def test_parentsExist(self):
-        self.assertFalse(self.importer.parentsExist(None, dict()))
-        self.assertTrue(self.importer.parentsExist(None, self.app))
+        self.assertFalse(self.processor.parentsExist(None, dict()))
+        self.assertTrue(self.processor.parentsExist(None, self.app))
 
     def test_entryExists(self):
-        assert self.importer.entryExists(
+        assert self.processor.entryExists(
             dict(student_id='ID_NONE'), self.app) is False
-        assert self.importer.entryExists(
+        assert self.processor.entryExists(
             dict(reg_number='123'), self.app) is True
 
     def test_getParent(self):
-        parent = self.importer.getParent(None, self.app)
+        parent = self.processor.getParent(None, self.app)
         assert parent is self.app['students']
 
     def test_getEntry(self):
-        assert self.importer.getEntry(
+        assert self.processor.getEntry(
             dict(student_id='ID_NONE'), self.app) is None
-        assert self.importer.getEntry(
+        assert self.processor.getEntry(
             dict(student_id=self.student.student_id), self.app) is self.student
 
     def test_addEntry(self):
         new_student = Student()
-        self.importer.addEntry(
+        self.processor.addEntry(
             new_student, dict(), self.app)
         assert len(self.app['students'].keys()) == 2
 
     def test_checkConversion(self):
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', reg_state='admitted'))
         self.assertEqual(len(errs),0)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', reg_state=''))
         self.assertEqual(len(errs),1)
         self.assertTrue(('reg_state', 'no value provided') in errs)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', reg_state='nonsense'))
         self.assertEqual(len(errs),1)
@@ -192,10 +192,10 @@
     def test_delEntry(self):
         assert self.student.student_id in self.app['students'].keys()
-        self.importer.delEntry(
+        self.processor.delEntry(
             dict(reg_number=self.student.reg_number), self.app)
         assert self.student.student_id not in self.app['students'].keys()
 
     def test_import(self):
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file, STUDENT_HEADER_FIELDS)
         self.assertEqual(num_warns,0)
@@ -205,8 +205,8 @@
 
     def test_import_update(self):
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file, STUDENT_HEADER_FIELDS)
         shutil.rmtree(os.path.dirname(fin_file))
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file_update, STUDENT_HEADER_FIELDS_UPDATE, 'update')
         self.assertEqual(num_warns,0)
@@ -214,8 +214,8 @@
 
     def test_import_update2(self):
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file, STUDENT_HEADER_FIELDS)
         shutil.rmtree(os.path.dirname(fin_file))
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file_update2, STUDENT_HEADER_FIELDS_UPDATE2, 'update')
         self.assertEqual(num_warns,0)
@@ -223,8 +223,8 @@
 
     def test_import_remove(self):
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file, STUDENT_HEADER_FIELDS)
         shutil.rmtree(os.path.dirname(fin_file))
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file_update, STUDENT_HEADER_FIELDS_UPDATE, 'remove')
         self.assertEqual(num_warns,0)
@@ -232,5 +232,5 @@
 
     def test_import_migration_data(self):
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file_migration, STUDENT_HEADER_FIELDS_MIGRATION)
         self.assertEqual(num_warns,2)
@@ -251,10 +251,10 @@
 
 
-class StudentStudyCourseImporterTest(FunctionalTestCase):
+class StudentStudyCourseProcessorTest(FunctionalTestCase):
 
     layer = FunctionalLayer
 
     def setUp(self):
-        super(StudentStudyCourseImporterTest, self).setUp()
+        super(StudentStudyCourseProcessorTest, self).setUp()
         self.dc_root = tempfile.mkdtemp()
         self.workdir = tempfile.mkdtemp()
@@ -283,5 +283,5 @@
             self.certificate)
 
-        self.importer = StudentStudyCourseProcessor()
+        self.processor = StudentStudyCourseProcessor()
         self.csv_file = os.path.join(
             self.workdir, 'sample_studycourse_data.csv')
@@ -290,5 +290,5 @@
 
     def tearDown(self):
-        super(StudentStudyCourseImporterTest, self).tearDown()
+        super(StudentStudyCourseProcessorTest, self).tearDown()
         shutil.rmtree(self.workdir)
         shutil.rmtree(self.dc_root)
@@ -298,50 +298,50 @@
     def test_interface(self):
         # Make sure we fulfill the interface contracts.
-        assert verifyObject(IBatchProcessor, self.importer) is True
+        assert verifyObject(IBatchProcessor, self.processor) is True
         assert verifyClass(
             IBatchProcessor, StudentStudyCourseProcessor) is True
 
     def test_entryExists(self):
-        assert self.importer.entryExists(
+        assert self.processor.entryExists(
             dict(reg_number='REG_NONE'), self.app) is False
-        assert self.importer.entryExists(
+        assert self.processor.entryExists(
             dict(reg_number='1'), self.app) is True
 
     def test_getEntry(self):
-        student = self.importer.getEntry(
+        student = self.processor.getEntry(
             dict(reg_number='1'), self.app).__parent__
         self.assertEqual(student.reg_number,'1')
 
     def test_checkConversion(self):
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', certificate='CERT1', current_level='200'))
         self.assertEqual(len(errs),0)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', certificate='CERT999'))
         self.assertEqual(len(errs),1)
         self.assertTrue(('certificate', u'Invalid value') in errs)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', certificate='CERT1', current_level='100'))
         self.assertEqual(len(errs),1)
         self.assertTrue(('current_level','not in range') in errs)
         # If we import only current_level, no conversion checking is done.
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', current_level='100'))
         self.assertEqual(len(errs),0)
 
     def test_import(self):
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file, STUDYCOURSE_HEADER_FIELDS,'update')
         self.assertEqual(num_warns,1)
-        studycourse = self.importer.getEntry(dict(reg_number='1'), self.app)
+        studycourse = self.processor.getEntry(dict(reg_number='1'), self.app)
         self.assertEqual(studycourse.certificate.code, u'CERT1')
         shutil.rmtree(os.path.dirname(fin_file))
 
-class StudentStudyLevelImporterTest(FunctionalTestCase):
+class StudentStudyLevelProcessorTest(FunctionalTestCase):
 
     layer = FunctionalLayer
 
     def setUp(self):
-        super(StudentStudyLevelImporterTest, self).setUp()
+        super(StudentStudyLevelProcessorTest, self).setUp()
         self.dc_root = tempfile.mkdtemp()
         self.workdir = tempfile.mkdtemp()
@@ -374,10 +374,10 @@
             self.workdir, 'sample_studycourse_data.csv')
         open(studycourse_file, 'wb').write(STUDYCOURSE_SAMPLE_DATA)
-        importer = StudentStudyCourseProcessor()
-        num, num_warns, fin_file, fail_file = importer.doImport(
+        processor = StudentStudyCourseProcessor()
+        num, num_warns, fin_file, fail_file = processor.doImport(
             studycourse_file, STUDYCOURSE_HEADER_FIELDS,'update')
         shutil.rmtree(os.path.dirname(fin_file))
 
-        self.importer = StudentStudyLevelProcessor()
+        self.processor = StudentStudyLevelProcessor()
         self.csv_file = os.path.join(
             self.workdir, 'sample_studylevel_data.csv')
@@ -385,5 +385,5 @@
 
     def tearDown(self):
-        super(StudentStudyLevelImporterTest, self).tearDown()
+        super(StudentStudyLevelProcessorTest, self).tearDown()
         shutil.rmtree(self.workdir)
         shutil.rmtree(self.dc_root)
@@ -393,17 +393,17 @@
     def test_interface(self):
         # Make sure we fulfill the interface contracts.
-        assert verifyObject(IBatchProcessor, self.importer) is True
+        assert verifyObject(IBatchProcessor, self.processor) is True
         assert verifyClass(
             IBatchProcessor, StudentStudyLevelProcessor) is True
 
     def test_checkConversion(self):
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', level='220'))
         self.assertEqual(len(errs),0)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', level='900'))
         self.assertEqual(len(errs),1)
         self.assertTrue(('level','no valid integer') in errs)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', level='xyz'))
         self.assertEqual(len(errs),1)
@@ -411,10 +411,10 @@
 
     def test_import(self):
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file, STUDYLEVEL_HEADER_FIELDS,'create')
         self.assertEqual(num_warns,2)
-        assert self.importer.entryExists(
+        assert self.processor.entryExists(
             dict(reg_number='1', level='100'), self.app) is True
-        studylevel = self.importer.getEntry(
+        studylevel = self.processor.getEntry(
             dict(reg_number='1', level='100'), self.app)
         self.assertEqual(studylevel.__parent__.certificate.code, u'CERT1')
@@ -425,10 +425,10 @@
         
 
-class CourseTicketImporterTest(FunctionalTestCase):
+class CourseTicketProcessorTest(FunctionalTestCase):
 
     layer = FunctionalLayer
 
     def setUp(self):
-        super(CourseTicketImporterTest, self).setUp()
+        super(CourseTicketProcessorTest, self).setUp()
         self.dc_root = tempfile.mkdtemp()
         self.workdir = tempfile.mkdtemp()
@@ -470,19 +470,19 @@
             self.workdir, 'sample_studycourse_data.csv')
         open(studycourse_file, 'wb').write(STUDYCOURSE_SAMPLE_DATA)
-        importer = StudentStudyCourseProcessor()
-        num, num_warns, fin_file, fail_file = importer.doImport(
+        processor = StudentStudyCourseProcessor()
+        num, num_warns, fin_file, fail_file = processor.doImport(
             studycourse_file, STUDYCOURSE_HEADER_FIELDS,'update')
         shutil.rmtree(os.path.dirname(fin_file))
 
         # Import study levels
-        importer = StudentStudyLevelProcessor()
+        processor = StudentStudyLevelProcessor()
         studylevel_file = os.path.join(
             self.workdir, 'sample_studylevel_data.csv')
         open(studylevel_file, 'wb').write(STUDYLEVEL_SAMPLE_DATA)
-        num, num_warns, fin_file, fail_file = importer.doImport(
+        num, num_warns, fin_file, fail_file = processor.doImport(
             studylevel_file, STUDYLEVEL_HEADER_FIELDS,'create')
         shutil.rmtree(os.path.dirname(fin_file))
 
-        self.importer = CourseTicketProcessor()
+        self.processor = CourseTicketProcessor()
         self.csv_file = os.path.join(
             self.workdir, 'sample_courseticket_data.csv')
@@ -490,5 +490,5 @@
 
     def tearDown(self):
-        super(CourseTicketImporterTest, self).tearDown()
+        super(CourseTicketProcessorTest, self).tearDown()
         shutil.rmtree(self.workdir)
         shutil.rmtree(self.dc_root)
@@ -498,13 +498,13 @@
     def test_interface(self):
         # Make sure we fulfill the interface contracts.
-        assert verifyObject(IBatchProcessor, self.importer) is True
+        assert verifyObject(IBatchProcessor, self.processor) is True
         assert verifyClass(
             IBatchProcessor, CourseTicketProcessor) is True
 
     def test_checkConversion(self):
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', code='COURSE1', level='220'))
         self.assertEqual(len(errs),0)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', code='COURSE2', level='220'))
         self.assertEqual(len(errs),1)
@@ -513,11 +513,11 @@
     def test_import(self):
 
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file, COURSETICKET_HEADER_FIELDS,'create')
 
         self.assertEqual(num_warns,2)
-        assert self.importer.entryExists(
+        assert self.processor.entryExists(
             dict(reg_number='1', level='100', code='COURSE1'), self.app) is True
-        courseticket = self.importer.getEntry(
+        courseticket = self.processor.getEntry(
             dict(reg_number='1', level='100', code='COURSE1'), self.app)
         self.assertEqual(courseticket.__parent__.__parent__.certificate.code, u'CERT1')
@@ -533,10 +533,10 @@
         shutil.rmtree(os.path.dirname(fin_file))
 
-class PaymentImporterTest(FunctionalTestCase):
+class PaymentProcessorTest(FunctionalTestCase):
 
     layer = FunctionalLayer
 
     def setUp(self):
-        super(PaymentImporterTest, self).setUp()
+        super(PaymentProcessorTest, self).setUp()
         self.dc_root = tempfile.mkdtemp()
         self.workdir = tempfile.mkdtemp()
@@ -566,5 +566,5 @@
         shutil.rmtree(os.path.dirname(fin_file))
 
-        self.importer = StudentOnlinePaymentProcessor()
+        self.processor = StudentOnlinePaymentProcessor()
         self.csv_file = os.path.join(
             self.workdir, 'sample_payment_data.csv')
@@ -572,5 +572,5 @@
 
     def tearDown(self):
-        super(PaymentImporterTest, self).tearDown()
+        super(PaymentProcessorTest, self).tearDown()
         shutil.rmtree(self.workdir)
         shutil.rmtree(self.dc_root)
@@ -580,15 +580,15 @@
     def test_interface(self):
         # Make sure we fulfill the interface contracts.
-        assert verifyObject(IBatchProcessor, self.importer) is True
+        assert verifyObject(IBatchProcessor, self.processor) is True
         assert verifyClass(
             IBatchProcessor, StudentOnlinePaymentProcessor) is True
 
     def test_getEntry(self):
-        assert self.importer.getEntry(
+        assert self.processor.getEntry(
             dict(student_id='ID_NONE', p_id='nonsense'), self.app) is None
-        assert self.importer.getEntry(
+        assert self.processor.getEntry(
             dict(student_id=self.student.student_id, p_id='p123'),
             self.app) is self.student['payments']['p123']
-        assert self.importer.getEntry(
+        assert self.processor.getEntry(
             dict(student_id=self.student.student_id, p_id='XXXXXX123'),
             self.app) is self.student['payments']['p123']
@@ -598,5 +598,5 @@
         payment1 = createObject(u'waeup.StudentOnlinePayment')
         payment1.p_id = 'p234'
-        self.importer.addEntry(
+        self.processor.addEntry(
             payment1, dict(student_id=self.student.student_id, p_id='p234'),
             self.app)
@@ -606,5 +606,5 @@
         payment1.p_id = 'nonsense'
         # payment1.p_id will be replaced if p_id doesn't start with 'p'
-        self.importer.addEntry(
+        self.processor.addEntry(
             payment2, dict(student_id=self.student.student_id, p_id='XXXXXX456'),
             self.app)
@@ -613,24 +613,24 @@
 
     def test_checkConversion(self):
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', p_id='3816951266236341955'))
         self.assertEqual(len(errs),0)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', p_id='p1266236341955'))
         self.assertEqual(len(errs),0)
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', p_id='nonsense'))
         self.assertEqual(len(errs),1)
         timestamp = "%d" % int(time()*1000)
         p_id = "p%s" % timestamp
-        errs, inv_errs, conv_dict = self.importer.checkConversion(
+        errs, inv_errs, conv_dict = self.processor.checkConversion(
             dict(reg_number='1', p_id=p_id))
         self.assertEqual(len(errs),0)
 
     def test_import(self):
-        num, num_warns, fin_file, fail_file = self.importer.doImport(
+        num, num_warns, fin_file, fail_file = self.processor.doImport(
             self.csv_file, PAYMENT_HEADER_FIELDS,'create')
         self.assertEqual(num_warns,0)
-        payment = self.importer.getEntry(dict(reg_number='1',
+        payment = self.processor.getEntry(dict(reg_number='1',
             p_id='p1290797973744'), self.app)
         self.assertEqual(payment.p_id, 'p1290797973744')
@@ -642,7 +642,7 @@
     suite = unittest.TestSuite()
     for testcase in [
-        StudentImporterTest,StudentStudyCourseImporterTest,
-        StudentStudyLevelImporterTest,CourseTicketImporterTest,
-        PaymentImporterTest,]:
+        StudentProcessorTest,StudentStudyCourseProcessorTest,
+        StudentStudyLevelProcessorTest,CourseTicketProcessorTest,
+        PaymentProcessorTest,]:
         suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
                 testcase
Index: main/waeup.kofa/trunk/src/waeup/kofa/students/tests/test_browser.py
===================================================================
--- main/waeup.kofa/trunk/src/waeup/kofa/students/tests/test_browser.py	(revision 7887)
+++ main/waeup.kofa/trunk/src/waeup/kofa/students/tests/test_browser.py	(revision 7933)
@@ -743,5 +743,5 @@
         importerselect = self.browser.getControl(name='importer')
         modeselect = self.browser.getControl(name='mode')
-        importerselect.getControl('Student Importer').selected = True
+        importerselect.getControl('Student Processor').selected = True
         modeselect.getControl(value='create').selected = True
         self.browser.getControl('Proceed to step 3').click()
@@ -770,5 +770,5 @@
         modeselect = self.browser.getControl(name='mode')
         importerselect.getControl(
-            'StudentStudyCourse Importer (update only)').selected = True
+            'StudentStudyCourse Processor (update only)').selected = True
         modeselect.getControl(value='create').selected = True
         self.browser.getControl('Proceed to step 3').click()
