Support for Borg --keep-secondly prune option (#98 ).

Hack to uncomment all options in config file used for finding unsupported Borg options.
Remove unneeded Dockerfile for end-to-end tests.
2018-10-04 21:54:23 -07:00 · 2018-10-04 21:45:31 -07:00 · 2018-10-03 22:44:23 -07:00 · 2018-10-03 22:36:25 -07:00 · 2018-10-03 19:35:42 -07:00 · 2018-10-03 08:59:08 -07:00
63 changed files with 1436 additions and 982 deletions
--- a/.drone.yml
+++ b/.drone.yml
@ -0,0 +1,9 @@
+pipeline:
+  build:
+    image: python:3.7.0-alpine3.8
+    pull: true
+    commands:
+      - pip install tox
+      - tox
+      - apk add --no-cache borgbackup
+      - tox -e end-to-end
--- a/.gitignore
+++ b/.gitignore
@ -3,6 +3,7 @@
 *.swp
 .cache
 .coverage
+.pytest_cache
 .tox
 build
 dist
--- a/5
+++ b/5
@ -1,11 +1,12 @@
 Dan Helfman <witten@torsion.org>: Main developer

 Alexander Görtz: Python 3 compatibility
+Florian Lindner: Logging rewrite
 Henning Schroeder: Copy editing
 Johannes Feichtner: Support for user hooks
 Michele Lazzeri: Custom archive names
+Nick Whyte: Support prefix filtering for archive consistency checks
 newtonne: Read encryption password from external file
 Robin `ypid` Schneider: Support additional options of Borg
 Scott Squires: Custom archive names
-Thomas LÉVEIL: Support for a keep_minutely prune option
-Nick Whyte: Support prefix filtering for archive consistency checks
+Thomas LÉVEIL: Support for a keep_minutely prune option. Support for the --json option
--- a/45
+++ b/45
@ -1,3 +1,48 @@
+1.2.7
+ * #98: Support for Borg --keep-secondly prune option.
+ * Use Black code formatter and Flake8 code checker as part of running automated tests.
+ * Add an end-to-end automated test that actually integrates with Borg.
+ * Set up continuous integration for borgmatic automated tests on projects.evoworx.org.
+
+1.2.6
+ * Fix generated configuration to also include a "keep_daily" value so pruning works out of the
+   box.
+
+1.2.5
+ * #57: When generating sample configuration with generate-borgmatic-config, comment out all
+   optional configuration so as to streamline the initial configuration process.
+
+1.2.4
+ * Fix for archive checking traceback due to parameter mismatch.
+
+1.2.3
+ * #64, #90, #92: Rewrite of logging system. Now verbosity flags passed to Borg are derived from
+   borgmatic's log level. Note that the output of borgmatic might slightly change.
+ * Part of #80: Support for Borg create --read-special via "read_special" option in borgmatic's
+   location configuration.
+ * #87: Support for Borg create --checkpoint-interval via "checkpoint_interval" option in
+   borgmatic's storage configuration.
+ * #88: Fix declared pykwalify compatibility version range in setup.py to prevent use of ancient
+   versions of pykwalify with large version numbers.
+ * #89: Pass --show-rc option to Borg when at highest verbosity level.
+ * #94: Support for Borg --json option via borgmatic command-line to --create archives.
+
+1.2.2
+ * #85: Fix compatibility issue between pykwalify and ruamel.yaml 0.15.52, which manifested in
+   borgmatic as a pykwalify RuleError.
+
+1.2.1
+ * Skip before/after backup hooks when only doing --prune, --check, --list, and/or --info.
+ * #71: Support for XDG_CONFIG_HOME environment variable for specifying alternate user ~/.config/
+   path.
+ * #74, #83: Support for Borg --json option via borgmatic command-line to --list archives or show
+   archive --info in JSON format, ideal for programmatic consumption.
+ * #38, #76: Upgrade ruamel.yaml compatibility version range and fix support for Python 3.7.
+ * #77: Skip non-"*.yaml" config filenames in /etc/borgmatic.d/ so as not to parse backup files,
+   editor swap files, etc.
+ * #81: Document user-defined hooks run before/after backup, or on error.
+ * Add code style guidelines to the documention.
+
 1.2.0
 * #61: Support for Borg --list option via borgmatic command-line to list all archives.
 * #61: Support for Borg --info option via borgmatic command-line to display summary information.
--- a/README.md
+++ b/README.md
@ -1,13 +1,17 @@
-<img src="https://projects.torsion.org/witten/borgmatic/raw/branch/master/static/borgmatic.png" width="150px" style="float: right; padding-left: 1em;">
-
+---
+title: borgmatic
+permalink: borgmatic/index.html
+---
 ## Overview

-borgmatic (formerly atticmatic) is a simple Python wrapper script for the
-[Borg](https://borgbackup.readthedocs.org/en/stable/) backup software that
-initiates a backup, prunes any old backups according to a retention policy,
-and validates backups for consistency. The script supports specifying your
-settings in a declarative configuration file rather than having to put them
-all on the command-line, and handles common errors.
+<img src="https://projects.torsion.org/witten/borgmatic/raw/branch/master/static/borgmatic.png" width="150px" style="float: right; padding-left: 1em;">
+
+borgmatic is a simple Python wrapper script for the
+[Borg](https://www.borgbackup.org/) backup software that initiates a backup,
+prunes any old backups according to a retention policy, and validates backups
+for consistency. The script supports specifying your settings in a declarative
+configuration file rather than having to put them all on the command-line, and
+handles common errors.

 Here's an example config file:

@ -44,7 +48,10 @@ borgmatic is hosted at <https://torsion.org/borgmatic> with [source code
 available](https://projects.torsion.org/witten/borgmatic). It's also mirrored
 on [GitHub](https://github.com/witten/borgmatic) for convenience.

-<a href="https://asciinema.org/a/164143" target="_blank"><img src="https://asciinema.org/a/164143.png" width="100%" /></a>
+Want to see borgmatic in action? Check out the <a
+href="https://asciinema.org/a/203761" target="_blank">screencast</a>.
+
+<script src="https://asciinema.org/a/203761.js" id="asciicast-203761" async></script>


 ## Installation
@ -104,7 +111,7 @@ not in your system `PATH`. Try looking in `/usr/local/bin/`.
 This generates a sample configuration file at /etc/borgmatic/config.yaml (by
 default). You should edit the file to suit your needs, as the values are just
 representative. All fields are optional except where indicated, so feel free
-to remove anything you don't need.
+to ignore anything you don't need.

 You can also have a look at the [full configuration
 schema](https://projects.torsion.org/witten/borgmatic/src/master/borgmatic/config/schema.yaml)
@ -138,6 +145,31 @@ configuration paths on the command-line with borgmatic's `--config` option.
 See `borgmatic --help` for more information.


+### Hooks
+
+If you find yourself performing prepraration tasks before your backup runs, or
+cleanup work afterwards, borgmatic hooks may be of interest. They're simply
+shell commands that borgmatic executes for you at various points, and they're
+configured in the `hooks` section of your configuration file.
+
+For instance, you can specify `before_backup` hooks to dump a database to file
+before backing it up, and specify `after_backup` hooks to delete the temporary
+file afterwards.
+
+borgmatic hooks run once per configuration file. `before_backup` hooks run
+prior to backups of all repositories. `after_backup` hooks run afterwards, but
+not if an error occurs in a previous hook or in the backups themselves. And
+borgmatic runs `on_error` hooks if an error occurs.
+
+An important security note about hooks: borgmatic executes all hook commands
+with the user permissions of borgmatic itself. So to prevent potential shell
+injection or privilege escalation, do not forget to set secure permissions
+(`chmod 0700`) on borgmatic configuration files and scripts invoked by hooks.
+
+See the sample generated configuration file mentioned above for specifics
+about hook configuration syntax.
+
+
 ## Upgrading

 In general, all you should need to do to upgrade borgmatic is run the
@ -266,6 +298,20 @@ any number of them. This supports use cases like running consistency checks
 from a different cron job with a different frequency, or running pruning with
 a different verbosity level.

+Additionally, borgmatic provides convenient flags for Borg's
+[list](https://borgbackup.readthedocs.io/en/stable/usage/list.html) and
+[info](https://borgbackup.readthedocs.io/en/stable/usage/info.html)
+functionality:
+
+
+```bash
+borgmatic --list
+borgmatic --info
+```
+
+You can include an optional `--json` flag with `--create`, `--list`, or
+`--info` to get the output formatted as JSON.
+

 ## Autopilot

@ -275,7 +321,7 @@ configure a job runner to invoke it periodically.
 ### cron

 If you're using cron, download the [sample cron
-file](https://projects.torsion.org/witten/borgmatic/raw/master/sample/cron/borgmatic).
+file](https://projects.torsion.org/witten/borgmatic/src/master/sample/cron/borgmatic).
 Then, from the directory where you downloaded it:

 ```bash
@ -326,11 +372,30 @@ to discuss your idea. We also accept Pull Requests on GitHub, if that's more
 your thing. In general, contributions are very welcome. We don't bite! 


+### Code style
+
+Start with [PEP 8](https://www.python.org/dev/peps/pep-0008/). But then, apply
+the following deviations from it:
+
+ * For strings, prefer single quotes over double quotes.
+ * Limit all lines to a maximum of 100 characters.
+ * Use trailing commas within multiline values or argument lists.
+ * For multiline constructs, put opening and closing delimeters on lines
+   separate from their contents.
+ * Within multiline constructs, use standard four-space indentation. Don't align
+   indentation with an opening delimeter.
+
+borgmatic code uses the [Black](https://black.readthedocs.io/en/stable/) code
+formatter and [Flake8](http://flake8.pycqa.org/en/latest/) code checker, so
+certain code style requirements will be enforced when running automated tests.
+See the Black and Flake8 documentation for more information.
+
+
 ### Development

 To get set up to hack on borgmatic, first clone master via HTTPS or SSH:

-```
+```bash
 git clone https://projects.torsion.org/witten/borgmatic.git
 ```

@ -341,7 +406,7 @@ git clone ssh://git@projects.torsion.org:3022/witten/borgmatic.git
 ```

 Then, install borgmatic
-"[editable](https://pip.pypa.io/en/stable/reference/pip_install/#editable-installs)"
+"[editable](https://pip.pypa.io/en/stable/reference/pip_install/#editable-installs)"
 so that you can easily run borgmatic commands while you're hacking on them to
 make sure your changes work.

@ -376,6 +441,28 @@ cd borgmatic
 tox
 ```

+Note that while running borgmatic itself only requires Python 3+, running
+borgmatic's tests require Python 3.6+.
+
+If when running tests, you get an error from the
+[Black](https://black.readthedocs.io/en/stable/) code formatter about files
+that would be reformatted, you can ask Black to format them for you via the
+following:
+
+```bash
+tox -e black
+```
+
+### End-to-end tests
+
+borgmatic additionally includes some end-to-end tests that integration test
+with Borg for a few representative scenarios. These tests don't run by default
+because they're relatively slow and depend on Borg. If you would like to run
+them:
+
+```bash
+tox -e end-to-end
+```

 ## Troubleshooting

--- a/borgmatic/borg/check.py
+++ b/borgmatic/borg/check.py
@ -3,7 +3,6 @@ import os
 import subprocess

 from borgmatic.borg import extract
-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS


 DEFAULT_CHECKS = ('repository', 'archives')
@ -32,7 +31,9 @@ def _parse_checks(consistency_config):
    if checks == ['disabled']:
        return ()

-    return tuple(check for check in checks if check.lower() not in ('disabled', '')) or DEFAULT_CHECKS
+    return (
+        tuple(check for check in checks if check.lower() not in ('disabled', '')) or DEFAULT_CHECKS
+    )


 def _make_check_flags(checks, check_last=None, prefix=None):
@ -61,25 +62,30 @@ def _make_check_flags(checks, check_last=None, prefix=None):
        last_flags = ()
        prefix_flags = ()
        if check_last:
-            logger.warn('Ignoring check_last option, as "archives" is not in consistency checks.')
+            logger.warning(
+                'Ignoring check_last option, as "archives" is not in consistency checks.'
+            )
        if prefix:
-            logger.warn('Ignoring consistency prefix option, as "archives" is not in consistency checks.')
-        
+            logger.warning(
+                'Ignoring consistency prefix option, as "archives" is not in consistency checks.'
+            )
+
    if set(DEFAULT_CHECKS).issubset(set(checks)):
        return last_flags + prefix_flags

-    return tuple(
-        '--{}-only'.format(check) for check in checks
-        if check in DEFAULT_CHECKS
-    ) + last_flags + prefix_flags
+    return (
+        tuple('--{}-only'.format(check) for check in checks if check in DEFAULT_CHECKS)
+        + last_flags
+        + prefix_flags
+    )


-def check_archives(verbosity, repository, storage_config, consistency_config, local_path='borg',
-                   remote_path=None):
+def check_archives(
+    repository, storage_config, consistency_config, local_path='borg', remote_path=None
+):
    '''
-    Given a verbosity flag, a local or remote repository path, a storage config dict, a consistency
-    config dict, and a local/remote commands to run, check the contained Borg archives for
-    consistency.
+    Given a local or remote repository path, a storage config dict, a consistency config dict,
+    and a local/remote commands to run, check the contained Borg archives for consistency.

    If there are no consistency checks to run, skip running them.
    '''
@ -91,16 +97,22 @@ def check_archives(verbosity, repository, storage_config, consistency_config, lo
        remote_path_flags = ('--remote-path', remote_path) if remote_path else ()
        lock_wait = storage_config.get('lock_wait', None)
        lock_wait_flags = ('--lock-wait', str(lock_wait)) if lock_wait else ()
-        verbosity_flags = {
-            VERBOSITY_SOME: ('--info',),
-            VERBOSITY_LOTS: ('--debug',),
-        }.get(verbosity, ())
+
+        verbosity_flags = ()
+        if logger.isEnabledFor(logging.INFO):
+            verbosity_flags = ('--info',)
+        if logger.isEnabledFor(logging.DEBUG):
+            verbosity_flags = ('--debug', '--show-rc')
+
        prefix = consistency_config.get('prefix')

        full_command = (
-            local_path, 'check',
-            repository,
-        ) + _make_check_flags(checks, check_last, prefix) + remote_path_flags + lock_wait_flags + verbosity_flags
+            (local_path, 'check', repository)
+            + _make_check_flags(checks, check_last, prefix)
+            + remote_path_flags
+            + lock_wait_flags
+            + verbosity_flags
+        )

        # The check command spews to stdout/stderr even without the verbose flag. Suppress it.
        stdout = None if verbosity_flags else open(os.devnull, 'w')
@ -109,4 +121,4 @@ def check_archives(verbosity, repository, storage_config, consistency_config, lo
        subprocess.check_call(full_command, stdout=stdout, stderr=subprocess.STDOUT)

    if 'extract' in checks:
-        extract.extract_last_archive_dry_run(verbosity, repository, lock_wait, local_path, remote_path)
+        extract.extract_last_archive_dry_run(repository, lock_wait, local_path, remote_path)
--- a/borgmatic/borg/create.py
+++ b/borgmatic/borg/create.py
@ -5,8 +5,6 @@ import os
 import subprocess
 import tempfile

-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
-

 logger = logging.getLogger(__name__)

@ -44,10 +42,7 @@ def _expand_directories(directories):
        return ()

    return tuple(
-        itertools.chain.from_iterable(
-            _expand_directory(directory)
-            for directory in directories
-        )
+        itertools.chain.from_iterable(_expand_directory(directory) for directory in directories)
    )


@ -77,8 +72,7 @@ def _make_pattern_flags(location_config, pattern_filename=None):

    return tuple(
        itertools.chain.from_iterable(
-            ('--patterns-from', pattern_filename)
-            for pattern_filename in pattern_filenames
+            ('--patterns-from', pattern_filename) for pattern_filename in pattern_filenames
        )
    )

@ -93,8 +87,7 @@ def _make_exclude_flags(location_config, exclude_filename=None):
    )
    exclude_from_flags = tuple(
        itertools.chain.from_iterable(
-            ('--exclude-from', exclude_filename)
-            for exclude_filename in exclude_filenames
+            ('--exclude-from', exclude_filename) for exclude_filename in exclude_filenames
        )
    )
    caches_flag = ('--exclude-caches',) if location_config.get('exclude_caches') else ()
@ -105,7 +98,13 @@ def _make_exclude_flags(location_config, exclude_filename=None):


 def create_archive(
-    verbosity, dry_run, repository, location_config, storage_config, local_path='borg', remote_path=None,
+    dry_run,
+    repository,
+    location_config,
+    storage_config,
+    local_path='borg',
+    remote_path=None,
+    json=False,
 ):
    '''
    Given vebosity/dry-run flags, a local or remote repository path, a location config dict, and a
@ -115,6 +114,7 @@ def create_archive(

    pattern_file = _write_pattern_file(location_config.get('patterns'))
    exclude_file = _write_pattern_file(_expand_directories(location_config.get('exclude_patterns')))
+    checkpoint_interval = storage_config.get('checkpoint_interval', None)
    compression = storage_config.get('compression', None)
    remote_rate_limit = storage_config.get('remote_rate_limit', None)
    umask = storage_config.get('umask', None)
@ -125,34 +125,31 @@ def create_archive(

    full_command = (
        (
-            local_path, 'create',
+            local_path,
+            'create',
            '{repository}::{archive_name_format}'.format(
-                repository=repository,
-                archive_name_format=archive_name_format,
+                repository=repository, archive_name_format=archive_name_format
            ),
        )
        + sources
-        + _make_pattern_flags(
-            location_config,
-            pattern_file.name if pattern_file else None,
-        )
-        + _make_exclude_flags(
-            location_config,
-            exclude_file.name if exclude_file else None,
-        )
+        + _make_pattern_flags(location_config, pattern_file.name if pattern_file else None)
+        + _make_exclude_flags(location_config, exclude_file.name if exclude_file else None)
+        + (('--checkpoint-interval', str(checkpoint_interval)) if checkpoint_interval else ())
        + (('--compression', compression) if compression else ())
        + (('--remote-ratelimit', str(remote_rate_limit)) if remote_rate_limit else ())
        + (('--one-file-system',) if location_config.get('one_file_system') else ())
+        + (('--read-special',) if location_config.get('read_special') else ())
        + (('--nobsdflags',) if location_config.get('bsd_flags') is False else ())
        + (('--files-cache', files_cache) if files_cache else ())
        + (('--remote-path', remote_path) if remote_path else ())
        + (('--umask', str(umask)) if umask else ())
        + (('--lock-wait', str(lock_wait)) if lock_wait else ())
-        + {
-            VERBOSITY_SOME: ('--info',) if dry_run else ('--info', '--stats',),
-            VERBOSITY_LOTS: ('--debug', '--list',) if dry_run else ('--debug', '--list', '--stats',),
-        }.get(verbosity, ())
+        + (('--list', '--filter', 'AME') if logger.isEnabledFor(logging.INFO) else ())
+        + (('--info',) if logger.getEffectiveLevel() == logging.INFO else ())
+        + (('--stats',) if not dry_run and logger.isEnabledFor(logging.INFO) else ())
+        + (('--debug', '--show-rc') if logger.isEnabledFor(logging.DEBUG) else ())
        + (('--dry-run',) if dry_run else ())
+        + (('--json',) if json else ())
    )

    logger.debug(' '.join(full_command))
--- a/borgmatic/borg/extract.py
+++ b/borgmatic/borg/extract.py
@ -2,29 +2,29 @@ import logging
 import sys
 import subprocess

-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
-

 logger = logging.getLogger(__name__)


-def extract_last_archive_dry_run(verbosity, repository, lock_wait=None, local_path='borg', remote_path=None):
+def extract_last_archive_dry_run(repository, lock_wait=None, local_path='borg', remote_path=None):
    '''
    Perform an extraction dry-run of just the most recent archive. If there are no archives, skip
    the dry-run.
    '''
    remote_path_flags = ('--remote-path', remote_path) if remote_path else ()
    lock_wait_flags = ('--lock-wait', str(lock_wait)) if lock_wait else ()
-    verbosity_flags = {
-        VERBOSITY_SOME: ('--info',),
-        VERBOSITY_LOTS: ('--debug',),
-    }.get(verbosity, ())
+    verbosity_flags = ()
+    if logger.isEnabledFor(logging.DEBUG):
+        verbosity_flags = ('--debug', '--show-rc')
+    elif logger.isEnabledFor(logging.INFO):
+        verbosity_flags = ('--info',)

    full_list_command = (
-        local_path, 'list',
-        '--short',
-        repository,
-    ) + remote_path_flags + lock_wait_flags + verbosity_flags
+        (local_path, 'list', '--short', repository)
+        + remote_path_flags
+        + lock_wait_flags
+        + verbosity_flags
+    )

    list_output = subprocess.check_output(full_list_command).decode(sys.stdout.encoding)

@ -32,15 +32,21 @@ def extract_last_archive_dry_run(verbosity, repository, lock_wait=None, local_pa
    if not last_archive_name:
        return

-    list_flag = ('--list',) if verbosity == VERBOSITY_LOTS else ()
+    list_flag = ('--list',) if logger.isEnabledFor(logging.DEBUG) else ()
    full_extract_command = (
-        local_path, 'extract',
-        '--dry-run',
-        '{repository}::{last_archive_name}'.format(
-            repository=repository,
-            last_archive_name=last_archive_name,
-        ),
-    ) + remote_path_flags + lock_wait_flags + verbosity_flags + list_flag
+        (
+            local_path,
+            'extract',
+            '--dry-run',
+            '{repository}::{last_archive_name}'.format(
+                repository=repository, last_archive_name=last_archive_name
+            ),
+        )
+        + remote_path_flags
+        + lock_wait_flags
+        + verbosity_flags
+        + list_flag
+    )

    logger.debug(' '.join(full_extract_command))
    subprocess.check_call(full_extract_command)
--- a/borgmatic/borg/info.py
+++ b/borgmatic/borg/info.py
@ -1,16 +1,15 @@
 import logging
 import subprocess

-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
-

 logger = logging.getLogger(__name__)


-def display_archives_info(verbosity, repository, storage_config, local_path='borg',
-                          remote_path=None):
+def display_archives_info(
+    repository, storage_config, local_path='borg', remote_path=None, json=False
+):
    '''
-    Given a verbosity flag, a local or remote repository path, and a storage config dict,
+    Given a local or remote repository path, and a storage config dict,
    display summary information for Borg archives in the repository.
    '''
    lock_wait = storage_config.get('lock_wait', None)
@ -19,11 +18,12 @@ def display_archives_info(verbosity, repository, storage_config, local_path='bor
        (local_path, 'info', repository)
        + (('--remote-path', remote_path) if remote_path else ())
        + (('--lock-wait', str(lock_wait)) if lock_wait else ())
-        + {
-            VERBOSITY_SOME: ('--info',),
-            VERBOSITY_LOTS: ('--debug',),
-        }.get(verbosity, ())
+        + (('--info',) if logger.getEffectiveLevel() == logging.INFO else ())
+        + (('--debug', '--show-rc') if logger.isEnabledFor(logging.DEBUG) else ())
+        + (('--json',) if json else ())
    )

    logger.debug(' '.join(full_command))
-    subprocess.check_call(full_command)
+
+    output = subprocess.check_output(full_command)
+    return output.decode() if output is not None else None
--- a/borgmatic/borg/list.py
+++ b/borgmatic/borg/list.py
@ -1,15 +1,13 @@
 import logging
 import subprocess

-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
-

 logger = logging.getLogger(__name__)


-def list_archives(verbosity, repository, storage_config, local_path='borg', remote_path=None):
+def list_archives(repository, storage_config, local_path='borg', remote_path=None, json=False):
    '''
-    Given a verbosity flag, a local or remote repository path, and a storage config dict,
+    Given a local or remote repository path, and a storage config dict,
    list Borg archives in the repository.
    '''
    lock_wait = storage_config.get('lock_wait', None)
@ -18,11 +16,11 @@ def list_archives(verbosity, repository, storage_config, local_path='borg', remo
        (local_path, 'list', repository)
        + (('--remote-path', remote_path) if remote_path else ())
        + (('--lock-wait', str(lock_wait)) if lock_wait else ())
-        + {
-            VERBOSITY_SOME: ('--info',),
-            VERBOSITY_LOTS: ('--debug',),
-        }.get(verbosity, ())
+        + (('--info',) if logger.getEffectiveLevel() == logging.INFO else ())
+        + (('--debug', '--show-rc') if logger.isEnabledFor(logging.DEBUG) else ())
+        + (('--json',) if json else ())
    )
-
    logger.debug(' '.join(full_command))
-    subprocess.check_call(full_command)
+
+    output = subprocess.check_output(full_command)
+    return output.decode() if output is not None else None
--- a/borgmatic/borg/prune.py
+++ b/borgmatic/borg/prune.py
@ -1,8 +1,6 @@
 import logging
 import subprocess

-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
-

 logger = logging.getLogger(__name__)

@ -32,10 +30,11 @@ def _make_prune_flags(retention_config):
    )


-def prune_archives(verbosity, dry_run, repository, storage_config, retention_config,
-                   local_path='borg', remote_path=None):
+def prune_archives(
+    dry_run, repository, storage_config, retention_config, local_path='borg', remote_path=None
+):
    '''
-    Given verbosity/dry-run flags, a local or remote repository path, a storage config dict, and a
+    Given dry-run flag, a local or remote repository path, a storage config dict, and a
    retention config dict, prune Borg archives according to the retention policy specified in that
    configuration.
    '''
@ -43,21 +42,14 @@ def prune_archives(verbosity, dry_run, repository, storage_config, retention_con
    lock_wait = storage_config.get('lock_wait', None)

    full_command = (
-        (
-            local_path, 'prune',
-            repository,
-        ) + tuple(
-            element
-            for pair in _make_prune_flags(retention_config)
-            for element in pair
-        )
+        (local_path, 'prune', repository)
+        + tuple(element for pair in _make_prune_flags(retention_config) for element in pair)
        + (('--remote-path', remote_path) if remote_path else ())
        + (('--umask', str(umask)) if umask else ())
        + (('--lock-wait', str(lock_wait)) if lock_wait else ())
-        + {
-            VERBOSITY_SOME: ('--info', '--stats',),
-            VERBOSITY_LOTS: ('--debug', '--stats', '--list'),
-        }.get(verbosity, ())
+        + (('--stats',) if not dry_run and logger.isEnabledFor(logging.INFO) else ())
+        + (('--info',) if logger.getEffectiveLevel() == logging.INFO else ())
+        + (('--debug', '--list', '--show-rc') if logger.isEnabledFor(logging.DEBUG) else ())
        + (('--dry-run',) if dry_run else ())
    )

--- a/borgmatic/commands/borgmatic.py
+++ b/borgmatic/commands/borgmatic.py
@ -1,16 +1,21 @@
-
 from argparse import ArgumentParser
+import json
 import logging
 import os
 from subprocess import CalledProcessError
 import sys

-from borgmatic.borg import check as borg_check, create as borg_create, prune as borg_prune, \
-     list as borg_list, info as borg_info
+from borgmatic.borg import (
+    check as borg_check,
+    create as borg_create,
+    prune as borg_prune,
+    list as borg_list,
+    info as borg_info,
+)
 from borgmatic.commands import hook
 from borgmatic.config import collect, convert, validate
 from borgmatic.signals import configure_signals
-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS, verbosity_to_log_level
+from borgmatic.verbosity import verbosity_to_log_level


 logger = logging.getLogger(__name__)
@ -24,20 +29,24 @@ def parse_arguments(*arguments):
    Given command-line arguments with which this script was invoked, parse the arguments and return
    them as an ArgumentParser instance.
    '''
+    config_paths = collect.get_default_config_paths()
+
    parser = ArgumentParser(
-        description=
-            '''
+        description='''
            A simple wrapper script for the Borg backup software that creates and prunes backups.
            If none of the --prune, --create, or --check options are given, then borgmatic defaults
            to all three: prune, create, and check archives.
            '''
    )
    parser.add_argument(
-        '-c', '--config',
+        '-c',
+        '--config',
        nargs='+',
        dest='config_paths',
-        default=collect.DEFAULT_CONFIG_PATHS,
-        help='Configuration filenames or directories, defaults to: {}'.format(' '.join(collect.DEFAULT_CONFIG_PATHS)),
+        default=config_paths,
+        help='Configuration filenames or directories, defaults to: {}'.format(
+            ' '.join(config_paths)
+        ),
    )
    parser.add_argument(
        '--excludes',
@ -45,49 +54,65 @@ def parse_arguments(*arguments):
        help='Deprecated in favor of exclude_patterns within configuration',
    )
    parser.add_argument(
-        '-p', '--prune',
+        '-p',
+        '--prune',
        dest='prune',
        action='store_true',
        help='Prune archives according to the retention policy',
    )
    parser.add_argument(
-        '-C', '--create',
+        '-C',
+        '--create',
        dest='create',
        action='store_true',
        help='Create archives (actually perform backups)',
    )
    parser.add_argument(
-        '-k', '--check',
-        dest='check',
-        action='store_true',
-        help='Check archives for consistency',
+        '-k', '--check', dest='check', action='store_true', help='Check archives for consistency'
    )
+    parser.add_argument('-l', '--list', dest='list', action='store_true', help='List archives')
    parser.add_argument(
-        '-l', '--list',
-        dest='list',
-        action='store_true',
-        help='List archives',
-    )
-    parser.add_argument(
-        '-i', '--info',
+        '-i',
+        '--info',
        dest='info',
        action='store_true',
        help='Display summary information on archives',
    )
    parser.add_argument(
-        '-n', '--dry-run',
+        '--json',
+        dest='json',
+        default=False,
+        action='store_true',
+        help='Output results from the --create, --list, or --info options as json',
+    )
+    parser.add_argument(
+        '-n',
+        '--dry-run',
        dest='dry_run',
        action='store_true',
        help='Go through the motions, but do not actually write to any repositories',
    )
    parser.add_argument(
-        '-v', '--verbosity',
+        '-v',
+        '--verbosity',
        type=int,
+        choices=range(0, 3),
+        default=0,
        help='Display verbose progress (1 for some, 2 for lots)',
    )

    args = parser.parse_args(arguments)

+    if args.json and not (args.create or args.list or args.info):
+        raise ValueError(
+            'The --json option can only be used with the --create, --list, or --info options'
+        )
+
+    if args.json and args.list and args.info:
+        raise ValueError(
+            'With the --json option, options --list and --info cannot be used together'
+        )
+
    # If any of the action flags are explicitly requested, leave them as-is. Otherwise, assume
    # defaults: Mutate the given arguments to enable the default actions.
    if args.prune or args.create or args.check or args.list or args.info:
@ -115,68 +140,95 @@ def run_configuration(config_filename, args):  # pragma: no cover
        local_path = location.get('local_path', 'borg')
        remote_path = location.get('remote_path')
        borg_create.initialize_environment(storage)
-        hook.execute_hook(hooks.get('before_backup'), config_filename, 'pre-backup')

-        for unexpanded_repository in location['repositories']:
-            repository = os.path.expanduser(unexpanded_repository)
-            dry_run_label = ' (dry run; not making any changes)' if args.dry_run else ''
-            if args.prune:
-                logger.info('{}: Pruning archives{}'.format(repository, dry_run_label))
-                borg_prune.prune_archives(
-                    args.verbosity,
-                    args.dry_run,
-                    repository,
-                    storage,
-                    retention,
-                    local_path=local_path,
-                    remote_path=remote_path,
-                )
-            if args.create:
-                logger.info('{}: Creating archive{}'.format(repository, dry_run_label))
-                borg_create.create_archive(
-                    args.verbosity,
-                    args.dry_run,
-                    repository,
-                    location,
-                    storage,
-                    local_path=local_path,
-                    remote_path=remote_path,
-                )
-            if args.check:
-                logger.info('{}: Running consistency checks'.format(repository))
-                borg_check.check_archives(
-                   args.verbosity,
-                    repository,
-                    storage,
-                    consistency,
-                    local_path=local_path,
-                    remote_path=remote_path,
-                )
-            if args.list:
-                logger.info('{}: Listing archives'.format(repository))
-                borg_list.list_archives(
-                    args.verbosity,
-                    repository,
-                    storage,
-                    local_path=local_path,
-                    remote_path=remote_path,
-                )
-            if args.info:
-                logger.info('{}: Displaying summary info for archives'.format(repository))
-                borg_info.display_archives_info(
-                    args.verbosity,
-                    repository,
-                    storage,
-                    local_path=local_path,
-                    remote_path=remote_path,
-                )
+        if args.create:
+            hook.execute_hook(hooks.get('before_backup'), config_filename, 'pre-backup')

-        hook.execute_hook(hooks.get('after_backup'), config_filename, 'post-backup')
+        _run_commands(args, consistency, local_path, location, remote_path, retention, storage)
+
+        if args.create:
+            hook.execute_hook(hooks.get('after_backup'), config_filename, 'post-backup')
    except (OSError, CalledProcessError):
        hook.execute_hook(hooks.get('on_error'), config_filename, 'on-error')
        raise


+def _run_commands(args, consistency, local_path, location, remote_path, retention, storage):
+    json_results = []
+    for unexpanded_repository in location['repositories']:
+        _run_commands_on_repository(
+            args,
+            consistency,
+            json_results,
+            local_path,
+            location,
+            remote_path,
+            retention,
+            storage,
+            unexpanded_repository,
+        )
+    if args.json:
+        sys.stdout.write(json.dumps(json_results))
+
+
+def _run_commands_on_repository(
+    args,
+    consistency,
+    json_results,
+    local_path,
+    location,
+    remote_path,
+    retention,
+    storage,
+    unexpanded_repository,
+):  # pragma: no cover
+    repository = os.path.expanduser(unexpanded_repository)
+    dry_run_label = ' (dry run; not making any changes)' if args.dry_run else ''
+    if args.prune:
+        logger.info('{}: Pruning archives{}'.format(repository, dry_run_label))
+        borg_prune.prune_archives(
+            args.dry_run,
+            repository,
+            storage,
+            retention,
+            local_path=local_path,
+            remote_path=remote_path,
+        )
+    if args.create:
+        logger.info('{}: Creating archive{}'.format(repository, dry_run_label))
+        borg_create.create_archive(
+            args.dry_run,
+            repository,
+            location,
+            storage,
+            local_path=local_path,
+            remote_path=remote_path,
+        )
+    if args.check:
+        logger.info('{}: Running consistency checks'.format(repository))
+        borg_check.check_archives(
+            repository, storage, consistency, local_path=local_path, remote_path=remote_path
+        )
+    if args.list:
+        logger.info('{}: Listing archives'.format(repository))
+        output = borg_list.list_archives(
+            repository, storage, local_path=local_path, remote_path=remote_path, json=args.json
+        )
+        if args.json:
+            json_results.append(json.loads(output))
+        else:
+            sys.stdout.write(output)
+    if args.info:
+        logger.info('{}: Displaying summary info for archives'.format(repository))
+        output = borg_info.display_archives_info(
+            repository, storage, local_path=local_path, remote_path=remote_path, json=args.json
+        )
+        if args.json:
+            json_results.append(json.loads(output))
+        else:
+            sys.stdout.write(output)
+
+
 def main():  # pragma: no cover
    try:
        configure_signals()
@ -188,7 +240,9 @@ def main():  # pragma: no cover
        convert.guard_configuration_upgraded(LEGACY_CONFIG_PATH, config_filenames)

        if len(config_filenames) == 0:
-            raise ValueError('Error: No configuration files found in: {}'.format(' '.join(args.config_paths)))
+            raise ValueError(
+                'Error: No configuration files found in: {}'.format(' '.join(args.config_paths))
+            )

        for config_filename in config_filenames:
            run_configuration(config_filename, args)
--- a/borgmatic/commands/convert_config.py
+++ b/borgmatic/commands/convert_config.py
@ -1,6 +1,5 @@
 from argparse import ArgumentParser
 import os
-from subprocess import CalledProcessError
 import sys
 import textwrap

@ -26,22 +25,31 @@ def parse_arguments(*arguments):
        '''
    )
    parser.add_argument(
-        '-s', '--source-config',
+        '-s',
+        '--source-config',
        dest='source_config_filename',
        default=DEFAULT_SOURCE_CONFIG_FILENAME,
-        help='Source INI-style configuration filename. Default: {}'.format(DEFAULT_SOURCE_CONFIG_FILENAME),
+        help='Source INI-style configuration filename. Default: {}'.format(
+            DEFAULT_SOURCE_CONFIG_FILENAME
+        ),
    )
    parser.add_argument(
-        '-e', '--source-excludes',
+        '-e',
+        '--source-excludes',
        dest='source_excludes_filename',
-        default=DEFAULT_SOURCE_EXCLUDES_FILENAME if os.path.exists(DEFAULT_SOURCE_EXCLUDES_FILENAME) else None,
+        default=DEFAULT_SOURCE_EXCLUDES_FILENAME
+        if os.path.exists(DEFAULT_SOURCE_EXCLUDES_FILENAME)
+        else None,
        help='Excludes filename',
    )
    parser.add_argument(
-        '-d', '--destination-config',
+        '-d',
+        '--destination-config',
        dest='destination_config_filename',
        default=DEFAULT_DESTINATION_CONFIG_FILENAME,
-        help='Destination YAML configuration filename. Default: {}'.format(DEFAULT_DESTINATION_CONFIG_FILENAME),
+        help='Destination YAML configuration filename. Default: {}'.format(
+            DEFAULT_DESTINATION_CONFIG_FILENAME
+        ),
    )

    return parser.parse_args(arguments)
@ -57,11 +65,13 @@ def display_result(args):  # pragma: no cover
        ),
        TEXT_WRAP_CHARACTERS,
    )
-    
+
    delete_lines = textwrap.wrap(
        'Once you are satisfied, you can safely delete {}{}.'.format(
            args.source_config_filename,
-            ' and {}'.format(args.source_excludes_filename) if args.source_excludes_filename else '',
+            ' and {}'.format(args.source_excludes_filename)
+            if args.source_excludes_filename
+            else '',
        ),
        TEXT_WRAP_CHARACTERS,
    )
@ -75,7 +85,9 @@ def main():  # pragma: no cover
    try:
        args = parse_arguments(*sys.argv[1:])
        schema = yaml.round_trip_load(open(validate.schema_filename()).read())
-        source_config = legacy.parse_configuration(args.source_config_filename, legacy.CONFIG_FORMAT)
+        source_config = legacy.parse_configuration(
+            args.source_config_filename, legacy.CONFIG_FORMAT
+        )
        source_config_file_mode = os.stat(args.source_config_filename).st_mode
        source_excludes = (
            open(args.source_excludes_filename).read().splitlines()
@ -83,12 +95,12 @@ def main():  # pragma: no cover
            else []
        )

-        destination_config = convert.convert_legacy_parsed_config(source_config, source_excludes, schema)
+        destination_config = convert.convert_legacy_parsed_config(
+            source_config, source_excludes, schema
+        )

        generate.write_configuration(
-            args.destination_config_filename,
-            destination_config,
-            mode=source_config_file_mode,
+            args.destination_config_filename, destination_config, mode=source_config_file_mode
        )

        display_result(args)
--- a/borgmatic/commands/generate_config.py
+++ b/borgmatic/commands/generate_config.py
@ -1,9 +1,7 @@
 from argparse import ArgumentParser
-import os
-from subprocess import CalledProcessError
 import sys

-from borgmatic.config import convert, generate, validate
+from borgmatic.config import generate, validate


 DEFAULT_DESTINATION_CONFIG_FILENAME = '/etc/borgmatic/config.yaml'
@ -16,10 +14,13 @@ def parse_arguments(*arguments):
    '''
    parser = ArgumentParser(description='Generate a sample borgmatic YAML configuration file.')
    parser.add_argument(
-        '-d', '--destination',
+        '-d',
+        '--destination',
        dest='destination_filename',
        default=DEFAULT_DESTINATION_CONFIG_FILENAME,
-        help='Destination YAML configuration filename. Default: {}'.format(DEFAULT_DESTINATION_CONFIG_FILENAME),
+        help='Destination YAML configuration filename. Default: {}'.format(
+            DEFAULT_DESTINATION_CONFIG_FILENAME
+        ),
    )

    return parser.parse_args(arguments)
@ -29,7 +30,9 @@ def main():  # pragma: no cover
    try:
        args = parse_arguments(*sys.argv[1:])

-        generate.generate_sample_configuration(args.destination_filename, validate.schema_filename())
+        generate.generate_sample_configuration(
+            args.destination_filename, validate.schema_filename()
+        )

        print('Generated a sample configuration file at {}.'.format(args.destination_filename))
        print()
--- a/borgmatic/commands/hook.py
+++ b/borgmatic/commands/hook.py
@ -13,7 +13,11 @@ def execute_hook(commands, config_filename, description):
    if len(commands) == 1:
        logger.info('{}: Running command for {} hook'.format(config_filename, description))
    else:
-        logger.info('{}: Running {} commands for {} hook'.format(config_filename, len(commands), description))
+        logger.info(
+            '{}: Running {} commands for {} hook'.format(
+                config_filename, len(commands), description
+            )
+        )

    for command in commands:
        logger.debug('{}: Hook command: {}'.format(config_filename, command))
--- a/borgmatic/config/collect.py
+++ b/borgmatic/config/collect.py
@ -1,24 +1,35 @@
 import os


-DEFAULT_CONFIG_PATHS = [
-    '/etc/borgmatic/config.yaml',
-    '/etc/borgmatic.d',
-    os.path.expanduser('~/.config/borgmatic/config.yaml'),
-]
+def get_default_config_paths():
+    '''
+    Based on the value of the XDG_CONFIG_HOME and HOME environment variables, return a list of
+    default configuration paths. This includes both system-wide configuration and configuration in
+    the current user's home directory.
+    '''
+    user_config_directory = os.getenv('XDG_CONFIG_HOME') or os.path.expandvars(
+        os.path.join('$HOME', '.config')
+    )
+
+    return [
+        '/etc/borgmatic/config.yaml',
+        '/etc/borgmatic.d',
+        '%s/borgmatic/config.yaml' % user_config_directory,
+    ]


 def collect_config_filenames(config_paths):
    '''
    Given a sequence of config paths, both filenames and directories, resolve that to just an
    iterable of files. Accomplish this by listing any given directories looking for contained config
-    files. This is non-recursive, so any directories within the given directories are ignored.
+    files (ending with the ".yaml" extension). This is non-recursive, so any directories within the
+    given directories are ignored.

    Return paths even if they don't exist on disk, so the user can find out about missing
    configuration paths. However, skip a default config path if it's missing, so the user doesn't
    have to create a default config path unless they need it.
    '''
-    real_default_config_paths = set(map(os.path.realpath, DEFAULT_CONFIG_PATHS))
+    real_default_config_paths = set(map(os.path.realpath, get_default_config_paths()))

    for path in config_paths:
        exists = os.path.exists(path)
@ -32,5 +43,5 @@ def collect_config_filenames(config_paths):

        for filename in os.listdir(path):
            full_filename = os.path.join(path, filename)
-            if not os.path.isdir(full_filename):
+            if full_filename.endswith('.yaml') and not os.path.isdir(full_filename):
                yield full_filename
--- a/borgmatic/config/convert.py
+++ b/borgmatic/config/convert.py
@ -12,14 +12,17 @@ def _convert_section(source_section_config, section_schema):

    Where integer types exist in the given section schema, convert their values to integers.
    '''
-    destination_section_config = yaml.comments.CommentedMap([
-        (
-            option_name,
-            int(option_value)
-                if section_schema['map'].get(option_name, {}).get('type') == 'int' else option_value
-        )
-        for option_name, option_value in source_section_config.items()
-    ])
+    destination_section_config = yaml.comments.CommentedMap(
+        [
+            (
+                option_name,
+                int(option_value)
+                if section_schema['map'].get(option_name, {}).get('type') == 'int'
+                else option_value,
+            )
+            for option_name, option_value in source_section_config.items()
+        ]
+    )

    return destination_section_config

@ -33,10 +36,12 @@ def convert_legacy_parsed_config(source_config, source_excludes, schema):
    Additionally, use the given schema as a source of helpful comments to include within the
    returned CommentedMap.
    '''
-    destination_config = yaml.comments.CommentedMap([
-        (section_name, _convert_section(section_config, schema['map'][section_name]))
-        for section_name, section_config in source_config._asdict().items()
-    ])
+    destination_config = yaml.comments.CommentedMap(
+        [
+            (section_name, _convert_section(section_config, schema['map'][section_name]))
+            for section_name, section_config in source_config._asdict().items()
+        ]
+    )

    # Split space-seperated values into actual lists, make "repository" into a list, and merge in
    # excludes.
@ -53,9 +58,7 @@ def convert_legacy_parsed_config(source_config, source_excludes, schema):

    for section_name, section_config in destination_config.items():
        generate.add_comments_to_configuration(
-            section_config,
-            schema['map'][section_name],
-            indent=generate.INDENT,
+            section_config, schema['map'][section_name], indent=generate.INDENT
        )

    return destination_config
@ -85,8 +88,7 @@ def guard_configuration_upgraded(source_config_filename, destination_config_file
    The idea is that we want to alert the user about upgrading their config if they haven't already.
    '''
    destination_config_exists = any(
-        os.path.exists(filename)
-        for filename in destination_config_filenames
+        os.path.exists(filename) for filename in destination_config_filenames
    )

    if os.path.exists(source_config_filename) and not destination_config_exists:
@ -107,5 +109,5 @@ Please remove the "--excludes" argument and run borgmatic again.'''


 def guard_excludes_filename_omitted(excludes_filename):
-    if excludes_filename != None:
+    if excludes_filename is not None:
        raise LegacyExcludesFilenamePresent()
--- a/borgmatic/config/generate.py
+++ b/borgmatic/config/generate.py
@ -1,4 +1,3 @@
-from collections import OrderedDict
 import os

 from ruamel import yaml
@ -9,12 +8,11 @@ INDENT = 4

 def _insert_newline_before_comment(config, field_name):
    '''
-    Using some ruamel.yaml black magic, insert a blank line in the config right befor the given
+    Using some ruamel.yaml black magic, insert a blank line in the config right before the given
    field and its comments.
    '''
    config.ca.items[field_name][1].insert(
-        0,
-        yaml.tokens.CommentToken('\n', yaml.error.CommentMark(0), None),
+        0, yaml.tokens.CommentToken('\n', yaml.error.CommentMark(0), None)
    )


@ -27,23 +25,79 @@ def _schema_to_sample_configuration(schema, level=0):
    if example is not None:
        return example

-    config = yaml.comments.CommentedMap([
-        (
-            section_name,
-            _schema_to_sample_configuration(section_schema, level + 1),
-        )
-        for section_name, section_schema in schema['map'].items()
-    ])
+    config = yaml.comments.CommentedMap(
+        [
+            (section_name, _schema_to_sample_configuration(section_schema, level + 1))
+            for section_name, section_schema in schema['map'].items()
+        ]
+    )

    add_comments_to_configuration(config, schema, indent=(level * INDENT))

    return config


-def write_configuration(config_filename, config, mode=0o600):
+def _comment_out_line(line):
+    # If it's already is commented out (or empty), there's nothing further to do!
+    stripped_line = line.lstrip()
+    if not stripped_line or stripped_line.startswith('#'):
+        return line
+
+    # Comment out the names of optional sections.
+    one_indent = ' ' * INDENT
+    if not line.startswith(one_indent):
+        return '#' + line
+
+    # Otherwise, comment out the line, but insert the "#" after the first indent for aesthetics.
+    return '#'.join((one_indent, line[INDENT:]))
+
+
+REQUIRED_KEYS = {'source_directories', 'repositories', 'keep_daily'}
+REQUIRED_SECTION_NAMES = {'location', 'retention'}
+
+
+def _comment_out_optional_configuration(rendered_config):
    '''
-    Given a target config filename and a config data structure of nested OrderedDicts, write out the
-    config to file as YAML. Create any containing directories as needed.
+    Post-process a rendered configuration string to comment out optional key/values. The idea is
+    that this prevents the user from having to comment out a bunch of configuration they don't care
+    about to get to a minimal viable configuration file.
+
+    Ideally ruamel.yaml would support this during configuration generation, but it's not terribly
+    easy to accomplish that way.
+    '''
+    lines = []
+    required = False
+
+    for line in rendered_config.split('\n'):
+        key = line.strip().split(':')[0]
+
+        if key in REQUIRED_SECTION_NAMES:
+            lines.append(line)
+            continue
+
+        # Upon encountering a required configuration option, skip commenting out lines until the
+        # next blank line.
+        if key in REQUIRED_KEYS:
+            required = True
+        elif not key:
+            required = False
+
+        lines.append(_comment_out_line(line) if not required else line)
+
+    return '\n'.join(lines)
+
+
+def _render_configuration(config):
+    '''
+    Given a config data structure of nested OrderedDicts, render the config as YAML and return it.
+    '''
+    return yaml.round_trip_dump(config, indent=INDENT, block_seq_indent=INDENT)
+
+
+def write_configuration(config_filename, rendered_config, mode=0o600):
+    '''
+    Given a target config filename and rendered config YAML, write it out to file. Create any
+    containing directories as needed.
    '''
    if os.path.exists(config_filename):
        raise FileExistsError('{} already exists. Aborting.'.format(config_filename))
@ -54,7 +108,7 @@ def write_configuration(config_filename, config, mode=0o600):
        pass

    with open(config_filename, 'w') as config_file:
-        config_file.write(yaml.round_trip_dump(config, indent=INDENT, block_seq_indent=INDENT))
+        config_file.write(rendered_config)

    os.chmod(config_filename, mode)

@ -73,11 +127,7 @@ def add_comments_to_configuration(config, schema, indent=0):
        if not field_schema or not description:
            continue

-        config.yaml_set_comment_before_after_key(
-            key=field_name,
-            before=description,
-            indent=indent,
-        )
+        config.yaml_set_comment_before_after_key(key=field_name, before=description, indent=indent)
        if index > 0:
            _insert_newline_before_comment(config, field_name)

@ -90,4 +140,6 @@ def generate_sample_configuration(config_filename, schema_filename):
    schema = yaml.round_trip_load(open(schema_filename))
    config = _schema_to_sample_configuration(schema)

-    write_configuration(config_filename, config)
+    write_configuration(
+        config_filename, _comment_out_optional_configuration(_render_configuration(config))
+    )
--- a/borgmatic/config/legacy.py
+++ b/borgmatic/config/legacy.py
@ -45,12 +45,8 @@ CONFIG_FORMAT = (
        ),
    ),
    Section_format(
-        'consistency',
-        (
-            option('checks', required=False),
-            option('check_last', required=False),
-        ),
-    )
+        'consistency', (option('checks', required=False), option('check_last', required=False))
+    ),
 )


@ -66,7 +62,8 @@ def validate_configuration_format(parser, config_format):
    '''
    section_names = set(parser.sections())
    required_section_names = tuple(
-        section.name for section in config_format
+        section.name
+        for section in config_format
        if any(option.required for option in section.options)
    )

@ -80,9 +77,7 @@ def validate_configuration_format(parser, config_format):

    missing_section_names = set(required_section_names) - section_names
    if missing_section_names:
-        raise ValueError(
-            'Missing config sections: {}'.format(', '.join(missing_section_names))
-        )
+        raise ValueError('Missing config sections: {}'.format(', '.join(missing_section_names)))

    for section_format in config_format:
        if section_format.name not in section_names:
@ -91,26 +86,28 @@ def validate_configuration_format(parser, config_format):
        option_names = parser.options(section_format.name)
        expected_options = section_format.options

-        unexpected_option_names = set(option_names) - set(option.name for option in expected_options)
+        unexpected_option_names = set(option_names) - set(
+            option.name for option in expected_options
+        )

        if unexpected_option_names:
            raise ValueError(
                'Unexpected options found in config section {}: {}'.format(
-                    section_format.name,
-                    ', '.join(sorted(unexpected_option_names)),
+                    section_format.name, ', '.join(sorted(unexpected_option_names))
                )
            )

        missing_option_names = tuple(
-            option.name for option in expected_options if option.required
+            option.name
+            for option in expected_options
+            if option.required
            if option.name not in option_names
        )

        if missing_option_names:
            raise ValueError(
                'Required options missing from config section {}: {}'.format(
-                    section_format.name,
-                    ', '.join(missing_option_names)
+                    section_format.name, ', '.join(missing_option_names)
                )
            )

@ -123,11 +120,7 @@ def parse_section_options(parser, section_format):

    Raise ValueError if any option values cannot be coerced to the expected Python data type.
    '''
-    type_getter = {
-        str: parser.get,
-        int: parser.getint,
-        bool: parser.getboolean,
-    }
+    type_getter = {str: parser.get, int: parser.getint, bool: parser.getboolean}

    return OrderedDict(
        (option.name, type_getter[option.value_type](section_format.name, option.name))
@ -151,11 +144,10 @@ def parse_configuration(config_filename, config_format):

    # Describes a parsed configuration, where each attribute is the name of a configuration file
    # section and each value is a dict of that section's parsed options.
-    Parsed_config = namedtuple('Parsed_config', (section_format.name for section_format in config_format))
+    Parsed_config = namedtuple(
+        'Parsed_config', (section_format.name for section_format in config_format)
+    )

    return Parsed_config(
-        *(
-            parse_section_options(parser, section_format)
-            for section_format in config_format
-        )
+        *(parse_section_options(parser, section_format) for section_format in config_format)
    )
--- a/borgmatic/config/schema.yaml
+++ b/borgmatic/config/schema.yaml
@ -18,10 +18,27 @@ map:
                    - /home
                    - /etc
                    - /var/log/syslog*
+            repositories:
+                required: true
+                seq:
+                    - type: scalar
+                desc: |
+                    Paths to local or remote repositories (required). Tildes are expanded. Multiple
+                    repositories are backed up to in sequence. See ssh_command for SSH options like
+                    identity file or port.
+                example:
+                    - user@backupserver:sourcehostname.borg
            one_file_system:
                type: bool
                desc: Stay in same file system (do not cross mount points).
                example: true
+            read_special:
+                type: bool
+                desc: |
+                    Use Borg's --read-special flag to allow backup of block and other special
+                    devices. Use with caution, as it will lead to problems if used when
+                    backing up special devices such as /dev/zero.
+                example: false
            bsd_flags:
                type: bool
                desc: Record bsdflags (e.g. NODUMP, IMMUTABLE) in archive. Defaults to true.
@ -41,16 +58,6 @@ map:
                type: scalar
                desc: Alternate Borg remote executable. Defaults to "borg".
                example: borg1
-            repositories:
-                required: true
-                seq:
-                    - type: scalar
-                desc: |
-                    Paths to local or remote repositories (required). Tildes are expanded. Multiple
-                    repositories are backed up to in sequence. See ssh_command for SSH options like
-                    identity file or port.
-                example:
-                    - user@backupserver:sourcehostname.borg
            patterns:
                seq:
                    - type: scalar
@ -124,6 +131,13 @@ map:
                    punctuation, so it parses correctly. And backslash any quote or backslash
                    literals as well.
                example: "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+            checkpoint_interval:
+                type: int
+                desc: |
+                    Number of seconds between each checkpoint during a long-running backup. See
+                    https://borgbackup.readthedocs.io/en/stable/faq.html#if-a-backup-stops-mid-way-does-the-already-backed-up-data-stay-there
+                    for details. Defaults to checkpoints every 1800 seconds (30 minutes).
+                example: 1800
            compression:
                type: scalar
                desc: |
@ -167,6 +181,10 @@ map:
                type: scalar
                desc: Keep all archives within this time interval.
                example: 3H
+            keep_secondly:
+                type: int
+                desc: Number of secondly archives to keep.
+                example: 60
            keep_minutely:
                type: int
                desc: Number of minutely archives to keep.
--- a/borgmatic/config/validate.py
+++ b/borgmatic/config/validate.py
@ -1,6 +1,4 @@
 import logging
-import sys
-import warnings

 import pkg_resources
 import pykwalify.core
@ -10,6 +8,7 @@ from ruamel import yaml

 logger = logging.getLogger(__name__)

+
 def schema_filename():
    '''
    Path to the installed YAML configuration schema file, used to validate and parse the
@ -23,6 +22,7 @@ class Validation_error(ValueError):
    A collection of error message strings generated when attempting to validate a particular
    configurartion file.
    '''
+
    def __init__(self, config_filename, error_messages):
        self.config_filename = config_filename
        self.error_messages = error_messages
@ -47,15 +47,16 @@ def apply_logical_validation(config_filename, parsed_configuration):

    if archive_name_format and not prefix:
        raise Validation_error(
-            config_filename, (
-                'If you provide an archive_name_format, you must also specify a retention prefix.',
-            )
+            config_filename,
+            ('If you provide an archive_name_format, you must also specify a retention prefix.',),
        )

    consistency_prefix = parsed_configuration.get('consistency', {}).get('prefix')
    if archive_name_format and not consistency_prefix:
-        logger.warning('Since version 1.1.16, if you provide `archive_name_format`, you should also'
-                       ' specify `consistency.prefix`.')
+        logger.warning(
+            'Since version 1.1.16, if you provide `archive_name_format`, you should also'
+            ' specify `consistency.prefix`.'
+        )


 def parse_configuration(config_filename, schema_filename):
@ -73,8 +74,8 @@ def parse_configuration(config_filename, schema_filename):
    logging.getLogger('pykwalify').setLevel(logging.ERROR)

    try:
-        config = yaml.round_trip_load(open(config_filename))
-        schema = yaml.round_trip_load(open(schema_filename))
+        config = yaml.safe_load(open(config_filename))
+        schema = yaml.safe_load(open(schema_filename))
    except yaml.error.YAMLError as error:
        raise Validation_error(config_filename, (str(error),))

--- a/borgmatic/tests/integration/commands/test_borgmatic.py
+++ b/borgmatic/tests/integration/commands/test_borgmatic.py
@ -1,66 +0,0 @@
-import os
-
-from flexmock import flexmock
-import pytest
-
-from borgmatic.commands import borgmatic as module
-
-
-def test_parse_arguments_with_no_arguments_uses_defaults():
-    parser = module.parse_arguments()
-
-    assert parser.config_paths == module.collect.DEFAULT_CONFIG_PATHS
-    assert parser.excludes_filename == None
-    assert parser.verbosity is None
-
-
-def test_parse_arguments_with_path_arguments_overrides_defaults():
-    parser = module.parse_arguments('--config', 'myconfig', '--excludes', 'myexcludes')
-
-    assert parser.config_paths == ['myconfig']
-    assert parser.excludes_filename == 'myexcludes'
-    assert parser.verbosity is None
-
-
-def test_parse_arguments_with_multiple_config_paths_parses_as_list():
-    parser = module.parse_arguments('--config', 'myconfig', 'otherconfig')
-
-    assert parser.config_paths == ['myconfig', 'otherconfig']
-    assert parser.verbosity is None
-
-
-def test_parse_arguments_with_verbosity_flag_overrides_default():
-    parser = module.parse_arguments('--verbosity', '1')
-
-    assert parser.config_paths == module.collect.DEFAULT_CONFIG_PATHS
-    assert parser.excludes_filename == None
-    assert parser.verbosity == 1
-
-
-def test_parse_arguments_with_no_actions_defaults_to_all_actions_enabled():
-    parser = module.parse_arguments()
-
-    assert parser.prune is True
-    assert parser.create is True
-    assert parser.check is True
-
-
-def test_parse_arguments_with_prune_action_leaves_other_actions_disabled():
-    parser = module.parse_arguments('--prune')
-
-    assert parser.prune is True
-    assert parser.create is False
-    assert parser.check is False
-
-
-def test_parse_arguments_with_multiple_actions_leaves_other_action_disabled():
-    parser = module.parse_arguments('--create', '--check')
-
-    assert parser.prune is False
-    assert parser.create is True
-    assert parser.check is True
-
-
-def test_parse_arguments_with_invalid_arguments_exits():
-    with pytest.raises(SystemExit):
-        module.parse_arguments('--posix-me-harder')
--- a/borgmatic/tests/unit/borg/test_info.py
+++ b/borgmatic/tests/unit/borg/test_info.py
@ -1,77 +0,0 @@
-from collections import OrderedDict
-
-from flexmock import flexmock
-
-from borgmatic.borg import info as module
-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
-
-
-def insert_subprocess_mock(check_call_command, **kwargs):
-    subprocess = flexmock(module.subprocess)
-    subprocess.should_receive('check_call').with_args(check_call_command, **kwargs).once()
-
-
-INFO_COMMAND = ('borg', 'info', 'repo')
-
-
-def test_display_archives_info_calls_borg_with_parameters():
-    insert_subprocess_mock(INFO_COMMAND)
-
-    module.display_archives_info(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-    )
-
-
-def test_display_archives_info_with_verbosity_some_calls_borg_with_info_parameter():
-    insert_subprocess_mock(INFO_COMMAND + ('--info',))
-
-    module.display_archives_info(
-        repository='repo',
-        storage_config={},
-        verbosity=VERBOSITY_SOME,
-    )
-
-
-def test_display_archives_info_with_verbosity_lots_calls_borg_with_debug_parameter():
-    insert_subprocess_mock(INFO_COMMAND + ('--debug',))
-
-    module.display_archives_info(
-        repository='repo',
-        storage_config={},
-        verbosity=VERBOSITY_LOTS,
-    )
-
-
-def test_display_archives_info_with_local_path_calls_borg_via_local_path():
-    insert_subprocess_mock(('borg1',) + INFO_COMMAND[1:])
-
-    module.display_archives_info(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-        local_path='borg1',
-    )
-
-
-def test_display_archives_info_with_remote_path_calls_borg_with_remote_path_parameters():
-    insert_subprocess_mock(INFO_COMMAND + ('--remote-path', 'borg1'))
-
-    module.display_archives_info(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-        remote_path='borg1',
-    )
-
-
-def test_display_archives_info_with_lock_wait_calls_borg_with_lock_wait_parameters():
-    storage_config = {'lock_wait': 5}
-    insert_subprocess_mock(INFO_COMMAND + ('--lock-wait', '5'))
-
-    module.display_archives_info(
-        verbosity=None,
-        repository='repo',
-        storage_config=storage_config,
-    )
--- a/borgmatic/tests/unit/borg/test_list.py
+++ b/borgmatic/tests/unit/borg/test_list.py
@ -1,77 +0,0 @@
-from collections import OrderedDict
-
-from flexmock import flexmock
-
-from borgmatic.borg import list as module
-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
-
-
-def insert_subprocess_mock(check_call_command, **kwargs):
-    subprocess = flexmock(module.subprocess)
-    subprocess.should_receive('check_call').with_args(check_call_command, **kwargs).once()
-
-
-LIST_COMMAND = ('borg', 'list', 'repo')
-
-
-def test_list_archives_calls_borg_with_parameters():
-    insert_subprocess_mock(LIST_COMMAND)
-
-    module.list_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-    )
-
-
-def test_list_archives_with_verbosity_some_calls_borg_with_info_parameter():
-    insert_subprocess_mock(LIST_COMMAND + ('--info',))
-
-    module.list_archives(
-        repository='repo',
-        storage_config={},
-        verbosity=VERBOSITY_SOME,
-    )
-
-
-def test_list_archives_with_verbosity_lots_calls_borg_with_debug_parameter():
-    insert_subprocess_mock(LIST_COMMAND + ('--debug',))
-
-    module.list_archives(
-        repository='repo',
-        storage_config={},
-        verbosity=VERBOSITY_LOTS,
-    )
-
-
-def test_list_archives_with_local_path_calls_borg_via_local_path():
-    insert_subprocess_mock(('borg1',) + LIST_COMMAND[1:])
-
-    module.list_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-        local_path='borg1',
-    )
-
-
-def test_list_archives_with_remote_path_calls_borg_with_remote_path_parameters():
-    insert_subprocess_mock(LIST_COMMAND + ('--remote-path', 'borg1'))
-
-    module.list_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-        remote_path='borg1',
-    )
-
-
-def test_list_archives_with_lock_wait_calls_borg_with_lock_wait_parameters():
-    storage_config = {'lock_wait': 5}
-    insert_subprocess_mock(LIST_COMMAND + ('--lock-wait', '5'))
-
-    module.list_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config=storage_config,
-    )
--- a/borgmatic/tests/unit/config/test_generate.py
+++ b/borgmatic/tests/unit/config/test_generate.py
@ -1,49 +0,0 @@
-from collections import OrderedDict
-
-from flexmock import flexmock
-
-from borgmatic.config import generate as module
-
-
-def test_schema_to_sample_configuration_generates_config_with_examples():
-    flexmock(module.yaml.comments).should_receive('CommentedMap').replace_with(OrderedDict)
-    flexmock(module).should_receive('add_comments_to_configuration')
-    schema = {
-        'map': OrderedDict([
-            (
-                'section1', {
-                    'map': {
-                        'field1': OrderedDict([
-                            ('example', 'Example 1')
-                        ]),
-                    },
-                },
-            ),
-            (
-                'section2', {
-                    'map': OrderedDict([
-                        ('field2', {'example': 'Example 2'}),
-                        ('field3', {'example': 'Example 3'}),
-                    ]),
-                }
-            ),
-        ])
-    }
-
-    config = module._schema_to_sample_configuration(schema)
-
-    assert config == OrderedDict([
-        (
-            'section1',
-            OrderedDict([
-                ('field1', 'Example 1'),
-            ]),
-        ),
-        (
-            'section2',
-            OrderedDict([
-                ('field2', 'Example 2'),
-                ('field3', 'Example 3'),
-            ]),
-        )
-    ])
--- a/borgmatic/tests/unit/test_verbosity.py
+++ b/borgmatic/tests/unit/test_verbosity.py
@ -1,11 +0,0 @@
-import logging
-
-from borgmatic import verbosity as module
-
-
-def test_verbosity_to_log_level_maps_known_verbosity_to_log_level():
-    assert module.verbosity_to_log_level(module.VERBOSITY_SOME) == logging.INFO
-
-
-def test_verbosity_to_log_level_maps_unknown_verbosity_to_warning_level():
-    assert module.verbosity_to_log_level('my pants') == logging.WARNING
--- a/borgmatic/verbosity.py
+++ b/borgmatic/verbosity.py
@ -1,6 +1,7 @@
 import logging


+VERBOSITY_WARNING = 0
 VERBOSITY_SOME = 1
 VERBOSITY_LOTS = 2

@ -10,6 +11,7 @@ def verbosity_to_log_level(verbosity):
    Given a borgmatic verbosity value, return the corresponding Python log level.
    '''
    return {
+        VERBOSITY_WARNING: logging.WARNING,
        VERBOSITY_SOME: logging.INFO,
        VERBOSITY_LOTS: logging.DEBUG,
    }.get(verbosity, logging.WARNING)
--- a/sample/cron-alpine/borgmatic
+++ b/sample/cron-alpine/borgmatic
@ -0,0 +1,3 @@
+# You can drop this file into /etc/cron.d/ to run borgmatic nightly.
+
+0 3 * * * PATH=$PATH:/usr/bin /usr/bin/borgmatic
--- a/scripts/find-unsupported-borg-options
+++ b/scripts/find-unsupported-borg-options
@ -6,8 +6,10 @@ set -o nounset
 # appear to support yet. This script isn't terribly robust. It's intended as a basic tool to ferret
 # out unsupported Borg options so that they can be considered for addition to borgmatic.

-# Generate a sample borgmatic configuration with all options set.
+# Generate a sample borgmatic configuration with all options set, and uncomment all options.
 generate-borgmatic-config --destination temp.yaml
+cat temp.yaml | sed -e 's/# \S.*$//' | sed -e 's/#//' > temp.yaml.uncommented
+mv temp.yaml.uncommented temp.yaml

 # For each sub-command (prune, create, and check), collect the Borg command-line flags that result
 # from running borgmatic with the generated configuration. Then, collect the full set of available
@ -22,22 +24,32 @@ for sub_command in prune create check list info; do
    sort borgmatic_borg_flags > borgmatic_borg_flags.sorted
    mv borgmatic_borg_flags.sorted borgmatic_borg_flags

-    for line in $(borg $sub_command --help | awk -v RS= '/^usage:/') ; do
+    for word in $(borg $sub_command --help | grep '^  -') ; do
        # Exclude a bunch of flags that borgmatic actually supports, but don't get exercised by the
        # generated sample config, and also flags that don't make sense to support.
-        echo "$line" | grep -- -- | sed -r 's/(\[|\])//g' \
-            | grep -v '^-h$' \
+        echo "$word" | grep ^-- | sed -e 's/,$//' \
            | grep -v '^--archives-only$' \
-            | grep -v '^--repository-only$' \
-            | grep -v '^--stats$' \
-            | grep -v '^--list$' \
            | grep -v '^--critical$' \
-            | grep -v '^--error$' \
-            | grep -v '^--warning$' \
-            | grep -v '^--info$' \
            | grep -v '^--debug$' \
+            | grep -v '^--dry-run$' \
+            | grep -v '^--error$' \
+            | grep -v '^--help$' \
+            | grep -v '^--info$' \
+            | grep -v '^--json$' \
+            | grep -v '^--keep-last$' \
+            | grep -v '^--list$' \
+            | grep -v '^--nobsdflags$' \
+            | grep -v '^--pattern$' \
+            | grep -v '^--read-special$' \
+            | grep -v '^--repository-only$' \
+            | grep -v '^--show-rc$' \
+            | grep -v '^--stats$' \
+            | grep -v '^--verbose$' \
+            | grep -v '^--warning$' \
+            | grep -v '^-h$' \
            >> all_borg_flags
    done
+
    sort all_borg_flags > all_borg_flags.sorted
    mv all_borg_flags.sorted all_borg_flags

--- a/setup.py
+++ b/setup.py
@ -1,7 +1,7 @@
 from setuptools import setup, find_packages


-VERSION = '1.2.0'
+VERSION = '1.2.7'


 setup(
@ -28,17 +28,8 @@ setup(
            'generate-borgmatic-config = borgmatic.commands.generate_config:main',
        ]
    },
-    obsoletes=[
-        'atticmatic',
-    ],
-    install_requires=(
-        'pykwalify>=1.6.0',
-        'ruamel.yaml<=0.15',
-        'setuptools',
-    ),
-    tests_require=(
-        'flexmock',
-        'pytest',
-    ),
+    obsoletes=['atticmatic'],
+    install_requires=('pykwalify>=1.6.0,<14.06', 'ruamel.yaml>0.15.0,<0.16.0', 'setuptools'),
+    tests_require=('flexmock', 'pytest'),
    include_package_data=True,
 )
--- a/test_requirements.txt
+++ b/test_requirements.txt
@ -1,5 +1,7 @@
+black==18.9b0
+flake8==3.5.0
 flexmock==0.10.2
-pykwalify==1.6.0
-pytest==2.9.1
-pytest-cov==2.5.1
-ruamel.yaml==0.15.18
+pykwalify==1.7.0
+pytest==3.8.1
+pytest-cov==2.6.0
+ruamel.yaml>0.15.0,<0.16.0
--- a/borgmatic/tests/init.py
+++ b/borgmatic/tests/init.py
--- a/borgmatic/tests/integration/init.py
+++ b/borgmatic/tests/integration/init.py
--- a/tests/end-to-end/test_borgmatic.py
+++ b/tests/end-to-end/test_borgmatic.py
@ -0,0 +1,53 @@
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+
+def generate_configuration(config_path, repository_path):
+    '''
+    Generate borgmatic configuration into a file at the config path, and update the defaults so as
+    to work for testing (including injecting the given repository path).
+    '''
+    subprocess.check_call(f'generate-borgmatic-config --destination {config_path}'.split(' '))
+    config = (
+        open(config_path)
+        .read()
+        .replace('user@backupserver:sourcehostname.borg', repository_path)
+        .replace('- /home', f'- {config_path}')
+        .replace('- /etc', '')
+        .replace('- /var/log/syslog*', '')
+    )
+    config_file = open(config_path, 'w')
+    config_file.write(config)
+    config_file.close()
+
+
+def test_borgmatic_command():
+    # Create a Borg repository.
+    temporary_directory = tempfile.mkdtemp()
+    repository_path = os.path.join(temporary_directory, 'test.borg')
+
+    try:
+        subprocess.check_call(
+            f'borg init --encryption repokey {repository_path}'.split(' '),
+            env={'BORG_PASSPHRASE': '', **os.environ},
+        )
+
+        config_path = os.path.join(temporary_directory, 'test.yaml')
+        generate_configuration(config_path, repository_path)
+
+        # Run borgmatic to generate a backup archive, and then list it to make sure it exists.
+        subprocess.check_call(f'borgmatic --config {config_path}'.split(' '))
+        output = subprocess.check_output(
+            f'borgmatic --config {config_path} --list --json'.split(' '),
+            encoding=sys.stdout.encoding,
+        )
+        parsed_output = json.loads(output)
+
+        assert len(parsed_output) == 1
+        assert len(parsed_output[0]['archives']) == 1
+    finally:
+        shutil.rmtree(temporary_directory)
--- a/borgmatic/tests/integration/commands/init.py
+++ b/borgmatic/tests/integration/commands/init.py
--- a/borgmatic/tests/integration/config/init.py
+++ b/borgmatic/tests/integration/config/init.py
--- a/tests/integration/commands/test_borgmatic.py
+++ b/tests/integration/commands/test_borgmatic.py
@ -0,0 +1,103 @@
+from flexmock import flexmock
+import pytest
+
+from borgmatic.commands import borgmatic as module
+
+
+def test_parse_arguments_with_no_arguments_uses_defaults():
+    config_paths = ['default']
+    flexmock(module.collect).should_receive('get_default_config_paths').and_return(config_paths)
+
+    parser = module.parse_arguments()
+
+    assert parser.config_paths == config_paths
+    assert parser.excludes_filename is None
+    assert parser.verbosity is 0
+    assert parser.json is False
+
+
+def test_parse_arguments_with_path_arguments_overrides_defaults():
+    flexmock(module.collect).should_receive('get_default_config_paths').and_return(['default'])
+
+    parser = module.parse_arguments('--config', 'myconfig', '--excludes', 'myexcludes')
+
+    assert parser.config_paths == ['myconfig']
+    assert parser.excludes_filename == 'myexcludes'
+    assert parser.verbosity is 0
+
+
+def test_parse_arguments_with_multiple_config_paths_parses_as_list():
+    flexmock(module.collect).should_receive('get_default_config_paths').and_return(['default'])
+
+    parser = module.parse_arguments('--config', 'myconfig', 'otherconfig')
+
+    assert parser.config_paths == ['myconfig', 'otherconfig']
+    assert parser.verbosity is 0
+
+
+def test_parse_arguments_with_verbosity_flag_overrides_default():
+    config_paths = ['default']
+    flexmock(module.collect).should_receive('get_default_config_paths').and_return(config_paths)
+
+    parser = module.parse_arguments('--verbosity', '1')
+
+    assert parser.config_paths == config_paths
+    assert parser.excludes_filename is None
+    assert parser.verbosity == 1
+
+
+def test_parse_arguments_with_json_flag_overrides_default():
+    parser = module.parse_arguments('--list', '--json')
+    assert parser.json is True
+
+
+def test_parse_arguments_with_no_actions_defaults_to_all_actions_enabled():
+    flexmock(module.collect).should_receive('get_default_config_paths').and_return(['default'])
+
+    parser = module.parse_arguments()
+
+    assert parser.prune is True
+    assert parser.create is True
+    assert parser.check is True
+
+
+def test_parse_arguments_with_prune_action_leaves_other_actions_disabled():
+    flexmock(module.collect).should_receive('get_default_config_paths').and_return(['default'])
+
+    parser = module.parse_arguments('--prune')
+
+    assert parser.prune is True
+    assert parser.create is False
+    assert parser.check is False
+
+
+def test_parse_arguments_with_multiple_actions_leaves_other_action_disabled():
+    flexmock(module.collect).should_receive('get_default_config_paths').and_return(['default'])
+
+    parser = module.parse_arguments('--create', '--check')
+
+    assert parser.prune is False
+    assert parser.create is True
+    assert parser.check is True
+
+
+def test_parse_arguments_with_invalid_arguments_exits():
+    flexmock(module.collect).should_receive('get_default_config_paths').and_return(['default'])
+
+    with pytest.raises(SystemExit):
+        module.parse_arguments('--posix-me-harder')
+
+
+def test_parse_arguments_with_json_flag_with_list_or_info_flag_does_not_raise_any_error():
+    module.parse_arguments('--list', '--json')
+    module.parse_arguments('--info', '--json')
+
+
+def test_parse_arguments_with_json_flag_but_no_list_or_info_flag_raises_value_error():
+    with pytest.raises(ValueError):
+        module.parse_arguments('--json')
+
+
+def test_parse_arguments_with_json_flag_and_both_list_and_info_flag_raises_value_error():
+    with pytest.raises(ValueError):
+        module.parse_arguments('--list', '--info', '--json')
--- a/borgmatic/tests/integration/commands/test_convert_config.py
+++ b/borgmatic/tests/integration/commands/test_convert_config.py
@ -20,9 +20,12 @@ def test_parse_arguments_with_filename_arguments_overrides_defaults():
    flexmock(os.path).should_receive('exists').and_return(True)

    parser = module.parse_arguments(
-        '--source-config', 'config',
-        '--source-excludes', 'excludes',
-        '--destination-config', 'config.yaml',
+        '--source-config',
+        'config',
+        '--source-excludes',
+        'excludes',
+        '--destination-config',
+        'config.yaml',
    )

    assert parser.source_config_filename == 'config'
--- a/borgmatic/tests/integration/commands/test_generate_config.py
+++ b/borgmatic/tests/integration/commands/test_generate_config.py
@ -6,6 +6,7 @@ def test_parse_arguments_with_no_arguments_uses_defaults():

    assert parser.destination_filename == module.DEFAULT_DESTINATION_CONFIG_FILENAME

+
 def test_parse_arguments_with_filename_argument_overrides_defaults():
    parser = module.parse_arguments('--destination', 'config.yaml')

--- a/tests/integration/config/init.py
+++ b/tests/integration/config/init.py
--- a/borgmatic/tests/integration/config/test_generate.py
+++ b/borgmatic/tests/integration/config/test_generate.py
@ -11,11 +11,74 @@ from borgmatic.config import generate as module
 def test_insert_newline_before_comment_does_not_raise():
    field_name = 'foo'
    config = module.yaml.comments.CommentedMap([(field_name, 33)])
-    config.yaml_set_comment_before_after_key(key=field_name, before='Comment',)
+    config.yaml_set_comment_before_after_key(key=field_name, before='Comment')

    module._insert_newline_before_comment(config, field_name)


+def test_comment_out_line_skips_blank_line():
+    line = '    \n'
+
+    assert module._comment_out_line(line) == line
+
+
+def test_comment_out_line_skips_already_commented_out_line():
+    line = '    # foo'
+
+    assert module._comment_out_line(line) == line
+
+
+def test_comment_out_line_comments_section_name():
+    line = 'figgy-pudding:'
+
+    assert module._comment_out_line(line) == '#' + line
+
+
+def test_comment_out_line_comments_indented_option():
+    line = '    enabled: true'
+
+    assert module._comment_out_line(line) == '    #enabled: true'
+
+
+def test_comment_out_optional_configuration_comments_optional_config_only():
+    flexmock(module)._comment_out_line = lambda line: '#' + line
+    config = '''
+foo:
+    bar:
+        - baz
+        - quux
+
+location:
+    repositories:
+        - one
+        - two
+
+    other: thing
+    '''
+
+    expected_config = '''
+#foo:
+#    bar:
+#        - baz
+#        - quux
+#
+location:
+    repositories:
+        - one
+        - two
+#
+#    other: thing
+    '''
+
+    assert module._comment_out_optional_configuration(config.strip()) == expected_config.strip()
+
+
+def test_render_configuration_does_not_raise():
+    flexmock(module.yaml).should_receive('round_trip_dump')
+
+    module._render_configuration({})
+
+
 def test_write_configuration_does_not_raise():
    flexmock(os.path).should_receive('exists').and_return(False)
    flexmock(os).should_receive('makedirs')
@ -23,14 +86,14 @@ def test_write_configuration_does_not_raise():
    builtins.should_receive('open').and_return(StringIO())
    flexmock(os).should_receive('chmod')

-    module.write_configuration('config.yaml', {})
+    module.write_configuration('config.yaml', 'config: yaml')


 def test_write_configuration_with_already_existing_file_raises():
    flexmock(os.path).should_receive('exists').and_return(True)

    with pytest.raises(FileExistsError):
-        module.write_configuration('config.yaml', {})
+        module.write_configuration('config.yaml', 'config: yaml')


 def test_write_configuration_with_already_existing_directory_does_not_raise():
@ -40,18 +103,13 @@ def test_write_configuration_with_already_existing_directory_does_not_raise():
    builtins.should_receive('open').and_return(StringIO())
    flexmock(os).should_receive('chmod')

-    module.write_configuration('config.yaml', {})
+    module.write_configuration('config.yaml', 'config: yaml')


 def test_add_comments_to_configuration_does_not_raise():
    # Ensure that it can deal with fields both in the schema and missing from the schema.
    config = module.yaml.comments.CommentedMap([('foo', 33), ('bar', 44), ('baz', 55)])
-    schema = {
-        'map': {
-            'foo': {'desc': 'Foo'},
-            'bar': {'desc': 'Bar'},
-        }
-    }
+    schema = {'map': {'foo': {'desc': 'Foo'}, 'bar': {'desc': 'Bar'}}}

    module.add_comments_to_configuration(config, schema)

@ -59,7 +117,9 @@ def test_add_comments_to_configuration_does_not_raise():
 def test_generate_sample_configuration_does_not_raise():
    builtins = flexmock(sys.modules['builtins'])
    builtins.should_receive('open').with_args('schema.yaml').and_return('')
-    flexmock(module).should_receive('write_configuration')
    flexmock(module).should_receive('_schema_to_sample_configuration')
+    flexmock(module).should_receive('_render_configuration')
+    flexmock(module).should_receive('_comment_out_optional_configuration')
+    flexmock(module).should_receive('write_configuration')

    module.generate_sample_configuration('config.yaml', 'schema.yaml')
--- a/borgmatic/tests/integration/config/test_legacy.py
+++ b/borgmatic/tests/integration/config/test_legacy.py
@ -8,17 +8,12 @@ from borgmatic.config import legacy as module

 def test_parse_section_options_with_punctuation_should_return_section_options():
    parser = module.RawConfigParser()
-    parser.readfp(StringIO('[section]\nfoo: {}\n'.format(string.punctuation)))
+    parser.read_file(StringIO('[section]\nfoo: {}\n'.format(string.punctuation)))

    section_format = module.Section_format(
-        'section',
-        (module.Config_option('foo', str, required=True),),
+        'section', (module.Config_option('foo', str, required=True),)
    )

    config = module.parse_section_options(parser, section_format)

-    assert config == OrderedDict(
-        (
-            ('foo', string.punctuation),
-        )
-    )
+    assert config == OrderedDict((('foo', string.punctuation),))
--- a/borgmatic/tests/integration/config/test_validate.py
+++ b/borgmatic/tests/integration/config/test_validate.py
@ -1,7 +1,6 @@
 import io
 import string
 import sys
-import os

 from flexmock import flexmock
 import pytest
@ -10,7 +9,7 @@ from borgmatic.config import validate as module


 def test_schema_filename_returns_plausable_path():
-    schema_path = module.schema_filename()    
+    schema_path = module.schema_filename()

    assert schema_path.endswith('/schema.yaml')

@ -75,7 +74,9 @@ def test_parse_configuration_passes_through_quoted_punctuation():

            repositories:
                - "{}.borg"
-        '''.format(escaped_punctuation)
+        '''.format(
+            escaped_punctuation
+        )
    )

    result = module.parse_configuration('config.yaml', 'schema.yaml')
@ -84,7 +85,7 @@ def test_parse_configuration_passes_through_quoted_punctuation():
        'location': {
            'source_directories': ['/home'],
            'repositories': ['{}.borg'.format(string.punctuation)],
-        },
+        }
    }


@ -111,7 +112,7 @@ def test_parse_configuration_with_schema_lacking_examples_does_not_raise():
                        required: true
                        seq:
                            - type: scalar
-        '''
+        ''',
    )

    module.parse_configuration('config.yaml', 'schema.yaml')
--- a/borgmatic/tests/integration/test_version.py
+++ b/borgmatic/tests/integration/test_version.py
--- a/borgmatic/tests/unit/borg/init.py
+++ b/borgmatic/tests/unit/borg/init.py
--- a/borgmatic/tests/unit/config/init.py
+++ b/borgmatic/tests/unit/config/init.py
--- a/borgmatic/tests/unit/borg/test_check.py
+++ b/borgmatic/tests/unit/borg/test_check.py
@ -1,11 +1,12 @@
 from subprocess import STDOUT
+import logging
 import sys

 from flexmock import flexmock
 import pytest

 from borgmatic.borg import check as module
-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
+from ..test_verbosity import insert_logging_mock


 def insert_subprocess_mock(check_call_command, **kwargs):
@ -115,20 +116,16 @@ def test_check_archives_calls_borg_with_parameters(checks):
    check_last = flexmock()
    consistency_config = {'check_last': check_last}
    flexmock(module).should_receive('_parse_checks').and_return(checks)
-    flexmock(module).should_receive('_make_check_flags').with_args(checks, check_last, None).and_return(())
+    flexmock(module).should_receive('_make_check_flags').with_args(
+        checks, check_last, None
+    ).and_return(())
    stdout = flexmock()
-    insert_subprocess_mock(
-        ('borg', 'check', 'repo'),
-        stdout=stdout, stderr=STDOUT,
-    )
+    insert_subprocess_mock(('borg', 'check', 'repo'), stdout=stdout, stderr=STDOUT)
    flexmock(sys.modules['builtins']).should_receive('open').and_return(stdout)
    flexmock(module.os).should_receive('devnull')

    module.check_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-        consistency_config=consistency_config,
+        repository='repo', storage_config={}, consistency_config=consistency_config
    )


