def test_discover_lintables_git_verbose(
reset_env_var: str,
message_prefix: str,
monkeypatch: MonkeyPatch,
caplog: LogCaptureFixture,
) -> None:
"""Ensure that autodiscovery lookup failures are logged."""
options = cli.get_config(['-v'])
initialize_logger(options.verbosity)
monkeypatch.setenv(reset_env_var, '')
file_utils.discover_lintables(options)
assert any(m[2].startswith("Looking up for files")
for m in caplog.record_tuples)
assert any(m.startswith(message_prefix) for m in caplog.messages)
def test_discover_lintables_silent(is_in_git: bool, monkeypatch: MonkeyPatch,
capsys: CaptureFixture[str]) -> None:
"""Verify that no stderr output is displayed while discovering yaml files.
(when the verbosity is off, regardless of the Git or Git-repo presence)
Also checks expected number of files are detected.
"""
options = cli.get_config([])
test_dir = Path(__file__).resolve().parent
lint_path = test_dir / '..' / 'examples' / 'roles' / 'test-role'
if not is_in_git:
monkeypatch.setenv('GIT_DIR', '')
yaml_count = len(list(lint_path.glob('**/*.yml'))) + len(
list(lint_path.glob('**/*.yaml')))
monkeypatch.chdir(str(lint_path))
files = file_utils.discover_lintables(options)
stderr = capsys.readouterr().err
assert not stderr, 'No stderr output is expected when the verbosity is off'
assert (
len(files) == yaml_count
), "Expected to find {yaml_count} yaml files in {lint_path}".format_map(
locals(), )
def test_discover_lintables_umlaut(monkeypatch: MonkeyPatch) -> None:
"""Verify that filenames containing German umlauts are not garbled by the discover_lintables."""
options = cli.get_config([])
test_dir = Path(__file__).resolve().parent
lint_path = test_dir / '..' / 'examples' / 'playbooks'
monkeypatch.chdir(str(lint_path))
files = file_utils.discover_lintables(options)
assert '"with-umlaut-\\303\\244.yml"' not in files
assert 'with-umlaut-ä.yml' in files
def test_default_kinds(monkeypatch: MonkeyPatch, path: str,
kind: FileType) -> None:
"""Verify auto-detection logic based on DEFAULT_KINDS."""
options = cli.get_config([])
def mockreturn(options: Namespace) -> Dict[str, Any]:
return {path: kind}
# assert Lintable is able to determine file type
lintable_detected = Lintable(path)
lintable_expected = Lintable(path, kind=kind)
assert lintable_detected == lintable_expected
monkeypatch.setattr(file_utils, 'discover_lintables', mockreturn)
result = file_utils.discover_lintables(options)
# get_lintable could return additional files and we only care to see
# that the given file is among the returned list.
assert lintable_detected.name in result
assert lintable_detected.kind == result[lintable_expected.name]
def get_lintables(options: Namespace = Namespace(),
args: Optional[List[str]] = None) -> List[Lintable]:
"""Detect files and directories that are lintable."""
lintables: List[Lintable] = []
# passing args bypass auto-detection mode
if args:
for arg in args:
lintable = Lintable(arg)
if lintable.kind in ("yaml", None):
_logger.warning(
"Overriding detected file kind '%s' with 'playbook' "
"for given positional argument: %s",
lintable.kind,
arg,
)
lintable = Lintable(arg, kind="playbook")
lintables.append(lintable)
else:
for filename in discover_lintables(options):
p = Path(filename)
# skip exclusions
try:
for file_path in options.exclude_paths:
if str(p.resolve()).startswith(str(file_path)):
raise FileNotFoundError(
f'File {file_path} matched exclusion entry: {p}')
except FileNotFoundError as e:
_logger.debug('Ignored %s due to: %s', p, e)
continue
lintables.append(Lintable(p))
# stage 2: guess roles from current lintables, as there is no unique
# file that must be present in any kind of role.
_extend_with_roles(lintables)
return lintables