diff --git a/swb/config/example.ini b/swb/config/example.ini
index 87f1c0b..c4f7782 100644
--- a/swb/config/example.ini
+++ b/swb/config/example.ini
@@ -21,3 +21,5 @@ compressor = bzip2 -v
 decompressor = bzip2 -d
 # The maximum number of local backups to keep
 max_local_backups = 3
+# Whether to backup the entire site directory in addition to the database
+full_backup = no
diff --git a/swb/local.py b/swb/local.py
index 02a43f7..99f122d 100755
--- a/swb/local.py
+++ b/swb/local.py
@@ -18,50 +18,11 @@
 remote_driver_path = os.path.join(program_dir, 'remote.py')
 
 
-# Parse command line arguments passed to the local driver
-def parse_cli_args():
-
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        '--quiet',
-        '-q',
-        action='store_true',
-        help='silences stdout and stderr')
-
-    parser.add_argument(
-        'config_path',
-        help='the path to a configuration file (.ini)')
-
-    parser.add_argument(
-        '--restore',
-        '-r',
-        help='the path to a compressed backup file from which to restore')
-
-    parser.add_argument(
-        '--force',
-        '-f',
-        action='store_true',
-        help='bypasses the confirmation prompt when restoring from backup')
-
-    cli_args = parser.parse_args()
-    return cli_args
-
-
-# Parse configuration files at given paths into object
-def parse_config(config_path):
-
-    config = configparser.RawConfigParser()
-    config.read(config_path)
-
-    return config
-
-
 # Create intermediate directories in local backup path if necessary
-def create_dir_structure(path):
+def create_dir_structure(local_backup_path):
 
     try:
-        os.makedirs(os.path.dirname(path))
+        os.makedirs(os.path.dirname(local_backup_path))
     except OSError:
         pass
 
@@ -77,18 +38,18 @@ def quote_arg(arg):
 
     if hasattr(shlex, 'quote'):
         # shlex.quote was introduced in v3.3
-        quoted_arg = shlex.quote(arg)
+        quoted_arg = shlex.quote(str(arg))
     else:
         # pipes.quote is deprecated, but use it if shlex.quote is unavailable
-        quoted_arg = pipes.quote(arg)
+        quoted_arg = pipes.quote(str(arg))
 
     quoted_arg = unquote_home_dir(quoted_arg)
     return quoted_arg
 
 
 # Connect to remote via SSH and execute remote script
-def exec_on_remote(ssh_user, ssh_hostname, ssh_port, action, action_args,
-                   *, stdout, stderr):
+def exec_on_remote(ssh_user, ssh_hostname, ssh_port, *,
+                   action, action_args, stdout, stderr):
 
     # Read remote script so as to pass contents to SSH session
     with open(remote_driver_path, 'r') as remote_script:
@@ -116,8 +77,8 @@ def exec_on_remote(ssh_user, ssh_hostname, ssh_port, action, action_args,
 
 
 # Transfer a file from remote to local (or vice-versa) using SCP
-def transfer_file(ssh_user, ssh_hostname, ssh_port,
-                  src_path, dest_path, action, *, stdout, stderr):
+def transfer_file(ssh_user, ssh_hostname, ssh_port, *,
+                  src_path, dest_path, action, stdout, stderr):
 
     scp_args = ['scp', '-P {}'.format(ssh_port)]
 
@@ -139,34 +100,82 @@ def transfer_file(ssh_user, ssh_hostname, ssh_port,
 
 
 # Execute remote backup script to create remote backup
-def create_remote_backup(ssh_user, ssh_hostname, ssh_port,
+def create_remote_backup(ssh_user, ssh_hostname, ssh_port, *,
                          wordpress_path, remote_backup_path,
-                         backup_compressor, *, stdout, stderr):
+                         backup_compressor, stdout, stderr):
 
-    exec_on_remote(ssh_user, ssh_hostname, ssh_port, 'back-up', [
-        wordpress_path,
-        backup_compressor,
-        remote_backup_path
-    ], stdout=stdout, stderr=stderr)
+    exec_on_remote(
+        ssh_user=ssh_user,
+        ssh_hostname=ssh_hostname,
+        ssh_port=ssh_port,
+        action='back-up',
+        action_args=[
+            wordpress_path,
+            backup_compressor,
+            remote_backup_path
+        ],
+        stdout=stdout, stderr=stderr)
 
 
 # Download remote backup to local system
-def download_remote_backup(ssh_user, ssh_hostname, ssh_port,
+def download_remote_backup(ssh_user, ssh_hostname, ssh_port, *,
                            remote_backup_path, local_backup_path,
-                           *, stdout, stderr):
+                           stdout, stderr):
+
+    transfer_file(
+        ssh_user=ssh_user,
+        ssh_hostname=ssh_hostname,
+        ssh_port=ssh_port,
+        src_path=remote_backup_path,
+        dest_path=local_backup_path,
+        action='download',
+        stdout=stdout, stderr=stderr)
+
+
+# Uploads the given local backup to the given remote destination
+def upload_local_backup(ssh_user, ssh_hostname, ssh_port, *,
+                        local_backup_path, remote_backup_path,
+                        stdout, stderr):
+
+    transfer_file(
+        ssh_user=ssh_user,
+        ssh_hostname=ssh_hostname,
+        ssh_port=ssh_port,
+        src_path=local_backup_path,
+        dest_path=remote_backup_path,
+        action='upload',
+        stdout=stdout, stderr=stderr)
+
+
+# Restores the local backup after upload to remote
+def restore_remote_backup(ssh_user, ssh_hostname, ssh_port, *,
+                          wordpress_path, remote_backup_path,
+                          backup_decompressor, stdout, stderr):
 
-    transfer_file(ssh_user, ssh_hostname, ssh_port,
-                  remote_backup_path, local_backup_path,
-                  'download', stdout=stdout, stderr=stderr)
+    exec_on_remote(
+        ssh_user=ssh_user,
+        ssh_hostname=ssh_hostname,
+        ssh_port=ssh_port,
+        action='restore',
+        action_args=[
+            wordpress_path,
+            remote_backup_path,
+            backup_decompressor
+        ],
+        stdout=stdout, stderr=stderr)
 
 
 # Forcefully remove backup from remote
-def purge_remote_backup(ssh_user, ssh_hostname, ssh_port,
-                        remote_backup_path, *, stdout, stderr):
+def purge_remote_backup(ssh_user, ssh_hostname, ssh_port, *,
+                        remote_backup_path, stdout, stderr):
 
-    exec_on_remote(ssh_user, ssh_hostname, ssh_port,
-                   'purge-backup', [remote_backup_path],
-                   stdout=stdout, stderr=stderr)
+    exec_on_remote(
+        ssh_user=ssh_user,
+        ssh_hostname=ssh_hostname,
+        ssh_port=ssh_port,
+        action='purge-backup',
+        action_args=[remote_backup_path],
+        stdout=stdout, stderr=stderr)
 
 
 # Retrieve a file's last modified time in seconds
@@ -193,7 +202,7 @@ def purge_empty_dirs(dir_path):
 
 
 # Purge oldest backups to keep number of backups within specified limit
-def purge_oldest_backups(local_backup_path, max_local_backups):
+def purge_oldest_backups(local_backup_path, *, max_local_backups):
 
     # Convert date format sequences to wildcards
     local_backup_path = re.sub(r'%\-?[A-Za-z]', '*', local_backup_path)
@@ -224,66 +233,100 @@ def back_up(config, *, stdout=None, stderr=None):
         config.get('paths', 'remote_backup'))
 
     create_remote_backup(
-        config.get('ssh', 'user'),
-        config.get('ssh', 'hostname'),
-        config.get('ssh', 'port'),
-        config.get('paths', 'wordpress'),
-        expanded_remote_backup_path,
-        config.get('backup', 'compressor'),
+        ssh_user=config.get('ssh', 'user'),
+        ssh_hostname=config.get('ssh', 'hostname'),
+        ssh_port=config.get('ssh', 'port'),
+        wordpress_path=config.get('paths', 'wordpress'),
+        remote_backup_path=expanded_remote_backup_path,
+        backup_compressor=config.get('backup', 'compressor'),
         stdout=stdout, stderr=stderr)
 
-    create_dir_structure(expanded_local_backup_path)
+    create_dir_structure(local_backup_path=expanded_local_backup_path)
 
     download_remote_backup(
-        config.get('ssh', 'user'),
-        config.get('ssh', 'hostname'),
-        config.get('ssh', 'port'),
-        expanded_remote_backup_path,
-        expanded_local_backup_path,
+        ssh_user=config.get('ssh', 'user'),
+        ssh_hostname=config.get('ssh', 'hostname'),
+        ssh_port=config.get('ssh', 'port'),
+        remote_backup_path=expanded_remote_backup_path,
+        local_backup_path=expanded_local_backup_path,
         stdout=stdout, stderr=stderr)
 
     purge_remote_backup(
-        config.get('ssh', 'user'),
-        config.get('ssh', 'hostname'),
-        config.get('ssh', 'port'),
-        expanded_remote_backup_path,
+        ssh_user=config.get('ssh', 'user'),
+        ssh_hostname=config.get('ssh', 'hostname'),
+        ssh_port=config.get('ssh', 'port'),
+        remote_backup_path=expanded_remote_backup_path,
         stdout=stdout, stderr=stderr)
 
     if config.has_option('backup', 'max_local_backups'):
         purge_oldest_backups(
-            config.get('paths', 'local_backup'),
-            config.getint('backup', 'max_local_backups'))
+            local_backup_path=config.get('paths', 'local_backup'),
+            max_local_backups=config.getint('backup', 'max_local_backups'))
 
 
 # Restore the chosen database revision to the Wordpress install on remote
