Remove acceptance_tests, they were diffucult to run and are superseded

Our ci-dnf-stack contains almost all of these createrepo_c tests:
https://github.com/rpm-software-management/ci-dnf-stack/tree/master/dnf-behave-tests/createrepo_c
(It is missing the ones comparing createrepo and createrepo_c)

11 files changed, 0 insertions, 1202 deletions

diff --git a/acceptance_tests/run_nosetests.sh b/acceptance_tests/run_nosetests.sh
deleted file mode 100755
index 9ed7002..0000000
--- a/acceptance_tests/run_nosetests.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/bash
-
-CURDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-BUILDDIR="$( cd "$CURDIR/../build" && pwd )"
-
-# All use cases
-PATH="$BUILDDIR/src/:/home/tmlcoch/git/yum-metadata-diff/:$PATH" LD_LIBRARY_PATH=$BUILDDIR/src/ PYTHONPATH=$BUILDDIR/src/python/ nosetests -s -v ./tests/ --processes 4 --process-timeout=300
-
-# Single module:
-#PATH="$BUILDDIR/src/:/home/tmlcoch/git/repodiff/:$PATH" LD_LIBRARY_PATH=$BUILDDIR/src/ PYTHONPATH=$BUILDDIR/src/python/ nosetests -s -v --processes 4 --process-timeout=300 tests/test_sqliterepo.py
-
-# Single test:
-# PATH="$BUILDDIR/src/:/home/tmlcoch/git/repodiff/:$PATH" LD_LIBRARY_PATH=$BUILDDIR/src/ PYTHONPATH=$BUILDDIR/src/python/ nosetests -s -v --processes 4 --process-timeout=300 tests/test_createrepo.py:TestCaseCreaterepo_emptyrepo.test_01_createrepo
diff --git a/acceptance_tests/testdata/packages/Archer-3.4.5-6.x86_64.rpm b/acceptance_tests/testdata/packages/Archer-3.4.5-6.x86_64.rpm
deleted file mode 100644
index 6067c88..0000000
--- a/acceptance_tests/testdata/packages/Archer-3.4.5-6.x86_64.rpm
+++ /dev/null
diff --git a/acceptance_tests/testdata/packages/fake_bash-1.1.1-1.x86_64.rpm b/acceptance_tests/testdata/packages/fake_bash-1.1.1-1.x86_64.rpm
deleted file mode 100644
index ddab045..0000000
--- a/acceptance_tests/testdata/packages/fake_bash-1.1.1-1.x86_64.rpm
+++ /dev/null
diff --git a/acceptance_tests/testdata/packages/super_kernel-6.0.1-2.x86_64.rpm b/acceptance_tests/testdata/packages/super_kernel-6.0.1-2.x86_64.rpm
deleted file mode 100644
index b606e16..0000000
--- a/acceptance_tests/testdata/packages/super_kernel-6.0.1-2.x86_64.rpm
+++ /dev/null
diff --git a/acceptance_tests/tests/__init__.py b/acceptance_tests/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/acceptance_tests/tests/__init__.py
+++ /dev/null
diff --git a/acceptance_tests/tests/base.py b/acceptance_tests/tests/base.py
deleted file mode 100644
index 4e534cf..0000000
--- a/acceptance_tests/tests/base.py
+++ /dev/null
@@ -1,389 +0,0 @@
-import os
-import re
-import time
-import shutil
-import pprint
-import gzip
-import filecmp
-import os.path
-import tempfile
-import unittest
-import threading
-import subprocess
-
-from .fixtures import PACKAGESDIR
-
-OUTPUTDIR = None
-OUTPUTDIR_LOCK = threading.Lock()
-
-def get_outputdir():
-    global OUTPUTDIR
-    if OUTPUTDIR:
-        return OUTPUTDIR
-    OUTPUTDIR_LOCK.acquire()
-    if not OUTPUTDIR:
-        prefix = time.strftime("./testresults_%Y%m%d_%H%M%S_")
-        OUTPUTDIR = tempfile.mkdtemp(prefix=prefix, dir="./")
-    OUTPUTDIR_LOCK.release()
-    return OUTPUTDIR
-
-
-class _Result(object):
-    def __str__(self):
-        return pprint.pformat(self.__dict__)
-
-
-class CrResult(_Result):
-    def __init__(self):
-        self.rc = None       # Return code
-        self.out = None      # stdout + stderr
-        self.dir = None      # Directory that was processed
-        self.prog = None     # Program name
-        self.cmd = None      # Complete command
-        self.outdir = None   # Output directory
-        self.logfile = None  # Log file where the out was logged
-
-
-class RepoDiffResult(_Result):
-    def __init__(self):
-        self.rc = None
-        self.out = None
-        self.repo1 = None
-        self.repo2 = None
-        self.cmd = None      # Complete command
-        self.logfile = None  # Log file where the out was logged
-
-
-class RepoSanityCheckResult(_Result):
-    def __init__(self):
-        self.rc = None
-        self.out = None
-        self.repo = None
-        self.cmd = None
-        self.logfile = None
-
-
-class BaseTestCase(unittest.TestCase):
-
-    def __init__(self, *args, **kwargs):
-        self.outdir = get_outputdir()
-        self.tcdir = os.path.join(self.outdir, self.__class__.__name__)
-        if not os.path.exists(self.tcdir):
-            os.mkdir(self.tcdir)
-        if self.__class__.__doc__:
-            description_fn = os.path.join(self.tcdir, "description")
-            open(description_fn, "w").write(self.__class__.__doc__+'\n')
-        unittest.TestCase.__init__(self, *args, **kwargs)
-
-        self.tdir = None            # Test dir for the current test
-        self.indir = None           # Input dir for the current test
-        self._currentResult = None  # Result of the current test
-
-        # Prevent use of a first line from test docstring as its name in output
-        self.shortDescription_orig = self.shortDescription
-        self.shortDescription = self._shortDescription
-        self.main_cwd = os.getcwd()
-
-    def _shortDescription(self):
-        return ".".join(self.id().split('.')[-2:])
-
-    def run(self, result=None):
-        # Hacky
-        self._currentResult = result # remember result for use in tearDown
-        unittest.TestCase.run(self, result)
-
-    def setUp(self):
-        os.chdir(self.main_cwd) # In case of TimedOutException in Nose test... the tearDown is not called :-/
-        caller = self.id().split(".", 3)[-1]
-        self.tdir = os.path.abspath(os.path.join(self.tcdir, caller))
-        os.mkdir(self.tdir)
-        self.indir = os.path.join(self.tdir, "input")
-        os.mkdir(self.indir)
-        description = self.shortDescription_orig()
-        if description:
-            fn = os.path.join(self.tdir, "description")
-            open(fn, "w").write(description+'\n')
-        #self.log = # TODO
-        os.chdir(self.tdir)
-        self.setup()
-
-    def setup(self):
-        pass
-
-    def tearDown(self):
-        if self.tdir and self._currentResult:
-            if not len(self._currentResult.errors) + len(self._currentResult.failures):
-                self.set_success()
-        self.teardown()
-        os.chdir(self.main_cwd)
-
-    def teardown(self):
-        pass
-
-    def runcmd(self, cmd, logfile=None, workdir=None, stdin_data=None):
-        """Stolen from the kobo library.
-         Author of the original function is dmach@redhat.com"""
-
-        # TODO: Add time how long the command takes
-
-        if type(cmd) in (list, tuple):
-            import pipes
-            cmd = " ".join(pipes.quote(i) for i in cmd)
-
-        if logfile is not None:
-            already_exists = False
-            if os.path.exists(logfile):
-                already_exists = True
-            logfile = open(logfile, "a")
-            if already_exists:
-                logfile.write("\n{0}\n Another run\n{0}\n".format('='*79))
-            logfile.write("cd %s\n" % os.getcwd())
-            for var in ("PATH", "PYTHONPATH", "LD_LIBRARY_PATH"):
-                logfile.write('export %s="%s"\n' % (var, os.environ.get(var,"")))
-            logfile.write("\n")
-            logfile.write(cmd+"\n")
-            logfile.write("\n+%s+\n\n" % ('-'*77))
-
-        stdin = None
-        if stdin_data is not None:
-            stdin = subprocess.PIPE
-
-        proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
-                                stderr=subprocess.STDOUT, cwd=workdir)
-
-        if stdin_data is not None:
-            class StdinThread(threading.Thread):
-                def run(self):
-                    proc.stdin.write(stdin_data)
-                    proc.stdin.close()
-            stdin_thread = StdinThread()
-            stdin_thread.daemon = True
-            stdin_thread.start()
-
-        output = ""
-        while True:
-            lines = proc.stdout.readline().decode('utf-8')
-            if lines == "":
-                break
-            if logfile:
-                logfile.write(lines)
-            output += lines
-        proc.wait()
-
-        if logfile:
-            logfile.write("\n+%s+\n\n" % ('-'*77))
-            logfile.write("RC: %s (%s)\n" % (proc.returncode, "Success" if not proc.returncode else "Failure"))
-            logfile.close()
-
-        if stdin_data is not None:
-            stdin_thread.join()
-
-        return proc.returncode, output
-
-    def set_success(self):
-        """Create a SUCCESS file in directory of the current test"""
-        fn = os.path.join(self.tdir, "SUCCESS")
-        open(fn, "w")
-
-    def copy_pkg(self, name, dst):
-        """Copy package from testdata into specified destination"""
-        src = os.path.join(PACKAGESDIR, name)
-        shutil.copy(src, dst)
-        return os.path.join(dst, name)
-
-    def indir_addpkg(self, name):
-        """Add package into input dir for the current test"""
-        src = os.path.join(PACKAGESDIR, name)
-        return self.copy_pkg(src, self.indir)
-
-    def indir_makedirs(self, path):
-        """Make a directory in input dir of the current test"""
-        path = path.lstrip('/')
-        final_path = os.path.join(self.indir, path)
-        os.makedirs(final_path)
-        return final_path
-
-    def indir_mkfile(self, name, content=""):
-        """Create a file in input dir of the current test"""
-        fn = os.path.join(self.indir, name)
-        with open(fn, "w") as f:
-            f.write(content)
-        return fn
-
-    def tdir_makedirs(self, path):
-        """Make a directory in test dir of the current test"""
-        path = path.lstrip('/')
-        final_path = os.path.join(self.tdir, path)
-        os.makedirs(final_path)
-        return final_path
-
-    def run_prog(self, prog, dir, args=None, outdir=None):
-        res = CrResult()
-        res.dir = dir
-        res.prog = prog
-        res.outdir = outdir
-        res.logfile =  os.path.join(self.tdir, "out_%s" % res.prog)
-        res.cmd = "%(prog)s --verbose %(args)s %(dir)s" % {
-            "prog": res.prog,
-            "dir": res.dir,
-            "args": args or "",
-        }
-        res.rc, res.out = self.runcmd(res.cmd, logfile=res.logfile)
-        return res
-
-    def run_cr(self, dir, args=None, c=False, outdir=None):
-        """Run createrepo and return CrResult object with results
-
-        :returns: Result of the createrepo run
-        :rtype: CrResult
-        """
-        prog = "createrepo_c" if c else "createrepo"
-
-        if not outdir:
-            outdir = os.path.join(self.tdir, prog)
-        else:
-            outdir = os.path.join(self.tdir, outdir)
-        if not os.path.exists(outdir):
-            os.mkdir(outdir)
-
-        args = " -o %s %s" % (outdir, args if args else "")
-
-        res = self.run_prog(prog, dir, args, outdir)
-        return res
-
-    def run_sqlr(self, dir, args=None):
-        """"""
-        res = self.run_prog("sqliterepo_c", dir, args)
-        return res
-
-    def compare_repos(self, repo1, repo2):
-        """Compare two repos
-
-        :returns: Difference between two repositories
-        :rtype: RepoDiffResult
-        """
-        res = RepoDiffResult()
-        res.repo1 = os.path.join(repo1, "repodata")
-        res.repo2 = os.path.join(repo2, "repodata")
-        res.logfile = os.path.join(self.tdir, "out_cmp")
-        res.cmd = "yum-metadata-diff --verbose --compare %s %s" % (res.repo1, res.repo2)
-        res.rc, res.out = self.runcmd(res.cmd, logfile=res.logfile)
-        return res
-
-    def check_repo_sanity(self, repo):
-        """Check if a repository is sane
-
-        :returns: Result of the sanity check
-        :rtype: RepoSanityCheckResult
-        """
-        res = RepoSanityCheckResult()
-        res.repo = os.path.join(repo, "repodata")
-        res.logfile = os.path.join(self.tdir, "out_sanity")
-        res.cmd = "yum-metadata-diff --verbose --check %s" % res.repo
-        res.rc, res.out = self.runcmd(res.cmd, logfile=res.logfile)
-        return res
-
-    def assert_run_cr(self, *args, **kwargs):
-        """Run createrepo and assert that it finished with return code 0
-
-        :returns: Result of the createrepo run
-        :rtype: CrResult
-        """
-        res = self.run_cr(*args, **kwargs)
-        self.assertFalse(res.rc)
-        return res
-
-    def assert_run_sqlr(self, *args, **kwargs):
-        """Run sqliterepo and assert that it finished with return code 0
-
-        :returns: Result of the sqliterepo run
-        :rtype: CrResult
-        """
-        res = self.run_sqlr(*args, **kwargs)
-        self.assertFalse(res.rc)
-        return res
-
-    def assert_same_results(self, indir, args=None):
-        """Run both createrepo and createrepo_c and assert that results are same
-
-        :returns: (result of comparison, createrepo result, createrepo_c result)
-        :rtype: (RepoDiffResult, CrResult, CrResult)
-        """
-        crres = self.run_cr(indir, args)
-        crcres = self.run_cr(indir, args, c=True)
-        self.assertFalse(crres.rc)   # Error while running createrepo
-        self.assertFalse(crcres.rc)  # Error while running createrepo_c
-        cmpres = self.compare_repos(crres.outdir, crcres.outdir)
-        self.assertFalse(cmpres.rc)  # Repos are not same
-        return (cmpres, crres, crcres)
-
-    def assert_repo_sanity(self, repo):
-        """Run repo sanity check and assert it's sane
-
-        :returns: Result of the sanity check
-        :rtype: RepoSanityCheckResult
-        """
-        res = self.check_repo_sanity(repo)
-        self.assertFalse(res.rc)
-        return res
-
-    def assert_repo_files(self, repo, file_patterns, additional_files_allowed=True):
-        """Assert that files (defined by re) are in the repo
-        """
-        compiled_patterns = map(re.compile, file_patterns)
-        fns = os.listdir(os.path.join(repo, "repodata/"))
-        used_patterns = []
-        for pattern in compiled_patterns:
-            for fn in fns[:]:
-                if pattern.match(fn):
-                    fns.remove(fn)
-                    used_patterns.append(pattern)
-
-        if not additional_files_allowed:
-            self.assertEqual(fns, [])  # Unexpected additional files
-
-        unused_paterns = [x.pattern for x in (set(compiled_patterns) - set(used_patterns))]
-        self.assertEqual(unused_paterns, [])  # Some patterns weren't used
-
-    def assert_same_dir_content(self, a, b):
-        """Assert identical content of two directories
-        (Not recursive yet)
-        """
-        # TODO: Recursive
-        self.assertTrue(os.path.isdir(a))
-        self.assertTrue(os.path.isdir(b))
-
-        _, logfn = tempfile.mkstemp(prefix="out_dircmp_%s_" % long(time.time()), dir=self.tdir)
-        logfile = open(logfn, "w")
-        logfile.write("A: %s\n" % a)
-        logfile.write("B: %s\n" % b)
-        logfile.write("\n")
-
-        dircmpobj = filecmp.dircmp(a, b)
-        if dircmpobj.left_only or dircmpobj.right_only or dircmpobj.diff_files:
-            logfile.write("A only:\n%s\n\n" % dircmpobj.left_only)
-            logfile.write("B only:\n%s\n\n" % dircmpobj.right_only)
-            logfile.write("Diff files:\n%s\n\n" % dircmpobj.diff_files)
-            logfile.close()
-            self.assertTrue(False)
-        logfile.write("OK\n")
-        logfile.close()
-
-    def assert_file_contains_line(self, path_to_file, line):
-        contents = ""
-        found = False
-
-        if path_to_file.endswith(".gz"):
-            with gzip.open(path_to_file, 'rb') as f:
-                for l in f.readlines():
-                    if (l.strip() == line.strip()):
-                        found = True
-                self.assertTrue(found, "Line: " + line + " not found in file: " + path_to_file)
-                return
-
-        with open(path_to_file) as f:
-            for l in f.readlines():
-                if (l.strip() == line.strip()):
-                    found = True
-
-        self.assertTrue(found, "Line: " + line + " not found in file: " + path_to_file)
diff --git a/acceptance_tests/tests/fixtures.py b/acceptance_tests/tests/fixtures.py
deleted file mode 100644
index c114bcc..0000000
--- a/acceptance_tests/tests/fixtures.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import os.path
-
-TESTDATADIR = os.path.normpath(os.path.join(__file__, "../../testdata"))
-PACKAGESDIR=os.path.join(TESTDATADIR, "packages")
-
-PACKAGES = [
-    "Archer-3.4.5-6.x86_64.rpm",
-    "fake_bash-1.1.1-1.x86_64.rpm",
-    "super_kernel-6.0.1-2.x86_64.rpm",
-]
\ No newline at end of file
diff --git a/acceptance_tests/tests/test_createrepo.py b/acceptance_tests/tests/test_createrepo.py
deleted file mode 100644
index f03d0b2..0000000
--- a/acceptance_tests/tests/test_createrepo.py
+++ /dev/null
@@ -1,347 +0,0 @@
-import os
-import os.path
-import glob
-
-from .fixtures import PACKAGES
-from .base import BaseTestCase
-
-
-class TestCaseCreaterepo_badparams(BaseTestCase):
-    """Use case with bad commandline arguments"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-
-    def test_01_createrepo_noinputdir(self):
-        """No directory to index was specified"""
-        res = self.run_cr("", c=True)
-        self.assertTrue(res.rc)
-
-    def test_02_createrepo_badinputdir(self):
-        """Directory specified to index doesn't exist"""
-        res = self.run_cr("somenonexistingdirectorytoindex/", c=True)
-        self.assertTrue(res.rc)
-
-    def test_03_createrepo_unknownparam(self):
-        """Unknown param is specified"""
-        res = self.run_cr(self.indir, "--someunknownparam", c=True)
-        self.assertTrue(res.rc)
-
-    def test_04_createrepo_badchecksumtype(self):
-        """Unknown checksum type is specified"""
-        res = self.run_cr(self.indir, "--checksum foobarunknownchecksum", c=True)
-        self.assertTrue(res.rc)
-
-    def test_05_createrepo_badcompressiontype(self):
-        """Unknown compressin type is specified"""
-        res = self.run_cr(self.indir, "--compress-type foobarunknowncompression", c=True)
-        self.assertTrue(res.rc)
-
-    def test_06_createrepo_badgroupfile(self):
-        """Bad groupfile file specified"""
-        res = self.run_cr(self.indir, "--groupfile badgroupfile", c=True)
-        self.assertTrue(res.rc)
-
-    def test_07_createrepo_badpkglist(self):
-        """Bad pkglist file specified"""
-        res = self.run_cr(self.indir, "--pkglist badpkglist", c=True)
-        self.assertTrue(res.rc)
-
-    def test_08_createrepo_retainoldmdbyagetogetherwithretainoldmd(self):
-        """Both --retain-old-md-by-age and --retain-old-md are specified"""
-        res = self.run_cr(self.indir, "--retain-old-md-by-age 1 --retain-old-md", c=True)
-        self.assertTrue(res.rc)
-
-    def test_09_createrepo_retainoldmdbyagewithbadage(self):
-        """Both --retain-old-md-by-age and --retain-old-md are specified"""
-        res = self.run_cr(self.indir, "--retain-old-md-by-age 55Z", c=True)
-        self.assertTrue(res.rc)
-
-
-class TestCaseCreaterepo_emptyrepo(BaseTestCase):
-    """Empty input repository"""
-
-    def setup(self):
-        self.fn_comps = self.indir_mkfile("comps.xml", '<?xml version="1.0"?><comps/>')
-
-    def test_01_createrepo(self):
-        """Repo from empty directory"""
-        res = self.assert_run_cr(self.indir, c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]{64}-primary.xml.gz$",
-                                "[a-z0-9]{64}-filelists.xml.gz$",
-                                "[a-z0-9]{64}-other.xml.gz$",
-                                "[a-z0-9]{64}-primary.sqlite.bz2$",
-                                "[a-z0-9]{64}-filelists.sqlite.bz2$",
-                                "[a-z0-9]{64}-other.sqlite.bz2$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_02_createrepo_database(self):
-        """--database"""
-        res = self.assert_run_cr(self.indir, "--database", c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]+-primary.xml.gz$",
-                                "[a-z0-9]+-filelists.xml.gz$",
-                                "[a-z0-9]+-other.xml.gz$",
-                                "[a-z0-9]+-primary.sqlite.bz2$",
-                                "[a-z0-9]+-filelists.sqlite.bz2$",
-                                "[a-z0-9]+-other.sqlite.bz2$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_03_createrepo_nodatabase(self):
-        """--database"""
-        res = self.assert_run_cr(self.indir, "--no-database", c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]+-primary.xml.gz$",
-                                "[a-z0-9]+-filelists.xml.gz$",
-                                "[a-z0-9]+-other.xml.gz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_04_createrepo_groupfile(self):
-        """--groupfile"""
-        res = self.assert_run_cr(self.indir, "--groupfile %s" % self.fn_comps, c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]+-primary.xml.gz$",
-                                "[a-z0-9]+-filelists.xml.gz$",
-                                "[a-z0-9]+-other.xml.gz$",
-                                "[a-z0-9]+-primary.sqlite.bz2$",
-                                "[a-z0-9]+-filelists.sqlite.bz2$",
-                                "[a-z0-9]+-other.sqlite.bz2$",
-                                "[a-z0-9]+-comps.xml$",
-                                "[a-z0-9]+-comps.xml.gz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_05_createrepo_checksum(self):
-        """--checksum sha and --groupfile"""
-        res = self.assert_run_cr(self.indir,
-                                 "--checksum %(checksum)s --groupfile %(groupfile)s" % {
-                                    'checksum': "sha1",
-                                    'groupfile': self.fn_comps },
-                                 c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]{40}-primary.xml.gz$",
-                                "[a-z0-9]{40}-filelists.xml.gz$",
-                                "[a-z0-9]{40}-other.xml.gz$",
-                                "[a-z0-9]{40}-primary.sqlite.bz2$",
-                                "[a-z0-9]{40}-filelists.sqlite.bz2$",
-                                "[a-z0-9]{40}-other.sqlite.bz2$",
-                                "[a-z0-9]{40}-comps.xml$",
-                                "[a-z0-9]{40}-comps.xml.gz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_06_createrepo_simplemdfilenames(self):
-        """--simple-md-filenames and --groupfile"""
-        res = self.assert_run_cr(self.indir,
-                                 "--simple-md-filenames --groupfile %(groupfile)s" % {
-                                    'groupfile': self.fn_comps },
-                                 c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "primary.xml.gz$",
-                                "filelists.xml.gz$",
-                                "other.xml.gz$",
-                                "primary.sqlite.bz2$",
-                                "filelists.sqlite.bz2$",
-                                "other.sqlite.bz2$",
-                                "comps.xml$",
-                                "comps.xml.gz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_07_createrepo_xz(self):
-        """--xz and --groupfile"""
-        res = self.assert_run_cr(self.indir,
-                                 "--xz --groupfile %(groupfile)s" % {
-                                    'groupfile': self.fn_comps },
-                                 c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]{64}-primary.xml.gz$",
-                                "[a-z0-9]{64}-filelists.xml.gz$",
-                                "[a-z0-9]{64}-other.xml.gz$",
-                                "[a-z0-9]{64}-primary.sqlite.xz$",
-                                "[a-z0-9]{64}-filelists.sqlite.xz$",
-                                "[a-z0-9]{64}-other.sqlite.xz$",
-                                "[a-z0-9]{64}-comps.xml$",
-                                "[a-z0-9]{64}-comps.xml.xz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_08_createrepo_compresstype_bz2(self):
-        """--compress-type bz2"""
-        res = self.assert_run_cr(self.indir, "--compress-type bz2", c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]{64}-primary.xml.gz$",
-                                "[a-z0-9]{64}-filelists.xml.gz$",
-                                "[a-z0-9]{64}-other.xml.gz$",
-                                "[a-z0-9]{64}-primary.sqlite.bz2$",
-                                "[a-z0-9]{64}-filelists.sqlite.bz2$",
-                                "[a-z0-9]{64}-other.sqlite.bz2$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_09_createrepo_compresstype_gz(self):
-        """--compress-type bz2"""
-        res = self.assert_run_cr(self.indir, "--compress-type gz", c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]{64}-primary.xml.gz$",
-                                "[a-z0-9]{64}-filelists.xml.gz$",
-                                "[a-z0-9]{64}-other.xml.gz$",
-                                "[a-z0-9]{64}-primary.sqlite.gz$",
-                                "[a-z0-9]{64}-filelists.sqlite.gz$",
-                                "[a-z0-9]{64}-other.sqlite.gz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_10_createrepo_compresstype_xz(self):
-        """--compress-type bz2"""
-        res = self.assert_run_cr(self.indir, "--compress-type xz", c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]{64}-primary.xml.gz$",
-                                "[a-z0-9]{64}-filelists.xml.gz$",
-                                "[a-z0-9]{64}-other.xml.gz$",
-                                "[a-z0-9]{64}-primary.sqlite.xz$",
-                                "[a-z0-9]{64}-filelists.sqlite.xz$",
-                                "[a-z0-9]{64}-other.sqlite.xz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_11_createrepo_repomd_checksum(self):
-        """--checksum sha and --groupfile"""
-        res = self.assert_run_cr(self.indir,
-                                 "--repomd-checksum %(checksum)s --groupfile %(groupfile)s" % {
-                                    'checksum': "sha1",
-                                    'groupfile': self.fn_comps },
-                                 c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]{40}-primary.xml.gz$",
-                                "[a-z0-9]{40}-filelists.xml.gz$",
-                                "[a-z0-9]{40}-other.xml.gz$",
-                                "[a-z0-9]{40}-primary.sqlite.bz2$",
-                                "[a-z0-9]{40}-filelists.sqlite.bz2$",
-                                "[a-z0-9]{40}-other.sqlite.bz2$",
-                                "[a-z0-9]{40}-comps.xml$",
-                                "[a-z0-9]{40}-comps.xml.gz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_12_createrepo_repomd_checksum(self):
-        """--checksum sha and --groupfile"""
-        res = self.assert_run_cr(self.indir,
-                                 "--checksum md5 --repomd-checksum %(checksum)s --groupfile %(groupfile)s" % {
-                                    'checksum': "sha1",
-                                    'groupfile': self.fn_comps },
-                                 c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]{40}-primary.xml.gz$",
-                                "[a-z0-9]{40}-filelists.xml.gz$",
-                                "[a-z0-9]{40}-other.xml.gz$",
-                                "[a-z0-9]{40}-primary.sqlite.bz2$",
-                                "[a-z0-9]{40}-filelists.sqlite.bz2$",
-                                "[a-z0-9]{40}-other.sqlite.bz2$",
-                                "[a-z0-9]{40}-comps.xml$",
-                                "[a-z0-9]{40}-comps.xml.gz$",
-                                ],
-                               additional_files_allowed=False)
-
-    def test_13_createrepo_general_compress_type(self):
-        """--checksum sha and --groupfile"""
-        res = self.assert_run_cr(self.indir,
-                                 "--general-compress-type %(compress_type)s --groupfile %(groupfile)s" % {
-                                    'compress_type': "xz",
-                                    'groupfile': self.fn_comps },
-                                 c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]+-primary.xml.xz$",
-                                "[a-z0-9]+-filelists.xml.xz$",
-                                "[a-z0-9]+-other.xml.xz$",
-                                "[a-z0-9]+-primary.sqlite.xz$",
-                                "[a-z0-9]+-filelists.sqlite.xz$",
-                                "[a-z0-9]+-other.sqlite.xz$",
-                                "[a-z0-9]+-comps.xml$",
-                                "[a-z0-9]+-comps.xml.xz$",
-                                ],
-                               additional_files_allowed=False)
-
-class TestCaseCreaterepo_packagedirstructure(BaseTestCase):
-    """Use case with various directory structure of packages"""
-    def test_01_createrepo_check_directories_recursively(self):
-        self.indir_makedirs("a")
-        self.indir_makedirs("a/b")
-        self.indir_makedirs("a/b/c")
-        self.copy_pkg(PACKAGES[0], self.indir + "/a")
-        self.copy_pkg(PACKAGES[1], self.indir + "/a/b")
-        self.copy_pkg(PACKAGES[2], self.indir + "/a/b/c")
-
-        res = self.assert_run_cr(self.indir, "", c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]+-primary.xml.gz$",
-                                "[a-z0-9]+-filelists.xml.gz$",
-                                "[a-z0-9]+-other.xml.gz$",
-                                "[a-z0-9]+-primary.sqlite.bz2$",
-                                "[a-z0-9]+-filelists.sqlite.bz2$",
-                                "[a-z0-9]+-other.sqlite.bz2$",
-                                ],
-                               additional_files_allowed=False)
-
-        primary_path = glob.glob(os.path.join(res.outdir, "repodata/*-primary.xml.gz"))[0]
-        self.assert_file_contains_line(primary_path, "<name>Archer</name>")
-        self.assert_file_contains_line(primary_path, "<name>super_kernel</name>")
-        self.assert_file_contains_line(primary_path, "<name>fake_bash</name>")
-        
-    def test_02_createrepo_check_directories_recursively_with_rpm_suffix(self):
-        self.indir_makedirs("a")
-        self.indir_makedirs('a/b.rpm')
-        self.indir_makedirs("a/b.rpm/c")
-        self.copy_pkg(PACKAGES[0], self.indir + "/a")
-        self.copy_pkg(PACKAGES[1], self.indir + "/a/b.rpm")
-        self.copy_pkg(PACKAGES[2], self.indir + "/a/b.rpm/c")
-
-        res = self.assert_run_cr(self.indir, "", c=True)
-        self.assert_repo_sanity(res.outdir)
-        self.assert_repo_files(res.outdir,
-                               ["repomd.xml$",
-                                "[a-z0-9]+-primary.xml.gz$",
-                                "[a-z0-9]+-filelists.xml.gz$",
-                                "[a-z0-9]+-other.xml.gz$",
-                                "[a-z0-9]+-primary.sqlite.bz2$",
-                                "[a-z0-9]+-filelists.sqlite.bz2$",
-                                "[a-z0-9]+-other.sqlite.bz2$",
-                                ],
-                               additional_files_allowed=False)
-
-        primary_path = glob.glob(os.path.join(res.outdir, "repodata/*-primary.xml.gz"))[0]
-        self.assert_file_contains_line(primary_path, "<name>Archer</name>")
-        self.assert_file_contains_line(primary_path, "<name>super_kernel</name>")
-        self.assert_file_contains_line(primary_path, "<name>fake_bash</name>")
diff --git a/acceptance_tests/tests/test_createrepo_comparative.py b/acceptance_tests/tests/test_createrepo_comparative.py
deleted file mode 100644
index 20a4b9e..0000000
--- a/acceptance_tests/tests/test_createrepo_comparative.py
+++ /dev/null
@@ -1,210 +0,0 @@
-import os
-import os.path
-
-from .fixtures import PACKAGES
-from .base import BaseTestCase
-
-
-class TestCaseCreaterepoComparative_emptyrepo(BaseTestCase):
-    """Empty input repository"""
-
-    def test_01_createrepo(self):
-        """Repo from empty directory"""
-        self.assert_same_results(self.indir)
-
-    def test_02_createrepo_relativepath(self):
-        """Repo from empty directory - specified by relative path"""
-        self.assert_same_results(os.path.relpath(self.indir))
-
-    def test_03_createrepo_distrotag(self):
-        """--distro"""
-        self.assert_same_results(self.indir, "--distro DISTRO-TAG")
-
-    def test_04_createrepo_distrotag(self):
-        """--distro"""
-        self.assert_same_results(self.indir, "--distro CPEID,Footag")
-
-    def test_05_createrepo_distrotag(self):
-        """--distro"""
-        self.assert_same_results(self.indir, "--distro cpeid,tag_a --distro tag_b")
-
-    def test_06_createrepo_contenttag(self):
-        """--content"""
-        self.assert_same_results(self.indir, "--content contenttag_a")
-
-    def test_07_createrepo_contenttag(self):
-        """--content"""
-        self.assert_same_results(self.indir, "--content contenttag_a --content contettag_b")
-
-    def test_08_createrepo_repotag(self):
-        """--repo"""
-        self.assert_same_results(self.indir, "--repo repotag_a")
-
-    def test_09_createrepo_repotag(self):
-        """--repo"""
-        self.assert_same_results(self.indir, "--repo repotag_a --repo repotag_b")
-
-    def test_10_createrepo_nodatabase(self):
-        """--no-database"""
-        self.assert_same_results(self.indir, "--no-database")
-
-    def test_11_createrepo_uniquemdfilenames(self):
-        """--unique-md-filenames"""
-        self.assert_same_results(self.indir, "--unique-md-filenames")
-
-    def test_12_createrepo_simplemdfilenames(self):
-        """--simple-md-filenames"""
-        self.assert_same_results(self.indir, "--simple-md-filenames")
-
-    def test_13_createrepo_revision(self):
-        """--revision"""
-        self.assert_same_results(self.indir, "--revision XYZ")
-
-    def test_14_createrepo_skipsymlinks(self):
-        """--skip-symlinks"""
-        self.assert_same_results(self.indir, "--skip-symlinks")
-
-
-class TestCaseCreaterepoComparative_regularrepo(BaseTestCase):
-    """Repo with 3 packages"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-        self.indir_addpkg(PACKAGES[1])
-        self.indir_addpkg(PACKAGES[2])
-
-    def test_01_createrepo(self):
-        """Regular createrepo"""
-        self.assert_same_results(self.indir)
-
-    def test_02_createrepo_relativepath(self):
-        """Regular createrepo"""
-        self.assert_same_results(os.path.relpath(self.indir))
-
-    def test_03_createrepo_excludes(self):
-        """--excludes * param"""
-        self.assert_same_results(self.indir, "--excludes '*'")
-
-    def test_04_createrepo_excludes(self):
-        """--excludes"""
-        self.assert_same_results(self.indir, "--excludes 'Archer-3.4.5-6.x86_64.rpm'")
-
-    def test_05_createrepo_excludes(self):
-        """--excludes"""
-        self.assert_same_results(self.indir, "--excludes 'Archer-*.rpm'")
-
-    def test_06_createrepo_skipsymlinks(self):
-        """--skip-symlinks"""
-        self.assert_same_results(self.indir, "--skip-symlinks")
-
-    def test_07_createrepo_pkglist(self):
-        """--pkglist"""
-        fn_pkglist = self.indir_mkfile("pkglist", "%s\n" % PACKAGES[0])
-        self.assert_same_results(self.indir, "--pkglist %s" % fn_pkglist)
-
-    def test_08_createrepo_pkglist(self):
-        """--pkglist"""
-        fn_pkglist = self.indir_mkfile("pkglist", "%s\n%s\n" % (PACKAGES[0], PACKAGES[1]))
-        self.assert_same_results(self.indir, "--pkglist %s" % fn_pkglist)
-
-    def test_09_createrepo_pkglist(self):
-        """--pkglist"""
-        fn_pkglist = self.indir_mkfile("pkglist", "%s\n\n%s\n\nfoobar.rpm\n\n" % (PACKAGES[0], PACKAGES[1]))
-        self.assert_same_results(self.indir, "--pkglist %s" % fn_pkglist)
-
-class TestCaseCreaterepoComparative_regularrepowithsubdirs(BaseTestCase):
-    """Repo with 3 packages, each in its own subdir"""
-
-    def setup(self):
-        subdir_a = self.indir_makedirs("a")
-        self.copy_pkg(PACKAGES[0], subdir_a)
-        subdir_b = self.indir_makedirs("b")
-        self.copy_pkg(PACKAGES[1], subdir_b)
-        subdir_c = self.indir_makedirs("c")
-        self.copy_pkg(PACKAGES[2], subdir_c)
-
-    def test_01_createrepo(self):
-        """Regular createrepo"""
-        self.assert_same_results(self.indir)
-
-    def test_02_createrepo_skipsymlinks(self):
-        """--skip-symlinks"""
-        self.assert_same_results(self.indir, "--skip-symlinks")
-
-    def test_03_createrepo_excludes(self):
-        """--excludes"""
-        self.assert_same_results(self.indir, "--excludes 'Archer-3.4.5-6.x86_64.rpm'")
-
-    def test_04_createrepo_excludes(self):
-        """--excludes"""
-        self.assert_same_results(self.indir, "--excludes 'Archer-*.rpm'")
-
-
-class TestCaseCreaterepoComparative_repowithsymlinks(BaseTestCase):
-    """Repo with 2 packages and 1 symlink to a package"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-        self.indir_addpkg(PACKAGES[1])
-        pkg_in_tdir = self.copy_pkg(PACKAGES[2], self.tdir)
-        os.symlink(pkg_in_tdir, os.path.join(self.indir, os.path.basename(pkg_in_tdir)))
-
-    def test_01_createrepo(self):
-        """Regular createrepo"""
-        self.assert_same_results(self.indir)
-
-    def test_02_createrepo_skipsymlinks(self):
-        """--skip-symlinks"""
-        self.assert_same_results(self.indir, "--skip-symlinks")
-
-
-class TestCaseCreaterepoComparative_repowithbadpackages(BaseTestCase):
-    """Repo with 1 regular package and few broken packages"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-        self.indir_makedirs("adirthatlookslike.rpm")
-        self.indir_mkfile("emptyfilethatlookslike.rpm")
-        self.indir_mkfile("afilethatlookslike.rpm", content="foobar")
-
-    def test_01_createrepo(self):
-        """Regular createrepo"""
-        self.assert_same_results(self.indir)
-
-
-class TestCaseCreaterepoComparative_cachedir(BaseTestCase):
-    """Repo with 3 packages and cachedir used"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-        self.indir_addpkg(PACKAGES[1])
-        self.indir_addpkg(PACKAGES[2])
-
-    def test_01_createrepo_owncachedir(self):
-        """Each createrepo has its own cachedir"""
-        # Gen cache
-        self.assert_same_results(self.indir, "--cachedir cache")
-        # Run again and use the cache
-        _, crres, crcres = self.assert_same_results(self.indir, "--cachedir cache")
-
-        # Compare files in the cache files (they should be identical)
-        cr_cache = os.path.join(crres.outdir, "cache")
-        crc_cache = os.path.join(crcres.outdir, "cache")
-        self.assert_same_dir_content(cr_cache, crc_cache)
-
-    def test_02_createrepo_sharedcachedir(self):
-        """Use cache mutually"""
-        cache_cr = os.path.abspath(os.path.join(self.indir, "cache_cr"))
-        cache_crc = os.path.abspath(os.path.join(self.indir, "cache_crc"))
-
-        # Gen cache by the cr then use it by cr_c
-        self.assert_run_cr(self.indir, "--cachedir %s" % cache_cr)
-        self.assert_run_cr(self.indir, "--cachedir %s" % cache_cr, c=True)
-
-        # Gen cache by the cr then use it by cr_c
-        self.assert_run_cr(self.indir, "--cachedir %s" % cache_crc, c=True)
-        self.assert_run_cr(self.indir, "--cachedir %s" % cache_crc)
-
-        # Compare files in the cache files (they should be identical)
-        self.assert_same_dir_content(cache_cr, cache_crc)
-
diff --git a/acceptance_tests/tests/test_createrepo_update_comparative.py b/acceptance_tests/tests/test_createrepo_update_comparative.py
deleted file mode 100644
index 098d8d4..0000000
--- a/acceptance_tests/tests/test_createrepo_update_comparative.py
+++ /dev/null
@@ -1,87 +0,0 @@
-import os
-import os.path
-
-from .fixtures import PACKAGES
-from .base import BaseTestCase
-
-
-class TestCaseCreaterepoUpdateComparative_emptyrepo(BaseTestCase):
-    """Empty input repository"""
-
-    def test_01_createrepoupdate(self):
-        """Repo from empty directory"""
-        self.assert_same_results(self.indir)
-        self.assert_same_results(self.indir, "--update")
-
-    def test_02_createrepoupdate_double(self):
-        """Repo from empty directory"""
-        self.assert_same_results(self.indir)
-        self.assert_same_results(self.indir, "--update")
-        self.assert_same_results(self.indir, "--update")
-
-    def test_03_createrepoupdate_relativepath(self):
-        """Repo from empty directory - specified by relative path"""
-        self.assert_same_results(os.path.relpath(self.indir))
-        self.assert_same_results(os.path.relpath(self.indir), "--update")
-
-    def test_04_createrepoupdate_simplemdfilenames(self):
-        """Repo from empty directory - specified by relative path"""
-        self.assert_same_results(os.path.relpath(self.indir))
-        self.assert_same_results(os.path.relpath(self.indir), "--update --simple-md-filenames")
-
-
-class TestCaseCreaterepoUpdateComparative_regularrepo(BaseTestCase):
-    """Repo with 3 packages"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-        self.indir_addpkg(PACKAGES[1])
-        self.indir_addpkg(PACKAGES[2])
-
-    def test_01_createrepoupdate(self):
-        """Repo from empty directory"""
-        self.assert_same_results(self.indir)
-        self.assert_same_results(self.indir, "--update")
-
-    def test_02_createrepoupdate_double(self):
-        """Repo from empty directory"""
-        self.assert_same_results(self.indir)
-        self.assert_same_results(self.indir, "--update")
-        self.assert_same_results(self.indir, "--update")
-
-    def test_03_createrepoupdate_relativepath(self):
-        """Repo from empty directory - specified by relative path"""
-        self.assert_same_results(os.path.relpath(self.indir))
-        self.assert_same_results(os.path.relpath(self.indir), "--update")
-
-    def test_04_createrepoupdate_simplemdfilenames(self):
-        """Repo from empty directory - specified by relative path"""
-        self.assert_same_results(os.path.relpath(self.indir))
-        self.assert_same_results(os.path.relpath(self.indir), "--update --simple-md-filenames")
-
-
-class TestCaseCreaterepoUpdateComparative_regularrepoandupdaterepo(BaseTestCase):
-    """Repo with 3 packages and repo that will be used as --update-md-path"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-        self.indir_addpkg(PACKAGES[1])
-        self.indir_addpkg(PACKAGES[2])
-        res = self.assert_run_cr(self.indir)
-        self.update_md_path = os.path.join(self.tdir, "update_md_path")
-        os.rename(res.outdir, self.update_md_path)
-        os.rename(res.logfile, os.path.join(self.tdir, "out_createrepo-update_md_path"))
-
-    def test_01_createrepoupdate_updatemdpath(self):
-        """Repo from empty directory"""
-        self.assert_same_results(self.indir, "--update --update-md-path %s" % self.update_md_path)
-
-    def test_02_createrepoupdate_updatemdpathandupdate(self):
-        """Repo from empty directory"""
-        self.assert_same_results(self.indir, "--update --update-md-path %s" % self.update_md_path)
-        self.assert_same_results(self.indir, "--update")
-
-    def test_03_createrepoupdate_updatemdpathdouble(self):
-        """Repo from empty directory"""
-        self.assert_same_results(self.indir, "--update --update-md-path %s" % self.update_md_path)
-        self.assert_same_results(self.indir, "--update --update-md-path %s" % self.update_md_path)
diff --git a/acceptance_tests/tests/test_sqliterepo.py b/acceptance_tests/tests/test_sqliterepo.py
deleted file mode 100644
index c3ba3d9..0000000
--- a/acceptance_tests/tests/test_sqliterepo.py
+++ /dev/null
@@ -1,146 +0,0 @@
-import os
-import time
-import os.path
-
-from .fixtures import PACKAGES
-from .base import BaseTestCase
-
-BASE_XML_PATTERNS_SIMPLE = ["repomd\.xml", "primary\.xml\..+", "filelists\.xml\..+", "other\.xml\..+"]
-BASE_XML_PATTERNS_UNIQUE = ["repomd\.xml", ".*-primary\.xml\..+", ".*-filelists\.xml\..+", ".*-other\.xml\..+"]
-
-DBS_PATTERNS = [".*primary\.sqlite\..+", ".*filelists\.sqlite\..+", ".*other\.sqlite\..+"]
-DBS_PATTERNS_SIMPLE = ["primary\.sqlite\..+", "filelists\.sqlite\..+", "other\.sqlite\..+"]
-DBS_PATTERNS_UNIQUE = [".*-primary\.sqlite\..+", ".*-filelists\.sqlite\..+", ".*-other\.sqlite\..+"]
-
-DBS_PATTERNS_UNIQUE_MD5 = ["[0-9a-z]{32}-primary\.sqlite\..+", ".*-filelists\.sqlite\..+", ".*-other\.sqlite\..+"]
-
-DBS_PATTERNS_SIMPLE_GZ = ["primary\.sqlite\.gz", "filelists\.sqlite\.gz", "other\.sqlite\.gz"]
-DBS_PATTERNS_SIMPLE_BZ2 = ["primary\.sqlite\.bz2", "filelists\.sqlite\.bz2", "other\.sqlite\.bz2"]
-DBS_PATTERNS_SIMPLE_XZ = ["primary\.sqlite\.xz", "filelists\.sqlite\.xz", "other\.sqlite\.xz"]
-
-
-class TestCaseSqliterepo_badparams(BaseTestCase):
-    """Use case with bad commandline arguments"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-
-
-class TestCaseSqliterepo(BaseTestCase):
-    """Base use cases"""
-
-    def setup(self):
-        self.indir_addpkg(PACKAGES[0])
-
-    def test_01_sqliterepo(self):
-        """Sqlitedbs already exists, sqliterepo without --force should fail"""
-        cr_res = self.run_cr(self.indir, c=True)
-        sq_res = self.run_sqlr(cr_res.outdir)
-        self.assertTrue(sq_res.rc)
-        self.assertTrue("already has sqlitedb present" in sq_res.out)
-
-    def test_02_sqliterepo(self):
-        """Sqlitedbs should be created"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--no-database", c=True, outdir=outdir)
-        self.assert_run_sqlr(outdir)
-        # Check that DBs really exists
-        self.assert_repo_files(outdir, DBS_PATTERNS, additional_files_allowed=True)
-
-    def test_03_sqliterepo(self):
-        """Sqlitedbs with simple md filenames should be created"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--no-database --simple-md-filenames", c=True, outdir=outdir)
-        self.assert_run_sqlr(outdir)
-        # Check that DBs really exists
-        self.assert_repo_files(outdir, DBS_PATTERNS_SIMPLE, additional_files_allowed=True)
-
-    def test_04_sqliterepo(self):
-        """Sqlitedbs with unique md filenames should be created"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--no-database --unique-md-filenames", c=True, outdir=outdir)
-        self.assert_run_sqlr(outdir)
-        # Check that DBs really exists
-        self.assert_repo_files(outdir, DBS_PATTERNS_UNIQUE, additional_files_allowed=True)
-
-    def test_05_sqliterepo(self):
-        """--xz is used (old bz2 DBs should be removed)"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--database --simple-md-filenames", c=True, outdir=outdir)
-        self.assert_run_sqlr(outdir, args="--force --xz")
-
-        # Check that DBs really exists
-        self.assert_repo_files(outdir,
-                               DBS_PATTERNS_SIMPLE_XZ+BASE_XML_PATTERNS_SIMPLE,
-                               additional_files_allowed=False)
-
-    def test_06_sqliterepo(self):
-        """DBs already exists but --force is used sqlitedbs should be created"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--database --simple-md-filenames", c=True, outdir=outdir)
-        old_primary_ts = os.path.getmtime(os.path.join(outdir, "repodata", "primary.sqlite.bz2"))
-
-        self.assert_run_sqlr(outdir, args="--force")
-        new_primary_ts = os.path.getmtime(os.path.join(outdir, "repodata", "primary.sqlite.bz2"))
-
-        # Check that DBs really exists
-        self.assert_repo_files(outdir, DBS_PATTERNS, additional_files_allowed=True)
-
-        # Check that DBs are newer than the old ones
-        self.assertTrue(old_primary_ts < new_primary_ts)
-
-    def test_07_sqliterepo(self):
-        """--force and --keep-old and --xz are used (old bz2 DBs should be keeped)"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--database --simple-md-filenames", c=True, outdir=outdir)
-        self.assert_run_sqlr(outdir, args="--force --keep-old --xz")
-
-        # Check that DBs really exists
-        self.assert_repo_files(outdir, DBS_PATTERNS_SIMPLE_BZ2, additional_files_allowed=True)
-        self.assert_repo_files(outdir, DBS_PATTERNS_SIMPLE_XZ, additional_files_allowed=True)
-
-    def test_08_sqliterepo(self):
-        """--local-sqlite is used and old DBs exists (--force is also used)"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--database --simple-md-filenames", c=True, outdir=outdir)
-        old_primary_ts = os.path.getmtime(os.path.join(outdir, "repodata", "primary.sqlite.bz2"))
-
-        self.assert_run_sqlr(outdir, args="--local-sqlite --force")
-        new_primary_ts = os.path.getmtime(os.path.join(outdir, "repodata", "primary.sqlite.bz2"))
-
-        # Check that DBs really exists
-        expected_files = DBS_PATTERNS_SIMPLE_BZ2 + BASE_XML_PATTERNS_SIMPLE
-        self.assert_repo_files(outdir, expected_files, additional_files_allowed=False)
-
-        # Check that DBs are newer than the old ones
-        self.assertTrue(old_primary_ts < new_primary_ts)
-
-    def test_09_sqliterepo(self):
-        """--local-sqlite is used with --xz and --force and --keep-old"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--database --simple-md-filenames", c=True, outdir=outdir)
-        self.assert_run_sqlr(outdir, args="--local-sqlite --force --keep-old --xz")
-
-        # Check that DBs really exists
-        self.assert_repo_files(outdir, DBS_PATTERNS_SIMPLE_BZ2, additional_files_allowed=True)
-        self.assert_repo_files(outdir, DBS_PATTERNS_SIMPLE_XZ, additional_files_allowed=True)
-
-    def test_10_sqliterepo(self):
-        """--compress-type used"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--database --simple-md-filenames", c=True, outdir=outdir)
-        self.assert_run_sqlr(outdir, args="--compress-type gz --force")
-
-        # Check that DBs really exists
-        expected_files = DBS_PATTERNS_SIMPLE_GZ + BASE_XML_PATTERNS_SIMPLE
-        self.assert_repo_files(outdir, expected_files, additional_files_allowed=False)
-
-    def test_11_sqliterepo(self):
-        """--checksum used"""
-        outdir = self.tdir_makedirs("repository")
-        self.assert_run_cr(self.indir, args="--database --unique-md-filenames", c=True, outdir=outdir)
-        self.assert_run_sqlr(outdir, args="--checksum md5 --force")
-
-        # Check that DBs really exists
-        expected_files = DBS_PATTERNS_UNIQUE_MD5 + BASE_XML_PATTERNS_UNIQUE
-        self.assert_repo_files(outdir, expected_files, additional_files_allowed=False)
\ No newline at end of file