Prepare for version 3.3.0

* Support nested ifs in default template (#436)
 * Support include and ifs in default template includes (#406)
 * Support environment variables in ifs in default template (#488)
 * Support != in default template (#358, #477)
 * Fix multiple classes in default template on macOS (#437)

.flake8

@@ -0,0 +1,2 @@
+[flake8]
+max-line-length = 120

CHANGES

@@ -1,3 +1,10 @@
+3.3.0
+  * Support nested ifs in default template (#436)
+  * Support include and ifs in default template includes (#406)
+  * Support environment variables in ifs in default template (#488)
+  * Support != in default template (#358, #477)
+  * Fix multiple classes in default template on macOS (#437)
+
 3.2.2
   * Support spaces in distro/distro-family (#432)
   * Fix zsh hanging when tab completing add/checkout (#417)

CONTRIBUTORS

@@ -25,9 +25,9 @@ Paulo Köch
 Oren Zipori
 Daniel Gray
 Paraplegic Racehorse
-japm48
 Siôn Le Roux
 Mateusz Piotrowski
+japm48
 Uroš Golja
 Satoshi Ohki
 Jonas
@@ -35,18 +35,20 @@ Franciszek Madej
 Daniel Wagenknecht
 Stig Palmquist
 Patrick Hof
-con-f-use
 Samisafool
+LFdev
+con-f-use
 Bram Ceulemans
 Travis A. Everett
 Sheng Yang
 Jared Smartt
 Adam Jimerson
-dessert1
-addshore
 Tim Condit
 Thomas Luzat
 Russ Allbery
+Patrick Roddy
+dessert1
 Brayden Banks
 Alexandre GV
+addshore
 Felipe S. S. Schneider

Makefile

@@ -1,5 +1,5 @@
 PYTESTS = $(wildcard test/test_*.py)
-IMAGE = docker.io/yadm/testbed:2022-01-07
+IMAGE = docker.io/yadm/testbed:2023-07-12
 OCI = docker
 
 .PHONY: all

README.md

@@ -72,7 +72,7 @@ The star count helps others discover yadm.
 [master-badge]: https://img.shields.io/github/actions/workflow/status/yadm-dev/yadm/test.yml?branch=master
 [master-commits]: https://github.com/yadm-dev/yadm/commits/master
 [master-date]: https://img.shields.io/github/last-commit/yadm-dev/yadm/master.svg?label=master
-[obs-badge]: https://img.shields.io/badge/OBS-v3.2.2-blue
+[obs-badge]: https://img.shields.io/badge/OBS-v3.3.0-blue
 [obs-link]: https://software.opensuse.org//download.html?project=home%3ATheLocehiliosan%3Ayadm&package=yadm
 [releases-badge]: https://img.shields.io/github/tag/yadm-dev/yadm.svg?label=latest+release
 [releases-link]: https://github.com/yadm-dev/yadm/releases

pylintrc

@@ -1,17 +0,0 @@
-[BASIC]
-good-names=pytestmark
-
-[DESIGN]
-max-args=14
-max-locals=28
-max-attributes=8
-max-statements=65
-
-[SIMILARITIES]
-min-similarity-lines=8
-
-[MESSAGES CONTROL]
-disable=redefined-outer-name
-
-[TYPECHECK]
-ignored-modules=py

pyproject.toml

@@ -0,0 +1,31 @@
+[tool.pytest.ini_options]
+cache_dir = "/tmp"
+addopts = "-ra"
+markers = [
+  "deprecated", # marks tests for deprecated features (deselect with '-m "not deprecated"')
+]
+
+[tool.pylint.design]
+max-args = 14
+max-locals = 28
+max-attributes = 8
+max-statements = 65
+
+[tool.pylint.format]
+max-line-length = 120
+
+[tool.pylint."messages control"]
+disable = [
+  "redefined-outer-name",
+]
+
+[tool.pylint.similarities]
+ignore-imports = "yes"
+min-similarity-lines = 8
+
+[tool.black]
+line-length = 120
+
+[tool.isort]
+line_length = 120
+profile = "black"

pytest.ini

@@ -1,5 +0,0 @@
-[pytest]
-cache_dir = /tmp
-addopts = -ra
-markers =
-  deprecated: marks tests for deprecated features (deselect with '-m "not deprecated"')

test/Dockerfile

@@ -1,9 +1,9 @@
-FROM ubuntu:18.04
+FROM ubuntu:23.04
 MAINTAINER Tim Byrne <sultan@locehilios.com>
 
 # Shellcheck and esh versions
-ARG SC_VER=0.8.0
+ARG SC_VER=0.9.0
-ARG ESH_VER=0.3.1
+ARG ESH_VER=0.3.2
 
 # Install prerequisites and configure UTF-8 locale
 RUN \
@@ -41,8 +41,8 @@ RUN cd /opt \
 
 # Upgrade pip3 and install requirements
 COPY test/requirements.txt /tmp/requirements.txt
-RUN python3 -m pip install --upgrade pip setuptools \
+RUN python3 -m pip install --break-system-packages --upgrade pip setuptools \
-  && python3 -m pip install --upgrade -r /tmp/requirements.txt \
+  && python3 -m pip install --break-system-packages --upgrade -r /tmp/requirements.txt \
   && rm -f /tmp/requirements
 
 # Install esh

test/conftest.py

@@ -3,11 +3,12 @@
 import collections
 import contextlib
 import copy
-import distutils.dir_util  # pylint: disable=no-name-in-module,import-error
 import os
 import platform
 import pwd
-from subprocess import Popen, PIPE
+import shutil
+from subprocess import PIPE, Popen
+
 import py
 import pytest
 
@@ -22,157 +23,168 @@ def pytest_addoption(parser):
     )
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def shellcheck_version():
     """Version of shellcheck supported"""
-    return '0.8.0'
+    return "0.9.0"
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def pylint_version():
     """Version of pylint supported"""
-    return '2.6.0'
+    return "2.17.0"
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
+def isort_version():
+    """Version of isort supported"""
+    return "5.12.0"
+
+
+@pytest.fixture(scope="session")
 def flake8_version():
     """Version of flake8 supported"""
-    return '3.8.4'
+    return "6.0.0"
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
+def black_version():
+    """Version of black supported"""
+    return "23.1.0"
+
+
+@pytest.fixture(scope="session")
 def yamllint_version():
     """Version of yamllint supported"""
-    return '1.25.0'
+    return "1.30.0"
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def tst_user():
     """Test session's user id"""
     return pwd.getpwuid(os.getuid()).pw_name
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def tst_host():
     """Test session's short hostname value"""
-    return platform.node().split('.')[0]
+    return platform.node().split(".")[0]
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def tst_distro(runner):
     """Test session's distro"""
-    distro = ''
+    distro = ""
     with contextlib.suppress(Exception):
-        run = runner(command=['lsb_release', '-si'], report=False)
+        run = runner(command=["lsb_release", "-si"], report=False)
         distro = run.out.strip()
     return distro
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def tst_distro_family(runner):
     """Test session's distro_family"""
-    family = ''
+    family = ""
     with contextlib.suppress(Exception):
-        run = runner(command=[
+        run = runner(command=["grep", "-oP", r"ID_LIKE=\K.+", "/etc/os-release"], report=False)
-            'grep', '-oP', r'ID_LIKE=\K.+', '/etc/os-release'], report=False)
         family = run.out.strip()
     return family
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def tst_sys():
     """Test session's uname value"""
     return platform.system()
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def tst_arch():
     """Test session's uname value"""
     return platform.machine()
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def supported_commands():
     """List of supported commands
 
     This list should be updated every time yadm learns a new command.
     """
     return [
-        'alt',
+        "alt",
-        'bootstrap',
+        "bootstrap",
-        'clean',
+        "clean",
-        'clone',
+        "clone",
-        'config',
+        "config",
-        'decrypt',
+        "decrypt",
-        'encrypt',
+        "encrypt",
-        'enter',
+        "enter",
-        'git-crypt',
+        "git-crypt",
-        'gitconfig',
+        "gitconfig",
-        'help',
+        "help",
-        'init',
+        "init",
-        'introspect',
+        "introspect",
-        'list',
+        "list",
-        'perms',
+        "perms",
-        'transcrypt',
+        "transcrypt",
-        'upgrade',
+        "upgrade",
-        'version',
+        "version",
-        ]
+    ]
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def supported_configs():
     """List of supported config options
 
     This list should be updated every time yadm learns a new config.
     """
     return [
-        'local.arch',
+        "local.arch",
-        'local.class',
+        "local.class",
-        'local.hostname',
+        "local.hostname",
-        'local.os',
+        "local.os",
-        'local.user',
+        "local.user",
-        'yadm.alt-copy',
+        "yadm.alt-copy",
-        'yadm.auto-alt',
+        "yadm.auto-alt",
-        'yadm.auto-exclude',
+        "yadm.auto-exclude",
-        'yadm.auto-perms',
+        "yadm.auto-perms",
-        'yadm.auto-private-dirs',
+        "yadm.auto-private-dirs",
-        'yadm.cipher',
+        "yadm.cipher",
-        'yadm.git-program',
+        "yadm.git-program",
-        'yadm.gpg-perms',
+        "yadm.gpg-perms",
-        'yadm.gpg-program',
+        "yadm.gpg-program",
-        'yadm.gpg-recipient',
+        "yadm.gpg-recipient",
-        'yadm.openssl-ciphername',
+        "yadm.openssl-ciphername",
-        'yadm.openssl-old',
+        "yadm.openssl-old",
-        'yadm.openssl-program',
+        "yadm.openssl-program",
-        'yadm.ssh-perms',
+        "yadm.ssh-perms",
-        ]
+    ]
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def supported_switches():
     """List of supported switches
 
     This list should be updated every time yadm learns a new switch.
     """
     return [
-        '--yadm-archive',
+        "--yadm-archive",
-        '--yadm-bootstrap',
+        "--yadm-bootstrap",
-        '--yadm-config',
+        "--yadm-config",
-        '--yadm-data',
+        "--yadm-data",
-        '--yadm-dir',
+        "--yadm-dir",
-        '--yadm-encrypt',
+        "--yadm-encrypt",
-        '--yadm-repo',
+        "--yadm-repo",
-        '-Y',
+        "-Y",
-        ]
+    ]
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def supported_local_configs(supported_configs):
     """List of supported local config options"""
-    return [c for c in supported_configs if c.startswith('local.')]
+    return [c for c in supported_configs if c.startswith("local.")]
 
 
-class Runner():
+class Runner:
     """Class for running commands
 
     Within yadm tests, this object should be used when running commands that
@@ -185,17 +197,9 @@ class Runner():
     Other instances of simply running commands should use os.system().
     """
 
-    def __init__(
+    def __init__(self, command, inp=None, shell=False, cwd=None, env=None, expect=None, report=True):
-            self,
-            command,
-            inp=None,
-            shell=False,
-            cwd=None,
-            env=None,
-            expect=None,
-            report=True):
         if shell:
-            self.command = ' '.join([str(cmd) for cmd in command])
+            self.command = " ".join([str(cmd) for cmd in command])
         else:
             self.command = command
         if env is None:
@@ -204,7 +208,7 @@ class Runner():
         merged_env.update(env)
         self.inp = inp
         self.wrap(expect)
-        process = Popen(
+        with Popen(
             self.command,
             stdin=PIPE,
             stdout=PIPE,
@@ -212,67 +216,57 @@ class Runner():
             shell=shell,
             cwd=cwd,
             env=merged_env,
-        )
+        ) as process:
-        input_bytes = self.inp
+            input_bytes = self.inp
-        if self.inp:
+            if self.inp:
-            input_bytes = self.inp.encode()
+                input_bytes = self.inp.encode()
-        (out_bstream, err_bstream) = process.communicate(input=input_bytes)
+            (out_bstream, err_bstream) = process.communicate(input=input_bytes)
-        self.out = out_bstream.decode()
+            self.out = out_bstream.decode()
-        self.err = err_bstream.decode()
+            self.err = err_bstream.decode()
-        self.code = process.wait()
+            self.code = process.wait()
         self.success = self.code == 0
         self.failure = self.code != 0
         if report:
             self.report()
 
     def __repr__(self):
-        return f'Runner({self.command})'
+        return f"Runner({self.command})"
 
     def report(self):
         """Print code/stdout/stderr"""
-        print(f'{self}')
+        print(f"{self}")
-        print(f'  RUN: code:{self.code}')
+        print(f"  RUN: code:{self.code}")
         if self.inp:
-            print(f'  RUN: input:\n{self.inp}')
+            print(f"  RUN: input:\n{self.inp}")
-        print(f'  RUN: stdout:\n{self.out}')
+        print(f"  RUN: stdout:\n{self.out}")
-        print(f'  RUN: stderr:\n{self.err}')
+        print(f"  RUN: stderr:\n{self.err}")
 
     def wrap(self, expect):
         """Wrap command with expect"""
         if not expect:
             return
-        cmdline = ' '.join([f'"{w}"' for w in self.command])
+        cmdline = " ".join([f'"{w}"' for w in self.command])
-        expect_script = f'set timeout 2\nspawn {cmdline}\n'
+        expect_script = f"set timeout 2\nspawn {cmdline}\n"
         for question, answer in expect:
-            expect_script += (
+            expect_script += "expect {\n" f'"{question}" {{send "{answer}\\r"}}\n' "timeout {close;exit 128}\n" "}\n"
-                'expect {\n'
+        expect_script += "expect eof\n" "foreach {pid spawnid os_error_flag value} [wait] break\n" "exit $value"
-                f'"{question}" {{send "{answer}\\r"}}\n'
-                'timeout {close;exit 128}\n'
-                '}\n')
-        expect_script += (
-            'expect eof\n'
-            'foreach {pid spawnid os_error_flag value} [wait] break\n'
-            'exit $value')
         self.inp = expect_script
-        print(f'EXPECT:{expect_script}')
+        print(f"EXPECT:{expect_script}")
-        self.command = ['expect']
+        self.command = ["expect"]
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def runner():
     """Class for running commands"""
     return Runner
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def config_git():
     """Configure global git configuration, if missing"""
-    os.system(
+    os.system("git config init.defaultBranch || git config --global init.defaultBranch master")
-        'git config user.name || '
+    os.system('git config user.name || git config --global user.name "test"')
-        'git config --global user.name "test"')
+    os.system('git config user.email || git config --global user.email "test@test.test"')
-    os.system(
-        'git config user.email || '
-        'git config --global user.email "test@test.test"')
 
 
 @pytest.fixture()
@@ -282,19 +276,19 @@ def repo_config(runner, paths):
     def query_func(key):
         """Query a yadm repo configuration value"""
         run = runner(
-            command=('git', 'config', '--local', key),
+            command=("git", "config", "--local", key),
-            env={'GIT_DIR': paths.repo},
+            env={"GIT_DIR": paths.repo},
             report=False,
-            )
+        )
         return run.out.rstrip()
 
     return query_func
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def yadm():
     """Path to yadm program to be tested"""
-    full_path = os.path.realpath('yadm')
+    full_path = os.path.realpath("yadm")
     assert os.path.isfile(full_path), "yadm program file isn't present"
     return full_path
 
@@ -303,38 +297,40 @@ def yadm():
 def paths(tmpdir, yadm):
     """Function scoped test paths"""
 
-    dir_root = tmpdir.mkdir('root')
+    dir_root = tmpdir.mkdir("root")
-    dir_remote = dir_root.mkdir('remote')
+    dir_remote = dir_root.mkdir("remote")
-    dir_work = dir_root.mkdir('work')
+    dir_work = dir_root.mkdir("work")
-    dir_xdg_data = dir_root.mkdir('xdg_data')
+    dir_xdg_data = dir_root.mkdir("xdg_data")
-    dir_xdg_home = dir_root.mkdir('xdg_home')
+    dir_xdg_home = dir_root.mkdir("xdg_home")
-    dir_data = dir_xdg_data.mkdir('yadm')
+    dir_data = dir_xdg_data.mkdir("yadm")
-    dir_yadm = dir_xdg_home.mkdir('yadm')
+    dir_yadm = dir_xdg_home.mkdir("yadm")
-    dir_hooks = dir_yadm.mkdir('hooks')
+    dir_hooks = dir_yadm.mkdir("hooks")
-    dir_repo = dir_data.mkdir('repo.git')
+    dir_repo = dir_data.mkdir("repo.git")
-    file_archive = dir_data.join('archive')
+    file_archive = dir_data.join("archive")
-    file_bootstrap = dir_yadm.join('bootstrap')
+    file_bootstrap = dir_yadm.join("bootstrap")
-    file_config = dir_yadm.join('config')
+    file_config = dir_yadm.join("config")
-    file_encrypt = dir_yadm.join('encrypt')
+    file_encrypt = dir_yadm.join("encrypt")
     paths = collections.namedtuple(
-        'Paths', [
+        "Paths",
-            'pgm',
+        [
-            'root',
+            "pgm",
-            'remote',
+            "root",
-            'work',
+            "remote",
-            'xdg_data',
+            "work",
-            'xdg_home',
+            "xdg_data",
-            'data',
+            "xdg_home",
-            'yadm',
+            "data",
-            'hooks',
+            "yadm",
-            'repo',
+            "hooks",
-            'archive',
+            "repo",
-            'bootstrap',
+            "archive",
-            'config',
+            "bootstrap",
-            'encrypt',
+            "config",
-            ])
+            "encrypt",
-    os.environ['XDG_CONFIG_HOME'] = str(dir_xdg_home)
+        ],
-    os.environ['XDG_DATA_HOME'] = str(dir_xdg_data)
+    )
+    os.environ["XDG_CONFIG_HOME"] = str(dir_xdg_home)
+    os.environ["XDG_DATA_HOME"] = str(dir_xdg_data)
     return paths(
         yadm,
         dir_root,
@@ -350,19 +346,25 @@ def paths(tmpdir, yadm):
         file_bootstrap,
         file_config,
         file_encrypt,
-        )
+    )
 
 
 @pytest.fixture()
 def yadm_cmd(paths):
     """Generate custom command_list function"""
+
     def command_list(*args):
         """Produce params for running yadm with -Y"""
         return [paths.pgm] + list(args)
+
     return command_list
 
 
-class DataFile():
+class NoRelativePath(Exception):
+    """Exception when finding relative paths"""
+
+
+class DataFile:
     """Datafile object"""
 
     def __init__(self, path, tracked=True, private=False):
@@ -381,7 +383,7 @@ class DataFile():
         """Relative path property"""
         if self.__parent:
             return self.__parent.join(self.path)
-        raise BaseException('Unable to provide relative path, no parent')
+        raise NoRelativePath("Unable to provide relative path, no parent")
 
     @property
     def tracked(self):
@@ -398,22 +400,18 @@ class DataFile():
         self.__parent = parent
 
 
-class DataSet():
+class DataSet:
     """Dataset object"""
 
     def __init__(self):
-        self.__files = list()
+        self.__files = []
-        self.__dirs = list()
+        self.__dirs = []
-        self.__tracked_dirs = list()
+        self.__tracked_dirs = []
-        self.__private_dirs = list()
+        self.__private_dirs = []
         self.__relpath = None
 
     def __repr__(self):
-        return (
+        return f"[DS with {len(self)} files; " f"{len(self.tracked)} tracked, " f"{len(self.private)} private]"
-            f'[DS with {len(self)} files; '
-            f'{len(self.tracked)} tracked, '
-            f'{len(self.private)} private]'
-            )
 
     def __iter__(self):
         return iter(self.__files)
@@ -451,17 +449,17 @@ class DataSet():
     @property
     def plain_dirs(self):
         """List of directories in DataSet not starting with '.'"""
-        return [d for d in self.dirs if not d.startswith('.')]
+        return [d for d in self.dirs if not d.startswith(".")]
 
     @property
     def hidden_dirs(self):
         """List of directories in DataSet starting with '.'"""
-        return [d for d in self.dirs if d.startswith('.')]
+        return [d for d in self.dirs if d.startswith(".")]
 
     @property
     def tracked_dirs(self):
         """List of directories in DataSet not starting with '.'"""
-        return [d for d in self.__tracked_dirs if not d.startswith('.')]
+        return [d for d in self.__tracked_dirs if not d.startswith(".")]
 
     @property
     def private_dirs(self):
@@ -491,23 +489,23 @@ class DataSet():
             datafile.relative_to(self.__relpath)
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def ds1_dset(tst_sys):
     """Meta-data for dataset one files"""
     dset = DataSet()
-    dset.add_file('t1')
+    dset.add_file("t1")
-    dset.add_file('d1/t2')
+    dset.add_file("d1/t2")
-    dset.add_file(f'test_alt_copy##os.{tst_sys}')
+    dset.add_file(f"test_alt_copy##os.{tst_sys}")
-    dset.add_file('u1', tracked=False)
+    dset.add_file("u1", tracked=False)
-    dset.add_file('d2/u2', tracked=False)
+    dset.add_file("d2/u2", tracked=False)
-    dset.add_file('.ssh/p1', tracked=False, private=True)
+    dset.add_file(".ssh/p1", tracked=False, private=True)
-    dset.add_file('.ssh/.p2', tracked=False, private=True)
+    dset.add_file(".ssh/.p2", tracked=False, private=True)
-    dset.add_file('.gnupg/p3', tracked=False, private=True)
+    dset.add_file(".gnupg/p3", tracked=False, private=True)
-    dset.add_file('.gnupg/.p4', tracked=False, private=True)
+    dset.add_file(".gnupg/.p4", tracked=False, private=True)
     return dset
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def ds1_data(tmpdir_factory, config_git, ds1_dset, runner):
     """A set of test data, worktree & repo"""
     # pylint: disable=unused-argument
@@ -515,65 +513,40 @@ def ds1_data(tmpdir_factory, config_git, ds1_dset, runner):
     # @pytest.mark.usefixtures('config_git')
     # cannot be applied to another fixture.
 
-    data = tmpdir_factory.mktemp('ds1')
+    data = tmpdir_factory.mktemp("ds1")
 
-    work = data.mkdir('work')
+    work = data.mkdir("work")
     for datafile in ds1_dset:
         work.join(datafile.path).write(datafile.path, ensure=True)
 
-    repo = data.mkdir('repo.git')
+    repo = data.mkdir("repo.git")
     env = os.environ.copy()
-    env['GIT_DIR'] = str(repo)
+    env["GIT_DIR"] = str(repo)
-    runner(
+    runner(command=["git", "init", "--shared=0600", "--bare", str(repo)], report=False)
-        command=['git', 'init', '--shared=0600', '--bare', str(repo)],
+    runner(command=["git", "config", "core.bare", "false"], env=env, report=False)
-        report=False)
+    runner(command=["git", "config", "status.showUntrackedFiles", "no"], env=env, report=False)
-    runner(
+    runner(command=["git", "config", "yadm.managed", "true"], env=env, report=False)
-        command=['git', 'config', 'core.bare', 'false'],
+    runner(command=["git", "config", "core.worktree", str(work)], env=env, report=False)
-        env=env,
+    runner(command=["git", "add"] + [str(work.join(f.path)) for f in ds1_dset if f.tracked], env=env)
-        report=False)
+    runner(command=["git", "commit", "--allow-empty", "-m", "Initial commit"], env=env, report=False)
-    runner(
-        command=['git', 'config', 'status.showUntrackedFiles', 'no'],
-        env=env,
-        report=False)
-    runner(
-        command=['git', 'config', 'yadm.managed', 'true'],
-        env=env,
-        report=False)
-    runner(
-        command=['git', 'config', 'core.worktree', str(work)],
-        env=env,
-        report=False)
-    runner(
-        command=['git', 'add'] +
-        [str(work.join(f.path)) for f in ds1_dset if f.tracked],
-        env=env)
-    runner(
-        command=['git', 'commit', '--allow-empty', '-m', 'Initial commit'],
-        env=env,
-        report=False)
 
-    data = collections.namedtuple('Data', ['work', 'repo'])
+    data = collections.namedtuple("Data", ["work", "repo"])
     return data(work, repo)
 
 
 @pytest.fixture()
 def ds1_work_copy(ds1_data, paths):
     """Function scoped copy of ds1_data.work"""
-    distutils.dir_util.copy_tree(  # pylint: disable=no-member
+    shutil.copytree(str(ds1_data.work), str(paths.work), dirs_exist_ok=True)
-        str(ds1_data.work), str(paths.work))
 
 
 @pytest.fixture()
 def ds1_repo_copy(runner, ds1_data, paths):
     """Function scoped copy of ds1_data.repo"""
-    distutils.dir_util.copy_tree(  # pylint: disable=no-member
+    shutil.copytree(str(ds1_data.repo), str(paths.repo), dirs_exist_ok=True)
-        str(ds1_data.repo), str(paths.repo))
     env = os.environ.copy()
-    env['GIT_DIR'] = str(paths.repo)
+    env["GIT_DIR"] = str(paths.repo)
-    runner(
+    runner(command=["git", "config", "core.worktree", str(paths.work)], env=env, report=False)
-        command=['git', 'config', 'core.worktree', str(paths.work)],
-        env=env,
-        report=False)
 
 
 @pytest.fixture()
@@ -598,30 +571,27 @@ def ds1(ds1_work_copy, paths, ds1_dset):
     return dscopy
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def gnupg(tmpdir_factory, runner):
     """Location of GNUPGHOME"""
 
     def register_gpg_password(password):
         """Publish a new GPG mock password"""
-        py.path.local('/tmp/mock-password').write(password)
+        py.path.local("/tmp/mock-password").write(password)
 
-    home = tmpdir_factory.mktemp('gnupghome')
+    home = tmpdir_factory.mktemp("gnupghome")
     home.chmod(0o700)
-    conf = home.join('gpg.conf')
+    conf = home.join("gpg.conf")
-    conf.write('no-secmem-warning\n')
+    conf.write("no-secmem-warning\n")
     conf.chmod(0o600)
-    agentconf = home.join('gpg-agent.conf')
+    agentconf = home.join("gpg-agent.conf")
-    agentconf.write(
+    agentconf.write(f'pinentry-program {os.path.abspath("test/pinentry-mock")}\n' "max-cache-ttl 0\n")
-        f'pinentry-program {os.path.abspath("test/pinentry-mock")}\n'
-        'max-cache-ttl 0\n'
-    )
     agentconf.chmod(0o600)
-    data = collections.namedtuple('GNUPG', ['home', 'pw'])
+    data = collections.namedtuple("GNUPG", ["home", "pw"])
     env = os.environ.copy()
-    env['GNUPGHOME'] = home
+    env["GNUPGHOME"] = home
 
     # this pre-populates std files in the GNUPGHOME
-    runner(['gpg', '-k'], env=env)
+    runner(["gpg", "-k"], env=env)
 
     return data(home, register_gpg_password)

test/pinentry-mock

@@ -1,12 +1,20 @@
 #!/bin/bash
 # This program is a custom mock pinentry program
-# It always uses whatever password is found in the /tmp directory
+# It uses whatever password is found in the /tmp directory
-password="$(cat /tmp/mock-password 2>/dev/null)"
+# If the password is empty, replies CANCEL causing an error to similate invalid
+# credentials
 echo "OK Pleased to meet you"
 while read -r line; do
   if [[ $line =~ GETPIN ]]; then
-    echo -n "D "
+    password="$(cat /tmp/mock-password 2>/dev/null)"
-    echo "$password"
+    if [ -n "$password" ]; then
+      echo -n "D "
+      echo "$password"
+      echo "OK";
+    else
+      echo "CANCEL";
+    fi
+  else
+    echo "OK";
   fi
-  echo "OK";
 done

test/pylintrc

@@ -1 +0,0 @@
-../pylintrc

test/requirements.txt

@@ -1,6 +1,8 @@
+black==23.1.0
 envtpl
-flake8==3.8.4
+flake8==6.0.0
+isort==5.12.0
 j2cli
-pylint==2.6.0
+pylint==2.17.0
-pytest==6.2.1
+pytest==7.2.2
-yamllint==1.25.0
+yamllint==1.30.0

test/test_alt.py

@@ -1,6 +1,7 @@
 """Test alt"""
 import os
 import string
+
 import py
 import pytest
 import utils
@@ -8,34 +9,34 @@ import utils
 TEST_PATHS = [utils.ALT_FILE1, utils.ALT_FILE2, utils.ALT_DIR]
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
-@pytest.mark.parametrize('yadm_alt', [True, False], ids=['alt', 'worktree'])
+@pytest.mark.parametrize("yadm_alt", [True, False], ids=["alt", "worktree"])
 @pytest.mark.parametrize(
-    'tracked,encrypt,exclude', [
+    "tracked,encrypt,exclude",
+    [
         (False, False, False),
         (True, False, False),
         (False, True, False),
         (False, True, True),
-    ], ids=['untracked', 'tracked', 'encrypted', 'excluded'])
+    ],
-def test_alt_source(
+    ids=["untracked", "tracked", "encrypted", "excluded"],
-        runner, paths,
+)
-        tracked, encrypt, exclude,
+def test_alt_source(runner, paths, tracked, encrypt, exclude, yadm_alt):
-        yadm_alt):
     """Test yadm alt operates on all expected sources of alternates"""
     yadm_dir, yadm_data = setup_standard_yadm_dir(paths)
 
     utils.create_alt_files(
-        paths, '##default', tracked=tracked, encrypt=encrypt, exclude=exclude,
+        paths, "##default", tracked=tracked, encrypt=encrypt, exclude=exclude, yadm_alt=yadm_alt, yadm_dir=yadm_dir
-        yadm_alt=yadm_alt, yadm_dir=yadm_dir)
+    )
-    run = runner([paths.pgm, '-Y', yadm_dir, '--yadm-data', yadm_data, 'alt'])
+    run = runner([paths.pgm, "-Y", yadm_dir, "--yadm-data", yadm_data, "alt"])
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     linked = utils.parse_alt_output(run.out)
 
-    basepath = yadm_dir.join('alt') if yadm_alt else paths.work
+    basepath = yadm_dir.join("alt") if yadm_alt else paths.work
 
     for link_path in TEST_PATHS:
-        source_file_content = link_path + '##default'
+        source_file_content = link_path + "##default"
         source_file = basepath.join(source_file_content)
         link_file = paths.work.join(link_path)
         if tracked or (encrypt and not exclude):
@@ -45,63 +46,69 @@ def test_alt_source(
                 assert link_file.read() == source_file_content
                 assert str(source_file) in linked
             else:
-                assert link_file.join(
+                assert link_file.join(utils.CONTAINED).read() == source_file_content
-                    utils.CONTAINED).read() == source_file_content
                 assert str(source_file) in linked
         else:
             assert not link_file.exists()
             assert str(source_file) not in linked
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
-@pytest.mark.parametrize('yadm_alt', [True, False], ids=['alt', 'worktree'])
+@pytest.mark.parametrize("yadm_alt", [True, False], ids=["alt", "worktree"])
 def test_relative_link(runner, paths, yadm_alt):
     """Confirm links created are relative"""
     yadm_dir, yadm_data = setup_standard_yadm_dir(paths)
 
     utils.create_alt_files(
-        paths, '##default', tracked=True, encrypt=False, exclude=False,
+        paths, "##default", tracked=True, encrypt=False, exclude=False, yadm_alt=yadm_alt, yadm_dir=yadm_dir
-        yadm_alt=yadm_alt, yadm_dir=yadm_dir)
+    )
-    run = runner([paths.pgm, '-Y', yadm_dir, '--yadm-data', yadm_data, 'alt'])
+    run = runner([paths.pgm, "-Y", yadm_dir, "--yadm-data", yadm_data, "alt"])
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
 
-    basepath = yadm_dir.join('alt') if yadm_alt else paths.work
+    basepath = yadm_dir.join("alt") if yadm_alt else paths.work
 
     for link_path in TEST_PATHS:
-        source_file_content = link_path + '##default'
+        source_file_content = link_path + "##default"
         source_file = basepath.join(source_file_content)
         link_file = paths.work.join(link_path)
         link = link_file.readlink()
-        relpath = os.path.relpath(
+        relpath = os.path.relpath(source_file, start=os.path.dirname(link_file))
-            source_file, start=os.path.dirname(link_file))
         assert link == relpath
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
-@pytest.mark.parametrize('suffix', [
+@pytest.mark.parametrize(
-    '##default',
+    "suffix",
-    '##default,e.txt', '##default,extension.txt',
+    [
-    '##a.$tst_arch', '##arch.$tst_arch',
+        "##default",
-    '##o.$tst_sys', '##os.$tst_sys',
+        "##default,e.txt",
-    '##d.$tst_distro', '##distro.$tst_distro',
+        "##default,extension.txt",
-    '##f.$tst_distro_family', '##distro_family.$tst_distro_family',
+        "##a.$tst_arch",
-    '##c.$tst_class', '##class.$tst_class',
+        "##arch.$tst_arch",
-    '##h.$tst_host', '##hostname.$tst_host',
+        "##o.$tst_sys",
-    '##u.$tst_user', '##user.$tst_user',
+        "##os.$tst_sys",
-    ])
+        "##d.$tst_distro",
-def test_alt_conditions(
+        "##distro.$tst_distro",
-        runner, paths,
+        "##f.$tst_distro_family",
-        tst_arch, tst_sys, tst_distro, tst_distro_family, tst_host, tst_user,
+        "##distro_family.$tst_distro_family",
-        suffix):
+        "##c.$tst_class",
+        "##class.$tst_class",
+        "##h.$tst_host",
+        "##hostname.$tst_host",
+        "##u.$tst_user",
+        "##user.$tst_user",
+    ],
+)
+def test_alt_conditions(runner, paths, tst_arch, tst_sys, tst_distro, tst_distro_family, tst_host, tst_user, suffix):
     """Test conditions supported by yadm alt"""
     yadm_dir, yadm_data = setup_standard_yadm_dir(paths)
 
     # set the class
-    tst_class = 'testclass'
+    tst_class = "testclass"
-    utils.set_local(paths, 'class', tst_class + ".before")
+    utils.set_local(paths, "class", tst_class + ".before")
-    utils.set_local(paths, 'class', tst_class, add=True)
+    utils.set_local(paths, "class", tst_class, add=True)
-    utils.set_local(paths, 'class', tst_class + ".after", add=True)
+    utils.set_local(paths, "class", tst_class + ".after", add=True)
 
     suffix = string.Template(suffix).substitute(
         tst_arch=tst_arch,
@@ -114,9 +121,9 @@ def test_alt_conditions(
     )
 
     utils.create_alt_files(paths, suffix)
-    run = runner([paths.pgm, '-Y', yadm_dir, '--yadm-data', yadm_data, 'alt'])
+    run = runner([paths.pgm, "-Y", yadm_dir, "--yadm-data", yadm_data, "alt"])
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     linked = utils.parse_alt_output(run.out)
 
     for link_path in TEST_PATHS:
@@ -127,27 +134,31 @@ def test_alt_conditions(
             assert paths.work.join(link_path).read() == source_file
             assert str(paths.work.join(source_file)) in linked
         else:
-            assert paths.work.join(link_path).join(
+            assert paths.work.join(link_path).join(utils.CONTAINED).read() == source_file
-                utils.CONTAINED).read() == source_file
             assert str(paths.work.join(source_file)) in linked
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
+@pytest.mark.parametrize("kind", ["default", "", None, "envtpl", "j2cli", "j2", "esh"])
 @pytest.mark.parametrize(
-    'kind', ['default', '', None, 'envtpl', 'j2cli', 'j2', 'esh'])
+    "label",
-@pytest.mark.parametrize('label', ['t', 'template', 'yadm', ])
+    [
-def test_alt_templates(
+        "t",
-        runner, paths, kind, label):
+        "template",
+        "yadm",
+    ],
+)
+def test_alt_templates(runner, paths, kind, label):
     """Test templates supported by yadm alt"""
     yadm_dir, yadm_data = setup_standard_yadm_dir(paths)
 
-    suffix = f'##{label}.{kind}'
+    suffix = f"##{label}.{kind}"
     if kind is None:
-        suffix = f'##{label}'
+        suffix = f"##{label}"
     utils.create_alt_files(paths, suffix)
-    run = runner([paths.pgm, '-Y', yadm_dir, '--yadm-data', yadm_data, 'alt'])
+    run = runner([paths.pgm, "-Y", yadm_dir, "--yadm-data", yadm_data, "alt"])
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     created = utils.parse_alt_output(run.out, linked=False)
 
     for created_path in TEST_PATHS:
@@ -158,41 +169,39 @@ def test_alt_templates(
             assert str(paths.work.join(source_file)) in created
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
-@pytest.mark.parametrize('autoalt', [None, 'true', 'false'])
+@pytest.mark.parametrize("autoalt", [None, "true", "false"])
 def test_auto_alt(runner, yadm_cmd, paths, autoalt):
     """Test auto alt"""
 
     # set the value of auto-alt
     if autoalt:
-        os.system(' '.join(yadm_cmd('config', 'yadm.auto-alt', autoalt)))
+        os.system(" ".join(yadm_cmd("config", "yadm.auto-alt", autoalt)))
 
-    utils.create_alt_files(paths, '##default')
+    utils.create_alt_files(paths, "##default")
-    run = runner(yadm_cmd('status'))
+    run = runner(yadm_cmd("status"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     linked = utils.parse_alt_output(run.out)
 
     for link_path in TEST_PATHS:
-        source_file = link_path + '##default'
+        source_file = link_path + "##default"
-        if autoalt == 'false':
+        if autoalt == "false":
             assert not paths.work.join(link_path).exists()
         else:
             assert paths.work.join(link_path).islink()
-            target = py.path.local(
+            target = py.path.local(os.path.realpath(paths.work.join(link_path)))
-                os.path.realpath(paths.work.join(link_path)))
             if target.isfile():
                 assert paths.work.join(link_path).read() == source_file
                 # no linking output when run via auto-alt
                 assert str(paths.work.join(source_file)) not in linked
             else:
-                assert paths.work.join(link_path).join(
+                assert paths.work.join(link_path).join(utils.CONTAINED).read() == source_file
-                    utils.CONTAINED).read() == source_file
                 # no linking output when run via auto-alt
                 assert str(paths.work.join(source_file)) not in linked
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
 def test_stale_link_removal(runner, yadm_cmd, paths):
     """Stale links to alternative files are removed
 
@@ -201,48 +210,47 @@ def test_stale_link_removal(runner, yadm_cmd, paths):
     """
 
     # set the class
-    tst_class = 'testclass'
+    tst_class = "testclass"
-    utils.set_local(paths, 'class', tst_class)
+    utils.set_local(paths, "class", tst_class)
 
     # create files which match the test class
-    utils.create_alt_files(paths, f'##class.{tst_class}')
+    utils.create_alt_files(paths, f"##class.{tst_class}")
 
     # run alt to trigger linking
-    run = runner(yadm_cmd('alt'))
+    run = runner(yadm_cmd("alt"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     linked = utils.parse_alt_output(run.out)
 
     # assert the proper linking has occurred
     for stale_path in TEST_PATHS:
-        source_file = stale_path + '##class.' + tst_class
+        source_file = stale_path + "##class." + tst_class
         assert paths.work.join(stale_path).islink()
         target = py.path.local(os.path.realpath(paths.work.join(stale_path)))
         if target.isfile():
             assert paths.work.join(stale_path).read() == source_file
             assert str(paths.work.join(source_file)) in linked
         else:
-            assert paths.work.join(stale_path).join(
+            assert paths.work.join(stale_path).join(utils.CONTAINED).read() == source_file
-                utils.CONTAINED).read() == source_file
             assert str(paths.work.join(source_file)) in linked
 
     # change the class so there are no valid alternates
-    utils.set_local(paths, 'class', 'changedclass')
+    utils.set_local(paths, "class", "changedclass")
 
     # run alt to trigger linking
-    run = runner(yadm_cmd('alt'))
+    run = runner(yadm_cmd("alt"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     linked = utils.parse_alt_output(run.out)
 
     # assert the linking is removed
     for stale_path in TEST_PATHS:
-        source_file = stale_path + '##class.' + tst_class
+        source_file = stale_path + "##class." + tst_class
         assert not paths.work.join(stale_path).exists()
         assert str(paths.work.join(source_file)) not in linked
 
 
-@pytest.mark.usefixtures('ds1_repo_copy')
+@pytest.mark.usefixtures("ds1_repo_copy")
 def test_template_overwrite_symlink(runner, yadm_cmd, paths, tst_sys):
     """Remove symlinks before processing a template
 
@@ -251,45 +259,44 @@ def test_template_overwrite_symlink(runner, yadm_cmd, paths, tst_sys):
     be removed just before processing a template.
     """
 
-    target = paths.work.join(f'test_link##os.{tst_sys}')
+    target = paths.work.join(f"test_link##os.{tst_sys}")
-    target.write('target')
+    target.write("target")
 
-    link = paths.work.join('test_link')
+    link = paths.work.join("test_link")
     link.mksymlinkto(target, absolute=1)
 
-    template = paths.work.join('test_link##template.default')
+    template = paths.work.join("test_link##template.default")
-    template.write('test-data')
+    template.write("test-data")
 
-    run = runner(yadm_cmd('add', target, template))
+    run = runner(yadm_cmd("add", target, template))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""
     assert not link.islink()
-    assert target.read().strip() == 'target'
+    assert target.read().strip() == "target"
-    assert link.read().strip() == 'test-data'
+    assert link.read().strip() == "test-data"
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
-@pytest.mark.parametrize('style', ['symlink', 'template'])
+@pytest.mark.parametrize("style", ["symlink", "template"])
 def test_ensure_alt_path(runner, paths, style):
     """Test that directories are created before making alternates"""
     yadm_dir, yadm_data = setup_standard_yadm_dir(paths)
-    suffix = 'default' if style == 'symlink' else 'template'
+    suffix = "default" if style == "symlink" else "template"
-    filename = 'a/b/c/file'
+    filename = "a/b/c/file"
-    source = yadm_dir.join(f'alt/{filename}##{suffix}')
+    source = yadm_dir.join(f"alt/{filename}##{suffix}")
-    source.write('test-data', ensure=True)
+    source.write("test-data", ensure=True)
-    run = runner([
+    run = runner([paths.pgm, "-Y", yadm_dir, "--yadm-data", yadm_data, "add", source])
-        paths.pgm, '-Y', yadm_dir, '--yadm-data', yadm_data, 'add', source])
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""
-    assert paths.work.join(filename).read().strip() == 'test-data'
+    assert paths.work.join(filename).read().strip() == "test-data"
 
 
 def setup_standard_yadm_dir(paths):
     """Configure a yadm home within the work tree"""
-    std_yadm_dir = paths.work.mkdir('.config').mkdir('yadm')
+    std_yadm_dir = paths.work.mkdir(".config").mkdir("yadm")
-    std_yadm_data = paths.work.mkdir('.local').mkdir('share').mkdir('yadm')
+    std_yadm_data = paths.work.mkdir(".local").mkdir("share").mkdir("yadm")
-    std_yadm_data.join('repo.git').mksymlinkto(paths.repo, absolute=1)
+    std_yadm_data.join("repo.git").mksymlinkto(paths.repo, absolute=1)
-    std_yadm_dir.join('encrypt').mksymlinkto(paths.encrypt, absolute=1)
+    std_yadm_dir.join("encrypt").mksymlinkto(paths.encrypt, absolute=1)
     return std_yadm_dir, std_yadm_data

test/test_alt_copy.py

@@ -1,45 +1,46 @@
 """Test yadm.alt-copy"""
 
 import os
+
 import pytest
 
 
 @pytest.mark.parametrize(
-    'setting, expect_link, pre_existing', [
+    "setting, expect_link, pre_existing",
+    [
         (None, True, None),
         (True, False, None),
         (False, True, None),
-        (True, False, 'link'),
+        (True, False, "link"),
-        (True, False, 'file'),
+        (True, False, "file"),
     ],
     ids=[
-        'unset',
+        "unset",
-        'true',
+        "true",
-        'false',
+        "false",
-        'pre-existing symlink',
+        "pre-existing symlink",
-        'pre-existing file',
+        "pre-existing file",
-    ])
+    ],
-@pytest.mark.usefixtures('ds1_copy')
+)
-def test_alt_copy(
+@pytest.mark.usefixtures("ds1_copy")
-        runner, yadm_cmd, paths, tst_sys,
+def test_alt_copy(runner, yadm_cmd, paths, tst_sys, setting, expect_link, pre_existing):
-        setting, expect_link, pre_existing):
     """Test yadm.alt-copy"""
 
     if setting is not None:
-        os.system(' '.join(yadm_cmd('config', 'yadm.alt-copy', str(setting))))
+        os.system(" ".join(yadm_cmd("config", "yadm.alt-copy", str(setting))))
 
-    expected_content = f'test_alt_copy##os.{tst_sys}'
+    expected_content = f"test_alt_copy##os.{tst_sys}"
 
-    alt_path = paths.work.join('test_alt_copy')
+    alt_path = paths.work.join("test_alt_copy")
-    if pre_existing == 'symlink':
+    if pre_existing == "symlink":
         alt_path.mklinkto(expected_content)
-    elif pre_existing == 'file':
+    elif pre_existing == "file":
-        alt_path.write('wrong content')
+        alt_path.write("wrong content")
 
-    run = runner(yadm_cmd('alt'))
+    run = runner(yadm_cmd("alt"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'Linking' in run.out
+    assert "Linking" in run.out
 
     assert alt_path.read() == expected_content
     assert alt_path.islink() == expect_link

test/test_assert_private_dirs.py

@@ -2,13 +2,14 @@
 
 import os
 import re
+
 import pytest
 
-pytestmark = pytest.mark.usefixtures('ds1_copy')
+pytestmark = pytest.mark.usefixtures("ds1_copy")
-PRIVATE_DIRS = ['.gnupg', '.ssh']
+PRIVATE_DIRS = [".gnupg", ".ssh"]
 
 
-@pytest.mark.parametrize('home', [True, False], ids=['home', 'not-home'])
+@pytest.mark.parametrize("home", [True, False], ids=["home", "not-home"])
 def test_pdirs_missing(runner, yadm_cmd, paths, home):
     """Private dirs (private dirs missing)
 
@@ -24,15 +25,15 @@ def test_pdirs_missing(runner, yadm_cmd, paths, home):
             path.remove()
         assert not path.exists()
 
-    env = {'DEBUG': 'yes'}
+    env = {"DEBUG": "yes"}
     if home:
-        env['HOME'] = paths.work
+        env["HOME"] = paths.work
 
     # run status
-    run = runner(command=yadm_cmd('status'), env=env)
+    run = runner(command=yadm_cmd("status"), env=env)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'On branch master' in run.out
+    assert "On branch master" in run.out
 
     # confirm directories are created
     # and are protected
@@ -40,17 +41,15 @@ def test_pdirs_missing(runner, yadm_cmd, paths, home):
         path = paths.work.join(pdir)
         if home:
             assert path.exists()
-            assert oct(path.stat().mode).endswith('00'), ('Directory is '
+            assert oct(path.stat().mode).endswith("00"), "Directory is " "not secured"
-                                                          'not secured')
         else:
             assert not path.exists()
 
     # confirm directories are created before command is run:
     if home:
         assert re.search(
-            (r'Creating.+\.(gnupg|ssh).+Creating.+\.(gnupg|ssh).+'
+            r"Creating.+\.(gnupg|ssh).+Creating.+\.(gnupg|ssh).+Running git command git status", run.out, re.DOTALL
-             r'Running git command git status'),
+        ), "directories created before command is run"
-            run.out, re.DOTALL), 'directories created before command is run'
 
 
 def test_pdirs_missing_apd_false(runner, yadm_cmd, paths):
@@ -70,14 +69,13 @@ def test_pdirs_missing_apd_false(runner, yadm_cmd, paths):
         assert not path.exists()
 
     # set configuration
-    os.system(' '.join(yadm_cmd(
+    os.system(" ".join(yadm_cmd("config", "--bool", "yadm.auto-private-dirs", "false")))
-        'config', '--bool', 'yadm.auto-private-dirs', 'false')))
 
     # run status
-    run = runner(command=yadm_cmd('status'))
+    run = runner(command=yadm_cmd("status"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'On branch master' in run.out
+    assert "On branch master" in run.out
 
     # confirm directories are STILL missing
     for pdir in PRIVATE_DIRS:
@@ -99,19 +97,18 @@ def test_pdirs_exist_apd_false(runner, yadm_cmd, paths):
         if not path.isdir():
             path.mkdir()
         path.chmod(0o777)
-        assert oct(path.stat().mode).endswith('77'), 'Directory is secure.'
+        assert oct(path.stat().mode).endswith("77"), "Directory is secure."
 
     # set configuration
-    os.system(' '.join(yadm_cmd(
+    os.system(" ".join(yadm_cmd("config", "--bool", "yadm.auto-perms", "false")))
-        'config', '--bool', 'yadm.auto-perms', 'false')))
 
     # run status
-    run = runner(command=yadm_cmd('status'))
+    run = runner(command=yadm_cmd("status"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'On branch master' in run.out
+    assert "On branch master" in run.out
 
     # created directories are STILL permissive
     for pdir in PRIVATE_DIRS:
         path = paths.work.join(pdir)
-        assert oct(path.stat().mode).endswith('77'), 'Directory is secure'
+        assert oct(path.stat().mode).endswith("77"), "Directory is secure"

test/test_bootstrap.py

@@ -4,32 +4,30 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'exists, executable, code, expect', [
+    "exists, executable, code, expect",
-        (False, False, 1, 'Cannot execute bootstrap'),
+    [
-        (True, False, 1, 'is not an executable program'),
+        (False, False, 1, "Cannot execute bootstrap"),
-        (True, True, 123, 'Bootstrap successful'),
+        (True, False, 1, "is not an executable program"),
-    ], ids=[
+        (True, True, 123, "Bootstrap successful"),
-        'missing',
+    ],
-        'not executable',
+    ids=[
-        'executable',
+        "missing",
-    ])
+        "not executable",
-def test_bootstrap(
+        "executable",
-        runner, yadm_cmd, paths, exists, executable, code, expect):
+    ],
+)
+def test_bootstrap(runner, yadm_cmd, paths, exists, executable, code, expect):
     """Test bootstrap command"""
     if exists:
-        paths.bootstrap.write('')
+        paths.bootstrap.write("")
     if executable:
-        paths.bootstrap.write(
+        paths.bootstrap.write("#!/bin/bash\n" f"echo {expect}\n" f"exit {code}\n")
-            '#!/bin/bash\n'
-            f'echo {expect}\n'
-            f'exit {code}\n'
-        )
         paths.bootstrap.chmod(0o775)
-    run = runner(command=yadm_cmd('bootstrap'))
+    run = runner(command=yadm_cmd("bootstrap"))
     assert run.code == code
     if exists and executable:
-        assert run.err == ''
+        assert run.err == ""
         assert expect in run.out
     else:
         assert expect in run.err
-        assert run.out == ''
+        assert run.out == ""

test/test_clean.py

@@ -3,9 +3,9 @@
 
 def test_clean_command(runner, yadm_cmd):
     """Run with clean command"""
-    run = runner(command=yadm_cmd('clean'))
+    run = runner(command=yadm_cmd("clean"))
     # do nothing, this is a dangerous Git command when managing dot files
     # report the command as disabled and exit as a failure
     assert run.failure
-    assert run.out == ''
+    assert run.out == ""
-    assert 'disabled' in run.err
+    assert "disabled" in run.err

test/test_clone.py

@@ -2,30 +2,32 @@
 
 import os
 import re
+
 import pytest
 
 BOOTSTRAP_CODE = 123
-BOOTSTRAP_MSG = 'Bootstrap successful'
+BOOTSTRAP_MSG = "Bootstrap successful"
 
 
-@pytest.mark.usefixtures('remote')
+@pytest.mark.usefixtures("remote")
 @pytest.mark.parametrize(
-    'good_remote, repo_exists, force, conflicts', [
+    "good_remote, repo_exists, force, conflicts",
+    [
         (False, False, False, False),
         (True, False, False, False),
         (True, True, False, False),
         (True, True, True, False),
         (True, False, False, True),
-    ], ids=[
+    ],
-        'bad remote',
+    ids=[
-        'simple',
+        "bad remote",
-        'existing repo',
+        "simple",
-        '-f',
+        "existing repo",
-        'conflicts',
+        "-f",
-    ])
+        "conflicts",
-def test_clone(
+    ],
-        runner, paths, yadm_cmd, repo_config, ds1,
+)
-        good_remote, repo_exists, force, conflicts):
+def test_clone(runner, paths, yadm_cmd, repo_config, ds1, good_remote, repo_exists, force, conflicts):
     """Test basic clone operation"""
 
     # clear out the work path
@@ -33,74 +35,70 @@ def test_clone(
     paths.work.mkdir()
 
     # determine remote url
-    remote_url = f'file://{paths.remote}'
+    remote_url = f"file://{paths.remote}"
     if not good_remote:
-        remote_url = 'file://bad_remote'
+        remote_url = "file://bad_remote"
 
     old_repo = None
     if repo_exists:
         # put a repo in the way
         paths.repo.mkdir()
-        old_repo = paths.repo.join('old_repo')
+        old_repo = paths.repo.join("old_repo")
-        old_repo.write('old_repo')
+        old_repo.write("old_repo")
 
     if conflicts:
-        ds1.tracked[0].relative.write('conflict')
+        ds1.tracked[0].relative.write("conflict")
         assert ds1.tracked[0].relative.exists()
 
     # run the clone command
-    args = ['clone', '-w', paths.work]
+    args = ["clone", "-w", paths.work]
     if force:
-        args += ['-f']
+        args += ["-f"]
     args += [remote_url]
     run = runner(command=yadm_cmd(*args))
 
     if not good_remote:
         # clone should fail
         assert run.failure
-        assert run.out == ''
+        assert run.out == ""
-        assert 'Unable to clone the repository' in run.err
+        assert "Unable to clone the repository" in run.err
         assert not paths.repo.exists()
     elif repo_exists and not force:
         # can't overwrite data
         assert run.failure
-        assert run.out == ''
+        assert run.out == ""
-        assert 'Git repo already exists' in run.err
+        assert "Git repo already exists" in run.err
     else:
         # clone should succeed, and repo should be configured properly
         assert successful_clone(run, paths, repo_config)
 
         # these clones should have master as HEAD
-        verify_head(paths, 'master')
+        verify_head(paths, "master")
 
         # ensure conflicts are handled properly
         if conflicts:
-            assert 'NOTE' in run.out
+            assert "NOTE" in run.out
-            assert 'Local files with content that differs' in run.out
+            assert "Local files with content that differs" in run.out
 
         # confirm correct Git origin
-        run = runner(
+        run = runner(command=("git", "remote", "-v", "show"), env={"GIT_DIR": paths.repo})
-            command=('git', 'remote', '-v', 'show'),
-            env={'GIT_DIR': paths.repo})
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
-        assert f'origin\t{remote_url}' in run.out
+        assert f"origin\t{remote_url}" in run.out
 
         # ensure conflicts are really preserved
         if conflicts:
             # test that the conflicts are preserved in the work tree
-            run = runner(
+            run = runner(command=yadm_cmd("status", "-uno", "--porcelain"), cwd=paths.work)
-                command=yadm_cmd('status', '-uno', '--porcelain'),
-                cwd=paths.work)
             assert run.success
-            assert run.err == ''
+            assert run.err == ""
             assert str(ds1.tracked[0].path) in run.out
 
             # verify content of the conflicts
-            run = runner(command=yadm_cmd('diff'), cwd=paths.work)
+            run = runner(command=yadm_cmd("diff"), cwd=paths.work)
             assert run.success
-            assert run.err == ''
+            assert run.err == ""
-            assert '\n+conflict' in run.out, 'conflict overwritten'
+            assert "\n+conflict" in run.out, "conflict overwritten"
 
     # another force-related assertion
     if old_repo:
@@ -110,54 +108,56 @@ def test_clone(
             assert old_repo.exists()
 
 
-@pytest.mark.usefixtures('remote')
+@pytest.mark.usefixtures("remote")
 @pytest.mark.parametrize(
-    'bs_exists, bs_param, answer', [
+    "bs_exists, bs_param, answer",
-        (False, '--bootstrap', None),
+    [
-        (True, '--bootstrap', None),
+        (False, "--bootstrap", None),
-        (True, '--no-bootstrap', None),
+        (True, "--bootstrap", None),
-        (True, None, 'n'),
+        (True, "--no-bootstrap", None),
-        (True, None, 'y'),
+        (True, None, "n"),
-    ], ids=[
+        (True, None, "y"),
-        'force, missing',
+    ],
-        'force, existing',
+    ids=[
-        'prevent',
+        "force, missing",
-        'existing, answer n',
+        "force, existing",
-        'existing, answer y',
+        "prevent",
-    ])
+        "existing, answer n",
-def test_clone_bootstrap(
+        "existing, answer y",
-        runner, paths, yadm_cmd, repo_config, bs_exists, bs_param, answer):
+    ],
+)
+def test_clone_bootstrap(runner, paths, yadm_cmd, repo_config, bs_exists, bs_param, answer):
     """Test bootstrap clone features"""
 
     # establish a bootstrap
     create_bootstrap(paths, bs_exists)
 
     # run the clone command
-    args = ['clone', '-w', paths.work]
+    args = ["clone", "-w", paths.work]
     if bs_param:
         args += [bs_param]
-    args += [f'file://{paths.remote}']
+    args += [f"file://{paths.remote}"]
     expect = []
     if answer:
-        expect.append(('Would you like to execute it now', answer))
+        expect.append(("Would you like to execute it now", answer))
     run = runner(command=yadm_cmd(*args), expect=expect)
 
     if answer:
-        assert 'Would you like to execute it now' in run.out
+        assert "Would you like to execute it now" in run.out
 
     expected_code = 0
-    if bs_exists and bs_param != '--no-bootstrap':
+    if bs_exists and bs_param != "--no-bootstrap":
         expected_code = BOOTSTRAP_CODE
 
-    if answer == 'y':
+    if answer == "y":
         expected_code = BOOTSTRAP_CODE
         assert BOOTSTRAP_MSG in run.out
-    elif answer == 'n':
+    elif answer == "n":
         expected_code = 0
         assert BOOTSTRAP_MSG not in run.out
 
     assert successful_clone(run, paths, repo_config, expected_code)
-    verify_head(paths, 'master')
+    verify_head(paths, "master")
 
     if not bs_exists:
         assert BOOTSTRAP_MSG not in run.out
@@ -166,108 +166,90 @@ def test_clone_bootstrap(
 def create_bootstrap(paths, exists):
     """Create bootstrap file for test"""
     if exists:
-        paths.bootstrap.write(
+        paths.bootstrap.write("#!/bin/sh\n" f"echo {BOOTSTRAP_MSG}\n" f"exit {BOOTSTRAP_CODE}\n")
-            '#!/bin/sh\n'
-            f'echo {BOOTSTRAP_MSG}\n'
-            f'exit {BOOTSTRAP_CODE}\n')
         paths.bootstrap.chmod(0o775)
         assert paths.bootstrap.exists()
     else:
         assert not paths.bootstrap.exists()
 
 
-@pytest.mark.usefixtures('remote')
+@pytest.mark.usefixtures("remote")
 @pytest.mark.parametrize(
-    'private_type, in_repo, in_work', [
+    "private_type, in_repo, in_work",
-        ('ssh', False, True),
+    [
-        ('gnupg', False, True),
+        ("ssh", False, True),
-        ('ssh', True, True),
+        ("gnupg", False, True),
-        ('gnupg', True, True),
+        ("ssh", True, True),
-        ('ssh', True, False),
+        ("gnupg", True, True),
-        ('gnupg', True, False),
+        ("ssh", True, False),
-    ], ids=[
+        ("gnupg", True, False),
-        'open ssh, not tracked',
+    ],
-        'open gnupg, not tracked',
+    ids=[
-        'open ssh, tracked',
+        "open ssh, not tracked",
-        'open gnupg, tracked',
+        "open gnupg, not tracked",
-        'missing ssh, tracked',
+        "open ssh, tracked",
-        'missing gnupg, tracked',
+        "open gnupg, tracked",
-    ])
+        "missing ssh, tracked",
-def test_clone_perms(
+        "missing gnupg, tracked",
-        runner, yadm_cmd, paths, repo_config,
+    ],
-        private_type, in_repo, in_work):
+)
+def test_clone_perms(runner, yadm_cmd, paths, repo_config, private_type, in_repo, in_work):
     """Test clone permission-related functions"""
 
     # update remote repo to include private data
     if in_repo:
-        rpath = paths.work.mkdir(f'.{private_type}').join('related')
+        rpath = paths.work.mkdir(f".{private_type}").join("related")
-        rpath.write('related')
+        rpath.write("related")
         os.system(f'GIT_DIR="{paths.remote}" git add {rpath}')
         os.system(f'GIT_DIR="{paths.remote}" git commit -m "{rpath}"')
         rpath.remove()
 
     # ensure local private data is insecure at the start
     if in_work:
-        pdir = paths.work.join(f'.{private_type}')
+        pdir = paths.work.join(f".{private_type}")
         if not pdir.exists():
             pdir.mkdir()
-        pfile = pdir.join('existing')
+        pfile = pdir.join("existing")
-        pfile.write('existing')
+        pfile.write("existing")
         pdir.chmod(0o777)
         pfile.chmod(0o777)
     else:
         paths.work.remove()
         paths.work.mkdir()
 
-    env = {'HOME': paths.work}
+    env = {"HOME": paths.work}
-    run = runner(
+    run = runner(yadm_cmd("clone", "-d", "-w", paths.work, f"file://{paths.remote}"), env=env)
-        yadm_cmd('clone', '-d', '-w', paths.work, f'file://{paths.remote}'),
-        env=env
-    )
 
     assert successful_clone(run, paths, repo_config)
-    verify_head(paths, 'master')
+    verify_head(paths, "master")
     if in_work:
         # private directories which already exist, should be left as they are,
         # which in this test is "insecure".
-        assert re.search(
+        assert re.search(f"initial private dir perms drwxrwxrwx.+.{private_type}", run.out)
-            f'initial private dir perms drwxrwxrwx.+.{private_type}',
+        assert re.search(f"pre-checkout private dir perms drwxrwxrwx.+.{private_type}", run.out)
-            run.out)
+        assert re.search(f"post-checkout private dir perms drwxrwxrwx.+.{private_type}", run.out)
-        assert re.search(
-            f'pre-checkout private dir perms drwxrwxrwx.+.{private_type}',
-            run.out)
-        assert re.search(
-            f'post-checkout private dir perms drwxrwxrwx.+.{private_type}',
-            run.out)
     else:
         # private directories which are created, should be done prior to
         # checkout, and with secure permissions.
-        assert 'initial private dir perms' not in run.out
+        assert "initial private dir perms" not in run.out
-        assert re.search(
+        assert re.search(f"pre-checkout private dir perms drwx------.+.{private_type}", run.out)
-            f'pre-checkout private dir perms drwx------.+.{private_type}',
+        assert re.search(f"post-checkout private dir perms drwx------.+.{private_type}", run.out)
-            run.out)
-        assert re.search(
-            f'post-checkout private dir perms drwx------.+.{private_type}',
-            run.out)
 
     # standard perms still apply afterwards unless disabled with auto.perms
-    assert oct(
+    assert oct(paths.work.join(f".{private_type}").stat().mode).endswith(
-        paths.work.join(f'.{private_type}').stat().mode).endswith('00'), (
+        "00"
-            f'.{private_type} has not been secured by auto.perms')
+    ), f".{private_type} has not been secured by auto.perms"
 
 
-@pytest.mark.usefixtures('remote')
+@pytest.mark.usefixtures("remote")
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("branch", ["master", "default", "valid", "invalid"])
-    'branch', ['master', 'default', 'valid', 'invalid'])
 def test_alternate_branch(runner, paths, yadm_cmd, repo_config, branch):
     """Test cloning a branch other than master"""
 
     # add a "valid" branch to the remote
     os.system(f'GIT_DIR="{paths.remote}" git checkout -b valid')
-    os.system(
+    os.system(f'GIT_DIR="{paths.remote}" git commit ' f'--allow-empty -m "This branch is valid"')
-        f'GIT_DIR="{paths.remote}" git commit '
+    if branch != "default":
-        f'--allow-empty -m "This branch is valid"')
-    if branch != 'default':
         # When branch == 'default', the "default" branch of the remote repo
         # will remain "valid" to validate identification the correct default
         # branch by inspecting the repo. Otherwise it will be set back to
@@ -278,45 +260,43 @@ def test_alternate_branch(runner, paths, yadm_cmd, repo_config, branch):
     paths.work.remove()
     paths.work.mkdir()
 
-    remote_url = f'file://{paths.remote}'
+    remote_url = f"file://{paths.remote}"
 
     # run the clone command
-    args = ['clone', '-w', paths.work]
+    args = ["clone", "-w", paths.work]
-    if branch not in ['master', 'default']:
+    if branch not in ["master", "default"]:
-        args += ['-b', branch]
+        args += ["-b", branch]
     args += [remote_url]
     run = runner(command=yadm_cmd(*args))
 
-    if branch == 'invalid':
+    if branch == "invalid":
         assert run.failure
-        assert 'ERROR: Unable to clone the repository' in run.err
+        assert "ERROR: Unable to clone the repository" in run.err
         assert f"Remote branch {branch} not found in upstream" in run.err
     else:
         assert successful_clone(run, paths, repo_config)
 
         # confirm correct Git origin
-        run = runner(
+        run = runner(command=("git", "remote", "-v", "show"), env={"GIT_DIR": paths.repo})
-            command=('git', 'remote', '-v', 'show'),
-            env={'GIT_DIR': paths.repo})
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
-        assert f'origin\t{remote_url}' in run.out
+        assert f"origin\t{remote_url}" in run.out
-        run = runner(command=yadm_cmd('show'))
+        run = runner(command=yadm_cmd("show"))
-        if branch == 'master':
+        if branch == "master":
-            assert 'Initial commit' in run.out
+            assert "Initial commit" in run.out
-            verify_head(paths, 'master')
+            verify_head(paths, "master")
         else:
-            assert 'This branch is valid' in run.out
+            assert "This branch is valid" in run.out
-            verify_head(paths, 'valid')
+            verify_head(paths, "valid")
 
 
 def successful_clone(run, paths, repo_config, expected_code=0):
     """Assert clone is successful"""
     assert run.code == expected_code
-    assert oct(paths.repo.stat().mode).endswith('00'), 'Repo is not secured'
+    assert oct(paths.repo.stat().mode).endswith("00"), "Repo is not secured"
-    assert repo_config('core.bare') == 'false'
+    assert repo_config("core.bare") == "false"
-    assert repo_config('status.showUntrackedFiles') == 'no'
+    assert repo_config("status.showUntrackedFiles") == "no"
-    assert repo_config('yadm.managed') == 'true'
+    assert repo_config("yadm.managed") == "true"
     return True
 
 
@@ -331,15 +311,18 @@ def remote(paths, ds1_repo_copy):
     paths.repo.move(paths.remote)
 
 
-def test_no_repo(runner, yadm_cmd, ):
+def test_no_repo(
+    runner,
+    yadm_cmd,
+):
     """Test cloning without specifying a repo"""
-    run = runner(command=yadm_cmd('clone', '-f'))
+    run = runner(command=yadm_cmd("clone", "-f"))
     assert run.failure
-    assert run.out == ''
+    assert run.out == ""
-    assert 'ERROR: Unable to clone the repository' in run.err
+    assert "ERROR: Unable to clone the repository" in run.err
-    assert 'repository \'repo.git\' does not exist' in run.err
+    assert "repository 'repo.git' does not exist" in run.err
 
 
 def verify_head(paths, branch):
     """Assert the local repo has the correct head branch"""
-    assert paths.repo.join('HEAD').read() == f'ref: refs/heads/{branch}\n'
+    assert paths.repo.join("HEAD").read() == f"ref: refs/heads/{branch}\n"

test/test_config.py

@@ -1,13 +1,14 @@
 """Test config"""
 
 import os
+
 import pytest
 
-TEST_SECTION = 'test'
+TEST_SECTION = "test"
-TEST_ATTRIBUTE = 'attribute'
+TEST_ATTRIBUTE = "attribute"
-TEST_KEY = f'{TEST_SECTION}.{TEST_ATTRIBUTE}'
+TEST_KEY = f"{TEST_SECTION}.{TEST_ATTRIBUTE}"
-TEST_VALUE = 'testvalue'
+TEST_VALUE = "testvalue"
-TEST_FILE = f'[{TEST_SECTION}]\n\t{TEST_ATTRIBUTE} = {TEST_VALUE}'
+TEST_FILE = f"[{TEST_SECTION}]\n\t{TEST_ATTRIBUTE} = {TEST_VALUE}"
 
 
 def test_config_no_params(runner, yadm_cmd, supported_configs):
@@ -18,11 +19,11 @@ def test_config_no_params(runner, yadm_cmd, supported_configs):
     Exit with 0
     """
 
-    run = runner(yadm_cmd('config'))
+    run = runner(yadm_cmd("config"))
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'Please read the CONFIGURATION section' in run.out
+    assert "Please read the CONFIGURATION section" in run.out
     for config in supported_configs:
         assert config in run.out
 
@@ -34,11 +35,11 @@ def test_config_read_missing(runner, yadm_cmd):
     Exit with 0
     """
 
-    run = runner(yadm_cmd('config', TEST_KEY))
+    run = runner(yadm_cmd("config", TEST_KEY))
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""
 
 
 def test_config_write(runner, yadm_cmd, paths):
@@ -49,11 +50,11 @@ def test_config_write(runner, yadm_cmd, paths):
     Exit with 0
     """
 
-    run = runner(yadm_cmd('config', TEST_KEY, TEST_VALUE))
+    run = runner(yadm_cmd("config", TEST_KEY, TEST_VALUE))
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""
     assert paths.config.read().strip() == TEST_FILE
 
 
@@ -65,10 +66,10 @@ def test_config_read(runner, yadm_cmd, paths):
     """
 
     paths.config.write(TEST_FILE)
-    run = runner(yadm_cmd('config', TEST_KEY))
+    run = runner(yadm_cmd("config", TEST_KEY))
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out.strip() == TEST_VALUE
 
 
@@ -82,16 +83,16 @@ def test_config_update(runner, yadm_cmd, paths):
 
     paths.config.write(TEST_FILE)
 
-    run = runner(yadm_cmd('config', TEST_KEY, TEST_VALUE + 'extra'))
+    run = runner(yadm_cmd("config", TEST_KEY, TEST_VALUE + "extra"))
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""
 
-    assert paths.config.read().strip() == TEST_FILE + 'extra'
+    assert paths.config.read().strip() == TEST_FILE + "extra"
 
 
-@pytest.mark.usefixtures('ds1_repo_copy')
+@pytest.mark.usefixtures("ds1_repo_copy")
 def test_config_local_read(runner, yadm_cmd, paths, supported_local_configs):
     """Read local attribute
 
@@ -101,19 +102,17 @@ def test_config_local_read(runner, yadm_cmd, paths, supported_local_configs):
 
     # populate test values
     for config in supported_local_configs:
-        os.system(
+        os.system(f'GIT_DIR="{paths.repo}" ' f'git config --local "{config}" "value_of_{config}"')
-            f'GIT_DIR="{paths.repo}" '
-            f'git config --local "{config}" "value_of_{config}"')
 
     # run yadm config
     for config in supported_local_configs:
-        run = runner(yadm_cmd('config', config))
+        run = runner(yadm_cmd("config", config))
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
-        assert run.out.strip() == f'value_of_{config}'
+        assert run.out.strip() == f"value_of_{config}"
 
 
-@pytest.mark.usefixtures('ds1_repo_copy')
+@pytest.mark.usefixtures("ds1_repo_copy")
 def test_config_local_write(runner, yadm_cmd, paths, supported_local_configs):
     """Write local attribute
 
@@ -124,40 +123,37 @@ def test_config_local_write(runner, yadm_cmd, paths, supported_local_configs):
 
     # run yadm config
     for config in supported_local_configs:
-        run = runner(yadm_cmd('config', config, f'value_of_{config}'))
+        run = runner(yadm_cmd("config", config, f"value_of_{config}"))
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
-        assert run.out == ''
+        assert run.out == ""
 
     # verify test values
     for config in supported_local_configs:
-        run = runner(
+        run = runner(command=("git", "config", config), env={"GIT_DIR": paths.repo})
-            command=('git', 'config', config),
-            env={'GIT_DIR': paths.repo})
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
-        assert run.out.strip() == f'value_of_{config}'
+        assert run.out.strip() == f"value_of_{config}"
 
 
 def test_config_without_parent_directory(runner, yadm_cmd, paths):
-    """Write and read attribute to/from config file with non-existent parent dir
+    """Write/read attribute to/from config file with non-existent parent dir
 
     Update configuration file
     Display value
     Exit with 0
     """
 
-    config_file = paths.root + '/folder/does/not/exist/config'
+    config_file = paths.root + "/folder/does/not/exist/config"
 
-    run = runner(
+    run = runner(yadm_cmd("--yadm-config", config_file, "config", TEST_KEY, TEST_VALUE))
-        yadm_cmd('--yadm-config', config_file, 'config', TEST_KEY, TEST_VALUE))
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""
 
-    run = runner(yadm_cmd('--yadm-config', config_file, 'config', TEST_KEY))
+    run = runner(yadm_cmd("--yadm-config", config_file, "config", TEST_KEY))
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out.strip() == TEST_VALUE

test/test_encryption.py

@@ -1,30 +1,31 @@
 """Test encryption"""
 
 import os
-import pipes
+import shlex
 import time
+
 import pytest
 
-KEY_FILE = 'test/test_key'
+KEY_FILE = "test/test_key"
-KEY_FINGERPRINT = 'F8BBFC746C58945442349BCEBA54FFD04C599B1A'
+KEY_FINGERPRINT = "F8BBFC746C58945442349BCEBA54FFD04C599B1A"
-KEY_NAME = 'yadm-test1'
+KEY_NAME = "yadm-test1"
-KEY_TRUST = 'test/ownertrust.txt'
+KEY_TRUST = "test/ownertrust.txt"
-PASSPHRASE = 'ExamplePassword'
+PASSPHRASE = "ExamplePassword"
 
-pytestmark = pytest.mark.usefixtures('config_git')
+pytestmark = pytest.mark.usefixtures("config_git")
 
 
 def add_asymmetric_key(runner, gnupg):
     """Add asymmetric key"""
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
     runner(
-        ['gpg', '--import', pipes.quote(KEY_FILE)],
+        ["gpg", "--import", shlex.quote(KEY_FILE)],
         env=env,
         shell=True,
     )
     runner(
-        ['gpg', '--import-ownertrust', '<', pipes.quote(KEY_TRUST)],
+        ["gpg", "--import-ownertrust", "<", shlex.quote(KEY_TRUST)],
         env=env,
         shell=True,
     )
@@ -33,20 +34,14 @@ def add_asymmetric_key(runner, gnupg):
 def remove_asymmetric_key(runner, gnupg):
     """Remove asymmetric key"""
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
     runner(
-        [
+        ["gpg", "--batch", "--yes", "--delete-secret-keys", shlex.quote(KEY_FINGERPRINT)],
-            'gpg', '--batch', '--yes',
-            '--delete-secret-keys', pipes.quote(KEY_FINGERPRINT)
-        ],
         env=env,
         shell=True,
     )
     runner(
-        [
+        ["gpg", "--batch", "--yes", "--delete-key", shlex.quote(KEY_FINGERPRINT)],
-            'gpg', '--batch', '--yes',
-            '--delete-key', pipes.quote(KEY_FINGERPRINT)
-        ],
         env=env,
         shell=True,
     )
@@ -78,48 +73,48 @@ def encrypt_targets(yadm_cmd, paths):
     """
 
     # init empty yadm repo
-    os.system(' '.join(yadm_cmd('init', '-w', str(paths.work), '-f')))
+    os.system(" ".join(yadm_cmd("init", "-w", str(paths.work), "-f")))
 
     expected = []
 
     # standard files w/ dirs & spaces
-    paths.work.join('inc file1').write('inc file1')
+    paths.work.join("inc file1").write("inc file1")
-    expected.append('inc file1')
+    expected.append("inc file1")
-    paths.encrypt.write('inc file1\n')
+    paths.encrypt.write("inc file1\n")
-    paths.work.join('inc dir').mkdir()
+    paths.work.join("inc dir").mkdir()
-    paths.work.join('inc dir/inc file2').write('inc file2')
+    paths.work.join("inc dir/inc file2").write("inc file2")
-    expected.append('inc dir/inc file2')
+    expected.append("inc dir/inc file2")
-    paths.encrypt.write('inc dir/inc file2\n', mode='a')
+    paths.encrypt.write("inc dir/inc file2\n", mode="a")
 
     # standard globs w/ dirs & spaces
-    paths.work.join('globs file1').write('globs file1')
+    paths.work.join("globs file1").write("globs file1")
-    expected.append('globs file1')
+    expected.append("globs file1")
-    paths.work.join('globs dir').mkdir()
+    paths.work.join("globs dir").mkdir()
-    paths.work.join('globs dir/globs file2').write('globs file2')
+    paths.work.join("globs dir/globs file2").write("globs file2")
-    expected.append('globs dir/globs file2')
+    expected.append("globs dir/globs file2")
-    paths.encrypt.write('globs*\n', mode='a')
+    paths.encrypt.write("globs*\n", mode="a")
 
     # blank lines
-    paths.encrypt.write('\n        \n\t\n', mode='a')
+    paths.encrypt.write("\n        \n\t\n", mode="a")
 
     # comments
-    paths.work.join('commentfile1').write('commentfile1')
+    paths.work.join("commentfile1").write("commentfile1")
-    paths.encrypt.write('#commentfile1\n', mode='a')
+    paths.encrypt.write("#commentfile1\n", mode="a")
-    paths.encrypt.write('        #commentfile1\n', mode='a')
+    paths.encrypt.write("        #commentfile1\n", mode="a")
 
     # exclusions
-    paths.work.join('extest').mkdir()
+    paths.work.join("extest").mkdir()
-    paths.encrypt.write('extest/*\n', mode='a')  # include within extest
+    paths.encrypt.write("extest/*\n", mode="a")  # include within extest
-    paths.work.join('extest/inglob1').write('inglob1')
+    paths.work.join("extest/inglob1").write("inglob1")
-    paths.work.join('extest/exglob1').write('exglob1')
+    paths.work.join("extest/exglob1").write("exglob1")
-    paths.work.join('extest/exglob2').write('exglob2')
+    paths.work.join("extest/exglob2").write("exglob2")
-    paths.encrypt.write('!extest/ex*\n', mode='a')  # exclude the ex*
+    paths.encrypt.write("!extest/ex*\n", mode="a")  # exclude the ex*
-    expected.append('extest/inglob1')  # should be left with only in*
+    expected.append("extest/inglob1")  # should be left with only in*
 
     return expected
 
 
-@pytest.fixture(scope='session')
+@pytest.fixture(scope="session")
 def decrypt_targets(tmpdir_factory, runner, gnupg):
     """Fixture for setting data to decrypt
 
@@ -128,234 +123,203 @@ def decrypt_targets(tmpdir_factory, runner, gnupg):
       * creates a list of expected decrypted files
     """
 
-    tmpdir = tmpdir_factory.mktemp('decrypt_targets')
+    tmpdir = tmpdir_factory.mktemp("decrypt_targets")
-    symmetric = tmpdir.join('symmetric.tar.gz.gpg')
+    symmetric = tmpdir.join("symmetric.tar.gz.gpg")
-    asymmetric = tmpdir.join('asymmetric.tar.gz.gpg')
+    asymmetric = tmpdir.join("asymmetric.tar.gz.gpg")
 
     expected = []
 
-    tmpdir.join('decrypt1').write('decrypt1')
+    tmpdir.join("decrypt1").write("decrypt1")
-    expected.append('decrypt1')
+    expected.append("decrypt1")
-    tmpdir.join('decrypt2').write('decrypt2')
+    tmpdir.join("decrypt2").write("decrypt2")
-    expected.append('decrypt2')
+    expected.append("decrypt2")
-    tmpdir.join('subdir').mkdir()
+    tmpdir.join("subdir").mkdir()
-    tmpdir.join('subdir/decrypt3').write('subdir/decrypt3')
+    tmpdir.join("subdir/decrypt3").write("subdir/decrypt3")
-    expected.append('subdir/decrypt3')
+    expected.append("subdir/decrypt3")
 
     gnupg.pw(PASSPHRASE)
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
     run = runner(
-        ['tar', 'cvf', '-'] +
+        ["tar", "cvf", "-"]
-        expected +
+        + expected
-        ['|', 'gpg', '--batch', '--yes', '-c'] +
+        + ["|", "gpg", "--batch", "--yes", "-c"]
-        ['--output', pipes.quote(str(symmetric))],
+        + ["--output", shlex.quote(str(symmetric))],
         cwd=tmpdir,
         env=env,
-        shell=True)
+        shell=True,
+    )
     assert run.success
 
-    gnupg.pw('')
+    gnupg.pw("")
     add_asymmetric_key(runner, gnupg)
     run = runner(
-        ['tar', 'cvf', '-'] +
+        ["tar", "cvf", "-"]
-        expected +
+        + expected
-        ['|', 'gpg', '--batch', '--yes', '-e'] +
+        + ["|", "gpg", "--batch", "--yes", "-e"]
-        ['-r', pipes.quote(KEY_NAME)] +
+        + ["-r", shlex.quote(KEY_NAME)]
-        ['--output', pipes.quote(str(asymmetric))],
+        + ["--output", shlex.quote(str(asymmetric))],
         cwd=tmpdir,
         env=env,
-        shell=True)
+        shell=True,
+    )
     assert run.success
     remove_asymmetric_key(runner, gnupg)
 
     return {
-        'asymmetric': asymmetric,
+        "asymmetric": asymmetric,
-        'expected': expected,
+        "expected": expected,
-        'symmetric': symmetric,
+        "symmetric": symmetric,
     }
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("bad_phrase", [False, True], ids=["good_phrase", "bad_phrase"])
-    'bad_phrase', [False, True],
+@pytest.mark.parametrize("missing_encrypt", [False, True], ids=["encrypt_exists", "encrypt_missing"])
-    ids=['good_phrase', 'bad_phrase'])
+@pytest.mark.parametrize("overwrite", [False, True], ids=["clean", "overwrite"])
-@pytest.mark.parametrize(
+def test_symmetric_encrypt(runner, yadm_cmd, paths, encrypt_targets, gnupg, bad_phrase, overwrite, missing_encrypt):
-    'missing_encrypt', [False, True],
-    ids=['encrypt_exists', 'encrypt_missing'])
-@pytest.mark.parametrize(
-    'overwrite', [False, True],
-    ids=['clean', 'overwrite'])
-def test_symmetric_encrypt(
-        runner, yadm_cmd, paths, encrypt_targets,
-        gnupg, bad_phrase, overwrite, missing_encrypt):
     """Test symmetric encryption"""
 
     if missing_encrypt:
         paths.encrypt.remove()
 
     if bad_phrase:
-        gnupg.pw('')
+        gnupg.pw("")
     else:
         gnupg.pw(PASSPHRASE)
 
     if overwrite:
-        paths.archive.write('existing archive')
+        paths.archive.write("existing archive")
 
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
-    run = runner(yadm_cmd('encrypt'), env=env)
+    run = runner(yadm_cmd("encrypt"), env=env)
 
     if missing_encrypt or bad_phrase:
         assert run.failure
     else:
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
 
     if missing_encrypt:
-        assert 'does not exist' in run.err
+        assert "does not exist" in run.err
     elif bad_phrase:
-        assert 'Invalid passphrase' in run.err
+        assert "Invalid IPC" in run.err
     else:
-        assert encrypted_data_valid(
+        assert encrypted_data_valid(runner, gnupg, paths.archive, encrypt_targets)
-            runner, gnupg, paths.archive, encrypt_targets)
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("bad_phrase", [False, True], ids=["good_phrase", "bad_phrase"])
-    'bad_phrase', [False, True],
+@pytest.mark.parametrize("archive_exists", [True, False], ids=["archive_exists", "archive_missing"])
-    ids=['good_phrase', 'bad_phrase'])
+@pytest.mark.parametrize("dolist", [False, True], ids=["decrypt", "list"])
-@pytest.mark.parametrize(
+def test_symmetric_decrypt(runner, yadm_cmd, paths, decrypt_targets, gnupg, dolist, archive_exists, bad_phrase):
-    'archive_exists', [True, False],
-    ids=['archive_exists', 'archive_missing'])
-@pytest.mark.parametrize(
-    'dolist', [False, True],
-    ids=['decrypt', 'list'])
-def test_symmetric_decrypt(
-        runner, yadm_cmd, paths, decrypt_targets, gnupg,
-        dolist, archive_exists, bad_phrase):
     """Test decryption"""
 
     # init empty yadm repo
-    os.system(' '.join(yadm_cmd('init', '-w', str(paths.work), '-f')))
+    os.system(" ".join(yadm_cmd("init", "-w", str(paths.work), "-f")))
 
     if bad_phrase:
-        gnupg.pw('')
+        gnupg.pw("")
         time.sleep(1)  # allow gpg-agent cache to expire
     else:
         gnupg.pw(PASSPHRASE)
 
     if archive_exists:
-        decrypt_targets['symmetric'].copy(paths.archive)
+        decrypt_targets["symmetric"].copy(paths.archive)
 
     # to test overwriting
-    paths.work.join('decrypt1').write('pre-existing file')
+    paths.work.join("decrypt1").write("pre-existing file")
 
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
 
     args = []
 
     if dolist:
-        args.append('-l')
+        args.append("-l")
-    run = runner(yadm_cmd('decrypt') + args, env=env)
+    run = runner(yadm_cmd("decrypt") + args, env=env)
 
     if archive_exists and not bad_phrase:
         assert run.success
-        assert 'encrypted with 1 passphrase' in run.err
+        assert "encrypted with 1 passphrase" in run.err
         if dolist:
-            for filename in decrypt_targets['expected']:
+            for filename in decrypt_targets["expected"]:
-                if filename != 'decrypt1':  # this one should exist
+                if filename != "decrypt1":  # this one should exist
                     assert not paths.work.join(filename).exists()
                 assert filename in run.out
         else:
-            for filename in decrypt_targets['expected']:
+            for filename in decrypt_targets["expected"]:
                 assert paths.work.join(filename).read() == filename
     else:
         assert run.failure
 
 
-@pytest.mark.usefixtures('asymmetric_key')
+@pytest.mark.usefixtures("asymmetric_key")
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("ask", [False, True], ids=["no_ask", "ask"])
-    'ask', [False, True],
+@pytest.mark.parametrize("key_exists", [True, False], ids=["key_exists", "key_missing"])
-    ids=['no_ask', 'ask'])
+@pytest.mark.parametrize("overwrite", [False, True], ids=["clean", "overwrite"])
-@pytest.mark.parametrize(
+def test_asymmetric_encrypt(runner, yadm_cmd, paths, encrypt_targets, gnupg, overwrite, key_exists, ask):
-    'key_exists', [True, False],
-    ids=['key_exists', 'key_missing'])
-@pytest.mark.parametrize(
-    'overwrite', [False, True],
-    ids=['clean', 'overwrite'])
-def test_asymmetric_encrypt(
-        runner, yadm_cmd, paths, encrypt_targets, gnupg,
-        overwrite, key_exists, ask):
     """Test asymmetric encryption"""
 
     # specify encryption recipient
     if ask:
-        os.system(' '.join(yadm_cmd('config', 'yadm.gpg-recipient', 'ASK')))
+        os.system(" ".join(yadm_cmd("config", "yadm.gpg-recipient", "ASK")))
-        expect = [('Enter the user ID', KEY_NAME), ('Enter the user ID', '')]
+        expect = [("Enter the user ID", KEY_NAME), ("Enter the user ID", "")]
     else:
-        os.system(' '.join(yadm_cmd('config', 'yadm.gpg-recipient', KEY_NAME)))
+        os.system(" ".join(yadm_cmd("config", "yadm.gpg-recipient", KEY_NAME)))
         expect = []
 
     if overwrite:
-        paths.archive.write('existing archive')
+        paths.archive.write("existing archive")
 
     if not key_exists:
         remove_asymmetric_key(runner, gnupg)
 
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
 
-    run = runner(yadm_cmd('encrypt'), env=env, expect=expect)
+    run = runner(yadm_cmd("encrypt"), env=env, expect=expect)
 
     if key_exists:
         assert run.success
-        assert encrypted_data_valid(
+        assert encrypted_data_valid(runner, gnupg, paths.archive, encrypt_targets)
-            runner, gnupg, paths.archive, encrypt_targets)
     else:
         assert run.failure
-        assert 'Unable to write' in run.out if expect else run.err
+        assert "Unable to write" in run.out if expect else run.err
 
     if ask:
-        assert 'Enter the user ID' in run.out
+        assert "Enter the user ID" in run.out
 
 
-@pytest.mark.usefixtures('asymmetric_key')
+@pytest.mark.usefixtures("asymmetric_key")
-@pytest.mark.usefixtures('encrypt_targets')
+@pytest.mark.usefixtures("encrypt_targets")
 def test_multi_key(runner, yadm_cmd, gnupg):
     """Test multiple recipients"""
 
     # specify two encryption recipient
-    os.system(' '.join(yadm_cmd(
+    os.system(" ".join(yadm_cmd("config", "yadm.gpg-recipient", f'"second-key {KEY_NAME}"')))
-        'config', 'yadm.gpg-recipient', f'"second-key {KEY_NAME}"')))
 
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
 
-    run = runner(yadm_cmd('encrypt'), env=env)
+    run = runner(yadm_cmd("encrypt"), env=env)
 
     assert run.failure
-    assert 'second-key: skipped: No public key' in run.err
+    assert "second-key: skipped: No public key" in run.err
 
 
-@pytest.mark.usefixtures('asymmetric_key')
+@pytest.mark.usefixtures("asymmetric_key")
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("key_exists", [True, False], ids=["key_exists", "key_missing"])
-    'key_exists', [True, False],
+@pytest.mark.parametrize("dolist", [False, True], ids=["decrypt", "list"])
-    ids=['key_exists', 'key_missing'])
+def test_asymmetric_decrypt(runner, yadm_cmd, paths, decrypt_targets, gnupg, dolist, key_exists):
-@pytest.mark.parametrize(
-    'dolist', [False, True],
-    ids=['decrypt', 'list'])
-def test_asymmetric_decrypt(
-        runner, yadm_cmd, paths, decrypt_targets, gnupg,
-        dolist, key_exists):
     """Test decryption"""
 
     # init empty yadm repo
-    os.system(' '.join(yadm_cmd('init', '-w', str(paths.work), '-f')))
+    os.system(" ".join(yadm_cmd("init", "-w", str(paths.work), "-f")))
 
-    decrypt_targets['asymmetric'].copy(paths.archive)
+    decrypt_targets["asymmetric"].copy(paths.archive)
 
     # to test overwriting
-    paths.work.join('decrypt1').write('pre-existing file')
+    paths.work.join("decrypt1").write("pre-existing file")
 
     if not key_exists:
         remove_asymmetric_key(runner, gnupg)
@@ -363,32 +327,28 @@ def test_asymmetric_decrypt(
     args = []
 
     if dolist:
-        args.append('-l')
+        args.append("-l")
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
-    run = runner(yadm_cmd('decrypt') + args, env=env)
+    run = runner(yadm_cmd("decrypt") + args, env=env)
 
     if key_exists:
         assert run.success
         if dolist:
-            for filename in decrypt_targets['expected']:
+            for filename in decrypt_targets["expected"]:
-                if filename != 'decrypt1':  # this one should exist
+                if filename != "decrypt1":  # this one should exist
                     assert not paths.work.join(filename).exists()
                 assert filename in run.out
         else:
-            for filename in decrypt_targets['expected']:
+            for filename in decrypt_targets["expected"]:
                 assert paths.work.join(filename).read() == filename
     else:
         assert run.failure
-        assert 'Unable to extract encrypted files' in run.err
+        assert "Unable to extract encrypted files" in run.err
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("untracked", [False, "y", "n"], ids=["tracked", "untracked_answer_y", "untracked_answer_n"])
-    'untracked',
+def test_offer_to_add(runner, yadm_cmd, paths, encrypt_targets, gnupg, untracked):
-    [False, 'y', 'n'],
-    ids=['tracked', 'untracked_answer_y', 'untracked_answer_n'])
-def test_offer_to_add(
-        runner, yadm_cmd, paths, encrypt_targets, gnupg, untracked):
     """Test offer to add encrypted archive
 
     All the other encryption tests use an archive outside of the work tree.
@@ -396,85 +356,75 @@ def test_offer_to_add(
     should be an offer to add it to the repo if it is not tracked.
     """
 
-    worktree_archive = paths.work.join('worktree-archive.tar.gpg')
+    worktree_archive = paths.work.join("worktree-archive.tar.gpg")
 
     expect = []
 
     gnupg.pw(PASSPHRASE)
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
 
     if untracked:
-        expect.append(('add it now', untracked))
+        expect.append(("add it now", untracked))
     else:
-        worktree_archive.write('exists')
+        worktree_archive.write("exists")
-        os.system(' '.join(yadm_cmd('add', str(worktree_archive))))
+        os.system(" ".join(yadm_cmd("add", str(worktree_archive))))
 
-    run = runner(
+    run = runner(yadm_cmd("encrypt", "--yadm-archive", str(worktree_archive)), env=env, expect=expect)
-        yadm_cmd('encrypt', '--yadm-archive', str(worktree_archive)),
-        env=env,
-        expect=expect
-        )
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert encrypted_data_valid(
+    assert encrypted_data_valid(runner, gnupg, worktree_archive, encrypt_targets)
-        runner, gnupg, worktree_archive, encrypt_targets)
 
-    run = runner(
+    run = runner(yadm_cmd("status", "--porcelain", "-uall", str(worktree_archive)))
-        yadm_cmd('status', '--porcelain', '-uall', str(worktree_archive)))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
 
-    if untracked == 'y':
+    if untracked == "y":
         # should be added to the index
-        assert f'A  {worktree_archive.basename}' in run.out
+        assert f"A  {worktree_archive.basename}" in run.out
-    elif untracked == 'n':
+    elif untracked == "n":
         # should NOT be added to the index
-        assert f'?? {worktree_archive.basename}' in run.out
+        assert f"?? {worktree_archive.basename}" in run.out
     else:
         # should appear modified in the index
-        assert f'AM {worktree_archive.basename}' in run.out
+        assert f"AM {worktree_archive.basename}" in run.out
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
 def test_encrypt_added_to_exclude(runner, yadm_cmd, paths, gnupg):
     """Confirm that .config/yadm/encrypt is added to exclude"""
 
     gnupg.pw(PASSPHRASE)
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
 
-    exclude_file = paths.repo.join('info/exclude')
+    exclude_file = paths.repo.join("info/exclude")
-    paths.encrypt.write('test-encrypt-data\n')
+    paths.encrypt.write("test-encrypt-data\n")
-    paths.work.join('test-encrypt-data').write('')
+    paths.work.join("test-encrypt-data").write("")
-    exclude_file.write('original-data', ensure=True)
+    exclude_file.write("original-data", ensure=True)
 
-    run = runner(yadm_cmd('encrypt'), env=env)
+    run = runner(yadm_cmd("encrypt"), env=env)
 
-    assert 'test-encrypt-data' in paths.repo.join('info/exclude').read()
+    assert "test-encrypt-data" in paths.repo.join("info/exclude").read()
-    assert 'original-data' in paths.repo.join('info/exclude').read()
+    assert "original-data" in paths.repo.join("info/exclude").read()
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
 
 
 def encrypted_data_valid(runner, gnupg, encrypted, expected):
     """Verify encrypted data matches expectations"""
     gnupg.pw(PASSPHRASE)
     env = os.environ.copy()
-    env['GNUPGHOME'] = gnupg.home
+    env["GNUPGHOME"] = gnupg.home
-    run = runner([
+    run = runner(
-        'gpg',
+        ["gpg", "-d", shlex.quote(str(encrypted)), "2>/dev/null", "|", "tar", "t"], env=env, shell=True, report=False
-        '-d', pipes.quote(str(encrypted)),
+    )
-        '2>/dev/null',
-        '|', 'tar', 't'], env=env, shell=True, report=False)
     file_count = 0
     for filename in run.out.splitlines():
-        if filename.endswith('/'):
+        if filename.endswith("/"):
             continue
         file_count += 1
-        assert filename in expected, (
+        assert filename in expected, f"Unexpected file in archive: {filename}"
-            f'Unexpected file in archive: {filename}')
+    assert file_count == len(expected), "Number of files in archive does not match expected"
-    assert file_count == len(expected), (
-        'Number of files in archive does not match expected')
     return True

test/test_enter.py

@@ -1,110 +1,117 @@
 """Test enter"""
 
 import os
+
 import pytest
 
 
 @pytest.mark.parametrize(
-    'shell, success', [
+    "shell, success",
-        ('delete', True),  # if there is no shell variable, bash creates it
+    [
-        ('', False),
+        ("delete", True),  # if there is no shell variable, bash creates it
-        ('/usr/bin/env', True),
+        ("", False),
-        ('noexec', False),
+        ("/usr/bin/env", True),
-    ], ids=[
+        ("noexec", False),
-        'shell-missing',
+    ],
-        'shell-empty',
+    ids=[
-        'shell-env',
+        "shell-missing",
-        'shell-noexec',
+        "shell-empty",
-    ])
+        "shell-env",
-@pytest.mark.usefixtures('ds1_copy')
+        "shell-noexec",
+    ],
+)
+@pytest.mark.usefixtures("ds1_copy")
 def test_enter(runner, yadm_cmd, paths, shell, success):
     """Enter tests"""
     env = os.environ.copy()
-    if shell == 'delete':
+    if shell == "delete":
         # remove shell
-        if 'SHELL' in env:
+        if "SHELL" in env:
-            del env['SHELL']
+            del env["SHELL"]
-    elif shell == 'noexec':
+    elif shell == "noexec":
         # specify a non-executable path
-        noexec = paths.root.join('noexec')
+        noexec = paths.root.join("noexec")
-        noexec.write('')
+        noexec.write("")
         noexec.chmod(0o664)
-        env['SHELL'] = str(noexec)
+        env["SHELL"] = str(noexec)
     else:
-        env['SHELL'] = shell
+        env["SHELL"] = shell
 
-    run = runner(command=yadm_cmd('enter'), env=env)
+    run = runner(command=yadm_cmd("enter"), env=env)
     assert run.success == success
-    prompt = f'yadm shell ({paths.repo})'
+    prompt = f"yadm shell ({paths.repo})"
     if success:
-        assert run.out.startswith('Entering yadm repo')
+        assert run.out.startswith("Entering yadm repo")
-        assert run.out.rstrip().endswith('Leaving yadm repo')
+        assert run.out.rstrip().endswith("Leaving yadm repo")
-        assert run.err == ''
+        assert run.err == ""
     else:
-        assert 'does not refer to an executable' in run.err
+        assert "does not refer to an executable" in run.err
-    if 'env' in shell:
+    if "env" in shell:
-        assert f'GIT_DIR={paths.repo}' in run.out
+        assert f"GIT_DIR={paths.repo}" in run.out
-        assert f'GIT_WORK_TREE={paths.work}' in run.out
+        assert f"GIT_WORK_TREE={paths.work}" in run.out
-        assert f'PROMPT={prompt}' in run.out
+        assert f"PROMPT={prompt}" in run.out
-        assert f'PS1={prompt}' in run.out
+        assert f"PS1={prompt}" in run.out
 
 
 @pytest.mark.parametrize(
-    'shell, opts, path', [
+    "shell, opts, path",
-        ('bash', '--norc', '\\w'),
+    [
-        ('csh', '-f', '%~'),
+        ("bash", "--norc", "\\w"),
-        ('zsh', '-f', '%~'),
+        ("csh", "-f", "%~"),
-    ], ids=[
+        ("zsh", "-f", "%~"),
-        'bash',
+    ],
-        'csh',
+    ids=[
-        'zsh',
+        "bash",
-    ])
+        "csh",
+        "zsh",
+    ],
+)
 @pytest.mark.parametrize(
-    'cmd',
+    "cmd",
-    [False, 'cmd', 'cmd-bad-exit'],
+    [False, "cmd", "cmd-bad-exit"],
-    ids=['no-cmd', 'cmd', 'cmd-bad-exit'])
+    ids=["no-cmd", "cmd", "cmd-bad-exit"],
+)
 @pytest.mark.parametrize(
-    'term', ['', 'dumb'],
+    "term",
-    ids=['term-empty', 'term-dumb'])
+    ["", "dumb"],
-@pytest.mark.usefixtures('ds1_copy')
+    ids=["term-empty", "term-dumb"],
-def test_enter_shell_ops(runner, yadm_cmd, paths, shell,
+)
-                         opts, path, cmd, term):
+@pytest.mark.usefixtures("ds1_copy")
+def test_enter_shell_ops(runner, yadm_cmd, paths, shell, opts, path, cmd, term):
     """Enter tests for specific shell options"""
 
-    change_exit = '\nfalse' if cmd == 'cmd-bad-exit' else ''
+    change_exit = "\nfalse" if cmd == "cmd-bad-exit" else ""
 
     # Create custom shell to detect options passed
     custom_shell = paths.root.join(shell)
-    custom_shell.write(
+    custom_shell.write(f"#!/bin/sh\necho OPTS=$*\necho PROMPT=$PROMPT{change_exit}")
-        f'#!/bin/sh\necho OPTS=$*\necho PROMPT=$PROMPT{change_exit}'
-    )
     custom_shell.chmod(0o775)
 
-    test_cmd = ['test1', 'test2', 'test3']
+    test_cmd = ["test1", "test2", "test3"]
 
-    enter_cmd = ['enter']
+    enter_cmd = ["enter"]
     if cmd:
         enter_cmd += test_cmd
 
     env = os.environ.copy()
-    env['TERM'] = term
+    env["TERM"] = term
-    env['SHELL'] = custom_shell
+    env["SHELL"] = custom_shell
 
-    if shell == 'zsh' and term == 'dumb':
+    if shell == "zsh" and term == "dumb":
-        opts += ' --no-zle'
+        opts += " --no-zle"
 
     run = runner(command=yadm_cmd(*enter_cmd), env=env)
-    if cmd == 'cmd-bad-exit':
+    if cmd == "cmd-bad-exit":
         assert run.failure
     else:
         assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert f'OPTS={opts}' in run.out
+    assert f"OPTS={opts}" in run.out
-    assert f'PROMPT=yadm shell ({paths.repo}) {path} >' in run.out
+    assert f"PROMPT=yadm shell ({paths.repo}) {path} >" in run.out
     if cmd:
-        assert '-c ' + ' '.join(test_cmd) in run.out
+        assert "-c " + " ".join(test_cmd) in run.out
-        assert 'Entering yadm repo' not in run.out
+        assert "Entering yadm repo" not in run.out
-        assert 'Leaving yadm repo' not in run.out
+        assert "Leaving yadm repo" not in run.out
     else:
-        assert 'Entering yadm repo' in run.out
+        assert "Entering yadm repo" in run.out
-        assert 'Leaving yadm repo' in run.out
+        assert "Leaving yadm repo" in run.out

test/test_ext_crypt.py

@@ -4,28 +4,30 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'crypt',
+    "crypt",
-    [False, 'installed', 'installed-but-failed'],
+    [False, "installed", "installed-but-failed"],
-    ids=['not-installed', 'installed', 'installed-but-failed']
+    ids=["not-installed", "installed", "installed-but-failed"],
 )
 @pytest.mark.parametrize(
-        'cmd,var', [
+    "cmd,var",
-            ['git_crypt', 'GIT_CRYPT_PROGRAM'],
+    [
-            ['transcrypt', 'TRANSCRYPT_PROGRAM'],
+        ["git_crypt", "GIT_CRYPT_PROGRAM"],
-        ],
+        ["transcrypt", "TRANSCRYPT_PROGRAM"],
-        ids=['git-crypt', 'transcrypt'])
+    ],
+    ids=["git-crypt", "transcrypt"],
+)
 def test_ext_encryption(runner, yadm, paths, tmpdir, crypt, cmd, var):
     """External encryption tests"""
 
     paths.repo.ensure(dir=True)
-    bindir = tmpdir.mkdir('bin')
+    bindir = tmpdir.mkdir("bin")
-    pgm = bindir.join('test-ext-crypt')
+    pgm = bindir.join("test-ext-crypt")
 
     if crypt:
-        pgm.write('#!/bin/sh\necho ext-crypt ran\n')
+        pgm.write("#!/bin/sh\necho ext-crypt ran\n")
         pgm.chmod(0o775)
-    if crypt == 'installed-but-failed':
+    if crypt == "installed-but-failed":
-        pgm.write('false\n', mode='a')
+        pgm.write("false\n", mode="a")
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -34,15 +36,15 @@ def test_ext_encryption(runner, yadm, paths, tmpdir, crypt, cmd, var):
         {cmd} "param1"
     """
 
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
 
     if crypt:
-        if crypt == 'installed-but-failed':
+        if crypt == "installed-but-failed":
             assert run.failure
         else:
             assert run.success
-        assert run.out.strip() == 'ext-crypt ran'
+        assert run.out.strip() == "ext-crypt ran"
-        assert run.err == ''
+        assert run.err == ""
     else:
         assert run.failure
         assert f"command '{pgm}' cannot be located" in run.err

test/test_git.py

@@ -1,10 +1,11 @@
 """Test git"""
 
 import re
+
 import pytest
 
 
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
 def test_git(runner, yadm_cmd, paths):
     """Test series of passthrough git commands
 
@@ -17,42 +18,42 @@ def test_git(runner, yadm_cmd, paths):
     """
 
     # passthru unknown commands to Git
-    run = runner(command=yadm_cmd('bogus'))
+    run = runner(command=yadm_cmd("bogus"))
     assert run.failure
     assert "git: 'bogus' is not a git command." in run.err
     assert "See 'git --help'" in run.err
-    assert run.out == ''
+    assert run.out == ""
 
     # git command 'add' - badfile
-    run = runner(command=yadm_cmd('add', '-v', 'does_not_exist'))
+    run = runner(command=yadm_cmd("add", "-v", "does_not_exist"))
     assert run.code == 128
     assert "pathspec 'does_not_exist' did not match any files" in run.err
-    assert run.out == ''
+    assert run.out == ""
 
     # git command 'add'
-    newfile = paths.work.join('test_git')
+    newfile = paths.work.join("test_git")
-    newfile.write('test_git')
+    newfile.write("test_git")
-    run = runner(command=yadm_cmd('add', '-v', str(newfile)))
+    run = runner(command=yadm_cmd("add", "-v", str(newfile)))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert "add 'test_git'" in run.out
 
     # git command 'status'
-    run = runner(command=yadm_cmd('status'))
+    run = runner(command=yadm_cmd("status"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert re.search(r'new file:\s+test_git', run.out)
+    assert re.search(r"new file:\s+test_git", run.out)
 
     # git command 'commit'
-    run = runner(command=yadm_cmd('commit', '-m', 'Add test_git'))
+    run = runner(command=yadm_cmd("commit", "-m", "Add test_git"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert '1 file changed' in run.out
+    assert "1 file changed" in run.out
-    assert '1 insertion' in run.out
+    assert "1 insertion" in run.out
-    assert re.search(r'create mode .+ test_git', run.out)
+    assert re.search(r"create mode .+ test_git", run.out)
 
     # git command 'log'
-    run = runner(command=yadm_cmd('log', '--oneline'))
+    run = runner(command=yadm_cmd("log", "--oneline"))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'Add test_git' in run.out
+    assert "Add test_git" in run.out

test/test_help.py

@@ -6,14 +6,14 @@ def test_missing_command(runner, yadm_cmd):
     """Run without any command"""
     run = runner(command=yadm_cmd())
     assert run.failure
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out.startswith('Usage: yadm')
+    assert run.out.startswith("Usage: yadm")
 
 
-@pytest.mark.parametrize('cmd', ['--help', 'help'])
+@pytest.mark.parametrize("cmd", ["--help", "help"])
 def test_help_command(runner, yadm_cmd, cmd):
     """Run with help command"""
     run = runner(command=yadm_cmd(cmd))
     assert run.failure
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out.startswith('Usage: yadm')
+    assert run.out.startswith("Usage: yadm")

test/test_hooks.py

@@ -4,7 +4,8 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'pre, pre_code, post, post_code', [
+    "pre, pre_code, post, post_code",
+    [
         (False, 0, False, 0),
         (True, 0, False, 0),
         (True, 5, False, 0),
@@ -12,83 +13,83 @@ import pytest
         (False, 0, True, 5),
         (True, 0, True, 0),
         (True, 5, True, 5),
-    ], ids=[
+    ],
-        'no-hooks',
+    ids=[
-        'pre-success',
+        "no-hooks",
-        'pre-fail',
+        "pre-success",
-        'post-success',
+        "pre-fail",
-        'post-fail',
+        "post-success",
-        'pre-post-success',
+        "post-fail",
-        'pre-post-fail',
+        "pre-post-success",
-    ])
+        "pre-post-fail",
-@pytest.mark.parametrize('cmd', ['--version', 'version'])
+    ],
-def test_hooks(
+)
-        runner, yadm_cmd, paths, cmd,
+@pytest.mark.parametrize("cmd", ["--version", "version"])
-        pre, pre_code, post, post_code):
+def test_hooks(runner, yadm_cmd, paths, cmd, pre, pre_code, post, post_code):
     """Test pre/post hook"""
 
     # generate hooks
     if pre:
-        create_hook(paths, 'pre_version', pre_code)
+        create_hook(paths, "pre_version", pre_code)
     if post:
-        create_hook(paths, 'post_version', post_code)
+        create_hook(paths, "post_version", post_code)
 
     # run yadm
     run = runner(yadm_cmd(cmd))
     # when a pre hook fails, yadm should exit with the hook's code
     assert run.code == pre_code
-    assert run.err == ''
+    assert run.err == ""
 
     if pre:
-        assert 'HOOK:pre_version' in run.out
+        assert "HOOK:pre_version" in run.out
     # if pre hook is missing or successful, yadm itself should exit 0
     if run.success:
         if post:
-            assert 'HOOK:post_version' in run.out
+            assert "HOOK:post_version" in run.out
     else:
         # when a pre hook fails, yadm should not run the command
-        assert 'version will not be run' in run.out
+        assert "version will not be run" in run.out
         # when a pre hook fails, yadm should not run the post hook
-        assert 'HOOK:post_version' not in run.out
+        assert "HOOK:post_version" not in run.out
 
 
 # repo fixture is needed to test the population of YADM_HOOK_WORK
-@pytest.mark.usefixtures('ds1_repo_copy')
+@pytest.mark.usefixtures("ds1_repo_copy")
 def test_hook_env(runner, yadm_cmd, paths):
     """Test hook environment"""
 
     # test will be done with a non existent "git" passthru command
     # which should exit with a failing code
-    cmd = 'passthrucmd'
+    cmd = "passthrucmd"
 
     # write the hook
-    hook = paths.hooks.join(f'post_{cmd}')
+    hook = paths.hooks.join(f"post_{cmd}")
-    hook.write('#!/bin/bash\nenv\ndeclare\n')
+    hook.write("#!/bin/bash\nenv\ndeclare\n")
     hook.chmod(0o755)
 
-    run = runner(yadm_cmd(cmd, 'extra_args'))
+    run = runner(yadm_cmd(cmd, "extra_args"))
 
     # expect passthru to fail
     assert run.failure
     assert f"'{cmd}' is not a git command" in run.err
 
     # verify hook environment
-    assert 'YADM_HOOK_EXIT=1\n' in run.out
+    assert "YADM_HOOK_EXIT=1\n" in run.out
-    assert f'YADM_HOOK_COMMAND={cmd}\n' in run.out
+    assert f"YADM_HOOK_COMMAND={cmd}\n" in run.out
-    assert f'YADM_HOOK_DIR={paths.yadm}\n' in run.out
+    assert f"YADM_HOOK_DIR={paths.yadm}\n" in run.out
-    assert f'YADM_HOOK_FULL_COMMAND={cmd} extra_args\n' in run.out
+    assert f"YADM_HOOK_FULL_COMMAND={cmd} extra_args\n" in run.out
-    assert f'YADM_HOOK_REPO={paths.repo}\n' in run.out
+    assert f"YADM_HOOK_REPO={paths.repo}\n" in run.out
-    assert f'YADM_HOOK_WORK={paths.work}\n' in run.out
+    assert f"YADM_HOOK_WORK={paths.work}\n" in run.out
-    assert 'YADM_ENCRYPT_INCLUDE_FILES=\n' in run.out
+    assert "YADM_ENCRYPT_INCLUDE_FILES=\n" in run.out
 
     # verify the hook environment contains certain exported functions
     for func in [
-            'builtin_dirname',
+        "builtin_dirname",
-            'relative_path',
+        "relative_path",
-            'unix_path',
+        "unix_path",
-            'mixed_path',
+        "mixed_path",
     ]:
-        assert f'BASH_FUNC_{func}' in run.out
+        assert f"BASH_FUNC_{func}" in run.out
 
     # verify the hook environment contains the list of encrypted files
     script = f"""
@@ -98,10 +99,10 @@ def test_hook_env(runner, yadm_cmd, paths):
         ENCRYPT_INCLUDE_FILES=(a b c)
         invoke_hook "post"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'YADM_ENCRYPT_INCLUDE_FILES=a\nb\nc\n' in run.out
+    assert "YADM_ENCRYPT_INCLUDE_FILES=a\nb\nc\n" in run.out
 
 
 def test_escaped(runner, yadm_cmd, paths):
@@ -109,35 +110,33 @@ def test_escaped(runner, yadm_cmd, paths):
 
     # test will be done with a non existent "git" passthru command
     # which should exit with a failing code
-    cmd = 'passthrucmd'
+    cmd = "passthrucmd"
 
     # write the hook
-    hook = paths.hooks.join(f'post_{cmd}')
+    hook = paths.hooks.join(f"post_{cmd}")
-    hook.write('#!/bin/bash\nenv\n')
+    hook.write("#!/bin/bash\nenv\n")
     hook.chmod(0o755)
 
-    run = runner(yadm_cmd(cmd, 'a b', 'c\td', 'e\\f'))
+    run = runner(yadm_cmd(cmd, "a b", "c\td", "e\\f"))
 
     # expect passthru to fail
     assert run.failure
 
     # verify escaped values
-    assert (
+    assert f"YADM_HOOK_FULL_COMMAND={cmd} a\\ b c\\\td e\\\\f\n" in run.out
-        f'YADM_HOOK_FULL_COMMAND={cmd} '
-        'a\\ b c\\\td e\\\\f\n') in run.out
 
 
-@pytest.mark.parametrize('condition', ['exec', 'no-exec', 'mingw'])
+@pytest.mark.parametrize("condition", ["exec", "no-exec", "mingw"])
 def test_executable(runner, paths, condition):
     """Verify hook must be exectuable"""
-    cmd = 'version'
+    cmd = "version"
-    hook = paths.hooks.join(f'pre_{cmd}')
+    hook = paths.hooks.join(f"pre_{cmd}")
-    hook.write('#!/bin/sh\necho HOOK\n')
+    hook.write("#!/bin/sh\necho HOOK\n")
     hook.chmod(0o644)
-    if condition == 'exec':
+    if condition == "exec":
         hook.chmod(0o755)
 
-    mingw = 'OPERATING_SYSTEM="MINGWx"' if condition == 'mingw' else ''
+    mingw = 'OPERATING_SYSTEM="MINGWx"' if condition == "mingw" else ""
     script = f"""
         YADM_TEST=1 source {paths.pgm}
         YADM_HOOKS="{paths.hooks}"
@@ -145,27 +144,23 @@ def test_executable(runner, paths, condition):
         {mingw}
         invoke_hook "pre"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
 
-    if condition != 'mingw':
+    if condition != "mingw":
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
     else:
         assert run.failure
-        assert 'Permission denied' in run.err
+        assert "Permission denied" in run.err
 
-    if condition == 'exec':
+    if condition == "exec":
-        assert 'HOOK' in run.out
+        assert "HOOK" in run.out
-    elif condition == 'no-exec':
+    elif condition == "no-exec":
-        assert 'HOOK' not in run.out
+        assert "HOOK" not in run.out
 
 
 def create_hook(paths, name, code):
     """Create hook"""
     hook = paths.hooks.join(name)
-    hook.write(
+    hook.write("#!/bin/sh\n" f"echo HOOK:{name}\n" f"exit {code}\n")
-        '#!/bin/sh\n'
-        f'echo HOOK:{name}\n'
-        f'exit {code}\n'
-    )
     hook.chmod(0o755)

test/test_init.py

@@ -4,22 +4,24 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'alt_work, repo_present, force', [
+    "alt_work, repo_present, force",
+    [
         (False, False, False),
         (True, False, False),
         (False, True, False),
         (False, True, True),
         (True, True, True),
-    ], ids=[
+    ],
-        'simple',
+    ids=[
-        '-w',
+        "simple",
-        'existing repo',
+        "-w",
-        '-f',
+        "existing repo",
-        '-w & -f',
+        "-f",
-    ])
+        "-w & -f",
-@pytest.mark.usefixtures('ds1_work_copy')
+    ],
-def test_init(
+)
-        runner, yadm_cmd, paths, repo_config, alt_work, repo_present, force):
+@pytest.mark.usefixtures("ds1_work_copy")
+def test_init(runner, yadm_cmd, paths, repo_config, alt_work, repo_present, force):
     """Test init
 
     Repos should have attribs:
@@ -31,54 +33,54 @@ def test_init(
     """
 
     # these tests will assume this for $HOME
-    home = str(paths.root.mkdir('HOME'))
+    home = str(paths.root.mkdir("HOME"))
 
     # ds1_work_copy comes WITH an empty repo dir present.
-    old_repo = paths.repo.join('old_repo')
+    old_repo = paths.repo.join("old_repo")
     if repo_present:
         # Let's put some data in it, so we can confirm that data is gone when
         # forced to be overwritten.
-        old_repo.write('old repo data')
+        old_repo.write("old repo data")
         assert old_repo.isfile()
     else:
         paths.repo.remove()
 
     # command args
-    args = ['init']
+    args = ["init"]
     cwd = None
     if alt_work:
         if force:
             cwd = paths.work.dirname
-            args.extend(['-w', paths.work.basename])
+            args.extend(["-w", paths.work.basename])
         else:
-            args.extend(['-w', paths.work])
+            args.extend(["-w", paths.work])
     if force:
-        args.append('-f')
+        args.append("-f")
 
     # run init
-    run = runner(yadm_cmd(*args), env={'HOME': home}, cwd=cwd)
+    runner(["git", "config", "--global", "init.defaultBranch", "master"], env={"HOME": home}, cwd=cwd)
+    run = runner(yadm_cmd(*args), env={"HOME": home}, cwd=cwd)
 
     if repo_present and not force:
         assert run.failure
-        assert 'repo already exists' in run.err
+        assert "repo already exists" in run.err
-        assert old_repo.isfile(), 'Missing original repo'
+        assert old_repo.isfile(), "Missing original repo"
     else:
         assert run.success
-        assert 'Initialized empty shared Git repository' in run.out
+        assert "Initialized empty shared Git repository" in run.out
 
         if repo_present:
-            assert not old_repo.isfile(), 'Original repo still exists'
+            assert not old_repo.isfile(), "Original repo still exists"
         else:
-            assert run.err == ''
+            assert run.err == ""
 
         if alt_work:
-            assert repo_config('core.worktree') == paths.work
+            assert repo_config("core.worktree") == paths.work
         else:
-            assert repo_config('core.worktree') == home
+            assert repo_config("core.worktree") == home
 
         # uniform repo assertions
-        assert oct(paths.repo.stat().mode).endswith('00'), (
+        assert oct(paths.repo.stat().mode).endswith("00"), "Repo is not secure"
-            'Repo is not secure')
+        assert repo_config("core.bare") == "false"
-        assert repo_config('core.bare') == 'false'
+        assert repo_config("status.showUntrackedFiles") == "no"
-        assert repo_config('status.showUntrackedFiles') == 'no'
+        assert repo_config("yadm.managed") == "true"
-        assert repo_config('yadm.managed') == 'true'

test/test_introspect.py

@@ -4,38 +4,38 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'name', [
+    "name",
-        '',
+    [
-        'invalid',
+        "",
-        'commands',
+        "invalid",
-        'configs',
+        "commands",
-        'repo',
+        "configs",
-        'switches',
+        "repo",
-    ])
+        "switches",
-def test_introspect_category(
+    ],
-        runner, yadm_cmd, paths, name,
+)
-        supported_commands, supported_configs, supported_switches):
+def test_introspect_category(runner, yadm_cmd, paths, name, supported_commands, supported_configs, supported_switches):
     """Validate introspection category"""
     if name:
-        run = runner(command=yadm_cmd('introspect', name))
+        run = runner(command=yadm_cmd("introspect", name))
     else:
-        run = runner(command=yadm_cmd('introspect'))
+        run = runner(command=yadm_cmd("introspect"))
 
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
 
     expected = []
-    if name == 'commands':
+    if name == "commands":
         expected = supported_commands
-    elif name == 'configs':
+    elif name == "configs":
         expected = supported_configs
-    elif name == 'switches':
+    elif name == "switches":
         expected = supported_switches
 
     # assert values
-    if name in ('', 'invalid'):
+    if name in ("", "invalid"):
-        assert run.out == ''
+        assert run.out == ""
-    if name == 'repo':
+    if name == "repo":
         assert run.out.rstrip() == paths.repo
 
     # make sure every expected value is present

test/test_list.py

@@ -1,31 +1,34 @@
 """Test list"""
 
 import os
+
 import pytest
 
 
 @pytest.mark.parametrize(
-    'location', [
+    "location",
-        'work',
+    [
-        'outside',
+        "work",
-        'subdir',
+        "outside",
-    ])
+        "subdir",
-@pytest.mark.usefixtures('ds1_copy')
+    ],
+)
+@pytest.mark.usefixtures("ds1_copy")
 def test_list(runner, yadm_cmd, paths, ds1, location):
     """List tests"""
-    if location == 'work':
+    if location == "work":
         run_dir = paths.work
-    elif location == 'outside':
+    elif location == "outside":
-        run_dir = paths.work.join('..')
+        run_dir = paths.work.join("..")
-    elif location == 'subdir':
+    elif location == "subdir":
         # first directory with tracked data
         run_dir = paths.work.join(ds1.tracked_dirs[0])
     with run_dir.as_cwd():
         # test with '-a'
         # should get all tracked files, relative to the work path
-        run = runner(command=yadm_cmd('list', '-a'))
+        run = runner(command=yadm_cmd("list", "-a"))
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
         returned_files = set(run.out.splitlines())
         expected_files = {e.path for e in ds1 if e.tracked}
         assert returned_files == expected_files
@@ -33,16 +36,14 @@ def test_list(runner, yadm_cmd, paths, ds1, location):
         # should get all tracked files, relative to the work path unless in a
         # subdir, then those should be a limited set of files, relative to the
         # subdir
-        run = runner(command=yadm_cmd('list'))
+        run = runner(command=yadm_cmd("list"))
         assert run.success
-        assert run.err == ''
+        assert run.err == ""
         returned_files = set(run.out.splitlines())
-        if location == 'subdir':
+        if location == "subdir":
             basepath = os.path.basename(os.getcwd())
             # only expect files within the subdir
             # names should be relative to subdir
-            expected_files = {
+            index = len(basepath) + 1
-                e.path[len(basepath)+1:]
+            expected_files = {e.path[index:] for e in ds1 if e.tracked and e.path.startswith(basepath)}
-                for e in ds1 if e.tracked and e.path.startswith(basepath)
-            }
         assert returned_files == expected_files

test/test_perms.py

@@ -1,21 +1,21 @@
 """Test perms"""
 
 import os
+
 import pytest
 
 
-@pytest.mark.parametrize('autoperms', ['notest', 'unset', 'true', 'false'])
+@pytest.mark.parametrize("autoperms", ["notest", "unset", "true", "false"])
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
 def test_perms(runner, yadm_cmd, paths, ds1, autoperms):
     """Test perms"""
     # set the value of auto-perms
-    if autoperms != 'notest':
+    if autoperms != "notest":
-        if autoperms != 'unset':
+        if autoperms != "unset":
-            os.system(' '.join(
+            os.system(" ".join(yadm_cmd("config", "yadm.auto-perms", autoperms)))
-                yadm_cmd('config', 'yadm.auto-perms', autoperms)))
 
     # privatepaths will hold all paths that should become secured
-    privatepaths = [paths.work.join('.ssh'), paths.work.join('.gnupg')]
+    privatepaths = [paths.work.join(".ssh"), paths.work.join(".gnupg")]
     privatepaths += [paths.work.join(private.path) for private in ds1.private]
 
     # create an archive file
@@ -23,82 +23,71 @@ def test_perms(runner, yadm_cmd, paths, ds1, autoperms):
     privatepaths.append(paths.archive)
 
     # create encrypted file test data
-    efile1 = paths.work.join('efile1')
+    efile1 = paths.work.join("efile1")
-    efile1.write('efile1')
+    efile1.write("efile1")
-    efile2 = paths.work.join('efile2')
+    efile2 = paths.work.join("efile2")
-    efile2.write('efile2')
+    efile2.write("efile2")
-    paths.encrypt.write('efile1\nefile2\n!efile1\n')
+    paths.encrypt.write("efile1\nefile2\n!efile1\n")
     insecurepaths = [efile1]
     privatepaths.append(efile2)
 
     # assert these paths begin unsecured
     for private in privatepaths + insecurepaths:
-        assert not oct(private.stat().mode).endswith('00'), (
+        assert not oct(private.stat().mode).endswith("00"), "Path started secured"
-            'Path started secured')
 
-    cmd = 'perms'
+    cmd = "perms"
-    if autoperms != 'notest':
+    if autoperms != "notest":
-        cmd = 'status'
+        cmd = "status"
-    run = runner(yadm_cmd(cmd), env={'HOME': paths.work})
+    run = runner(yadm_cmd(cmd), env={"HOME": paths.work})
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if cmd == 'perms':
+    if cmd == "perms":
-        assert run.out == ''
+        assert run.out == ""
 
     # these paths should be secured if processing perms
     for private in privatepaths:
-        if autoperms == 'false':
+        if autoperms == "false":
-            assert not oct(private.stat().mode).endswith('00'), (
+            assert not oct(private.stat().mode).endswith("00"), "Path should not be secured"
-                'Path should not be secured')
         else:
-            assert oct(private.stat().mode).endswith('00'), (
+            assert oct(private.stat().mode).endswith("00"), "Path has not been secured"
-                'Path has not been secured')
 
     # these paths should never be secured
     for private in insecurepaths:
-        assert not oct(private.stat().mode).endswith('00'), (
+        assert not oct(private.stat().mode).endswith("00"), "Path should not be secured"
-            'Path should not be secured')
 
 
-@pytest.mark.parametrize('sshperms', [None, 'true', 'false'])
+@pytest.mark.parametrize("sshperms", [None, "true", "false"])
-@pytest.mark.parametrize('gpgperms', [None, 'true', 'false'])
+@pytest.mark.parametrize("gpgperms", [None, "true", "false"])
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
 def test_perms_control(runner, yadm_cmd, paths, ds1, sshperms, gpgperms):
     """Test fine control of perms"""
     # set the value of ssh-perms
     if sshperms:
-        os.system(' '.join(yadm_cmd('config', 'yadm.ssh-perms', sshperms)))
+        os.system(" ".join(yadm_cmd("config", "yadm.ssh-perms", sshperms)))
 
     # set the value of gpg-perms
     if gpgperms:
-        os.system(' '.join(yadm_cmd('config', 'yadm.gpg-perms', gpgperms)))
+        os.system(" ".join(yadm_cmd("config", "yadm.gpg-perms", gpgperms)))
 
     # privatepaths will hold all paths that should become secured
-    privatepaths = [paths.work.join('.ssh'), paths.work.join('.gnupg')]
+    privatepaths = [paths.work.join(".ssh"), paths.work.join(".gnupg")]
     privatepaths += [paths.work.join(private.path) for private in ds1.private]
 
     # assert these paths begin unsecured
     for private in privatepaths:
-        assert not oct(private.stat().mode).endswith('00'), (
+        assert not oct(private.stat().mode).endswith("00"), "Path started secured"
-            'Path started secured')
 
-    run = runner(yadm_cmd('perms'), env={'HOME': paths.work})
+    run = runner(yadm_cmd("perms"), env={"HOME": paths.work})
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""
 
     # these paths should be secured if processing perms
     for private in privatepaths:
-        if (
+        if (sshperms == "false" and "ssh" in str(private)) or (gpgperms == "false" and "gnupg" in str(private)):
-                (sshperms == 'false' and 'ssh' in str(private))
+            assert not oct(private.stat().mode).endswith("00"), "Path should not be secured"
-                or
-                (gpgperms == 'false' and 'gnupg' in str(private))
-        ):
-            assert not oct(private.stat().mode).endswith('00'), (
-                'Path should not be secured')
         else:
-            assert oct(private.stat().mode).endswith('00'), (
+            assert oct(private.stat().mode).endswith("00"), "Path has not been secured"
-                'Path has not been secured')
 
     # verify permissions aren't changed for the worktree
-    assert oct(paths.work.stat().mode).endswith('0755')
+    assert oct(paths.work.stat().mode).endswith("0755")

test/test_syntax.py

@@ -1,65 +1,83 @@
 """Syntax checks"""
 
 import os
+
 import pytest
 
 
 def test_yadm_syntax(runner, yadm):
     """Is syntactically valid"""
-    run = runner(command=['bash', '-n', yadm])
+    run = runner(command=["bash", "-n", yadm])
     assert run.success
 
 
 def test_shellcheck(pytestconfig, runner, yadm, shellcheck_version):
     """Passes shellcheck"""
     if not pytestconfig.getoption("--force-linters"):
-        run = runner(command=['shellcheck', '-V'], report=False)
+        run = runner(command=["shellcheck", "-V"], report=False)
-        if f'version: {shellcheck_version}' not in run.out:
+        if f"version: {shellcheck_version}" not in run.out:
-            pytest.skip('Unsupported shellcheck version')
+            pytest.skip("Unsupported shellcheck version")
-    run = runner(command=['shellcheck', '-s', 'bash', yadm])
+    run = runner(command=["shellcheck", "-s", "bash", yadm])
     assert run.success
 
 
 def test_pylint(pytestconfig, runner, pylint_version):
     """Passes pylint"""
     if not pytestconfig.getoption("--force-linters"):
-        run = runner(command=['pylint', '--version'], report=False)
+        run = runner(command=["pylint", "--version"], report=False)
-        if f'pylint {pylint_version}' not in run.out:
+        if f"pylint {pylint_version}" not in run.out:
-            pytest.skip('Unsupported pylint version')
+            pytest.skip("Unsupported pylint version")
-    pyfiles = list()
+    pyfiles = []
-    for tfile in os.listdir('test'):
+    for tfile in os.listdir("test"):
-        if tfile.endswith('.py'):
+        if tfile.endswith(".py"):
-            pyfiles.append(f'test/{tfile}')
+            pyfiles.append(f"test/{tfile}")
-    run = runner(command=['pylint'] + pyfiles)
+    run = runner(command=["pylint"] + pyfiles)
+    assert run.success
+
+
+def test_isort(pytestconfig, runner, isort_version):
+    """Passes isort"""
+    if not pytestconfig.getoption("--force-linters"):
+        run = runner(command=["isort", "--version"], report=False)
+        if isort_version not in run.out:
+            pytest.skip("Unsupported isort version")
+    run = runner(command=["isort", "-c", "test"])
     assert run.success
 
 
 def test_flake8(pytestconfig, runner, flake8_version):
     """Passes flake8"""
     if not pytestconfig.getoption("--force-linters"):
-        run = runner(command=['flake8', '--version'], report=False)
+        run = runner(command=["flake8", "--version"], report=False)
         if not run.out.startswith(flake8_version):
-            pytest.skip('Unsupported flake8 version')
+            pytest.skip("Unsupported flake8 version")
-    run = runner(command=['flake8', 'test'])
+    run = runner(command=["flake8", "test"])
+    assert run.success
+
+
+def test_black(pytestconfig, runner, black_version):
+    """Passes black"""
+    if not pytestconfig.getoption("--force-linters"):
+        run = runner(command=["black", "--version"], report=False)
+        if black_version not in run.out:
+            pytest.skip("Unsupported black version")
+    run = runner(command=["black", "--check", "test"])
     assert run.success
 
 
 def test_yamllint(pytestconfig, runner, yamllint_version):
     """Passes yamllint"""
     if not pytestconfig.getoption("--force-linters"):
-        run = runner(command=['yamllint', '--version'], report=False)
+        run = runner(command=["yamllint", "--version"], report=False)
         if not run.out.strip().endswith(yamllint_version):
-            pytest.skip('Unsupported yamllint version')
+            pytest.skip("Unsupported yamllint version")
-    run = runner(
+    run = runner(command=["yamllint", "-s", "$(find . -name \\*.yml)"], shell=True)
-        command=['yamllint', '-s', '$(find . -name \\*.yml)'],
-        shell=True)
     assert run.success
 
 
 def test_man(runner):
     """Check for warnings from man"""
-    run = runner(
+    run = runner(command=["man.REAL", "--warnings", "./yadm.1"])
-        command=['man', '--warnings', './yadm.1'])
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'yadm - Yet Another Dotfiles Manager' in run.out
+    assert "yadm - Yet Another Dotfiles Manager" in run.out

test/test_unit_bootstrap_available.py

@@ -8,14 +8,14 @@ def test_bootstrap_missing(runner, paths):
 
 def test_bootstrap_no_exec(runner, paths):
     """Test result of bootstrap_available, when bootstrap not executable"""
-    paths.bootstrap.write('')
+    paths.bootstrap.write("")
     paths.bootstrap.chmod(0o644)
     run_test(runner, paths, False)
 
 
 def test_bootstrap_exec(runner, paths):
     """Test result of bootstrap_available, when bootstrap executable"""
-    paths.bootstrap.write('')
+    paths.bootstrap.write("")
     paths.bootstrap.chmod(0o775)
     run_test(runner, paths, True)
 
@@ -27,7 +27,7 @@ def run_test(runner, paths, success):
         YADM_BOOTSTRAP='{paths.bootstrap}'
         bootstrap_available
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success == success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""

test/test_unit_choose_template_cmd.py

@@ -2,20 +2,20 @@
 import pytest
 
 
-@pytest.mark.parametrize('label', ['', 'default', 'other'])
+@pytest.mark.parametrize("label", ["", "default", "other"])
-@pytest.mark.parametrize('awk', [True, False], ids=['awk', 'no-awk'])
+@pytest.mark.parametrize("awk", [True, False], ids=["awk", "no-awk"])
 def test_kind_default(runner, yadm, awk, label):
     """Test kind: default"""
 
-    expected = 'template_default'
+    expected = "template_default"
-    awk_avail = 'true'
+    awk_avail = "true"
 
     if not awk:
-        awk_avail = 'false'
+        awk_avail = "false"
-        expected = ''
+        expected = ""
 
-    if label == 'other':
+    if label == "other":
-        expected = ''
+        expected = ""
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -23,30 +23,30 @@ def test_kind_default(runner, yadm, awk, label):
         template="$(choose_template_cmd "{label}")"
         echo "TEMPLATE:$template"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert f'TEMPLATE:{expected}\n' in run.out
+    assert f"TEMPLATE:{expected}\n" in run.out
 
 
-@pytest.mark.parametrize('label', ['envtpl', 'j2cli', 'j2', 'other'])
+@pytest.mark.parametrize("label", ["envtpl", "j2cli", "j2", "other"])
-@pytest.mark.parametrize('envtpl', [True, False], ids=['envtpl', 'no-envtpl'])
+@pytest.mark.parametrize("envtpl", [True, False], ids=["envtpl", "no-envtpl"])
-@pytest.mark.parametrize('j2cli', [True, False], ids=['j2cli', 'no-j2cli'])
+@pytest.mark.parametrize("j2cli", [True, False], ids=["j2cli", "no-j2cli"])
 def test_kind_j2cli_envtpl(runner, yadm, envtpl, j2cli, label):
     """Test kind: j2 (both j2cli & envtpl)
 
     j2cli is preferred over envtpl if available.
     """
 
-    envtpl_avail = 'true' if envtpl else 'false'
+    envtpl_avail = "true" if envtpl else "false"
-    j2cli_avail = 'true' if j2cli else 'false'
+    j2cli_avail = "true" if j2cli else "false"
 
-    if label in ('j2cli', 'j2') and j2cli:
+    if label in ("j2cli", "j2") and j2cli:
-        expected = 'template_j2cli'
+        expected = "template_j2cli"
-    elif label in ('envtpl', 'j2') and envtpl:
+    elif label in ("envtpl", "j2") and envtpl:
-        expected = 'template_envtpl'
+        expected = "template_envtpl"
     else:
-        expected = ''
+        expected = ""
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -55,7 +55,7 @@ def test_kind_j2cli_envtpl(runner, yadm, envtpl, j2cli, label):
         template="$(choose_template_cmd "{label}")"
         echo "TEMPLATE:$template"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert f'TEMPLATE:{expected}\n' in run.out
+    assert f"TEMPLATE:{expected}\n" in run.out

test/test_unit_configure_paths.py

@@ -2,52 +2,56 @@
 
 import pytest
 
-ARCHIVE = 'archive'
+ARCHIVE = "archive"
-BOOTSTRAP = 'bootstrap'
+BOOTSTRAP = "bootstrap"
-CONFIG = 'config'
+CONFIG = "config"
-ENCRYPT = 'encrypt'
+ENCRYPT = "encrypt"
-HOME = '/testhome'
+HOME = "/testhome"
-REPO = 'repo.git'
+REPO = "repo.git"
-YDIR = '.config/yadm'
+YDIR = ".config/yadm"
-YDATA = '.local/share/yadm'
+YDATA = ".local/share/yadm"
 
 
 @pytest.mark.parametrize(
-    'override, expect', [
+    "override, expect",
+    [
         (None, {}),
-        ('-Y', {'yadm': 'YADM_DIR'}),
+        ("-Y", {"yadm": "YADM_DIR"}),
-        ('--yadm-data', {'data': 'YADM_DATA'}),
+        ("--yadm-data", {"data": "YADM_DATA"}),
-        ('--yadm-repo', {'repo': 'YADM_REPO', 'git': 'GIT_DIR'}),
+        ("--yadm-repo", {"repo": "YADM_REPO", "git": "GIT_DIR"}),
-        ('--yadm-config', {'config': 'YADM_CONFIG'}),
+        ("--yadm-config", {"config": "YADM_CONFIG"}),
-        ('--yadm-encrypt', {'encrypt': 'YADM_ENCRYPT'}),
+        ("--yadm-encrypt", {"encrypt": "YADM_ENCRYPT"}),
-        ('--yadm-archive', {'archive': 'YADM_ARCHIVE'}),
+        ("--yadm-archive", {"archive": "YADM_ARCHIVE"}),
-        ('--yadm-bootstrap', {'bootstrap': 'YADM_BOOTSTRAP'}),
+        ("--yadm-bootstrap", {"bootstrap": "YADM_BOOTSTRAP"}),
-    ], ids=[
+    ],
-        'default',
+    ids=[
-        'override yadm dir',
+        "default",
-        'override yadm data',
+        "override yadm dir",
-        'override repo',
+        "override yadm data",
-        'override config',
+        "override repo",
-        'override encrypt',
+        "override config",
-        'override archive',
+        "override encrypt",
-        'override bootstrap',
+        "override archive",
-    ])
+        "override bootstrap",
+    ],
+)
 @pytest.mark.parametrize(
-    'path', ['.', './override', 'override', '.override', '/override'], ids=[
+    "path",
-        'cwd', './relative', 'relative', 'hidden relative', 'absolute'
+    [".", "./override", "override", ".override", "/override"],
-    ])
+    ids=["cwd", "./relative", "relative", "hidden relative", "absolute"],
+)
 def test_config(runner, paths, override, expect, path):
     """Test configure_paths"""
-    if path.startswith('/'):
+    if path.startswith("/"):
         expected_path = path
     else:
         expected_path = str(paths.root.join(path))
 
     args = [override, path] if override else []
 
-    if override == '-Y':
+    if override == "-Y":
         matches = match_map(expected_path)
-    elif override == '--yadm-data':
+    elif override == "--yadm-data":
         matches = match_map(None, expected_path)
     else:
         matches = match_map()
@@ -61,23 +65,23 @@ def test_config(runner, paths, override, expect, path):
 def match_map(yadm_dir=None, yadm_data=None):
     """Create a dictionary of matches, relative to yadm_dir"""
     if not yadm_dir:
-        yadm_dir = '/'.join([HOME, YDIR])
+        yadm_dir = "/".join([HOME, YDIR])
     if not yadm_data:
-        yadm_data = '/'.join([HOME, YDATA])
+        yadm_data = "/".join([HOME, YDATA])
     return {
-        'yadm': f'YADM_DIR="{yadm_dir}"',
+        "yadm": f'YADM_DIR="{yadm_dir}"',
-        'repo': f'YADM_REPO="{yadm_data}/{REPO}"',
+        "repo": f'YADM_REPO="{yadm_data}/{REPO}"',
-        'config': f'YADM_CONFIG="{yadm_dir}/{CONFIG}"',
+        "config": f'YADM_CONFIG="{yadm_dir}/{CONFIG}"',
-        'encrypt': f'YADM_ENCRYPT="{yadm_dir}/{ENCRYPT}"',
+        "encrypt": f'YADM_ENCRYPT="{yadm_dir}/{ENCRYPT}"',
-        'archive': f'YADM_ARCHIVE="{yadm_data}/{ARCHIVE}"',
+        "archive": f'YADM_ARCHIVE="{yadm_data}/{ARCHIVE}"',
-        'bootstrap': f'YADM_BOOTSTRAP="{yadm_dir}/{BOOTSTRAP}"',
+        "bootstrap": f'YADM_BOOTSTRAP="{yadm_dir}/{BOOTSTRAP}"',
-        'git': f'GIT_DIR="{yadm_data}/{REPO}"',
+        "git": f'GIT_DIR="{yadm_data}/{REPO}"',
-        }
+    }
 
 
 def run_test(runner, paths, args, expected_matches, cwd=None):
     """Run proces global args, and run configure_paths"""
-    argstring = ' '.join(['"'+a+'"' for a in args])
+    argstring = " ".join(['"' + a + '"' for a in args])
     script = f"""
         YADM_TEST=1 HOME="{HOME}" source {paths.pgm}
         process_global_args {argstring}
@@ -87,8 +91,8 @@ def run_test(runner, paths, args, expected_matches, cwd=None):
         configure_paths
         declare -p | grep -E '(YADM|GIT)_'
     """
-    run = runner(command=['bash'], inp=script, cwd=cwd)
+    run = runner(command=["bash"], inp=script, cwd=cwd)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     for match in expected_matches:
         assert match in run.out

test/test_unit_copy_perms.py

@@ -1,43 +1,42 @@
 """Unit tests: copy_perms"""
 import os
+
 import pytest
 
-OCTAL = '7654'
+OCTAL = "7654"
-NON_OCTAL = '9876'
+NON_OCTAL = "9876"
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("stat_broken", [True, False], ids=["normal", "stat broken"])
-    'stat_broken', [True, False], ids=['normal', 'stat broken'])
 def test_copy_perms(runner, yadm, tmpdir, stat_broken):
     """Test function copy_perms"""
     src_mode = 0o754
     dst_mode = 0o644
-    source = tmpdir.join('source')
+    source = tmpdir.join("source")
-    source.write('test', ensure=True)
+    source.write("test", ensure=True)
     source.chmod(src_mode)
 
-    dest = tmpdir.join('dest')
+    dest = tmpdir.join("dest")
-    dest.write('test', ensure=True)
+    dest.write("test", ensure=True)
     dest.chmod(dst_mode)
 
-    override_stat = ''
+    override_stat = ""
     if stat_broken:
-        override_stat = 'function stat() { echo broken; }'
+        override_stat = "function stat() { echo broken; }"
     script = f"""
         YADM_TEST=1 source {yadm}
         {override_stat}
         copy_perms "{source}" "{dest}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert run.out == ''
+    assert run.out == ""
     expected = dst_mode if stat_broken else src_mode
     assert oct(os.stat(dest).st_mode)[-3:] == oct(expected)[-3:]
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("stat_output", [OCTAL, NON_OCTAL], ids=["octal", "non-octal"])
-    'stat_output', [OCTAL, NON_OCTAL], ids=['octal', 'non-octal'])
 def test_get_mode(runner, yadm, stat_output):
     """Test function get_mode"""
     script = f"""
@@ -46,8 +45,8 @@ def test_get_mode(runner, yadm, stat_output):
         mode=$(get_mode abc)
         echo "MODE:$mode"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     expected = OCTAL if stat_output == OCTAL else ""
-    assert f'MODE:{expected}\n' in run.out
+    assert f"MODE:{expected}\n" in run.out

test/test_unit_encryption.py

@@ -3,12 +3,12 @@
 import pytest
 
 
-@pytest.mark.parametrize('condition', ['default', 'override'])
+@pytest.mark.parametrize("condition", ["default", "override"])
 def test_get_cipher(runner, paths, condition):
     """Test _get_cipher()"""
 
-    if condition == 'override':
+    if condition == "override":
-        paths.config.write('[yadm]\n\tcipher = override-cipher')
+        paths.config.write("[yadm]\n\tcipher = override-cipher")
 
     script = f"""
         YADM_TEST=1 source {paths.pgm}
@@ -19,18 +19,18 @@ def test_get_cipher(runner, paths, condition):
         echo "output_archive:$output_archive"
         echo "yadm_cipher:$yadm_cipher"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'output_archive:test-archive' in run.out
+    assert "output_archive:test-archive" in run.out
-    if condition == 'override':
+    if condition == "override":
-        assert 'yadm_cipher:override-cipher' in run.out
+        assert "yadm_cipher:override-cipher" in run.out
     else:
-        assert 'yadm_cipher:gpg' in run.out
+        assert "yadm_cipher:gpg" in run.out
 
 
-@pytest.mark.parametrize('cipher', ['gpg', 'openssl', 'bad'])
+@pytest.mark.parametrize("cipher", ["gpg", "openssl", "bad"])
-@pytest.mark.parametrize('mode', ['_encrypt_to', '_decrypt_from'])
+@pytest.mark.parametrize("mode", ["_encrypt_to", "_decrypt_from"])
 def test_encrypt_decrypt(runner, paths, cipher, mode):
     """Test _encrypt_to() & _decrypt_from"""
 
@@ -49,24 +49,24 @@ def test_encrypt_decrypt(runner, paths, cipher, mode):
         GPG_PROGRAM=mock_gpg
         {mode} {paths.archive}
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
 
-    if cipher != 'bad':
+    if cipher != "bad":
         assert run.success
         assert run.out.startswith(cipher)
         assert str(paths.archive) in run.out
-        assert run.err == ''
+        assert run.err == ""
     else:
         assert run.failure
-        assert 'Unknown cipher' in run.err
+        assert "Unknown cipher" in run.err
 
 
-@pytest.mark.parametrize('condition', ['default', 'override'])
+@pytest.mark.parametrize("condition", ["default", "override"])
 def test_get_openssl_ciphername(runner, paths, condition):
     """Test _get_openssl_ciphername()"""
 
-    if condition == 'override':
+    if condition == "override":
-        paths.config.write('[yadm]\n\topenssl-ciphername = override-cipher')
+        paths.config.write("[yadm]\n\topenssl-ciphername = override-cipher")
 
     script = f"""
         YADM_TEST=1 source {paths.pgm}
@@ -76,21 +76,21 @@ def test_get_openssl_ciphername(runner, paths, condition):
         result=$(_get_openssl_ciphername)
         echo "result:$result"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if condition == 'override':
+    if condition == "override":
-        assert run.out.strip() == 'result:override-cipher'
+        assert run.out.strip() == "result:override-cipher"
     else:
-        assert run.out.strip() == 'result:aes-256-cbc'
+        assert run.out.strip() == "result:aes-256-cbc"
 
 
-@pytest.mark.parametrize('condition', ['old', 'not-old'])
+@pytest.mark.parametrize("condition", ["old", "not-old"])
 def test_set_openssl_options(runner, paths, condition):
     """Test _set_openssl_options()"""
 
-    if condition == 'old':
+    if condition == "old":
-        paths.config.write('[yadm]\n\topenssl-old = true')
+        paths.config.write("[yadm]\n\topenssl-old = true")
 
     script = f"""
         YADM_TEST=1 source {paths.pgm}
@@ -101,20 +101,20 @@ def test_set_openssl_options(runner, paths, condition):
         _set_openssl_options
         echo "result:${{OPENSSL_OPTS[@]}}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if condition == 'old':
+    if condition == "old":
-        assert '-testcipher -salt -md md5' in run.out
+        assert "-testcipher -salt -md md5" in run.out
     else:
-        assert '-testcipher -salt -pbkdf2 -iter 100000 -md sha512' in run.out
+        assert "-testcipher -salt -pbkdf2 -iter 100000 -md sha512" in run.out
 
 
-@pytest.mark.parametrize('recipient', ['ASK', 'present', ''])
+@pytest.mark.parametrize("recipient", ["ASK", "present", ""])
 def test_set_gpg_options(runner, paths, recipient):
     """Test _set_gpg_options()"""
 
-    paths.config.write(f'[yadm]\n\tgpg-recipient = {recipient}')
+    paths.config.write(f"[yadm]\n\tgpg-recipient = {recipient}")
 
     script = f"""
         YADM_TEST=1 source {paths.pgm}
@@ -124,12 +124,12 @@ def test_set_gpg_options(runner, paths, recipient):
         _set_gpg_options
         echo "result:${{GPG_OPTS[@]}}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if recipient == 'ASK':
+    if recipient == "ASK":
-        assert run.out.strip() == 'result:--no-default-recipient -e'
+        assert run.out.strip() == "result:--no-default-recipient -e"
-    elif recipient != '':
+    elif recipient != "":
-        assert run.out.strip() == f'result:-e -r {recipient}'
+        assert run.out.strip() == f"result:-e -r {recipient}"
     else:
-        assert run.out.strip() == 'result:-c'
+        assert run.out.strip() == "result:-c"

test/test_unit_exclude_encrypted.py

@@ -2,38 +2,28 @@
 import pytest
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("exclude", ["missing", "outdated", "up-to-date"])
-    'exclude', ['missing', 'outdated', 'up-to-date'])
+@pytest.mark.parametrize("encrypt_exists", [True, False], ids=["encrypt", "no-encrypt"])
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("auto_exclude", [True, False], ids=["enabled", "disabled"])
-    'encrypt_exists', [True, False], ids=['encrypt', 'no-encrypt'])
+def test_exclude_encrypted(runner, tmpdir, yadm, encrypt_exists, auto_exclude, exclude):
-@pytest.mark.parametrize(
-    'auto_exclude', [True, False], ids=['enabled', 'disabled'])
-def test_exclude_encrypted(
-        runner, tmpdir, yadm, encrypt_exists, auto_exclude, exclude):
     """Test exclude_encrypted()"""
 
-    header = (
+    header = "# yadm-auto-excludes\n# This section is managed by yadm.\n# Any edits below will be lost.\n"
-        "# yadm-auto-excludes\n"
-        "# This section is managed by yadm.\n"
-        "# Any edits below will be lost.\n"
-    )
 
     config_function = 'function config() { echo "false";}'
     if auto_exclude:
-        config_function = 'function config() { return; }'
+        config_function = "function config() { return; }"
 
-    encrypt_file = tmpdir.join('encrypt_file')
+    encrypt_file = tmpdir.join("encrypt_file")
-    repo_dir = tmpdir.join('repodir')
+    repo_dir = tmpdir.join("repodir")
-    exclude_file = repo_dir.join('info/exclude')
+    exclude_file = repo_dir.join("info/exclude")
 
     if encrypt_exists:
-        encrypt_file.write('test-encrypt-data\n', ensure=True)
+        encrypt_file.write("test-encrypt-data\n", ensure=True)
-    if exclude == 'outdated':
+    if exclude == "outdated":
-        exclude_file.write(
+        exclude_file.write(f"original-exclude\n{header}outdated\n", ensure=True)
-            f'original-exclude\n{header}outdated\n', ensure=True)
+    elif exclude == "up-to-date":
-    elif exclude == 'up-to-date':
+        exclude_file.write(f"original-exclude\n{header}test-encrypt-data\n", ensure=True)
-        exclude_file.write(
-            f'original-exclude\n{header}test-encrypt-data\n', ensure=True)
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -43,24 +33,22 @@ def test_exclude_encrypted(
         YADM_REPO="{repo_dir}"
         exclude_encrypted
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
 
     if auto_exclude:
         if encrypt_exists:
             assert exclude_file.exists()
-            if exclude == 'missing':
+            if exclude == "missing":
-                assert exclude_file.read() == f'{header}test-encrypt-data\n'
+                assert exclude_file.read() == f"{header}test-encrypt-data\n"
             else:
-                assert exclude_file.read() == (
+                assert exclude_file.read() == ("original-exclude\n" f"{header}test-encrypt-data\n")
-                    'original-exclude\n'
+            if exclude != "up-to-date":
-                    f'{header}test-encrypt-data\n')
+                assert f"Updating {exclude_file}" in run.out
-            if exclude != 'up-to-date':
-                assert f'Updating {exclude_file}' in run.out
             else:
-                assert run.out == ''
+                assert run.out == ""
         else:
-            assert run.out == ''
+            assert run.out == ""
     else:
-        assert run.out == ''
+        assert run.out == ""

test/test_unit_issue_legacy_path_warning.py

@@ -3,25 +3,24 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'legacy_path', [
+    "legacy_path",
+    [
         None,
-        'repo.git',
+        "repo.git",
-        'files.gpg',
+        "files.gpg",
-        ],
+    ],
-    )
+)
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("override", [True, False], ids=["override", "no-override"])
-    'override', [True, False], ids=['override', 'no-override'])
+@pytest.mark.parametrize("upgrade", [True, False], ids=["upgrade", "no-upgrade"])
-@pytest.mark.parametrize(
-    'upgrade', [True, False], ids=['upgrade', 'no-upgrade'])
 def test_legacy_warning(tmpdir, runner, yadm, upgrade, override, legacy_path):
     """Use issue_legacy_path_warning"""
-    home = tmpdir.mkdir('home')
+    home = tmpdir.mkdir("home")
 
     if legacy_path:
-        home.ensure(f'.config/yadm/{str(legacy_path)}')
+        home.ensure(f".config/yadm/{str(legacy_path)}")
 
-    override = 'YADM_OVERRIDE_REPO=override' if override else ''
+    override = "YADM_OVERRIDE_REPO=override" if override else ""
-    main_args = 'MAIN_ARGS=("upgrade")' if upgrade else ''
+    main_args = 'MAIN_ARGS=("upgrade")' if upgrade else ""
     script = f"""
         XDG_CONFIG_HOME=
         XDG_DATA_HOME=
@@ -32,10 +31,10 @@ def test_legacy_warning(tmpdir, runner, yadm, upgrade, override, legacy_path):
         set_yadm_dirs
         issue_legacy_path_warning
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.out == ''
+    assert run.out == ""
     if legacy_path and (not upgrade) and (not override):
-        assert 'Legacy paths have been detected' in run.err
+        assert "Legacy paths have been detected" in run.err
     else:
-        assert 'Legacy paths have been detected' not in run.err
+        assert "Legacy paths have been detected" not in run.err

test/test_unit_parse_encrypt.py

@@ -7,136 +7,137 @@ def test_not_called(runner, paths):
     """Test parse_encrypt (not called)"""
     run = run_parse_encrypt(runner, paths, skip_parse=True)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'EIF:unparsed' in run.out, 'EIF should be unparsed'
+    assert "EIF:unparsed" in run.out, "EIF should be unparsed"
-    assert 'EIF_COUNT:1' in run.out, 'Only value of EIF should be unparsed'
+    assert "EIF_COUNT:1" in run.out, "Only value of EIF should be unparsed"
 
 
 def test_short_circuit(runner, paths):
     """Test parse_encrypt (short-circuit)"""
     run = run_parse_encrypt(runner, paths, twice=True)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'PARSE_ENCRYPT_SHORT=parse_encrypt() not reprocessed' in run.out, (
+    assert "PARSE_ENCRYPT_SHORT=parse_encrypt() not reprocessed" in run.out, "parse_encrypt() should short-circuit"
-        'parse_encrypt() should short-circuit')
 
 
 @pytest.mark.parametrize(
-    'encrypt', [
+    "encrypt",
-        ('missing'),
+    [
-        ('empty'),
+        ("missing"),
-    ])
+        ("empty"),
+    ],
+)
 def test_empty(runner, paths, encrypt):
     """Test parse_encrypt (file missing/empty)"""
 
     # write encrypt file
-    if encrypt == 'missing':
+    if encrypt == "missing":
-        assert not paths.encrypt.exists(), 'Encrypt should be missing'
+        assert not paths.encrypt.exists(), "Encrypt should be missing"
     else:
-        paths.encrypt.write('')
+        paths.encrypt.write("")
-        assert paths.encrypt.exists(), 'Encrypt should exist'
+        assert paths.encrypt.exists(), "Encrypt should exist"
-        assert paths.encrypt.size() == 0, 'Encrypt should be empty'
+        assert paths.encrypt.size() == 0, "Encrypt should be empty"
 
     # run parse_encrypt
     run = run_parse_encrypt(runner, paths)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
 
     # validate parsing result
-    assert 'EIF_COUNT:0' in run.out, 'EIF should be empty'
+    assert "EIF_COUNT:0" in run.out, "EIF should be empty"
 
 
 def create_test_encrypt_data(paths):
     """Generate test data for testing encrypt"""
 
-    edata = ''
+    edata = ""
     expected = set()
 
     # empty line
-    edata += '\n'
+    edata += "\n"
 
     # simple comments
-    edata += '# a simple comment\n'
+    edata += "# a simple comment\n"
-    edata += '    # a comment with leading space\n'
+    edata += "    # a comment with leading space\n"
 
     # unreferenced directory
-    paths.work.join('unreferenced').mkdir()
+    paths.work.join("unreferenced").mkdir()
 
     # simple files
-    edata += 'simple_file\n'
+    edata += "simple_file\n"
-    edata += 'simple.file\n'
+    edata += "simple.file\n"
-    paths.work.join('simple_file').write('')
+    paths.work.join("simple_file").write("")
-    paths.work.join('simple.file').write('')
+    paths.work.join("simple.file").write("")
-    paths.work.join('simple_file2').write('')
+    paths.work.join("simple_file2").write("")
-    paths.work.join('simple.file2').write('')
+    paths.work.join("simple.file2").write("")
-    expected.add('simple_file')
+    expected.add("simple_file")
-    expected.add('simple.file')
+    expected.add("simple.file")
 
     # simple files in directories
-    edata += 'simple_dir/simple_file\n'
+    edata += "simple_dir/simple_file\n"
-    paths.work.join('simple_dir/simple_file').write('', ensure=True)
+    paths.work.join("simple_dir/simple_file").write("", ensure=True)
-    paths.work.join('simple_dir/simple_file2').write('', ensure=True)
+    paths.work.join("simple_dir/simple_file2").write("", ensure=True)
-    expected.add('simple_dir/simple_file')
+    expected.add("simple_dir/simple_file")
 
     # paths with spaces
-    edata += 'with space/with space\n'
+    edata += "with space/with space\n"
-    paths.work.join('with space/with space').write('', ensure=True)
+    paths.work.join("with space/with space").write("", ensure=True)
-    paths.work.join('with space/with space2').write('', ensure=True)
+    paths.work.join("with space/with space2").write("", ensure=True)
-    expected.add('with space/with space')
+    expected.add("with space/with space")
 
     # hidden files
-    edata += '.hidden\n'
+    edata += ".hidden\n"
-    paths.work.join('.hidden').write('')
+    paths.work.join(".hidden").write("")
-    expected.add('.hidden')
+    expected.add(".hidden")
 
     # hidden files in directories
-    edata += '.hidden_dir/.hidden_file\n'
+    edata += ".hidden_dir/.hidden_file\n"
-    paths.work.join('.hidden_dir/.hidden_file').write('', ensure=True)
+    paths.work.join(".hidden_dir/.hidden_file").write("", ensure=True)
-    expected.add('.hidden_dir/.hidden_file')
+    expected.add(".hidden_dir/.hidden_file")
 
     # wildcards
-    edata += 'wild*\n'
+    edata += "wild*\n"
-    paths.work.join('wildcard1').write('', ensure=True)
+    paths.work.join("wildcard1").write("", ensure=True)
-    paths.work.join('wildcard2').write('', ensure=True)
+    paths.work.join("wildcard2").write("", ensure=True)
-    expected.add('wildcard1')
+    expected.add("wildcard1")
-    expected.add('wildcard2')
+    expected.add("wildcard2")
 
-    edata += 'dirwild*\n'
+    edata += "dirwild*\n"
-    paths.work.join('dirwildcard/file1').write('', ensure=True)
+    paths.work.join("dirwildcard/file1").write("", ensure=True)
-    paths.work.join('dirwildcard/file2').write('', ensure=True)
+    paths.work.join("dirwildcard/file2").write("", ensure=True)
-    expected.add('dirwildcard')
+    expected.add("dirwildcard")
 
     # excludes
-    edata += 'exclude*\n'
+    edata += "exclude*\n"
-    edata += 'ex ex/*\n'
+    edata += "ex ex/*\n"
-    paths.work.join('exclude_file1').write('')
+    paths.work.join("exclude_file1").write("")
-    paths.work.join('exclude_file2.ex').write('')
+    paths.work.join("exclude_file2.ex").write("")
-    paths.work.join('exclude_file3.ex3').write('')
+    paths.work.join("exclude_file3.ex3").write("")
-    expected.add('exclude_file1')
+    expected.add("exclude_file1")
-    expected.add('exclude_file3.ex3')
+    expected.add("exclude_file3.ex3")
-    edata += '!*.ex\n'
+    edata += "!*.ex\n"
-    edata += '!ex ex/*.txt\n'
+    edata += "!ex ex/*.txt\n"
-    paths.work.join('ex ex/file4').write('', ensure=True)
+    paths.work.join("ex ex/file4").write("", ensure=True)
-    paths.work.join('ex ex/file5.txt').write('', ensure=True)
+    paths.work.join("ex ex/file5.txt").write("", ensure=True)
-    paths.work.join('ex ex/file6.text').write('', ensure=True)
+    paths.work.join("ex ex/file6.text").write("", ensure=True)
-    expected.add('ex ex/file4')
+    expected.add("ex ex/file4")
-    expected.add('ex ex/file6.text')
+    expected.add("ex ex/file6.text")
 
     # double star
-    edata += 'doublestar/**/file*\n'
+    edata += "doublestar/**/file*\n"
-    edata += '!**/file3\n'
+    edata += "!**/file3\n"
-    paths.work.join('doublestar/a/b/file1').write('', ensure=True)
+    paths.work.join("doublestar/a/b/file1").write("", ensure=True)
-    paths.work.join('doublestar/c/d/file2').write('', ensure=True)
+    paths.work.join("doublestar/c/d/file2").write("", ensure=True)
-    paths.work.join('doublestar/e/f/file3').write('', ensure=True)
+    paths.work.join("doublestar/e/f/file3").write("", ensure=True)
-    paths.work.join('doublestar/g/h/nomatch').write('', ensure=True)
+    paths.work.join("doublestar/g/h/nomatch").write("", ensure=True)
-    expected.add('doublestar/a/b/file1')
+    expected.add("doublestar/a/b/file1")
-    expected.add('doublestar/c/d/file2')
+    expected.add("doublestar/c/d/file2")
     # doublestar/e/f/file3 is excluded
 
     return edata, expected
 
 
-@pytest.mark.usefixtures('ds1_repo_copy')
+@pytest.mark.usefixtures("ds1_repo_copy")
 def test_file_parse_encrypt(runner, paths):
     """Test parse_encrypt
 
@@ -147,39 +148,35 @@ def test_file_parse_encrypt(runner, paths):
     edata, expected = create_test_encrypt_data(paths)
 
     # write encrypt file
-    print(f'ENCRYPT:\n---\n{edata}---\n')
+    print(f"ENCRYPT:\n---\n{edata}---\n")
     paths.encrypt.write(edata)
     assert paths.encrypt.isfile()
 
     # run parse_encrypt
     run = run_parse_encrypt(runner, paths)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
 
-    assert f'EIF_COUNT:{len(expected)}' in run.out, 'EIF count wrong'
+    assert f"EIF_COUNT:{len(expected)}" in run.out, "EIF count wrong"
     for expected_file in expected:
-        assert f'EIF:{expected_file}\n' in run.out
+        assert f"EIF:{expected_file}\n" in run.out
 
-    sorted_expectations = '\n'.join(
+    sorted_expectations = "\n".join([f"EIF:{exp}" for exp in sorted(expected)])
-        [f'EIF:{exp}' for exp in sorted(expected)])
     assert sorted_expectations in run.out
 
 
-def run_parse_encrypt(
+def run_parse_encrypt(runner, paths, skip_parse=False, twice=False):
-        runner, paths,
-        skip_parse=False,
-        twice=False):
     """Run parse_encrypt
 
     A count of ENCRYPT_INCLUDE_FILES will be reported as EIF_COUNT:X. All
     values of ENCRYPT_INCLUDE_FILES will be reported as individual EIF:value
     lines.
     """
-    parse_cmd = 'parse_encrypt'
+    parse_cmd = "parse_encrypt"
     if skip_parse:
-        parse_cmd = ''
+        parse_cmd = ""
     if twice:
-        parse_cmd = 'parse_encrypt; parse_encrypt'
+        parse_cmd = "parse_encrypt; parse_encrypt"
     script = f"""
         YADM_TEST=1 source {paths.pgm}
         YADM_ENCRYPT={paths.encrypt}
@@ -197,5 +194,5 @@ def run_parse_encrypt(
             echo "EIF:$value"
         done
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     return run

test/test_unit_private_dirs.py

@@ -3,15 +3,15 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'gnupghome',
+    "gnupghome",
     [True, False],
-    ids=['gnupghome-set', 'gnupghome-unset'],
+    ids=["gnupghome-set", "gnupghome-unset"],
 )
-@pytest.mark.parametrize('param', ['all', 'gnupg'])
+@pytest.mark.parametrize("param", ["all", "gnupg"])
 def test_relative_path(runner, paths, gnupghome, param):
     """Test translate_to_relative"""
 
-    alt_gnupghome = 'alt/gnupghome'
+    alt_gnupghome = "alt/gnupghome"
     env_gnupghome = paths.work.join(alt_gnupghome)
 
     script = f"""
@@ -22,13 +22,13 @@ def test_relative_path(runner, paths, gnupghome, param):
 
     env = {}
     if gnupghome:
-        env['GNUPGHOME'] = env_gnupghome
+        env["GNUPGHOME"] = env_gnupghome
 
-    expected = alt_gnupghome if gnupghome else '.gnupg'
+    expected = alt_gnupghome if gnupghome else ".gnupg"
-    if param == 'all':
+    if param == "all":
-        expected = f'.ssh {expected}'
+        expected = f".ssh {expected}"
 
-    run = runner(command=['bash'], inp=script, env=env)
+    run = runner(command=["bash"], inp=script, env=env)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out.strip() == expected

test/test_unit_query_distro.py

@@ -2,18 +2,16 @@
 import pytest
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("condition", ["lsb_release", "os-release", "os-release-quotes", "missing"])
-    'condition', ['lsb_release', 'os-release', 'os-release-quotes', 'missing'])
 def test_query_distro(runner, yadm, tst_distro, tmp_path, condition):
     """Match lsb_release -si when present"""
-    test_release = 'testrelease'
+    test_release = "testrelease"
-    lsb_release = ''
+    lsb_release = ""
-    os_release = tmp_path.joinpath('os-release')
+    os_release = tmp_path.joinpath("os-release")
-    if 'os-release' in condition:
+    if "os-release" in condition:
-        quotes = '"' if 'quotes' in condition else ''
+        quotes = '"' if "quotes" in condition else ""
-        os_release.write_text(
+        os_release.write_text(f"testing\nID={quotes}{test_release}{quotes}\nrelease")
-            f"testing\nID={quotes}{test_release}{quotes}\nrelease")
+    if condition != "lsb_release":
-    if condition != 'lsb_release':
         lsb_release = 'LSB_RELEASE_PROGRAM="missing_lsb_release"'
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -21,12 +19,12 @@ def test_query_distro(runner, yadm, tst_distro, tmp_path, condition):
         OS_RELEASE="{os_release}"
         query_distro
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if condition == 'lsb_release':
+    if condition == "lsb_release":
         assert run.out.rstrip() == tst_distro
-    elif 'os-release' in condition:
+    elif "os-release" in condition:
         assert run.out.rstrip() == test_release
     else:
-        assert run.out.rstrip() == ''
+        assert run.out.rstrip() == ""

test/test_unit_query_distro_family.py

@@ -2,25 +2,23 @@
 import pytest
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("condition", ["os-release", "os-release-quotes", "missing"])
-    'condition', ['os-release', 'os-release-quotes', 'missing'])
 def test_query_distro_family(runner, yadm, tmp_path, condition):
     """Match ID_LIKE when present"""
