Version bump

Exchanged os.rename with shutil.move since there was a problem with
moving files between different filesystems.

README.rst

@@ -126,8 +126,14 @@ Options used:
 
 * ``wrapper`` (required) with ``cd32`` as an value
 * ``wrapper_archive`` (required) path to the archive with CD32 iso/cue/wav
+* ``wrapper_archiver`` (conditionally required) archiver to use for storage
+  save state
 * ``wrapper_gui_msg`` (optional) if set to "1", will display a graphical
   message during extracting files
+* ``wrapper_save_state`` (optional) if set to "1", will load/archive save state
+  directory, defined as ``$CONFIG/[save-state-dir-name]`` using provided
+  ``wrapper_archiver`` archiver. If this option is enabled,
+  ``wrapper_archiver`` will be required.
 
 Let's see some sample config for a game, which is saved as
 ``ChaosEngine.fs-uae``:
@@ -138,6 +144,7 @@ Let's see some sample config for a game, which is saved as
    [config]
    wrapper = cd32
    wrapper_archive = ChaosEngine.7z
+   wrapper_archiver = 7z
    wrapper_gui_msg = 1
 
    amiga_model = CD32
@@ -164,14 +171,15 @@ Now, there several thing will happen:
 - Archive with game assists will be extracted in that directory
 - Configuration file will be copied into that directory, and renamed to
   ``Config.fs-uae``
-- If there is saved state, it also would be extracted there
+- If ``wrapper_save_state`` is set, and there is saved state archive, it also
+  would be extracted there
 - ``fs-uae`` will be launched inside that directory
 
 Next, after ``fs-uae`` quit, there will:
 
-- Create archive containing save state with name like the configuration file
+- Optionally create archive containing save state with name like the
-  with additional ``_save`` suffix. In this example it would be
+  configuration file with additional ``_save`` suffix. In this example it would
-  ``ChaosEngine_save.7z``.
+  be ``ChaosEngine_save.7z``.
 - Wipe out temporary directory
 
 archive
@@ -179,13 +187,19 @@ archive
 
 Options used:
 
-* ``wrapper`` (required) with ``cd32`` as an value
+* ``wrapper`` (required) with ``archive`` as an value
 * ``wrapper_archive`` (required) path to the archive with assets (usually means
-  whole system directories, floppies or hd images)
+  whole system directories, floppies or hard disk images)
+* ``wrapper_archiver`` (conditionally required) archiver to use for storage
+  save state
 * ``wrapper_gui_msg`` (optional) if set to "1", will display a graphical
   message during extracting files
 * ``wrapper_persist_data`` (optional) if set to "1", will compress (possibly
   changed) data, replacing original archive
+* ``wrapper_save_state`` (optional) if set to "1", will archive save state
+  directory, defined as ``$CONFIG/[save-state-dir-name]`` using provided
+  ``wrapper_archiver`` archiver. If this option is enabled,
+  ``wrapper_archiver`` will be required.
 
 Example configuration:
 
@@ -195,9 +209,10 @@ Example configuration:
    [config]
    wrapper = archive
    wrapper_archive = Workbench_3.1.tar.bz2
+   wrapper_archiver = lha
    wrapper_gui_msg = 1
    wrapper_persist_data = 1
-
+   wrapper_save_state = 1
    ...
 
 And execution is as usual:
@@ -210,11 +225,12 @@ This module will do several steps (similar as with ``cd32`` wrapper):
 
 - create temporary directory
 - extract provided in configuration archive
-- extract save state (if exists)
+- extract save state (if ``wrapper_save_state`` is set to ``1`` and archive
+  with save exists)
 - copy configuration under name ``Config.fs-uae``
 - run the fs-uae emulator
-- create archive with save state (if save state directory place is *not* a
+- optionally create archive with save state (if save state directory place is
-  global one)
+  *not* a global one)
 - optionally create new archive under the same name as the original one and
   replace it with original one.
 

fs_uae_wrapper/archive.py

@@ -40,7 +40,6 @@ class Archive(base.Base):
         if not super(Archive, self).run():
             return False
 
-        self._set_assets_paths()
         if not self._extract():
             return False
 
@@ -56,15 +55,16 @@ class Archive(base.Base):
         if not self._run_emulator(self.fsuae_options.list()):
             return False
 
+        if self._get_saves_dir():
+            if not self._save_save():
+                return False
+
         return self._make_archive()
 
     def _validate_options(self):
 
         validation_result = super(Archive, self)._validate_options()
 