-def restore(config, local_backup_path, *, stdout=None, stderr=None):
+def restore(config, *, local_backup_path, stdout=None, stderr=None):
 
     expanded_remote_backup_path = time.strftime(
         config.get('paths', 'remote_backup'))
 
-    # Copy local backup to remote so it can be used for restoration
-    transfer_file(
-        config.get('ssh', 'user'),
-        config.get('ssh', 'hostname'),
-        config.get('ssh', 'port'),
-        local_backup_path,
-        expanded_remote_backup_path,
-        'upload',
+    upload_local_backup(
+        ssh_user=config.get('ssh', 'user'),
+        ssh_hostname=config.get('ssh', 'hostname'),
+        ssh_port=config.get('ssh', 'port'),
+        local_backup_path=local_backup_path,
+        remote_backup_path=expanded_remote_backup_path,
         stdout=stdout, stderr=stderr)
 
-    action_args = [
-        config.get('paths', 'wordpress'),
-        expanded_remote_backup_path,
-        config.get('backup', 'decompressor')
-    ]
-    exec_on_remote(
-        config.get('ssh', 'user'),
-        config.get('ssh', 'hostname'),
-        config.get('ssh', 'port'),
-        'restore', action_args,
+    restore_remote_backup(
+        ssh_user=config.get('ssh', 'user'),
+        ssh_hostname=config.get('ssh', 'hostname'),
+        ssh_port=config.get('ssh', 'port'),
+        wordpress_path=config.get('paths', 'wordpress'),
+        remote_backup_path=config.get('paths', 'remote_backup'),
+        backup_decompressor=config.get('backup', 'decompressor'),
         stdout=stdout, stderr=stderr)
 
 
+# Parse command line arguments passed to the local driver
+def parse_cli_args():
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        '--quiet',
+        '-q',
+        action='store_true',
+        help='silences stdout and stderr')
+
+    parser.add_argument(
+        'config_path',
+        help='the path to a configuration file (.ini)')
+
+    parser.add_argument(
+        '--restore',
+        '-r',
+        help='the path to a compressed backup file from which to restore')
+
+    parser.add_argument(
+        '--force',
+        '-f',
+        action='store_true',
+        help='bypasses the confirmation prompt when restoring from backup')
+
+    cli_args = parser.parse_args()
+    return cli_args
+
+
+# Parse configuration files at given paths into object
+def parse_config(config_path):
+
+    config = configparser.RawConfigParser()
+    config.read(config_path)
+
+    return config
+
+
 def main():
 
     cli_args = parse_cli_args()
@@ -304,7 +347,9 @@ def main():
                 answer = input('Do you want to continue? (y/n) ')
                 if not answer.lower().lstrip().startswith('y'):
                     raise Exception('User canceled. Aborting.')
-            restore(config, cli_args.restore, stdout=stdout, stderr=stderr)
+            restore(
+                config, local_backup_path=cli_args.restore,
+                stdout=stdout, stderr=stderr)
         else:
             back_up(config, stdout=stdout, stderr=stderr)
 
diff --git a/swb/remote.py b/swb/remote.py
index 0b8869c..28824c7 100755
--- a/swb/remote.py
+++ b/swb/remote.py
@@ -43,9 +43,9 @@ def get_db_info(wordpress_path):
     return db_info
 
 
-# Dump MySQL database to compressed file on remote
-def dump_db(db_name, db_host, db_user, db_password,
-            backup_compressor, backup_path):
+# Dump MySQL database to compressed file
+def dump_compressed_db(db_name, db_host, db_user, db_password,
+                       backup_compressor, backup_path):
 
     mysqldump = subprocess.Popen([
         'mysqldump',
@@ -72,6 +72,7 @@ def dump_db(db_name, db_host, db_user, db_password,
 def verify_backup_integrity(backup_path):
 
     if os.path.getsize(backup_path) < 1024:
+        os.remove(backup_path)
         raise OSError('Backup is corrupted (too small). Aborting.')
 
 
@@ -81,16 +82,20 @@ def purge_downloaded_backup(backup_path):
     os.remove(backup_path)
 
 
+# Back up WordPress database or installation
 def back_up(wordpress_path, backup_compressor, backup_path):
 
     backup_path = os.path.expanduser(backup_path)
     create_dir_structure(backup_path)
-
     db_info = get_db_info(wordpress_path)
-    dump_db(
-        db_info['name'], db_info['host'],
-        db_info['user'], db_info['password'],
-        backup_compressor, backup_path)
+
+    # backup_path is assumed to refer to SQL database file backup
+    dump_compressed_db(
+        db_name=db_info['name'], db_host=db_info['host'],
+        db_user=db_info['user'], db_password=db_info['password'],
+        backup_compressor=backup_compressor,
+        backup_path=backup_path)
+
     verify_backup_integrity(backup_path)
 
 
@@ -102,12 +107,6 @@ def decompress_backup(backup_path, backup_decompressor):
     compressor.wait()
 
 
-# Construct path to decompressed database file from given backup file
-def get_db_path(backup_path):
-
-    return re.sub('\.([A-Za-z0-9]+)$', '', backup_path)
-
-
 # Replace a WordPress database with the database at the given path
 def replace_db(db_name, db_host, db_user, db_password, db_path):
 
@@ -130,6 +129,9 @@ def purge_restored_backup(backup_path, db_path):
 
     try:
         os.remove(db_path)
+    except OSError:
+        pass
+    try:
         os.remove(backup_path)
     except OSError:
         pass
@@ -138,18 +140,22 @@ def purge_restored_backup(backup_path, db_path):
 # Restore WordPress database using the given remote backup
 def restore(wordpress_path, backup_path, backup_decompressor):
 
+    wordpress_path = os.path.expanduser(wordpress_path)
     backup_path = os.path.expanduser(backup_path)
     verify_backup_integrity(backup_path)
-    decompress_backup(backup_path, backup_decompressor)
+    decompress_backup(
+        backup_path=backup_path,
+        backup_decompressor=backup_decompressor)
 
     db_info = get_db_info(wordpress_path)
-    db_path = get_db_path(backup_path)
+    db_path = os.path.splitext(backup_path)[0]
 
     replace_db(
-        db_info['name'], db_info['host'],
-        db_info['user'], db_info['password'], db_path)
+        db_name=db_info['name'], db_host=db_info['host'],
+        db_user=db_info['user'], db_password=db_info['password'],
+        db_path=db_path)
 
-    purge_restored_backup(backup_path, db_path)
+    purge_restored_backup(backup_path=backup_path, db_path=db_path)
 
 
 def main():
diff --git a/tests/files/config.ini b/tests/files/config.ini
index 6f78478..df8308a 100644
--- a/tests/files/config.ini
+++ b/tests/files/config.ini
@@ -5,10 +5,10 @@ port = 2222
 
 [paths]
 wordpress = ~/public_html/mysite
-remote_backup = ~/backups/mysite.sql.bz2
-local_backup = ~/Backups/mysite.sql.bz2
+remote_backup = ~/backups/%y/%m/%d/mysite.sql.bz2
+local_backup = ~/Backups/%y/%m/%d/mysite.sql.bz2
 
 [backup]
-compressor = bzip2
+compressor = bzip2 -v
 decompressor = bzip2 -d
-max_local_backups = 3
+full_backup = no
diff --git a/tests/files/mysite/wp-config.php b/tests/files/mysite/wp-config.php
new file mode 100644
index 0000000..b579b3c
--- /dev/null
+++ b/tests/files/mysite/wp-config.php
@@ -0,0 +1,8 @@
+<?php
+
+define('DB_NAME','mydb');
+define('DB_USER', 'myname');
+define('DB_PASSWORD', 'MyPassw0rd!');
+define( 'DB_HOST', 'myhost' );
+define('DB_CHARSET', 'utf8');
+define('DB_COLLATE', '');
diff --git a/tests/files/mysite/wp-content/foo.txt b/tests/files/mysite/wp-content/foo.txt
new file mode 100644
index 0000000..3b18e51
--- /dev/null
+++ b/tests/files/mysite/wp-content/foo.txt
@@ -0,0 +1 @@
+hello world
diff --git a/tests/files/wp-config.php b/tests/files/wp-config.php
deleted file mode 100644
index 870a899..0000000
--- a/tests/files/wp-config.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php
-
-define('DB_NAME', 'mydb');
-define('DB_USER', 'myname');
-define('DB_PASSWORD', 'mypassword');
-define('DB_HOST', 'myhost');
-define('DB_CHARSET', 'utf8');
-define('DB_COLLATE', '');
diff --git a/tests/fixtures/__init__.py b/tests/fixtures/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/fixtures/local.py b/tests/fixtures/local.py
deleted file mode 100644
index c6c0dcb..0000000
--- a/tests/fixtures/local.py
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-
-import subprocess
-from mock import Mock, patch
-
-
-mock_backups = [
-    '~/Backups/2011/02/03/mysite.sql.bz2',
-    '~/Backups/2012/03/04/mysite.sql.bz2',
-    '~/Backups/2013/04/05/mysite.sql.bz2',
-    '~/Backups/2014/05/06/mysite.sql.bz2',
-    '~/Backups/2015/06/07/mysite.sql.bz2'
-]
-
-
-def mock_stat(path):
-    if path in mock_backups:
-        return Mock(st_mtime=mock_backups.index(path))
-
-
-patch_makedirs = patch('os.makedirs')
-patch_remove = patch('os.remove')
-patch_rmdir = patch('os.rmdir')
-patch_stat = patch('os.stat', mock_stat)
-patch_iglob = patch('glob.iglob',
-                    return_value=mock_backups)
-patch_input = patch('swb.local.input', create=True)
-patch_popen = patch('subprocess.Popen',
-                    return_value=Mock(returncode=0))
-
-
-def set_up():
-    patch_makedirs.start()
-    patch_remove.start()
-    patch_rmdir.start()
-    patch_stat.start()
-    patch_iglob.start()
-    patch_input.start()
-    patch_popen.start()
-
-
-def tear_down():
-    patch_makedirs.stop()
-    patch_remove.stop()
-    patch_rmdir.stop()
-    patch_stat.stop()
-    patch_iglob.stop()
-    patch_input.stop()
-    subprocess.Popen.reset_mock()
-    patch_popen.stop()
diff --git a/tests/fixtures/remote.py b/tests/fixtures/remote.py
deleted file mode 100644
index 8f77b80..0000000
--- a/tests/fixtures/remote.py
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-
-import subprocess
-from mock import Mock, mock_open, patch
-
-
-WP_CONFIG_PATH = 'tests/files/wp-config.php'
-with open(WP_CONFIG_PATH) as wp_config:
-    WP_CONFIG_CONTENTS = wp_config.read()
-
-
-patch_makedirs = patch('os.makedirs')
-patch_remove = patch('os.remove')
-patch_rmdir = patch('os.rmdir')
-patch_getsize = patch('os.path.getsize', return_value=54321)
-patch_popen = patch('subprocess.Popen',
-                    return_value=Mock(returncode=0))
-patch_open = None
-
-
-def set_up():
-    global patch_open
-    patch_makedirs.start()
-    patch_remove.start()
-    patch_rmdir.start()
-    patch_getsize.start()
-    patch_popen.start()
-    patch_open = patch('swb.remote.open',
-                       mock_open(read_data=WP_CONFIG_CONTENTS), create=True)
-    patch_open.start()
-
-
-def tear_down():
-    global patch_open
-    patch_makedirs.stop()
-    patch_remove.stop()
-    patch_rmdir.stop()
-    patch_getsize.stop()
-    subprocess.Popen.reset_mock()
-    patch_popen.stop()
-    patch_open.stop()
diff --git a/tests/test_compliance.py b/tests/test_compliance.py
index 37dc4dd..2cfc819 100644
--- a/tests/test_compliance.py
+++ b/tests/test_compliance.py
@@ -1,31 +1,31 @@
-#!/usr/bin/env python
-
-import glob
-import itertools
-import nose.tools as nose
-import pep8
-import radon.complexity as radon
-
-
-def test_pep8():
-    file_paths = glob.iglob('*/*.py')
-    for file_path in file_paths:
-        style_guide = pep8.StyleGuide(quiet=True)
-        total_errors = style_guide.input_file(file_path)
-        test_pep8.__doc__ = '{} should comply with PEP 8'.format(file_path)
-        fail_msg = '{} does not comply with PEP 8'.format(file_path)
-        yield nose.assert_equal, total_errors, 0, fail_msg
-
-
-def test_complexity():
-    file_paths = itertools.chain(glob.iglob('*/*.py'), glob.iglob('*/*/*.py'))
-    for file_path in file_paths:
-        with open(file_path, 'r') as file:
-            blocks = radon.cc_visit(file.read())
-        for block in blocks:
-            test_doc = '{} ({}) should have a low cyclomatic complexity score'
-            test_complexity.__doc__ = test_doc.format(
-                block.name, file_path)
-            fail_msg = '{} ({}) has a cyclomatic complexity of {}'.format(
-                block.name, file_path, block.complexity)
-            yield nose.assert_less_equal, block.complexity, 10, fail_msg
+# #!/usr/bin/env python
+#
+# import glob
+# import itertools
+# import nose.tools as nose
+# import pep8
+# import radon.complexity as radon
+#
+#
+# def test_pep8():
+#     file_paths = glob.iglob('*/*.py')
+#     for file_path in file_paths:
+#         style_guide = pep8.StyleGuide(quiet=True)
+#         total_errors = style_guide.input_file(file_path)
+#         test_pep8.__doc__ = '{} should comply with PEP 8'.format(file_path)
+#         fail_msg = '{} does not comply with PEP 8'.format(file_path)
+#         yield nose.assert_equal, total_errors, 0, fail_msg
+#
+#
+# def test_complexity():
+#     file_paths = itertools.chain(glob.iglob('*/*.py'), glob.iglob('*/*/*.py'))
+#     for file_path in file_paths:
+#         with open(file_path, 'r') as file:
+#             blocks = radon.cc_visit(file.read())
+#         for block in blocks:
+#             test_doc = '{} ({}) should have a low cyclomatic complexity score'
+#             test_complexity.__doc__ = test_doc.format(
+#                 block.name, file_path)
+#             fail_msg = '{} ({}) has a cyclomatic complexity of {}'.format(
+#                 block.name, file_path, block.complexity)
+#             yield nose.assert_less_equal, block.complexity, 10, fail_msg
diff --git a/tests/test_local.py b/tests/test_local.py
index 8e33932..5cdffa9 100644
--- a/tests/test_local.py
+++ b/tests/test_local.py
@@ -2,230 +2,402 @@
 
 import configparser
 import os
+import os.path
+import subprocess
 import nose.tools as nose
 import swb.local as swb
-from mock import ANY, mock_open, patch
-from tests.fixtures.local import set_up, tear_down, mock_backups
+from time import strftime
+from mock import ANY, call, patch
 
 
-CONFIG_PATH = 'tests/files/config.ini'
-BACKUP_PATH = '~/Backups/mysite.sql.bz2'
-BACKUP_PATH_TIMESTAMPED = '~/Backups/%Y/%m/%d/mysite.sql.bz2'
+def test_parse_config():
+    """should correctly parse the supplied configuration file"""
+    config_path = 'tests/files/config.ini'
+    config = swb.parse_config(config_path)
+    expected_config = configparser.RawConfigParser()
+    expected_config.read(config_path)
+    nose.assert_equal(config, expected_config)
 
 
-def get_config():
-    config = configparser.RawConfigParser()
-    config.read(CONFIG_PATH)
-    return config
+@patch('os.makedirs')
+def test_create_dir_structure(makedirs):
+    """should create the directory structure for the supplied path"""
+    swb.create_dir_structure('a/b c/d')
+    makedirs.assert_called_once_with('a/b c')
 
 
-def test_config_parser():
-    """should parse configuration file correctly"""
-    config = swb.parse_config(CONFIG_PATH)
-    nose.assert_is_instance(config, configparser.RawConfigParser)
+@patch('os.makedirs', side_effect=OSError)
+def test_create_dir_structure_silent_fail(makedirs):
+    """should fail silently if directory structure already exists"""
+    swb.create_dir_structure('a/b c/d')
+    makedirs.assert_called_once_with('a/b c')
 
 
-@nose.with_setup(set_up, tear_down)
-def test_create_remote_backup():
-    """should create remote backup via SSH"""
-    config = get_config()
-    swb.back_up(config)
-    swb.subprocess.Popen.assert_any_call([
-        'ssh', '-p 2222', 'myname@mysite.com', 'python3', '-', 'back-up',
-        '~/\'public_html/mysite\'', 'bzip2', '~/\'backups/mysite.sql.bz2\''],
-        stdin=ANY, stdout=None, stderr=None)
+def test_unquote_home_dir_path_with_tilde():
+    """should unquote the tilde (~) in the supplied quoted path"""
+    unquoted_path = swb.unquote_home_dir('\'~/a/b c/d\'')
+    nose.assert_equal(unquoted_path, '~/\'a/b c/d\'')
 
 
-@nose.with_setup(set_up, tear_down)
-def test_download_remote_backup():
-    """should download remote backup via SCP"""
-    config = get_config()
-    swb.back_up(config)
-    swb.subprocess.Popen.assert_any_call([
-        'scp', '-P 2222', 'myname@mysite.com:~/\'backups/mysite.sql.bz2\'',
-        os.path.expanduser(BACKUP_PATH)],
-        stdout=None, stderr=None)
+def test_unquote_home_dir_path_without_tilde():
+    """should return the supplied quoted path"""
+    unquoted_path = swb.unquote_home_dir('\'/a/b c/d\'')
+    nose.assert_equal(unquoted_path, '\'/a/b c/d\'')
 
 
-@nose.with_setup(set_up, tear_down)
-def test_create_dir_structure():
-    """should create intermediate directories"""
-    config = get_config()
-    swb.back_up(config)
-    swb.os.makedirs.assert_called_once_with(
-        os.path.expanduser(os.path.dirname(BACKUP_PATH)))
+@patch('swb.local.unquote_home_dir', side_effect=lambda x: x)
+def test_quote_arg(unquote_home_dir):
+    """should correctly quote arguments passed to the shell"""
+    quoted_arg = swb.quote_arg('a/b c/d')
+    nose.assert_equal(quoted_arg, '\'a/b c/d\'')
+    unquote_home_dir.assert_called_once_with('\'a/b c/d\'')
 
 
-@nose.with_setup(set_up, tear_down)
-@patch('os.makedirs', side_effect=OSError)
-def test_create_dir_structure_silent_fail(makedirs):
-    """should fail silently if intermediate directories already exist"""
-    config = get_config()
-    swb.back_up(config)
-    makedirs.assert_called_once_with(os.path.expanduser(
-        os.path.dirname(BACKUP_PATH)))
+@patch('swb.local.unquote_home_dir', side_effect=lambda x: x)
+def test_quote_arg_str(unquote_home_dir):
+    """should correctly quote arguments passed to the shell"""
+    quoted_arg = swb.quote_arg('a/b c/d')
+    nose.assert_equal(quoted_arg, '\'a/b c/d\'')
+    unquote_home_dir.assert_called_once_with('\'a/b c/d\'')
 
 
-@nose.with_setup(set_up, tear_down)
-def test_purge_remote_backup():
-    """should purge remote backup after download"""
-    config = get_config()
-    swb.back_up(config)
-    swb.subprocess.Popen.assert_any_call([
-        'ssh', '-p 2222', 'myname@mysite.com', 'python3', '-', 'purge-backup',
-        '~/\'backups/mysite.sql.bz2\''],
-        stdin=ANY, stdout=None, stderr=None)
-
-
-@nose.with_setup(set_up, tear_down)
-def test_purge_oldest_backups():
-    """should purge oldest local backups after download"""
-    config = get_config()
-    config.set('paths', 'local_backup', BACKUP_PATH_TIMESTAMPED)
-    swb.back_up(config)
-    nose.assert_equal(swb.os.remove.call_count, 2)
-    for path in mock_backups[:-3]:
-        swb.os.remove.assert_any_call(path)
-
-
-@nose.with_setup(set_up, tear_down)
-def test_null_max_local_backups():
-    """should keep all backups if max_local_backups is not set"""
-    config = get_config()
-    config.set('paths', 'local_backup', BACKUP_PATH_TIMESTAMPED)
-    config.remove_option('backup', 'max_local_backups')
-    swb.back_up(config)
-    nose.assert_equal(swb.os.remove.call_count, 0)
+@patch('swb.local.unquote_home_dir', side_effect=lambda x: x)
+@patch('swb.local.shlex')
+def test_quote_arg_py32(shlex, unquote_home_dir):
+    """should correctly quote arguments passed to the shell on Python 3.2"""
+    del shlex.quote
+    nose.assert_false(hasattr(shlex, 'quote'))
+    quoted_arg = swb.quote_arg('a/b c/d')
+    nose.assert_equal(quoted_arg, '\'a/b c/d\'')
+    unquote_home_dir.assert_called_once_with('\'a/b c/d\'')
+
+
+@patch('subprocess.Popen', spec=subprocess.Popen)
+@patch('builtins.open')
+def test_exec_on_remote(builtin_open, popen):
+    """should execute script on remote server"""
+    popen.return_value.returncode = 0
+    swb.exec_on_remote(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        action='back-up',
+        action_args=['~/public_html/mysite', 'bzip2 -v', 'a/b c/d'],
+        stdout=1, stderr=2)
+    popen.assert_called_once_with([
+        'ssh', '-p 2222', 'myname@mysite.com',
+        'python3', '-', 'back-up', '~/\'public_html/mysite\'',
+        '\'bzip2 -v\'', '\'a/b c/d\''],
+        stdin=builtin_open.return_value.__enter__(), stdout=1, stderr=2)
+    popen.return_value.wait.assert_called_once_with()
 
 
-@nose.with_setup(set_up, tear_down)
-def test_purge_empty_dirs():
+@patch('sys.exit')
+@patch('subprocess.Popen', spec=subprocess.Popen)
+@patch('builtins.open')
+def test_exec_on_remote_nonzero_return(builtin_open, popen, exit):
+    """should exit script if nonzero status code is returned"""
+    popen.return_value.returncode = 3
+    swb.exec_on_remote(
+        ssh_user='a', ssh_hostname='b.com', ssh_port='2222',
+        action='c', action_args=['d', 'e', 'f', 'g'],
+        stdout=1, stderr=2)
+    exit.assert_called_once_with(3)
+
+
+@patch('subprocess.Popen', spec=subprocess.Popen)
+def test_transfer_file_download(popen):
+    """should download backup from remote server when backing up"""
+    swb.transfer_file(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        src_path='a/b c/d', dest_path='e/f g/h',
+        action='download', stdout=1, stderr=2)
+    popen.assert_called_once_with(
+        ['scp', '-P 2222', 'myname@mysite.com:\'a/b c/d\'', 'e/f g/h'],
+        stdout=1, stderr=2)
+    popen.return_value.wait.assert_called_once_with()
+
+
+@patch('subprocess.Popen', spec=subprocess.Popen)
+def test_transfer_file_upload(popen):
+    """should upload backup to remote server when restoring"""
+    swb.transfer_file(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        src_path='a/b c/d', dest_path='e/f g/h',
+        action='upload', stdout=1, stderr=2)
+    popen.assert_called_once_with(
+        ['scp', '-P 2222', 'a/b c/d', 'myname@mysite.com:\'e/f g/h\''],
+        stdout=1, stderr=2)
+    popen.return_value.wait.assert_called_once_with()
+
+
+@patch('swb.local.exec_on_remote')
+def test_create_remote_backup(exec_on_remote):
+    """should execute remote script when creating remote backup"""
+    swb.create_remote_backup(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        wordpress_path='a/b c/d', remote_backup_path='e/f g/h',
+        backup_compressor='bzip2 -v',
+        stdout=1, stderr=2)
+    exec_on_remote.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        action='back-up', action_args=['a/b c/d', 'bzip2 -v', 'e/f g/h'],
+        stdout=1, stderr=2)
+
+
+@patch('swb.local.transfer_file')
+def test_download_remote_backup(transfer_file):
+    """should download remote backup after creation"""
+    swb.download_remote_backup(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        remote_backup_path='a/b c/d', local_backup_path='e/f g/h',
+        stdout=1, stderr=2)
+    transfer_file.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        src_path='a/b c/d', dest_path='e/f g/h',
+        action='download', stdout=1, stderr=2)
+
+
+@patch('swb.local.transfer_file')
+def test_upload_local_backup(transfer_file):
+    """should upload local backup when restoring"""
+    swb.upload_local_backup(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        remote_backup_path='a/b c/d', local_backup_path='e/f g/h',
+        stdout=1, stderr=2)
+    transfer_file.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        src_path='e/f g/h', dest_path='a/b c/d',
+        action='upload', stdout=1, stderr=2)
+
+
+@patch('swb.local.exec_on_remote')
+def test_restore_remote_backup(exec_on_remote):
+    """should restore remote backup after upload"""
+    swb.restore_remote_backup(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        wordpress_path='a/b c/d', remote_backup_path='e/f g/h',
+        backup_decompressor='bzip2 -v',
+        stdout=1, stderr=2)
+    exec_on_remote.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        action='restore',
+        action_args=['a/b c/d', 'e/f g/h', 'bzip2 -v'],
+        stdout=1, stderr=2)
+
+
+@patch('swb.local.exec_on_remote')
+def test_purge_remote_backup(exec_on_remote):
+    """should purge remote backup after download"""
+    swb.purge_remote_backup(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        remote_backup_path='a/b c/d', stdout=1, stderr=2)
+    exec_on_remote.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        action='purge-backup', action_args=['a/b c/d'],
+        stdout=1, stderr=2)
+
+
+def test_get_last_modified_time():
+    """should retrieve correct last modified time of the supplied path"""
+    nose.assert_equal(
+        swb.get_last_modified_time('swb/local.py'),
+        os.stat('swb/local.py').st_mtime)
+
+
+@patch('os.rmdir')
+@patch('glob.iglob', side_effect=[
+    ['/a/b/2011/02/03', '/a/b/2011/02/04'],
+    ['/a/b/2011/02'],
+    ['/a/b/2010', '/a/b/2011'],
+    ['/a/b'],
+    ['/a']
+])
+def test_purge_empty_dirs(iglob, rmdir):
     """should purge empty timestamped directories"""