-    test_family = 'testfamily'
+    test_family = "testfamily"
-    os_release = tmp_path.joinpath('os-release')
+    os_release = tmp_path.joinpath("os-release")
-    if 'os-release' in condition:
+    if "os-release" in condition:
-        quotes = '"' if 'quotes' in condition else ''
+        quotes = '"' if "quotes" in condition else ""
-        os_release.write_text(
+        os_release.write_text(f"testing\nID_LIKE={quotes}{test_family}{quotes}\nfamily")
-            f"testing\nID_LIKE={quotes}{test_family}{quotes}\nfamily")
     script = f"""
         YADM_TEST=1 source {yadm}
         OS_RELEASE="{os_release}"
         query_distro_family
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if 'os-release' in condition:
+    if "os-release" in condition:
         assert run.out.rstrip() == test_family
     else:
-        assert run.out.rstrip() == ''
+        assert run.out.rstrip() == ""

test/test_unit_record_score.py

@@ -30,13 +30,13 @@ def test_dont_record_zeros(runner, yadm):
         record_score "0" "testtgt" "testsrc"
         {REPORT_RESULTS}
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'SIZE:0\n' in run.out
+    assert "SIZE:0\n" in run.out
-    assert 'SCORES:\n' in run.out
+    assert "SCORES:\n" in run.out
-    assert 'TARGETS:\n' in run.out
+    assert "TARGETS:\n" in run.out
-    assert 'SOURCES:\n' in run.out
+    assert "SOURCES:\n" in run.out
 
 
 def test_new_scores(runner, yadm):
@@ -50,29 +50,29 @@ def test_new_scores(runner, yadm):
         record_score "4" "tgt_three" "src_three"
         {REPORT_RESULTS}
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'SIZE:3\n' in run.out
+    assert "SIZE:3\n" in run.out
-    assert 'SCORES:1 2 4\n' in run.out
+    assert "SCORES:1 2 4\n" in run.out
-    assert 'TARGETS:tgt_one tgt_two tgt_three\n' in run.out
+    assert "TARGETS:tgt_one tgt_two tgt_three\n" in run.out
-    assert 'SOURCES:src_one src_two src_three\n' in run.out
+    assert "SOURCES:src_one src_two src_three\n" in run.out
 
 
-@pytest.mark.parametrize('difference', ['lower', 'equal', 'higher'])
+@pytest.mark.parametrize("difference", ["lower", "equal", "higher"])
 def test_existing_scores(runner, yadm, difference):
     """Test existing scores"""
 
-    expected_score = '2'
+    expected_score = "2"
-    expected_src = 'existing_src'
+    expected_src = "existing_src"
-    if difference == 'lower':
+    if difference == "lower":
-        score = '1'
+        score = "1"
-    elif difference == 'equal':
+    elif difference == "equal":
-        score = '2'
+        score = "2"
     else:
-        score = '4'
+        score = "4"
-        expected_score = '4'
+        expected_score = "4"
-        expected_src = 'new_src'
+        expected_src = "new_src"
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -83,13 +83,13 @@ def test_existing_scores(runner, yadm, difference):
         record_score "{score}" "testtgt" "new_src"
         {REPORT_RESULTS}
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'SIZE:1\n' in run.out
+    assert "SIZE:1\n" in run.out
-    assert f'SCORES:{expected_score}\n' in run.out
+    assert f"SCORES:{expected_score}\n" in run.out
-    assert 'TARGETS:testtgt\n' in run.out
+    assert "TARGETS:testtgt\n" in run.out
-    assert f'SOURCES:{expected_src}\n' in run.out
+    assert f"SOURCES:{expected_src}\n" in run.out
 
 
 def test_existing_template(runner, yadm):
@@ -105,19 +105,19 @@ def test_existing_template(runner, yadm):
         record_score "2" "testtgt" "new_src"
         {REPORT_RESULTS}
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'SIZE:1\n' in run.out
+    assert "SIZE:1\n" in run.out
-    assert 'SCORES:1\n' in run.out
+    assert "SCORES:1\n" in run.out
-    assert 'TARGETS:testtgt\n' in run.out
+    assert "TARGETS:testtgt\n" in run.out
-    assert 'SOURCES:\n' in run.out
+    assert "SOURCES:\n" in run.out
 
 
 def test_config_first(runner, yadm):
     """Verify YADM_CONFIG is always processed first"""
 
-    config = 'yadm_config_file'
+    config = "yadm_config_file"
     script = f"""
         YADM_TEST=1 source {yadm}
         {INIT_VARS}