@ -142,46 +139,35 @@ def test_check_archives_with_extract_check_calls_extract_only():
    insert_subprocess_never()

    module.check_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-        consistency_config=consistency_config,
+        repository='repo', storage_config={}, consistency_config=consistency_config
    )


-def test_check_archives_with_verbosity_some_calls_borg_with_info_parameter():
+def test_check_archives_with_log_info_calls_borg_with_info_parameter():
    checks = ('repository',)
    consistency_config = {'check_last': None}
    flexmock(module).should_receive('_parse_checks').and_return(checks)
    flexmock(module).should_receive('_make_check_flags').and_return(())
-    insert_subprocess_mock(
-        ('borg', 'check', 'repo', '--info'),
-        stdout=None, stderr=STDOUT,
-    )
+    insert_logging_mock(logging.INFO)
+    insert_subprocess_mock(('borg', 'check', 'repo', '--info'), stdout=None, stderr=STDOUT)

    module.check_archives(
-        verbosity=VERBOSITY_SOME,
-        repository='repo',
-        storage_config={},
-        consistency_config=consistency_config,
+        repository='repo', storage_config={}, consistency_config=consistency_config
    )


-def test_check_archives_with_verbosity_lots_calls_borg_with_debug_parameter():
+def test_check_archives_with_log_debug_calls_borg_with_debug_parameter():
    checks = ('repository',)
    consistency_config = {'check_last': None}
    flexmock(module).should_receive('_parse_checks').and_return(checks)
    flexmock(module).should_receive('_make_check_flags').and_return(())