-        if not super(Archive, self)._validate_options():
-            validation_result = False
-
         if 'wrapper_archive' not in self.all_options:
             sys.stderr.write("Configuration lacks of required "
                              "`wrapper_archive' option.\n")
@@ -79,14 +79,10 @@ class Archive(base.Base):
         if self.all_options.get('wrapper_persist_data', '0') != '1':
             return True
 
-        saves = self._get_saves_dir()
-        if saves:
-            if not self._save_save():
-                return False
-
         curdir = os.path.abspath('.')
         os.chdir(self.dir)
 
+        saves = self._get_saves_dir()
         if saves:
             shutil.rmtree(saves)
         os.unlink('Config.fs-uae')
@@ -97,7 +93,7 @@ class Archive(base.Base):
         if not utils.create_archive(arch, title):
             return False
 
-        os.rename(arch, self.arch_filepath)
+        shutil.move(arch, self.arch_filepath)
         os.chdir(curdir)
         return True
 

fs_uae_wrapper/base.py

@@ -7,6 +7,7 @@ import shutil
 import tempfile
 
 from fs_uae_wrapper import utils
+from fs_uae_wrapper import path
 
 
 class Base(object):
@@ -46,6 +47,8 @@ class Base(object):
 
         self.dir = tempfile.mkdtemp()
 
+        self._set_assets_paths()
+
         return True
 
     def clean(self):
@@ -90,13 +93,17 @@ class Base(object):
         conf_base = os.path.basename(self.conf_file)
         conf_base = os.path.splitext(conf_base)[0]
 
-        arch = self.all_options['wrapper_archive']
+        arch = self.all_options.get('wrapper_archive')
+        if arch:
             if os.path.isabs(arch):
                 self.arch_filepath = arch
             else:
                 self.arch_filepath = os.path.join(conf_abs_dir, arch)
         # set optional save_state
-        self.save_filename = os.path.join(conf_abs_dir, conf_base + '_save.7z')
+        arch_ext = utils.get_arch_ext(self.all_options.get('wrapper_archiver'))
+        if arch_ext:
+            self.save_filename = os.path.join(conf_abs_dir, conf_base +
+                                              '_save' + arch_ext)
 
     def _copy_conf(self):
         """copy provided configuration as Config.fs-uae"""
@@ -140,6 +147,10 @@ class Base(object):
         """
         Get the saves from emulator and store it where configuration is placed
         """
+        if self.all_options.get('wrapper_save_state', '0') != '1':
+            return True
+
+        os.chdir(self.dir)
         save_path = self._get_saves_dir()
         if not save_path:
             return True
@@ -147,32 +158,40 @@ class Base(object):
         if os.path.exists(self.save_filename):
             os.unlink(self.save_filename)
 
-        if not utils.run_command(['7z', 'a', self.save_filename, save_path]):
+        curdir = os.path.abspath('.')
+
+        if not utils.create_archive(self.save_filename, '', [save_path]):
             sys.stderr.write('Error: archiving save state failed\n')
+            os.chdir(curdir)
             return False
 
+        os.chdir(curdir)
         return True
 
     def _load_save(self):
         """
         Put the saves (if exists) to the temp directory.
         """
+        if self.all_options.get('wrapper_save_state', '0') != '1':
+            return True
+
         if not os.path.exists(self.save_filename):
             return True
 
         curdir = os.path.abspath('.')
         os.chdir(self.dir)
-        utils.run_command(['7z', 'x', self.save_filename])
+        utils.extract_archive(self.save_filename)
         os.chdir(curdir)
         return True
 
     def _get_saves_dir(self):
         """
-        Return full path to save state directory or None in cases:
+        Return path to save state directory or None in cases:
             - there is no save state dir set relative to config file
             - save state dir is set globally
             - save state dir is set relative to the config file
             - save state dir doesn't exists
+        Note, that returned path is relative not absolute
         """
         if not self.all_options.get('save_states_dir'):
             return None
@@ -187,7 +206,10 @@ class Base(object):
         if not os.path.exists(save_path) or not os.path.isdir(save_path):
             return None
 
-        return save_path
+        if save.endswith('/'):
+            save = save[:-1]
+
+        return save
 
     def _validate_options(self):
         """Validate mandatory options"""
@@ -195,4 +217,18 @@ class Base(object):
             sys.stderr.write("Configuration lacks of required "
                              "`wrapper' option.\n")
             return False