@@ -130,12 +130,12 @@ def test_config_first(runner, yadm):
         echo "CMD_VALUE:${{alt_template_cmds[@]}}"
         echo "CMD_INDEX:${{!alt_template_cmds[@]}}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'SIZE:3\n' in run.out
+    assert "SIZE:3\n" in run.out
-    assert 'SCORES:2 1 3\n' in run.out
+    assert "SCORES:2 1 3\n" in run.out
-    assert f'TARGETS:{config} tgt_before tgt_tmp tgt_after\n' in run.out
+    assert f"TARGETS:{config} tgt_before tgt_tmp tgt_after\n" in run.out
-    assert 'SOURCES:src_config src_before src_tmp src_after\n' in run.out
+    assert "SOURCES:src_config src_before src_tmp src_after\n" in run.out
-    assert 'CMD_VALUE:cmd_tmp\n' in run.out
+    assert "CMD_VALUE:cmd_tmp\n" in run.out
-    assert 'CMD_INDEX:2\n' in run.out
+    assert "CMD_INDEX:2\n" in run.out

test/test_unit_record_template.py

@@ -25,13 +25,13 @@ def test_new_template(runner, yadm):
         record_template "tgt_three" "cmd_three" "src_three"
         {REPORT_RESULTS}
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'SIZE:3\n' in run.out
+    assert "SIZE:3\n" in run.out
-    assert 'TARGETS:tgt_one tgt_two tgt_three\n' in run.out
+    assert "TARGETS:tgt_one tgt_two tgt_three\n" in run.out
-    assert 'CMDS:cmd_one cmd_two cmd_three\n' in run.out
+    assert "CMDS:cmd_one cmd_two cmd_three\n" in run.out
-    assert 'SOURCES:src_one src_two src_three\n' in run.out
+    assert "SOURCES:src_one src_two src_three\n" in run.out
 
 
 def test_existing_template(runner, yadm):
