The current version is (mostly) working

9 files changed, 68 insertions, 152 deletions

diff --git a/lib/test.py b/clitest.py
index b1ff2a3..00955ae 100644
--- a/lib/test.py
+++ b/clitest.py
@@ -1,45 +1,29 @@
-import mat
+import cli
 import unittest
-import shutil
-import glob
-import tempfile
+import test
 
-FILE_LIST = zip(glob.glob('clean*'), glob.glob('dirty*'))
+import shlex
+import subprocess
 
-class MATTest(unittest.TestCase):
-    def setUp(self):
-        '''create working copy of the clean and the dirty file in the TMP dir'''
-        self.file_list = []
-        self.tmpdir = tempfile.mkdtemp()
-
-        for clean, dirty in FILE_LIST:
-            shutil.copy2(clean, self.tmpdir + clean)
-            shutil.copy2(dirty, self.tmpdir + dirty)
-            self.file_list.append((self.tmpdir + clean, self.tmpdir + dirty))
-
-    def tearDown(self):
-        '''Remove the tmp folder'''
-        shutil.rmtree(self.tmpdir)
-
-class Test_Remove(MATTest):
+class Test_Remove_cli(test.MATTest):
     def test_remove(self):
-        '''make sure that the lib remove all compromizing meta'''
+        '''make sure that the cli remove all compromizing meta'''
         for clean, dirty in self.file_list:
-            mat.file(dirty).remove_all()
+            subprocess.call("cli.py %s" dirty)
             self.assertTrue(mat.file(dirty).is_clean())
 
     def test_remove_empty(self):
         '''Test removal with clean files'''
         for clean, dirty in self.file_list:
-            mat.file(clean).remove_all()
-            self.assertTrue(mat.file(clean).is_clean())
+            subprocess.call("cli.py %s" clean)
+            self.assertTrue(mat.file(dirty).is_clean())
 
 
-class Test_List(MATTest):
+class Test_List_cli(test.MATTest):
     def test_list(self):
         '''check if get_meta returns all the expected meta'''
         for clean, dirty in self.file_list:
-            meta_list = dict() #FIXME
+            meta_list = dict("fixme":"please",) #FIXME
             self.assertDictEqual(mat.file(dirty).get_meta(), meta_list)
 
     def testlist_list_empty(self):
@@ -48,7 +32,7 @@ class Test_List(MATTest):
             self.assertEqual(mat.file(clean).get_meta(), None)
 
 
-class Test_isClean(MATTest):
+class Test_isClean_cli(test.MATTest):
     def test_clean(self):
         '''test is_clean on clean files'''
         for clean, dirty in self.file_list:
diff --git a/lib/hachoir_editor/__init__.py b/hachoir_editor/__init__.py
index b106278..b106278 100644
--- a/lib/hachoir_editor/__init__.py
+++ b/hachoir_editor/__init__.py
diff --git a/lib/hachoir_editor/field.py b/hachoir_editor/field.py
index 6b1efe3..6b1efe3 100644
--- a/lib/hachoir_editor/field.py
+++ b/hachoir_editor/field.py
diff --git a/lib/hachoir_editor/fieldset.py b/hachoir_editor/fieldset.py
index 1669b5a..1669b5a 100644
--- a/lib/hachoir_editor/fieldset.py
+++ b/hachoir_editor/fieldset.py
diff --git a/lib/hachoir_editor/typed_field.py b/hachoir_editor/typed_field.py
index 4abc989..4abc989 100644
--- a/lib/hachoir_editor/typed_field.py
+++ b/hachoir_editor/typed_field.py
diff --git a/lib/check/images/jpg.py b/lib/check/images/jpg.py
deleted file mode 100644
index 7f29587..0000000
--- a/lib/check/images/jpg.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import hachoir_core.error
-import hachoir_core.cmd_line
-import hachoir_parser
-import hachoir_metadata
-import sys
-import mat
-
-
-class JpegStripper(file):
-    def checkField(self, field):
-            print(field.description)
-            if field.name.startswith("comment"):
-                return True
-            return field.name in ("photoshop", "exif", "adobe")
-        return False
-
-
diff --git a/lib/mat.py b/lib/mat.py
deleted file mode 100644
index d22c9ab..0000000
--- a/lib/mat.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import hachoir_core.error
-import hachoir_core.cmd_line
-import hachoir_parser
-import hachoir_metadata
-
-from strippers import *
-
-from hachoir_editor import (createEditor,
-    NewFieldSet, EditableInteger, EditableBytes)
-
-import hachoir_editor
-
-import sys
-
-__version__ = "0.1"
-__author__ = "jvoisin"
-
-
-class file():
-    def __init__(self, filename):
-        self.metadata = {}
-        self.clean = False
-        self.editor = createEditor(self.parser)
-        self.filename = filename
-        self.filename, self.realname = hachoir_core.cmd_line.unicodeFilename(
-            self.filename), self.filename
-        self.parser = hachoir_parser.createParser(self.filename, self.realname)
-
-        if not self.parser:
-            print("Unable to parse file : sorry")
-            sys.exit(1)
-
-        try:
-            self.meta = hachoir_metadata.extractMetadata(self.parser)
-        except hachoir_core.error.HachoirError, err:
-            print "Metadata extraction error: %s" % unicode(err)
-            self.data = None
-
-        if not self.meta:
-            print "Unable to extract metadata"
-            sys.exit(1)
-
-    def is_clean(self):
-        '''
-            Return true if the file is clean from any compromizing meta
-        '''
-        return self.clean
-
-    def remove_all(self):
-        '''
-            Remove all the files that are compromizing
-        '''
-        stripEditor(self.editor, self.realname, level, not(values.quiet))
-        for key, field in metadata:
-            if should_remove(key):
-                remove(self, key)
-
-    def remove(self, field):
-        '''
-            Remove the given file
-        '''
-        del editor[field]
-        return True
-
-
-    def get_meta(self):
-        '''return a dict with all the meta of the file'''
-        #FIXME : sooooooooooo dirty !
-        for title in self.meta:
-            if title.values != []: #if the field is not empty
-                value = ""
-                for item in title.values:
-                    value = item.text
-                self.metadata[title.key] = value
-        return self.metadata
-
-    def should_remove(self, field):
-        '''
-            return True if the field is compromizing
-            abstract method
-        '''
-        raise NotImplementedError()
-
-def stripEditor(editor, filename, realname, level, verbose):
-    '''
-        Assign a stripper to an editor
-    '''
-    cls = editor.input.__class__
-    try:
-        stripper_cls = strippers[cls]
-    except KeyError:
-        print "Don't have stripper for file type: %s" % editor.description
-        return False
-    stripper = stripper_cls(editor, level, verbose)
-
-    if stripper():
-        output = FileOutputStream(filename, realname)
-        editor.writeInto(output)
-
-    else:
-        print _("Stripper doesn't touch the file")
-    return True
-
-file(sys.argv[1]).get_meta()
diff --git a/lib/strippers.py b/lib/strippers.py
deleted file mode 100644
index 70d0fc7..0000000
--- a/lib/strippers.py
+++ /dev/null
@@ -1,3 +0,0 @@
-strippers = {
-    JpegFile: JpegStripper,
-}
diff --git a/libtest.py b/libtest.py
new file mode 100644
index 0000000..191a981
--- /dev/null
+++ b/libtest.py
@@ -0,0 +1,56 @@
+import mat
+import unittest
+import test
+
+class Test_Remove_lib(test.MATTest):
+    def test_remove(self):
+        '''make sure that the lib remove all compromizing meta'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(dirty)
+            current_file.remove_all()
+            self.assertTrue(current_file.is_clean())
+
+    def test_remove_empty(self):
+        '''Test removal with clean files'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(clean)
+            current_file.remove_all()
+            self.assertTrue(current_file.is_clean())
+
+
+class Test_List_lib(test.MATTest):
+    def test_list(self):
+        '''check if get_meta returns all the expected meta'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(dirty)
+            meta_list = dict({"fixme":"please"},)
+            self.assertDictEqual(current_file.get_meta(), meta_list)
+
+    def testlist_list_empty(self):
+        '''check that a listing of a clean file return an empty dict'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(clean)
+            self.assertEqual(current_file.get_meta(), dict()) #dirty, isn't it ?
+
+
+class Test_isClean_lib(test.MATTest):
+    def test_clean(self):
+        '''test is_clean on clean files'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(dirty)
+            self.assertTrue(current_file.is_clean())
+
+    def test_clean(self):
+        '''test is_clean on dirty files'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(clean)
+            self.assertFalse(current_file.is_clean())
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(Test_Remove_lib))
+    suite.addTest(unittest.makeSuite(Test_List_lib))
+    suite.addTest(unittest.makeSuite(Test_isClean_lib))
+    unittest.TextTestRunner(verbosity=2).run(suite)
+