ansible-core 2.17.4__py3-none-any.whl → 2.18.0b1__py3-none-any.whl

ansible_test/_internal/commands/sanity/pylint.py

@@ -43,7 +43,6 @@ from ...util import (
 
 from ...util_common import (
     run_command,
-    process_scoped_temporary_file,
 )
 
 from ...ansible_util import (
@@ -87,7 +86,7 @@ class PylintTest(SanitySingleVersion):
         return [target for target in targets if os.path.splitext(target.path)[1] == '.py' or is_subdir(target.path, 'bin')]
 
     def test(self, args: SanityConfig, targets: SanityTargets, python: PythonConfig) -> TestResult:
-        min_python_version_db_path = self.create_min_python_db(args, targets.targets)
+        target_paths = set(target.path for target in self.filter_remote_targets(list(targets.targets)))
 
         plugin_dir = os.path.join(SANITY_ROOT, 'pylint', 'plugins')
         plugin_names = sorted(p[0] for p in [
@@ -115,7 +114,13 @@ class PylintTest(SanitySingleVersion):
         def add_context(available_paths: set[str], context_name: str, context_filter: c.Callable[[str], bool]) -> None:
             """Add the specified context to the context list, consuming available paths that match the given context filter."""
             filtered_paths = set(p for p in available_paths if context_filter(p))
-            contexts.append((context_name, sorted(filtered_paths)))
+
+            if selected_paths := sorted(path for path in filtered_paths if path in target_paths):
+                contexts.append((context_name, True, selected_paths))
+
+            if selected_paths := sorted(path for path in filtered_paths if path not in target_paths):
+                contexts.append((context_name, False, selected_paths))
+
             available_paths -= filtered_paths
 
         def filter_path(path_filter: str = None) -> c.Callable[[str], bool]:
@@ -166,12 +171,12 @@ class PylintTest(SanitySingleVersion):
 
         test_start = datetime.datetime.now(tz=datetime.timezone.utc)
 
-        for context, context_paths in sorted(contexts):
+        for context, is_target, context_paths in sorted(contexts):
             if not context_paths:
                 continue
 
             context_start = datetime.datetime.now(tz=datetime.timezone.utc)
-            messages += self.pylint(args, context, context_paths, plugin_dir, plugin_names, python, collection_detail, min_python_version_db_path)
+            messages += self.pylint(args, context, is_target, context_paths, plugin_dir, plugin_names, python, collection_detail)
             context_end = datetime.datetime.now(tz=datetime.timezone.utc)
 
             context_times.append('%s: %d (%s)' % (context, len(context_paths), context_end - context_start))
@@ -202,32 +207,16 @@ class PylintTest(SanitySingleVersion):
 
         return SanitySuccess(self.name)
 
-    def create_min_python_db(self, args: SanityConfig, targets: t.Iterable[TestTarget]) -> str:
-        """Create a database of target file paths and their minimum required Python version, returning the path to the database."""
-        target_paths = set(target.path for target in self.filter_remote_targets(list(targets)))
-        controller_min_version = CONTROLLER_PYTHON_VERSIONS[0]
-        target_min_version = REMOTE_ONLY_PYTHON_VERSIONS[0]
-        min_python_versions = {
-            os.path.abspath(target.path): target_min_version if target.path in target_paths else controller_min_version for target in targets
-        }
-
-        min_python_version_db_path = process_scoped_temporary_file(args)
-
-        with open(min_python_version_db_path, 'w') as database_file:
-            json.dump(min_python_versions, database_file)
-
-        return min_python_version_db_path
-
     @staticmethod
     def pylint(
         args: SanityConfig,
         context: str,
+        is_target: bool,
         paths: list[str],
         plugin_dir: str,
         plugin_names: list[str],
         python: PythonConfig,
         collection_detail: CollectionDetail,
-        min_python_version_db_path: str,
     ) -> list[dict[str, str]]:
         """Run pylint using the config specified by the context on the specified paths."""
         rcfile = os.path.join(SANITY_ROOT, 'pylint', 'config', context.split('/')[0] + '.cfg')
@@ -249,6 +238,13 @@ class PylintTest(SanitySingleVersion):
         disable_plugins = set(i.strip() for i in config.get('disable-plugins', '').split(',') if i)
         load_plugins = set(plugin_names + ['pylint.extensions.mccabe']) - disable_plugins
 
+        if is_target:
+            context_label = 'target'
+            min_python_version = REMOTE_ONLY_PYTHON_VERSIONS[0]
+        else:
+            context_label = 'controller'
+            min_python_version = CONTROLLER_PYTHON_VERSIONS[0]
+
         cmd = [
             python.path,
             '-m', 'pylint',
@@ -259,7 +255,7 @@ class PylintTest(SanitySingleVersion):
             '--rcfile', rcfile,
             '--output-format', 'json',
             '--load-plugins', ','.join(sorted(load_plugins)),
-            '--min-python-version-db', min_python_version_db_path,
+            '--py-version', min_python_version,
         ] + paths  # fmt: skip
 
         if data_context().content.collection:
@@ -286,7 +282,7 @@ class PylintTest(SanitySingleVersion):
         env.update(PYLINTHOME=pylint_home)
 
         if paths:
-            display.info('Checking %d file(s) in context "%s" with config: %s' % (len(paths), context, rcfile), verbosity=1)
+            display.info(f'Checking {len(paths)} file(s) in context {context!r} ({context_label}) with config: {rcfile}', verbosity=1)
 
             try:
                 stdout, stderr = run_command(args, cmd, env=env, capture=True)

ansible_test/_internal/completion.py

@@ -246,6 +246,8 @@ class PosixRemoteCompletionConfig(RemoteCompletionConfig, PythonCompletionConfig
 class WindowsRemoteCompletionConfig(RemoteCompletionConfig):
     """Configuration for remote Windows platforms."""
 
+    connection: str = ''
+
 
 TCompletionConfig = t.TypeVar('TCompletionConfig', bound=CompletionConfig)
 

ansible_test/_internal/constants.py

@@ -37,7 +37,6 @@ SECCOMP_CHOICES = [
 ANSIBLE_BIN_SYMLINK_MAP = {
     'ansible': '../lib/ansible/cli/adhoc.py',
     'ansible-config': '../lib/ansible/cli/config.py',
-    'ansible-connection': '../lib/ansible/cli/scripts/ansible_connection_cli_stub.py',
     'ansible-console': '../lib/ansible/cli/console.py',
     'ansible-doc': '../lib/ansible/cli/doc.py',
     'ansible-galaxy': '../lib/ansible/cli/galaxy.py',

ansible_test/_internal/coverage_util.py

@@ -69,8 +69,7 @@ class CoverageVersion:
 
 COVERAGE_VERSIONS = (
     # IMPORTANT: Keep this in sync with the ansible-test.txt requirements file.
-    CoverageVersion('7.3.2', 7, (3, 8), (3, 12)),
-    CoverageVersion('6.5.0', 7, (3, 7), (3, 7)),
+    CoverageVersion('7.6.1', 7, (3, 8), (3, 13)),
 )
 """
 This tuple specifies the coverage version to use for Python version ranges.

ansible_test/_internal/docker_util.py

@@ -47,7 +47,7 @@ DOCKER_COMMANDS = [
     'podman',
 ]
 
-UTILITY_IMAGE = 'quay.io/ansible/ansible-test-utility-container:2.0.0'
+UTILITY_IMAGE = 'quay.io/ansible/ansible-test-utility-container:3.1.0'
 
 # Max number of open files in a docker container.
 # Passed with --ulimit option to the docker run command.

ansible_test/_internal/host_configs.py

@@ -399,10 +399,20 @@ class WindowsConfig(HostConfig, metaclass=abc.ABCMeta):
 class WindowsRemoteConfig(RemoteConfig, WindowsConfig):
     """Configuration for a remote Windows host."""
 
+    connection: t.Optional[str] = None
+
     def get_defaults(self, context: HostContext) -> WindowsRemoteCompletionConfig:
         """Return the default settings."""
         return filter_completion(windows_completion()).get(self.name) or windows_completion().get(self.platform)
 
+    def apply_defaults(self, context: HostContext, defaults: CompletionConfig) -> None:
+        """Apply default settings."""
+        assert isinstance(defaults, WindowsRemoteCompletionConfig)
+
+        super().apply_defaults(context, defaults)
+
+        self.connection = self.connection or defaults.connection
+
 
 @dataclasses.dataclass
 class WindowsInventoryConfig(InventoryConfig, WindowsConfig):

ansible_test/_internal/host_profiles.py

@@ -56,6 +56,7 @@ from .util import (
     InternalError,
     HostConnectionError,
     ANSIBLE_TEST_TARGET_ROOT,
+    WINDOWS_CONNECTION_VARIABLES,
 )
 
 from .util_common import (
@@ -1367,23 +1368,18 @@ class WindowsRemoteProfile(RemoteProfile[WindowsRemoteConfig]):
         connection = core_ci.connection
 
         variables: dict[str, t.Optional[t.Union[str, int]]] = dict(
-            ansible_connection='winrm',
-            ansible_pipelining='yes',
-            ansible_winrm_server_cert_validation='ignore',
             ansible_host=connection.hostname,
-            ansible_port=connection.port,
+            # ansible_port is intentionally not set using connection.port -- connection-specific variables can set this instead
             ansible_user=connection.username,
-            ansible_password=connection.password,
-            ansible_ssh_private_key_file=core_ci.ssh_key.key,
+            ansible_ssh_private_key_file=core_ci.ssh_key.key,  # required for scenarios which change the connection plugin to SSH
+            ansible_test_connection_password=connection.password,  # required for scenarios which change the connection plugin to require a password
         )
 
-        # HACK: force 2016 to use NTLM + HTTP message encryption
-        if self.config.version == '2016':
-            variables.update(
-                ansible_winrm_transport='ntlm',
-                ansible_winrm_scheme='http',
-                ansible_port='5985',
-            )
+        variables.update(ansible_connection=self.config.connection.split('+')[0])
+        variables.update(WINDOWS_CONNECTION_VARIABLES[self.config.connection])
+
+        if variables.pop('use_password'):
+            variables.update(ansible_password=connection.password)
 
         return variables
 

ansible_test/_internal/pypi_proxy.py

@@ -69,7 +69,7 @@ def run_pypi_proxy(args: EnvironmentConfig, targets_use_pypi: bool) -> None:
         display.warning('Unable to use the PyPI proxy because Docker is not available. Installation of packages using `pip` may fail.')
         return
 
-    image = 'quay.io/ansible/pypi-test-container:3.1.0'
+    image = 'quay.io/ansible/pypi-test-container:3.2.0'
     port = 3141
 
     run_support_container(

ansible_test/_internal/python_requirements.py

@@ -112,6 +112,8 @@ class PipBootstrap(PipCommand):
 
     pip_version: str
     packages: list[str]
+    setuptools: bool
+    wheel: bool
 
 
 # Entry Points
@@ -177,6 +179,8 @@ def collect_bootstrap(python: PythonConfig) -> list[PipCommand]:
     bootstrap = PipBootstrap(
         pip_version=pip_version,
         packages=packages,
+        setuptools=False,
+        wheel=False,
     )
 
     return [bootstrap]
@@ -218,17 +222,6 @@ def collect_requirements(
         # removing them reduces the size of environments cached in containers
         uninstall_packages = list(get_venv_packages(python))
 
-        if not minimize:
-            # installed packages may have run-time dependencies on setuptools
-            uninstall_packages.remove('setuptools')
-
-        # hack to allow the package-data sanity test to keep wheel in the venv
-        install_commands = [command for command in commands if isinstance(command, PipInstall)]
-        install_wheel = any(install.has_package('wheel') for install in install_commands)
-
-        if install_wheel:
-            uninstall_packages.remove('wheel')
-
         commands.extend(collect_uninstall(packages=uninstall_packages))
 
     return commands
@@ -412,9 +405,7 @@ def get_venv_packages(python: PythonConfig) -> dict[str, str]:
     #       See: https://github.com/ansible/base-test-container/blob/main/files/installer.py
 
     default_packages = dict(
-        pip='23.1.2',
-        setuptools='67.7.2',
-        wheel='0.37.1',
+        pip='24.2',
     )
 
     override_packages: dict[str, dict[str, str]] = {

ansible_test/_internal/timeout.py

@@ -118,7 +118,7 @@ def configure_test_timeout(args: TestConfig) -> None:
 
         raise TimeoutExpiredError(f'Tests aborted after exceeding the {timeout.duration} minute time limit.')
 
-    def timeout_waiter(timeout_seconds: int) -> None:
+    def timeout_waiter(timeout_seconds: float) -> None:
         """Background thread which will kill the current process if the timeout elapses."""
         time.sleep(timeout_seconds)
         os.kill(os.getpid(), signal.SIGUSR1)

ansible_test/_internal/util.py

@@ -134,6 +134,46 @@ class Architecture:
 REMOTE_ARCHITECTURES = list(value for key, value in Architecture.__dict__.items() if not key.startswith('__'))
 
 
+WINDOWS_CONNECTION_VARIABLES: dict[str, t.Any] = {
+    'psrp+http': dict(
+        ansible_port=5985,
+        ansible_psrp_protocol='http',
+        use_password=True,
+    ),
+    'psrp+https': dict(
+        ansible_port=5986,
+        ansible_psrp_protocol='https',
+        ansible_psrp_cert_validation='ignore',
+        use_password=True,
+    ),
+    'ssh+key': dict(
+        ansible_port=22,
+        ansible_shell_type='powershell',
+        use_password=False,
+    ),
+    'ssh+password': dict(
+        ansible_port=22,
+        ansible_shell_type='powershell',
+        use_password=True,
+    ),
+    'winrm+http': dict(
+        ansible_port=5985,
+        ansible_winrm_scheme='http',
+        ansible_winrm_transport='ntlm',
+        use_password=True,
+    ),
+    'winrm+https': dict(
+        ansible_port=5986,
+        ansible_winrm_scheme='https',
+        ansible_winrm_server_cert_validation='ignore',
+        use_password=True,
+    ),
+}
+"""Dictionary of Windows connection types and variables required to use them."""
+
+WINDOWS_CONNECTIONS = list(WINDOWS_CONNECTION_VARIABLES)
+
+
 def is_valid_identifier(value: str) -> bool:
     """Return True if the given value is a valid non-keyword Python identifier, otherwise return False."""
     return value.isidentifier() and not keyword.iskeyword(value)

ansible_test/_internal/util_common.py

@@ -269,7 +269,10 @@ def named_temporary_file(args: CommonConfig, prefix: str, suffix: str, directory
             tempfile_fd.write(to_bytes(content))
             tempfile_fd.flush()
 
-            yield tempfile_fd.name
+            try:
+                yield tempfile_fd.name
+            finally:
+                pass
 
 
 def write_json_test_results(
@@ -300,6 +303,7 @@ def get_injector_path() -> str:
     injector_names = sorted(list(ANSIBLE_BIN_SYMLINK_MAP) + [
         'importer.py',
         'pytest',
+        'ansible_connection_cli_stub.py',
     ])
 
     scripts = (

ansible_test/_util/controller/sanity/code-smell/action-plugin-docs.json

@@ -7,7 +7,9 @@
         "plugins/action/"
     ],
     "extensions": [
-        ".py"
+        ".py",
+        ".yml",
+        ".yaml"
     ],
     "output": "path-message"
 }

ansible_test/_util/controller/sanity/code-smell/action-plugin-docs.py

@@ -28,13 +28,13 @@ def main():
             module_names.add(full_name)
 
     for path in paths:
-        full_name = get_full_name(path, action_prefixes)
+        full_name = get_full_name(path, action_prefixes, extensions=('.py',))
 
         if full_name and full_name not in module_names:
             print('%s: action plugin has no matching module to provide documentation' % path)
 
 
-def get_full_name(path, prefixes):
+def get_full_name(path: str, prefixes: dict[str, bool], extensions: tuple[str] | None = None) -> str | None:
     """Return the full name of the plugin at the given path by matching against the given path prefixes, or None if no match is found."""
     for prefix, flat in prefixes.items():
         if path.startswith(prefix):
@@ -45,13 +45,16 @@ def get_full_name(path, prefixes):
             else:
                 full_name = relative_path
 
-            full_name = os.path.splitext(full_name)[0]
+            full_name, file_ext = os.path.splitext(full_name)
 
             name = os.path.basename(full_name)
 
             if name == '__init__':
                 return None
 
+            if extensions and file_ext not in extensions:
+                return None
+
             if name.startswith('_'):
                 name = name[1:]
 

ansible_test/_util/controller/sanity/code-smell/empty-init.json

@@ -1,9 +1,7 @@
 {
     "prefixes": [
         "lib/ansible/modules/",
-        "lib/ansible/module_utils/",
         "plugins/modules/",
-        "plugins/module_utils/",
         "test/units/",
         "tests/unit/"
     ],

ansible_test/_util/controller/sanity/pylint/config/collection.cfg

@@ -69,6 +69,7 @@ disable=
     pointless-statement,
     pointless-string-statement,
     possibly-unused-variable,
+    possibly-used-before-assignment,
     protected-access,
     raise-missing-from,  # Python 2.x does not support raise from
     redefined-argument-from-local,

ansible_test/_util/controller/sanity/pylint/config/default.cfg

@@ -63,6 +63,7 @@ disable=
     not-an-iterable,
     not-callable,
     possibly-unused-variable,
+    possibly-used-before-assignment,
     protected-access,
     raise-missing-from,  # Python 2.x does not support raise from
     redefined-argument-from-local,

ansible_test/_util/controller/sanity/pylint/plugins/deprecated.py

@@ -5,8 +5,6 @@
 from __future__ import annotations
 
 import datetime
-import functools
-import json
 import re
 import shlex
 import typing as t
@@ -326,15 +324,6 @@ class AnsibleDeprecatedCommentChecker(BaseTokenChecker):
                   {'minversion': (2, 6)}),
     }
 
-    options = (
-        ('min-python-version-db', {
-            'default': None,
-            'type': 'string',
-            'metavar': '<path>',
-            'help': 'The path to the DB mapping paths to minimum Python versions.',
-        }),
-    )
-
     def process_tokens(self, tokens: list[TokenInfo]) -> None:
         for token in tokens:
             if token.type == COMMENT:
@@ -365,15 +354,8 @@ class AnsibleDeprecatedCommentChecker(BaseTokenChecker):
             )
         return data
 
-    @functools.cached_property
-    def _min_python_version_db(self) -> dict[str, str]:
-        """A dictionary of absolute file paths and their minimum required Python version."""
-        with open(self.linter.config.min_python_version_db) as db_file:
-            return json.load(db_file)
-
     def _process_python_version(self, token: TokenInfo, data: dict[str, str]) -> None:
-        current_file = self.linter.current_file
-        check_version = self._min_python_version_db[current_file]
+        check_version = '.'.join(map(str, self.linter.config.py_version))
 
         try:
             if LooseVersion(data['python_version']) < LooseVersion(check_version):

ansible_test/_util/controller/sanity/shellcheck/exclude.txt

@@ -1,2 +1,3 @@
 SC1090
 SC1091
+SC2028

ansible_test/_util/controller/sanity/validate-modules/validate_modules/main.py

@@ -838,6 +838,46 @@ class ModuleValidator(Validator):
                 msg='%s: %s' % (combined_path, error_message)
             )
 
+    def _validate_option_docs(self, options, context=None):
+        if not isinstance(options, dict):
+            return
+        if context is None:
+            context = []
+
+        normalized_option_alias_names = dict()
+
+        def add_option_alias_name(name, option_name):
+            normalized_name = str(name).lower()
+            normalized_option_alias_names.setdefault(normalized_name, {}).setdefault(option_name, set()).add(name)
+
+        for option, data in options.items():
+            if 'suboptions' in data:
+                self._validate_option_docs(data.get('suboptions'), context + [option])
+            add_option_alias_name(option, option)
+            if 'aliases' in data and isinstance(data['aliases'], list):
+                for alias in data['aliases']:
+                    add_option_alias_name(alias, option)
+
+        for normalized_name, options in normalized_option_alias_names.items():
+            if len(options) < 2:
+                continue
+
+            what = []
+            for option_name, names in sorted(options.items()):
+                if option_name in names:
+                    what.append("option '%s'" % option_name)
+                else:
+                    what.append("alias '%s' of option '%s'" % (sorted(names)[0], option_name))
+            msg = "Multiple options/aliases"
+            if context:
+                msg += " found in %s" % " -> ".join(context)
+            msg += " are equal up to casing: %s" % ", ".join(what)
+            self.reporter.error(
+                path=self.object_path,
+                code='option-equal-up-to-casing',
+                msg=msg,
+            )
+
     def _validate_docs(self):
         doc = None
         # We have three ways of marking deprecated/removed files.  Have to check each one
@@ -1015,6 +1055,9 @@ class ModuleValidator(Validator):
                     'invalid-documentation',
                 )
 
+            if doc:
+                self._validate_option_docs(doc.get('options'))
+
             self._validate_all_semantic_markup(doc, returns)
 
             if not self.collection:
@@ -1235,7 +1278,7 @@ class ModuleValidator(Validator):
                         self._validate_semantic_markup(entry.get(key))
 
         if isinstance(docs.get('deprecated'), dict):
-            for key in ('why', 'alternative'):
+            for key in ('why', 'alternative', 'alternatives'):
                 self._validate_semantic_markup(docs.get('deprecated').get(key))
 
         self._validate_semantic_markup_options(docs.get('options'))
@@ -1876,8 +1919,10 @@ class ModuleValidator(Validator):
             if len(doc_options_args) == 0:
                 # Undocumented arguments will be handled later (search for undocumented-parameter)
                 doc_options_arg = {}
+                doc_option_name = None
             else:
-                doc_options_arg = doc_options[doc_options_args[0]]
+                doc_option_name = doc_options_args[0]
+                doc_options_arg = doc_options[doc_option_name]
                 if len(doc_options_args) > 1:
                     msg = "Argument '%s' in argument_spec" % arg
                     if context:
@@ -1892,6 +1937,26 @@ class ModuleValidator(Validator):
                         msg=msg
                     )
 
+            all_aliases = set(aliases + [arg])
+            all_docs_aliases = set(
+                ([doc_option_name] if doc_option_name is not None else [])
+                +
+                (doc_options_arg['aliases'] if isinstance(doc_options_arg.get('aliases'), list) else [])
+            )
+            if all_docs_aliases and all_aliases != all_docs_aliases:
+                msg = "Argument '%s' in argument_spec" % arg
+                if context:
+                    msg += " found in %s" % " -> ".join(context)
+                msg += " has names %s, but its documentation has names %s" % (
+                    ", ".join([("'%s'" % alias) for alias in sorted(all_aliases)]),
+                    ", ".join([("'%s'" % alias) for alias in sorted(all_docs_aliases)])
+                )
+                self.reporter.error(
+                    path=self.object_path,
+                    code='parameter-documented-aliases-differ',
+                    msg=msg
+                )
+
             try:
                 doc_default = None
                 if 'default' in doc_options_arg and doc_options_arg['default'] is not None:

ansible_test/_util/controller/sanity/validate-modules/validate_modules/schema.py

@@ -84,6 +84,22 @@ def date(error_code=None):
     return Any(isodate, error_code=error_code)
 
 
+def require_only_one(keys):
+    def f(obj):
+        found = None
+        for k in obj.keys():
+            if k in keys:
+                if found is None:
+                    found = k
+                else:
+                    raise Invalid('Found conflicting keys, must contain only one of {}'.format(keys))
+        if found is None:
+            raise Invalid('Must contain one of {}'.format(keys))
+
+        return obj
+    return f
+
+
 # Roles can also be referenced by semantic markup
 _VALID_PLUGIN_TYPES = set(DOCUMENTABLE_PLUGINS + ('role', ))
 
@@ -568,7 +584,9 @@ def list_dict_option_schema(for_collection, plugin_type):
                     {
                         # This definition makes sure everything has the correct types/values
                         'why': doc_string,
-                        'alternatives': doc_string,
+                        # TODO: phase out either plural or singular, 'alt' is exclusive group
+                        Exclusive('alternative', 'alt'): doc_string,
+                        Exclusive('alternatives', 'alt'): doc_string,
                         # vod stands for 'version or date'; this is the name of the exclusive group
                         Exclusive('removed_at_date', 'vod'): date(),
                         Exclusive('version', 'vod'): version(for_collection),
@@ -577,7 +595,7 @@ def list_dict_option_schema(for_collection, plugin_type):
                     {
                         # This definition makes sure that everything we require is there
                         Required('why'): Any(*string_types),
-                        'alternatives': Any(*string_types),
+                        Required(Any('alternatives', 'alternative')): Any(*string_types),
                         Required(Any('removed_at_date', 'version')): Any(*string_types),
                         Required('collection_name'): Any(*string_types),
                     },
@@ -761,13 +779,16 @@ def return_schema(for_collection, plugin_type='module'):
 
 
 def deprecation_schema(for_collection):
+
     main_fields = {
         Required('why'): doc_string,
-        Required('alternative'): doc_string,
-        Required('removed_from_collection'): collection_name,
-        'removed': Any(True),
+        'alternative': doc_string,
+        'alternatives': doc_string,
     }
 
+    if for_collection:
+        main_fields.update({Required('removed_from_collection'): collection_name, 'removed': Any(True)})
+
     date_schema = {
         Required('removed_at_date'): date(),
     }
@@ -791,6 +812,7 @@ def deprecation_schema(for_collection):
     if for_collection:
         result = All(
             result,
+            require_only_one(['alternative', 'alternatives']),
             partial(check_removal_version,
                     version_field='removed_in',
                     collection_name_field='removed_from_collection',

ansible_test/_util/target/common/constants.py

@@ -5,13 +5,13 @@
 from __future__ import annotations
 
 REMOTE_ONLY_PYTHON_VERSIONS = (
-    '3.7',
     '3.8',
     '3.9',
+    '3.10',
 )
 
 CONTROLLER_PYTHON_VERSIONS = (
-    '3.10',
     '3.11',
     '3.12',
+    '3.13',
 )