@@ -46,10 +46,10 @@ def test_existing_template(runner, yadm):
         record_template "testtgt" "new_cmd" "new_src"
         {REPORT_RESULTS}
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'SIZE:1\n' in run.out
+    assert "SIZE:1\n" in run.out
-    assert 'TARGETS:testtgt\n' in run.out
+    assert "TARGETS:testtgt\n" in run.out
-    assert 'CMDS:new_cmd\n' in run.out
+    assert "CMDS:new_cmd\n" in run.out
-    assert 'SOURCES:new_src\n' in run.out
+    assert "SOURCES:new_src\n" in run.out

test/test_unit_relative_path.py

@@ -3,7 +3,7 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'base,full_path,expected',
+    "base,full_path,expected",
     [
         ("/A/B/C", "/A", "../.."),
         ("/A/B/C", "/A/B", ".."),
@@ -25,7 +25,7 @@ def test_relative_path(runner, paths, base, full_path, expected):
         relative_path "{base}" "{full_path}"
     """
 
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out.strip() == expected

test/test_unit_remove_stale_links.py

@@ -1,23 +1,24 @@
 """Unit tests: remove_stale_links"""
 import os
+
 import pytest
 
 
-@pytest.mark.parametrize('linked', [True, False])
+@pytest.mark.parametrize("linked", [True, False])
-@pytest.mark.parametrize('kind', ['file', 'symlink'])
+@pytest.mark.parametrize("kind", ["file", "symlink"])
 def test_remove_stale_links(runner, yadm, tmpdir, kind, linked):
     """Test remove_stale_links()"""
 
-    source_file = tmpdir.join('source_file')
+    source_file = tmpdir.join("source_file")
-    source_file.write('source file', ensure=True)
+    source_file.write("source file", ensure=True)
-    link = tmpdir.join('link')
+    link = tmpdir.join("link")
 
-    if kind == 'file':
+    if kind == "file":
-        link.write('link file', ensure=True)
+        link.write("link file", ensure=True)
     else:
-        os.system(f'ln -s {source_file} {link}')
+        os.system(f"ln -s {source_file} {link}")
 
-    alt_linked = ''
+    alt_linked = ""
     if linked:
         alt_linked = source_file
 
@@ -29,9 +30,9 @@ def test_remove_stale_links(runner, yadm, tmpdir, kind, linked):
         remove_stale_links
     """
 
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
-    assert run.err == ''
+    assert run.err == ""
-    if kind == 'symlink' and not linked:
+    if kind == "symlink" and not linked:
-        assert f'rm -f {link}' in run.out
+        assert f"rm -f {link}" in run.out
     else:
-        assert run.out == ''
+        assert run.out == ""

test/test_unit_report_invalid_alts.py

@@ -2,15 +2,15 @@
 import pytest
 
 
-@pytest.mark.parametrize('valid', [True, False], ids=['valid', 'no_valid'])
+@pytest.mark.parametrize("valid", [True, False], ids=["valid", "no_valid"])
-@pytest.mark.parametrize('previous', [True, False], ids=['prev', 'no_prev'])
+@pytest.mark.parametrize("previous", [True, False], ids=["prev", "no_prev"])
 def test_report_invalid_alts(runner, yadm, valid, previous):
     """Use report_invalid_alts"""
 
-    lwi = ''
+    lwi = ""
-    alts = 'INVALID_ALT=()'
+    alts = "INVALID_ALT=()"
     if previous:
-        lwi = 'LEGACY_WARNING_ISSUED=1'
+        lwi = "LEGACY_WARNING_ISSUED=1"
     if not valid:
         alts = 'INVALID_ALT=("file##invalid")'
 
@@ -20,11 +20,11 @@ def test_report_invalid_alts(runner, yadm, valid, previous):
         {alts}
         report_invalid_alts
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.out == ''
+    assert run.out == ""
     if not valid and not previous:
-        assert 'WARNING' in run.err
+        assert "WARNING" in run.err
-        assert 'file##invalid' in run.err
+        assert "file##invalid" in run.err
     else:
-        assert run.err == ''
+        assert run.err == ""

test/test_unit_score_file.py

@@ -2,40 +2,40 @@
 import pytest
 
 CONDITION = {
-    'default': {
+    "default": {
-        'labels': ['default'],
+        "labels": ["default"],
-        'modifier': 0,
+        "modifier": 0,
-        },
+    },
-    'arch': {
+    "arch": {
-        'labels': ['a', 'arch'],
+        "labels": ["a", "arch"],
-        'modifier': 1,
+        "modifier": 1,
-        },
+    },
-    'system': {
+    "system": {
-        'labels': ['o', 'os'],
+        "labels": ["o", "os"],
-        'modifier': 2,
+        "modifier": 2,
-        },
+    },
-    'distro': {
+    "distro": {
-        'labels': ['d', 'distro'],
+        "labels": ["d", "distro"],
-        'modifier': 4,
+        "modifier": 4,
-        },
+    },
-    'distro_family': {
+    "distro_family": {
-        'labels': ['f', 'distro_family'],
+        "labels": ["f", "distro_family"],
-        'modifier': 8,
+        "modifier": 8,
-        },
+    },
-    'class': {
+    "class": {
-        'labels': ['c', 'class'],
+        "labels": ["c", "class"],
-        'modifier': 16,
+        "modifier": 16,
-        },
+    },
-    'hostname': {
+    "hostname": {
-        'labels': ['h', 'hostname'],
+        "labels": ["h", "hostname"],
-        'modifier': 32,
+        "modifier": 32,
-        },
+    },
-    'user': {
+    "user": {
-        'labels': ['u', 'user'],
+        "labels": ["u", "user"],
-        'modifier': 64,
+        "modifier": 64,
-        },
+    },
-    }
+}
-TEMPLATE_LABELS = ['t', 'template', 'yadm']
+TEMPLATE_LABELS = ["t", "template", "yadm"]
 
 
 def calculate_score(filename):
