Clean up old files. Repair unit tests

tests/dbcommon_test.py

@@ -0,0 +1,28 @@
+"""
+    Project: pyGTKtalog
+    Description: Tests for DataBase class.
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-07-19
+"""
+import unittest
+import os
+
+from pygtktalog.dbcommon import connect, Meta, Session, Base
+
+
+class TestDataBase(unittest.TestCase):
+    """
+    Class responsible for database connection and schema creation
+    """
+
+    def test_connect(self):
+        """
+        Test connection to database. Memory and file method will be tested.
+        """
+        connect(":memory:")
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()

tests/dialogs_test.py

@@ -0,0 +1,77 @@
+"""
+    Project: pyGTKtalog
+    Description: Test simple dialogs
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-05-19
+"""
+import unittest
+import os
+
+import gtk
+
+from pygtktalog.dialogs import Dialog, yesno, okcancel, info, warn, error
+
+
+class MessageDialogMock(gtk.MessageDialog):
+    """Mock class for MessageDialog, which shouldn't be displayed in a test"""
+
+    def run(self):
+        """Carefull! only for MESSAGE_INFO return value is RESPONSE_OK!"""
+        if self.get_property('message-type') == gtk.MESSAGE_INFO:
+            return gtk.RESPONSE_OK
+        else:
+            return gtk.RESPONSE_CANCEL
+
+class TestDialog(unittest.TestCase):
+    """Tests for Dialog class"""
+
+    def test_dialog_create(self):
+        """Test dialog creation and run method"""
+        # overwrite MessageDialog class in gtk module
+        gtk.MessageDialog = MessageDialogMock
+        dialog = Dialog(gtk.MESSAGE_INFO, 'msg', 'secondarymsg', 'title')
+        self.assertTrue(dialog.buttons == gtk.BUTTONS_OK, "dialog should have"
+                        " gtk.BUTTONS_OK")
+        self.assertTrue(dialog.run(), "dialog should return True")
+
+        dialog = Dialog(gtk.MESSAGE_QUESTION, 'msg', 'secondarymsg', 'title')
+        self.assertFalse(dialog.run(), "dialog should return False")
+        # NOTE: dialog should be run before test against buttons attribute
+        self.assertTrue(dialog.buttons == gtk.BUTTONS_YES_NO,
+                        "dialog should have gtk.BUTTONS_YES_NO")
+
+        dialog = Dialog(gtk.MESSAGE_QUESTION, 'msg', 'secondarymsg', 'title')
+        dialog.buttons = gtk.BUTTONS_OK
+        dialog.ok_default = True
+        self.assertFalse(dialog.run(), "dialog should return True")
+
+    def test_error(self):
+        """Test error function"""
+        result = error('msg', 'secondarymsg', 'title')
+        self.assertTrue(result, "Should return True")
+
+    def test_warn(self):
+        """Test warn function"""
+        result = warn('msg', 'secondarymsg', 'title')
+        self.assertTrue(result, "Should return True")
+
+    def test_info(self):
+        """Test info function"""
+        result = info('msg', 'secondarymsg', 'title')
+        self.assertTrue(result, "Should return True")
+
+    def test_yesno(self):
+        """Test yesno function"""
+        result = yesno('msg', 'secondarymsg', 'title')
+        self.assertFalse(result, "Should return False")
+
+    def test_okcancel(self):
+        """Test yesno function"""
+        result = okcancel('msg', 'secondarymsg', 'title')
+        self.assertFalse(result, "Should return False")
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()

tests/misc_test.py

@@ -0,0 +1,33 @@
+"""
+    Project: pyGTKtalog
+    Description: Tests for misc functions.
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2009-04-09
+"""
+import unittest
+import os
+
+import pygtktalog.misc as pgtkmisc
+
+
+class TestMiscModule(unittest.TestCase):
+    """
+    Tests functions from misc module
+    """
+
+    def test_float_to_string(self):
+        """
+        test conversion between digits to formated output
+        """
+        self.assertEqual(pgtkmisc.float_to_string(10), '00:00:10')
+        self.assertEqual(pgtkmisc.float_to_string(76), '00:01:16')
+        self.assertEqual(pgtkmisc.float_to_string(22222), '06:10:22')
+        self.assertRaises(TypeError, pgtkmisc.float_to_string)
+        self.assertRaises(TypeError, pgtkmisc.float_to_string, None)
+        self.assertRaises(TypeError, pgtkmisc.float_to_string, '10')
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()