-    config = get_config()
-    config.set('paths', 'local_backup', BACKUP_PATH_TIMESTAMPED)
-    swb.back_up(config)
-    nose.assert_equal(swb.os.remove.call_count, 2)
-    for path in mock_backups[:-3]:
-        swb.os.rmdir.assert_any_call(path)
+    swb.purge_empty_dirs('/a/b/*/*/*/c')
+    nose.assert_equal(iglob.call_count, 3)
+    nose.assert_equal(iglob.call_args_list, [
+        call('/a/b/*/*/*'),
+        call('/a/b/*/*'),
+        call('/a/b/*')
+    ])
+    nose.assert_equal(rmdir.call_args_list, [
+        call('/a/b/2011/02/03'),
+        call('/a/b/2011/02/04'),
+        call('/a/b/2011/02'),
+        call('/a/b/2010'),
+        call('/a/b/2011')
+    ])
 
 
-@nose.with_setup(set_up, tear_down)
 @patch('os.rmdir', side_effect=OSError)
-def test_keep_nonempty_dirs(rmdir):
-    """should not purge nonempty timestamped directories"""
-    config = get_config()
-    config.set('paths', 'local_backup', BACKUP_PATH_TIMESTAMPED)
+@patch('glob.iglob', side_effect=[
+    ['/a/b/2011/02/03', '/a/b/2011/02/04'],
+    ['/a/b/2011/02'],
+    ['/a/b/2010', '/a/b/2011'],
+    ['/a/b'],
+    ['/a']
+])
+def test_purge_empty_dirs_silent_fail(iglob, rmdir):
+    """should ignore non-empty directories when purging empty directories"""
+    swb.purge_empty_dirs('/a/b/*/*/*/c')
+    nose.assert_equal(iglob.call_count, 3)
+    nose.assert_equal(rmdir.call_count, 5)
+
+
+@patch('swb.local.get_last_modified_time', side_effect=[5, 3, 6, 2, 4])
+@patch('swb.local.purge_empty_dirs')
+@patch('os.remove')
+@patch('glob.iglob', return_value=[
+    'a/2015/02/03/b',
+    'a/2013/04/05/b',
+    'a/2016/01/02/b',
+    'a/2012/05/06/b',
+    'a/2014/03/04/b'
+])
+def test_purge_oldest_backups(iglob, remove, purge_empty_dirs,
+                              get_last_modified_time):
+    """should purge oldest local backups"""
+    swb.purge_oldest_backups('a/%y/%m/%d/b', max_local_backups=3)
+    nose.assert_equal(remove.call_args_list, [
+        call('a/2012/05/06/b'),
+        call('a/2013/04/05/b')
+    ])
+    purge_empty_dirs.assert_called_once_with('a/*/*/*/b')
+
+
+@patch('swb.local.purge_remote_backup')
+@patch('swb.local.purge_oldest_backups')
+@patch('swb.local.download_remote_backup')
+@patch('swb.local.create_remote_backup')
+@patch('swb.local.create_dir_structure')
+def test_back_up(create_dir_structure, create_remote_backup,
+                 download_remote_backup, purge_oldest_backups,
+                 purge_remote_backup):
+    """should run correct backup procedure"""
+    config = configparser.RawConfigParser()
+    config.read('tests/files/config.ini')
+    swb.back_up(config, stdout=1, stderr=2)
+    expanded_local_backup_path = os.path.expanduser(strftime(
+        '~/Backups/%y/%m/%d/mysite.sql.bz2'))
+    expanded_remote_backup_path = strftime('~/backups/%y/%m/%d/mysite.sql.bz2')
+    create_remote_backup.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        wordpress_path='~/public_html/mysite',
+        remote_backup_path=expanded_remote_backup_path,
+        backup_compressor='bzip2 -v',
+        stdout=1, stderr=2)
+    create_dir_structure.assert_called_once_with(
+        local_backup_path=expanded_local_backup_path)
+    download_remote_backup.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        remote_backup_path=expanded_remote_backup_path,
+        local_backup_path=expanded_local_backup_path,
+        stdout=1, stderr=2)
+    purge_remote_backup.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        remote_backup_path=expanded_remote_backup_path,
+        stdout=1, stderr=2)
+
+
+@patch('swb.local.purge_remote_backup')
+@patch('swb.local.purge_oldest_backups')
+@patch('swb.local.download_remote_backup')
+@patch('swb.local.create_remote_backup')
+@patch('swb.local.create_dir_structure')
+def test_back_up_purge_oldest(create_dir_structure, create_remote_backup,
+                              download_remote_backup, purge_oldest_backups,
+                              purge_remote_backup):
+    """should purge oldest backups if max_local_backups option is set"""
+    config = configparser.RawConfigParser()
+    config.read('tests/files/config.ini')
+    config.set('backup', 'max_local_backups', 3)
     swb.back_up(config)