@@ -43,48 +43,48 @@ def calculate_score(filename):
     # pylint: disable=too-many-branches
     score = 0
 
-    _, conditions = filename.split('##', 1)
+    _, conditions = filename.split("##", 1)
 
-    for condition in conditions.split(','):
+    for condition in conditions.split(","):
         label = condition
         value = None
-        if '.' in condition:
+        if "." in condition:
-            label, value = condition.split('.', 1)
+            label, value = condition.split(".", 1)
-        if label in CONDITION['default']['labels']:
+        if label in CONDITION["default"]["labels"]:
             score += 1000
-        elif label in CONDITION['arch']['labels']:
+        elif label in CONDITION["arch"]["labels"]:
-            if value == 'testarch':
+            if value == "testarch":
-                score += 1000 + CONDITION['arch']['modifier']
+                score += 1000 + CONDITION["arch"]["modifier"]
             else:
                 score = 0
                 break
-        elif label in CONDITION['system']['labels']:
+        elif label in CONDITION["system"]["labels"]:
-            if value == 'testsystem':
+            if value == "testsystem":
-                score += 1000 + CONDITION['system']['modifier']
+                score += 1000 + CONDITION["system"]["modifier"]
             else:
                 score = 0
                 break
-        elif label in CONDITION['distro']['labels']:
+        elif label in CONDITION["distro"]["labels"]:
-            if value == 'testdistro':
+            if value == "testdistro":
-                score += 1000 + CONDITION['distro']['modifier']
+                score += 1000 + CONDITION["distro"]["modifier"]
             else:
                 score = 0
                 break