+
+        if self.all_options.get('wrapper_save_state', '0') == '0':
+            return True
+
+        if 'wrapper_archiver' not in self.all_options:
+            sys.stderr.write("Configuration lacks of required "
+                             "`wrapper_archiver' option.\n")
+            return False
+
+        if not path.which(self.all_options['wrapper_archiver']):
+            sys.stderr.write("Cannot find archiver `%s'." %
+                             self.all_options['wrapper_archiver'])
+            return False
+
         return True

fs_uae_wrapper/cd32.py

@@ -34,7 +34,6 @@ class CD32(base.Base):
         if not self._validate_options():
             return False
 
-        self._set_assets_paths()
         if not self._extract():
             return False
 
@@ -46,7 +45,10 @@ class CD32(base.Base):
         if kick_opts:
             self.fsuae_options.update(kick_opts)
 
-        if self._run_emulator(self.fsuae_options.list()):
+        if not self._run_emulator(self.fsuae_options.list()):
+            return False
+
+        if self._get_saves_dir():
             return self._save_save()
 
         return True

fs_uae_wrapper/file_archive.py

@@ -6,23 +6,7 @@ import subprocess
 import sys
 import re
 
-
+from fs_uae_wrapper import path
-def which(archivers):
-    """
-    Check if there selected archiver is available in the system and place it
-    to the archiver attribute
-    """
-
-    if not isinstance(archivers, list):
-        archivers = [archivers]
-
-    for fname in archivers:
-        for path in os.environ["PATH"].split(os.pathsep):
-            path = os.path.join(path.strip('"'), fname)
-            if os.path.isfile(path) and os.access(path, os.X_OK):
-                return fname
-
-    return None
 
 
 class Archive(object):
@@ -32,15 +16,17 @@ class Archive(object):
     ARCH = 'false'
 
     def __init__(self):
-        self.archiver = which(self.ARCH)
+        self.archiver = path.which(self.ARCH)
         self._compess = self.archiver
         self._decompess = self.archiver
 
-    def create(self, arch_name):
+    def create(self, arch_name, files=None):
         """
         Create archive. Return True on success, False otherwise.
         """
-        result = subprocess.call([self._compess] + self.ADD + [arch_name, '.'])
+        files = files if files else ['.']
+        result = subprocess.call([self._compess] + self.ADD + [arch_name]
+                                 + files)
         if result != 0:
             sys.stderr.write("Unable to create archive `%s'\n" % arch_name)
             return False
@@ -91,7 +77,7 @@ class ZipArchive(Archive):
     def __init__(self):
         super(ZipArchive, self).__init__()
         if self.archiver == 'zip':
-            self._decompess = which('unzip')
+            self._decompess = path.which('unzip')
             ZipArchive.ADD = ['-r']
             ZipArchive.EXTRACT = []
 
@@ -105,7 +91,7 @@ class LzxArchive(Archive):
     ARCH = 'unlzx'
 
     @classmethod
-    def create(self, arch_name):
+    def create(self, arch_name, files=None):
         sys.stderr.write('Cannot create LZX archive. Only extracting is'
                          'supported\n')
         return False
@@ -114,20 +100,56 @@ class LzxArchive(Archive):
 class RarArchive(Archive):
     ARCH = ['rar', 'unrar']
 
-    def create(self, arch_name):
+    def create(self, arch_name, files=None):
+        files = files if files else sorted(os.listdir('.'))
         if self.archiver == 'unrar':
             sys.stderr.write('Cannot create RAR archive. Only extracting is'
                              'supported by unrar.\n')
             return False
 
         result = subprocess.call([self._compess] + self.ADD + [arch_name] +
-                                 sorted(os.listdir('.')))
+                                 files)
         if result != 0:
             sys.stderr.write("Unable to create archive `%s'\n" % arch_name)
             return False
         return True
 
 
+class Archivers(object):
+    """Archivers class"""
+    archivers = [{'arch': TarArchive, 'name': 'tar', 'ext': ['tar']},
+                 {'arch': TarGzipArchive, 'name': 'tgz',
+                  'ext': ['tar.gz', 'tgz']},
+                 {'arch': TarBzip2Archive, 'name': 'tar.bz2',
+                  'ext': ['tar.bz2']},
+                 {'arch': TarXzArchive, 'name': 'tar.xz', 'ext': ['tar.xz']},
+                 {'arch': RarArchive, 'name': 'rar', 'ext': ['rar']},
+                 {'arch': SevenZArchive, 'name': '7z', 'ext': ['7z']},
+                 {'arch': ZipArchive, 'name': 'zip', 'ext': ['zip']},
+                 {'arch': LhaArchive, 'name': 'lha', 'ext': ['lha', 'lzh']},
+                 {'arch': LzxArchive, 'name': 'lzx', 'ext': ['lzx']}]
+
+    @classmethod
+    def get(cls, extension):
+        """
+        Get the archive class or None
+        """
+        for arch in cls.archivers:
+            if extension in arch['ext']:
+                return arch['arch']
+        return None
+
+    @classmethod
+    def get_extension_by_name(cls, name):
+        """
+        Get the first defined extension for the archive format
+        """
+        for arch in cls.archivers:
+            if name == arch['name']:
+                return '.' + arch['ext'][0]
+        return None
+
+
 def get_archiver(arch_name):
     """Return right class for provided archive file name"""
 