tests/scan_test.py

@@ -0,0 +1,192 @@
+"""
+    Project: pyGTKtalog
+    Description: Tests for scan files.
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2011-03-26
+"""
+import os
+import shutil
+import tempfile
+import unittest
+
+from pygtktalog import scan
+from pygtktalog.dbobjects import File, Config, Image
+from pygtktalog.dbcommon import connect, Session
+
+
+def populate_with_mock_files(dir_):
+    """Make some files under specified directory, return number of files"""
+    files1 = ['anim.mkv', 'text.txt', 'image.png', 'photoimage.jpg']
+    files2 = ['music.mp3', 'loseless.flac']
+
+    files_no = 0
+    for file_ in files1:
+        with open(os.path.join(dir_, file_), "wb") as fobj:
+            fobj.write("\xde\xad\xbe\xef" * len(file_))
+            files_no += 1
+
+    os.symlink(os.path.join(dir_, files1[-1]), os.path.join(dir_, 'link.jpg'))
+    files_no += 1
+
+    os.mkdir(os.path.join(dir_, 'directory'))
+    for file_ in files2:
+        with open(os.path.join(dir_, 'directory', file_), "wb") as fobj:
+            fobj.write("\xfe\xad\xfa\xce" * len(file_))
+            files_no += 1
+
+    return files_no
+
+
+# TODO: exchange this with mock module
+def _fake_video(obj, fobj, filepath):
+    fobj.images.append(Image())
+    fobj.images[0].filename = filepath + ".jpg"
+
+
+def _fake_audio(obj, fobj, filepath):
+    pass
+
+
+def _fake_image(obj, fobj, filepath):
+    pass
+
+
+scan.Scan._video = _fake_video
+scan.Scan._audio = _fake_audio
+scan.Scan._image = _fake_image
+
+
+class TestScan(unittest.TestCase):
+    """
+    Test cases for scan functionality
+
+    1. execution scan function:
+    1.1 simple case - should pass
+    1.2 non-existent directory passed
+    1.3 file passed
+    1.4 directory has permission that forbids file listing
+
+    2. rescan directory; looking for changes
+    2.0 don't touch records for changed files (same directories, same
+        filename, same type and size)
+    2.1 search for files of the same type, same size.
+    2.2 change parent node for moved files (don't insert new)
+
+    3. adding new directory tree which contains same files like already stored
+       in the database
+    """
+    def setUp(self):
+        self.image_path = tempfile.mkdtemp()
+        self.scan_dir = tempfile.mkdtemp()
+        self.no_of_files = populate_with_mock_files(self.scan_dir)
+
+        connect()
+        root = File()
+        root.id = 1
+        root.filename = 'root'
+        root.size = 0
+        root.source = 0
+        root.type = 0
+        root.parent_id = 1
+
+        config = Config()
+        config.key = 'image_path'
+        config.value = self.image_path
+
+        sess = Session()
+        sess.add(root)
+        sess.add(config)
+        sess.commit()
+
+    def tearDown(self):
+        shutil.rmtree(self.image_path)
+        shutil.rmtree(self.scan_dir)
+
+    def test_happy_scenario(self):
+        """
+        make scan, count items
+        """
+        scanob = scan.Scan(self.scan_dir)
+        result_list = scanob.add_files()
+
+        # the number of added objects (files/links only) + "directory" +
+        # topmost directory (self.scan_dir)
+        self.assertEqual(len(result_list), self.no_of_files + 2)
+
+        # all of topmost nide children - including "directory", but excluding
+        # its contents - so it is all_files + 1 (directory) - 2 files from
+        # subdir contents
+        self.assertEqual(len(result_list[0].children), self.no_of_files - 1)
+        # check soft links
+        self.assertEqual(len([x for x in result_list if x.type == 3]), 1)
+
+    def test_wrong_and_nonexistent(self):
+        """
+        Check for accessing non existent directory, regular file instead of
+        the directory.
+        """
+        scanobj = scan.Scan('/nonexistent_directory_')
+        self.assertRaises(OSError, scanobj.add_files)
+
+        scanobj.path = '/root'
+        self.assertRaises(scan.NoAccessError, scanobj.add_files)
+
+        scanobj.path = '/bin/sh'
+        self.assertRaises(scan.NoAccessError, scanobj.add_files)
+
+    def test_abort_functionality(self):
+        scanobj = scan.Scan(self.scan_dir)
+        scanobj.abort = True
+        self.assertEqual(None, scanobj.add_files())
+
+    def test_double_scan(self):
+        """
+        Do the scan twice.
+        """
+        ses = Session()
+        self.assertEqual(len(ses.query(File).all()), 1)
+
+        scanob = scan.Scan(self.scan_dir)
+        scanob.add_files()
+
+        # dirs: main one + "directory" subdir
+        self.assertEqual(len(ses.query(File).filter(File.type == 1).all()), 2)
+
+        # files: '-1' for existing link there, which have it's own type
+        self.assertEqual(len(ses.query(File).filter(File.type == 2).all()),
+                         self.no_of_files - 1)
+        # links
+        self.assertEqual(len(ses.query(File).filter(File.type == 3).all()), 1)
+
+        # all - sum of all of the above + root node
+        self.assertEqual(len(ses.query(File).all()), self.no_of_files + 2 + 1)
+
+        # it is perfectly ok, since we don't update collection, but just added
+        # same directory twice.
+        scanob2 = scan.Scan(self.scan_dir)
+        scanob2.add_files()
+        # we have twice as much of files (self.no_of_files), plus 2 * of
+        # topmost dir and subdir "directory" (means 4) + root element
+        self.assertEqual(len(ses.query(File).all()), self.no_of_files * 2 + 5)
+
+        # get some movie files to examine
+        file_ob = [x for x in scanob._files if x.filename == 'anim.mkv'][0]
+        file2_ob = [x for x in scanob2._files if x.filename == 'anim.mkv'][0]
+
+        # File objects are different
+        self.assertTrue(file_ob is not file2_ob)
+
+        # While Image objects points to the same file
+        self.assertTrue(file_ob.images[0].filename == \
+                file2_ob.images[0].filename)
+
+        # they are different objects
+        self.assertTrue(file_ob.images[0] is not file2_ob.images[0])
+
+        ses.close()
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()