-        elif label in CONDITION['class']['labels']:
+        elif label in CONDITION["class"]["labels"]:
-            if value == 'testclass':
+            if value == "testclass":
-                score += 1000 + CONDITION['class']['modifier']
+                score += 1000 + CONDITION["class"]["modifier"]
             else:
                 score = 0
                 break
-        elif label in CONDITION['hostname']['labels']:
+        elif label in CONDITION["hostname"]["labels"]:
-            if value == 'testhost':
+            if value == "testhost":
-                score += 1000 + CONDITION['hostname']['modifier']
+                score += 1000 + CONDITION["hostname"]["modifier"]
             else:
                 score = 0
                 break
-        elif label in CONDITION['user']['labels']:
+        elif label in CONDITION["user"]["labels"]:
-            if value == 'testuser':
+            if value == "testuser":
-                score += 1000 + CONDITION['user']['modifier']
+                score += 1000 + CONDITION["user"]["modifier"]
             else:
                 score = 0
                 break
@@ -94,111 +94,85 @@ def calculate_score(filename):
     return score
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("default", ["default", None], ids=["default", "no-default"])
-    'default', ['default', None], ids=['default', 'no-default'])
+@pytest.mark.parametrize("arch", ["arch", None], ids=["arch", "no-arch"])
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("system", ["system", None], ids=["system", "no-system"])
-    'arch', ['arch', None], ids=['arch', 'no-arch'])
+@pytest.mark.parametrize("distro", ["distro", None], ids=["distro", "no-distro"])
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("cla", ["class", None], ids=["class", "no-class"])
-    'system', ['system', None], ids=['system', 'no-system'])
+@pytest.mark.parametrize("host", ["hostname", None], ids=["hostname", "no-host"])
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("user", ["user", None], ids=["user", "no-user"])
-    'distro', ['distro', None], ids=['distro', 'no-distro'])
+def test_score_values(runner, yadm, default, arch, system, distro, cla, host, user):
-@pytest.mark.parametrize(
-    'cla', ['class', None], ids=['class', 'no-class'])
-@pytest.mark.parametrize(
-    'host', ['hostname', None], ids=['hostname', 'no-host'])
-@pytest.mark.parametrize(
-    'user', ['user', None], ids=['user', 'no-user'])
-def test_score_values(
-        runner, yadm, default, arch, system, distro, cla, host, user):
     """Test score results"""
     # pylint: disable=too-many-branches
-    local_class = 'testclass'
+    local_class = "testclass"
-    local_arch = 'testarch'
+    local_arch = "testarch"
-    local_system = 'testsystem'
+    local_system = "testsystem"
-    local_distro = 'testdistro'
+    local_distro = "testdistro"
-    local_host = 'testhost'
+    local_host = "testhost"
-    local_user = 'testuser'
+    local_user = "testuser"
-    filenames = {'filename##': 0}
+    filenames = {"filename##": 0}
 
     if default:
         for filename in list(filenames):
-            for label in CONDITION[default]['labels']:
+            for label in CONDITION[default]["labels"]:
                 newfile = filename
-                if not newfile.endswith('##'):
+                if not newfile.endswith("##"):
-                    newfile += ','
+                    newfile += ","
                 newfile += label
                 filenames[newfile] = calculate_score(newfile)
     if arch:
         for filename in list(filenames):
             for match in [True, False]:
-                for label in CONDITION[arch]['labels']:
+                for label in CONDITION[arch]["labels"]:
                     newfile = filename
-                    if not newfile.endswith('##'):
+                    if not newfile.endswith("##"):
-                        newfile += ','
+                        newfile += ","
-                    newfile += '.'.join([
+                    newfile += ".".join([label, local_arch if match else "badarch"])
-                        label,
-                        local_arch if match else 'badarch'
-                        ])
                     filenames[newfile] = calculate_score(newfile)
     if system:
         for filename in list(filenames):
             for match in [True, False]:
-                for label in CONDITION[system]['labels']:
+                for label in CONDITION[system]["labels"]:
                     newfile = filename
-                    if not newfile.endswith('##'):
+                    if not newfile.endswith("##"):
-                        newfile += ','
+                        newfile += ","
-                    newfile += '.'.join([
+                    newfile += ".".join([label, local_system if match else "badsys"])
-                        label,
-                        local_system if match else 'badsys'
-                        ])
                     filenames[newfile] = calculate_score(newfile)
     if distro:
         for filename in list(filenames):
             for match in [True, False]:
-                for label in CONDITION[distro]['labels']:
+                for label in CONDITION[distro]["labels"]:
                     newfile = filename
-                    if not newfile.endswith('##'):
+                    if not newfile.endswith("##"):
-                        newfile += ','
+                        newfile += ","
-                    newfile += '.'.join([
+                    newfile += ".".join([label, local_distro if match else "baddistro"])
-                        label,
-                        local_distro if match else 'baddistro'
-                        ])
                     filenames[newfile] = calculate_score(newfile)
     if cla:
         for filename in list(filenames):
             for match in [True, False]:
-                for label in CONDITION[cla]['labels']:
+                for label in CONDITION[cla]["labels"]:
                     newfile = filename
-                    if not newfile.endswith('##'):
+                    if not newfile.endswith("##"):
-                        newfile += ','
+                        newfile += ","
-                    newfile += '.'.join([
+                    newfile += ".".join([label, local_class if match else "badclass"])
-                        label,
-                        local_class if match else 'badclass'
-                        ])
                     filenames[newfile] = calculate_score(newfile)
     if host:
         for filename in list(filenames):
             for match in [True, False]:
-                for label in CONDITION[host]['labels']:
+                for label in CONDITION[host]["labels"]:
                     newfile = filename
-                    if not newfile.endswith('##'):
+                    if not newfile.endswith("##"):
-                        newfile += ','
+                        newfile += ","
-                    newfile += '.'.join([
+                    newfile += ".".join([label, local_host if match else "badhost"])
-                        label,
-                        local_host if match else 'badhost'
-                        ])
                     filenames[newfile] = calculate_score(newfile)
     if user:
         for filename in list(filenames):
             for match in [True, False]:
-                for label in CONDITION[user]['labels']:
+                for label in CONDITION[user]["labels"]:
                     newfile = filename
-                    if not newfile.endswith('##'):
+                    if not newfile.endswith("##"):
-                        newfile += ','
+                        newfile += ","
-                    newfile += '.'.join([
+                    newfile += ".".join([label, local_user if match else "baduser"])
-                        label,
-                        local_user if match else 'baduser'
-                        ])
                     filenames[newfile] = calculate_score(newfile)
 
     script = f"""
@@ -212,29 +186,29 @@ def test_score_values(
         local_host={local_host}
         local_user={local_user}
     """
-    expected = ''
+    expected = ""
-    for filename in filenames:
+    for filename, score in filenames.items():
         script += f"""
             score_file "{filename}"
             echo "{filename}"
             echo "$score"
         """
-        expected += filename + '\n'
+        expected += filename + "\n"
-        expected += str(filenames[filename]) + '\n'
+        expected += str(score) + "\n"
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out == expected
 
 
-@pytest.mark.parametrize('ext', [None, 'e', 'extension'])
+@pytest.mark.parametrize("ext", [None, "e", "extension"])
 def test_extensions(runner, yadm, ext):
     """Verify extensions do not effect scores"""
-    local_user = 'testuser'
+    local_user = "testuser"
-    filename = f'filename##u.{local_user}'
+    filename = f"filename##u.{local_user}"
     if ext:
-        filename += f',{ext}.xyz'
+        filename += f",{ext}.xyz"
-    expected = ''
+    expected = ""
     script = f"""
         YADM_TEST=1 source {yadm}
         score=0
@@ -243,28 +217,28 @@ def test_extensions(runner, yadm, ext):
         echo "$score"
     """
     expected = f'{1000 + CONDITION["user"]["modifier"]}\n'
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out == expected
 
 
 def test_score_values_templates(runner, yadm):
     """Test score results"""
-    local_class = 'testclass'
+    local_class = "testclass"
-    local_arch = 'arch'
+    local_arch = "arch"
-    local_system = 'testsystem'
+    local_system = "testsystem"
-    local_distro = 'testdistro'
+    local_distro = "testdistro"
-    local_host = 'testhost'
+    local_host = "testhost"
-    local_user = 'testuser'
+    local_user = "testuser"
-    filenames = {'filename##': 0}
+    filenames = {"filename##": 0}
 
     for filename in list(filenames):
         for label in TEMPLATE_LABELS:
             newfile = filename
-            if not newfile.endswith('##'):
+            if not newfile.endswith("##"):
-                newfile += ','
+                newfile += ","
-            newfile += '.'.join([label, 'testtemplate'])
+            newfile += ".".join([label, "testtemplate"])
             filenames[newfile] = calculate_score(newfile)
 
     script = f"""
@@ -277,33 +251,30 @@ def test_score_values_templates(runner, yadm):
         local_host={local_host}
         local_user={local_user}
     """
-    expected = ''
+    expected = ""
-    for filename in filenames:
+    for filename, score in filenames.items():
         script += f"""
             score_file "{filename}"
             echo "{filename}"
             echo "$score"
         """
-        expected += filename + '\n'
+        expected += filename + "\n"
-        expected += str(filenames[filename]) + '\n'
+        expected += str(score) + "\n"
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out == expected
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("cmd_generated", [True, False], ids=["supported-template", "unsupported-template"])
-    'cmd_generated',
-    [True, False],
-    ids=['supported-template', 'unsupported-template'])
 def test_template_recording(runner, yadm, cmd_generated):
     """Template should be recorded if choose_template_cmd outputs a command"""
 
-    mock = 'function choose_template_cmd() { return; }'
+    mock = "function choose_template_cmd() { return; }"
-    expected = ''
+    expected = ""
     if cmd_generated:
         mock = 'function choose_template_cmd() { echo "test_cmd"; }'
-        expected = 'template recorded'
+        expected = "template recorded"
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -311,24 +282,24 @@ def test_template_recording(runner, yadm, cmd_generated):
         {mock}
         score_file "testfile##template.kind"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out.rstrip() == expected
 
 
 def test_underscores_in_distro_and_family(runner, yadm):
     """Test replacing spaces in distro / distro_family with underscores"""
-    local_distro = 'test distro'
+    local_distro = "test distro"
-    local_distro_family = 'test family'
+    local_distro_family = "test family"
     filenames = {
-            'filename##distro.test distro': 1004,
+        "filename##distro.test distro": 1004,
-            'filename##distro.test-distro': 0,
+        "filename##distro.test-distro": 0,
-            'filename##distro.test_distro': 1004,
+        "filename##distro.test_distro": 1004,
-            'filename##distro_family.test family': 1008,
+        "filename##distro_family.test family": 1008,
-            'filename##distro_family.test-family': 0,
+        "filename##distro_family.test-family": 0,
-            'filename##distro_family.test_family': 1008,
+        "filename##distro_family.test_family": 1008,
-            }
+    }
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -336,16 +307,16 @@ def test_underscores_in_distro_and_family(runner, yadm):
         local_distro="{local_distro}"
         local_distro_family="{local_distro_family}"
     """
-    expected = ''
+    expected = ""
-    for filename in filenames:
+    for filename, score in filenames.items():
         script += f"""
             score_file "{filename}"
             echo "{filename}"
             echo "$score"
         """
-        expected += filename + '\n'
+        expected += filename + "\n"
-        expected += str(filenames[filename]) + '\n'
+        expected += str(score) + "\n"
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert run.out == expected

test/test_unit_set_local_alt_values.py

@@ -4,26 +4,26 @@ import utils
 
 
 @pytest.mark.parametrize(
-    'override', [
+    "override",
+    [
         False,
-        'class',
+        "class",
-        'arch',
+        "arch",
-        'os',
+        "os",
-        'hostname',
+        "hostname",
-        'user',
+        "user",
-        ],
+    ],
     ids=[
-        'no-override',
+        "no-override",
-        'override-class',
+        "override-class",
-        'override-arch',
+        "override-arch",
-        'override-os',
+        "override-os",
-        'override-hostname',
+        "override-hostname",
-        'override-user',
+        "override-user",
-        ]
+    ],
-    )
+)
-@pytest.mark.usefixtures('ds1_copy')
+@pytest.mark.usefixtures("ds1_copy")
-def test_set_local_alt_values(
+def test_set_local_alt_values(runner, yadm, paths, tst_arch, tst_sys, tst_host, tst_user, override):
-        runner, yadm, paths, tst_arch, tst_sys, tst_host, tst_user, override):
     """Use issue_legacy_path_warning"""
     script = f"""
         YADM_TEST=1 source {yadm} &&