@@ -138,18 +160,10 @@ def get_archiver(arch_name):
     if result:
         ext = result.groups()[0]
 
-    archivers = {'.tar': TarArchive,
+    if ext:
-                 '.tgz': TarGzipArchive,
+        ext = ext[1:]
-                 '.tar.gz': TarGzipArchive,
-                 '.tar.bz2': TarBzip2Archive,
-                 '.tar.xz': TarXzArchive,
-                 '.rar': RarArchive,
-                 '.7z': SevenZArchive,
-                 '.zip': ZipArchive,
-                 '.lha': LhaArchive,
-                 '.lzx': LzxArchive}
 
-    archiver = archivers.get(ext)
+    archiver = Archivers.get(ext)
     if not archiver:
         sys.stderr.write("Unable find archive type for `%s'\n" % arch_name)
         return None

fs_uae_wrapper/path.py

@@ -0,0 +1,22 @@
+"""
+Misc utilities
+"""
+import os
+
+
+def which(executables):
+    """
+    Check if there selected archiver is available in the system and place it
+    to the archiver attribute
+    """
+
+    if not isinstance(executables, list):
+        executables = [executables]
+
+    for fname in executables:
+        for path in os.environ["PATH"].split(os.pathsep):
+            path = os.path.join(path.strip('"'), fname)
+            if os.path.isfile(path) and os.access(path, os.X_OK):
+                return fname
+
+    return None

fs_uae_wrapper/utils.py

@@ -57,7 +57,7 @@ def get_config_options(conf):
             for key, val in parser.items(section)}
 
 
-def operate_archive(arch_name, operation, text):
+def operate_archive(arch_name, operation, text, params):
     """
     Create archive from contents of current directory
     """
@@ -77,31 +77,31 @@ def operate_archive(arch_name, operation, text):
         res = archiver.extract(arch_name)
 
     if operation == 'create':
-        res = archiver.create(arch_name)
+        res = archiver.create(arch_name, params)
 
     msg.close()
 
     return res
 
 
-def create_archive(arch_name, title=''):
+def create_archive(arch_name, title='', params=None):
     """
     Create archive from contents of current directory
     """
     msg = ''
     if title:
         msg = "Creating archive for `%s'. Please be patient" % title
-    return operate_archive(arch_name, 'create', msg)
+    return operate_archive(arch_name, 'create', msg, params)
 
 
-def extract_archive(arch_name, title=''):
+def extract_archive(arch_name, title='', params=None):
     """
     Extract provided archive to current directory
     """
     msg = ''
     if title:
         msg = "Extracting files for `%s'. Please be patient" % title
-    return operate_archive(arch_name, 'extract', msg)
+    return operate_archive(arch_name, 'extract', msg, params)
 
 
 def run_command(cmd):
@@ -217,3 +217,8 @@ def get_config(conf_file):
         config['_base_dir'] = conf_dir
 
     return config
+
+
+def get_arch_ext(archiver_name):
+    """Return extension for the archiver"""
+    return file_archive.Archivers.get_extension_by_name(archiver_name)

setup.py