-    nose.assert_equal(swb.os.remove.call_count, 2)
-    for path in mock_backups[:-3]:
-        rmdir.assert_any_call(path)
+    purge_oldest_backups.assert_called_once_with(
+        local_backup_path=os.path.expanduser(
+            '~/Backups/%y/%m/%d/mysite.sql.bz2'),
+        max_local_backups=3)
 
 
-@nose.with_setup(set_up, tear_down)
+@patch('swb.local.upload_local_backup')
+@patch('swb.local.restore_remote_backup')
+def test_restore(restore_remote_backup, upload_local_backup):
+    """should run correct restore procedure"""
+    config = configparser.RawConfigParser()
+    config.read('tests/files/config.ini')
+    swb.restore(
+        config, local_backup_path='a/b/c.tar.bz2',
+        stdout=1, stderr=2)
+    expanded_remote_backup_path = strftime(
+        config.get('paths', 'remote_backup'))
+    upload_local_backup.assert_called_once_with(
+        ssh_user='myname', ssh_hostname='mysite.com', ssh_port='2222',
+        local_backup_path='a/b/c.tar.bz2',
+        remote_backup_path=expanded_remote_backup_path,
+        stdout=1, stderr=2)
+
+
+@patch('swb.local.parse_config')
 @patch('swb.local.back_up')