+    insert_logging_mock(logging.DEBUG)
    insert_subprocess_mock(
-        ('borg', 'check', 'repo', '--debug'),
-        stdout=None, stderr=STDOUT,
+        ('borg', 'check', 'repo', '--debug', '--show-rc'), stdout=None, stderr=STDOUT
    )

    module.check_archives(
-        verbosity=VERBOSITY_LOTS,
-        repository='repo',
-        storage_config={},
-        consistency_config=consistency_config,
+        repository='repo', storage_config={}, consistency_config=consistency_config
    )


@ -191,10 +177,7 @@ def test_check_archives_without_any_checks_bails():
    insert_subprocess_never()

    module.check_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-        consistency_config=consistency_config,
+        repository='repo', storage_config={}, consistency_config=consistency_config
    )


@ -203,17 +186,15 @@ def test_check_archives_with_local_path_calls_borg_via_local_path():
    check_last = flexmock()
    consistency_config = {'check_last': check_last}
    flexmock(module).should_receive('_parse_checks').and_return(checks)
-    flexmock(module).should_receive('_make_check_flags').with_args(checks, check_last, None).and_return(())
+    flexmock(module).should_receive('_make_check_flags').with_args(
+        checks, check_last, None
+    ).and_return(())
    stdout = flexmock()