@@ -7,7 +7,7 @@ from distutils.core import setup
 
 setup(name='fs-uae-wrapper',
       packages=['fs_uae_wrapper'],
-      version='0.3.1',
+      version='0.5',
       description='Automate archives and state for fs-uae',
       author='Roman Dobosz',
       author_email='gryf73@gmail.com',

tests/test_archive.py

@@ -26,58 +26,76 @@ class TestArchive(TestCase):
         except OSError:
             pass
 
-    def test_validate_options(self):
+    @mock.patch('fs_uae_wrapper.path.which')
+    def test_validate_options(self, which):
+        which.return_value = 'unrar'
 
         arch = archive.Archive('Config.fs-uae', utils.CmdOption(), {})
         self.assertFalse(arch._validate_options())
+        arch.all_options = {'wrapper': 'archive'}
 
         arch.all_options['wrapper'] = 'archive'
         self.assertFalse(arch._validate_options())
 
-        arch.all_options['wrapper_archive'] = 'fake.tgz'
+        arch.all_options['wrapper_archive'] = 'rar'
         self.assertTrue(arch._validate_options())
 
     @mock.patch('tempfile.mkdtemp')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('fs_uae_wrapper.archive.Archive._make_archive')
+    @mock.patch('fs_uae_wrapper.base.Base._save_save')
+    @mock.patch('fs_uae_wrapper.base.Base._get_saves_dir')
     @mock.patch('fs_uae_wrapper.base.Base._run_emulator')
     @mock.patch('fs_uae_wrapper.base.Base._kickstart_option')
     @mock.patch('fs_uae_wrapper.base.Base._copy_conf')
     @mock.patch('fs_uae_wrapper.base.Base._load_save')
     @mock.patch('fs_uae_wrapper.base.Base._extract')
-    def test_run(self, extr, load, copy, kick, run, march, mkdtemp):
+    def test_run(self, extract, load_save, copy_conf, kick_option,
+                 run_emulator, get_save_dir, save_state, make_arch, which,
+                 mkdtemp):
 
-        extr.return_value = False
+        extract.return_value = False
-        load.return_value = False
+        load_save.return_value = False
-        copy.return_value = False
+        copy_conf.return_value = False
-        kick.return_value = False
+        kick_option.return_value = False
-        run.return_value = False
+        run_emulator.return_value = False
-        march.return_value = False
+        get_save_dir.return_value = False
+        save_state.return_value = False
+        make_arch.return_value = False
+        which.return_value = 'rar'
 
         arch = archive.Archive('Config.fs-uae', utils.CmdOption(), {})
         self.assertFalse(arch.run())
 
         arch.all_options = {'wrapper': 'archive',
-                            'wrapper_archive': 'fake.tgz'}
+                            'wrapper_archive': 'fake.tgz',
+                            'wrapper_archiver': 'rar'}
 
         self.assertFalse(arch.run())
 
-        extr.return_value = True
+        extract.return_value = True
         self.assertFalse(arch.run())
 
-        load.return_value = True
+        load_save.return_value = True
         self.assertFalse(arch.run())
 
-        copy.return_value = True
+        copy_conf.return_value = True
         self.assertFalse(arch.run())
 
-        kick.return_value = {'foo': 'bar'}
+        kick_option.return_value = {'foo': 'bar'}
         self.assertFalse(arch.run())
         self.assertDictEqual(arch.fsuae_options, {'foo': 'bar'})
 
-        run.return_value = True
+        run_emulator.return_value = True
         self.assertFalse(arch.run())
 
-        march.return_value = True
+        get_save_dir.return_value = True
+        self.assertFalse(arch.run())
+
+        save_state.return_value = True
+        self.assertFalse(arch.run())
+
+        make_arch.return_value = True
         self.assertTrue(arch.run())
 
     @mock.patch('os.rename')
@@ -85,12 +103,10 @@ class TestArchive(TestCase):
     @mock.patch('shutil.rmtree')
     @mock.patch('fs_uae_wrapper.utils.create_archive')
     @mock.patch('fs_uae_wrapper.base.Base._get_title')
-    @mock.patch('fs_uae_wrapper.base.Base._save_save')
     @mock.patch('fs_uae_wrapper.base.Base._get_saves_dir')
-    def test_make_archive(self, sdir, save, title, carch, rmt, unlink, rename):
+    def test_make_archive(self, sdir, title, carch, rmt, unlink, rename):
 
         sdir.return_value = None
-        save.return_value = False
         title.return_value = ''
         carch.return_value = False
 
@@ -107,7 +123,4 @@ class TestArchive(TestCase):
         self.assertTrue(arch._make_archive())
 
         sdir.return_value = '/some/path'
-        self.assertFalse(arch._make_archive())
-
-        save.return_value = True
         self.assertTrue(arch._make_archive())

tests/test_base.py

@@ -75,13 +75,15 @@ class TestBase(TestCase):
         bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
         os.chdir(self.dirname)
         bobj.conf_file = 'Config.fs-uae'
-        bobj.all_options = {'wrapper_archive': 'foo.7z'}
+        bobj.all_options = {'wrapper_archive': 'foo.7z',
+                            'wrapper_archiver': '7z'}
 
         bobj._set_assets_paths()
         full_path = os.path.join(self.dirname, 'Config_save.7z')
         self.assertEqual(bobj.save_filename, full_path)
 