@@ -37,37 +37,37 @@ def test_set_local_alt_values(
         echo "user='$local_user'"
     """
 
-    if override == 'class':
+    if override == "class":
-        utils.set_local(paths, override, 'first')
+        utils.set_local(paths, override, "first")
-        utils.set_local(paths, override, 'override', add=True)
+        utils.set_local(paths, override, "override", add=True)
     elif override:
-        utils.set_local(paths, override, 'override')
+        utils.set_local(paths, override, "override")
 
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
 
-    if override == 'class':
+    if override == "class":
         assert "class='override'" in run.out
     else:
         assert "class=''" in run.out
 
-    if override == 'arch':
+    if override == "arch":
         assert "arch='override'" in run.out
     else:
         assert f"arch='{tst_arch}'" in run.out
 
-    if override == 'os':
+    if override == "os":
         assert "os='override'" in run.out
     else:
         assert f"os='{tst_sys}'" in run.out
 
-    if override == 'hostname':
+    if override == "hostname":
         assert "host='override'" in run.out
     else:
         assert f"host='{tst_host}'" in run.out
 
-    if override == 'user':
+    if override == "user":
         assert "user='override'" in run.out
     else:
         assert f"user='{tst_user}'" in run.out
@@ -85,8 +85,8 @@ def test_distro_and_family(runner, yadm):
         echo "distro='$local_distro'"
         echo "distro_family='$local_distro_family'"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert "distro='testdistro'" in run.out
     assert "distro_family='testfamily'" in run.out

test/test_unit_set_os.py

@@ -4,25 +4,27 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'proc_value, expected_os', [
+    "proc_value, expected_os",
-        ('missing', 'uname'),
+    [
-        ('has microsoft inside', 'WSL'),  # case insensitive
+        ("missing", "uname"),
-        ('has Microsoft inside', 'WSL'),  # case insensitive
+        ("has microsoft inside", "WSL"),  # case insensitive
-        ('another value', 'uname'),
+        ("has Microsoft inside", "WSL"),  # case insensitive
-    ], ids=[
+        ("another value", "uname"),
-        '/proc/version missing',
+    ],
-        '/proc/version includes ms',
+    ids=[
-        '/proc/version excludes Ms',
+        "/proc/version missing",
-        'another value',
+        "/proc/version includes ms",
-    ])
+        "/proc/version excludes Ms",
-def test_set_operating_system(
+        "another value",
-        runner, paths, tst_sys, proc_value, expected_os):
+    ],
+)
+def test_set_operating_system(runner, paths, tst_sys, proc_value, expected_os):
     """Run set_operating_system and test result"""
 
     # Normally /proc/version (set in PROC_VERSION) is inspected to identify
     # WSL. During testing, we will override that value.
-    proc_version = paths.root.join('proc_version')
+    proc_version = paths.root.join("proc_version")
-    if proc_value != 'missing':
+    if proc_value != "missing":
         proc_version.write(proc_value)
     script = f"""
         YADM_TEST=1 source {paths.pgm}
@@ -30,9 +32,9 @@ def test_set_operating_system(
         set_operating_system
         echo $OPERATING_SYSTEM
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if expected_os == 'uname':
+    if expected_os == "uname":
         expected_os = tst_sys
     assert run.out.rstrip() == expected_os

test/test_unit_set_yadm_dir.py

@@ -3,25 +3,20 @@ import pytest
 
 
 @pytest.mark.parametrize(
-    'condition', [
+    "condition",
-        'basic',
+    ["basic", "override", "override_data", "xdg_config_home", "xdg_data_home"],
-        'override',
+)
-        'override_data',
-        'xdg_config_home',
-        'xdg_data_home'
-        ],
-    )
 def test_set_yadm_dirs(runner, yadm, condition):
     """Test set_yadm_dirs"""
-    setup = ''
+    setup = ""
-    if condition == 'override':
+    if condition == "override":
-        setup = 'YADM_DIR=/override'
+        setup = "YADM_DIR=/override"
-    elif condition == 'override_data':
+    elif condition == "override_data":
-        setup = 'YADM_DATA=/override'
+        setup = "YADM_DATA=/override"
-    elif condition == 'xdg_config_home':
+    elif condition == "xdg_config_home":
-        setup = 'XDG_CONFIG_HOME=/xdg'
+        setup = "XDG_CONFIG_HOME=/xdg"
-    elif condition == 'xdg_data_home':
+    elif condition == "xdg_data_home":
-        setup = 'XDG_DATA_HOME=/xdg'
+        setup = "XDG_DATA_HOME=/xdg"
     script = f"""
         HOME=/testhome
         YADM_TEST=1 source {yadm}
@@ -32,17 +27,17 @@ def test_set_yadm_dirs(runner, yadm, condition):
         echo "YADM_DIR=$YADM_DIR"
         echo "YADM_DATA=$YADM_DATA"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if condition == 'basic':
+    if condition == "basic":
-        assert 'YADM_DIR=/testhome/.config/yadm' in run.out
+        assert "YADM_DIR=/testhome/.config/yadm" in run.out
-        assert 'YADM_DATA=/testhome/.local/share/yadm' in run.out
+        assert "YADM_DATA=/testhome/.local/share/yadm" in run.out
-    elif condition == 'override':
+    elif condition == "override":
-        assert 'YADM_DIR=/override' in run.out
+        assert "YADM_DIR=/override" in run.out
-    elif condition == 'override_data':
+    elif condition == "override_data":
-        assert 'YADM_DATA=/override' in run.out
+        assert "YADM_DATA=/override" in run.out
-    elif condition == 'xdg_config_home':
+    elif condition == "xdg_config_home":
-        assert 'YADM_DIR=/xdg/yadm' in run.out
+        assert "YADM_DIR=/xdg/yadm" in run.out
-    elif condition == 'xdg_data_home':
+    elif condition == "xdg_data_home":
-        assert 'YADM_DATA=/xdg/yadm' in run.out
+        assert "YADM_DATA=/xdg/yadm" in run.out

test/test_unit_template_default.py

@@ -1,4 +1,5 @@
 """Unit tests: template_default"""
+
 import os
 
 FILE_MODE = 0o754
@@ -12,7 +13,8 @@ LOCAL_HOST = "default_Test+@-!^Host"
 LOCAL_USER = "default_Test+@-!^User"
 LOCAL_DISTRO = "default_Test+@-!^Distro"
 LOCAL_DISTRO_FAMILY = "default_Test+@-!^Family"
-TEMPLATE = f'''
+ENV_VAR = "default_Test+@-!^Env"
+TEMPLATE = f"""
 start of template
 default class         = >{{{{yadm.class}}}}<
 default arch          = >{{{{yadm.arch}}}}<
@@ -30,6 +32,9 @@ Included section from else
 {{% if yadm.class == "wrongclass1" %}}
 wrong class 1
 {{% endif %}}
+{{% if yadm.class != "wronglcass" %}}
+Included section from !=
+{{%     endif\t\t  %}}
 {{% if yadm.class == "{LOCAL_CLASS}" %}}
 Included section for class = {{{{yadm.class}}}} ({{{{yadm.class}}}} repeated)
 Multiple lines
@@ -97,9 +102,16 @@ Included section for distro_family = \
 {{% if yadm.distro_family == "wrongfamily2" %}}
 wrong family 2
 {{% endif %}}
+{{% if env.VAR == "{ENV_VAR}" %}}
+Included section for env.VAR = {{{{env.VAR}}}} ({{{{env.VAR}}}} again)
+{{% endif %}}
+{{% if env.VAR == "wrongenvvar" %}}
+wrong env.VAR
+{{% endif %}}
+yadm.no_such_var="{{{{ yadm.no_such_var }}}}" and env.NO_SUCH_VAR="{{{{ env.NO_SUCH_VAR }}}}"
 end of template
-'''
+"""
-EXPECTED = f'''
+EXPECTED = f"""
 start of template
 default class         = >{LOCAL_CLASS}<
 default arch          = >{LOCAL_ARCH}<
@@ -111,6 +123,7 @@ default distro_family = >{LOCAL_DISTRO_FAMILY}<
 classes = >{LOCAL_CLASS2}
 {LOCAL_CLASS}<
 Included section from else
+Included section from !=
 Included section for class = {LOCAL_CLASS} ({LOCAL_CLASS} repeated)
 Multiple lines
 Included section for second class
@@ -121,28 +134,30 @@ Included section for user = {LOCAL_USER} ({LOCAL_USER} repeated)
 Included section for distro = {LOCAL_DISTRO} ({LOCAL_DISTRO} again)
 Included section for distro_family = \
 {LOCAL_DISTRO_FAMILY} ({LOCAL_DISTRO_FAMILY} again)
+Included section for env.VAR = {ENV_VAR} ({ENV_VAR} again)
+yadm.no_such_var="" and env.NO_SUCH_VAR=""
 end of template
-'''
+"""
 
-INCLUDE_BASIC = 'basic\n'
+INCLUDE_BASIC = "basic\n"
-INCLUDE_VARIABLES = '''\
+INCLUDE_VARIABLES = """\
 included <{{ yadm.class }}> file
 
 empty line above
-'''
+"""
-INCLUDE_NESTED = 'no newline at the end'
+INCLUDE_NESTED = "no newline at the end"
 
-TEMPLATE_INCLUDE = '''\
+TEMPLATE_INCLUDE = """\
 The first line
 {% include empty %}
 An empty file removes the line above
 {%include basic%}
 {% include "./variables.{{ yadm.os }}"  %}
-{% include dir/nested %}
+  {% include dir/nested %}
 Include basic again:
 {% include basic %}
-'''
+"""
-EXPECTED_INCLUDE = f'''\
+EXPECTED_INCLUDE = f"""\
 The first line
 An empty file removes the line above
 basic
@@ -152,21 +167,57 @@ empty line above
 no newline at the end
 Include basic again:
 basic
-'''
+"""
+
+TEMPLATE_NESTED_IFS = """\
+{% if yadm.user == "me" %}
+    print1
+  {% if yadm.user == "me" %}
+    print2
+  {% else %}
+    no print1
+  {% endif %}
+{% else %}
+  {% if yadm.user == "me" %}
+    no print2
+  {% else %}
+    no print3
+  {% endif %}
+{% endif %}
+{% if yadm.user != "me" %}
+    no print4
+  {% if yadm.user == "me" %}
+    no print5
+  {% else %}
+    no print6
+  {% endif %}
+{% else %}
+  {% if yadm.user == "me" %}
+    print3
+  {% else %}
+    no print7
+  {% endif %}
+{% endif %}
+"""
+EXPECTED_NESTED_IFS = """\
+    print1
+    print2
+    print3
+"""
 
 
 def test_template_default(runner, yadm, tmpdir):
     """Test template_default"""
 
-    input_file = tmpdir.join('input')
+    input_file = tmpdir.join("input")
     input_file.write(TEMPLATE, ensure=True)
     input_file.chmod(FILE_MODE)
-    output_file = tmpdir.join('output')
+    output_file = tmpdir.join("output")
 
     # ensure overwrite works when file exists as read-only (there is some
     # special processing when this is encountered because some environments do
     # not properly overwrite read-only files)
-    output_file.write('existing')
+    output_file.write("existing")
     output_file.chmod(0o400)
 
     script = f"""
@@ -182,9 +233,9 @@ def test_template_default(runner, yadm, tmpdir):
         local_distro_family="{LOCAL_DISTRO_FAMILY}"
         template_default "{input_file}" "{output_file}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script, env={"VAR": ENV_VAR})
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert output_file.read() == EXPECTED
     assert os.stat(output_file).st_mode == os.stat(input_file).st_mode
 
@@ -192,19 +243,19 @@ def test_template_default(runner, yadm, tmpdir):
 def test_source(runner, yadm, tmpdir):
     """Test yadm.source"""
 
-    input_file = tmpdir.join('input')
+    input_file = tmpdir.join("input")
-    input_file.write('{{yadm.source}}', ensure=True)
+    input_file.write("{{yadm.source}}", ensure=True)
     input_file.chmod(FILE_MODE)
-    output_file = tmpdir.join('output')
+    output_file = tmpdir.join("output")
 
     script = f"""
         YADM_TEST=1 source {yadm}
         set_awk
         template_default "{input_file}" "{output_file}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert output_file.read().strip() == str(input_file)
     assert os.stat(output_file).st_mode == os.stat(input_file).st_mode
 
@@ -212,22 +263,22 @@ def test_source(runner, yadm, tmpdir):
 def test_include(runner, yadm, tmpdir):
     """Test include"""
 
-    empty_file = tmpdir.join('empty')
+    empty_file = tmpdir.join("empty")
-    empty_file.write('', ensure=True)
+    empty_file.write("", ensure=True)
 
-    basic_file = tmpdir.join('basic')
+    basic_file = tmpdir.join("basic")
     basic_file.write(INCLUDE_BASIC)
 
-    variables_file = tmpdir.join(f'variables.{LOCAL_SYSTEM}')
+    variables_file = tmpdir.join(f"variables.{LOCAL_SYSTEM}")
     variables_file.write(INCLUDE_VARIABLES)
 
-    nested_file = tmpdir.join('dir').join('nested')
+    nested_file = tmpdir.join("dir").join("nested")
     nested_file.write(INCLUDE_NESTED, ensure=True)
 
-    input_file = tmpdir.join('input')
+    input_file = tmpdir.join("input")
     input_file.write(TEMPLATE_INCLUDE)
     input_file.chmod(FILE_MODE)
-    output_file = tmpdir.join('output')
+    output_file = tmpdir.join("output")
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -236,27 +287,45 @@ def test_include(runner, yadm, tmpdir):
         local_system="{LOCAL_SYSTEM}"
         template_default "{input_file}" "{output_file}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert output_file.read() == EXPECTED_INCLUDE
     assert os.stat(output_file).st_mode == os.stat(input_file).st_mode
 
 
+def test_nested_ifs(runner, yadm, tmpdir):
+    """Test nested if statements"""
+
+    input_file = tmpdir.join("input")
+    input_file.write(TEMPLATE_NESTED_IFS, ensure=True)
+    output_file = tmpdir.join("output")
+
+    script = f"""
+        YADM_TEST=1 source {yadm}
+        set_awk
+        local_user="me"
+        template_default "{input_file}" "{output_file}"
+    """
+    run = runner(command=["bash"], inp=script)
+    assert run.success
+    assert run.err == ""
+    assert output_file.read() == EXPECTED_NESTED_IFS
+
+
 def test_env(runner, yadm, tmpdir):
     """Test env"""
 
-    input_file = tmpdir.join('input')
+    input_file = tmpdir.join("input")
-    input_file.write('{{env.PWD}}', ensure=True)
+    input_file.write("{{env.PWD}}", ensure=True)
-    input_file.chmod(FILE_MODE)
+    output_file = tmpdir.join("output")
-    output_file = tmpdir.join('output')
 
     script = f"""
         YADM_TEST=1 source {yadm}
         set_awk
         template_default "{input_file}" "{output_file}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert output_file.read().strip() == os.environ['PWD']
+    assert output_file.read().strip() == os.environ["PWD"]

test/test_unit_template_esh.py

@@ -11,7 +11,7 @@ LOCAL_HOST = "esh_Test+@-!^Host"
 LOCAL_USER = "esh_Test+@-!^User"
 LOCAL_DISTRO = "esh_Test+@-!^Distro"
 LOCAL_DISTRO_FAMILY = "esh_Test+@-!^Family"
-TEMPLATE = f'''
+TEMPLATE = f"""
 start of template
 esh class         = ><%=$YADM_CLASS%><
 esh arch          = ><%=$YADM_ARCH%><
@@ -90,8 +90,8 @@ Included esh section for distro_family = \
 wrong family 2
 <% fi -%>
 end of template
-'''
+"""
-EXPECTED = f'''
+EXPECTED = f"""
 start of template
 esh class         = >{LOCAL_CLASS}<
 esh arch          = >{LOCAL_ARCH}<
@@ -111,21 +111,22 @@ Included esh section for distro = {LOCAL_DISTRO} ({LOCAL_DISTRO} again)
 Included esh section for distro_family = \
 {LOCAL_DISTRO_FAMILY} ({LOCAL_DISTRO_FAMILY} again)
 end of template
-'''
+"""
 
 
 def test_template_esh(runner, yadm, tmpdir):
     """Test processing by esh"""
+    # pylint: disable=duplicate-code
 
-    input_file = tmpdir.join('input')
+    input_file = tmpdir.join("input")
     input_file.write(TEMPLATE, ensure=True)
     input_file.chmod(FILE_MODE)
-    output_file = tmpdir.join('output')
+    output_file = tmpdir.join("output")
 
     # ensure overwrite works when file exists as read-only (there is some
     # special processing when this is encountered because some environments do
     # not properly overwrite read-only files)
-    output_file.write('existing')
+    output_file.write("existing")
     output_file.chmod(0o400)
 
     script = f"""
@@ -140,9 +141,9 @@ def test_template_esh(runner, yadm, tmpdir):
         local_distro_family="{LOCAL_DISTRO_FAMILY}"
         template_esh "{input_file}" "{output_file}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert output_file.read().strip() == str(EXPECTED).strip()
     assert os.stat(output_file).st_mode == os.stat(input_file).st_mode
 
@@ -150,17 +151,17 @@ def test_template_esh(runner, yadm, tmpdir):
 def test_source(runner, yadm, tmpdir):
     """Test YADM_SOURCE"""
 
-    input_file = tmpdir.join('input')
+    input_file = tmpdir.join("input")
-    input_file.write('<%= $YADM_SOURCE %>', ensure=True)
+    input_file.write("<%= $YADM_SOURCE %>", ensure=True)
     input_file.chmod(FILE_MODE)
-    output_file = tmpdir.join('output')
+    output_file = tmpdir.join("output")
 
     script = f"""
         YADM_TEST=1 source {yadm}
         template_esh "{input_file}" "{output_file}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert output_file.read().strip() == str(input_file)
     assert os.stat(output_file).st_mode == os.stat(input_file).st_mode

test/test_unit_template_j2.py

@@ -1,5 +1,6 @@
 """Unit tests: template_j2cli & template_envtpl"""
 import os
+
 import pytest
 
 FILE_MODE = 0o754
@@ -12,7 +13,7 @@ LOCAL_HOST = "j2_Test+@-!^Host"
 LOCAL_USER = "j2_Test+@-!^User"
 LOCAL_DISTRO = "j2_Test+@-!^Distro"
 LOCAL_DISTRO_FAMILY = "j2_Test+@-!^Family"
-TEMPLATE = f'''
+TEMPLATE = f"""
 start of template
 j2 class         = >{{{{YADM_CLASS}}}}<
 j2 arch          = >{{{{YADM_ARCH}}}}<
@@ -93,8 +94,8 @@ Included j2 section for distro_family = \
 wrong family 2
 {{%- endif %}}
 end of template
-'''
+"""
-EXPECTED = f'''
+EXPECTED = f"""
 start of template
 j2 class         = >{LOCAL_CLASS}<
 j2 arch          = >{LOCAL_ARCH}<
@@ -115,22 +116,23 @@ Included j2 section for distro = {LOCAL_DISTRO} ({LOCAL_DISTRO} again)
 Included j2 section for distro_family = \
 {LOCAL_DISTRO_FAMILY} ({LOCAL_DISTRO_FAMILY} again)
 end of template
-'''
+"""
 
 
-@pytest.mark.parametrize('processor', ('j2cli', 'envtpl'))
+@pytest.mark.parametrize("processor", ("j2cli", "envtpl"))
 def test_template_j2(runner, yadm, tmpdir, processor):
     """Test processing by j2cli & envtpl"""
+    # pylint: disable=duplicate-code
 
-    input_file = tmpdir.join('input')
+    input_file = tmpdir.join("input")
     input_file.write(TEMPLATE, ensure=True)
     input_file.chmod(FILE_MODE)
-    output_file = tmpdir.join('output')
+    output_file = tmpdir.join("output")
 
     # ensure overwrite works when file exists as read-only (there is some
     # special processing when this is encountered because some environments do
     # not properly overwrite read-only files)
-    output_file.write('existing')
+    output_file.write("existing")
     output_file.chmod(0o400)
 
     script = f"""
@@ -145,28 +147,28 @@ def test_template_j2(runner, yadm, tmpdir, processor):
         local_distro_family="{LOCAL_DISTRO_FAMILY}"
         template_{processor} "{input_file}" "{output_file}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert output_file.read() == EXPECTED
     assert os.stat(output_file).st_mode == os.stat(input_file).st_mode
 
 
-@pytest.mark.parametrize('processor', ('j2cli', 'envtpl'))
+@pytest.mark.parametrize("processor", ("j2cli", "envtpl"))
 def test_source(runner, yadm, tmpdir, processor):
     """Test YADM_SOURCE"""
 
-    input_file = tmpdir.join('input')
+    input_file = tmpdir.join("input")
-    input_file.write('{{YADM_SOURCE}}', ensure=True)
+    input_file.write("{{YADM_SOURCE}}", ensure=True)
     input_file.chmod(FILE_MODE)
-    output_file = tmpdir.join('output')
+    output_file = tmpdir.join("output")
 
     script = f"""
         YADM_TEST=1 source {yadm}
         template_{processor} "{input_file}" "{output_file}"
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
     assert output_file.read().strip() == str(input_file)
     assert os.stat(output_file).st_mode == os.stat(input_file).st_mode

test/test_unit_upgrade.py

@@ -2,21 +2,21 @@
 import pytest
 
 
-@pytest.mark.parametrize('condition', ['override', 'equal', 'existing_repo'])
+@pytest.mark.parametrize("condition", ["override", "equal", "existing_repo"])
 def test_upgrade_errors(tmpdir, runner, yadm, condition):
     """Test upgrade() error conditions"""
 
-    home = tmpdir.mkdir('home')
+    home = tmpdir.mkdir("home")
-    yadm_dir = home.join('.config/yadm')
+    yadm_dir = home.join(".config/yadm")
-    yadm_data = home.join('.local/share/yadm')
+    yadm_data = home.join(".local/share/yadm")
-    override = ''
+    override = ""
-    if condition == 'override':
+    if condition == "override":
-        override = 'override'
+        override = "override"
-    if condition == 'equal':
+    if condition == "equal":
         yadm_data = yadm_dir
-    if condition == 'existing_repo':
+    if condition == "existing_repo":
-        yadm_dir.ensure_dir('repo.git')
+        yadm_dir.ensure_dir("repo.git")
-        yadm_data.ensure_dir('repo.git')
+        yadm_data.ensure_dir("repo.git")
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -27,17 +27,16 @@ def test_upgrade_errors(tmpdir, runner, yadm, condition):
         YADM_OVERRIDE_REPO="{override}"
         upgrade
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.failure
-    assert 'Unable to upgrade' in run.err
+    assert "Unable to upgrade" in run.err
-    if condition in ['override', 'equal']:
+    if condition in ["override", "equal"]:
-        assert 'Paths have been overridden' in run.err
+        assert "Paths have been overridden" in run.err
-    elif condition == 'existing_repo':
+    elif condition == "existing_repo":
-        assert 'already exists' in run.err
+        assert "already exists" in run.err
 
 
-@pytest.mark.parametrize(
+@pytest.mark.parametrize("condition", ["no-paths", "untracked", "tracked", "submodules"])
-    'condition', ['no-paths', 'untracked', 'tracked', 'submodules'])
 def test_upgrade(tmpdir, runner, yadm, condition):
     """Test upgrade()
 
@@ -45,21 +44,21 @@ def test_upgrade(tmpdir, runner, yadm, condition):
     mock for git. echo will return true, simulating a positive result from "git
     ls-files". Also echo will report the parameters for "git mv".
     """
-    legacy_paths = ('config', 'encrypt', 'bootstrap', 'hooks/pre_cmd')
+    legacy_paths = ("config", "encrypt", "bootstrap", "hooks/pre_cmd")
-    home = tmpdir.mkdir('home')
+    home = tmpdir.mkdir("home")
-    yadm_dir = home.join('.config/yadm')
+    yadm_dir = home.join(".config/yadm")
-    yadm_data = home.join('.local/share/yadm')
+    yadm_data = home.join(".local/share/yadm")
-    yadm_legacy = home.join('.yadm')
+    yadm_legacy = home.join(".yadm")
 
-    if condition != 'no-paths':
+    if condition != "no-paths":
-        yadm_dir.join('repo.git/config').write('test-repo', ensure=True)
+        yadm_dir.join("repo.git/config").write("test-repo", ensure=True)
-        yadm_dir.join('files.gpg').write('files.gpg', ensure=True)
+        yadm_dir.join("files.gpg").write("files.gpg", ensure=True)
         for path in legacy_paths:
             yadm_legacy.join(path).write(path, ensure=True)
 
     mock_git = ""
-    if condition != 'no-paths':
+    if condition != "no-paths":
-        mock_git = f'''
+        mock_git = f"""
             function git() {{
                 echo "$@"
                 if [[ "$*" = *"submodule status" ]]; then
@@ -71,7 +70,7 @@ def test_upgrade(tmpdir, runner, yadm, condition):
                 fi
                 return 0
             }}
-        '''
+        """
 
     script = f"""
         YADM_TEST=1 source {yadm}
@@ -85,38 +84,30 @@ def test_upgrade(tmpdir, runner, yadm, condition):
         function cd {{ echo "$@";}}
         upgrade
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    if condition == 'no-paths':
+    if condition == "no-paths":
-        assert 'Upgrade is not necessary' in run.out
+        assert "Upgrade is not necessary" in run.out
     else:
-        for (lpath, npath) in [
+        for lpath, npath in [("repo.git", "repo.git"), ("files.gpg", "archive")]:
-                ('repo.git', 'repo.git'), ('files.gpg', 'archive')]:
+            expected = f"Moving {yadm_dir.join(lpath)} " f"to {yadm_data.join(npath)}"
-            expected = (
-                f'Moving {yadm_dir.join(lpath)} '
-                f'to {yadm_data.join(npath)}')
             assert expected in run.out
         for path in legacy_paths:
-            expected = (
+            expected = f"Moving {yadm_legacy.join(path)} " f"to {yadm_dir.join(path)}"
-                f'Moving {yadm_legacy.join(path)} '
-                f'to {yadm_dir.join(path)}')
             assert expected in run.out
-        if condition == 'untracked':
+        if condition == "untracked":
-            assert 'test-repo' in yadm_data.join('repo.git/config').read()
+            assert "test-repo" in yadm_data.join("repo.git/config").read()
-            assert 'files.gpg' in yadm_data.join('archive').read()
+            assert "files.gpg" in yadm_data.join("archive").read()
             for path in legacy_paths:
                 assert path in yadm_dir.join(path).read()
-        elif condition in ['tracked', 'submodules']:
+        elif condition in ["tracked", "submodules"]:
-            expected = (
+            expected = f'mv {yadm_dir.join("files.gpg")} ' f'{yadm_data.join("archive")}'
-                f'mv {yadm_dir.join("files.gpg")} '
-                f'{yadm_data.join("archive")}')
             assert expected in run.out
-            assert 'files tracked by yadm have been renamed' in run.out
+            assert "files tracked by yadm have been renamed" in run.out
-            if condition == 'submodules':
+            if condition == "submodules":
-                assert 'submodule deinit -- mymodule' in run.out
+                assert "submodule deinit -- mymodule" in run.out
-                assert 'submodule update --init --recursive -- mymodule' \
+                assert "submodule update --init --recursive -- mymodule" in run.out
-                    in run.out
             else:
-                assert 'submodule deinit' not in run.out
+                assert "submodule deinit" not in run.out
-                assert 'submodule update --init --recursive' not in run.out
+                assert "submodule update --init --recursive" not in run.out

test/test_unit_x_program.py

@@ -1,28 +1,30 @@
 """Unit tests: yadm.[git,gpg]-program"""
 
 import os
+
 import pytest
 
 
 @pytest.mark.parametrize(
-    'executable, success, value, match', [
+    "executable, success, value, match",
-        (None, True, 'program', None),
+    [
-        ('cat', True, 'cat', None),
+        (None, True, "program", None),
-        ('badprogram', False, None, 'badprogram'),
+        ("cat", True, "cat", None),
-    ], ids=[
+        ("badprogram", False, None, "badprogram"),
-        'executable missing',
+    ],
-        'valid alternative',
+    ids=[
-        'invalid alternative',
+        "executable missing",
-    ])
+        "valid alternative",
-@pytest.mark.parametrize('program', ['git', 'gpg'])
+        "invalid alternative",
-def test_x_program(
+    ],
-        runner, yadm_cmd, paths, program, executable, success, value, match):
+)
+@pytest.mark.parametrize("program", ["git", "gpg"])
+def test_x_program(runner, yadm_cmd, paths, program, executable, success, value, match):
     """Set yadm.X-program, and test result of require_X"""
 
     # set configuration
     if executable:
-        os.system(' '.join(yadm_cmd(
+        os.system(" ".join(yadm_cmd("config", f"yadm.{program}-program", executable)))
-            'config', f'yadm.{program}-program', executable)))
 
     # test require_[git,gpg]
     script = f"""
@@ -32,11 +34,11 @@ def test_x_program(
         require_{program}
         echo ${program.upper()}_PROGRAM
     """
-    run = runner(command=['bash'], inp=script)
+    run = runner(command=["bash"], inp=script)
     assert run.success == success
 
     # [GIT,GPG]_PROGRAM set correctly
-    if value == 'program':
+    if value == "program":
         assert run.out.rstrip() == program
     elif value:
         assert run.out.rstrip() == value
@@ -45,4 +47,4 @@ def test_x_program(
     if match:
         assert match in run.err
     else:
-        assert run.err == ''
+        assert run.err == ""

test/test_upgrade.py

@@ -1,129 +1,131 @@
 """Test upgrade"""
 
 import os
+
 import pytest
 
 
 @pytest.mark.parametrize(
-    'versions', [
+    "versions",
-        ('1.12.0', '2.5.0'),
+    [
-        ('1.12.0',),
+        ("1.12.0", "2.5.0"),
-        ('2.5.0',),
+        ("1.12.0",),
-    ], ids=[
+        ("2.5.0",),
-        '1.12.0 -> 2.5.0 -> latest',
+    ],
-        '1.12.0 -> latest',
+    ids=[
-        '2.5.0 -> latest',
+        "1.12.0 -> 2.5.0 -> latest",
-    ])
+        "1.12.0 -> latest",
-@pytest.mark.parametrize(
+        "2.5.0 -> latest",
-    'submodule', [False, True],
+    ],
-    ids=['no submodule', 'with submodules'])
+)
+@pytest.mark.parametrize("submodule", [False, True], ids=["no submodule", "with submodules"])
 def test_upgrade(tmpdir, runner, versions, submodule):
     """Upgrade tests"""
     # pylint: disable=too-many-statements
-    home = tmpdir.mkdir('HOME')
+    home = tmpdir.mkdir("HOME")
-    env = {'HOME': str(home)}
+    env = {"HOME": str(home)}
+    runner(["git", "config", "--global", "init.defaultBranch", "master"], env=env)
+    runner(["git", "config", "--global", "protocol.file.allow", "always"], env=env)
 
     if submodule:
-        ext_repo = tmpdir.mkdir('ext_repo')
+        ext_repo = tmpdir.mkdir("ext_repo")
-        ext_repo.join('afile').write('some data')
+        ext_repo.join("afile").write("some data")
 
-        for cmd in (('init',), ('add', 'afile'), ('commit', '-m', 'test')):
+        for cmd in (("init",), ("add", "afile"), ("commit", "-m", "test")):
-            run = runner(['git', '-C', str(ext_repo), *cmd])
+            run = runner(["git", "-C", str(ext_repo), *cmd])
             assert run.success
 
-    os.environ.pop('XDG_CONFIG_HOME', None)
+    os.environ.pop("XDG_CONFIG_HOME", None)
-    os.environ.pop('XDG_DATA_HOME', None)
+    os.environ.pop("XDG_DATA_HOME", None)
 
     def run_version(version, *args, check_stderr=True):
-        yadm = 'yadm-%s' % version if version else '/yadm/yadm'
+        yadm = f"yadm-{version}" if version else "/yadm/yadm"
         run = runner([yadm, *args], shell=True, cwd=str(home), env=env)
         assert run.success
         if check_stderr:
-            assert run.err == ''
+            assert run.err == ""
         return run
 
     # Initialize the repo with the first version
     first = versions[0]
-    run_version(first, 'init')
+    run_version(first, "init")
 
-    home.join('file').write('some data')
+    home.join("file").write("some data")
-    run_version(first, 'add', 'file')
+    run_version(first, "add", "file")
-    run_version(first, 'commit', '-m', '"First commit"')
+    run_version(first, "commit", "-m", '"First commit"')
 
     if submodule:
         # When upgrading via 2.5.0 we can't have a submodule that's been added
         # after being cloned as 2.5.0 fails the upgrade in that case.
-        can_upgrade_cloned_submodule = '2.5.0' not in versions[1:]
+        can_upgrade_cloned_submodule = "2.5.0" not in versions[1:]
         if can_upgrade_cloned_submodule:
             # Check out a repo and then add it as a submodule
-            run = runner(['git', '-C', str(home), 'clone', str(ext_repo), 'b'])
+            run = runner(["git", "-C", str(home), "clone", str(ext_repo), "b"])
             assert run.success
-            run_version(first, 'submodule', 'add', str(ext_repo), 'b')
+            run_version(first, "submodule", "add", str(ext_repo), "b")
 
         # Add submodule without first checking it out
-        run_version(first, 'submodule', 'add', str(ext_repo), 'a',
+        run_version(first, "submodule", "add", str(ext_repo), "a", check_stderr=False)
-                    check_stderr=False)
+        run_version(first, "submodule", "add", str(ext_repo), "c", check_stderr=False)
-        run_version(first, 'submodule', 'add', str(ext_repo), 'c',
-                    check_stderr=False)
 
-        run_version(first, 'commit', '-m', '"Add submodules"')
+        run_version(first, "commit", "-m", '"Add submodules"')
 
-    for path in ('.yadm', '.config/yadm'):
+    for path in (".yadm", ".config/yadm"):
         yadm_dir = home.join(path)
         if yadm_dir.exists():
             break
 
-    yadm_dir.join('bootstrap').write('init stuff')
+    yadm_dir.join("bootstrap").write("init stuff")
-    run_version(first, 'add', yadm_dir.join('bootstrap'))
+    run_version(first, "add", yadm_dir.join("bootstrap"))
-    run_version(first, 'commit', '-m', 'bootstrap')
+    run_version(first, "commit", "-m", "bootstrap")
 
-    yadm_dir.join('encrypt').write('secret')
+    yadm_dir.join("encrypt").write("secret")
 
-    hooks_dir = yadm_dir.mkdir('hooks')
+    hooks_dir = yadm_dir.mkdir("hooks")
-    hooks_dir.join('pre_status').write('status')
+    hooks_dir.join("pre_status").write("status")
-    hooks_dir.join('post_commit').write('commit')
+    hooks_dir.join("post_commit").write("commit")
 
-    run_version(first, 'config', 'local.class', 'test')
+    run_version(first, "config", "local.class", "test")
-    run_version(first, 'config', 'foo.bar', 'true')
+    run_version(first, "config", "foo.bar", "true")
 
     # Run upgrade with intermediate versions and latest
     latest = None
     for version in versions[1:] + (latest,):
-        run = run_version(version, 'upgrade', check_stderr=not submodule)
+        run = run_version(version, "upgrade", check_stderr=not submodule)
         if submodule:
             lines = run.err.splitlines()
             if can_upgrade_cloned_submodule:
-                assert 'Migrating git directory of' in lines[0]
+                assert "Migrating git directory of" in lines[0]
-                assert str(home.join('b/.git')) in lines[1]
+                assert str(home.join("b/.git")) in lines[1]
-                assert str(yadm_dir.join('repo.git/modules/b')) in lines[2]
+                assert str(yadm_dir.join("repo.git/modules/b")) in lines[2]
                 del lines[:3]
             for line in lines:
-                assert line.startswith('Submodule')
+                assert line.startswith("Submodule")
-                assert 'registered for path' in line
+                assert "registered for path" in line
 
     # Verify result for the final upgrade
-    run_version(latest, 'status')
+    run_version(latest, "status")
 
-    run = run_version(latest, 'show', 'HEAD:file')
+    run = run_version(latest, "show", "HEAD:file")
-    assert run.out == 'some data'
+    assert run.out == "some data"
 
     if submodule:
         if can_upgrade_cloned_submodule:
-            assert home.join('b/afile').read() == 'some data'
+            assert home.join("b/afile").read() == "some data"
-        assert home.join('a/afile').read() == 'some data'
+        assert home.join("a/afile").read() == "some data"
-        assert home.join('c/afile').read() == 'some data'
+        assert home.join("c/afile").read() == "some data"
 
-    yadm_dir = home.join('.config/yadm')
+    yadm_dir = home.join(".config/yadm")
 
-    assert yadm_dir.join('bootstrap').read() == 'init stuff'
+    assert yadm_dir.join("bootstrap").read() == "init stuff"
-    assert yadm_dir.join('encrypt').read() == 'secret'
+    assert yadm_dir.join("encrypt").read() == "secret"
 
-    hooks_dir = yadm_dir.join('hooks')
+    hooks_dir = yadm_dir.join("hooks")
-    assert hooks_dir.join('pre_status').read() == 'status'
+    assert hooks_dir.join("pre_status").read() == "status"
-    assert hooks_dir.join('post_commit').read() == 'commit'
+    assert hooks_dir.join("post_commit").read() == "commit"
 
-    run = run_version(latest, 'config', 'local.class')
+    run = run_version(latest, "config", "local.class")
-    assert run.out.rstrip() == 'test'
+    assert run.out.rstrip() == "test"
 
-    run = run_version(latest, 'config', 'foo.bar')
+    run = run_version(latest, "config", "foo.bar")
-    assert run.out.rstrip() == 'true'
+    assert run.out.rstrip() == "true"

test/test_version.py

@@ -1,38 +1,36 @@
 """Test version"""
 
 import re
+
 import pytest
 
 
-@pytest.fixture(scope='module')
+@pytest.fixture(scope="module")
 def expected_version(yadm):
     """
     Expected semantic version number. This is taken directly out of yadm,
     searching for the VERSION= string.
     """
-    yadm_version = re.findall(
+    with open(yadm, encoding="utf-8") as source_file:
-        r'VERSION=([^\n]+)',
+        yadm_version = re.findall(r"VERSION=([^\n]+)", source_file.read())
-        open(yadm).read())
     if yadm_version:
         return yadm_version[0]
-    pytest.fail(f'version not found in {yadm}')
+    pytest.fail(f"version not found in {yadm}")
-    return 'not found'
+    return "not found"
 
 
 def test_semantic_version(expected_version):
     """Version is semantic"""
     # semantic version conforms to MAJOR.MINOR.PATCH
-    assert re.search(r'^\d+\.\d+\.\d+$', expected_version), (
+    assert re.search(r"^\d+\.\d+\.\d+$", expected_version), "does not conform to MAJOR.MINOR.PATCH"
-        'does not conform to MAJOR.MINOR.PATCH')
 
 
-@pytest.mark.parametrize('cmd', ['--version', 'version'])
+@pytest.mark.parametrize("cmd", ["--version", "version"])
-def test_reported_version(
+def test_reported_version(runner, yadm_cmd, cmd, expected_version):
-        runner, yadm_cmd, cmd, expected_version):
     """Report correct version and bash/git versions"""
     run = runner(command=yadm_cmd(cmd))
     assert run.success
-    assert run.err == ''
+    assert run.err == ""
-    assert 'bash version' in run.out
+    assert "bash version" in run.out
-    assert 'git version' in run.out
+    assert "git version" in run.out
-    assert run.out.endswith(f'\nyadm version {expected_version}\n')
+    assert run.out.endswith(f"\nyadm version {expected_version}\n")

test/utils.py

@@ -3,38 +3,42 @@
 This module holds values/functions common to multiple tests.
 """
 
-import re
 import os
+import re
 
-ALT_FILE1 = 'test_alt'
+ALT_FILE1 = "test_alt"
-ALT_FILE2 = 'test alt/test alt'
+ALT_FILE2 = "test alt/test alt"
-ALT_DIR = 'test alt/test alt dir'
+ALT_DIR = "test alt/test alt dir"
 
 # Directory based alternates must have a tracked contained file.
 # This will be the test contained file name
-CONTAINED = 'contained_file'
+CONTAINED = "contained_file"
 
 # These variables are used for making include files which will be processed
 # within jinja templates
-INCLUDE_FILE = 'inc_file'
+INCLUDE_FILE = "inc_file"
-INCLUDE_DIRS = ['', 'test alt']
+INCLUDE_DIRS = ["", "test alt"]
-INCLUDE_CONTENT = '8780846c02e34c930d0afd127906668f'
+INCLUDE_CONTENT = "8780846c02e34c930d0afd127906668f"
 
 
 def set_local(paths, variable, value, add=False):
     """Set local override"""
     add = "--add" if add else ""
-    os.system(
+    os.system(f"GIT_DIR={str(paths.repo)} " f'git config --local {add} "local.{variable}" "{value}"')
-        f'GIT_DIR={str(paths.repo)} '
-        f'git config --local {add} "local.{variable}" "{value}"'
-    )
 
 
-def create_alt_files(paths, suffix,
+def create_alt_files(
-                     preserve=False, tracked=True,
+    paths,
-                     encrypt=False, exclude=False,
+    suffix,
-                     content=None, includefile=False,
+    preserve=False,
-                     yadm_alt=False, yadm_dir=None):
+    tracked=True,
+    encrypt=False,
+    exclude=False,
+    content=None,
+    includefile=False,
+    yadm_alt=False,
+    yadm_dir=None,
+):
     """Create new files, and add to the repo
 
     This is used for testing alternate files. In each case, a suffix is
@@ -42,7 +46,7 @@ def create_alt_files(paths, suffix,
     repo handling are dependent upon the function arguments.
     """
 
-    basepath = yadm_dir.join('alt') if yadm_alt else paths.work
+    basepath = yadm_dir.join("alt") if yadm_alt else paths.work
 
     if not preserve:
         for remove_path in (ALT_FILE1, ALT_FILE2, ALT_DIR):
@@ -60,28 +64,28 @@ def create_alt_files(paths, suffix,
     # Do not test directory support for jinja alternates
     test_paths = [new_file1, new_file2]
     test_names = [ALT_FILE1, ALT_FILE2]
-    if not re.match(r'##(t$|t\.|template|yadm)', suffix):
+    if not re.match(r"##(t$|t\.|template|yadm)", suffix):
         test_paths += [new_dir]
         test_names += [ALT_DIR]
 
     for test_path in test_paths:
         if content:
-            test_path.write('\n' + content, mode='a', ensure=True)
+            test_path.write("\n" + content, mode="a", ensure=True)
         assert test_path.exists()
 
     _create_includefiles(includefile, test_paths, basepath)
     _create_tracked(tracked, test_paths, paths)
 
-    prefix = '.config/yadm/alt/' if yadm_alt else ''
+    prefix = ".config/yadm/alt/" if yadm_alt else ""
     _create_encrypt(encrypt, test_names, suffix, paths, exclude, prefix)
 
 
 def parse_alt_output(output, linked=True):
     """Parse output of 'alt', and return list of linked files"""
-    regex = r'Creating (.+) from template (.+)$'
+    regex = r"Creating (.+) from template (.+)$"
     if linked:
-        regex = r'Linking (.+) to (.+)$'
+        regex = r"Linking (.+) to (.+)$"
-    parsed_list = dict()
+    parsed_list = {}
     for line in output.splitlines():
         match = re.match(regex, line)
         if match:
@@ -95,7 +99,7 @@ def parse_alt_output(output, linked=True):
 def _create_includefiles(includefile, test_paths, basepath):
     if includefile:
         for dpath in INCLUDE_DIRS:
-            incfile = basepath.join(dpath + '/' + INCLUDE_FILE)
+            incfile = basepath.join(dpath + "/" + INCLUDE_FILE)
             incfile.write(INCLUDE_CONTENT, ensure=True)
             test_paths += [incfile]
 
@@ -110,8 +114,6 @@ def _create_tracked(tracked, test_paths, paths):
 def _create_encrypt(encrypt, test_names, suffix, paths, exclude, prefix):
     if encrypt:
         for encrypt_name in test_names:
-            paths.encrypt.write(
+            paths.encrypt.write(f"{prefix + encrypt_name + suffix}\n", mode="a")
-                f'{prefix + encrypt_name + suffix}\n', mode='a')
             if exclude:
-                paths.encrypt.write(
+                paths.encrypt.write(f"!{prefix + encrypt_name + suffix}\n", mode="a")
-                    f'!{prefix + encrypt_name + suffix}\n', mode='a')

yadm

@@ -1,6 +1,6 @@
 #!/bin/sh
 # yadm - Yet Another Dotfiles Manager
-# Copyright (C) 2015-2023 Tim Byrne
+# Copyright (C) 2015-2024 Tim Byrne
 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,7 +21,7 @@ if [ -z "$BASH_VERSION" ]; then
   [ "$YADM_TEST" != 1 ] && exec bash "$0" "$@"
 fi
 
-VERSION=3.2.2
+VERSION=3.3.0
 
 YADM_WORK="$HOME"
 YADM_DIR=
@@ -289,18 +289,18 @@ function record_score() {
         # increase the index of any existing alt_template_cmds
         new_cmds=()
         for cmd_index in "${!alt_template_cmds[@]}"; do
-            new_cmds[$((cmd_index+1))]="${alt_template_cmds[$cmd_index]}"
+            new_cmds[cmd_index+1]="${alt_template_cmds[$cmd_index]}"
         done
         alt_template_cmds=()
         for cmd_index in "${!new_cmds[@]}"; do
-            alt_template_cmds[$cmd_index]="${new_cmds[$cmd_index]}"
+            alt_template_cmds[cmd_index]="${new_cmds[$cmd_index]}"
         done
     else
         alt_targets+=("$tgt")
         # set index to the last index (newly created one)
         for index in "${!alt_targets[@]}"; do :; done
         # and set its initial score to zero
-        alt_scores[$index]=0
+        alt_scores[index]=0
      fi
   fi
 
@@ -309,8 +309,8 @@ function record_score() {
 
   # record higher scoring sources
   if [ "$score" -gt "${alt_scores[$index]}" ]; then
-    alt_scores[$index]="$score"
+    alt_scores[index]="$score"
-    alt_sources[$index]="$src"
+    alt_sources[index]="$src"
   fi
 
 }
@@ -336,8 +336,8 @@ function record_template() {
   fi
 
   # record the template command, last one wins
-  alt_template_cmds[$index]="$cmd"
+  alt_template_cmds[index]="$cmd"
-  alt_sources[$index]="$src"
+  alt_sources[index]="$src"
 
 }
 
@@ -368,87 +368,114 @@ function template_default() {
   # the explicit "space + tab" character class used below is used because not
   # all versions of awk seem to support the POSIX character classes [[:blank:]]
   read -r -d '' awk_pgm << "EOF"
-# built-in default template processor
 BEGIN {
-  blank              = "[ 	]"
+  classes = ARGV[2]
-  c["class"]         = class
+  for (i = 3; i < ARGC; ++i) {
-  c["classes"]       = classes
+    classes = classes "\n" ARGV[i]
-  c["arch"]          = arch
+  }
-  c["os"]            = os
+  yadm["class"] = class
-  c["hostname"]      = host
+  yadm["classes"] = classes
-  c["user"]          = user
+  yadm["arch"] = arch
-  c["distro"]        = distro
+  yadm["os"] = os
-  c["distro_family"] = distro_family
+  yadm["hostname"] = host
-  c["source"]        = source
+  yadm["user"] = user
-  ifs                = "^{%" blank "*if"
+  yadm["distro"] = distro
-  els                = "^{%" blank "*else" blank "*%}$"
+  yadm["distro_family"] = distro_family
-  end                = "^{%" blank "*endif" blank "*%}$"
+  yadm["source"] = source
-  skp                = "^{%" blank "*(if|else|endif)"
-  vld                = conditions()
-  inc_start          = "^{%" blank "*include" blank "+\"?"
-  inc_end            = "\"?" blank "*%}$"
-  inc                = inc_start ".+" inc_end
-  prt                = 1
-  err                = 0
-}
-END { exit err }
-{ replace_vars() } # variable replacements
-$0 ~ vld, $0 ~ end {
-  if ($0 ~ vld || $0 ~ end) prt=1;
-  if ($0 ~ els) prt=0;
-  if ($0 ~ skp) next;
-}
-($0 ~ ifs && $0 !~ vld), $0 ~ end {
-  if ($0 ~ ifs && $0 !~ vld) prt=0;
-  if ($0 ~ els || $0 ~ end) prt=1;
-  if ($0 ~ skp) next;
-}
-{ if (!prt) next }
-$0 ~ inc {
-  file = $0
-  sub(inc_start, "", file)
-  sub(inc_end, "", file)
-  sub(/^[^\/].*$/, source_dir "/&", file)
 
-  while ((res = getline <file) > 0) {
+  VARIABLE = "(env|yadm)\\.[a-zA-Z0-9_]+"
-    replace_vars()
+
-    print
+  current = 0
+  filename[current] = ARGV[1]
+  line[current] = 0
+
+  level = 0
+  skip[level] = 0
+
+  for (; current >= 0; --current) {
+    while ((res = getline <filename[current]) > 0) {
+      ++line[current]
+      if ($0 ~ "^[ \t]*\\{%[ \t]*if[ \t]+" VARIABLE "[ \t]*[!=]=[ \t]*\".*\"[ \t]*%\\}$") {
+        if (skip[level]) { skip[++level] = 1; continue }
+
+        match($0, VARIABLE)
+        lhs = substr($0, RSTART, RLENGTH)
+        match($0, /[!=]=/)
+        op = substr($0, RSTART, RLENGTH)
+        match($0, /".*"/)
+        rhs = replace_vars(substr($0, RSTART + 1, RLENGTH - 2))
+
+        if (lhs == "yadm.class") {
+          lhs = "not" rhs
+          split(classes, cls_array, "\n")
+          for (idx in cls_array) {
+            if (rhs == cls_array[idx]) { lhs = rhs; break }
+          }
+        }
+        else {
+          lhs = replace_vars("{{" lhs "}}")
+        }
+
+        if (op == "==") { skip[++level] = lhs != rhs }
+        else { skip[++level] = lhs == rhs }
+      }
+      else if (/^[ \t]*\{%[ \t]*else[ \t]*%\}$/) {
+        if (level == 0 || skip[level] < 0) { error("else without matching if") }
+        skip[level] = skip[level] ? skip[level - 1] : -1
+      }
+      else if (/^[ \t]*\{%[ \t]*endif[ \t]*%\}$/) {
+        if (--level < 0) { error("endif without matching if") }
+      }
+      else if (!skip[level]) {
+        $0 = replace_vars($0)
+        if (match($0, /^[ \t]*\{%[ \t]*include[ \t]+("[^"]+"|[^"]+)[ \t]*%\}$/)) {
+          include = $0
+          sub(/^[ \t]*\{%[ \t]*include[ \t]+"?/, "", include)
+          sub(/"?[ \t]*%\}$/, "", include)
+          if (index(include, "/") != 1) {
+            include = source_dir "/" include
+          }
+          filename[++current] = include
+          line[current] = 0
+        }
+        else { print }
+      }
+    }
+    if (res >= 0) { close(filename[current]) }
+    else if (current == 0) { error("could not read input file") }
+    else { --current; error("could not read include file '" filename[current + 1] "'") }
   }
-  if (res < 0) {
+  if (level > 0) {
-    printf "%s:%d: error: could not read '%s'\n", FILENAME, NR, file | "cat 1>&2"
+    current = 0
-    err = 1
+    error("unterminated if")
   }
-  close(file)
+  exit 0
-  next
 }
-{ print }
+function error(text) {
-function replace_vars() {
+  printf "%s:%d: error: %s\n",
-  for (label in c) {
+    filename[current], line[current], text > "/dev/stderr"
-    gsub(("{{" blank "*yadm\\." label blank "*}}"), c[label])
+  exit 1
-  }
-  for (label in ENVIRON) {
-    gsub(("{{" blank "*env\\." label blank "*}}"), ENVIRON[label])
-  }
 }
-function condition_helper(label, value) {
+function replace_vars(input) {
-  gsub(/[\\.^$(){}\[\]|*+?]/, "\\\\&", value)
+  output = ""
-  return sprintf("yadm\\.%s" blank "*==" blank "*\"%s\"", label, value)
+  while (match(input, "\\{\\{[ \t]*" VARIABLE "[ \t]*\\}\\}")) {
-}
+    if (RSTART > 1) {
-function conditions() {
+      output = output substr(input, 0, RSTART - 1)
-  pattern = ifs blank "+("
+    }
-  for (label in c) {
+    data = substr(input, RSTART + 2, RLENGTH - 4)
-    if (label != "class") {
+    input = substr(input, RSTART + RLENGTH)
-      value = c[label]
+
-      pattern = sprintf("%s%s|", pattern, condition_helper(label, value));
+    gsub(/[ \t]+/, "", data)
+    split(data, fields, /\./)
+
+    if (fields[1] == "env") {
+      output = output ENVIRON[fields[2]]
+    }
+    else {
+      output = output yadm[fields[2]]
     }
   }
-  split(classes, cls_array, "\n")
+  return output input
-  for (idx in cls_array) {
-    value = cls_array[idx]
-    pattern = sprintf("%s%s|", pattern, condition_helper("class", value));
-  }
-  sub(/\|$/, ")" blank "*%}$", pattern)
-  return pattern
 }
 EOF
 
@@ -462,9 +489,8 @@ EOF
     -v distro_family="$local_distro_family" \
     -v source="$input" \
     -v source_dir="$(dirname "$input")" \
-    -v classes="$(join_string $'\n' "${local_classes[@]}")" \
     "$awk_pgm" \
-    "$input" > "$temp_file" || rm -f "$temp_file"
+    "$input" "${local_classes[@]}" > "$temp_file" || rm -f "$temp_file"
 
   move_file "$input" "$output" "$temp_file"
 }

yadm.1

@@ -1,5 +1,5 @@
 .\" vim: set spell so=8:
-.TH yadm 1 "23 January 2023" "3.2.2"
+.TH yadm 1 "8 November 2024" "3.3.0"
 
 .SH NAME
 

yadm.md

@@ -1,6 +1,4 @@
 
-
-
 ## NAME
        yadm - Yet Another Dotfiles Manager
 
@@ -56,17 +54,17 @@
               aged repository.  The working directory for Git commands will be
               the configured work-tree (usually $HOME).
 
-              Dotfiles are managed by using standard git commands;  add,  com‐
+              Dotfiles  are  managed by using standard git commands; add, com‐
               mit, push, pull, etc.
 
-              The  config command is not passed directly through.  Instead use
+              The config command is not passed directly through.  Instead  use
               the gitconfig command (see below).
 
-       alt    Create symbolic links and  process  templates  for  any  managed
+       alt    Create  symbolic  links  and  process  templates for any managed
-              files  matching the naming rules described in the ALTERNATES and
+              files matching the naming rules described in the ALTERNATES  and
-              TEMPLATES sections. It is usually unnecessary to run  this  com‐
+              TEMPLATES  sections.  It is usually unnecessary to run this com‐
-              mand,  as  yadm  automatically  processes alternates by default.
+              mand, as yadm automatically  processes  alternates  by  default.
-              This automatic behavior can be disabled by setting the  configu‐
+              This  automatic behavior can be disabled by setting the configu‐
               ration yadm.auto-alt to "false".
 
        bootstrap
@@ -82,12 +80,12 @@
 
               The repository is  stored  in  $HOME/.local/share/yadm/repo.git.
               By default, $HOME will be used as the work-tree, but this can be
-              overridden with the -w option.  yadm can be forced to  overwrite
+              overridden  with the -w option.  yadm can be forced to overwrite
-              an  existing repository by providing the -f option.  If you want
+              an existing repository by providing the -f option.  If you  want
-              to use a branch other than the remote HEAD branch you can  spec‐
+              to  use a branch other than the remote HEAD branch you can spec‐
-              ify  it  using the -b option.  By default yadm will ask the user
+              ify it using the -b option.  By default yadm will ask  the  user
-              if the bootstrap program should be run (if it exists).  The  op‐
+              if  the  bootstrap program should be run (if it exists). The op‐
-              tions  --bootstrap or --no-bootstrap will either force the boot‐
+              tions --bootstrap or --no-bootstrap will either force the  boot‐
               strap to be run, or prevent it from being run, without prompting
               the user.
 
@@ -96,8 +94,8 @@
               section for more details.
 
        decrypt
-              Decrypt  all  files  stored  in $HOME/.local/share/yadm/archive.
+              Decrypt all  files  stored  in  $HOME/.local/share/yadm/archive.
-              Files decrypted will be relative  to  the  configured  work-tree
+              Files  decrypted  will  be  relative to the configured work-tree
               (usually $HOME).  Using the -l option will list the files stored
               without extracting them.
 
@@ -135,28 +133,28 @@
               use the yadm repository.
 
               git-crypt enables transparent encryption and decryption of files
-              in a git repository.  You can read  https://github.com/AGWA/git-
+              in  a git repository.  You can read https://github.com/AGWA/git-
               crypt for details.
 
        gitconfig
-              Pass  options to the git config command. Since yadm already uses
+              Pass options to the git config command. Since yadm already  uses
-              the config command to manage its own configurations,  this  com‐
+              the  config  command to manage its own configurations, this com‐
               mand is provided as a way to change configurations of the repos‐
               itory managed by yadm.  One useful case might  be  to  configure
               the  repository so untracked files are shown in status commands.
               yadm initially configures its repository so that untracked files
-              are  not  shown.   If  you wish use the default Git behavior (to
+              are not shown.  If you wish use the  default  Git  behavior  (to
-              show untracked files and directories), you can remove this  con‐
+              show  untracked files and directories), you can remove this con‐
               figuration.
 
                      yadm gitconfig --unset status.showUntrackedFiles
 
        help   Print a summary of yadm commands.
 
-       init   Initialize  a  new, empty repository for tracking dotfiles.  The
+       init   Initialize a new, empty repository for tracking  dotfiles.   The
-              repository is stored  in  $HOME/.local/share/yadm/repo.git.   By
+              repository  is  stored  in $HOME/.local/share/yadm/repo.git.  By
-              default,  $HOME  will  be used as the work-tree, but this can be
+              default, $HOME will be used as the work-tree, but  this  can  be
-              overridden with the -w option.  yadm can be forced to  overwrite
+              overridden  with the -w option.  yadm can be forced to overwrite
               an existing repository by providing the -f option.
 
        list   Print a list of files managed by yadm.  The -a option will cause
@@ -168,14 +166,14 @@
               configs, repo, and switches.  The purpose of introspection is to
               support command line completion.
 
-       perms  Update  permissions as described in the PERMISSIONS section.  It
+       perms  Update permissions as described in the PERMISSIONS section.   It
-              is usually unnecessary to run this command,  as  yadm  automati‐
+              is  usually  unnecessary  to run this command, as yadm automati‐
-              cally  processes permissions by default. This automatic behavior
+              cally processes permissions by default. This automatic  behavior
-              can be disabled by setting the configuration yadm.auto-perms  to
+              can  be disabled by setting the configuration yadm.auto-perms to
               "false".
 
        transcrypt options
-              If  transcrypt is installed, this command allows you to pass op‐
+              If transcrypt is installed, this command allows you to pass  op‐
               tions directly to transcrypt, with the environment configured to
               use the yadm repository.
 
@@ -187,16 +185,16 @@
               Version  3  of yadm uses a different directory for storing data.
               When you start to use version 3 for the first time, you may  see
               warnings about moving your data to this new directory.  The eas‐
-              iest way to accomplish this is by running "yadm upgrade".   This
+              iest  way to accomplish this is by running "yadm upgrade".  This
-              command  will  start  by  moving your yadm repo to the new path.
+              command will start by moving your yadm repo  to  the  new  path.
-              Next it will move any archive data.  If the archive  is  tracked
+              Next  it  will move any archive data.  If the archive is tracked
               within your yadm repo, this command will "stage" the renaming of
               that file in the repo's index.
 
               Upgrading will attempt to de-initialize and  re-initialize  your
               submodules. If your submodules cannot be de-initialized, the up‐
-              grade will fail. The most common reason submodules will fail  to
+              grade  will fail. The most common reason submodules will fail to
-              de-initialize  is  because they have local modifications. If you
+              de-initialize is because they have local modifications.  If  you
               are willing to lose the local modifications to those submodules,
               you  can  use  the -f option with the "upgrade" command to force
               the de-initialization.
@@ -213,20 +211,20 @@
 
 
 ## OPTIONS
-       yadm  supports a set of universal options that alter the paths it uses.
+       yadm supports a set of universal options that alter the paths it  uses.
-       The default paths are documented in the FILES section. Any path  speci‐
+       The  default paths are documented in the FILES section. Any path speci‐
-       fied  by  these  options must be fully qualified. If you always want to
+       fied by these options must be fully qualified. If you  always  want  to
-       override one or more of these paths, it may  be  useful  to  create  an
+       override  one  or  more  of  these paths, it may be useful to create an
-       alias  for the yadm command.  For example, the following alias could be
+       alias for the yadm command.  For example, the following alias could  be
        used to override the repository directory.
 
               alias yadm='yadm --yadm-repo /alternate/path/to/repo'
 
-       The following is the full  list  of  universal  options.   Each  option
+       The  following  is  the  full  list  of universal options.  Each option
        should be followed by a path.
 
        -Y,--yadm-dir
-              Override  the  yadm  directory.   yadm stores its configurations
+              Override the yadm directory.   yadm  stores  its  configurations
               relative to this directory.
 
        --yadm-data
@@ -291,40 +289,40 @@
               TION.
 
        yadm.git-program
-              Specify  an  alternate  program to use instead of "git".  By de‐
+              Specify an alternate program to use instead of  "git".   By  de‐
               fault, the first "git" found in $PATH is used.
 
        yadm.gpg-perms
-              Disable the permission changes to $HOME/.gnupg/*.  This  feature
+              Disable  the permission changes to $HOME/.gnupg/*.  This feature
               is enabled by default.
 
        yadm.gpg-program
-              Specify  an  alternate  program to use instead of "gpg".  By de‐
+              Specify an alternate program to use instead of  "gpg".   By  de‐
               fault, the first "gpg" found in $PATH is used.
 
        yadm.gpg-recipient
               Asymmetrically encrypt files with a gpg public/private key pair.
               Provide  a "key ID" to specify which public key to encrypt with.
               The key must exist in your public keyrings.  Multiple recipients
-              can  be  specified  (separated  by space).  If left blank or not
+              can be specified (separated by space).  If  left  blank  or  not
-              provided, symmetric encryption  is  used  instead.   If  set  to
+              provided,  symmetric  encryption  is  used  instead.   If set to
-              "ASK",  gpg  will interactively ask for recipients.  See the EN‐
+              "ASK", gpg will interactively ask for recipients.  See  the  EN‐
-              CRYPTION section for more details.  This feature is disabled  by
+              CRYPTION  section for more details.  This feature is disabled by
               default.
 
        yadm.openssl-ciphername
-              Specify  which  cipher should be used by openssl.  "aes-256-cbc"
+              Specify which cipher should be used by  openssl.   "aes-256-cbc"
               is used by default.
 
        yadm.openssl-old
-              Newer versions of openssl  support  the  pbkdf2  key  derivation
+              Newer  versions  of  openssl  support  the pbkdf2 key derivation
-              function.  This is used by default. If this configuration is set
+              function. This is used by default. If this configuration is  set
-              to "true", openssl operations will use options  compatible  with
+              to  "true",  openssl operations will use options compatible with
-              older  versions  of openssl. If you change this option, you will
+              older versions of openssl. If you change this option,  you  will
               need to recreate your encrypted archive.
 
        yadm.openssl-program
-              Specify an alternate program to use instead  of  "openssl".   By
+              Specify  an  alternate  program to use instead of "openssl".  By
               default, the first "openssl" found in $PATH is used.
 
        yadm.ssh-perms
@@ -343,11 +341,11 @@
               yadm config --add local.class <additional-class>
 
        local.arch
-              Override  the  architecture for the purpose of symlinking alter‐
+              Override the architecture for the purpose of  symlinking  alter‐
               nate files.
 
        local.hostname
-              Override the hostname for the purpose  of  symlinking  alternate
+              Override  the  hostname  for the purpose of symlinking alternate
               files.
 
        local.os
@@ -362,9 +360,9 @@
        to have an automated way of choosing an alternate version of a file for
        a different operating system, host, user, etc.
 
-       yadm  will automatically create a symbolic link to the appropriate ver‐
+       yadm will automatically create a symbolic link to the appropriate  ver‐
-       sion of a file, when a valid suffix is appended to  the  filename.  The
+       sion  of  a  file, when a valid suffix is appended to the filename. The
-       suffix  contains  the  conditions  that must be met for that file to be
+       suffix contains the conditions that must be met for  that  file  to  be
        used.
 
        The suffix begins with "##", followed by any number of conditions sepa‐
@@ -384,11 +382,11 @@
 
 
        template, t
-              Valid  when  the  value  matches a supported template processor.
+              Valid when the value matches  a  supported  template  processor.
               See the TEMPLATES section for more details.
 
        user, u
-              Valid if the value matches the current user.   Current  user  is
+              Valid  if  the  value matches the current user.  Current user is
               calculated by running id -u -n.
 
        hostname, h
@@ -407,14 +405,14 @@
               lease.
 
        distro_family, f
-              Valid  if the value matches the distro family.  Distro family is
+              Valid if the value matches the distro family.  Distro family  is
               calculated by inspecting the ID_LIKE line from /etc/os-release.
 
-       os, o  Valid if the value matches the OS.  OS is calculated by  running
+       os, o  Valid  if the value matches the OS.  OS is calculated by running
               uname -s.
 
        arch, a
-              Valid  if  the  value matches the architecture.  Architecture is
+              Valid if the value matches the  architecture.   Architecture  is
               calculated by running uname -m.
 
        default
@@ -423,16 +421,16 @@
        extension, e
               A special "condition" that doesn't affect the selection process.
               Its purpose is instead to allow the alternate file to end with a
-              certain extension to e.g. make  editors  highlight  the  content
+              certain  extension  to  e.g.  make editors highlight the content
               properly.
 
-       NOTE:  The  OS  for "Windows Subsystem for Linux" is reported as "WSL",
+       NOTE: The OS for "Windows Subsystem for Linux" is  reported  as  "WSL",
        even though uname identifies as "Linux".
 
-       You may use any number of conditions, in any order.  An alternate  will
+       You  may use any number of conditions, in any order.  An alternate will
-       only  be  used  if  ALL conditions are valid.  For all files managed by
+       only be used if ALL conditions are valid.  For  all  files  managed  by
-       yadm's repository or  listed  in  $HOME/.config/yadm/encrypt,  if  they
+       yadm's  repository  or  listed  in  $HOME/.config/yadm/encrypt, if they
-       match  this  naming  convention, symbolic links will be created for the
+       match this naming convention, symbolic links will be  created  for  the
        most appropriate version.
 
        The "most appropriate" version is determined by calculating a score for
@@ -491,12 +489,12 @@
        have at least one yadm managed file within them (at the top level).
 
        yadm will automatically create these links by default. This can be dis‐
-       abled  using  the yadm.auto-alt configuration.  Even if disabled, links
+       abled using the yadm.auto-alt configuration.  Even if  disabled,  links
        can be manually created by running yadm alt.
 
-       Class is a special value which is stored locally on each  host  (inside
+       Class  is  a special value which is stored locally on each host (inside
-       the  local repository). To use alternate symlinks using class, you must
+       the local repository). To use alternate symlinks using class, you  must
-       set the value of class using the configuration  local.class.   This  is
+       set  the  value  of class using the configuration local.class.  This is
        set like any other yadm configuration with the yadm config command. The
        following sets the class to be "Work".
 
@@ -515,11 +513,11 @@
        Supported template processors:
 
        default
-              This is yadm's built-in template processor.  This  processor  is
+              This  is  yadm's  built-in template processor. This processor is
-              very basic, with a Jinja-like syntax. The advantage of this pro‐
+              very basic, with a Jinja-like  syntax.  The  advantage  of  this
-              cessor is that it only depends upon awk, which is  available  on
+              processor  is  that it only depends upon awk, which is available
-              most  *nix  systems. To use this processor, specify the value of
+              on most *nix systems. To use this processor, specify  the  value
-              "default" or just leave the value off (e.g. "##template").
+              of "default" or just leave the value off (e.g. "##template").
 
        ESH    ESH is a template processor written in POSIX compliant shell. It
               allows  executing  shell  commands within templates. This can be
@@ -610,8 +608,8 @@
        It  can  be  useful to manage confidential files, like SSH or GPG keys,
        across multiple systems. However, doing so would put  plain  text  data
        into a Git repository, which often resides on a public system. yadm can
-       make it easy to encrypt and decrypt a set of  files  so  the  encrypted
+       make  it  easy  to  encrypt and decrypt a set of files so the encrypted
-       version  can  be  maintained  in the Git repository.  This feature will
+       version can be maintained in the Git  repository.   This  feature  will
        only work if a supported tool is available.  Both gpg(1) and openssl(1)
        are  supported.   gpg is used by default, but openssl can be configured
        with the yadm.cipher configuration.
@@ -624,7 +622,7 @@
                   .gnupg/*.gpg
 
        Standard filename expansions (*, ?, [) are supported.  If you have Bash
-       version  4,  you may use "**" to match all subdirectories.  Other shell
+       version 4, you may use "**" to match all subdirectories.   Other  shell
        expansions like brace and tilde are not supported.  Spaces in paths are
        supported,  and should not be quoted.  If a directory is specified, its
        contents will be included, but not recursively.  Paths beginning with a
@@ -637,13 +635,13 @@
        tory so they are available across multiple systems.
 
        To decrypt these files later, or on another system run yadm decrypt and
-       provide the correct password.  After files are  decrypted,  permissions
+       provide  the  correct password.  After files are decrypted, permissions
        are automatically updated as described in the PERMISSIONS section.
 
-       Symmetric  encryption is used by default, but asymmetric encryption may
+       Symmetric encryption is used by default, but asymmetric encryption  may
        be enabled using the yadm.gpg-recipient configuration.
 
-       NOTE: It is recommended that you use a private repository when  keeping
+       NOTE:  It is recommended that you use a private repository when keeping
        confidential files, even though they are encrypted.
 
        Patterns found in $HOME/.config/yadm/encrypt are automatically added to
@@ -653,10 +651,10 @@
 
        Using transcrypt or git-crypt
 
-       A completely separate option for encrypting data is to install and  use
+       A  completely separate option for encrypting data is to install and use
-       transcrypt  or  git-crypt.   Once installed, you can use these tools by
+       transcrypt or git-crypt.  Once installed, you can use  these  tools  by
-       running yadm transcrypt or yadm git-crypt.  These tools enables  trans‐
+       running  yadm transcrypt or yadm git-crypt.  These tools enables trans‐
-       parent  encryption and decryption of files in a git repository. See the
+       parent encryption and decryption of files in a git repository. See  the
        following web sites for more information:
 
        - https://github.com/elasticdog/transcrypt
@@ -664,9 +662,9 @@
        - https://github.com/AGWA/git-crypt
 
 ## PERMISSIONS
-       When files are checked out of a Git repository, their  initial  permis‐
+       When  files  are checked out of a Git repository, their initial permis‐
-       sions  are  dependent upon the user's umask. Because of this, yadm will
+       sions are dependent upon the user's umask. Because of this,  yadm  will
-       automatically update the permissions of some file  paths.  The  "group"
+       automatically  update  the  permissions of some file paths. The "group"
        and "others" permissions will be removed from the following files:
 
        - $HOME/.local/share/yadm/archive
@@ -696,21 +694,21 @@
 
 
 ## HOOKS
-       For every command yadm supports, a program can be provided to  run  be‐
+       For  every  command yadm supports, a program can be provided to run be‐
-       fore  or  after  that  command.  These are referred to as "hooks". yadm
+       fore or after that command. These are  referred  to  as  "hooks".  yadm
-       looks for hooks in the directory $HOME/.config/yadm/hooks.   Each  hook
+       looks  for  hooks in the directory $HOME/.config/yadm/hooks.  Each hook
        is named using a prefix of pre_ or post_, followed by the command which
        should trigger the hook. For example, to create a hook which is run af‐
        ter every yadm pull command, create a hook named post_pull.  Hooks must
        have the executable file permission set.
 
        If a pre_ hook is defined, and the hook terminates with a non-zero exit
-       status,  yadm  will  refuse  to run the yadm command. For example, if a
+       status, yadm will refuse to run the yadm command.  For  example,  if  a
-       pre_commit hook is defined, but that command ends with a non-zero  exit
+       pre_commit  hook is defined, but that command ends with a non-zero exit
-       status,  the  yadm commit will never be run. This allows one to "short-
+       status, the yadm commit will never be run. This allows one  to  "short-
        circuit" any operation using a pre_ hook.
 
-       Hooks have the following environment variables  available  to  them  at
+       Hooks  have  the  following  environment variables available to them at
        runtime:
 
        YADM_HOOK_COMMAND
@@ -732,10 +730,10 @@
 
 
 ## FILES
-       All  of  yadm's  configurations  are  relative to the "yadm directory".
+       All of yadm's configurations are  relative  to  the  "yadm  directory".
-       yadm uses the "XDG Base Directory Specification" to determine this  di‐
+       yadm  uses the "XDG Base Directory Specification" to determine this di‐
-       rectory.   If the environment variable $XDG_CONFIG_HOME is defined as a
+       rectory.  If the environment variable $XDG_CONFIG_HOME is defined as  a
-       fully qualified path, this  directory  will  be  $XDG_CONFIG_HOME/yadm.
+       fully  qualified  path,  this  directory will be $XDG_CONFIG_HOME/yadm.
        Otherwise it will be $HOME/.config/yadm.
 
        Similarly, yadm's data files are relative to the "yadm data directory".
@@ -744,7 +742,7 @@
        fully qualified path, this directory will be $XDG_DATA_HOME/yadm.  Oth‐
        erwise it will be $HOME/.local/share/yadm.
 
-       The  following  are the default paths yadm uses for its own data.  Most
+       The following are the default paths yadm uses for its own  data.   Most
        of these paths can be altered using universal options.  See the OPTIONS
        section for details.
 
@@ -753,16 +751,16 @@
               tive to this directory.
 
        $HOME/.local/share/yadm
-              The yadm data directory. By default, all  data  yadm  stores  is
+              The  yadm  data  directory.  By default, all data yadm stores is
               relative to this directory.
 
        $YADM_DIR/config
               Configuration file for yadm.
 
        $YADM_DIR/alt
-              This  is  a  directory  to keep "alternate files" without having
+              This is a directory to keep  "alternate  files"  without  having
-              them side-by-side with the resulting symlink or  processed  tem‐
+              them  side-by-side  with the resulting symlink or processed tem‐
-              plate.  Alternate files placed in this directory will be created
+              plate. Alternate files placed in this directory will be  created
               relative to $HOME instead.
 
        $YADM_DATA/repo.git
@@ -810,5 +808,3 @@
 
        https://yadm.io/
 
-
-

yadm.spec

@@ -1,7 +1,7 @@
 %{!?_pkgdocdir: %global _pkgdocdir %{_docdir}/%{name}-%{version}}
 Name: yadm
 Summary: Yet Another Dotfiles Manager
-Version: 3.2.2
+Version: 3.3.0
 Group: Development/Tools
 Release: 1%{?dist}
 URL: https://yadm.io