-    insert_subprocess_mock(
-        ('borg1', 'check', 'repo'),
-        stdout=stdout, stderr=STDOUT,
-    )
+    insert_subprocess_mock(('borg1', 'check', 'repo'), stdout=stdout, stderr=STDOUT)
    flexmock(sys.modules['builtins']).should_receive('open').and_return(stdout)
    flexmock(module.os).should_receive('devnull')

    module.check_archives(
-        verbosity=None,
        repository='repo',
        storage_config={},
        consistency_config=consistency_config,
@ -226,17 +207,17 @@ def test_check_archives_with_remote_path_calls_borg_with_remote_path_parameters(
    check_last = flexmock()
    consistency_config = {'check_last': check_last}
    flexmock(module).should_receive('_parse_checks').and_return(checks)
-    flexmock(module).should_receive('_make_check_flags').with_args(checks, check_last, None).and_return(())
+    flexmock(module).should_receive('_make_check_flags').with_args(
+        checks, check_last, None
+    ).and_return(())
    stdout = flexmock()
    insert_subprocess_mock(
-        ('borg', 'check', 'repo', '--remote-path', 'borg1'),
-        stdout=stdout, stderr=STDOUT,
+        ('borg', 'check', 'repo', '--remote-path', 'borg1'), stdout=stdout, stderr=STDOUT
    )
    flexmock(sys.modules['builtins']).should_receive('open').and_return(stdout)
    flexmock(module.os).should_receive('devnull')

    module.check_archives(
-        verbosity=None,
        repository='repo',
        storage_config={},
        consistency_config=consistency_config,
@ -249,20 +230,18 @@ def test_check_archives_with_lock_wait_calls_borg_with_lock_wait_parameters():
    check_last = flexmock()
    consistency_config = {'check_last': check_last}
    flexmock(module).should_receive('_parse_checks').and_return(checks)
-    flexmock(module).should_receive('_make_check_flags').with_args(checks, check_last, None).and_return(())
+    flexmock(module).should_receive('_make_check_flags').with_args(
+        checks, check_last, None
+    ).and_return(())
    stdout = flexmock()
    insert_subprocess_mock(
-        ('borg', 'check', 'repo', '--lock-wait', '5'),
-        stdout=stdout, stderr=STDOUT,
+        ('borg', 'check', 'repo', '--lock-wait', '5'), stdout=stdout, stderr=STDOUT
    )
    flexmock(sys.modules['builtins']).should_receive('open').and_return(stdout)
    flexmock(module.os).should_receive('devnull')

    module.check_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config={'lock_wait': 5},
-        consistency_config=consistency_config,
+        repository='repo', storage_config={'lock_wait': 5}, consistency_config=consistency_config
    )


@ -272,19 +251,15 @@ def test_check_archives_with_retention_prefix():
    prefix = 'foo-'
    consistency_config = {'check_last': check_last, 'prefix': prefix}
    flexmock(module).should_receive('_parse_checks').and_return(checks)
-    flexmock(module).should_receive('_make_check_flags').with_args(checks, check_last, prefix).and_return(())
+    flexmock(module).should_receive('_make_check_flags').with_args(
+        checks, check_last, prefix
+    ).and_return(())
    stdout = flexmock()
-    insert_subprocess_mock(
-        ('borg', 'check', 'repo'),
-        stdout=stdout, stderr=STDOUT,
-    )
+    insert_subprocess_mock(('borg', 'check', 'repo'), stdout=stdout, stderr=STDOUT)

    flexmock(sys.modules['builtins']).should_receive('open').and_return(stdout)
    flexmock(module.os).should_receive('devnull')

    module.check_archives(
-        verbosity=None,
-        repository='repo',
-        storage_config={},
-        consistency_config=consistency_config,
+        repository='repo', storage_config={}, consistency_config=consistency_config
    )
--- a/borgmatic/tests/unit/borg/test_create.py
+++ b/borgmatic/tests/unit/borg/test_create.py
@ -1,9 +1,10 @@
+import logging
 import os

 from flexmock import flexmock

 from borgmatic.borg import create as module
-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
+from ..test_verbosity import insert_logging_mock


 def test_initialize_environment_with_passcommand_should_set_environment():
@ -45,9 +46,9 @@ def test_initialize_environment_without_configuration_should_not_set_environment
    try:
        os.environ = {}
        module.initialize_environment({})
-        assert os.environ.get('BORG_PASSCOMMAND') == None
-        assert os.environ.get('BORG_PASSPHRASE') == None
-        assert os.environ.get('BORG_RSH') == None
+        assert os.environ.get('BORG_PASSCOMMAND') is None
+        assert os.environ.get('BORG_PASSPHRASE') is None
+        assert os.environ.get('BORG_RSH') is None
    finally:
        os.environ = orig_environ

@ -71,8 +72,12 @@ def test_expand_directory_with_glob_expands():


 def test_expand_directories_flattens_expanded_directories():
-    flexmock(module).should_receive('_expand_directory').with_args('~/foo').and_return(['/root/foo'])
-    flexmock(module).should_receive('_expand_directory').with_args('bar*').and_return(['bar', 'barf'])
+    flexmock(module).should_receive('_expand_directory').with_args('~/foo').and_return(
+        ['/root/foo']
+    )
+    flexmock(module).should_receive('_expand_directory').with_args('bar*').and_return(
+        ['bar', 'barf']
+    )

    paths = module._expand_directories(('~/foo', 'bar*'))

@ -86,11 +91,7 @@ def test_expand_directories_considers_none_as_no_directories():


 def test_write_pattern_file_does_not_raise():
-    temporary_file = flexmock(
-        name='filename',
-        write=lambda mode: None,
-        flush=lambda: None,
-    )
+    temporary_file = flexmock(name='filename', write=lambda mode: None, flush=lambda: None)
    flexmock(module.tempfile).should_receive('NamedTemporaryFile').and_return(temporary_file)

    module._write_pattern_file(['exclude'])
@ -107,8 +108,7 @@ def insert_subprocess_mock(check_call_command, **kwargs):

 def test_make_pattern_flags_includes_pattern_filename_when_given():
    pattern_flags = module._make_pattern_flags(
-        location_config={'patterns': ['R /', '- /var']},
-        pattern_filename='/tmp/patterns',
+        location_config={'patterns': ['R /', '- /var']}, pattern_filename='/tmp/patterns'
    )

    assert pattern_flags == ('--patterns-from', '/tmp/patterns')
@ -116,7 +116,7 @@ def test_make_pattern_flags_includes_pattern_filename_when_given():

 def test_make_pattern_flags_includes_patterns_from_filenames_when_in_config():
    pattern_flags = module._make_pattern_flags(
-        location_config={'patterns_from': ['patterns', 'other']},
+        location_config={'patterns_from': ['patterns', 'other']}
    )

    assert pattern_flags == ('--patterns-from', 'patterns', '--patterns-from', 'other')
@ -124,25 +124,21 @@ def test_make_pattern_flags_includes_patterns_from_filenames_when_in_config():

 def test_make_pattern_flags_includes_both_filenames_when_patterns_given_and_patterns_from_in_config():
    pattern_flags = module._make_pattern_flags(
-        location_config={'patterns_from': ['patterns']},
-        pattern_filename='/tmp/patterns',
+        location_config={'patterns_from': ['patterns']}, pattern_filename='/tmp/patterns'
    )

    assert pattern_flags == ('--patterns-from', 'patterns', '--patterns-from', '/tmp/patterns')


 def test_make_pattern_flags_considers_none_patterns_from_filenames_as_empty():
-    pattern_flags = module._make_pattern_flags(
-        location_config={'patterns_from': None},
-    )
+    pattern_flags = module._make_pattern_flags(location_config={'patterns_from': None})

    assert pattern_flags == ()


 def test_make_exclude_flags_includes_exclude_patterns_filename_when_given():
    exclude_flags = module._make_exclude_flags(
-        location_config={'exclude_patterns': ['*.pyc', '/var']},
-        exclude_filename='/tmp/excludes',
+        location_config={'exclude_patterns': ['*.pyc', '/var']}, exclude_filename='/tmp/excludes'
    )

    assert exclude_flags == ('--exclude-from', '/tmp/excludes')
@ -151,7 +147,7 @@ def test_make_exclude_flags_includes_exclude_patterns_filename_when_given():
 def test_make_exclude_flags_includes_exclude_from_filenames_when_in_config():

    exclude_flags = module._make_exclude_flags(
-        location_config={'exclude_from': ['excludes', 'other']},
+        location_config={'exclude_from': ['excludes', 'other']}
    )

    assert exclude_flags == ('--exclude-from', 'excludes', '--exclude-from', 'other')
@ -159,41 +155,32 @@ def test_make_exclude_flags_includes_exclude_from_filenames_when_in_config():

 def test_make_exclude_flags_includes_both_filenames_when_patterns_given_and_exclude_from_in_config():
    exclude_flags = module._make_exclude_flags(
-        location_config={'exclude_from': ['excludes']},
-        exclude_filename='/tmp/excludes',
+        location_config={'exclude_from': ['excludes']}, exclude_filename='/tmp/excludes'
    )

    assert exclude_flags == ('--exclude-from', 'excludes', '--exclude-from', '/tmp/excludes')


 def test_make_exclude_flags_considers_none_exclude_from_filenames_as_empty():
-    exclude_flags = module._make_exclude_flags(
-        location_config={'exclude_from': None},
-    )
+    exclude_flags = module._make_exclude_flags(location_config={'exclude_from': None})

    assert exclude_flags == ()


 def test_make_exclude_flags_includes_exclude_caches_when_true_in_config():
-    exclude_flags = module._make_exclude_flags(
-        location_config={'exclude_caches': True},
-    )
+    exclude_flags = module._make_exclude_flags(location_config={'exclude_caches': True})

    assert exclude_flags == ('--exclude-caches',)


 def test_make_exclude_flags_does_not_include_exclude_caches_when_false_in_config():
-    exclude_flags = module._make_exclude_flags(
-        location_config={'exclude_caches': False},
-    )
+    exclude_flags = module._make_exclude_flags(location_config={'exclude_caches': False})

    assert exclude_flags == ()


 def test_make_exclude_flags_includes_exclude_if_present_when_in_config():
-    exclude_flags = module._make_exclude_flags(
-        location_config={'exclude_if_present': 'exclude_me'},
-    )
+    exclude_flags = module._make_exclude_flags(location_config={'exclude_if_present': 'exclude_me'})

    assert exclude_flags == ('--exclude-if-present', 'exclude_me')

@ -216,7 +203,6 @@ def test_create_archive_calls_borg_with_parameters():
    insert_subprocess_mock(CREATE_COMMAND)

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -231,13 +217,14 @@ def test_create_archive_calls_borg_with_parameters():
 def test_create_archive_with_patterns_calls_borg_with_patterns():
    pattern_flags = ('--patterns-from', 'patterns')
    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
-    flexmock(module).should_receive('_write_pattern_file').and_return(flexmock(name='/tmp/patterns')).and_return(None)
+    flexmock(module).should_receive('_write_pattern_file').and_return(
+        flexmock(name='/tmp/patterns')
+    ).and_return(None)
    flexmock(module).should_receive('_make_pattern_flags').and_return(pattern_flags)
    flexmock(module).should_receive('_make_exclude_flags').and_return(())
    insert_subprocess_mock(CREATE_COMMAND + pattern_flags)

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -251,14 +238,17 @@ def test_create_archive_with_patterns_calls_borg_with_patterns():

 def test_create_archive_with_exclude_patterns_calls_borg_with_excludes():
    exclude_flags = ('--exclude-from', 'excludes')
-    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(('exclude',))
-    flexmock(module).should_receive('_write_pattern_file').and_return(None).and_return(flexmock(name='/tmp/excludes'))
+    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(
+        ('exclude',)
+    )
+    flexmock(module).should_receive('_write_pattern_file').and_return(None).and_return(
+        flexmock(name='/tmp/excludes')
+    )
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_exclude_flags').and_return(exclude_flags)
    insert_subprocess_mock(CREATE_COMMAND + exclude_flags)

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -270,16 +260,16 @@ def test_create_archive_with_exclude_patterns_calls_borg_with_excludes():
    )


-def test_create_archive_with_verbosity_some_calls_borg_with_info_parameter():
+def test_create_archive_with_log_info_calls_borg_with_info_parameter():
    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
    flexmock(module).should_receive('_write_pattern_file').and_return(None)
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_exclude_flags').and_return(())
-    insert_subprocess_mock(CREATE_COMMAND + ('--info', '--stats',))
+    insert_subprocess_mock(CREATE_COMMAND + ('--list', '--filter', 'AME', '--info', '--stats'))
+    insert_logging_mock(logging.INFO)

    module.create_archive(
-        verbosity=VERBOSITY_SOME,
        dry_run=False,
        repository='repo',
        location_config={
@ -291,15 +281,17 @@ def test_create_archive_with_verbosity_some_calls_borg_with_info_parameter():
    )


-def test_create_archive_with_verbosity_lots_calls_borg_with_debug_parameter():
+def test_create_archive_with_log_debug_calls_borg_with_debug_parameter():
    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
    flexmock(module).should_receive('_write_pattern_file').and_return(None)
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_exclude_flags').and_return(())
-    insert_subprocess_mock(CREATE_COMMAND + ('--debug', '--list', '--stats'))
+    insert_subprocess_mock(
+        CREATE_COMMAND + ('--list', '--filter', 'AME', '--stats', '--debug', '--show-rc')
+    )
+    insert_logging_mock(logging.DEBUG)

    module.create_archive(
-        verbosity=VERBOSITY_LOTS,
        dry_run=False,
        repository='repo',
        location_config={
@ -320,7 +312,6 @@ def test_create_archive_with_dry_run_calls_borg_with_dry_run_parameter():
    insert_subprocess_mock(CREATE_COMMAND + ('--dry-run',))

    module.create_archive(
-        verbosity=None,
        dry_run=True,
        repository='repo',
        location_config={
@ -332,16 +323,18 @@ def test_create_archive_with_dry_run_calls_borg_with_dry_run_parameter():
    )


-def test_create_archive_with_dry_run_and_verbosity_some_calls_borg_without_stats_parameter():
+def test_create_archive_with_dry_run_and_log_info_calls_borg_without_stats_parameter():
+    """ --dry-run and --stats are mutually exclusive, see:
+    https://borgbackup.readthedocs.io/en/stable/usage/create.html#description """
    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
    flexmock(module).should_receive('_write_pattern_file').and_return(None)
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_exclude_flags').and_return(())
-    insert_subprocess_mock(CREATE_COMMAND + ('--info', '--dry-run'))
+    insert_subprocess_mock(CREATE_COMMAND + ('--list', '--filter', 'AME', '--info', '--dry-run'))
+    insert_logging_mock(logging.INFO)

    module.create_archive(
-        verbosity=VERBOSITY_SOME,
        dry_run=True,
        repository='repo',
        location_config={
@ -353,16 +346,20 @@ def test_create_archive_with_dry_run_and_verbosity_some_calls_borg_without_stats
    )


-def test_create_archive_with_dry_run_and_verbosity_lots_calls_borg_without_stats_parameter():
+def test_create_archive_with_dry_run_and_log_debug_calls_borg_without_stats_parameter():
+    """ --dry-run and --stats are mutually exclusive, see:
+    https://borgbackup.readthedocs.io/en/stable/usage/create.html#description """
    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
    flexmock(module).should_receive('_write_pattern_file').and_return(None)
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_exclude_flags').and_return(())
-    insert_subprocess_mock(CREATE_COMMAND + ('--debug', '--list', '--dry-run'))
+    insert_subprocess_mock(
+        CREATE_COMMAND + ('--list', '--filter', 'AME', '--debug', '--show-rc', '--dry-run')
+    )
+    insert_logging_mock(logging.DEBUG)

    module.create_archive(
-        verbosity=VERBOSITY_LOTS,
        dry_run=True,
        repository='repo',
        location_config={
@ -374,6 +371,25 @@ def test_create_archive_with_dry_run_and_verbosity_lots_calls_borg_without_stats
    )


+def test_create_archive_with_checkpoint_interval_calls_borg_with_checkpoint_interval_parameters():
+    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
+    flexmock(module).should_receive('_write_pattern_file').and_return(None)
+    flexmock(module).should_receive('_make_pattern_flags').and_return(())
+    flexmock(module).should_receive('_make_exclude_flags').and_return(())
+    insert_subprocess_mock(CREATE_COMMAND + ('--checkpoint-interval', '600'))
+
+    module.create_archive(
+        dry_run=False,
+        repository='repo',
+        location_config={
+            'source_directories': ['foo', 'bar'],
+            'repositories': ['repo'],
+            'exclude_patterns': None,
+        },
+        storage_config={'checkpoint_interval': 600},
+    )
+
+
 def test_create_archive_with_compression_calls_borg_with_compression_parameters():
    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
    flexmock(module).should_receive('_write_pattern_file').and_return(None)
@ -382,7 +398,6 @@ def test_create_archive_with_compression_calls_borg_with_compression_parameters(
    insert_subprocess_mock(CREATE_COMMAND + ('--compression', 'rle'))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -402,7 +417,6 @@ def test_create_archive_with_remote_rate_limit_calls_borg_with_remote_ratelimit_
    insert_subprocess_mock(CREATE_COMMAND + ('--remote-ratelimit', '100'))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -422,7 +436,6 @@ def test_create_archive_with_one_file_system_calls_borg_with_one_file_system_par
    insert_subprocess_mock(CREATE_COMMAND + ('--one-file-system',))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -435,6 +448,26 @@ def test_create_archive_with_one_file_system_calls_borg_with_one_file_system_par
    )


+def test_create_archive_with_read_special_calls_borg_with_read_special_parameter():
+    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
+    flexmock(module).should_receive('_write_pattern_file').and_return(None)
+    flexmock(module).should_receive('_make_pattern_flags').and_return(())
+    flexmock(module).should_receive('_make_exclude_flags').and_return(())
+    insert_subprocess_mock(CREATE_COMMAND + ('--read-special',))
+
+    module.create_archive(
+        dry_run=False,
+        repository='repo',
+        location_config={
+            'source_directories': ['foo', 'bar'],
+            'repositories': ['repo'],
+            'read_special': True,
+            'exclude_patterns': None,
+        },
+        storage_config={},
+    )
+
+
 def test_create_archive_with_bsd_flags_true_calls_borg_without_nobsdflags_parameter():
    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
    flexmock(module).should_receive('_write_pattern_file').and_return(None)
@ -443,7 +476,6 @@ def test_create_archive_with_bsd_flags_true_calls_borg_without_nobsdflags_parame
    insert_subprocess_mock(CREATE_COMMAND)

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -464,7 +496,6 @@ def test_create_archive_with_bsd_flags_false_calls_borg_with_nobsdflags_paramete
    insert_subprocess_mock(CREATE_COMMAND + ('--nobsdflags',))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -485,7 +516,6 @@ def test_create_archive_with_files_cache_calls_borg_with_files_cache_parameters(
    insert_subprocess_mock(CREATE_COMMAND + ('--files-cache', 'ctime,size'))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -506,7 +536,6 @@ def test_create_archive_with_local_path_calls_borg_via_local_path():
    insert_subprocess_mock(('borg1',) + CREATE_COMMAND[1:])

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -527,7 +556,6 @@ def test_create_archive_with_remote_path_calls_borg_with_remote_path_parameters(
    insert_subprocess_mock(CREATE_COMMAND + ('--remote-path', 'borg1'))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -548,7 +576,6 @@ def test_create_archive_with_umask_calls_borg_with_umask_parameters():
    insert_subprocess_mock(CREATE_COMMAND + ('--umask', '740'))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -568,7 +595,6 @@ def test_create_archive_with_lock_wait_calls_borg_with_lock_wait_parameters():
    insert_subprocess_mock(CREATE_COMMAND + ('--lock-wait', '5'))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -580,16 +606,39 @@ def test_create_archive_with_lock_wait_calls_borg_with_lock_wait_parameters():
    )


-def test_create_archive_with_source_directories_glob_expands():
-    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'food')).and_return(())
+def test_create_archive_with_json_calls_borg_with_json_parameter():
+    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'bar')).and_return(())
    flexmock(module).should_receive('_write_pattern_file').and_return(None)
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_exclude_flags').and_return(())
-    insert_subprocess_mock(('borg', 'create', 'repo::{}'.format(DEFAULT_ARCHIVE_NAME), 'foo', 'food'))
+    insert_subprocess_mock(CREATE_COMMAND + ('--json',))
+
+    module.create_archive(
+        dry_run=False,
+        repository='repo',
+        location_config={
+            'source_directories': ['foo', 'bar'],
+            'repositories': ['repo'],
+            'exclude_patterns': None,
+        },
+        storage_config={},
+        json=True,
+    )
+
+
+def test_create_archive_with_source_directories_glob_expands():
+    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'food')).and_return(
+        ()
+    )
+    flexmock(module).should_receive('_write_pattern_file').and_return(None)
+    flexmock(module).should_receive('_make_pattern_flags').and_return(())
+    flexmock(module).should_receive('_make_exclude_flags').and_return(())
+    insert_subprocess_mock(
+        ('borg', 'create', 'repo::{}'.format(DEFAULT_ARCHIVE_NAME), 'foo', 'food')
+    )
    flexmock(module.glob).should_receive('glob').with_args('foo*').and_return(['foo', 'food'])

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -610,7 +659,6 @@ def test_create_archive_with_non_matching_source_directories_glob_passes_through
    flexmock(module.glob).should_receive('glob').with_args('foo*').and_return([])

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -623,14 +671,17 @@ def test_create_archive_with_non_matching_source_directories_glob_passes_through


 def test_create_archive_with_glob_calls_borg_with_expanded_directories():
-    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'food')).and_return(())
+    flexmock(module).should_receive('_expand_directories').and_return(('foo', 'food')).and_return(
+        ()
+    )
    flexmock(module).should_receive('_write_pattern_file').and_return(None)
    flexmock(module).should_receive('_make_pattern_flags').and_return(())
    flexmock(module).should_receive('_make_exclude_flags').and_return(())