-        bobj.all_options = {'wrapper_archive': '/home/user/foo.7z'}
+        bobj.all_options = {'wrapper_archive':  '/home/user/foo.7z',
+                            'wrapper_archiver': '7z'}
 
         bobj._set_assets_paths()
         full_path = os.path.join(self.dirname, 'Config_save.7z')
@@ -141,37 +143,49 @@ class TestBase(TestCase):
         run.assert_called_once_with(['fs-uae'])
 
     @mock.patch('fs_uae_wrapper.base.Base._get_saves_dir')
-    @mock.patch('fs_uae_wrapper.utils.run_command')
+    @mock.patch('fs_uae_wrapper.utils.create_archive')
-    def test_save_save(self, run, saves_dir):
+    def test_save_save(self, carch, saves_dir):
 
-        bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
+        os.chdir(self.confdir)
+
+        bobj = base.Base('myconf.fs-uae', utils.CmdOption(), {})
         bobj.dir = self.dirname
-        bobj.save_filename = 'foobar_save.7z'
+        bobj.save_filename = os.path.join(self.confdir, 'myconf_save.7z')
-        saves_dir.bobj.save_filenamereturn_value = None
-        run.return_value = True
 
-        self.assertTrue(bobj._save_save())
+        saves_dir.return_value = None
+        carch.return_value = True
+
+        self.assertTrue(bobj._save_save(),
+                        'there is assumption, that wrapper_save_state is'
+                        ' false by default. Here it was true.')
+
+        bobj.all_options['wrapper_save_state'] = '1'
+        self.assertTrue(bobj._save_save(),
+                        'unexpected save_state directory found')
 
         saves_dir.return_value = bobj.save_filename
-        os.chdir(self.confdir)
         with open(bobj.save_filename, 'w') as fobj:
             fobj.write('asd')
 
-        self.assertTrue(bobj._save_save())
-
         os.mkdir(os.path.join(self.dirname, 'fs-uae-save'))
         self.assertTrue(bobj._save_save())
 
-        run.return_value = False
+        carch.return_value = False
         self.assertFalse(bobj._save_save())
 
-    @mock.patch('fs_uae_wrapper.utils.run_command')
+    @mock.patch('fs_uae_wrapper.utils.extract_archive')
-    def test_load_save(self, run):
+    def test_load_save(self, earch):
 
         bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
         bobj.dir = self.dirname
         bobj.save_filename = "foobar_save.7z"
-        run.return_value = 0
+        earch.return_value = 0
+
+        # By default there would be no save state persistence
+        self.assertTrue(bobj._load_save())
+
+        # set wrapper_save_state option, so we can proceed with test
+        bobj.all_options['wrapper_save_state'] = '1'
 
         # fail to load save is not fatal
         self.assertTrue(bobj._load_save())
@@ -181,11 +195,11 @@ class TestBase(TestCase):
             fobj.write('asd')
 
         self.assertTrue(bobj._load_save())
-        run.assert_called_once_with(['7z', 'x', bobj.save_filename])
+        earch.assert_called_once_with(bobj.save_filename)
 
         # failure in searching for archiver are also non fatal
-        run.reset_mock()
+        earch.reset_mock()
-        run.return_value = 1
+        earch.return_value = 1
         self.assertTrue(bobj._save_save())
 
     def test_get_saves_dir(self):
@@ -214,9 +228,15 @@ class TestBase(TestCase):
 
         os.unlink(path)
         os.mkdir(path)
-        self.assertEqual(bobj._get_saves_dir(), path)
+        self.assertEqual(bobj._get_saves_dir(), 'saves')
 
-    def test_validate_options(self):
+        bobj.all_options['save_states_dir'] = '$CONFIG/saves/'
+        self.assertEqual(bobj._get_saves_dir(), 'saves')
+
+    @mock.patch('fs_uae_wrapper.path.which')
+    def test_validate_options(self, which):
+
+        which.return_value = None
 
         bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
         bobj.all_options = {}
@@ -226,14 +246,37 @@ class TestBase(TestCase):
         bobj.all_options = {'wrapper': 'dummy'}
         self.assertTrue(bobj._validate_options())
 
-    def test_run_clean(self):
+        bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_archiver': 'myarchiver'}
+        self.assertTrue(bobj._validate_options())
+
+        bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_save_state': '1',
+                            'wrapper_archiver': 'myarchiver'}
+        self.assertFalse(bobj._validate_options())
+
+        which.return_value = '7z'
+        bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_save_state': '1'}
+        self.assertFalse(bobj._validate_options())
+
+        bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_save_state': '1',
+                            'wrapper_archiver': '7z'}
+        self.assertTrue(bobj._validate_options())
+
+    @mock.patch('fs_uae_wrapper.path.which')
+    def test_run_clean(self, which):
+
+        which.return_value = 'rar'
 
         bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
         bobj.all_options = {}
 
         self.assertFalse(bobj.run())
 
