4110 lines
128 KiB
Python
4110 lines
128 KiB
Python
"""Remote generation behavior at the command-line and emitted-role seams."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
from click.testing import CliRunner
|
|
from jinja2 import Environment
|
|
from ruamel.yaml import YAML
|
|
from ssh_stub import legacy_source_session_bridge
|
|
|
|
from compose2role.cli import main
|
|
|
|
|
|
def _install_stub_command(bin_directory: Path, name: str, script: str) -> None:
|
|
command = bin_directory / name
|
|
if name == "ssh":
|
|
legacy_ssh = bin_directory / "ssh-legacy"
|
|
legacy_ssh.write_text(script, encoding="utf-8")
|
|
legacy_ssh.chmod(0o755)
|
|
command.write_text(legacy_source_session_bridge(legacy_ssh), encoding="utf-8")
|
|
command.chmod(0o755)
|
|
return
|
|
command.write_text(script, encoding="utf-8")
|
|
command.chmod(0o755)
|
|
|
|
|
|
def _encrypted_sops_output(*keys: str) -> str:
|
|
return "\n".join(
|
|
(
|
|
*(f"{key}: ENC[AES256_GCM,data:fixture]" for key in keys),
|
|
"sops:",
|
|
" mac: ENC[AES256_GCM,data:fixture]",
|
|
)
|
|
)
|
|
|
|
|
|
def _ansible_executable(name: str) -> str:
|
|
configured_bin = os.environ.get("COMPOSE2ROLE_ANSIBLE_BIN")
|
|
return str(Path(configured_bin) / name) if configured_bin else name
|
|
|
|
|
|
def _assert_generated_role_validates(
|
|
tmp_path: Path, output_directory: Path, role_name: str
|
|
) -> None:
|
|
"""Lint and syntax-check one generated role against the pinned collections."""
|
|
role_directory = output_directory / role_name
|
|
environment = {
|
|
**os.environ,
|
|
"ANSIBLE_COLLECTIONS_PATH": str(Path(__file__).parents[1] / "collections"),
|
|
"ANSIBLE_ROLES_PATH": str(output_directory),
|
|
}
|
|
lint_result = subprocess.run(
|
|
[
|
|
_ansible_executable("ansible-lint"),
|
|
"--exclude",
|
|
str(role_directory / "vars" / "secrets.sops.yml"),
|
|
str(role_directory),
|
|
],
|
|
check=False,
|
|
capture_output=True,
|
|
# ansible-lint treats the working directory as the project and skips an
|
|
# out-of-tree target, so lint from the roles directory, not the repository.
|
|
cwd=output_directory,
|
|
env=environment,
|
|
text=True,
|
|
)
|
|
assert lint_result.returncode == 0, lint_result.stdout + lint_result.stderr
|
|
playbook = tmp_path / "syntax-check.yml"
|
|
playbook.write_text(
|
|
f"""\
|
|
---
|
|
- name: Validate generated role syntax
|
|
hosts: localhost
|
|
connection: local
|
|
gather_facts: false
|
|
roles:
|
|
- {role_name}
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
syntax_result = subprocess.run(
|
|
[
|
|
_ansible_executable("ansible-playbook"),
|
|
"--inventory",
|
|
"localhost,",
|
|
"--connection",
|
|
"local",
|
|
"--syntax-check",
|
|
str(playbook),
|
|
],
|
|
check=False,
|
|
capture_output=True,
|
|
env=environment,
|
|
text=True,
|
|
)
|
|
assert syntax_result.returncode == 0, syntax_result.stdout + syntax_result.stderr
|
|
|
|
|
|
def _remote_environment(
|
|
tmp_path: Path, source_document: str, canonical_document: dict[str, object]
|
|
) -> tuple[dict[str, str], Path]:
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
config_path=${C2R_CONFIG_PATH:-/srv/my-app/compose.yaml}
|
|
printf '[{"Name":"my-app","Status":"running(1)","ConfigFiles":"%s"}]\\n' "$config_path"
|
|
exit 0
|
|
fi
|
|
|
|
case "$*" in
|
|
*"docker ps"*)
|
|
printf '%s' "${C2R_WORKING_DIRECTORY_LABEL:-}"
|
|
exit 0
|
|
;;
|
|
esac
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
case "$operation" in
|
|
capture)
|
|
printf '%s\\n' 'file 640 0 0'
|
|
printf '%s\\n' "$C2R_SOURCE_DOCUMENT"
|
|
;;
|
|
stat)
|
|
printf '%s\\n' missing
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*)
|
|
exit 97
|
|
;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(bin_directory, "sops", "#!/bin/sh\nexit 99\n")
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
return (
|
|
{
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_SOURCE_DOCUMENT": base64.b64encode(source_document.encode("utf-8")).decode(
|
|
"ascii"
|
|
),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
},
|
|
sops_config,
|
|
)
|
|
|
|
|
|
def test_generate_creates_a_secret_free_remote_role(tmp_path: Path) -> None:
|
|
"""A source-fidelity role adopts one remote Compose file in place."""
|
|
source_document = (
|
|
"# Preserve comments, quotes, ordering, and CRLF.\r\n"
|
|
"services:\r\n"
|
|
" web:\r\n"
|
|
" image: \"ghcr.io/example/web:1.2.3\"\r\n"
|
|
" ports:\r\n"
|
|
" - \"8080:80\"\r\n"
|
|
" environment:\r\n"
|
|
" LOG_LEVEL: info\r\n"
|
|
)
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"LOG_LEVEL": "info"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"ports": [{"target": 80, "published": "8080", "protocol": "tcp"}],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert result.output.splitlines() == [
|
|
"Discovering projects on web1...",
|
|
"✓ my-app -> my_app (generated)",
|
|
"",
|
|
"1 generated",
|
|
]
|
|
role_directory = output_directory / "my_app"
|
|
defaults = (role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
assert 'my_app_compose_project_name: "my-app"' in defaults
|
|
assert 'my_app_project_dir: "/srv/my-app"' in defaults
|
|
assert 'my_app_web_image: "ghcr.io/example/web"' in defaults
|
|
assert 'my_app_web_image_tag: "1.2.3"' in defaults
|
|
assert 'my_app_web_published_port: "8080"' in defaults
|
|
assert 'my_app_web_log_level: "info"' in defaults
|
|
compose_template = (
|
|
role_directory / "templates" / "compose.yaml.j2"
|
|
).read_bytes().decode("utf-8")
|
|
assert compose_template.startswith("# Preserve comments, quotes, ordering, and CRLF.\r\n")
|
|
assert 'image: "{{ my_app_web_image }}:{{ my_app_web_image_tag }}"' in compose_template
|
|
assert '"{{ my_app_web_published_port }}:80"' in compose_template
|
|
assert "LOG_LEVEL: {{ my_app_web_log_level }}" in compose_template
|
|
generated_defaults = YAML(typ="safe").load(defaults)
|
|
assert isinstance(generated_defaults, dict)
|
|
rendered_source = Environment(
|
|
keep_trailing_newline=True, newline_sequence="\r\n"
|
|
).from_string(compose_template).render(**generated_defaults)
|
|
assert rendered_source.encode("utf-8") == source_document.encode("utf-8")
|
|
tasks = (role_directory / "tasks" / "main.yml").read_text(encoding="utf-8")
|
|
assert 'project_name: "{{ my_app_compose_project_name }}"' in tasks
|
|
assert 'dest: "{{ my_app_project_dir }}/compose.yaml"' in tasks
|
|
assert 'src: "compose.yaml.j2"' in tasks
|
|
assert 'owner: "0"' in tasks
|
|
assert 'mode: "0640"' in tasks
|
|
assert 'newline_sequence: "\\r\\n"' in tasks
|
|
assert 'files:\n - "compose.yaml"' in tasks
|
|
assert "compose.yml.j2" not in tasks
|
|
assert "- name: \"Render compose.yaml\"\n tags:\n - source\n" in tasks
|
|
assert "- name: Deploy my_app Compose project\n tags:\n - compose\n" in tasks
|
|
assert not (role_directory / "templates" / "compose.yml.j2").exists()
|
|
assert not (role_directory / ".sops.yaml").exists()
|
|
assert not (role_directory / "vars" / "secrets.example.yml").exists()
|
|
assert not (role_directory / "vars" / "secrets.sops.yml").exists()
|
|
|
|
|
|
def test_generate_reports_a_byte_identical_remote_role_as_unchanged(tmp_path: Path) -> None:
|
|
"""Re-running remote generation against the same source is a no-op."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
LOG_LEVEL: info
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"LOG_LEVEL": "info"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
arguments = [
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
]
|
|
|
|
first = CliRunner().invoke(main, arguments, env=environment)
|
|
assert first.exit_code == 0, first.output
|
|
role_directory = output_directory / "my_app"
|
|
before = {
|
|
str(path.relative_to(role_directory)): path.read_bytes()
|
|
for path in sorted(role_directory.rglob("*"))
|
|
if path.is_file()
|
|
}
|
|
|
|
second = CliRunner().invoke(main, arguments, env=environment)
|
|
|
|
assert second.exit_code == 0, second.output
|
|
assert second.output.splitlines() == [
|
|
"Discovering projects on web1...",
|
|
"✓ my-app -> my_app (unchanged)",
|
|
"",
|
|
"1 unchanged",
|
|
]
|
|
after = {
|
|
str(path.relative_to(role_directory)): path.read_bytes()
|
|
for path in sorted(role_directory.rglob("*"))
|
|
if path.is_file()
|
|
}
|
|
assert after == before
|
|
assert not (output_directory / ".compose2role").exists()
|
|
|
|
json_result = CliRunner().invoke(main, [*arguments, "--format", "json"], env=environment)
|
|
assert json_result.exit_code == 0, json_result.output
|
|
assert json.loads(json_result.output)["projects"][0]["status"] == "unchanged"
|
|
|
|
|
|
def test_generate_remote_diff_reports_path_states_without_writing(tmp_path: Path) -> None:
|
|
"""Remote --diff reviews the rendered plan without writing role content."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
LOG_LEVEL: info
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"LOG_LEVEL": "info"},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
arguments = [
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
]
|
|
|
|
first = CliRunner().invoke(main, arguments, env=environment)
|
|
assert first.exit_code == 0, first.output
|
|
role_directory = output_directory / "my_app"
|
|
before = {
|
|
str(path.relative_to(role_directory)): path.read_bytes()
|
|
for path in sorted(role_directory.rglob("*"))
|
|
if path.is_file()
|
|
}
|
|
|
|
changed_source = source_document + " command: [\"serve\"]\n"
|
|
environment["C2R_SOURCE_DOCUMENT"] = base64.b64encode(
|
|
changed_source.encode("utf-8")
|
|
).decode("ascii")
|
|
environment["C2R_CANONICAL_DOCUMENT"] = json.dumps(
|
|
{
|
|
"services": {
|
|
"web": {
|
|
"command": ["serve"],
|
|
"environment": {"LOG_LEVEL": "info"},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
}
|
|
}
|
|
}
|
|
)
|
|
result = CliRunner().invoke(
|
|
main, [*arguments, "--diff", "--format", "json"], env=environment
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
payload = json.loads(result.output)
|
|
assert payload["projects"][0]["status"] == "diff"
|
|
diff = payload["projects"][0]["diff"]
|
|
assert ".compose2role.json" in diff["changed"]
|
|
assert "templates/compose.yaml.j2" in diff["withheld"]
|
|
assert "defaults/main.yml" in diff["unchanged"]
|
|
assert "1.2.3" not in json.dumps(diff)
|
|
after = {
|
|
str(path.relative_to(role_directory)): path.read_bytes()
|
|
for path in sorted(role_directory.rglob("*"))
|
|
if path.is_file()
|
|
}
|
|
assert after == before
|
|
assert not (output_directory / ".compose2role").exists()
|
|
|
|
|
|
def test_generate_hides_warning_findings_unless_verbose(tmp_path: Path) -> None:
|
|
"""Default text generation shows errors only; --verbose adds warnings."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
base_arguments = [
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--sops-config",
|
|
str(sops_config),
|
|
]
|
|
|
|
quiet = CliRunner().invoke(
|
|
main,
|
|
[*base_arguments, "--output", str(tmp_path / "quiet-roles")],
|
|
env=environment,
|
|
)
|
|
verbose = CliRunner().invoke(
|
|
main,
|
|
[*base_arguments, "--output", str(tmp_path / "verbose-roles"), "--verbose"],
|
|
env=environment,
|
|
)
|
|
|
|
assert quiet.exit_code == 0, quiet.output
|
|
assert "C2R001" not in quiet.output
|
|
assert "✓ my-app -> my_app (generated)" in quiet.output
|
|
assert verbose.exit_code == 0, verbose.output
|
|
assert "C2R001" in verbose.output
|
|
assert "WARNING" in verbose.output
|
|
|
|
|
|
def test_generate_uses_a_labeled_compose_project_directory_for_defaults_and_provenance(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""A valid container label supersedes the first Compose file's parent directory."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
**environment,
|
|
"C2R_CONFIG_PATH": "/srv/stacks/my-app/compose/compose.yaml",
|
|
"C2R_WORKING_DIRECTORY_LABEL": "my-app\t/srv/stacks/my-app\n",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
defaults = (role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
assert 'my_app_project_dir: "/srv/stacks/my-app"' in defaults
|
|
assert (role_directory / "templates" / "compose" / "compose.yaml.j2").is_file()
|
|
provenance = json.loads((role_directory / ".compose2role.json").read_text(encoding="utf-8"))
|
|
assert provenance["source"]["root"] == "/srv/stacks/my-app"
|
|
|
|
|
|
def test_generate_adopts_merge_keys_and_aliases_without_duplicate_edits(tmp_path: Path) -> None:
|
|
"""Inherited and aliased values stay literal while direct values remain configurable."""
|
|
source_document = """\
|
|
x-common: &common
|
|
image: &common_image ghcr.io/example/shared:1.2.3
|
|
ports: &common_ports
|
|
- &common_port "8080:80"
|
|
environment: &common_environment
|
|
LOG_LEVEL: &common_log info
|
|
services:
|
|
merged_one:
|
|
<<: *common
|
|
merged_two:
|
|
<<: *common
|
|
direct:
|
|
<<: *common
|
|
image: ghcr.io/example/direct:2.0.0
|
|
ports:
|
|
- "8081:81"
|
|
environment:
|
|
LOG_LEVEL: debug
|
|
aliases:
|
|
image: *common_image
|
|
ports: *common_ports
|
|
environment: *common_environment
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"aliases": {
|
|
"environment": {"LOG_LEVEL": "info"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/shared:1.2.3",
|
|
"ports": [{"target": 80, "published": "8080", "protocol": "tcp"}],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
},
|
|
"direct": {
|
|
"environment": {"LOG_LEVEL": "debug"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/direct:2.0.0",
|
|
"ports": [{"target": 81, "published": "8081", "protocol": "tcp"}],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
},
|
|
"merged_one": {
|
|
"environment": {"LOG_LEVEL": "info"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/shared:1.2.3",
|
|
"ports": [{"target": 80, "published": "8080", "protocol": "tcp"}],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
},
|
|
"merged_two": {
|
|
"environment": {"LOG_LEVEL": "info"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/shared:1.2.3",
|
|
"ports": [{"target": 80, "published": "8080", "protocol": "tcp"}],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
},
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
defaults = (role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
assert 'my_app_direct_image: "ghcr.io/example/direct"' in defaults
|
|
assert 'my_app_direct_image_tag: "2.0.0"' in defaults
|
|
assert 'my_app_direct_published_port: "8081"' in defaults
|
|
assert 'my_app_direct_log_level: "debug"' in defaults
|
|
assert "my_app_merged_one_" not in defaults
|
|
assert "my_app_merged_two_" not in defaults
|
|
assert "my_app_aliases_" not in defaults
|
|
compose_template = (role_directory / "templates" / "compose.yaml.j2").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert compose_template.count(" <<: *common\n") == 3
|
|
assert " image: &common_image ghcr.io/example/shared:1.2.3\n" in compose_template
|
|
assert ' - &common_port "8080:80"\n' in compose_template
|
|
assert " LOG_LEVEL: &common_log info\n" in compose_template
|
|
assert " image: *common_image\n" in compose_template
|
|
assert " ports: *common_ports\n" in compose_template
|
|
assert " environment: *common_environment\n" in compose_template
|
|
assert "image: {{ my_app_direct_image }}:{{ my_app_direct_image_tag }}" in compose_template
|
|
assert '"{{ my_app_direct_published_port }}:81"' in compose_template
|
|
assert "LOG_LEVEL: {{ my_app_direct_log_level }}" in compose_template
|
|
rendered_source = Environment(keep_trailing_newline=True).from_string(compose_template).render(
|
|
**YAML(typ="safe").load(defaults)
|
|
)
|
|
assert rendered_source.encode("utf-8") == source_document.encode("utf-8")
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"source_document_template",
|
|
(
|
|
"""\
|
|
x-common: &common
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
services:
|
|
web:
|
|
<<: *common
|
|
""",
|
|
"""\
|
|
x-common: &common
|
|
environment: &secret_environment
|
|
API_TOKEN: {secret_value}
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment: *secret_environment
|
|
""",
|
|
),
|
|
ids=("merge", "alias"),
|
|
)
|
|
def test_generate_rejects_secret_environment_without_direct_source_span(
|
|
tmp_path: Path, source_document_template: str
|
|
) -> None:
|
|
"""A secret without a direct source span never reaches a generated role."""
|
|
secret_value = "merged-secret-must-not-persist"
|
|
source_document = source_document_template.format(secret_value=secret_value)
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "remote Compose source has an unsupported secret environment" in result.output
|
|
assert secret_value not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_rejects_secret_inherited_by_a_partial_environment_override(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""A direct override cannot leave an inherited secret in the template."""
|
|
secret_value = "partial-override-secret-must-not-persist"
|
|
source_document = f"""\
|
|
x-common: &common
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
services:
|
|
web:
|
|
<<: *common
|
|
environment:
|
|
LOG_LEVEL: debug
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value, "LOG_LEVEL": "debug"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "remote Compose source has an unsupported secret environment" in result.output
|
|
assert secret_value not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_lifts_list_form_environment_secrets_without_plaintext(tmp_path: Path) -> None:
|
|
"""A classified list-form environment value is rendered from SOPS, not source plaintext."""
|
|
secret_value = "fixture-$1-secret"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
- LOG_LEVEL=info
|
|
- API_TOKEN={secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value, "LOG_LEVEL": "info"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' \"$C2R_SOPS_OUTPUT\"\n",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
**environment,
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output("my_app_web_api_token"),
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
generated_role_contents = b"".join(
|
|
path.read_bytes() for path in role_directory.rglob("*") if path.is_file()
|
|
)
|
|
assert secret_value.encode("utf-8") not in generated_role_contents
|
|
template = (role_directory / "templates" / "compose.yaml.j2").read_text(encoding="utf-8")
|
|
assert "- LOG_LEVEL={{ my_app_web_log_level }}" in template
|
|
assert "API_TOKEN={{ my_app_secrets['my_app_web_api_token'] }}" in template
|
|
tasks = (role_directory / "tasks" / "main.yml").read_text(encoding="utf-8")
|
|
assert "community.sops.load_vars:" in tasks
|
|
assert "- name: Load my_app SOPS secrets\n tags:\n - secrets\n" in tasks
|
|
defaults = (role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
assert 'my_app_web_log_level: "info"' in defaults
|
|
assert " - my_app_web_api_token" in defaults
|
|
rendered = Environment(keep_trailing_newline=True).from_string(template).render(
|
|
**YAML(typ="safe").load(defaults),
|
|
my_app_secrets={"my_app_web_api_token": secret_value},
|
|
)
|
|
assert rendered.encode("utf-8") == source_document.encode("utf-8")
|
|
|
|
|
|
def test_generate_lifts_a_quoted_secret_value_ending_in_a_backslash(tmp_path: Path) -> None:
|
|
"""A quoted secret ending in a literal backslash remains source-faithful."""
|
|
effective_secret_value = "fixture\\"
|
|
source_secret_value = r"fixture\\"
|
|
source_document = r"""services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: "fixture\\"
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": effective_secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
sops_payload = tmp_path / "sops-payload.json"
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\ncat > \"$C2R_SOPS_PAYLOAD\"\nprintf '%s\\n' \"$C2R_SOPS_OUTPUT\"\n",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
**environment,
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output("my_app_web_api_token"),
|
|
"C2R_SOPS_PAYLOAD": str(sops_payload),
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert json.loads(sops_payload.read_text(encoding="utf-8")) == {
|
|
"my_app_web_api_token": source_secret_value
|
|
}
|
|
role_directory = output_directory / "my_app"
|
|
generated_role_contents = b"".join(
|
|
path.read_bytes() for path in role_directory.rglob("*") if path.is_file()
|
|
)
|
|
assert source_secret_value.encode("utf-8") not in generated_role_contents
|
|
assert effective_secret_value.encode("utf-8") not in generated_role_contents
|
|
template = (role_directory / "templates" / "compose.yaml.j2").read_text(encoding="utf-8")
|
|
assert 'API_TOKEN: "{{ my_app_secrets[\'my_app_web_api_token\'] }}"' in template
|
|
defaults = YAML(typ="safe").load(
|
|
(role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
)
|
|
assert isinstance(defaults, dict)
|
|
rendered = Environment(keep_trailing_newline=True).from_string(template).render(
|
|
**defaults,
|
|
my_app_secrets={"my_app_web_api_token": source_secret_value},
|
|
)
|
|
assert rendered.encode("utf-8") == source_document.encode("utf-8")
|
|
|
|
|
|
def test_generate_preserves_plain_block_scalar_environment_values(tmp_path: Path) -> None:
|
|
"""An unparameterizable plain scalar stays literal instead of failing adoption."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
LOG_LEVEL: info
|
|
CONFIG_TEXT: >-
|
|
hello
|
|
world
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"CONFIG_TEXT": "hello world", "LOG_LEVEL": "info"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
template = (role_directory / "templates" / "compose.yaml.j2").read_text(encoding="utf-8")
|
|
assert "CONFIG_TEXT: >-\n hello\n world\n" in template
|
|
defaults = (role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
assert 'my_app_web_log_level: "info"' in defaults
|
|
assert "my_app_web_config_text" not in defaults
|
|
|
|
|
|
def test_generate_parameterizes_short_and_long_form_published_ports(tmp_path: Path) -> None:
|
|
"""Host-IP, protocol, and long-form port declarations retain their source and knob."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
ports:
|
|
- "127.0.0.1:8080:80/udp"
|
|
- target: 443
|
|
published: "8443"
|
|
protocol: tcp
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"ports": [
|
|
{"published": "8080", "target": 80, "protocol": "udp"},
|
|
{"published": "8443", "target": 443, "protocol": "tcp"},
|
|
],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
defaults = (role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
assert 'my_app_web_published_port_1: "8080"' in defaults
|
|
assert 'my_app_web_published_port_2: "8443"' in defaults
|
|
template = (role_directory / "templates" / "compose.yaml.j2").read_text(encoding="utf-8")
|
|
assert '"127.0.0.1:{{ my_app_web_published_port_1 }}:80/udp"' in template
|
|
assert 'published: "{{ my_app_web_published_port_2 }}"' in template
|
|
rendered = Environment(keep_trailing_newline=True).from_string(template).render(
|
|
**YAML(typ="safe").load(defaults)
|
|
)
|
|
assert rendered.encode("utf-8") == source_document.encode("utf-8")
|
|
|
|
|
|
def test_generated_role_adopts_a_matching_source_tree_without_changes(tmp_path: Path) -> None:
|
|
"""Matching source is idempotent and unsafe file-secret targets are refused."""
|
|
source_document = b"""\
|
|
# Existing source remains in place.
|
|
services:
|
|
web:
|
|
image: "ghcr.io/example/web:1.2.3"
|
|
secrets:
|
|
app_secret:
|
|
file: ./secrets/app.bin
|
|
"""
|
|
secret_bytes = b"\x00adopted-secret\n"
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"my-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/my-app/compose.yaml"}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
case "$path" in
|
|
/srv/my-app/compose.yaml)
|
|
printf 'file %s %s %s\\n' "$C2R_SOURCE_MODE" "$C2R_SOURCE_UID" "$C2R_SOURCE_GID"
|
|
printf '%s\\n' "$C2R_SOURCE_DOCUMENT"
|
|
;;
|
|
/srv/my-app/secrets/app.bin)
|
|
printf 'file 600 %s %s\\n' "$C2R_SECRET_UID" "$C2R_SECRET_GID"
|
|
printf '%s\\n' "$C2R_SECRET_SOURCE"
|
|
;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
stat)
|
|
case "$path" in
|
|
/srv/my-app/.env) printf '%s\\n' missing ;;
|
|
/srv/my-app/secrets/app.bin) printf '%s\\n' file ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*) exit 97 ;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' \"$C2R_SOPS_OUTPUT\"\n",
|
|
)
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_SECRET_GID": str(os.getgid()),
|
|
"C2R_SECRET_SOURCE": base64.b64encode(secret_bytes).decode("ascii"),
|
|
"C2R_SECRET_UID": str(os.getuid()),
|
|
"C2R_SOURCE_DOCUMENT": base64.b64encode(source_document).decode("ascii"),
|
|
"C2R_SOURCE_GID": str(os.getgid()),
|
|
"C2R_SOURCE_MODE": "640",
|
|
"C2R_SOURCE_UID": str(os.getuid()),
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output("my_app_secret_app_secret"),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
assert not (role_directory / "README.md").exists()
|
|
tasks = (role_directory / "tasks" / "main.yml").read_text(encoding="utf-8")
|
|
assert "my_app_secret_app_secret" in tasks
|
|
assert "secrets/app.bin" in tasks
|
|
source_tree = tmp_path / "matching-source"
|
|
source_tree.mkdir()
|
|
compose_file = source_tree / "compose.yaml"
|
|
compose_file.write_bytes(source_document)
|
|
compose_file.chmod(0o640)
|
|
secret_file = source_tree / "secrets" / "app.bin"
|
|
secret_file.parent.mkdir()
|
|
secret_file.write_bytes(secret_bytes)
|
|
secret_file.chmod(0o600)
|
|
original_checksum = hashlib.sha256(compose_file.read_bytes()).digest()
|
|
original_secret_checksum = hashlib.sha256(secret_file.read_bytes()).digest()
|
|
fake_collection_root = tmp_path / "fake-collections"
|
|
module_directory = (
|
|
fake_collection_root
|
|
/ "ansible_collections"
|
|
/ "community"
|
|
/ "docker"
|
|
/ "plugins"
|
|
/ "modules"
|
|
)
|
|
module_directory.mkdir(parents=True)
|
|
(module_directory / "docker_compose_v2.py").write_text(
|
|
"""\
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
|
|
module = AnsibleModule(
|
|
argument_spec={
|
|
"files": {"type": "list", "elements": "str", "required": True},
|
|
"project_name": {"type": "str", "required": True},
|
|
"project_src": {"type": "str", "required": True},
|
|
"pull": {"type": "str", "required": True},
|
|
"recreate": {"type": "str", "required": True},
|
|
"remove_orphans": {"type": "bool", "required": True},
|
|
"state": {"type": "str", "required": True},
|
|
}
|
|
)
|
|
if module.params["files"] != ["compose.yaml"] or module.params["project_name"] != "my-app":
|
|
module.fail_json(msg="unexpected source-fidelity Compose invocation")
|
|
module.exit_json(changed=False)
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
sops_action_directory = (
|
|
fake_collection_root
|
|
/ "ansible_collections"
|
|
/ "community"
|
|
/ "sops"
|
|
/ "plugins"
|
|
/ "action"
|
|
)
|
|
sops_action_directory.mkdir(parents=True)
|
|
(sops_action_directory / "load_vars.py").write_text(
|
|
"""\
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
|
|
from ansible.plugins.action import ActionBase
|
|
|
|
|
|
class ActionModule(ActionBase):
|
|
def run(self, tmp=None, task_vars=None):
|
|
result = super().run(tmp, task_vars)
|
|
result["ansible_facts"] = {
|
|
self._task.args["name"]: {
|
|
"my_app_secret_app_secret": os.environ["C2R_TEST_SECRET_BASE64"],
|
|
}
|
|
}
|
|
return result
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
playbook = tmp_path / "adopt.yml"
|
|
playbook.write_text(
|
|
f"""\
|
|
---
|
|
- name: Adopt a matching source tree
|
|
hosts: localhost
|
|
connection: local
|
|
gather_facts: false
|
|
vars:
|
|
my_app_project_dir: {json.dumps(str(source_tree))}
|
|
roles:
|
|
- my_app
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
configured_bin = os.environ.get("COMPOSE2ROLE_ANSIBLE_BIN")
|
|
ansible_playbook = (
|
|
str(Path(configured_bin) / "ansible-playbook") if configured_bin else "ansible-playbook"
|
|
)
|
|
validation_environment = {
|
|
**os.environ,
|
|
"ANSIBLE_COLLECTIONS_PATH": (
|
|
f"{fake_collection_root}:{Path(__file__).parents[1] / 'collections'}"
|
|
),
|
|
"ANSIBLE_ROLES_PATH": str(output_directory),
|
|
"C2R_TEST_SECRET_BASE64": base64.b64encode(secret_bytes).decode("ascii"),
|
|
}
|
|
for _ in range(2):
|
|
apply_result = subprocess.run(
|
|
[ansible_playbook, "--inventory", "localhost,", str(playbook)],
|
|
check=False,
|
|
capture_output=True,
|
|
env=validation_environment,
|
|
text=True,
|
|
)
|
|
assert apply_result.returncode == 0, apply_result.stdout + apply_result.stderr
|
|
assert "changed=0" in apply_result.stdout
|
|
assert hashlib.sha256(compose_file.read_bytes()).digest() == original_checksum
|
|
assert hashlib.sha256(secret_file.read_bytes()).digest() == original_secret_checksum
|
|
|
|
def apply_unsafe_target(project_directory: Path) -> subprocess.CompletedProcess[str]:
|
|
unsafe_playbook = tmp_path / f"{project_directory.name}.yml"
|
|
unsafe_playbook.write_text(
|
|
f"""\
|
|
---
|
|
- name: Refuse an unsafe file-secret target
|
|
hosts: localhost
|
|
connection: local
|
|
gather_facts: false
|
|
vars:
|
|
my_app_project_dir: {json.dumps(str(project_directory))}
|
|
roles:
|
|
- my_app
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
return subprocess.run(
|
|
[ansible_playbook, "--inventory", "localhost,", str(unsafe_playbook)],
|
|
check=False,
|
|
capture_output=True,
|
|
env=validation_environment,
|
|
text=True,
|
|
)
|
|
|
|
symlink_project = tmp_path / "symlink-target"
|
|
symlink_target = symlink_project / "secrets" / "app.bin"
|
|
symlink_target.parent.mkdir(parents=True)
|
|
outside_target = tmp_path / "outside-secret"
|
|
outside_target.write_bytes(b"outside-target")
|
|
symlink_target.symlink_to(outside_target)
|
|
symlink_result = apply_unsafe_target(symlink_project)
|
|
|
|
assert symlink_result.returncode != 0
|
|
assert outside_target.read_bytes() == b"outside-target"
|
|
assert base64.b64encode(secret_bytes).decode("ascii") not in (
|
|
symlink_result.stdout + symlink_result.stderr
|
|
)
|
|
|
|
directory_project = tmp_path / "directory-target"
|
|
directory_target = directory_project / "secrets" / "app.bin"
|
|
directory_target.mkdir(parents=True)
|
|
directory_result = apply_unsafe_target(directory_project)
|
|
|
|
assert directory_result.returncode != 0
|
|
assert not tuple(directory_target.iterdir())
|
|
assert base64.b64encode(secret_bytes).decode("ascii") not in (
|
|
directory_result.stdout + directory_result.stderr
|
|
)
|
|
|
|
|
|
def test_generate_preserves_external_compose_prerequisites(tmp_path: Path) -> None:
|
|
"""External config and secret declarations stay visible to the deployment operator."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
configs:
|
|
app_config:
|
|
external: true
|
|
secrets:
|
|
db_password:
|
|
external: true
|
|
"""
|
|
canonical_document = {
|
|
"configs": {"app_config": {"external": True, "name": "shared_config"}},
|
|
"secrets": {"db_password": {"external": True, "name": "shared_db_password"}},
|
|
"services": {
|
|
"web": {
|
|
"configs": [{"source": "app_config", "target": "/etc/app/config.yml"}],
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"secrets": [{"source": "db_password", "target": "db_password"}],
|
|
"user": "1000:1000",
|
|
}
|
|
},
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
compose_template = (role_directory / "templates" / "compose.yaml.j2").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert "app_config:" in compose_template
|
|
assert "db_password:" in compose_template
|
|
assert "external: true" in compose_template
|
|
assert not (role_directory / "README.md").exists()
|
|
assert (
|
|
" prerequisites: external config app_config, external secret db_password"
|
|
in result.output
|
|
)
|
|
|
|
|
|
def test_generate_adopts_dotenv_files_and_preserves_bind_mounts(tmp_path: Path) -> None:
|
|
"""Adoption templates approved dotenv inputs but never captures bind-mounted data."""
|
|
compose_source = """\
|
|
# Keep this hand-maintained bind declaration.
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
env_file: env/web.env
|
|
environment:
|
|
- LOG_LEVEL=${LOG_LEVEL}
|
|
- API_TOKEN=${APP_VALUE}
|
|
volumes:
|
|
- ${UPLOAD_LOCATION}:/var/lib/web
|
|
networks:
|
|
internal:
|
|
shared:
|
|
external: true
|
|
"""
|
|
root_dotenv = """\
|
|
# Keep dotenv comments and ordering.
|
|
LOG_LEVEL=info
|
|
APP_VALUE=fixture-dotenv-secret
|
|
UPLOAD_LOCATION=/srv/web-data
|
|
UNUSED_TOKEN=unused-secret-value
|
|
"""
|
|
service_dotenv = """\
|
|
DATABASE_URL=postgres://operator:dotenv-password@db.example/web
|
|
"""
|
|
canonical_document = {
|
|
"networks": {"internal": {}, "shared": {"external": True}},
|
|
"services": {
|
|
"web": {
|
|
"environment": {
|
|
"API_TOKEN": "fixture-dotenv-secret",
|
|
"DATABASE_URL": "postgres://operator:dotenv-password@db.example/web",
|
|
"LOG_LEVEL": "info",
|
|
},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
"volumes": [
|
|
{"source": "/srv/web-data", "target": "/var/lib/web", "type": "bind"}
|
|
],
|
|
}
|
|
},
|
|
}
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"my-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/my-app/docker-compose.yml"}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
printf '%s\\n' "$payload" >> "$C2R_PAYLOAD_LOG"
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
printf '%s\\n' 'file 640 1000 1001'
|
|
case "$path" in
|
|
/srv/my-app/docker-compose.yml) printf '%s\\n' "$C2R_COMPOSE_SOURCE" ;;
|
|
/srv/my-app/.env) printf '%s\\n' "$C2R_ROOT_DOTENV" ;;
|
|
/srv/my-app/env/web.env) printf '%s\\n' "$C2R_SERVICE_DOTENV" ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
stat)
|
|
case "$path" in
|
|
/srv/my-app/.env|/srv/my-app/env/web.env) printf '%s\\n' file ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*)
|
|
exit 97
|
|
;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"""\
|
|
#!/bin/sh
|
|
cat > "$C2R_SOPS_PAYLOAD"
|
|
cat <<'EOF'
|
|
sops:
|
|
mac: ENC[AES256_GCM,data:fixture]
|
|
my_app_dotenv_env_app_value: ENC[AES256_GCM,data:fixture]
|
|
my_app_dotenv_env_log_level: ENC[AES256_GCM,data:fixture]
|
|
my_app_dotenv_env_web_env_database_url: ENC[AES256_GCM,data:fixture]
|
|
EOF
|
|
""",
|
|
)
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
payload_log = tmp_path / "payloads"
|
|
sops_payload = tmp_path / "sops-payload.json"
|
|
secret_policy_path = tmp_path / "policy.toml"
|
|
secret_policy_path.write_text(
|
|
"""\
|
|
[[dotenv_rules]]
|
|
project = "my-app"
|
|
source = ".env"
|
|
key = "LOG_LEVEL"
|
|
decision = "secret"
|
|
|
|
[[dotenv_rules]]
|
|
project = "my-app"
|
|
source = ".env"
|
|
key = "UNUSED_TOKEN"
|
|
decision = "plain"
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--secret-policy",
|
|
str(secret_policy_path),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_COMPOSE_SOURCE": base64.b64encode(compose_source.encode("utf-8")).decode("ascii"),
|
|
"C2R_ROOT_DOTENV": base64.b64encode(root_dotenv.encode("utf-8")).decode("ascii"),
|
|
"C2R_SERVICE_DOTENV": base64.b64encode(service_dotenv.encode("utf-8")).decode(
|
|
"ascii"
|
|
),
|
|
"C2R_PAYLOAD_LOG": str(payload_log),
|
|
"C2R_SOPS_PAYLOAD": str(sops_payload),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert json.loads(sops_payload.read_text(encoding="utf-8")) == {
|
|
"my_app_dotenv_env_app_value": "fixture-dotenv-secret",
|
|
"my_app_dotenv_env_log_level": "info",
|
|
"my_app_dotenv_env_web_env_database_url": (
|
|
"postgres://operator:dotenv-password@db.example/web"
|
|
),
|
|
}
|
|
role_directory = output_directory / "my_app"
|
|
assert (role_directory / "templates" / "docker-compose.yml.j2").is_file()
|
|
assert (role_directory / "templates" / ".env.j2").is_file()
|
|
assert (role_directory / "templates" / "env" / "web.env.j2").is_file()
|
|
compose_template = (role_directory / "templates" / "docker-compose.yml.j2").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert "${UPLOAD_LOCATION}:/var/lib/web" in compose_template
|
|
assert "internal:" in compose_template
|
|
assert "external: true" in compose_template
|
|
defaults = (role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
assert "my_app_dotenv_env_app_value:" not in defaults
|
|
assert "my_app_dotenv_env_log_level:" not in defaults
|
|
assert 'my_app_dotenv_env_upload_location: "/srv/web-data"' in defaults
|
|
assert 'my_app_dotenv_env_unused_token: "unused-secret-value"' in defaults
|
|
assert "my_app_dotenv_env_web_env_database_url" in defaults
|
|
generated_role_contents = b"".join(
|
|
path.read_bytes() for path in role_directory.rglob("*") if path.is_file()
|
|
)
|
|
assert b"fixture-dotenv-secret" not in generated_role_contents
|
|
assert b"dotenv-password" not in generated_role_contents
|
|
payloads = payload_log.read_text(encoding="utf-8")
|
|
assert "capture\n/srv/my-app/docker-compose.yml" in payloads
|
|
assert "capture\n/srv/my-app/.env" in payloads
|
|
assert "capture\n/srv/my-app/env/web.env" in payloads
|
|
assert "/srv/web-data" not in payloads
|
|
|
|
|
|
def test_generate_adopts_ordered_multifile_source_tree(tmp_path: Path) -> None:
|
|
"""Ordered Compose files retain their relative layout and render their exact source bytes."""
|
|
primary_source = b"""\
|
|
# Primary Compose source.\r
|
|
services:\r
|
|
web:\r
|
|
image: \"ghcr.io/example/web:1.2.3\"\r
|
|
ports: !override\r
|
|
- "8080:80"\r
|
|
environment: !override\r
|
|
LOG_LEVEL: info\r
|
|
"""
|
|
override_source = b"""\
|
|
# Override source stays separate.
|
|
services:
|
|
web:
|
|
ports: !reset
|
|
- "9080:80"
|
|
environment: !reset
|
|
LOG_LEVEL: debug
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"LOG_LEVEL": "debug"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"ports": [{"target": 80, "published": "9080", "protocol": "tcp"}],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"my-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":["/srv/my-app/docker-compose.yml",'
|
|
printf '%s\\n' '"/srv/my-app/compose/override.yml"]}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
printf '%s\\n' "$payload" >> "$C2R_PAYLOAD_LOG"
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
printf '%s\\n' 'file 640 1000 1001'
|
|
case "$path" in
|
|
/srv/my-app/docker-compose.yml) printf '%s\\n' "$C2R_PRIMARY_SOURCE" ;;
|
|
/srv/my-app/compose/override.yml) printf '%s\\n' "$C2R_OVERRIDE_SOURCE" ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
stat)
|
|
[ "$path" = /srv/my-app/.env ] || exit 98
|
|
printf '%s\\n' missing
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*) exit 97 ;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(bin_directory, "sops", "#!/bin/sh\nexit 99\n")
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
payload_log = tmp_path / "payloads"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_OVERRIDE_SOURCE": base64.b64encode(override_source).decode("ascii"),
|
|
"C2R_PAYLOAD_LOG": str(payload_log),
|
|
"C2R_PRIMARY_SOURCE": base64.b64encode(primary_source).decode("ascii"),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
defaults = YAML(typ="safe").load(
|
|
(role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
)
|
|
assert isinstance(defaults, dict)
|
|
for relative_path, source, newline_sequence in (
|
|
("docker-compose.yml", primary_source, "\r\n"),
|
|
("compose/override.yml", override_source, "\n"),
|
|
):
|
|
template = (
|
|
role_directory / "templates" / f"{relative_path}.j2"
|
|
).read_bytes().decode("utf-8")
|
|
rendered = Environment(
|
|
keep_trailing_newline=True, newline_sequence=newline_sequence
|
|
).from_string(template).render(**defaults)
|
|
assert rendered.encode("utf-8") == source
|
|
tasks = (role_directory / "tasks" / "main.yml").read_text(encoding="utf-8")
|
|
assert 'files:\n - "docker-compose.yml"\n - "compose/override.yml"' in tasks
|
|
payloads = payload_log.read_text(encoding="utf-8")
|
|
assert payloads.index("capture\n/srv/my-app/docker-compose.yml") < payloads.index(
|
|
"capture\n/srv/my-app/compose/override.yml"
|
|
)
|
|
_assert_generated_role_validates(tmp_path, output_directory, "my_app")
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"source_document",
|
|
(
|
|
"""\
|
|
services:
|
|
web:
|
|
image: !override fixture-secret-value
|
|
""",
|
|
"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment: !unsupported
|
|
API_TOKEN: fixture-secret-value
|
|
""",
|
|
),
|
|
)
|
|
def test_generate_rejects_unsupported_yaml_tags(tmp_path: Path, source_document: str) -> None:
|
|
"""Only Compose reset and override collection tags are accepted from source."""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "remote Compose source has an unsupported YAML tag" in result.output
|
|
assert "fixture-secret-value" not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("primary_environment", "override_environment", "canonical_environment", "plain_value"),
|
|
(
|
|
(
|
|
" environment:\n DATABASE_URL: postgres://operator:fixture-source-secret@db/app\n",
|
|
" environment:\n DATABASE_URL: postgres://plain@db/app\n",
|
|
{"DATABASE_URL": "postgres://plain@db/app"},
|
|
"postgres://plain@db/app",
|
|
),
|
|
(
|
|
" environment:\n - DATABASE_URL=postgres://operator:fixture-source-secret@db/app\n",
|
|
" environment:\n - DATABASE_URL=postgres://plain@db/app\n",
|
|
{"DATABASE_URL": "postgres://plain@db/app"},
|
|
"postgres://plain@db/app",
|
|
),
|
|
(
|
|
" environment:\n DATABASE_URL: postgres://operator:fixture-source-secret@db/app\n",
|
|
" environment: !reset []\n",
|
|
{},
|
|
None,
|
|
),
|
|
),
|
|
ids=("mapping-override", "list-override", "reset-removed"),
|
|
)
|
|
def test_generate_classifies_each_multifile_environment_occurrence(
|
|
tmp_path: Path,
|
|
primary_environment: str,
|
|
override_environment: str,
|
|
canonical_environment: dict[str, str],
|
|
plain_value: str | None,
|
|
) -> None:
|
|
"""A source-only secret never becomes a plaintext default after an override."""
|
|
secret_value = "postgres://operator:fixture-source-secret@db/app"
|
|
source_identity = (
|
|
"compose:compose.yaml:web:environment-list:0:DATABASE_URL"
|
|
if "- DATABASE_URL" in primary_environment
|
|
else "compose:compose.yaml:web:environment:DATABASE_URL"
|
|
)
|
|
secret_key = "my_app_web_database_url"
|
|
if plain_value is not None:
|
|
source_digest = hashlib.sha256(source_identity.encode()).hexdigest()[:8]
|
|
secret_key = f"{secret_key}_{source_digest}"
|
|
primary_source = (
|
|
"services:\n"
|
|
" web:\n"
|
|
" image: ghcr.io/example/web:1.2.3\n"
|
|
f"{primary_environment}"
|
|
).encode()
|
|
override_source = (
|
|
"services:\n"
|
|
" web:\n"
|
|
f"{override_environment}"
|
|
).encode()
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": canonical_environment,
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"my-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":["/srv/my-app/compose.yaml",'
|
|
printf '%s\\n' '"/srv/my-app/compose.override.yaml"]}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
printf '%s\\n' 'file 640 1000 1001'
|
|
case "$path" in
|
|
/srv/my-app/compose.yaml) printf '%s\\n' "$C2R_PRIMARY_SOURCE" ;;
|
|
/srv/my-app/compose.override.yaml) printf '%s\\n' "$C2R_OVERRIDE_SOURCE" ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
stat)
|
|
[ "$path" = /srv/my-app/.env ] || exit 98
|
|
printf '%s\\n' missing
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*) exit 97 ;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' \"$C2R_SOPS_OUTPUT\"\n",
|
|
)
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_OVERRIDE_SOURCE": base64.b64encode(override_source).decode("ascii"),
|
|
"C2R_PRIMARY_SOURCE": base64.b64encode(primary_source).decode("ascii"),
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output(secret_key),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
generated_role_contents = b"".join(
|
|
path.read_bytes() for path in role_directory.rglob("*") if path.is_file()
|
|
)
|
|
assert secret_value.encode("utf-8") not in generated_role_contents
|
|
primary_template = (role_directory / "templates" / "compose.yaml.j2").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert "my_app_secrets[" in primary_template
|
|
defaults = (role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
if plain_value is not None:
|
|
assert plain_value in defaults
|
|
|
|
|
|
def test_generate_refuses_a_source_only_service_with_a_secret_environment(tmp_path: Path) -> None:
|
|
"""A service removed from the canonical model cannot leave a source secret literal behind."""
|
|
secret_value = "postgres://operator:source-only-secret@db/app"
|
|
source_document = f"""\
|
|
services:
|
|
stale:
|
|
image: ghcr.io/example/stale:1.2.3
|
|
environment:
|
|
DATABASE_URL: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "remote Compose source has an unsupported secret environment" in result.output
|
|
assert secret_value not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_refuses_an_unused_extension_anchor_with_a_secret_environment(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""A captured extension anchor cannot preserve a secret the role cannot parameterize."""
|
|
secret_value = "postgres://operator:unused-anchor-secret@db/app"
|
|
source_document = f"""\
|
|
x-common:
|
|
environment:
|
|
DATABASE_URL: {secret_value}
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "remote Compose source has an unsupported secret environment" in result.output
|
|
assert secret_value not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_refuses_file_backed_remote_configs(tmp_path: Path) -> None:
|
|
"""A role does not claim to carry a remote file-backed Compose config."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
configs:
|
|
app_config:
|
|
file: ./app.conf
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "C2R027: remote file-backed Compose configs are not supported" in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_imports_binary_file_backed_compose_secrets(tmp_path: Path) -> None:
|
|
"""A contained file secret is encrypted and restored at its original path and metadata."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
secrets:
|
|
app_secret:
|
|
file: ./secrets/app.bin
|
|
"""
|
|
secret_bytes = b"\x00binary\xffsecret\n"
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"my-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/my-app/docker-compose.yml"}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
case "$path" in
|
|
/srv/my-app/docker-compose.yml)
|
|
printf '%s\\n' 'file 640 1000 1001'
|
|
printf '%s\\n' "$C2R_COMPOSE_SOURCE"
|
|
;;
|
|
/srv/my-app/secrets/app.bin)
|
|
printf '%s\\n' 'file 600 1002 1003'
|
|
printf '%s\\n' "$C2R_SECRET_SOURCE"
|
|
;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
stat)
|
|
case "$path" in
|
|
/srv/my-app/.env) printf '%s\\n' missing ;;
|
|
/srv/my-app/secrets/app.bin) printf '%s\\n' file ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*) exit 97 ;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"""\
|
|
#!/bin/sh
|
|
payload=$(cat)
|
|
case "$payload" in
|
|
*"$C2R_EXPECTED_BASE64"*) ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
cat <<'EOF'
|
|
sops:
|
|
mac: ENC[AES256_GCM,data:fixture]
|
|
my_app_secret_app_secret: ENC[AES256_GCM,data:fixture]
|
|
EOF
|
|
""",
|
|
)
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_COMPOSE_SOURCE": base64.b64encode(source_document.encode("utf-8")).decode(
|
|
"ascii"
|
|
),
|
|
"C2R_EXPECTED_BASE64": base64.b64encode(secret_bytes).decode("ascii"),
|
|
"C2R_SECRET_SOURCE": base64.b64encode(secret_bytes).decode("ascii"),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
tasks = (role_directory / "tasks" / "main.yml").read_text(encoding="utf-8")
|
|
assert "my_app_secret_app_secret" in tasks
|
|
assert "secrets/app.bin" in tasks
|
|
assert 'mode: "0600"' in tasks
|
|
assert "base64 --decode" in tasks
|
|
assert "file: ./secrets/app.bin" in (
|
|
role_directory / "templates" / "docker-compose.yml.j2"
|
|
).read_text(encoding="utf-8")
|
|
generated_role_contents = b"".join(
|
|
path.read_bytes() for path in role_directory.rglob("*") if path.is_file()
|
|
)
|
|
assert secret_bytes not in generated_role_contents
|
|
assert base64.b64encode(secret_bytes) not in generated_role_contents
|
|
_assert_generated_role_validates(tmp_path, output_directory, "my_app")
|
|
|
|
|
|
def test_generate_accepts_empty_secrets_left_unencrypted_by_sops(tmp_path: Path) -> None:
|
|
"""SOPS leaves empty values plaintext; an empty secret carries nothing to protect."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: ""
|
|
secrets:
|
|
app_secret:
|
|
file: ./secrets/empty.bin
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": ""},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"my-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/my-app/docker-compose.yml"}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
case "$path" in
|
|
/srv/my-app/docker-compose.yml)
|
|
printf '%s\\n' 'file 640 1000 1001'
|
|
printf '%s\\n' "$C2R_COMPOSE_SOURCE"
|
|
;;
|
|
/srv/my-app/secrets/empty.bin)
|
|
printf '%s\\n' 'file 600 1002 1003'
|
|
printf '\\n'
|
|
;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
stat)
|
|
case "$path" in
|
|
/srv/my-app/.env) printf '%s\\n' missing ;;
|
|
/srv/my-app/secrets/empty.bin) printf '%s\\n' file ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*) exit 97 ;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"""\
|
|
#!/bin/sh
|
|
cat >/dev/null
|
|
cat <<'EOF'
|
|
sops:
|
|
mac: ENC[AES256_GCM,data:fixture]
|
|
my_app_secret_app_secret: ""
|
|
my_app_web_api_token: ""
|
|
EOF
|
|
""",
|
|
)
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_COMPOSE_SOURCE": base64.b64encode(source_document.encode("utf-8")).decode(
|
|
"ascii"
|
|
),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
secrets = (role_directory / "vars" / "secrets.sops.yml").read_text(encoding="utf-8")
|
|
assert 'my_app_secret_app_secret: ""' in secrets
|
|
assert 'my_app_web_api_token: ""' in secrets
|
|
tasks = (role_directory / "tasks" / "main.yml").read_text(encoding="utf-8")
|
|
assert "my_app_secret_app_secret" in tasks
|
|
assert "secrets/empty.bin" in tasks
|
|
assert "base64 --decode" in tasks
|
|
|
|
|
|
def test_generate_accepts_short_secrets_that_appear_inside_ciphertext(tmp_path: Path) -> None:
|
|
"""A plaintext value can coincide with ciphertext characters without a leak."""
|
|
secret_value = "x"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"""\
|
|
#!/bin/sh
|
|
cat >/dev/null
|
|
cat <<'EOF'
|
|
my_app_web_api_token: ENC[AES256_GCM,data:x==,iv:x==,tag:x==,type:str]
|
|
sops:
|
|
mac: ENC[AES256_GCM,data:x==]
|
|
EOF
|
|
""",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
secrets = (output_directory / "my_app" / "vars" / "secrets.sops.yml").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert "my_app_web_api_token: ENC[" in secrets
|
|
|
|
|
|
def test_generate_refuses_escaping_file_backed_compose_secret_paths(tmp_path: Path) -> None:
|
|
"""A secret input outside the project root fails without naming or copying it."""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
for name, reference in (
|
|
("parent", "../outside.txt"),
|
|
("absolute", "/etc/passwd"),
|
|
):
|
|
case_directory = tmp_path / name
|
|
case_directory.mkdir()
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
secrets:
|
|
app_secret:
|
|
file: {reference}
|
|
"""
|
|
environment, sops_config = _remote_environment(
|
|
case_directory, source_document, canonical_document
|
|
)
|
|
output_directory = case_directory / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "remote file-backed Compose secret path escapes the project root" in result.output
|
|
assert reference not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_disambiguates_colliding_file_secret_sops_keys(tmp_path: Path) -> None:
|
|
"""Colliding normalized Compose secret names receive stable distinct SOPS keys."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
secrets:
|
|
app-token:
|
|
file: ./secrets/first.bin
|
|
app_token:
|
|
file: ./secrets/second.bin
|
|
"""
|
|
first_secret = b"\x00first-secret\n"
|
|
second_secret = b"\xffsecond-secret\n"
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"my-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/my-app/compose.yaml"}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
case "$path" in
|
|
/srv/my-app/compose.yaml)
|
|
printf '%s\\n' 'file 640 0 0'
|
|
printf '%s\\n' "$C2R_COMPOSE_SOURCE"
|
|
;;
|
|
/srv/my-app/secrets/first.bin)
|
|
printf '%s\\n' 'file 600 0 0'
|
|
printf '%s\\n' "$C2R_FIRST_SECRET_SOURCE"
|
|
;;
|
|
/srv/my-app/secrets/second.bin)
|
|
printf '%s\\n' 'file 600 0 0'
|
|
printf '%s\\n' "$C2R_SECOND_SECRET_SOURCE"
|
|
;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
stat)
|
|
case "$path" in
|
|
/srv/my-app/.env) printf '%s\\n' missing ;;
|
|
/srv/my-app/secrets/first.bin|/srv/my-app/secrets/second.bin) printf '%s\\n' file ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*) exit 97 ;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"""\
|
|
#!/bin/sh
|
|
cat > "$C2R_SOPS_PAYLOAD"
|
|
printf '%s\\n' "$C2R_SOPS_OUTPUT"
|
|
""",
|
|
)
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
first_payload_path = tmp_path / "first-sops-payload.json"
|
|
environment = {
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_COMPOSE_SOURCE": base64.b64encode(source_document.encode("utf-8")).decode("ascii"),
|
|
"C2R_FIRST_SECRET_SOURCE": base64.b64encode(first_secret).decode("ascii"),
|
|
"C2R_SECOND_SECRET_SOURCE": base64.b64encode(second_secret).decode("ascii"),
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output(
|
|
*(
|
|
"my_app_secret_app_token_"
|
|
+ hashlib.sha256(identity.encode("utf-8")).hexdigest()[:8]
|
|
for identity in (
|
|
"file-secret:app-token:secrets/first.bin",
|
|
"file-secret:app_token:secrets/second.bin",
|
|
)
|
|
)
|
|
),
|
|
"C2R_SOPS_PAYLOAD": str(first_payload_path),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
}
|
|
arguments = [
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--sops-config",
|
|
str(sops_config),
|
|
]
|
|
output_directory = tmp_path / "roles"
|
|
|
|
first_result = CliRunner().invoke(
|
|
main,
|
|
[*arguments, "--output", str(output_directory)],
|
|
env=environment,
|
|
)
|
|
|
|
assert first_result.exit_code == 0, first_result.output
|
|
second_payload_path = tmp_path / "second-sops-payload.json"
|
|
second_result = CliRunner().invoke(
|
|
main,
|
|
[*arguments, "--output", str(tmp_path / "roles-again")],
|
|
env={**environment, "C2R_SOPS_PAYLOAD": str(second_payload_path)},
|
|
)
|
|
|
|
assert second_result.exit_code == 0, second_result.output
|
|
first_payload = json.loads(first_payload_path.read_text(encoding="utf-8"))
|
|
assert first_payload == json.loads(second_payload_path.read_text(encoding="utf-8"))
|
|
assert set(first_payload.values()) == {
|
|
base64.b64encode(first_secret).decode("ascii"),
|
|
base64.b64encode(second_secret).decode("ascii"),
|
|
}
|
|
keys = set(first_payload)
|
|
prefix = "my_app_secret_app_token_"
|
|
assert len(keys) == 2
|
|
assert all(
|
|
key.startswith(prefix)
|
|
and len(key) == len(prefix) + 8
|
|
and all(character in "0123456789abcdef" for character in key[len(prefix) :])
|
|
for key in keys
|
|
)
|
|
tasks = (output_directory / "my_app" / "tasks" / "main.yml").read_text(encoding="utf-8")
|
|
assert all(f'key: "{key}"' in tasks for key in keys)
|
|
generated_role_contents = b"".join(
|
|
path.read_bytes() for path in (output_directory / "my_app").rglob("*") if path.is_file()
|
|
)
|
|
assert first_secret not in generated_role_contents
|
|
assert second_secret not in generated_role_contents
|
|
assert base64.b64encode(first_secret) not in generated_role_contents
|
|
assert base64.b64encode(second_secret) not in generated_role_contents
|
|
|
|
|
|
def test_generate_refuses_secret_shaped_non_environment_keys(tmp_path: Path) -> None:
|
|
"""A secret-shaped label is refused rather than rendered as an unprotected value."""
|
|
secret_value = "do-not-render-this-label-value"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
labels:
|
|
API_TOKEN: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"labels": {"API_TOKEN": secret_value},
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert (
|
|
"C2R029: remote non-environment secret-shaped mapping keys are not supported"
|
|
in result.output
|
|
)
|
|
assert secret_value not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_preserves_canonical_no_file_topology(tmp_path: Path) -> None:
|
|
"""Ordinary source topology survives source-faithful remote role generation."""
|
|
source_document = """\
|
|
networks:
|
|
backplane:
|
|
name: my-app_backplane
|
|
services:
|
|
db:
|
|
image: "postgres:16"
|
|
healthcheck:
|
|
test: ["CMD-SHELL", "pg_isready"]
|
|
networks:
|
|
- backplane
|
|
restart: unless-stopped
|
|
user: "1000:1000"
|
|
volumes:
|
|
- type: volume
|
|
source: db_data
|
|
target: /var/lib/postgresql/data
|
|
web:
|
|
image: "ghcr.io/example/web:1.2.3"
|
|
command: ["serve", "--mode", "production"]
|
|
depends_on:
|
|
db:
|
|
condition: service_healthy
|
|
healthcheck:
|
|
test: ["CMD", "true"]
|
|
labels:
|
|
org.example.component: web
|
|
networks:
|
|
- backplane
|
|
restart: unless-stopped
|
|
user: "1000:1000"
|
|
volumes:
|
|
db_data:
|
|
name: my-app_db_data
|
|
"""
|
|
canonical_document = {
|
|
"networks": {"backplane": {"name": "my-app_backplane"}},
|
|
"services": {
|
|
"db": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD-SHELL", "pg_isready"]},
|
|
"image": "postgres:16",
|
|
"networks": ["backplane"],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
"volumes": [
|
|
{"source": "db_data", "target": "/var/lib/postgresql/data", "type": "volume"}
|
|
],
|
|
},
|
|
"web": {
|
|
"command": ["serve", "--mode", "production"],
|
|
"depends_on": {"db": {"condition": "service_healthy"}},
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"labels": {"org.example.component": "web"},
|
|
"networks": ["backplane"],
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
},
|
|
},
|
|
"volumes": {"db_data": {"name": "my-app_db_data"}},
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
template = YAML(typ="safe").load(
|
|
(output_directory / "my_app" / "templates" / "compose.yaml.j2").read_text(encoding="utf-8")
|
|
)
|
|
assert template["networks"] == canonical_document["networks"]
|
|
assert template["volumes"] == canonical_document["volumes"]
|
|
assert template["services"]["web"]["command"] == ["serve", "--mode", "production"]
|
|
assert template["services"]["web"]["depends_on"] == {
|
|
"db": {"condition": "service_healthy"}
|
|
}
|
|
assert template["services"]["web"]["labels"] == {"org.example.component": "web"}
|
|
assert template["services"]["db"]["healthcheck"] == {
|
|
"test": ["CMD-SHELL", "pg_isready"]
|
|
}
|
|
|
|
|
|
def test_generate_encrypts_remote_environment_secrets_without_plaintext_files(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""Classified remote environment values reach SOPS only over stdin."""
|
|
secret_value = "remote-secret-must-not-persist"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
LOG_LEVEL: info
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value, "LOG_LEVEL": "info"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
sops_marker = tmp_path / "sops-marker"
|
|
sops_arguments = tmp_path / "sops-arguments"
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"""\
|
|
#!/bin/sh
|
|
payload=$(cat)
|
|
case "$payload" in
|
|
*"$C2R_EXPECTED_SECRET"*)
|
|
;;
|
|
*)
|
|
exit 98
|
|
;;
|
|
esac
|
|
case "$*" in
|
|
*"$C2R_EXPECTED_SECRET"*)
|
|
exit 97
|
|
;;
|
|
esac
|
|
printf '%s\\n' "$@" > "$C2R_SOPS_ARGUMENTS"
|
|
printf '%s\\n' stdin-secret-received >> "$C2R_SOPS_MARKER"
|
|
cat <<'EOF'
|
|
sops:
|
|
mac: ENC[AES256_GCM,data:fixture]
|
|
my_app_web_api_token: ENC[AES256_GCM,data:fixture]
|
|
EOF
|
|
""",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
**environment,
|
|
"C2R_EXPECTED_SECRET": secret_value,
|
|
"C2R_SOPS_ARGUMENTS": str(sops_arguments),
|
|
"C2R_SOPS_MARKER": str(sops_marker),
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
role_directory = output_directory / "my_app"
|
|
assert sops_marker.read_text(encoding="utf-8") == "stdin-secret-received\n"
|
|
assert secret_value not in sops_arguments.read_text(encoding="utf-8")
|
|
assert "--filename-override" in sops_arguments.read_text(encoding="utf-8")
|
|
encrypted_secrets = (role_directory / "vars" / "secrets.sops.yml").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert "ENC[AES256_GCM,data:fixture]" in encrypted_secrets
|
|
assert secret_value not in encrypted_secrets
|
|
assert not (role_directory / ".sops.yaml").exists()
|
|
assert not (role_directory / "vars" / "secrets.example.yml").exists()
|
|
assert 'my_app_secrets_file: "{{ role_path }}/vars/secrets.sops.yml"' in (
|
|
role_directory / "defaults" / "main.yml"
|
|
).read_text(encoding="utf-8")
|
|
assert "community.sops.load_vars:" in (role_directory / "tasks" / "main.yml").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert "community.sops" in (role_directory / "meta" / "requirements.yml").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
compose_template = (role_directory / "templates" / "compose.yaml.j2").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert "API_TOKEN: {{ my_app_secrets['my_app_web_api_token'] }}" in compose_template
|
|
assert "LOG_LEVEL: {{ my_app_web_log_level }}" in compose_template
|
|
for path in tmp_path.rglob("*"):
|
|
if path.is_file():
|
|
assert secret_value.encode("utf-8") not in path.read_bytes()
|
|
assert secret_value not in result.output
|
|
|
|
|
|
def test_generated_remote_secret_role_passes_ansible_validation(tmp_path: Path) -> None:
|
|
"""The role wiring for encrypted remote environment values is lint- and syntax-valid."""
|
|
secret_value = "ansible-validation-secret"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"""\
|
|
#!/bin/sh
|
|
cat >/dev/null
|
|
cat <<'EOF'
|
|
sops:
|
|
mac: "ENC[AES256_GCM,data:fixture]"
|
|
my_app_web_api_token: "ENC[AES256_GCM,data:fixture]"
|
|
EOF
|
|
""",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
_assert_generated_role_validates(tmp_path, output_directory, "my_app")
|
|
|
|
|
|
def test_generate_writes_redacted_remote_provenance(tmp_path: Path) -> None:
|
|
"""Remote role provenance identifies structure without retaining environment values."""
|
|
secret_value = "provenance-must-not-contain-this"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' \"$C2R_SOPS_OUTPUT\"\n",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
**environment,
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output("my_app_web_api_token"),
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
provenance_text = (output_directory / "my_app" / ".compose2role.json").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
provenance = json.loads(provenance_text)
|
|
assert provenance["generator"] == "compose2role"
|
|
assert provenance["mode"] == "remote"
|
|
assert provenance["project"] == "my-app"
|
|
assert provenance["role"] == "my_app"
|
|
assert provenance["source"] == {
|
|
"config_files": ["/srv/my-app/compose.yaml"],
|
|
"root": "/srv/my-app",
|
|
}
|
|
assert len(provenance["structural_hash"]) == 64
|
|
assert secret_value not in provenance_text
|
|
|
|
|
|
def test_remote_provenance_hash_is_stable_when_only_environment_values_change(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""Effective environment values do not influence the structural provenance hash."""
|
|
hashes: list[str] = []
|
|
for index, log_level in enumerate(("info", "debug"), start=1):
|
|
case_directory = tmp_path / str(index)
|
|
case_directory.mkdir()
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
LOG_LEVEL: {log_level}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"LOG_LEVEL": log_level},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(
|
|
case_directory, source_document, canonical_document
|
|
)
|
|
output_directory = case_directory / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
provenance = json.loads(
|
|
(output_directory / "my_app" / ".compose2role.json").read_text(encoding="utf-8")
|
|
)
|
|
hashes.append(provenance["structural_hash"])
|
|
|
|
assert hashes[0] == hashes[1]
|
|
|
|
|
|
def test_generate_check_validates_remote_secrets_without_writing_or_encrypting(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""Remote check mode reaches validation but leaves no role or SOPS artifact behind."""
|
|
secret_value = "check-mode-secret"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
sops_called = tmp_path / "sops-called"
|
|
_install_stub_command(bin_directory, "sops", "#!/bin/sh\n: > \"$C2R_SOPS_CALLED\"\nexit 99\n")
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--check",
|
|
],
|
|
env={**environment, "C2R_SOPS_CALLED": str(sops_called)},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "✓ my-app -> my_app (checked)" in result.output
|
|
assert " templates/compose.yaml.j2" in result.output
|
|
assert secret_value not in result.output
|
|
assert not output_directory.exists()
|
|
assert not sops_called.exists()
|
|
|
|
json_result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--check",
|
|
"--format",
|
|
"json",
|
|
],
|
|
env={**environment, "C2R_SOPS_CALLED": str(sops_called)},
|
|
)
|
|
|
|
assert json_result.exit_code == 0, json_result.output
|
|
checked_project = json.loads(json_result.output)["projects"][0]
|
|
assert checked_project["role"] == "my_app"
|
|
assert "templates/compose.yaml.j2" in checked_project["files"]
|
|
assert secret_value not in json_result.output
|
|
assert not output_directory.exists()
|
|
assert not sops_called.exists()
|
|
|
|
|
|
def test_generate_all_keeps_successful_roles_after_an_isolated_failure(tmp_path: Path) -> None:
|
|
"""Bulk generation keeps a good role when another project is not portable."""
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"bad","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/bad/compose.yaml"},'
|
|
printf '%s\\n' '{"Name":"good","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/good/compose.yaml"}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
if [ "$path" = /srv/bad/compose.yaml ]; then
|
|
printf '%s\\n' 'file 640 0 0'
|
|
base64 <<'EOF' | tr -d '\\n'
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
build: .
|
|
EOF
|
|
else
|
|
printf '%s\\n' 'file 640 0 0'
|
|
base64 <<'EOF' | tr -d '\\n'
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
EOF
|
|
fi
|
|
printf '\\n'
|
|
;;
|
|
stat)
|
|
printf '%s\\n' missing
|
|
;;
|
|
config)
|
|
printf '%s\\n' '{"services":{"web":{"environment":{},'
|
|
printf '%s\\n' '"healthcheck":{"test":["CMD","true"]},'
|
|
printf '%s\\n' '"image":"ghcr.io/example/web:1.2.3",'
|
|
printf '%s\\n' '"restart":"unless-stopped","user":"1000:1000"}}}'
|
|
;;
|
|
*)
|
|
exit 97
|
|
;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(bin_directory, "sops", "#!/bin/sh\nexit 99\n")
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--all",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--format",
|
|
"json",
|
|
],
|
|
env={"PATH": f"{bin_directory}:{os.environ['PATH']}"},
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
summary = json.loads(result.output)["projects"]
|
|
assert [(project["name"], project["role"], project["status"]) for project in summary] == [
|
|
("bad", None, "failed"),
|
|
("good", "good", "generated"),
|
|
]
|
|
assert summary[0]["error"] == "C2R005: remote build contexts are not supported"
|
|
assert (output_directory / "good").is_dir()
|
|
assert not (output_directory / "bad").exists()
|
|
|
|
|
|
def test_generate_all_adopts_multifile_sources_and_isolates_an_unsupported_project(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""Bulk generation retains a source-faithful role without persisting its secrets."""
|
|
secret_value = "postgres://operator:bulk-source-secret@db/app"
|
|
primary_source = (
|
|
b"# Primary source remains byte-faithful.\r\n"
|
|
b"services:\r\n"
|
|
b" web:\r\n"
|
|
b" image: ghcr.io/example/web:1.2.3\r\n"
|
|
b" environment:\r\n"
|
|
b" DATABASE_URL: ${DATABASE_URL}\r\n"
|
|
b" env_file: ./env/web.env\r\n"
|
|
b"secrets:\r\n"
|
|
b" app_secret:\r\n"
|
|
b" file: ./secrets/app.bin\r\n"
|
|
)
|
|
override_source = b"""\
|
|
services:
|
|
web:
|
|
environment:
|
|
LOG_LEVEL: debug
|
|
"""
|
|
root_dotenv = f"DATABASE_URL={secret_value}\n".encode()
|
|
service_dotenv = b"LOG_LEVEL=debug\n"
|
|
file_secret = b"\x00bulk-file-secret\n"
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"good-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":["/srv/good/compose.yaml",'
|
|
printf '%s\\n' '"/srv/good/compose.override.yaml"]},'
|
|
printf '%s\\n' '{"Name":"bad-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/bad/compose.yaml"}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
path=$(printf '%s\\n' "$payload" | sed -n '2p')
|
|
case "$operation" in
|
|
capture)
|
|
printf '%s\\n' 'file 640 0 0'
|
|
case "$path" in
|
|
/srv/good/compose.yaml) printf '%s\\n' "$C2R_PRIMARY_SOURCE" ;;
|
|
/srv/good/compose.override.yaml) printf '%s\\n' "$C2R_OVERRIDE_SOURCE" ;;
|
|
/srv/good/.env) printf '%s\\n' "$C2R_ROOT_DOTENV" ;;
|
|
/srv/good/env/web.env) printf '%s\\n' "$C2R_SERVICE_DOTENV" ;;
|
|
/srv/good/secrets/app.bin) printf '%s\\n' "$C2R_FILE_SECRET" ;;
|
|
/srv/bad/compose.yaml)
|
|
base64 <<'EOF' | tr -d '\\n'
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
build: .
|
|
EOF
|
|
printf '\\n'
|
|
;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
stat)
|
|
case "$path" in
|
|
/srv/good/.env|/srv/good/env/web.env|/srv/good/secrets/app.bin) printf '%s\\n' file ;;
|
|
/srv/bad/.env) printf '%s\\n' missing ;;
|
|
*) exit 98 ;;
|
|
esac
|
|
;;
|
|
config)
|
|
printf '%s\\n' "$C2R_CANONICAL_DOCUMENT"
|
|
;;
|
|
*) exit 97 ;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"""\
|
|
#!/bin/sh
|
|
printf '%s\\n' called >> "$C2R_SOPS_CALLS"
|
|
cat >/dev/null
|
|
printf '%s\\n' "$C2R_SOPS_OUTPUT"
|
|
""",
|
|
)
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"DATABASE_URL": secret_value, "LOG_LEVEL": "debug"},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
sops_calls = tmp_path / "sops-calls"
|
|
output_directory = tmp_path / "roles"
|
|
environment = {
|
|
"C2R_CANONICAL_DOCUMENT": json.dumps(canonical_document),
|
|
"C2R_FILE_SECRET": base64.b64encode(file_secret).decode("ascii"),
|
|
"C2R_OVERRIDE_SOURCE": base64.b64encode(override_source).decode("ascii"),
|
|
"C2R_PRIMARY_SOURCE": base64.b64encode(primary_source).decode("ascii"),
|
|
"C2R_ROOT_DOTENV": base64.b64encode(root_dotenv).decode("ascii"),
|
|
"C2R_SERVICE_DOTENV": base64.b64encode(service_dotenv).decode("ascii"),
|
|
"C2R_SOPS_CALLS": str(sops_calls),
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output(
|
|
"good_app_dotenv_env_database_url", "good_app_secret_app_secret"
|
|
),
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
}
|
|
arguments = [
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--all",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--format",
|
|
"json",
|
|
]
|
|
|
|
result = CliRunner().invoke(main, arguments, env=environment)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
summary = json.loads(result.output)["projects"]
|
|
assert [(item["name"], item["role"], item["status"]) for item in summary] == [
|
|
("good-app", "good_app", "generated"),
|
|
("bad-app", None, "failed"),
|
|
]
|
|
assert summary[1]["error"] == "C2R005: remote build contexts are not supported"
|
|
assert secret_value not in result.output
|
|
assert (output_directory / "good_app").is_dir()
|
|
assert not (output_directory / "bad_app").exists()
|
|
assert sops_calls.read_text(encoding="utf-8").splitlines() == ["called"]
|
|
|
|
role_directory = output_directory / "good_app"
|
|
defaults = YAML(typ="safe").load(
|
|
(role_directory / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
)
|
|
assert isinstance(defaults, dict)
|
|
for relative_path, source, newline_sequence in (
|
|
("compose.yaml", primary_source, "\r\n"),
|
|
("compose.override.yaml", override_source, "\n"),
|
|
(".env", root_dotenv, "\n"),
|
|
("env/web.env", service_dotenv, "\n"),
|
|
):
|
|
template = (role_directory / "templates" / f"{relative_path}.j2").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
rendered = Environment(
|
|
keep_trailing_newline=True, newline_sequence=newline_sequence
|
|
).from_string(template).render(
|
|
**defaults,
|
|
good_app_secrets={"good_app_dotenv_env_database_url": secret_value},
|
|
)
|
|
assert rendered.encode() == source
|
|
role_bytes = b"".join(
|
|
path.read_bytes() for path in role_directory.rglob("*") if path.is_file()
|
|
)
|
|
assert secret_value.encode() not in role_bytes
|
|
assert base64.b64encode(file_secret) not in role_bytes
|
|
assert secret_value not in (role_directory / ".compose2role.json").read_text(encoding="utf-8")
|
|
|
|
check_output = tmp_path / "check-roles"
|
|
check_result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--all",
|
|
"--output",
|
|
str(check_output),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--check",
|
|
"--format",
|
|
"json",
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert check_result.exit_code == 1, check_result.output
|
|
checked_summary = json.loads(check_result.output)["projects"]
|
|
assert [(item["name"], item["role"], item["status"]) for item in checked_summary] == [
|
|
("good-app", "good_app", "checked"),
|
|
("bad-app", None, "failed"),
|
|
]
|
|
assert "templates/compose.yaml.j2" in checked_summary[0]["files"]
|
|
assert secret_value not in check_result.output
|
|
assert not check_output.exists()
|
|
assert sops_calls.read_text(encoding="utf-8").splitlines() == ["called"]
|
|
|
|
|
|
def test_generate_reports_secret_role_output_failures_as_output_failures(tmp_path: Path) -> None:
|
|
"""A secret role's output failure is not misreported as an SOPS failure."""
|
|
secret_value = "output-category-secret"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' \"$C2R_SOPS_OUTPUT\"\n",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
output_directory.write_text("not a directory", encoding="utf-8")
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={
|
|
**environment,
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output("my_app_web_api_token"),
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert (
|
|
"my-app -> my_app: FAILED (output): remote role output must be a directory"
|
|
in result.output
|
|
)
|
|
assert secret_value not in result.output
|
|
|
|
|
|
def test_generate_keeps_secret_role_unwritten_when_sops_encryption_fails(tmp_path: Path) -> None:
|
|
"""SOPS failure exposes no stderr value and leaves no partial role behind."""
|
|
secret_value = "sops-failure-secret"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\nprintf '%s\\n' \"$C2R_EXPECTED_SECRET\" >&2\nexit 91\n",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={**environment, "C2R_EXPECTED_SECRET": secret_value},
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "my-app -> my_app: FAILED (sops): SOPS encryption failed" in result.output
|
|
assert secret_value not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"sops_output",
|
|
(
|
|
"not: [valid",
|
|
"sops:\n mac: ENC[AES256_GCM,data:fixture]",
|
|
"my_app_web_api_token: sops-output-secret\nsops:\n mac: ENC[AES256_GCM,data:fixture]",
|
|
),
|
|
ids=("invalid-yaml", "missing-secret", "plaintext-secret"),
|
|
)
|
|
def test_generate_keeps_secret_role_unwritten_when_sops_output_is_invalid(
|
|
tmp_path: Path, sops_output: str
|
|
) -> None:
|
|
"""Malformed, incomplete, or plaintext SOPS output never reaches a role directory."""
|
|
secret_value = "sops-output-secret"
|
|
source_document = f"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: {secret_value}
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {"API_TOKEN": secret_value},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' \"$C2R_SOPS_OUTPUT\"\n",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={**environment, "C2R_SOPS_OUTPUT": sops_output},
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert "my-app -> my_app: FAILED (sops): SOPS encryption output is invalid" in result.output
|
|
assert secret_value not in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_all_rejects_normalized_role_name_collisions_before_writing(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""Raw project names that normalize equally leave no ambiguous role output."""
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"""\
|
|
#!/bin/sh
|
|
request=$(cat)
|
|
|
|
if [ "$*" = '-- web1 docker compose ls --all --format json' ]; then
|
|
printf '%s\\n' '[{"Name":"my-app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/my-app/compose.yaml"},'
|
|
printf '%s\\n' '{"Name":"my_app","Status":"running(1)",'
|
|
printf '%s\\n' '"ConfigFiles":"/srv/my_app/compose.yaml"}]'
|
|
exit 0
|
|
fi
|
|
|
|
encoded=$(printf '%s\\n' "$request" | tail -n 2 | head -n 1)
|
|
payload=$(printf '%s' "$encoded" | base64 -d)
|
|
operation=$(printf '%s\\n' "$payload" | head -n 1)
|
|
case "$operation" in
|
|
capture)
|
|
printf '%s\\n' 'file 640 0 0'
|
|
base64 <<'EOF' | tr -d '\\n'
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
EOF
|
|
printf '\\n'
|
|
;;
|
|
stat)
|
|
printf '%s\\n' missing
|
|
;;
|
|
config)
|
|
printf '%s\\n' '{"services":{"web":{"environment":{},'
|
|
printf '%s\\n' '"healthcheck":{"test":["CMD","true"]},'
|
|
printf '%s\\n' '"image":"ghcr.io/example/web:1.2.3",'
|
|
printf '%s\\n' '"restart":"unless-stopped","user":"1000:1000"}}}'
|
|
;;
|
|
*)
|
|
exit 97
|
|
;;
|
|
esac
|
|
""",
|
|
)
|
|
_install_stub_command(bin_directory, "sops", "#!/bin/sh\nexit 99\n")
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--all",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--format",
|
|
"json",
|
|
],
|
|
env={"PATH": f"{bin_directory}:{os.environ['PATH']}"},
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
projects = json.loads(result.output)["projects"]
|
|
assert [(project["name"], project["role"], project["status"]) for project in projects] == [
|
|
("my-app", "my_app", "failed"),
|
|
("my_app", "my_app", "failed"),
|
|
]
|
|
assert all(
|
|
project["error"] == "normalized remote role name collides with another selected project"
|
|
for project in projects
|
|
)
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_check_reports_planned_files_for_pre_existing_role_without_modifying_it(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""Check mode lists planned files without validating or altering existing output."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
output_directory = tmp_path / "roles"
|
|
role_directory = output_directory / "my_app"
|
|
role_directory.mkdir(parents=True)
|
|
sentinel = role_directory / "operator-file"
|
|
sentinel.write_text("do not alter", encoding="utf-8")
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--check",
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "my-app -> my_app (checked)" in result.output
|
|
assert " .compose2role.json" in result.output
|
|
assert sentinel.read_text(encoding="utf-8") == "do not alter"
|
|
assert not (role_directory / ".compose2role.json").exists()
|
|
|
|
|
|
def test_generate_check_rejects_a_symlinked_output_directory(tmp_path: Path) -> None:
|
|
"""Check mode applies the writer's output-directory safety rule before reporting success."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
target_directory = tmp_path / "operator-output"
|
|
target_directory.mkdir()
|
|
output_directory = tmp_path / "roles"
|
|
output_directory.symlink_to(target_directory, target_is_directory=True)
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--check",
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert (
|
|
"my-app -> my_app: FAILED (output): remote role output must be a directory"
|
|
in result.output
|
|
)
|
|
assert not (target_directory / "my_app").exists()
|
|
|
|
|
|
def test_generate_prefers_explicit_sops_config_and_falls_back_to_environment(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""The selected SOPS config has deterministic option-over-environment precedence."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, explicit_config = _remote_environment(
|
|
tmp_path, source_document, canonical_document
|
|
)
|
|
environment_config = tmp_path / "environment-sops.yaml"
|
|
environment_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
missing_config = tmp_path / "not-used.yaml"
|
|
|
|
explicit_result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(tmp_path / "explicit-roles"),
|
|
"--sops-config",
|
|
str(explicit_config),
|
|
"--check",
|
|
],
|
|
env={**environment, "COMPOSE2ROLE_SOPS_CONFIG": str(missing_config)},
|
|
)
|
|
environment_result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(tmp_path / "environment-roles"),
|
|
"--check",
|
|
],
|
|
env={**environment, "COMPOSE2ROLE_SOPS_CONFIG": str(environment_config)},
|
|
)
|
|
|
|
assert explicit_result.exit_code == 0, explicit_result.output
|
|
assert environment_result.exit_code == 0, environment_result.output
|
|
|
|
|
|
def test_generate_rejects_missing_sops_config_before_remote_acquisition(tmp_path: Path) -> None:
|
|
"""Missing configuration stops before the SSH resolver can acquire remote values."""
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"#!/bin/sh\n: > \"$C2R_SSH_MARKER\"\nexit 97\n",
|
|
)
|
|
ssh_marker = tmp_path / "ssh-called"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(tmp_path / "roles"),
|
|
],
|
|
env={
|
|
"C2R_SSH_MARKER": str(ssh_marker),
|
|
"COMPOSE2ROLE_SOPS_CONFIG": "",
|
|
"PATH": f"{bin_directory}:{os.environ['PATH']}",
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 1
|
|
assert "remote generation requires an existing SOPS config" in result.output
|
|
assert not ssh_marker.exists()
|
|
|
|
|
|
def test_generate_rejects_missing_sops_executable_before_remote_acquisition(tmp_path: Path) -> None:
|
|
"""A valid config does not permit SSH acquisition when SOPS is unavailable."""
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"#!/bin/sh\n: > \"$C2R_SSH_MARKER\"\nexit 97\n",
|
|
)
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: vars/secrets\\.sops\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
ssh_marker = tmp_path / "ssh-called"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(tmp_path / "roles"),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env={"C2R_SSH_MARKER": str(ssh_marker), "PATH": str(bin_directory)},
|
|
)
|
|
|
|
assert result.exit_code == 1
|
|
assert "remote generation requires the SOPS executable" in result.output
|
|
assert not ssh_marker.exists()
|
|
|
|
|
|
def test_generate_check_validates_the_sops_creation_rule_before_remote_acquisition(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""Check mode validates an applicable creation rule without running SOPS or SSH."""
|
|
bin_directory = tmp_path / "bin"
|
|
bin_directory.mkdir()
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"ssh",
|
|
"#!/bin/sh\n: > \"$C2R_SSH_MARKER\"\nexit 97\n",
|
|
)
|
|
_install_stub_command(bin_directory, "sops", "#!/bin/sh\nexit 97\n")
|
|
sops_config = tmp_path / "sops.yaml"
|
|
sops_config.write_text(
|
|
"creation_rules:\n - path_regex: other-output\\.yml$\n",
|
|
encoding="utf-8",
|
|
)
|
|
ssh_marker = tmp_path / "ssh-called"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(tmp_path / "roles"),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--check",
|
|
],
|
|
env={"C2R_SSH_MARKER": str(ssh_marker), "PATH": str(bin_directory)},
|
|
)
|
|
|
|
assert result.exit_code == 1
|
|
assert "SOPS config has no creation rule for vars/secrets.sops.yml" in result.output
|
|
assert not ssh_marker.exists()
|
|
|
|
|
|
def test_generate_applies_secret_policy_overrides_to_remote_environment(
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""Exact secret policy decisions override automatic remote environment classification."""
|
|
source_document = """\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
environment:
|
|
API_TOKEN: operator-approved-plain
|
|
LOG_LEVEL: info
|
|
"""
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {
|
|
"API_TOKEN": "operator-approved-plain",
|
|
"LOG_LEVEL": "info",
|
|
},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
bin_directory = Path(environment["PATH"].split(":", maxsplit=1)[0])
|
|
_install_stub_command(
|
|
bin_directory,
|
|
"sops",
|
|
"#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' \"$C2R_SOPS_OUTPUT\"\n",
|
|
)
|
|
secret_policy_path = tmp_path / "policy.toml"
|
|
secret_policy_path.write_text(
|
|
"""\
|
|
[[rules]]
|
|
project = "my-app"
|
|
service = "web"
|
|
key = "API_TOKEN"
|
|
decision = "plain"
|
|
|
|
[[rules]]
|
|
project = "my-app"
|
|
service = "web"
|
|
key = "LOG_LEVEL"
|
|
decision = "secret"
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
output_directory = tmp_path / "roles"
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--secret-policy",
|
|
str(secret_policy_path),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
"--format",
|
|
"json",
|
|
],
|
|
env={
|
|
**environment,
|
|
"C2R_SOPS_OUTPUT": _encrypted_sops_output("my_app_web_log_level"),
|
|
},
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
project = json.loads(result.output)["projects"][0]
|
|
assert project["classifications"] == [
|
|
{
|
|
"key": "LOG_LEVEL",
|
|
"location": "remote-compose.json:1:1",
|
|
"reason": "secret-policy:forced-secret",
|
|
"service": "web",
|
|
}
|
|
]
|
|
defaults = (output_directory / "my_app" / "defaults" / "main.yml").read_text(encoding="utf-8")
|
|
compose_template = (output_directory / "my_app" / "templates" / "compose.yaml.j2").read_text(
|
|
encoding="utf-8"
|
|
)
|
|
assert 'my_app_web_api_token: "operator-approved-plain"' in defaults
|
|
assert "my_app_web_log_level:" not in defaults
|
|
assert "API_TOKEN: {{ my_app_web_api_token }}" in compose_template
|
|
assert "LOG_LEVEL: {{ my_app_secrets['my_app_web_log_level'] }}" in compose_template
|
|
|
|
|
|
def test_generate_refuses_other_nonportable_compose_features(tmp_path: Path) -> None:
|
|
"""Selected generation retains the resolver's build/extends/profiles/include refusals."""
|
|
cases = (
|
|
(
|
|
"build",
|
|
"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
build: .
|
|
""",
|
|
"C2R005: remote build contexts are not supported",
|
|
),
|
|
(
|
|
"extends",
|
|
"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
extends: base
|
|
""",
|
|
"C2R006: remote service extends declarations are not supported",
|
|
),
|
|
(
|
|
"profiles",
|
|
"""\
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
profiles: [optional]
|
|
""",
|
|
"C2R007: remote service profiles are not supported",
|
|
),
|
|
(
|
|
"include",
|
|
"""\
|
|
include: other.compose.yml
|
|
services:
|
|
web:
|
|
image: ghcr.io/example/web:1.2.3
|
|
""",
|
|
"C2R008: remote Compose include files are not supported",
|
|
),
|
|
)
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
|
|
for name, source_document, expected_message in cases:
|
|
case_directory = tmp_path / name
|
|
case_directory.mkdir()
|
|
environment, sops_config = _remote_environment(
|
|
case_directory, source_document, canonical_document
|
|
)
|
|
output_directory = case_directory / "roles"
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--project",
|
|
"my-app",
|
|
"--output",
|
|
str(output_directory),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 1, result.output
|
|
assert expected_message in result.output
|
|
assert not output_directory.exists()
|
|
|
|
|
|
def test_generate_all_writes_roles_and_no_playbook(tmp_path: Path) -> None:
|
|
"""Generation is roles-only: --all writes one role per project and nothing else."""
|
|
source_document = "services:\n web:\n image: ghcr.io/example/web:1.2.3\n"
|
|
canonical_document = {
|
|
"services": {
|
|
"web": {
|
|
"environment": {},
|
|
"healthcheck": {"test": ["CMD", "true"]},
|
|
"image": "ghcr.io/example/web:1.2.3",
|
|
"restart": "unless-stopped",
|
|
"user": "1000:1000",
|
|
}
|
|
}
|
|
}
|
|
environment, sops_config = _remote_environment(tmp_path, source_document, canonical_document)
|
|
|
|
result = CliRunner().invoke(
|
|
main,
|
|
[
|
|
"generate",
|
|
"--host",
|
|
"web1",
|
|
"--all",
|
|
"--output",
|
|
str(tmp_path / "roles"),
|
|
"--sops-config",
|
|
str(sops_config),
|
|
],
|
|
env=environment,
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert (tmp_path / "roles" / "my_app" / "tasks" / "main.yml").is_file()
|
|
assert sorted(path.name for path in tmp_path.iterdir() if path.is_dir()) == [
|
|
"bin",
|
|
"roles",
|
|
]
|