-    insert_subprocess_mock(('borg', 'create', 'repo::{}'.format(DEFAULT_ARCHIVE_NAME), 'foo', 'food'))
+    insert_subprocess_mock(
+        ('borg', 'create', 'repo::{}'.format(DEFAULT_ARCHIVE_NAME), 'foo', 'food')
+    )

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -650,7 +701,6 @@ def test_create_archive_with_archive_name_format_calls_borg_with_archive_name():
    insert_subprocess_mock(('borg', 'create', 'repo::ARCHIVE_NAME', 'foo', 'bar'))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -658,9 +708,7 @@ def test_create_archive_with_archive_name_format_calls_borg_with_archive_name():
            'repositories': ['repo'],
            'exclude_patterns': None,
        },
-        storage_config={
-            'archive_name_format': 'ARCHIVE_NAME',
-        },
+        storage_config={'archive_name_format': 'ARCHIVE_NAME'},
    )


@ -672,7 +720,6 @@ def test_create_archive_with_archive_name_format_accepts_borg_placeholders():
    insert_subprocess_mock(('borg', 'create', 'repo::Documents_{hostname}-{now}', 'foo', 'bar'))

    module.create_archive(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        location_config={
@ -680,7 +727,5 @@ def test_create_archive_with_archive_name_format_accepts_borg_placeholders():
            'repositories': ['repo'],
            'exclude_patterns': None,
        },
-        storage_config={
-            'archive_name_format': 'Documents_{hostname}-{now}',
-        },
+        storage_config={'archive_name_format': 'Documents_{hostname}-{now}'},
    )