-        bobj.all_options = {'wrapper': 'dummy'}
+        bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_archiver': 'rar'}
         try:
             self.assertTrue(bobj.run())
             self.assertTrue(os.path.exists(bobj.dir))

tests/test_cd32.py

@@ -11,7 +11,10 @@ from fs_uae_wrapper import utils
 
 class TestCD32(TestCase):
 
-    def test_validate_options(self):
+    @mock.patch('fs_uae_wrapper.path.which')
+    def test_validate_options(self, which):
+
+        which.return_value = 'rar'
 
         acd32 = cd32.CD32('Config.fs-uae', utils.CmdOption(), {})
         self.assertFalse(acd32._validate_options())
@@ -23,44 +26,53 @@ class TestCD32(TestCase):
         self.assertTrue(acd32._validate_options())
 
     @mock.patch('tempfile.mkdtemp')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('fs_uae_wrapper.base.Base._save_save')
+    @mock.patch('fs_uae_wrapper.base.Base._get_saves_dir')
     @mock.patch('fs_uae_wrapper.base.Base._run_emulator')
     @mock.patch('fs_uae_wrapper.base.Base._kickstart_option')
-    @mock.patch('fs_uae_wrapper.base.Base._load_save')
     @mock.patch('fs_uae_wrapper.base.Base._copy_conf')
+    @mock.patch('fs_uae_wrapper.base.Base._load_save')
     @mock.patch('fs_uae_wrapper.base.Base._extract')
-    def test_run(self, extr, cconf, lsave, kick, runemul, ssave, mkdtemp):
+    def test_run(self, extract, load_save, copy_conf, kick_option,
+                 run_emulator, get_save_dir, save_state, which, mkdtemp):
 
-        extr.return_value = False
+        extract.return_value = False
-        cconf.return_value = False
+        copy_conf.return_value = False
-        lsave.return_value = False
+        load_save.return_value = False
-        kick.return_value = {}
+        kick_option.return_value = {}
-        runemul.return_value = False
+        run_emulator.return_value = False
-        ssave.return_value = False
+        get_save_dir.return_value = False
+        save_state.return_value = False
+        which.return_value = 'unrar'
 
         acd32 = cd32.CD32('Config.fs-uae', utils.CmdOption(), {})
         self.assertFalse(acd32.run())
 
         acd32.all_options = {'wrapper': 'cd32',
-                             'wrapper_archive': 'fake.tgz'}
+                             'wrapper_archive': 'fake.tgz',
+                             'wrapper_archiver': 'rar'}
 
         self.assertFalse(acd32.run())
 
-        extr.return_value = True
+        extract.return_value = True
         self.assertFalse(acd32.run())
 
-        cconf.return_value = True
+        copy_conf.return_value = True
         self.assertFalse(acd32.run())
 
-        lsave.return_value = True
+        load_save.return_value = True
-        self.assertTrue(acd32.run())
+        self.assertFalse(acd32.run())
 
-        kick.return_value = {'foo': 'bar'}
+        kick_option.return_value = {'foo': 'bar'}
-        self.assertTrue(acd32.run())
+        self.assertFalse(acd32.run())
         self.assertDictEqual(acd32.fsuae_options, {'foo': 'bar'})
 
-        runemul.return_value = True
+        run_emulator.return_value = True
+        self.assertTrue(acd32.run())
+
+        get_save_dir.return_value = True
         self.assertFalse(acd32.run())
 
-        ssave.return_value = True
+        save_state.return_value = True
         self.assertTrue(acd32.run())

tests/test_file_archive.py

@@ -60,13 +60,7 @@ class TestArchive(TestCase):
         self.assertFalse(arch.extract('foo'))
         call.assert_called_once_with(['false', 'x', 'foo'])
 
-    def test_archive_which(self):
+    @mock.patch('fs_uae_wrapper.path.which')
-        self.assertEqual(file_archive.which('sh'), 'sh')
-        self.assertIsNone(file_archive.which('blahblahexec'))
-        self.assertEqual(file_archive.which(['blahblahexec', 'pip', 'sh']),
-                         'pip')
-
-    @mock.patch('fs_uae_wrapper.file_archive.which')
     @mock.patch('subprocess.call')
     def test_tar(self, call, which):
         with open('foo', 'w') as fobj:
@@ -122,7 +116,7 @@ class TestArchive(TestCase):
         self.assertFalse(arch.extract('foo'))
         call.assert_called_once_with(['tar', 'xf', 'foo'])
 
-    @mock.patch('fs_uae_wrapper.file_archive.which')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('subprocess.call')
     def test_lha(self, call, which):
         with open('foo', 'w') as fobj:
@@ -142,7 +136,7 @@ class TestArchive(TestCase):
         self.assertFalse(arch.extract('foo'))
         call.assert_called_once_with(['lha', 'x', 'foo'])
 
-    @mock.patch('fs_uae_wrapper.file_archive.which')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('subprocess.call')
     def test_lzx(self, call, which):
         with open('foo', 'w') as fobj:
@@ -162,7 +156,7 @@ class TestArchive(TestCase):
         self.assertFalse(arch.extract('foo'))
         call.assert_called_once_with(['unlzx', '-x', 'foo'])
 
-    @mock.patch('fs_uae_wrapper.file_archive.which')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('subprocess.call')
     def test_7zip(self, call, which):
         with open('foo', 'w') as fobj:
@@ -182,7 +176,7 @@ class TestArchive(TestCase):
         self.assertFalse(arch.extract('foo'))
         call.assert_called_once_with(['7z', 'x', 'foo'])
 
-    @mock.patch('fs_uae_wrapper.file_archive.which')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('subprocess.call')
     def test_zip(self, call, which):
         with open('foo', 'w') as fobj:
@@ -202,7 +196,7 @@ class TestArchive(TestCase):
         self.assertFalse(arch.extract('foo'))
         call.assert_called_once_with(['7z', 'x', 'foo'])
 
-    @mock.patch('fs_uae_wrapper.file_archive.which')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('subprocess.call')
     def test_rar(self, call, which):
 

tests/test_path.py

@@ -0,0 +1,12 @@
+from unittest import TestCase
+
+from fs_uae_wrapper import path
+
+
+class TestPath(TestCase):
+
+    def test_which(self):
+        self.assertEqual(path.which('sh'), 'sh')
+        self.assertIsNone(path.which('blahblahexec'))
+        self.assertEqual(path.which(['blahblahexec', 'pip', 'sh']),
+                         'pip')

tests/test_utils.py

@@ -72,7 +72,7 @@ class TestUtils(TestCase):
         conf = utils.get_config_options(self.fname)
         self.assertDictEqual(conf, {'wrapper': ''})
 
-    @mock.patch('fs_uae_wrapper.file_archive.which')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('fs_uae_wrapper.file_archive.Archive.extract')
     @mock.patch('fs_uae_wrapper.file_archive.Archive.create')
     @mock.patch('fs_uae_wrapper.message.Message.close')
@@ -83,13 +83,14 @@ class TestUtils(TestCase):
         which.return_value = None
 
         # No config
-        self.assertFalse(utils.operate_archive('non-existend.7z', 'foo', ''))
+        self.assertFalse(utils.operate_archive('non-existend.7z', 'foo', '',
+                                               None))
 
         # Archive type not known
         with open('unsupported-archive.ace', 'w') as fobj:
             fobj.write("\n")
         self.assertFalse(utils.operate_archive('unsupported-archive.ace',
-                                               'foo', ''))
+                                               'foo', '', None))
 
         # archive is known, but extraction will fail - we have an empty
         # archive and there is no guarantee, that 7z exists on system where
@@ -99,17 +100,17 @@ class TestUtils(TestCase):
         with open('supported-archive.7z', 'w') as fobj:
             fobj.write("\n")
         self.assertTrue(utils.operate_archive('supported-archive.7z',
-                                              'extract', ''))
+                                              'extract', '', None))
         extract.assert_called_once()
 
         extract.reset_mock()
         self.assertTrue(utils.operate_archive('supported-archive.7z',
-                                              'extract', ''))
+                                              'extract', '', None))
         extract.assert_called_once()
 
         os.unlink('supported-archive.7z')
         self.assertTrue(utils.operate_archive('supported-archive.7z',
-                                              'create', 'test'))
+                                              'create', 'test', ['foo']))
         create.assert_called_once()
         show.assert_called_once()
 
@@ -153,7 +154,7 @@ class TestUtils(TestCase):
             fobj.write("\n")
         self.assertFalse(utils.extract_archive('supported-archive.7z'))
 
-    @mock.patch('fs_uae_wrapper.file_archive.which')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('fs_uae_wrapper.file_archive.Archive.extract')
     def test_extract_archive_positive(self, arch_extract, which):
         arch_extract.return_value = True