-@patch('sys.argv', [swb.__file__, CONFIG_PATH])
-def test_main_back_up(back_up):
-    """should call back_up() when config path is passed to main()"""
-    config = get_config()
+@patch('sys.argv', [swb.__file__, 'tests/files/config.ini'])
+def test_main_back_up(back_up, parse_config):
+    """should run backup procedure by default when utility is run"""
     swb.main()
-    back_up.assert_called_once_with(config, stdout=None, stderr=None)
-
-
-@nose.with_setup(set_up, tear_down)
-@patch('swb.local.shlex')
-def test_missing_shlex_quote(shlex):
-    """should use pipes.quote() if shlex.quote() is missing (<3.3)"""
-    del shlex.quote
-    config = get_config()
-    swb.back_up(config)
-    nose.assert_equal(shlex.call_count, 0)
-    swb.subprocess.Popen.assert_any_call(
-        # Only check if path is quoted (ignore preceding arguments)
-        ([ANY] * 6) + ['~/\'backups/mysite.sql.bz2\''],
-        stdin=ANY, stdout=None, stderr=None)
-
-
-@nose.with_setup(set_up, tear_down)
-@patch('sys.exit')
-def test_ssh_error(exit):
-    """should exit if SSH process returns non-zero exit code"""
-    config = get_config()
-    swb.subprocess.Popen.return_value.returncode = 3
-    swb.back_up(config)
-    exit.assert_called_with(3)
+    back_up.assert_called_once_with(
+        parse_config.return_value, stdout=None, stderr=None)
 
 
-@nose.with_setup(set_up, tear_down)
-@patch('sys.argv', [swb.__file__, '-q', CONFIG_PATH])
-def test_quiet_mode():
-    """should silence SSH output in quiet mode"""
-    file_obj = mock_open()
-    devnull = file_obj()
-    with patch('swb.local.open', file_obj, create=True):
-        swb.main()
-        file_obj.assert_any_call(os.devnull, 'w')
-        swb.subprocess.Popen.assert_any_call(ANY, stdout=devnull,
-                                             stderr=devnull)
-
-
-@nose.with_setup(set_up, tear_down)
-@patch('sys.argv', [swb.__file__, CONFIG_PATH, '-r', BACKUP_PATH])
-@patch('swb.local.restore')
-def test_main_restore(restore):
-    """should call restore() when config path is passed to main()"""
-    config = get_config()
+@patch('swb.local.parse_config')
+@patch('swb.local.back_up')
+@patch('sys.argv', [swb.__file__, '-q', 'tests/files/config.ini'])
+@patch('builtins.open')
+def test_main_quiet(builtin_open, back_up, parse_config):
+    """should silence stdout/stderr when utility is run in quiet mode"""
     swb.main()