--- a/borgmatic/tests/unit/borg/test_extract.py
+++ b/borgmatic/tests/unit/borg/test_extract.py
@ -1,9 +1,10 @@
+import logging
 import sys

 from flexmock import flexmock

 from borgmatic.borg import extract as module
-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
+from ..test_verbosity import insert_logging_mock


 def insert_subprocess_mock(check_call_command, **kwargs):
@ -18,91 +19,64 @@ def insert_subprocess_never():

 def insert_subprocess_check_output_mock(check_output_command, result, **kwargs):
    subprocess = flexmock(module.subprocess)
-    subprocess.should_receive('check_output').with_args(check_output_command, **kwargs).and_return(result).once()
+    subprocess.should_receive('check_output').with_args(check_output_command, **kwargs).and_return(
+        result
+    ).once()


 def test_extract_last_archive_dry_run_should_call_borg_with_last_archive():
    flexmock(sys.stdout).encoding = 'utf-8'
    insert_subprocess_check_output_mock(
-        ('borg', 'list', '--short', 'repo'),
-        result='archive1\narchive2\n'.encode('utf-8'),
-    )
-    insert_subprocess_mock(
-        ('borg', 'extract', '--dry-run', 'repo::archive2'),
+        ('borg', 'list', '--short', 'repo'), result='archive1\narchive2\n'.encode('utf-8')
    )
+    insert_subprocess_mock(('borg', 'extract', '--dry-run', 'repo::archive2'))

-    module.extract_last_archive_dry_run(
-        verbosity=None,
-        repository='repo',
-        lock_wait=None,
-    )
+    module.extract_last_archive_dry_run(repository='repo', lock_wait=None)


 def test_extract_last_archive_dry_run_without_any_archives_should_bail():
    flexmock(sys.stdout).encoding = 'utf-8'
    insert_subprocess_check_output_mock(
-        ('borg', 'list', '--short', 'repo'),
-        result='\n'.encode('utf-8'),
+        ('borg', 'list', '--short', 'repo'), result='\n'.encode('utf-8')
    )
    insert_subprocess_never()

-    module.extract_last_archive_dry_run(
-        verbosity=None,
-        repository='repo',
-        lock_wait=None,
-    )
+    module.extract_last_archive_dry_run(repository='repo', lock_wait=None)


-def test_extract_last_archive_dry_run_with_verbosity_some_should_call_borg_with_info_parameter():
+def test_extract_last_archive_dry_run_with_log_info_should_call_borg_with_info_parameter():
    flexmock(sys.stdout).encoding = 'utf-8'
    insert_subprocess_check_output_mock(
-        ('borg', 'list', '--short', 'repo', '--info'),
+        ('borg', 'list', '--short', 'repo', '--info'), result='archive1\narchive2\n'.encode('utf-8')
+    )
+    insert_subprocess_mock(('borg', 'extract', '--dry-run', 'repo::archive2', '--info'))
+    insert_logging_mock(logging.INFO)
+
+    module.extract_last_archive_dry_run(repository='repo', lock_wait=None)
+
+
+def test_extract_last_archive_dry_run_with_log_debug_should_call_borg_with_debug_parameter():
+    flexmock(sys.stdout).encoding = 'utf-8'
+    insert_subprocess_check_output_mock(
+        ('borg', 'list', '--short', 'repo', '--debug', '--show-rc'),
        result='archive1\narchive2\n'.encode('utf-8'),
    )
    insert_subprocess_mock(
-        ('borg', 'extract', '--dry-run', 'repo::archive2', '--info'),
+        ('borg', 'extract', '--dry-run', 'repo::archive2', '--debug', '--show-rc', '--list')
    )
+    insert_logging_mock(logging.DEBUG)

-    module.extract_last_archive_dry_run(
-        verbosity=VERBOSITY_SOME,
-        repository='repo',
-        lock_wait=None,
-    )
-
-
-def test_extract_last_archive_dry_run_with_verbosity_lots_should_call_borg_with_debug_parameter():
-    flexmock(sys.stdout).encoding = 'utf-8'
-    insert_subprocess_check_output_mock(
-        ('borg', 'list', '--short', 'repo', '--debug'),
-        result='archive1\narchive2\n'.encode('utf-8'),
-    )
-    insert_subprocess_mock(
-        ('borg', 'extract', '--dry-run', 'repo::archive2', '--debug', '--list'),
-    )
-
-    module.extract_last_archive_dry_run(
-        verbosity=VERBOSITY_LOTS,
-        repository='repo',
-        lock_wait=None,
-    )
+    module.extract_last_archive_dry_run(repository='repo', lock_wait=None)


 def test_extract_last_archive_dry_run_should_call_borg_via_local_path():
    flexmock(sys.stdout).encoding = 'utf-8'
    insert_subprocess_check_output_mock(
-        ('borg1', 'list', '--short', 'repo'),
-        result='archive1\narchive2\n'.encode('utf-8'),
-    )
-    insert_subprocess_mock(
-        ('borg1', 'extract', '--dry-run', 'repo::archive2'),
+        ('borg1', 'list', '--short', 'repo'), result='archive1\narchive2\n'.encode('utf-8')
    )
+    insert_subprocess_mock(('borg1', 'extract', '--dry-run', 'repo::archive2'))

