Add unitest for mic/archive.py

Change-Id: Ic75ef5a31a5b935958de7eaa3f2995dfdaad86ef

1 files changed, 656 insertions, 0 deletions

diff --git a/tests/test_archive.py b/tests/test_archive.py
new file mode 100644
index 0000000..6b81c3a
--- /dev/null
+++ b/tests/test_archive.py
@@ -0,0 +1,656 @@
+"""
+It is used to test mic/archive.py
+"""
+
+
+import os
+import shutil
+import unittest
+
+from mic import archive
+
+
+class ArchiveTest(unittest.TestCase):
+    """
+        test pulic methods in archive.py
+    """
+    def setUp(self):
+        """Create files and directories for later use"""
+        self.relative_file = './sdfb.gxdf.bzws.zzz'
+        abs_file = '/tmp/adsdfb.gxdf.bzws.zzz'
+        bare_file = 'abc.def.bz.zzz'
+        self.relative_dir = './sdf.zzz'
+        abs_dir = '/tmp/asdf.zzz'
+        bare_dir = 'abd.zzz'
+        self.wrong_format_file = './sdbs.werxdf.bz.zzz'
+
+        self.files = [self.relative_file, abs_file, bare_file]
+        self.dirs = [self.relative_dir, abs_dir, bare_dir]
+        for file_item in self.files:
+            os.system('touch %s' % file_item)
+
+        for dir_item in self.dirs:
+            self.create_dir(dir_item)
+            shutil.copy(self.relative_file, '%s/1.txt' % dir_item)
+            shutil.copy(self.relative_file, '%s/2.txt' % dir_item)
+            self.create_dir('%s/dir1' % dir_item)
+            self.create_dir('%s/dir2' % dir_item)
+
+    def tearDown(self):
+        """Clean up unuseful file and directory """
+        try:
+            for file_item in self.files:
+                os.remove(file_item)
+            for dir_item in self.dirs:
+                shutil.rmtree(dir_item, ignore_errors=True)
+        except OSError:
+            pass
+
+    def create_dir(self, dir_name):
+        """Create directories and ignore any erros """
+        try:
+            os.makedirs(dir_name)
+        except OSError:
+            pass
+
+    def test_get_compress_formats(self):
+        """Test get compress format """
+        compress_list = archive.get_compress_formats()
+        compress_list.sort()
+        self.assertEqual(compress_list, ['bz2', 'gz', 'lzo'])
+
+    def test_compress_negtive_file_path_is_required(self):
+        """Test if the first parameter: file path is empty"""
+        with self.assertRaises(OSError):
+            archive.compress('', 'bz2')
+
+    def test_compress_negtive_compress_format_is_required(self):
+        """Test if the second parameter: compress format is empty"""
+        with self.assertRaises(ValueError):
+            archive.compress(self.relative_file, '')
+
+    def test_compress_negtive_parameters_are_all_required(self):
+        """Test if two parameters are both empty"""
+        with self.assertRaises(OSError):
+            archive.compress('', '')
+
+    def test_compress_negtive_file_not_exist(self):
+        """Test target file does not exist"""
+        with self.assertRaises(OSError):
+            archive.compress('a.py', 'bz2')
+
+    def test_compress_negtive_file_is_dir(self):
+        """Test target is one direcoty, which is not supported"""
+        with self.assertRaises(OSError):
+            archive.compress(self.relative_dir, 'bz2')
+
+    def test_compress_negtive_wrong_compress_format(self):
+        """Test wrong compress format"""
+        with self.assertRaises(ValueError):
+            archive.compress(self.relative_file, 'bzip2')
+
+    def _compress_negtive_gz_command_not_exists(self):
+        #TODO: test if command like 'pigz', 'gzip' does not exist
+        pass
+
+    def _compress_negtive_lzo_command_not_exists(self):
+        #TODO: test if command 'lzop' does not exist
+        pass
+
+    def _compress_negtive_bz2_command_not_exists(self):
+        #TODO: test if command like 'pbzip2', 'bzip2' does not exist
+        pass
+
+    def test_compress_gz(self):
+        """Test compress format: gz"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'gz')
+            self.assertEqual('%s.gz' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            os.remove(output_name)
+
+    def test_compress_bz2(self):
+        """Test compress format: bz2"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'bz2')
+            self.assertEqual('%s.bz2' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            os.remove(output_name)
+
+    def _test_compress_lzo(self):
+        """Test compress format: lzo"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'lzo')
+            self.assertEqual('%s.lzo' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            os.remove(output_name)
+
+    def test_decompress_negtive_file_path_is_required(self):
+        """Test if the first parameter: file to be uncompressed is empty"""
+        with self.assertRaises(OSError):
+            archive.decompress('', 'bz')
+
+    def test_decompress_compress_format_is_empty(self):
+        """Test if the second parameter: compress format is empty string"""
+        output_name = archive.compress(self.relative_file, 'gz')
+        self.assertEqual('%s.gz' % self.relative_file, output_name)
+        self.assertTrue(os.path.exists(output_name))
+        self.assertFalse(os.path.exists(self.relative_file))
+        archive.decompress(output_name, '')
+        self.assertTrue(os.path.exists(self.relative_file))
+
+    def test_decompress_negtive_parameters_are_empty(self):
+        """Test if two parameters are both empty string"""
+        with self.assertRaises(OSError):
+            archive.decompress('', '')
+
+    def test_decompress_negtive_file_not_exist(self):
+        """Test decompress target does not exist"""
+        with self.assertRaises(OSError):
+            archive.decompress('tresa.py', 'bz2')
+
+    def test_decompress_negtive_path_is_dir(self):
+        """Test decompress target is a directory"""
+        with self.assertRaises(OSError):
+            archive.decompress(self.relative_dir, 'bz2')
+
+    def _decompress_negtive_not_corresponding(self):
+        # TODO: test if path is .lzo, but given format is bz2
+        pass
+
+    def test_decompress_negtive_wrong_compress_format(self):
+        """Test wrong decompress format"""
+        with self.assertRaises(ValueError):
+            archive.decompress(self.relative_file, 'bzip2')
+
+    def test_decompress_negtive_wrong_file_format(self):
+        """Test wrong target format"""
+        with self.assertRaises(Exception):
+            archive.decompress(self.wrong_format_file, 'bz2')
+
+    def test_decompress_gz(self):
+        """Test decompress
+            Format: gz
+            both two parameters are given, one is target file,
+            the other is corresponding compress format"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'gz')
+            self.assertEqual('%s.gz' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            self.assertFalse(os.path.exists(file_item))
+            archive.decompress(output_name, 'gz')
+            self.assertTrue(os.path.exists(file_item))
+
+    def test_decompress_gz_no_compress_format(self):
+        """Test decompress
+            Format: gz
+            one parameters is given, only target file"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'gz')
+            self.assertEqual('%s.gz' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            self.assertFalse(os.path.exists(file_item))
+            archive.decompress(output_name)
+            self.assertTrue(os.path.exists(file_item))
+
+    def test_decompress_bz2(self):
+        """Test decompress
+            Format: bz2
+            both two parameters are given, one is target file,
+            the other is corresponding compress format"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'bz2')
+            self.assertEqual('%s.bz2' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            self.assertFalse(os.path.exists(file_item))
+            archive.decompress(output_name, 'bz2')
+            self.assertTrue(os.path.exists(file_item))
+
+    def test_decompress_bz2_no_compress_format(self):
+        """Test decompress
+            Format: bz2
+            one parameters is given, only target file"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'bz2')
+            self.assertEqual('%s.bz2' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            self.assertFalse(os.path.exists(file_item))
+            archive.decompress(output_name)
+            self.assertTrue(os.path.exists(file_item))
+
+    def _test_decompress_lzo(self):
+        """Test decompress
+            Format: lzo
+            both two parameters are given, one is target file,
+            the other is corresponding compress format"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'lzo')
+            self.assertEqual('%s.lzo' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            self.assertFalse(os.path.exists(file_item))
+            archive.decompress(output_name, 'lzo')
+            self.assertTrue(os.path.exists(file_item))
+
+    def _test_decompress_lzo_no_compress_format(self):
+        """Test decompress
+            Format: lzo
+            one parameters is given, only target file"""
+        for file_item in self.files:
+            output_name = archive.compress(file_item, 'lzo')
+            self.assertEqual('%s.lzo' % file_item, output_name)
+            self.assertTrue(os.path.exists(output_name))
+            self.assertFalse(os.path.exists(file_item))
+            archive.decompress(output_name)
+            self.assertTrue(os.path.exists(file_item))
+
+    def test_get_archive_formats(self):
+        """Test get archive format"""
+        archive_formats = archive.get_archive_formats()
+        archive_formats.sort()
+        self.assertEqual(archive_formats,
+                        ["bztar", "gztar", "lzotar", "tar", 'zip'])
+
+    def test_get_archive_suffixes(self):
+        """Test get archive suffixes"""
+        archive_suffixes = archive.get_archive_suffixes()
+        archive_suffixes.sort()
+
+        self.assertEqual(archive_suffixes,
+                         ['.tar', '.tar.bz', '.tar.bz2', '.tar.gz', '.tar.lzo',
+                         '.taz', '.tbz', '.tbz2', '.tgz', '.tzo', '.zip'])
+
+    def test_make_archive_negtive_archive_name_is_required(self):
+        """Test if first parameter: file path is empty"""
+        with self.assertRaises(Exception):
+            archive.make_archive('', self.relative_dir)
+
+    def test_extract_archive_negtive_archive_name_is_required(self):
+        """Test if first parameter: file path is empty"""
+        with self.assertRaises(Exception):
+            archive.extract_archive('', self.relative_dir)
+
+    def test_make_archive_negtive_target_name_is_required(self):
+        """Test if second parameter: target name is empty"""
+        with self.assertRaises(Exception):
+            archive.make_archive('a.zip', '')
+
+    def _extract_archive_negtive_target_name_is_required(self):
+        # Not sure if the current dir will be used ?
+        # TODO:
+        pass
+
+    def test_make_archive_negtive_parameters_are_empty(self):
+        """Test if both parameters are empty"""
+        with self.assertRaises(Exception):
+            archive.make_archive('', '')
+
+    def test_extract_archive_negtive_parameters_are_empty(self):
+        """Test if both parameters are empty"""
+        with self.assertRaises(Exception):
+            archive.extract_archive('', '')
+
+    def test_make_archive_negtive_target_path_not_exists(self):
+        """Test if file path does not exist"""
+        fake_file = 'abcdfsdf'
+        with self.assertRaises(Exception):
+            archive.make_archive('a.tar', fake_file)
+
+        with self.assertRaises(Exception):
+            archive.make_archive('a.zip', fake_file)
+
+    def test_extract_archive_negtive_path_not_exists(self):
+        """Test if file path does not exist"""
+        fake_file = 'abcdfsdf'
+        with self.assertRaises(Exception):
+            archive.extract_archive(fake_file, self.relative_dir)
+
+    def test_extract_archive_negtive_target_is_file(self):
+        """Test if the extract target is file"""
+        out_file = '%s.tar' % self.relative_dir
+        self.assertTrue(archive.make_archive(out_file, self.relative_dir))
+        self.assertTrue(os.path.exists(out_file))
+        with self.assertRaises(Exception):
+            archive.extract_archive(out_file, self.relative_file)
+        os.remove(out_file)
+
+    def test_make_archive_wrong_format(self):
+        """Test wrong make_archive format"""
+        with self.assertRaises(Exception):
+            archive.make_archive('a.sfsfrwe', self.relative_dir)
+
+    def test_make_archive_tar_with_different_name(self):
+        """ Test make_archive format: tar
+            It packs the source with another name"""
+        for item in self.files + self.dirs:
+            out_file = 'abcd.tar'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_tar(self):
+        """ Test make_archive format: tar"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_extract_archive_tar(self):
+        """ Test extract format: tar"""
+        for item in self.files:
+            out_file = '%s.tar' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(
+                                           out_dir,
+                                           os.path.basename(item))))
+            shutil.rmtree(out_dir)
+
+        for item in self.dirs:
+            out_file = '%s.tar' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, '1.txt')))
+            self.assertTrue(os.path.exists(os.path.join(out_dir, '2.txt')))
+            self.assertTrue(os.path.exists(os.path.join(out_dir, 'dir1')))
+            self.assertTrue(os.path.exists(os.path.join(out_dir, 'dir2')))
+            shutil.rmtree(out_dir)
+
+    def test_make_archive_zip_with_different_name(self):
+        """ Test make_archive format: zip
+            It packs the source with another name"""
+        for item in self.files + self.dirs:
+            out_file = 'a.zip'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_zip(self):
+        """ Test make_archive format: zip"""
+        for item in self.files + self.dirs:
+            out_file = '%s.zip' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_zip(self):
+        """ Test extract archive format: zip"""
+        for item in self.files + self.dirs:
+            out_file = '%s.zip' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def _test_make_archive_tzo_with_different_name(self):
+        """ Test make_archive format: tzo
+            It packs the source with another name"""
+        for item in self.files + self.dirs:
+            out_file = 'abc.tzo'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _test_make_archive_tzo(self):
+        """ Test make_archive format: tzo"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tzo' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_tzo(self):
+        """ Test extract format: tzo"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tzo' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def _test_make_archive_tar_lzo_with_different_name(self):
+        """ Test make_archive format: lzo
+            It packs the source with another name"""
+        for item in self.files + self.dirs:
+            out_file = 'abc.tar.lzo'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _test_make_archive_tar_lzo(self):
+        """ Test make_archive format: lzo"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar.lzo' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_tar_lzo(self):
+        """ Test extract_archive format: lzo"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar.lzo' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def test_make_archive_taz_with_different_name(self):
+        """ Test make_archive format: taz
+            It packs the source with another name"""
+        for item in self.files + self.dirs:
+            out_file = 'abcd.taz'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_taz(self):
+        """ Test make_archive format: taz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.taz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_taz(self):
+        """ Test extract archive format: taz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.taz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def test_make_archive_tgz_with_different_name(self):
+        """ Test make_archive format: tgz
+            It packs the source with anotehr name"""
+        for item in self.files + self.dirs:
+            out_file = 'abc.tgz'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_tgz(self):
+        """ Test make_archive format: tgz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tgz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_tgz(self):
+        """ Test extract archive format: tgz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tgz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def test_make_archive_tar_gz_with_different_name(self):
+        """ Test make_archive format: tar.gz
+            It packs the source with another name"""
+        for item in self.files + self.dirs:
+            out_file = 'erwe.tar.gz'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_tar_gz(self):
+        """ Test make_archive format: tar.gz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar.gz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_tar_gz(self):
+        """ Test extract archive format: tar.gz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar.gz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def test_make_archive_tbz_with_different_name(self):
+        """ Test make_archive format: tbz
+            It packs the source with another name"""
+        for item in self.files + self.dirs:
+            out_file = 'sdfsd.tbz'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_tbz(self):
+        """ Test make_archive format: tbz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tbz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_tbz(self):
+        """ Test extract format: tbz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tbz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def test_make_archive_tbz2_with_different_name(self):
+        """ Test make_archive format: tbz2
+            It packs source with another name"""
+        for item in self.files + self.dirs:
+            out_file = 'sfsfd.tbz2'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_tbz2(self):
+        """ Test make_archive format: tbz2"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tbz2' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_tbz2(self):
+        """ Test extract format: tbz2"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tbz2' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def test_make_archive_tar_bz_with_different_name(self):
+        """ Test make_archive format: tar.bz
+            It packs source with antoher name"""
+        for item in self.files + self.dirs:
+            out_file = 'sdf.tar.bz'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_tar_bz(self):
+        """ Test make_archive format: tar.bz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar.bz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_tar_bz(self):
+        """ Test extract format: tar.bz"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar.bz' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+    def test_make_archive_tar_bz2_with_different_name(self):
+        """ Test make_archive format: tar.bz2
+            it packs the source with another name """
+        for item in self.files + self.dirs:
+            out_file = 'df.tar.bz2'
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def test_make_archive_tar_bz2(self):
+        """ Test make_archive format: tar.bz2"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar.bz2' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+            os.remove(out_file)
+
+    def _extract_archive_tar_bz2(self):
+        """ Test extract format: tar.bz2"""
+        for item in self.files + self.dirs:
+            out_file = '%s.tar.bz2' % item
+            self.assertTrue(archive.make_archive(out_file, item))
+            self.assertTrue(os.path.exists(out_file))
+
+            out_dir = 'un_tar_dir'
+            archive.extract_archive(out_file, out_dir)
+            self.assertTrue(os.path.exists(os.path.join(out_dir, item)))
+            shutil.rmtree(out_dir)
+
+if __name__ == "__main__":
+    unittest.main()