+         raise ValueError(evr_str)

+         middle = match.group("middle") or None

+ def get_package_builds(pkgname: str) -> List[dict]:

+ def main_sequential_builds_algo(package: str, dist: str):

+     for build in get_package_builds(package):

+         if dist in build["release"]:

+     print(f"Next build: {last_build['name']}-{last_build['version']}-{n_builds}.{dist}")

+         raise ValueError(f"Dist tag {dist!r} has wrong format (should be e.g. 'fc31', 'epel7')")

+     print(f"Calculated new release: {new_evr['release']}, EVR: {new_evr_str}")

+         main_sequential_builds_algo(args.package, args.dist)

+ import sys

+ from unittest import mock

+ 

+ import pytest

+ 

+ from rpmautospec import cli

+ 

+ 

+ class TestCli:

+     """Test the rpmautospec.cli module"""

+ 

+     @mock.patch.dict("rpmautospec.cli.subcmd_modules_by_name")

+     @mock.patch("argparse.ArgumentParser.exit")

+     def test_get_cli_args(self, argparse_exit, capsys):

+         """Test normal function of get_cli_args()"""

+         args = cli.get_cli_args(["--koji-url=https://192.0.2.1"])

+ 

+         # Verify the global argument passed in has an effect

+         assert args.koji_url == "https://192.0.2.1"

+ 

+         # Verify that the sub-command modules are registered

+         assert len(cli.subcmd_modules_by_name)

+ 

+         # We didn't pass a sub-command, it should print help then exit

+         stdout, stderr = capsys.readouterr()

+         assert not stdout

+         assert stderr

+         argparse_exit.assert_called_once()

+ 

+     @mock.patch.dict("rpmautospec.cli.subcmd_modules_by_name")

+     def test_get_cli_args_duplicate_subcmd(self):

+         """Test that sub-commands can't register under the same name"""

+         cli.subcmd_modules_by_name["generate-changelog"] = "dummy"

+ 

+         with pytest.raises(RuntimeError):

+             cli.get_cli_args([])

+ 

+     @mock.patch.object(sys, "argv")

+     @mock.patch("rpmautospec.cli.get_cli_args")

+     @mock.patch("argparse.ArgumentParser.exit")

+     @mock.patch.dict("rpmautospec.cli.subcmd_modules_by_name")

+     @pytest.mark.parametrize("has_subcmd", (True, False))

+     def test_main(self, argparse_exit, get_cli_args, sys_argv, has_subcmd):

+         """Test normal function of main()"""

+         sys_argv = ["boo"]  # noqa: F841

+         cli.subcmd_modules_by_name["a-subcommand"] = subcmd_module = mock.MagicMock()

+ 

+         args = mock.MagicMock()

+         if has_subcmd:

+             args.subcommand = "a-subcommand"

+         else:

+             args.subcommand = None

+         get_cli_args.return_value = args

+ 

+         cli.main()

+ 

+         if has_subcmd:

+             subcmd_module.main.assert_called_once_with(args)

+         else:

+             subcmd_module.main.assert_not_called()

+ import random

+ from unittest import mock

+ 

+ import pytest

+ 

+ from rpmautospec import misc

+ 

+ 

+ class TestMisc:

+     """Test the rpmautospec.misc module"""

+ 

+     builds_lower_higher = (

+         {"epoch": None, "version": "1.0", "release": "1"},

+         {"epoch": None, "version": "1.0", "release": "2"},

+         {"epoch": None, "version": "1.0", "release": "3"},

+         {"epoch": 1, "version": "0.1", "release": "1"},

+     )

+ 

+     evr_str_expected = {

+         "2:2.10.18-1.fc31": (2, "2.10.18", "1.fc31"),

+         "1.0-1.fc32": (0, "1.0", "1.fc32"),

+         "not:an:evr": ValueError,

+     }

+ 

+     tag_expected = {

+         "1": (1, None, None),

+         "1.fc31": (1, ".fc31", None),

+         "2.fc30.1": (2, ".fc30", 1),

+         "3.fc32.a": (3, ".fc32.a", None),

+         "not a valid release": (None, None, None),

+     }

+ 

+     def test_rpmvercmp_key(self):

+         """Test sorting with rpmvercmp_key"""

+         # Ensure we have a build that counts as "same".

+         builds_in_order = list(self.builds_lower_higher[:3] + self.builds_lower_higher[2:])

+ 

+         # Shuffle.

+         builds = random.sample(builds_in_order, len(builds_in_order))

+ 

+         assert sorted(builds, key=misc.rpmvercmp_key) == builds_in_order

+ 

+     @pytest.mark.parametrize("evr_str", evr_str_expected.keys())

+     def test_parse_evr(self, evr_str):

+         """Test the parse_evr() function"""

+         expected = self.evr_str_expected[evr_str]

+         if isinstance(expected, type) and issubclass(expected, Exception):

+             with pytest.raises(expected) as excinfo:

+                 misc.parse_evr(evr_str)

+             assert str(excinfo.value) == evr_str

+         else:

+             assert misc.parse_evr(evr_str) == expected

+ 

+     @pytest.mark.parametrize("tag", tag_expected.keys())

+     def test_parse_release_tag(self, tag):

+         """Test the parse_release_tag() function"""

+         expected = self.tag_expected[tag]

+         assert misc.parse_release_tag(tag) == expected

+ 

+     @mock.patch.object(misc, "_kojiclient", new=mock.MagicMock())

+     @mock.patch("rpmautospec.misc.koji.ClientSession")

+     def test_koji_init(self, client_session):

+         """Test the koji_init() function"""

+         client_session.return_value = "Boo!"

+         assert misc.koji_init("https://192.0.2.1") == "Boo!"

+         client_session.assert_called_once_with("https://192.0.2.1")

+         assert misc._kojiclient == "Boo!"

+ 

+     @pytest.mark.parametrize("phenomenon", ("normal", "kojiclient unset", "unknown package"))

+     @mock.patch("rpmautospec.misc._kojiclient")

+     def test_get_package_builds(self, kojiclient_global, phenomenon):

+         """Test the get_package_builds() function"""

+         getPackageID = kojiclient_global.getPackageID

+         listBuilds = kojiclient_global.listBuilds

+ 

+         if phenomenon == "kojiclient unset":

+             misc._kojiclient = None

+         elif phenomenon == "unknown package":

+             getPackageID.return_value = None

+         else:  # normal

+             getPackageID.return_value = 12345

+             listBuilds.return_value = expected = ["foo-1.0-1.fc31", "foo-0.9-1.fc30"]

+ 

+         if phenomenon == "kojiclient unset":

+             with pytest.raises(AssertionError):

+                 misc.get_package_builds("foo")

+         elif phenomenon == "unknown package":

+             with pytest.raises(ValueError):

+                 misc.get_package_builds("foo")

+         else:

+             result = misc.get_package_builds("foo")

+ 

+         if phenomenon == "kojiclient unset":

+             getPackageID.assert_not_called()

+         else:

+             getPackageID.assert_called_once_with("foo")

+ 

+         if phenomenon == "normal":

+             listBuilds.assert_called_once_with(12345, type="rpm", queryOpts={"order": "-nvr"})

+             assert result == expected

+         else:

+             listBuilds.assert_not_called()