-    module.extract_last_archive_dry_run(
-        verbosity=None,
-        repository='repo',
-        lock_wait=None,
-        local_path='borg1',
-    )
+    module.extract_last_archive_dry_run(repository='repo', lock_wait=None, local_path='borg1')


 def test_extract_last_archive_dry_run_should_call_borg_with_remote_path_parameters():
@ -112,15 +86,10 @@ def test_extract_last_archive_dry_run_should_call_borg_with_remote_path_paramete
        result='archive1\narchive2\n'.encode('utf-8'),
    )
    insert_subprocess_mock(
-        ('borg', 'extract', '--dry-run', 'repo::archive2', '--remote-path', 'borg1'),
+        ('borg', 'extract', '--dry-run', 'repo::archive2', '--remote-path', 'borg1')
    )

-    module.extract_last_archive_dry_run(
-        verbosity=None,
-        repository='repo',
-        lock_wait=None,
-        remote_path='borg1',
-    )
+    module.extract_last_archive_dry_run(repository='repo', lock_wait=None, remote_path='borg1')


 def test_extract_last_archive_dry_run_should_call_borg_with_lock_wait_parameters():
@ -129,12 +98,6 @@ def test_extract_last_archive_dry_run_should_call_borg_with_lock_wait_parameters
        ('borg', 'list', '--short', 'repo', '--lock-wait', '5'),
        result='archive1\narchive2\n'.encode('utf-8'),
    )
-    insert_subprocess_mock(
-        ('borg', 'extract', '--dry-run', 'repo::archive2', '--lock-wait', '5'),
-    )
+    insert_subprocess_mock(('borg', 'extract', '--dry-run', 'repo::archive2', '--lock-wait', '5'))

-    module.extract_last_archive_dry_run(
-        verbosity=None,
-        repository='repo',
-        lock_wait=5,
-    )
+    module.extract_last_archive_dry_run(repository='repo', lock_wait=5)
--- a/borgmatic/tests/unit/borg/test_hook.py
+++ b/borgmatic/tests/unit/borg/test_hook.py
--- a/tests/unit/borg/test_info.py
+++ b/tests/unit/borg/test_info.py
@ -0,0 +1,58 @@
+import logging
+
+from flexmock import flexmock
+
+from borgmatic.borg import info as module
+from ..test_verbosity import insert_logging_mock
+
+
+def insert_subprocess_mock(check_call_command, **kwargs):
+    subprocess = flexmock(module.subprocess)
+    subprocess.should_receive('check_output').with_args(check_call_command, **kwargs).once()
+
+
+INFO_COMMAND = ('borg', 'info', 'repo')
+
+
+def test_display_archives_info_calls_borg_with_parameters():
+    insert_subprocess_mock(INFO_COMMAND)
+
+    module.display_archives_info(repository='repo', storage_config={})
+
+
+def test_display_archives_info_with_log_info_calls_borg_with_info_parameter():
+    insert_subprocess_mock(INFO_COMMAND + ('--info',))
+    insert_logging_mock(logging.INFO)
+    module.display_archives_info(repository='repo', storage_config={})
+
+
+def test_display_archives_info_with_log_debug_calls_borg_with_debug_parameter():
+    insert_subprocess_mock(INFO_COMMAND + ('--debug', '--show-rc'))
+    insert_logging_mock(logging.DEBUG)
+
+    module.display_archives_info(repository='repo', storage_config={})
+
+
+def test_display_archives_info_with_json_calls_borg_with_json_parameter():
+    insert_subprocess_mock(INFO_COMMAND + ('--json',))
+
+    module.display_archives_info(repository='repo', storage_config={}, json=True)
+
+
+def test_display_archives_info_with_local_path_calls_borg_via_local_path():
+    insert_subprocess_mock(('borg1',) + INFO_COMMAND[1:])
+
+    module.display_archives_info(repository='repo', storage_config={}, local_path='borg1')
+
+
+def test_display_archives_info_with_remote_path_calls_borg_with_remote_path_parameters():
+    insert_subprocess_mock(INFO_COMMAND + ('--remote-path', 'borg1'))
+
+    module.display_archives_info(repository='repo', storage_config={}, remote_path='borg1')
+
+
+def test_display_archives_info_with_lock_wait_calls_borg_with_lock_wait_parameters():
+    storage_config = {'lock_wait': 5}
+    insert_subprocess_mock(INFO_COMMAND + ('--lock-wait', '5'))
+
+    module.display_archives_info(repository='repo', storage_config=storage_config)
--- a/tests/unit/borg/test_list.py
+++ b/tests/unit/borg/test_list.py
@ -0,0 +1,59 @@
+import logging
+
+from flexmock import flexmock
+
+from borgmatic.borg import list as module
+from ..test_verbosity import insert_logging_mock
+
+
+def insert_subprocess_mock(check_call_command, **kwargs):
+    subprocess = flexmock(module.subprocess)
+    subprocess.should_receive('check_output').with_args(check_call_command, **kwargs).once()
+
+
+LIST_COMMAND = ('borg', 'list', 'repo')
+
+
+def test_list_archives_calls_borg_with_parameters():
+    insert_subprocess_mock(LIST_COMMAND)
+
+    module.list_archives(repository='repo', storage_config={})
+
+
+def test_list_archives_with_log_info_calls_borg_with_info_parameter():
+    insert_subprocess_mock(LIST_COMMAND + ('--info',))
+    insert_logging_mock(logging.INFO)
+
+    module.list_archives(repository='repo', storage_config={})
+
+
+def test_list_archives_with_log_debug_calls_borg_with_debug_parameter():
+    insert_subprocess_mock(LIST_COMMAND + ('--debug', '--show-rc'))
+    insert_logging_mock(logging.DEBUG)
+
+    module.list_archives(repository='repo', storage_config={})
+
+
+def test_list_archives_with_json_calls_borg_with_json_parameter():
+    insert_subprocess_mock(LIST_COMMAND + ('--json',))
+
+    module.list_archives(repository='repo', storage_config={}, json=True)
+
+
+def test_list_archives_with_local_path_calls_borg_via_local_path():
+    insert_subprocess_mock(('borg1',) + LIST_COMMAND[1:])
+
+    module.list_archives(repository='repo', storage_config={}, local_path='borg1')
+
+
+def test_list_archives_with_remote_path_calls_borg_with_remote_path_parameters():
+    insert_subprocess_mock(LIST_COMMAND + ('--remote-path', 'borg1'))
+
+    module.list_archives(repository='repo', storage_config={}, remote_path='borg1')
+
+
+def test_list_archives_with_lock_wait_calls_borg_with_lock_wait_parameters():
+    storage_config = {'lock_wait': 5}
+    insert_subprocess_mock(LIST_COMMAND + ('--lock-wait', '5'))
+
+    module.list_archives(repository='repo', storage_config=storage_config)
--- a/borgmatic/tests/unit/borg/test_prune.py
+++ b/borgmatic/tests/unit/borg/test_prune.py
@ -1,9 +1,10 @@
+import logging
 from collections import OrderedDict

 from flexmock import flexmock

 from borgmatic.borg import prune as module
-from borgmatic.verbosity import VERBOSITY_SOME, VERBOSITY_LOTS
+from ..test_verbosity import insert_logging_mock


 def insert_subprocess_mock(check_call_command, **kwargs):
@ -11,21 +12,11 @@ def insert_subprocess_mock(check_call_command, **kwargs):
    subprocess.should_receive('check_call').with_args(check_call_command, **kwargs).once()


-BASE_PRUNE_FLAGS = (
-    ('--keep-daily', '1'),
-    ('--keep-weekly', '2'),
-    ('--keep-monthly', '3'),
-)
+BASE_PRUNE_FLAGS = (('--keep-daily', '1'), ('--keep-weekly', '2'), ('--keep-monthly', '3'))


 def test_make_prune_flags_returns_flags_from_config_plus_default_prefix():
-    retention_config = OrderedDict(
-        (
-            ('keep_daily', 1),
-            ('keep_weekly', 2),
-            ('keep_monthly', 3),
-        )
-    )
+    retention_config = OrderedDict((('keep_daily', 1), ('keep_weekly', 2), ('keep_monthly', 3)))

    result = module._make_prune_flags(retention_config)

@ -33,101 +24,86 @@ def test_make_prune_flags_returns_flags_from_config_plus_default_prefix():


 def test_make_prune_flags_accepts_prefix_with_placeholders():
-    retention_config = OrderedDict(
-        (
-            ('keep_daily', 1),
-            ('prefix', 'Documents_{hostname}-{now}'),
-        )
-    )
+    retention_config = OrderedDict((('keep_daily', 1), ('prefix', 'Documents_{hostname}-{now}')))

    result = module._make_prune_flags(retention_config)

-    expected = (
-        ('--keep-daily', '1'),
-        ('--prefix', 'Documents_{hostname}-{now}'),
-    )
+    expected = (('--keep-daily', '1'), ('--prefix', 'Documents_{hostname}-{now}'))

    assert tuple(result) == expected


 PRUNE_COMMAND = (
-    'borg', 'prune', 'repo', '--keep-daily', '1', '--keep-weekly', '2', '--keep-monthly', '3',
+    'borg',
+    'prune',
+    'repo',
+    '--keep-daily',
+    '1',
+    '--keep-weekly',
+    '2',
+    '--keep-monthly',
+    '3',
 )


 def test_prune_archives_calls_borg_with_parameters():
    retention_config = flexmock()
    flexmock(module).should_receive('_make_prune_flags').with_args(retention_config).and_return(
-        BASE_PRUNE_FLAGS,
+        BASE_PRUNE_FLAGS
    )
    insert_subprocess_mock(PRUNE_COMMAND)

    module.prune_archives(
-        verbosity=None,
-        dry_run=False,
-        repository='repo',
-        storage_config={},
-        retention_config=retention_config,
+        dry_run=False, repository='repo', storage_config={}, retention_config=retention_config
    )


-def test_prune_archives_with_verbosity_some_calls_borg_with_info_parameter():
+def test_prune_archives_with_log_info_calls_borg_with_info_parameter():
    retention_config = flexmock()
    flexmock(module).should_receive('_make_prune_flags').with_args(retention_config).and_return(
-        BASE_PRUNE_FLAGS,
+        BASE_PRUNE_FLAGS
    )
-    insert_subprocess_mock(PRUNE_COMMAND + ('--info', '--stats',))
+    insert_subprocess_mock(PRUNE_COMMAND + ('--stats', '--info'))
+    insert_logging_mock(logging.INFO)

    module.prune_archives(
-        repository='repo',
-        storage_config={},
-        verbosity=VERBOSITY_SOME,
-        dry_run=False,
-        retention_config=retention_config,
+        repository='repo', storage_config={}, dry_run=False, retention_config=retention_config
    )


-def test_prune_archives_with_verbosity_lots_calls_borg_with_debug_parameter():
+def test_prune_archives_with_log_debug_calls_borg_with_debug_parameter():
    retention_config = flexmock()
    flexmock(module).should_receive('_make_prune_flags').with_args(retention_config).and_return(
-        BASE_PRUNE_FLAGS,
+        BASE_PRUNE_FLAGS
    )