tests/video_test.py

@@ -0,0 +1,364 @@
+"""
+    Project: pyGTKtalog
+    Description: Tests for Video class.
+    Type: test
+    Author: Roman 'gryf' Dobosz, gryf73@gmail.com
+    Created: 2008-12-15
+"""
+import os
+import unittest
+
+import PIL
+
+from pygtktalog.video import Video
+
+
+DATA = {"m1.avi": """ID_VIDEO_ID=0
+ID_AUDIO_ID=1
+ID_FILENAME=m1.avi
+ID_DEMUXER=avi
+ID_VIDEO_FORMAT=H264
+ID_VIDEO_BITRATE=46184
+ID_VIDEO_WIDTH=128
+ID_VIDEO_HEIGHT=96
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=85
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=0
+ID_AUDIO_NCH=0
+ID_START_TIME=0.00
+ID_LENGTH=4.03
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffh264
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=2
+ID_AUDIO_CODEC=mpg123
+ID_EXIT=EOF
+""",
+        "m.avi": """ID_VIDEO_ID=0
+ID_AUDIO_ID=1
+ID_FILENAME=m.avi
+ID_DEMUXER=avi
+ID_VIDEO_FORMAT=XVID
+ID_VIDEO_BITRATE=313536
+ID_VIDEO_WIDTH=128
+ID_VIDEO_HEIGHT=96
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=85
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=0
+ID_AUDIO_NCH=0
+ID_START_TIME=0.00
+ID_LENGTH=4.03
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffodivx
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=2
+ID_AUDIO_CODEC=mpg123
+ID_EXIT=EOF""",
+        "m.mkv": """ID_VIDEO_ID=0
+ID_AUDIO_ID=0
+ID_CLIP_INFO_NAME0=title
+ID_CLIP_INFO_VALUE0=Avidemux
+ID_CLIP_INFO_NAME1=encoder
+ID_CLIP_INFO_VALUE1=Lavf51.12.1
+ID_CLIP_INFO_N=2
+ID_FILENAME=m.mkv
+ID_DEMUXER=lavfpref
+ID_VIDEO_FORMAT=MP4V
+ID_VIDEO_BITRATE=0
+ID_VIDEO_WIDTH=128
+ID_VIDEO_HEIGHT=96
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=8192
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=1
+ID_START_TIME=0.00
+ID_LENGTH=4.07
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffodivx
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=1
+ID_AUDIO_CODEC=ffac3
+ID_EXIT=EOF""",
+        "m.mpg": """ID_VIDEO_ID=0
+ID_FILENAME=m.mpg
+ID_DEMUXER=mpeges
+ID_VIDEO_FORMAT=0x10000001
+ID_VIDEO_BITRATE=2200000
+ID_VIDEO_WIDTH=128
+ID_VIDEO_HEIGHT=96
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_START_TIME=0.00
+ID_LENGTH=0.97
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffmpeg1
+ID_EXIT=EOF""",
+        "m.ogm": """ID_VIDEO_ID=0
+ID_AUDIO_ID=0
+ID_FILENAME=m.ogm
+ID_DEMUXER=lavfpref
+ID_VIDEO_FORMAT=H264
+ID_VIDEO_BITRATE=0
+ID_VIDEO_WIDTH=160
+ID_VIDEO_HEIGHT=120
+ID_VIDEO_FPS=30.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=8192
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=1
+ID_START_TIME=0.00
+ID_LENGTH=4.00
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffh264
+ID_AUDIO_BITRATE=128000
+ID_AUDIO_RATE=22050
+ID_AUDIO_NCH=1
+ID_AUDIO_CODEC=ffac3
+ID_EXIT=EOF""",
+        "m.wmv":"""ID_AUDIO_ID=1
+ID_VIDEO_ID=2
+ID_FILENAME=m.wmv
+ID_DEMUXER=asf
+ID_VIDEO_FORMAT=WMV3
+ID_VIDEO_BITRATE=1177000
+ID_VIDEO_WIDTH=852
+ID_VIDEO_HEIGHT=480
+ID_VIDEO_FPS=1000.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=353
+ID_AUDIO_BITRATE=0
+ID_AUDIO_RATE=0
+ID_AUDIO_NCH=0
+ID_START_TIME=4.00
+ID_LENGTH=4656.93
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffwmv3
+ID_AUDIO_BITRATE=64028
+ID_AUDIO_RATE=48000
+ID_AUDIO_NCH=2
+ID_AUDIO_CODEC=ffwmav2
+ID_EXIT=EOF""",
+        "m.mp4": """ID_VIDEO_ID=0
+ID_AUDIO_ID=0
+ID_AID_0_LANG=unk
+ID_CLIP_INFO_NAME0=major_brand
+ID_CLIP_INFO_VALUE0=isom
+ID_CLIP_INFO_NAME1=minor_version
+ID_CLIP_INFO_VALUE1=512
+ID_CLIP_INFO_NAME2=compatible_brands
+ID_CLIP_INFO_VALUE2=isomiso2avc1mp41
+ID_CLIP_INFO_NAME3=encoder
+ID_CLIP_INFO_VALUE3=Lavf56.25.101
+ID_CLIP_INFO_N=4
+ID_FILENAME=m.mp4
+ID_DEMUXER=lavfpref
+ID_VIDEO_FORMAT=H264
+ID_VIDEO_BITRATE=1263573
+ID_VIDEO_WIDTH=720
+ID_VIDEO_HEIGHT=404
+ID_VIDEO_FPS=25.000
+ID_VIDEO_ASPECT=0.0000
+ID_AUDIO_FORMAT=MP4A
+ID_AUDIO_BITRATE=155088
+ID_AUDIO_RATE=44100
+ID_AUDIO_NCH=2
+ID_START_TIME=0.00
+ID_LENGTH=69.18
+ID_SEEKABLE=1
+ID_CHAPTERS=0
+ID_VIDEO_CODEC=ffh264
+ID_AUDIO_BITRATE=155082
+ID_AUDIO_RATE=44100
+ID_AUDIO_NCH=2
+ID_AUDIO_CODEC=ffaac
+ID_EXIT=EOF"""}
+
+
+# TODO: exchange this with mock
+class Readlines(object):
+    def __init__(self, key=None):
+        self.data = DATA.get(key, "")
+
+    def readlines(self):
+        return self.data.split('\n')
+
+def mock_popen(command):
+    key = None
+    if 'midentify' in command:
+        key = command.split('"')[1]
+    elif 'jpeg:outdir' in command:
+        # simulate capture for mplayer
+        img_dir = command.split('"')[-2]
+        img = PIL.Image.new('RGBA', (320, 200))
+        with open(os.path.join(img_dir, "00000001.jpg"), "wb") as fobj:
+            img.save(fobj)
+
+    return Readlines(key)
+
+
+os.popen = mock_popen
+
+
+class TestVideo(unittest.TestCase):
+    """test class for retrive midentify script output"""
+
+    def test_avi(self):
+        """test mock avi file, should return dict with expected values"""
+        avi = Video("m.avi")
+        self.assertTrue(len(avi.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(avi.tags['audio_format'], '85')
+        self.assertEqual(avi.tags['width'], 128)
+        self.assertEqual(avi.tags['audio_no_channels'], 2)
+        self.assertEqual(avi.tags['height'], 96)
+        self.assertEqual(avi.tags['video_format'], 'xvid')
+        self.assertEqual(avi.tags['length'], 4)
+        self.assertEqual(avi.tags['audio_codec'], 'mpg123')
+        self.assertEqual(avi.tags['video_codec'], 'ffodivx')
+        self.assertEqual(avi.tags['duration'], '00:00:04')
+        self.assertEqual(avi.tags['container'], 'avi')
+
+    def test_avi2(self):
+        """test another mock avi file, should return dict with expected
+        values"""
+        avi = Video("m1.avi")
+        self.assertTrue(len(avi.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(avi.tags['audio_format'], '85')
+        self.assertEqual(avi.tags['width'], 128)
+        self.assertEqual(avi.tags['audio_no_channels'], 2)
+        self.assertEqual(avi.tags['height'], 96)
+        self.assertEqual(avi.tags['video_format'], 'h264')
+        self.assertEqual(avi.tags['length'], 4)
+        self.assertEqual(avi.tags['audio_codec'], 'mpg123')
+        self.assertEqual(avi.tags['video_codec'], 'ffh264')
+        self.assertEqual(avi.tags['duration'], '00:00:04')
+        self.assertEqual(avi.tags['container'], 'avi')
+
+    def test_mkv(self):
+        """test mock mkv file, should return dict with expected values"""
+        mkv = Video("m.mkv")
+        self.assertTrue(len(mkv.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(mkv.tags['audio_format'], '8192')
+        self.assertEqual(mkv.tags['width'], 128)
+        self.assertTrue(mkv.tags['audio_no_channels'] in (1, 2))
+        self.assertEqual(mkv.tags['height'], 96)
+        self.assertEqual(mkv.tags['video_format'], 'mp4v')
+        self.assertEqual(mkv.tags['length'], 4)
+        self.assertTrue(mkv.tags['audio_codec'] in ('a52', 'ffac3'))
+        self.assertEqual(mkv.tags['video_codec'], 'ffodivx')
+        self.assertEqual(mkv.tags['duration'], '00:00:04')
+        self.assertTrue(mkv.tags['container'] in ('mkv', 'lavfpref'))
+
+    def test_mpg(self):
+        """test mock mpg file, should return dict with expected values"""
+        mpg = Video("m.mpg")
+        self.assertTrue(len(mpg.tags) != 0, "result should have lenght > 0")
+        self.assertFalse(mpg.tags.has_key('audio_format'))
+        self.assertEqual(mpg.tags['width'], 128)
+        self.assertFalse(mpg.tags.has_key('audio_no_channels'))
+        self.assertEqual(mpg.tags['height'], 96)
+        self.assertEqual(mpg.tags['video_format'], '0x10000001')
+        self.assertFalse(mpg.tags.has_key('lenght'))
+        self.assertFalse(mpg.tags.has_key('audio_codec'))
+        self.assertEqual(mpg.tags['video_codec'], 'ffmpeg1')
+        self.assertFalse(mpg.tags.has_key('duration'))
+        self.assertEqual(mpg.tags['container'], 'mpeges')
+
+    def test_ogm(self):
+        """test mock ogm file, should return dict with expected values"""
+        ogm = Video("m.ogm")
+        self.assertTrue(len(ogm.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(ogm.tags['audio_format'], '8192')
+        self.assertEqual(ogm.tags['width'], 160)
+        self.assertTrue(ogm.tags['audio_no_channels'] in (1, 2))
+        self.assertEqual(ogm.tags['height'], 120)
+        self.assertEqual(ogm.tags['video_format'], 'h264')
+        self.assertEqual(ogm.tags['length'], 4)
+        self.assertTrue(ogm.tags['audio_codec'] in ('a52', 'ffac3'))
+        self.assertEqual(ogm.tags['video_codec'], 'ffh264')
+        self.assertEqual(ogm.tags['duration'], '00:00:04')
+        self.assertTrue(ogm.tags['container'] in ('ogg', 'lavfpref'))
+
+    def test_wmv(self):
+        """test mock wmv file, should return dict with expected values"""
+        wmv = Video("m.wmv")
+        self.assertTrue(len(wmv.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(wmv.tags['audio_format'], '353')
+        self.assertEqual(wmv.tags['width'], 852)
+        self.assertEqual(wmv.tags['audio_no_channels'], 2)
+        self.assertEqual(wmv.tags['height'], 480)
+        self.assertEqual(wmv.tags['video_format'], 'wmv3')
+        self.assertEqual(wmv.tags['length'], 4656)
+        self.assertEqual(wmv.tags['audio_codec'], 'ffwmav2')
+        self.assertEqual(wmv.tags['video_codec'], 'ffwmv3')
+        self.assertEqual(wmv.tags['duration'], '01:17:32')
+        self.assertEqual(wmv.tags['container'], 'asf')
+
+    def test_mp4(self):
+        """test mock mp4 file, should return dict with expected values"""
+        mp4 = Video("m.mp4")
+        self.assertTrue(len(mp4.tags) != 0, "result should have lenght > 0")
+        self.assertEqual(mp4.tags['audio_format'], 'mp4a')
+        self.assertEqual(mp4.tags['width'], 720)
+        self.assertEqual(mp4.tags['audio_no_channels'], 2)
+        self.assertEqual(mp4.tags['height'], 404)
+        self.assertEqual(mp4.tags['video_format'], 'h264')
+        self.assertEqual(mp4.tags['length'], 69)
+        self.assertEqual(mp4.tags['audio_codec'], 'ffaac')
+        self.assertEqual(mp4.tags['video_codec'], 'ffh264')
+        self.assertEqual(mp4.tags['duration'], '00:01:09')
+        self.assertEqual(mp4.tags['container'], 'lavfpref')
+
+    def test_capture(self):
+        """test capture with some small movie and play a little with tags"""
+        avi = Video("m.avi")
+        filename = avi.capture()
+        self.assertTrue(filename != None)
+        self.assertTrue(os.path.exists(filename))
+        file_size = os.stat(filename)[6]
+        self.assertAlmostEqual(file_size/10000.0, 0.151, 0)
+        os.unlink(filename)
+
+        for length in (480, 380, 4):
+            avi.tags['length'] = length
+            filename = avi.capture()
+            self.assertTrue(filename is not None)
+            os.unlink(filename)
+
+        avi.tags['length'] = 3
+        self.assertTrue(avi.capture() is None)
+
+        avi.tags['length'] = 4
+
+        avi.tags['width'] = 0
+        self.assertTrue(avi.capture() is None)
+
+        avi.tags['width'] = 1025
+        filename = avi.capture()
+        self.assertTrue(filename is not None)
+        os.unlink(filename)
+
+        del(avi.tags['length'])
+        self.assertTrue(avi.capture() is None)
+
+        self.assertTrue(len(str(avi)) > 0)
+
+
+if __name__ == "__main__":
+    os.chdir(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../"))
+    unittest.main()