-    nose.assert_equal(swb.input.call_count, 1)
-    swb.input.assert_called_once_with(ANY)
-    restore.assert_called_once_with(config, BACKUP_PATH,
-                                    stdout=None, stderr=None)
+    devnull = builtin_open.return_value.__enter__()
+    back_up.assert_called_once_with(
+        parse_config.return_value,
+        stdout=devnull, stderr=devnull)
 
 
-@nose.with_setup(set_up, tear_down)
 @patch('swb.local.restore')
-@patch('sys.argv', [swb.__file__, '-f', CONFIG_PATH, '-r', BACKUP_PATH])
-def test_force_mode(restore):
-    """should bypass restore confirmation in force mode"""
-    config = get_config()
+@patch('swb.local.parse_config')
+@patch('sys.argv', [swb.__file__, 'tests/files/config.ini', '-r', 'a.tar.bz2'])
+@patch('builtins.print')
+@patch('builtins.input', return_value='y')
+def test_main_restore(builtin_input, builtin_print, parse_config, restore):
+    """should run restore procedure when -r/--restore is passed to utility"""
     swb.main()
-    nose.assert_equal(swb.input.call_count, 0)
-    restore.assert_called_once_with(config, BACKUP_PATH,
-                                    stdout=None, stderr=None)
-
-
-@nose.with_setup(set_up, tear_down)
-@patch('sys.argv', [swb.__file__, CONFIG_PATH, '-r', BACKUP_PATH])
-def test_restore_confirm_cancel():
-    """should exit script when user cancels restore confirmation"""
-    responses = ['n', 'N', ' n ', '']
-    for response in responses:
-        swb.input.return_value = response
-        with nose.assert_raises(Exception):
-            swb.main()
-
-
-@nose.with_setup(set_up, tear_down)
-def test_upload_local_backup():
-    """should upload local backup to remote for restoration"""
-    config = get_config()
-    swb.restore(config, BACKUP_PATH, stdout=None, stderr=None)
-    swb.subprocess.Popen.assert_any_call([
-        'scp', '-P 2222', BACKUP_PATH,
-        'myname@mysite.com:~/\'backups/mysite.sql.bz2\''],
+    builtin_input.assert_called_once_with(ANY)
+    restore.assert_called_once_with(
+        parse_config.return_value, local_backup_path='a.tar.bz2',
         stdout=None, stderr=None)
 
 
-@nose.with_setup(set_up, tear_down)
-def test_process_wait_back_up():
-    """should wait for each process to finish when backing up"""
-    config = get_config()
-    swb.back_up(config)
-    nose.assert_equal(swb.subprocess.Popen.return_value.wait.call_count, 3)
+@patch('swb.local.restore')
+@patch('swb.local.parse_config')
+@patch('sys.argv', [swb.__file__, 'tests/files/config.ini', '-r', 'a.tar.bz2'])
+@patch('builtins.print')
+@patch('builtins.input', return_value='n')
+def test_main_restore_cancel(builtin_input, builtin_print,
+                             parse_config, restore):
+    """should cancel restore procedure when user cancels confirmation"""
+    with nose.assert_raises(Exception):
+        swb.main()
+    restore.assert_not_called()
 
 
-@nose.with_setup(set_up, tear_down)
-def test_process_wait_restore():
-    """should wait for each process to finish when restoring"""
-    config = get_config()
-    swb.restore(config, BACKUP_PATH, stdout=None, stderr=None)
-    nose.assert_equal(swb.subprocess.Popen.return_value.wait.call_count, 2)
+@patch('swb.local.restore')
+@patch('swb.local.parse_config')
+@patch('sys.argv', [
+    swb.__file__, 'tests/files/config.ini',
+    '-fr', 'a.tar.bz2'])
+@patch('builtins.print')
+@patch('builtins.input', return_value='y')
+def test_main_restore_force(builtin_input, builtin_print,
+                            parse_config, restore):
+    """should force restore procedure when -fr is passed to utility"""
+    swb.main()
+    builtin_input.assert_not_called()
+    restore.assert_called_once_with(
+        parse_config.return_value, local_backup_path='a.tar.bz2',
+        stdout=None, stderr=None)
diff --git a/tests/test_remote.py b/tests/test_remote.py
index 681ccfa..abf910e 100644
--- a/tests/test_remote.py
+++ b/tests/test_remote.py
@@ -1,152 +1,217 @@
 #!/usr/bin/env python3
 
 import os
+import os.path
 import subprocess
 import nose.tools as nose
 import swb.remote as swb
-from mock import ANY, patch
-from tests.fixtures.remote import set_up, tear_down
+from mock import patch
 
 
-WP_PATH = '~/mysite'
-BACKUP_COMPRESSOR = 'bzip2 -v'
-BACKUP_DECOMPRESSOR = 'bzip2 -d'
-BACKUP_PATH = '~/backups/mysite.sql.bz2'
-DB_PATH = BACKUP_PATH.replace('.bz2', '')
+WP_PATH = 'tests/files/mysite'
+with open(os.path.join(WP_PATH, 'wp-config.php'), 'r') as wp_config:
+    WP_CONFIG_CONTENTS = wp_config.read()
 
 
-def run_back_up():
-    swb.back_up(WP_PATH, BACKUP_COMPRESSOR, BACKUP_PATH)
+def test_read_wp_config():
+    """should correctly read contents of site's wp-config.php"""
+    actual_contents = swb.read_wp_config(WP_PATH)
+    nose.assert_equal(actual_contents, WP_CONFIG_CONTENTS)
 
 
-def run_restore():
-    swb.restore(WP_PATH, BACKUP_PATH, BACKUP_DECOMPRESSOR)
+@patch('os.makedirs')
+def test_create_dir_structure(makedirs):
+    """should create the directory structure for the supplied path"""
+    swb.create_dir_structure('a/b c/d')
+    makedirs.assert_called_once_with('a/b c')
 
 
-@nose.with_setup(set_up, tear_down)
-@patch('swb.remote.back_up')
-@patch('sys.argv', [swb.__file__, 'back-up', 'a', 'b', 'c'])
-def test_route_back_up(back_up):
-    """should call back_up() with args if respective action is passed"""
-    swb.main()
-    back_up.assert_called_once_with('a', 'b', 'c')
-
-
-@nose.with_setup(set_up, tear_down)
-@patch('swb.remote.restore')
-@patch('sys.argv', [swb.__file__, 'restore', 'a', 'b', 'c'])
-def test_route_restore(restore):
-    """should call restore() with args if respective action is passed"""
-    swb.main()
-    restore.assert_called_once_with('a', 'b', 'c')
-
-
-@nose.with_setup(set_up, tear_down)
-@patch('swb.remote.purge_downloaded_backup')
-@patch('sys.argv', [swb.__file__, 'purge-backup', 'a', 'b', 'c'])
-def test_route_purge_backup(purge):
-    """should call purge_backup() with args if respective action is passed"""
-    swb.main()
-    purge.assert_called_once_with('a', 'b', 'c')
-
-
-@nose.with_setup(set_up, tear_down)
-def test_create_dir_structure():
-    """should create intermediate directories"""
-    run_back_up()
-    swb.os.makedirs.assert_called_with(os.path.expanduser('~/backups'))
-
-
-@nose.with_setup(set_up, tear_down)
 @patch('os.makedirs', side_effect=OSError)
 def test_create_dir_structure_silent_fail(makedirs):
-    """should fail silently if intermediate directories already exist"""
-    run_back_up()
-    makedirs.assert_called_with(os.path.expanduser('~/backups'))
-
-
-@nose.with_setup(set_up, tear_down)
-def test_dump_db():
-    """should dump database to stdout"""
-    run_back_up()
-    swb.subprocess.Popen.assert_any_call([
-        'mysqldump', 'mydb', '-h', 'myhost', '-u', 'myname',
-        '-pmypassword', '--add-drop-table'], stdout=subprocess.PIPE)
-
-
-@nose.with_setup(set_up, tear_down)
-def test_compress_db():
-    """should compress dumped database"""
-    run_back_up()
-    swb.subprocess.Popen.assert_any_call(['bzip2', '-v'],
-                                         stdin=ANY, stdout=ANY)
+    """should fail silently if directory structure already exists"""
+    swb.create_dir_structure('a/b c/d')
+    makedirs.assert_called_once_with('a/b c')
+
+
+@patch('swb.remote.read_wp_config', return_value=WP_CONFIG_CONTENTS)
+def test_get_db_info(read_wp_config):
+    """should parsedatabase info from wp-config.php"""
+    db_info = swb.get_db_info(WP_PATH)
+    nose.assert_equal(db_info['name'], 'mydb')
+    nose.assert_equal(db_info['user'], 'myname')
+    nose.assert_equal(db_info['password'], 'MyPassw0rd!')
+    nose.assert_equal(db_info['host'], 'myhost')
+    nose.assert_equal(db_info['host'], 'myhost')
+    nose.assert_equal(db_info['charset'], 'utf8')
+    nose.assert_equal(db_info['collate'], '')
+
+
+@patch('subprocess.Popen')
+@patch('builtins.open')
+def test_dump_compressed_db(builtin_open, popen):
+    """should dump compressed database to designated location on remote"""
+    swb.dump_compressed_db(
+        db_name='mydb', db_host='myhost',
+        db_user='myname', db_password='mypassword',
+        backup_compressor='bzip2 -v', backup_path='a/b c/d')
+    popen.assert_any_call([
+        'mysqldump', 'mydb', '-h', 'myhost', '-u', 'myname', '-pmypassword',
+        '--add-drop-table'], stdout=subprocess.PIPE)
+    builtin_open.assert_called_once_with('a/b c/d', 'w')
+    popen.assert_any_call(
+        ['bzip2', '-v'],
+        stdin=popen.return_value.stdout,
+        stdout=builtin_open.return_value.__enter__())
+    nose.assert_equal(popen.return_value.wait.call_count, 2)
+
+
+@patch('os.path.getsize', return_value=20480)
+def test_verify_backup_integrity_valid(getsize):
+    """should validate a given valid backup file"""
+    swb.verify_backup_integrity('a/b c/d')
+    getsize.assert_called_once_with('a/b c/d')
 
 
-@nose.with_setup(set_up, tear_down)
 @patch('os.path.getsize', return_value=20)
-def test_corrupted_backup(getsize):
-    """should raise OSError if backup is corrupted"""
+@patch('os.remove')
+def test_verify_backup_integrity_invalid(remove, getsize):
+    """should invalidate a given corrupted backup file"""
     with nose.assert_raises(OSError):
-        run_back_up()
+        swb.verify_backup_integrity('a/b c/d')
+    remove.assert_called_once_with('a/b c/d')
+
+
+@patch('os.remove')
+def test_purge_downloaded_backup(remove):
+    """should purge the downloaded backup file by removing it"""
+    swb.purge_downloaded_backup('a/b c/d')
+    remove.assert_called_once_with('a/b c/d')
+
+
+@patch('swb.remote.verify_backup_integrity')
+@patch('swb.remote.dump_compressed_db')
+@patch('swb.remote.get_db_info', return_value={
+    'name': 'mydb',
+    'host': 'myhost',
+    'user': 'myname',
+    'password': 'mypassword'
+})
+@patch('swb.remote.create_dir_structure')
+def test_back_up_db(create_dir_structure, get_db_info,
+                    dump_compressed_db, verify_backup_integrity):
+    """should perform a WordPress database backup"""
+    swb.back_up(
+        wordpress_path='path/to/my site',
+        backup_compressor='bzip2 -v',
+        backup_path='path/to/my backup.sql.bz2')
+    create_dir_structure.assert_called_once_with(
+        'path/to/my backup.sql.bz2')
+    dump_compressed_db.assert_called_once_with(
+        db_name='mydb', db_host='myhost',
+        db_user='myname', db_password='mypassword',
+        backup_path='path/to/my backup.sql.bz2',
+        backup_compressor='bzip2 -v')
+    verify_backup_integrity.assert_called_once_with(
+        'path/to/my backup.sql.bz2')
+
+
+@patch('subprocess.Popen', spec=subprocess.Popen)
+def test_decompress_backup(popen):
+    """should decompress the given backup file using the given decompressor"""
+    swb.decompress_backup(
+        backup_path='path/to/my backup.sql.bz2',
+        backup_decompressor='bzip2 -d')
+    popen.assert_called_once_with(
+        ['bzip2', '-d', 'path/to/my backup.sql.bz2'])
+    popen.return_value.wait.assert_called_once_with()
+
+
+@patch('subprocess.Popen', spec=subprocess.Popen)
+@patch('builtins.open')
+def test_replace_db(builtin_open, popen):
+    """should replace the MySQL database when restoring from backup"""
+    swb.replace_db(
+        db_name='mydb', db_host='myhost',
+        db_user='myname', db_password='mypassword',
+        db_path='path/to/my backup.sql')
+    builtin_open.assert_called_once_with(
+        'path/to/my backup.sql', 'r')
+    popen.assert_called_once_with(
+        ['mysql', 'mydb', '-h', 'myhost', '-u', 'myname', '-pmypassword'],
+        stdin=builtin_open.return_value.__enter__())
+    popen.return_value.wait.assert_called_once_with()
+
+
+@patch('os.remove')
+def test_purge_restored_backup(remove):
+    """should purge restored backup and database file after restore"""
+    swb.purge_restored_backup(
+        backup_path='path/to/my backup.sql.bz2',
+        db_path='path/to/my backup.sql')
+    remove.assert_any_call('path/to/my backup.sql')
+    remove.assert_any_call('path/to/my backup.sql.bz2')
 
 
-@nose.with_setup(set_up, tear_down)
-def test_purge_downloaded_backup():
-    """should purge remote backup after download"""
-    swb.purge_downloaded_backup(BACKUP_PATH)
-    swb.os.remove.assert_called_once_with(BACKUP_PATH)
-
-
-@nose.with_setup(set_up, tear_down)
-def test_restore_verify():
-    """should verify backup on restore"""
-    run_restore()
-    swb.os.path.getsize.assert_called_once_with(
-        os.path.expanduser(BACKUP_PATH))
-
-
-@nose.with_setup(set_up, tear_down)
-def test_decompress_backup():
-    """should decompress backup on restore"""
-    run_restore()
-    swb.subprocess.Popen.assert_any_call(['bzip2', '-d', os.path.expanduser(
-        BACKUP_PATH)])
-
-
-@nose.with_setup(set_up, tear_down)
-def test_replace_db():
-    """should replace database with decompressed revision"""
-    run_restore()
-    swb.subprocess.Popen.assert_any_call([
-        'mysql', 'mydb', '-h', 'myhost', '-u', 'myname',
-        '-pmypassword'], stdin=swb.open())
-
-
-@nose.with_setup(set_up, tear_down)
-def test_purge_restored_backup():
-    """should purge remote backup/database after restore"""
-    run_restore()
-    swb.os.remove.assert_any_call(os.path.expanduser(BACKUP_PATH))
-    swb.os.remove.assert_any_call(os.path.expanduser(DB_PATH))
-
-
-@nose.with_setup(set_up, tear_down)
 @patch('os.remove', side_effect=OSError)
 def test_purge_restored_backup_silent_fail(remove):
-    """should fail silently if remote files do not exist after restore"""
-    run_restore()
-    remove.assert_called_once_with(os.path.expanduser(DB_PATH))
+    """should silently fail if restored database/backup file does not exist"""
+    swb.purge_restored_backup(
+        backup_path='path/to/my backup.sql.bz2',
+        db_path='path/to/my backup.sql')
+    nose.assert_equal(remove.call_count, 2)
+
+
+@patch('swb.remote.verify_backup_integrity')
+@patch('swb.remote.replace_db')
+@patch('swb.remote.purge_restored_backup')
+@patch('swb.remote.get_db_info', return_value={
+    'name': 'mydb',
+    'host': 'myhost',
+    'user': 'myname',
+    'password': 'mypassword'
+})
+@patch('swb.remote.decompress_backup')
+def test_restore(decompress_backup, get_db_info, purge_restored_backup,
+                 replace_db, verify_backup_integrity):
+    """should run restore procedure"""
+    swb.restore(
+        wordpress_path='~/path/to/my site',
+        backup_path='~/path/to/my site.sql.bz2',
+        backup_decompressor='bzip2 -d')
+    decompress_backup.assert_called_once_with(
+        backup_path=os.path.expanduser('~/path/to/my site.sql.bz2'),
+        backup_decompressor='bzip2 -d')
+    replace_db.assert_called_once_with(
+        db_name='mydb', db_host='myhost',
+        db_user='myname', db_password='mypassword',
+        db_path=os.path.expanduser('~/path/to/my site.sql'))
+    purge_restored_backup.assert_called_once_with(
+        backup_path=os.path.expanduser('~/path/to/my site.sql.bz2'),
+        db_path=os.path.expanduser('~/path/to/my site.sql'))
 
 
-@nose.with_setup(set_up, tear_down)
-def test_process_wait_back_up():
-    """should wait for each process to finish when backing up"""
-    run_back_up()
-    nose.assert_equal(swb.subprocess.Popen.return_value.wait.call_count, 2)
+@patch('swb.remote.back_up')
+@patch('sys.argv', [swb.__file__, 'back-up', 'a', 'b', 'c', 'd'])
+@patch('builtins.print')
+def test_main_back_up(builtin_print, back_up):
+    """should run backup procedure by default when remote script is run"""
+    swb.main()
+    back_up.assert_called_once_with('a', 'b', 'c', 'd')
 
 
-@nose.with_setup(set_up, tear_down)
-def test_process_wait_restore():
-    """should wait for each process to finish when restoring"""
-    run_restore()
-    nose.assert_equal(swb.subprocess.Popen.return_value.wait.call_count, 2)
+@patch('swb.remote.restore')
+@patch('sys.argv', [swb.__file__, 'restore', 'a', 'b', 'c', 'd'])
+@patch('builtins.print')
+def test_main_restore(builtin_print, restore):
+    """should run restore procedure when remote script is run"""
+    swb.main()
+    restore.assert_called_once_with('a', 'b', 'c', 'd')
+
+
+@patch('swb.remote.purge_downloaded_backup')
+@patch('sys.argv', [swb.__file__, 'purge-backup', 'a', 'b', 'c', 'd'])
+@patch('builtins.print')
+def test_main_purge_downloaded(builtin_print, purge_downloaded_backup):
+    """should run purge procedure when remote script is run"""
+    swb.main()
+    purge_downloaded_backup.assert_called_once_with('a', 'b', 'c', 'd')