-    insert_subprocess_mock(PRUNE_COMMAND + ('--debug', '--stats', '--list'))
+    insert_subprocess_mock(PRUNE_COMMAND + ('--stats', '--debug', '--list', '--show-rc'))
+    insert_logging_mock(logging.DEBUG)

    module.prune_archives(
-        repository='repo',
-        storage_config={},
-        verbosity=VERBOSITY_LOTS,
-        dry_run=False,
-        retention_config=retention_config,
+        repository='repo', storage_config={}, dry_run=False, retention_config=retention_config
    )


 def test_prune_archives_with_dry_run_calls_borg_with_dry_run_parameter():
    retention_config = flexmock()
    flexmock(module).should_receive('_make_prune_flags').with_args(retention_config).and_return(
-        BASE_PRUNE_FLAGS,
+        BASE_PRUNE_FLAGS
    )
    insert_subprocess_mock(PRUNE_COMMAND + ('--dry-run',))

    module.prune_archives(
-        repository='repo',
-        storage_config={},
-        verbosity=None,
-        dry_run=True,
-        retention_config=retention_config,
+        repository='repo', storage_config={}, dry_run=True, retention_config=retention_config
    )


 def test_prune_archives_with_local_path_calls_borg_via_local_path():
    retention_config = flexmock()
    flexmock(module).should_receive('_make_prune_flags').with_args(retention_config).and_return(
-        BASE_PRUNE_FLAGS,
+        BASE_PRUNE_FLAGS
    )
    insert_subprocess_mock(('borg1',) + PRUNE_COMMAND[1:])

    module.prune_archives(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        storage_config={},
@ -139,12 +115,11 @@ def test_prune_archives_with_local_path_calls_borg_via_local_path():
 def test_prune_archives_with_remote_path_calls_borg_with_remote_path_parameters():
    retention_config = flexmock()
    flexmock(module).should_receive('_make_prune_flags').with_args(retention_config).and_return(
-        BASE_PRUNE_FLAGS,
+        BASE_PRUNE_FLAGS
    )
    insert_subprocess_mock(PRUNE_COMMAND + ('--remote-path', 'borg1'))

    module.prune_archives(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        storage_config={},
@ -157,12 +132,11 @@ def test_prune_archives_with_umask_calls_borg_with_umask_parameters():
    storage_config = {'umask': '077'}
    retention_config = flexmock()
    flexmock(module).should_receive('_make_prune_flags').with_args(retention_config).and_return(
-        BASE_PRUNE_FLAGS,
+        BASE_PRUNE_FLAGS
    )
    insert_subprocess_mock(PRUNE_COMMAND + ('--umask', '077'))

    module.prune_archives(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        storage_config=storage_config,
@ -174,12 +148,11 @@ def test_prune_archives_with_lock_wait_calls_borg_with_lock_wait_parameters():
    storage_config = {'lock_wait': 5}
    retention_config = flexmock()
    flexmock(module).should_receive('_make_prune_flags').with_args(retention_config).and_return(
-        BASE_PRUNE_FLAGS,
+        BASE_PRUNE_FLAGS
    )
    insert_subprocess_mock(PRUNE_COMMAND + ('--lock-wait', '5'))

    module.prune_archives(
-        verbosity=None,
        dry_run=False,
        repository='repo',
        storage_config=storage_config,
--- a/tests/unit/commands/init.py
+++ b/tests/unit/commands/init.py
--- a/tests/unit/commands/test_borgmatic.py
+++ b/tests/unit/commands/test_borgmatic.py
@ -0,0 +1,47 @@
+import json
+import sys
+
+from flexmock import flexmock
+
+from borgmatic.commands import borgmatic
+
+
+def test__run_commands_handles_multiple_json_outputs_in_array():
+    (
+        flexmock(borgmatic)
+        .should_receive('_run_commands_on_repository')
+        .times(3)
+        .replace_with(
+            lambda args, consistency, json_results, local_path, location, remote_path, retention, storage, unexpanded_repository: json_results.append(
+                {"whatever": unexpanded_repository}
+            )
+        )
+    )
+
+    (
+        flexmock(sys.stdout)
+        .should_call("write")
+        .with_args(
+            json.dumps(
+                json.loads(
+                    '''
+                        [
+                            {"whatever": "fake_repo1"},
+                            {"whatever": "fake_repo2"},
+                            {"whatever": "fake_repo3"}
+                        ]
+                    '''
+                )
+            )
+        )
+    )
+
+    borgmatic._run_commands(
+        args=flexmock(json=True),
+        consistency=None,
+        local_path=None,
+        location={'repositories': ['fake_repo1', 'fake_repo2', 'fake_repo3']},
+        remote_path=None,
+        retention=None,
+        storage=None,
+    )
--- a/tests/unit/config/init.py
+++ b/tests/unit/config/init.py
--- a/borgmatic/tests/unit/config/test_collect.py
+++ b/borgmatic/tests/unit/config/test_collect.py
@ -3,6 +3,22 @@ from flexmock import flexmock
 from borgmatic.config import collect as module


+def test_get_default_config_paths_includes_absolute_user_config_path():
+    flexmock(module.os, environ={'XDG_CONFIG_HOME': None, 'HOME': '/home/user'})
+
+    config_paths = module.get_default_config_paths()
+
+    assert '/home/user/.config/borgmatic/config.yaml' in config_paths
+
+
+def test_get_default_config_paths_prefers_xdg_config_home_for_user_config_path():
+    flexmock(module.os, environ={'XDG_CONFIG_HOME': '/home/user/.etc', 'HOME': '/home/user'})
+
+    config_paths = module.get_default_config_paths()
+
+    assert '/home/user/.etc/borgmatic/config.yaml' in config_paths
+
+
 def test_collect_config_filenames_collects_given_files():
    config_paths = ('config.yaml', 'other.yaml')
    flexmock(module.os.path).should_receive('isdir').and_return(False)
@ -32,6 +48,21 @@ def test_collect_config_filenames_collects_files_from_given_directories_and_igno
    )


+def test_collect_config_filenames_collects_files_from_given_directories_and_ignores_non_yaml_filenames():
+    config_paths = ('/etc/borgmatic.d',)
+    mock_path = flexmock(module.os.path)
+    mock_path.should_receive('exists').and_return(True)
+    mock_path.should_receive('isdir').with_args('/etc/borgmatic.d').and_return(True)
+    mock_path.should_receive('isdir').with_args('/etc/borgmatic.d/foo.yaml').and_return(False)
+    mock_path.should_receive('isdir').with_args('/etc/borgmatic.d/bar.yaml~').and_return(False)
+    mock_path.should_receive('isdir').with_args('/etc/borgmatic.d/baz.txt').and_return(False)
+    flexmock(module.os).should_receive('listdir').and_return(['foo.yaml', 'bar.yaml~', 'baz.txt'])
+
+    config_filenames = tuple(module.collect_config_filenames(config_paths))
+
+    assert config_filenames == ('/etc/borgmatic.d/foo.yaml',)
+
+
 def test_collect_config_filenames_skips_etc_borgmatic_config_dot_yaml_if_it_does_not_exist():
    config_paths = ('config.yaml', '/etc/borgmatic/config.yaml')
    mock_path = flexmock(module.os.path)
--- a/borgmatic/tests/unit/config/test_convert.py
+++ b/borgmatic/tests/unit/config/test_convert.py
@ -33,25 +33,31 @@ def test_convert_legacy_parsed_config_transforms_source_config_to_mapping():

    destination_config = module.convert_legacy_parsed_config(source_config, source_excludes, schema)

-    assert destination_config == OrderedDict([
-        (
-            'location',
-            OrderedDict([
-                ('source_directories', ['/home']),
-                ('repositories', ['hostname.borg']),
-                ('exclude_patterns', ['/var']),
-            ]),
-        ),
-        ('storage', OrderedDict([('encryption_passphrase', 'supersecret')])),
-        ('retention', OrderedDict([('keep_daily', 7)])),
-        ('consistency', OrderedDict([('checks', ['repository'])])),
-    ])
+    assert destination_config == OrderedDict(
+        [
+            (
+                'location',
+                OrderedDict(
+                    [
+                        ('source_directories', ['/home']),
+                        ('repositories', ['hostname.borg']),
+                        ('exclude_patterns', ['/var']),
+                    ]
+                ),
+            ),
+            ('storage', OrderedDict([('encryption_passphrase', 'supersecret')])),
+            ('retention', OrderedDict([('keep_daily', 7)])),
+            ('consistency', OrderedDict([('checks', ['repository'])])),
+        ]
+    )


 def test_convert_legacy_parsed_config_splits_space_separated_values():
    flexmock(module.yaml.comments).should_receive('CommentedMap').replace_with(OrderedDict)
    source_config = Parsed_config(
-        location=OrderedDict([('source_directories', '/home /etc'), ('repository', 'hostname.borg')]),
+        location=OrderedDict(
+            [('source_directories', '/home /etc'), ('repository', 'hostname.borg')]
+        ),
        storage=OrderedDict(),
        retention=OrderedDict(),
        consistency=OrderedDict([('checks', 'repository archives')]),
@ -59,21 +65,25 @@ def test_convert_legacy_parsed_config_splits_space_separated_values():
    source_excludes = ['/var']
    schema = {'map': defaultdict(lambda: {'map': {}})}

-    destination_config = module.convert_legacy_parsed_config(source_config, source_excludes, schema) 
+    destination_config = module.convert_legacy_parsed_config(source_config, source_excludes, schema)

-    assert destination_config == OrderedDict([
-        (
-            'location',
-            OrderedDict([
-                ('source_directories', ['/home', '/etc']),
-                ('repositories', ['hostname.borg']),
-                ('exclude_patterns', ['/var']),
-            ]),
-        ),
-        ('storage', OrderedDict()),
-        ('retention', OrderedDict()),
-        ('consistency', OrderedDict([('checks', ['repository', 'archives'])])),
-    ])
+    assert destination_config == OrderedDict(
+        [
+            (
+                'location',
+                OrderedDict(
+                    [
+                        ('source_directories', ['/home', '/etc']),
+                        ('repositories', ['hostname.borg']),
+                        ('exclude_patterns', ['/var']),
+                    ]
+                ),
+            ),
+            ('storage', OrderedDict()),
+            ('retention', OrderedDict()),
+            ('consistency', OrderedDict([('checks', ['repository', 'archives'])])),
+        ]
+    )


 def test_guard_configuration_upgraded_raises_when_only_source_config_present():
--- a/tests/unit/config/test_generate.py
+++ b/tests/unit/config/test_generate.py
@ -0,0 +1,37 @@
+from collections import OrderedDict
+
+from flexmock import flexmock
+
+from borgmatic.config import generate as module
+
+
+def test_schema_to_sample_configuration_generates_config_with_examples():
+    flexmock(module.yaml.comments).should_receive('CommentedMap').replace_with(OrderedDict)
+    flexmock(module).should_receive('add_comments_to_configuration')
+    schema = {
+        'map': OrderedDict(
+            [
+                ('section1', {'map': {'field1': OrderedDict([('example', 'Example 1')])}}),
+                (
+                    'section2',
+                    {
+                        'map': OrderedDict(
+                            [
+                                ('field2', {'example': 'Example 2'}),
+                                ('field3', {'example': 'Example 3'}),
+                            ]
+                        )
+                    },
+                ),
+            ]
+        )
+    }
+
+    config = module._schema_to_sample_configuration(schema)
+
+    assert config == OrderedDict(
+        [
+            ('section1', OrderedDict([('field1', 'Example 1')])),
+            ('section2', OrderedDict([('field2', 'Example 2'), ('field3', 'Example 3')])),
+        ]
+    )
--- a/borgmatic/tests/unit/config/test_legacy.py
+++ b/borgmatic/tests/unit/config/test_legacy.py
@ -25,17 +25,9 @@ def test_validate_configuration_format_with_valid_config_should_not_raise():
    parser.should_receive('options').with_args('other').and_return(('such',))
    config_format = (
        module.Section_format(
-            'section',
-            options=(
-                module.Config_option('stuff', str, required=True),
-            ),
-        ),
-        module.Section_format(
-            'other',
-            options=(
-                module.Config_option('such', str, required=True),
-            ),
+            'section', options=(module.Config_option('stuff', str, required=True),)
        ),
+        module.Section_format('other', options=(module.Config_option('such', str, required=True),)),
    )

    module.validate_configuration_format(parser, config_format)
@ -46,10 +38,7 @@ def test_validate_configuration_format_with_missing_required_section_should_rais
    parser.should_receive('sections').and_return(('section',))
    config_format = (
        module.Section_format(
-            'section',
-            options=(
-                module.Config_option('stuff', str, required=True),
-            ),
+            'section', options=(module.Config_option('stuff', str, required=True),)
        ),
        # At least one option in this section is required, so the section is required.
        module.Section_format(
@ -71,10 +60,7 @@ def test_validate_configuration_format_with_missing_optional_section_should_not_
    parser.should_receive('options').with_args('section').and_return(('stuff',))
    config_format = (
        module.Section_format(
-            'section',
-            options=(
-                module.Config_option('stuff', str, required=True),
-            ),
+            'section', options=(module.Config_option('stuff', str, required=True),)
        ),
        # No options in the section are required, so the section is optional.
        module.Section_format(
@ -92,9 +78,7 @@ def test_validate_configuration_format_with_missing_optional_section_should_not_
 def test_validate_configuration_format_with_unknown_section_should_raise():
    parser = flexmock()
    parser.should_receive('sections').and_return(('section', 'extra'))
-    config_format = (
-        module.Section_format('section', options=()),
-    )
+    config_format = (module.Section_format('section', options=()),)

    with pytest.raises(ValueError):
        module.validate_configuration_format(parser, config_format)
@ -141,8 +125,7 @@ def test_validate_configuration_format_with_extra_option_should_raise():
    parser.should_receive('options').with_args('section').and_return(('option', 'extra'))
    config_format = (
        module.Section_format(
-            'section',
-            options=(module.Config_option('option', str, required=True),),
+            'section', options=(module.Config_option('option', str, required=True),)
        ),
    )

@ -168,12 +151,7 @@ def test_parse_section_options_should_return_section_options():

    config = module.parse_section_options(parser, section_format)

-    assert config == OrderedDict(
-        (
-            ('foo', 'value'),
-            ('bar', 1),
-        )
-    )
+    assert config == OrderedDict((('foo', 'value'), ('bar', 1)))


 def test_parse_section_options_for_missing_section_should_return_empty_dict():
@ -210,13 +188,13 @@ def test_parse_configuration_should_return_section_configs():
    config_format = (flexmock(name='items'), flexmock(name='things'))
    mock_module = flexmock(module)
    mock_module.should_receive('validate_configuration_format').with_args(
-        parser, config_format,
+        parser, config_format
    ).once()
    mock_section_configs = (flexmock(), flexmock())

    for section_format, section_config in zip(config_format, mock_section_configs):
        mock_module.should_receive('parse_section_options').with_args(
-            parser, section_format,
+            parser, section_format
        ).and_return(section_config).once()

    parsed_config = module.parse_configuration('filename', config_format)
--- a/borgmatic/tests/unit/config/test_validate.py
+++ b/borgmatic/tests/unit/config/test_validate.py
@ -24,6 +24,7 @@ def test_apply_logical_validation_raises_if_archive_name_format_present_without_
            },
        )

+
 def test_apply_logical_validation_raises_if_archive_name_format_present_without_retention_prefix():
    with pytest.raises(module.Validation_error):
        module.apply_logical_validation(
@ -31,7 +32,7 @@ def test_apply_logical_validation_raises_if_archive_name_format_present_without_
            {
                'storage': {'archive_name_format': '{hostname}-{now}'},
                'retention': {'keep_daily': 7},
-                'consistency': {'prefix': '{hostname}-'}
+                'consistency': {'prefix': '{hostname}-'},
            },
        )

@ -59,15 +60,10 @@ def test_apply_logical_validation_does_not_raise_or_warn_if_archive_name_format_
        {
            'storage': {'archive_name_format': '{hostname}-{now}'},
            'retention': {'prefix': '{hostname}-'},
-            'consistency': {'prefix': '{hostname}-'}
+            'consistency': {'prefix': '{hostname}-'},
        },
    )


 def test_apply_logical_validation_does_not_raise_otherwise():
-    module.apply_logical_validation(
-        'config.yaml',
-        {
-            'retention': {'keep_secondly': 1000},
-        },
-    )
+    module.apply_logical_validation('config.yaml', {'retention': {'keep_secondly': 1000}})
--- a/tests/unit/test_verbosity.py
+++ b/tests/unit/test_verbosity.py
@ -0,0 +1,21 @@
+import logging
+
+from flexmock import flexmock
+
+from borgmatic import verbosity as module
+
+
+def insert_logging_mock(log_level):
+    """ Mocks the isEnabledFor from python logging. """
+    logging = flexmock(module.logging.Logger)
+    logging.should_receive('isEnabledFor').replace_with(lambda lvl: lvl >= log_level)
+    logging.should_receive('getEffectiveLevel').replace_with(lambda: log_level)
+
+
+def test_verbosity_to_log_level_maps_known_verbosity_to_log_level():
+    assert module.verbosity_to_log_level(module.VERBOSITY_SOME) == logging.INFO
+    assert module.verbosity_to_log_level(module.VERBOSITY_LOTS) == logging.DEBUG
+
+
+def test_verbosity_to_log_level_maps_unknown_verbosity_to_warning_level():
+    assert module.verbosity_to_log_level('my pants') == logging.WARNING
--- a/tox.ini
+++ b/tox.ini
@ -1,8 +1,26 @@
 [tox]
-envlist=py3
-skipsdist=True
+envlist = py3
+skipsdist = True

 [testenv]
-usedevelop=True
-deps=-rtest_requirements.txt
-commands = py.test --cov-report term-missing:skip-covered --cov=borgmatic borgmatic []
+usedevelop = True
+deps = -rtest_requirements.txt
+commands =
+    py.test --cov-report term-missing:skip-covered --cov=borgmatic --ignore=tests/end-to-end \
+        tests []
+    black --skip-string-normalization --line-length 100 --check .
+    flake8 .
+
+[testenv:black]
+basepython = python3.7
+commands =
+    black --skip-string-normalization --line-length 100 .
+
+[testenv:end-to-end]
+deps = -rtest_requirements.txt
+commands =
+    py.test tests/end-to-end []
+
+[flake8]
+ignore = E501,W503
+exclude = *.*/*
Author	SHA1	Message	Date
Dan Helfman	da8e9638f4	Support for Borg --keep-secondly prune option (#98 ). All checks were successful the build was successful Details	2018-10-04 21:54:23 -07:00
Dan Helfman	900ea80a42	Hack to uncomment all options in config file used for finding unsupported Borg options. All checks were successful the build was successful Details	2018-10-04 21:45:31 -07:00
Dan Helfman	4b92d0f685	Remove unneeded Dockerfile for end-to-end tests. All checks were successful the build was successful Details	2018-10-03 22:44:23 -07:00
Dan Helfman	3ce5533103	Make end-to-end test clean up after itself, and drop unnecessary use of Docker for it. All checks were successful the build was successful Details	2018-10-03 22:36:25 -07:00
Dan Helfman	4a1ee8c911	Pull new base Docker images during CI. All checks were successful the build was successful Details	2018-10-03 19:35:42 -07:00
Dan Helfman	3f22a99412	Rev pykwalify. All checks were successful the build was successful Details	2018-10-03 08:59:08 -07:00
Dan Helfman	caf95cc913	Rebuild. All checks were successful the build was successful Details	2018-09-30 22:58:23 -07:00
Dan Helfman	fd3130b4d9	Install tox before using it.	2018-09-30 22:47:07 -07:00
Dan Helfman	65bb5a49e2	CI?	2018-09-30 22:43:49 -07:00
Dan Helfman	4bcc517326	Attempted Drone CI configuration.	2018-09-30 22:09:53 -07:00
Dan Helfman	0b164973e0	Add an end-to-end automated test that actually integrates with Borg.	2018-09-30 17:30:04 -07:00
Dan Helfman	a125df991b	Move tests to the root of the repository, in keeping with more common convention.	2018-09-30 13:57:20 -07:00
Dan Helfman	f9a9b42c58	A little introductory text for the screencast.	2018-09-30 11:11:07 -07:00
Dan Helfman	56ad1d164a	Use Flake8 code checker as part of running automated tests.	2018-09-29 23:15:18 -07:00
Dan Helfman	3cce18919c	Switch Black link to documentation.	2018-09-29 22:46:34 -07:00
Dan Helfman	76d6a69f5a	Use Black code formatter as part of running automated tests.	2018-09-29 22:45:00 -07:00
Dan Helfman	3db17277b4	Replace broken screencast thumbnail with embedded player.	2018-09-29 21:38:38 -07:00
Dan Helfman	ece49eb500	Update screencast.	2018-09-29 18:56:39 -07:00
Dan Helfman	746428ed44	Fix generated configuration to also include a "keep_daily" value so pruning works out of the box.	2018-09-29 15:44:37 -07:00
Dan Helfman	984702b3b2	Fix various warnings.	2018-09-29 15:06:57 -07:00
Dan Helfman	1bc71e1c5d	Upgrade test requirements.	2018-09-29 15:04:42 -07:00
Dan Helfman	47efa88c9d	In generate-borgmatic-config, comment out all optional config (#57 ).	2018-09-29 15:03:11 -07:00
Dan Helfman	3821636b77	Bump version.	2018-09-27 08:13:23 -07:00
Dan Helfman	596f6f9dac	Update help/README about --create --json.	2018-09-27 08:12:54 -07:00
Dan Helfman	7ecdaea83a	Fix check_archives does not take json parameter.	2018-09-27 08:09:23 -07:00
Nils Hesse	98cb2644db	check_archives does not take json parameter	2018-09-27 12:21:14 +02:00
Dan Helfman	31db6faa19	Set to release version.	2018-09-26 21:32:28 -07:00
Dan Helfman	872d8b695a	Flesh out NEWS line item a bit.	2018-09-24 21:37:45 -07:00
Dan Helfman	6db3e1dda5	Merge branch 'master' of floli/borgmatic into master	2018-09-25 04:36:09 +00:00
Florian Lindner	9aaf78b9dd	Add --json option for --create command line. Closes #94.	2018-09-24 21:53:09 +02:00
Dan Helfman	5d8ac158ce	Merge ssh://projects.torsion.org:3022/witten/borgmatic	2018-09-17 22:34:08 -07:00
Dan Helfman	d32a53d58f	Mention log level fix in NEWS.	2018-09-17 22:33:34 -07:00
floli	a836ec944f	Limit argument range for --verbose, make default log level more explicit. (#93 )	2018-09-18 05:31:27 +00:00
Dan Helfman	e7b128e735	--read-special is now supported.	2018-09-09 11:21:06 -07:00
Dan Helfman	ff3cb1d80f	Attach #64 to logging rewrite in NEWS.	2018-09-09 11:18:26 -07:00
Dan Helfman	c5ff08ee25	Remove now-gone verbosity parameter from test.	2018-09-09 11:14:33 -07:00
Dan Helfman	856db29180	Mention --read-special in NEWS.	2018-09-09 10:42:06 -07:00
Steve Kerrison	20e09b4ea8	Support for Borg create --read-special via "read_special" option (#25 ).	2018-09-09 10:39:56 -07:00
Dan Helfman	1dd0682661	Merge branch 'master' of ssh://projects.torsion.org:3022/witten/borgmatic	2018-09-08 13:54:18 -07:00
floli	7252b8d614	Rework logging/verbosity system (#90 ) Looks great, merged! Thanks again for all your hard work here.	2018-09-08 20:53:37 +00:00
grerrg	e5870a169b	Add example for cron in Alpine Linux (#24 )	2018-09-05 21:58:30 -07:00
Dan Helfman	94795a3560	Link to Borg home page instead of docs.	2018-09-02 22:06:57 -07:00
Dan	7705debab0	Switching back to table-like 11ty front matter. It looks less bad than JSON.	2018-09-01 22:45:13 -07:00
Dan	f87df0527f	Adding JSON front matter for 11ty.	2018-09-01 22:38:17 -07:00
Dan Helfman	e4512a40e0	Removing 11ty front matter out of README since it renders as a table on GitHub.	2018-09-01 22:11:38 -07:00
Dan Helfman	1d4a9510b8	Upgrade pytest.	2018-09-01 20:29:05 -07:00
Dan Helfman	2648f07e7a	Add missing syntax highlighting.	2018-08-29 23:01:11 -07:00
Dan Helfman	459bf1fcf6	Document --list and --info flags.	2018-08-29 22:57:32 -07:00
Dan	3930e63320	Merge branch 'master' of ssh://projects.torsion.org:3022/witten/borgmatic	2018-08-29 22:44:45 -07:00
Dan	acecb1e397	README metadata changes to support 11ty static site generator.	2018-08-29 22:44:12 -07:00
Dan Helfman	9b48eb5a61	Clarify that --json can be used with --info command-line flag.	2018-08-19 12:57:52 -07:00
Dan Helfman	7d40a448cb	Pass --show-rc option to Borg when at highest verbosity level (#89 ).	2018-08-19 12:44:40 -07:00
Dan Helfman	da7aed3814	Support for Borg create --checkpoint-interval (#87 ).	2018-08-19 11:41:49 -07:00
Dan Helfman	c7f4200417	Somewhat more robust mechanism to find unsupported Borg arguments.	2018-08-19 11:24:48 -07:00
Dan Helfman	5e2a5494af	Fix declared pykwalify compatibility version range in setup.py (#88 ).	2018-08-18 14:07:18 -07:00
Dan Helfman	7b77fd2510	Fix compatibility issue between pykwalify and ruamel.yaml 0.15.52 (#85 ).	2018-08-11 13:59:27 -07:00
Dan Helfman	ece5608677	Rev for release.	2018-07-28 22:27:39 -07:00
Dan Helfman	4644f613b2	Fix typo in README.	2018-07-28 22:24:24 -07:00
Dan Helfman	3afa5ac76d	Document hooks (#81 ).	2018-07-28 22:22:25 -07:00
Dan Helfman	27f8a1df04	Switch to non-raw link to sample cron job.	2018-07-28 20:29:55 -07:00
Dan Helfman	8e5b0bbf17	Remove errant ctrl-F character from docs.	2018-07-28 20:27:18 -07:00
Dan Helfman	282e9565c9	Mentioning new --info --json option in NEWS.	2018-07-28 20:24:19 -07:00
Thomas LÉVEIL	b714ffd48b	add support for `--info --json` (#83 )	2018-07-29 03:17:45 +00:00
Dan Helfman	9968a15ef8	Clarifying code style for multiline constructs.	2018-07-28 15:21:19 -07:00
Dan Helfman	d93da55ce9	Add code style guidelines to the documention, and reformat some code accordingly.	2018-07-28 15:02:17 -07:00
Thomas LÉVEIL	789bcd402a	add support for `--list --json` (#74 )	2018-07-28 21:21:38 +00:00
Dan Helfman	cf6ab60d2e	Use XDG_CONFIG_HOME for user configuration directory, if set. (Thanks to floli.) (#71 ) Thanks! This will go out in the next release.	2018-07-25 01:34:05 +00:00
Dan Helfman	64364b20ff	Skip non-"*.yaml" config filenames in /etc/borgmatic.d/ so as not to parse backup files, editor swap files, etc. (#77 )	2018-07-22 12:08:49 -07:00
Dan Helfman	d29c7956bc	Upgrade ruamel.yaml compatibility version range and fix support for Python 3.7 (#38 , #76 ).	2018-07-22 11:25:06 -07:00
Dan Helfman	e5ef485d6b	Merge branch 'master' of ssh://projects.torsion.org:3022/witten/borgmatic	2018-07-01 14:54:15 -07:00
Dan Helfman	fc8046edc4	Adding NEWS item about skipping before/after backup hooks.	2018-07-01 14:51:57 -07:00
Dan Helfman	4538017206	Merge branch 'fix-72-hooks-are-executed-when-list-or-info' of thomasleveil/borgmatic into master Thanks for fixing this! I agree about more specific hooks if and when `--check` or `--prune`-specific hook use cases are needed. I think what you've done here is fine until then.	2018-07-01 21:47:39 +00:00
Thomas LEVEIL	d664b6d253	only run hooks when creating an archive fix #72	2018-07-01 21:09:45 +02:00
Dan Helfman	f42aa0a6f2	Revving version for development.	2018-06-17 15:26:53 -07:00