def test_retrieve_binaries_data(self):
features.register(DockerFeature())
load_registered_features()
action = actions.get(
'docker:display-info') # type:DockerDisplayInfoAction
assert [] == action._retrieve_binaries_data(Dotty({}))
assert [] == action._retrieve_binaries_data(Dotty({'toto': 'toto'}))
assert [] == action._retrieve_binaries_data(
Dotty({'labels': {
'toto': '123'
}}))
assert ['npm-simple'] == action._retrieve_binaries_data(
Dotty({
'labels': {
'ddb.emit.docker:binary[npm-simple](name)': 'npm-simple',
'ddb.emit.docker:binary[npm-simple](workdir)': '/app'
}
}))
assert ['npm', 'npm-simple'] == sorted(
action._retrieve_binaries_data(
Dotty({
'labels': {
'ddb.emit.docker:binary[npm](name)': 'npm',
'ddb.emit.docker:binary[npm-simple](name)':
'npm-simple',
'ddb.emit.docker:binary[npm-simple](workdir)': '/app'
}
})))
def test_from_mysql_fixuid_removed(self, project_loader):
project_loader("from-mysql-fixuid-removed")
register_default_caches()
features.register(FixuidFeature())
load_registered_features()
register_actions_in_event_bus(True)
with open('docker-compose.yml', 'r') as config_file:
config = yaml.load(config_file, yaml.SafeLoader)
events.docker.docker_compose_config(config)
with open(os.path.join("docker", "Dockerfile.expected"), "r") as f:
expected = f.read()
with open(os.path.join("docker", "Dockerfile"), "r") as f:
content = f.read()
assert content == expected
assert os.path.exists(os.path.join("docker", "fixuid.tar.gz"))
os.remove(os.path.join("docker", "fixuid.yml"))
events.file.deleted(os.path.join("docker", "fixuid.yml"))
with open(os.path.join("docker", "Dockerfile.removed.expected"),
"r") as f:
expected = f.read()
with open(os.path.join("docker", "Dockerfile"), "r") as f:
content = f.read()
assert content == expected
assert not os.path.exists(os.path.join("docker", "fixuid.tar.gz"))
def test_execute_extra_services(self, capsys: CaptureFixture,
project_loader):
project_loader("extra-services")
features.register(DockerFeature())
features.register(TraefikFeature())
load_registered_features()
config.args.type = None
action = actions.get(
'docker:display-info') # type:DockerDisplayInfoAction
action.execute()
capture = capsys.readouterr()
assert capture.out
assert not capture.err
assert ('\n'.join([
'+-------------------------+', '| web |',
'+-------------------------+', '| https://web.domain.tld/ |',
'+-------------------------+', '',
'+-----------------------------------------------+',
'| foo (extra) |',
'+-----------------------------------------------+',
'| https://sub.test --> http://192.168.99.1:8080 |',
'+-----------------------------------------------+', '\n'
])) == capture.out
def test_update_files_with_submodule(self, project_loader):
project_loader("with_submodules")
features.register(CoreFeature())
features.register(GitFeature())
load_registered_features()
path_main = config.path.project_home
path_submodule = os.path.join(path_main, 'submodule')
submodule = Repo.init(path_submodule)
submodule.create_remote(
'origin', 'https://github.com/inetum-orleans/docker-devbox-ddb')
submodule.git.add('.')
submodule.git.update_index('.gitignore', chmod='+x')
submodule.git.commit('-m "Initial commit"')
repo = Repo.init(path_main)
repo.git.add('.')
repo.create_submodule('a-sub-module', 'submodule', no_checkout=True)
repo.git.update_index('.gitignore', chmod='+x')
repo.git.commit('-m "Initial commit"')
action = FixFilePermissionsAction()
action.execute()
assert os.access(os.path.join(config.path.project_home, '.gitignore'),
os.X_OK)
assert os.access(
os.path.join(config.path.project_home, 'submodule', '.gitignore'),
os.X_OK)
assert not os.access(
os.path.join(config.path.project_home, '.gitmodules'), os.X_OK)
def test_fixuid(self, project_loader, project):
project_loader(project)
register_default_caches()
features.register(FixuidFeature())
load_registered_features()
with open('docker-compose.yml', 'r') as config_file:
config = yaml.load(config_file, yaml.SafeLoader)
action = FixuidDockerComposeAction()
action.execute(docker_compose_config=config)
with open(os.path.join("docker", "Dockerfile.expected"), "r") as f:
expected = f.read()
with open(os.path.join("docker", "Dockerfile"), "r") as f:
content = f.read()
assert content == expected
if project in ["from-php-missing-configuration"]:
assert not os.path.exists(os.path.join("docker", "fixuid.tar.gz"))
else:
assert os.path.exists(os.path.join("docker", "fixuid.tar.gz"))
if "scratch" not in project:
client = docker.from_env()
image = client.images.build(path="docker")
assert image
def test_empty_project_without_core(self, project_loader):
project_loader("empty")
features.register(TraefikFeature())
load_registered_features()
assert config.data.get('traefik.disabled') is True
def test_autofix_eol(self, project_loader):
project_loader("autofix_eol")
history = (
PropertyMigration("docker.compose.network_name",
"jsonnet.docker.compose.network_name",
since="v1.6.0"),
PropertyMigration("docker.port_prefix",
"jsonnet.docker.expose.port_prefix",
since="v1.6.0"),
)
migrations.set_history(history)
features.register(FileFeature())
features.register(JinjaFeature())
load_registered_features()
register_actions_in_event_bus(True)
action = FileWalkAction()
action.initialize()
action.execute()
with open('docker-compose.properties', 'r') as f:
rendered = f.read()
with open('docker-compose.expected.properties', 'r') as f:
expected = f.read()
assert rendered == expected
def test_copy_ca_certificates(self, project_loader):
project_loader("copy-ca-certificates")
features.register(CopyFeature())
load_registered_features()
action = CopyAction()
action.execute()
assert os.path.exists(
os.path.join('.docker', 'service1', 'ca-certs', 'some-cert.crt'))
assert not os.path.exists(
os.path.join('.docker', 'service1', 'ca-certs',
'another-cert.crt'))
assert os.path.exists(
os.path.join('.docker', 'service2', 'ca-certs', 'some-cert.crt'))
assert not os.path.exists(
os.path.join('.docker', 'service2', 'ca-certs',
'another-cert.crt'))
assert not os.path.exists(
os.path.join('.docker', '.not-a-service', 'ca-certs',
'some-cert.crt'))
assert not os.path.exists(
os.path.join('.docker', '.not-a-service', 'ca-certs',
'another-cert.crt'))
def test_empty_configuration_without_core(self, project_loader):
project_loader("empty")
with pytest.raises(FeatureConfigurationError):
features.register(SymlinksFeature())
load_registered_features()
register_actions_in_event_bus(True)
def test_existing_does_nothing(self, project_loader,
module_scoped_container_getter):
project_loader("existing")
features.register(CoreFeature())
features.register(CertsFeature())
load_registered_features()
setup_cfssl(module_scoped_container_getter)
assert os.path.exists(os.path.join(".certs", "testing.test.crt"))
assert os.path.exists(os.path.join(".certs", "testing.test.key"))
with open(os.path.join(".certs", "testing.test.crt")) as crt_file:
crt = crt_file.read()
with open(os.path.join(".certs", "testing.test.key")) as key_file:
key = key_file.read()
generate_action = GenerateCertAction()
generate_action.execute(domain="testing.test")
with open(os.path.join(".certs", "testing.test.crt")) as crt_file:
assert crt == crt_file.read()
with open(os.path.join(".certs", "testing.test.key")) as key_file:
assert key == key_file.read()
remove_action = RemoveCertAction()
remove_action.execute(domain="testing.test")
assert not os.path.exists(os.path.join(".certs", "testing.test.crt"))
assert not os.path.exists(os.path.join(".certs", "testing.test.key"))
def test_empty_project_with_core(self, project_loader,
module_scoped_container_getter):
project_loader("empty")
features.register(CoreFeature())
features.register(CertsFeature())
load_registered_features()
setup_cfssl(module_scoped_container_getter)
generate_action = GenerateCertAction()
generate_action.execute(domain="testing.test")
assert os.path.exists(os.path.join(".certs", "testing.test.crt"))
assert os.path.exists(os.path.join(".certs", "testing.test.key"))
with open(os.path.join(".certs", "testing.test.crt")) as crt_file:
assert 'CERTIFICATE' in crt_file.read()
with open(os.path.join(".certs", "testing.test.key")) as key_file:
assert 'PRIVATE KEY' in key_file.read()
remove_action = RemoveCertAction()
remove_action.execute(domain="testing.test")
assert not os.path.exists(os.path.join(".certs", "testing.test.crt"))
assert not os.path.exists(os.path.join(".certs", "testing.test.key"))
def test_empty_project_without_core(self, project_loader):
project_loader("empty")
features.register(FixuidFeature())
load_registered_features()
action = FixuidDockerComposeAction()
action.execute(docker_compose_config={})
def test_named_user_group_windows(self, project_loader):
project_loader("empty")
features.register(JsonnetFeature())
load_registered_features()
assert config.data.get('jsonnet.docker.user.name_to_uid') == {}
assert config.data.get('jsonnet.docker.user.group_to_gid') == {}
def test_empty_project(self, project_loader):
project_loader("empty")
features.register(CookiecutterFeature())
load_registered_features()
action = CookiecutterAction()
action.execute()
def test_empty_project_without_core(self, project_loader,
mocker: MockerFixture):
mocker.patch('ddb.feature.version.is_git_repository',
is_git_repository)
project_loader("no_repo")
features.register(VersionFeature())
load_registered_features()
def test_empty_project_without_core(self, project_loader):
project_loader("empty")
features.register(DockerFeature())
load_registered_features()
action = actions.get('docker:emit-docker-compose-config'
) # type:EmitDockerComposeConfigAction
action.execute()
def test_empty_project_without_core(self, project_loader):
project_loader("empty")
features.register(RunFeature())
features.register(ShellFeature())
load_registered_features()
register_actions_in_event_bus(True)
action = RunAction()
action.execute()
def test_copy_no_dispatch(self, project_loader):
project_loader("copy-no-dispatch")
features.register(CopyFeature())
load_registered_features()
register_default_caches()
action = CopyAction()
action.execute()
assert os.path.exists(os.path.join('.', 'some-cert.crt'))
def test_stage_env(self, project_loader):
project_loader("stage-env")
gitignore_feature = GitignoreFeature()
features.register(CoreFeature())
features.register(gitignore_feature)
load_registered_features()
assert gitignore_feature.disabled
def test_update_files_disabled(project_loader):
project_loader("disabled")
features.register(CoreFeature())
features.register(GitFeature())
load_registered_features()
config.data['git.fix_file_permissions'] = False
action = FixFilePermissionsAction()
assert action.disabled is True
def test_empty_project_without_core(self, project_loader):
project_loader("empty")
features.register(SmartcdFeature())
load_registered_features()
action = WindowsProjectActivate()
action.execute()
assert not os.path.exists("ddb_activate.bat")
assert not os.path.exists("ddb_deactivate.bat")
def test_binary_options(self, project_loader):
project_loader("binary-options")
features.register(DockerFeature())
load_registered_features()
register_actions_in_event_bus(True)
action = actions.get('docker:emit-docker-compose-config'
) # type:EmitDockerComposeConfigAction
action.execute()
assert len(list(binaries.all())) == 3
assert binaries.has("npm-simple")
assert binaries.has("npm-conditions")
assert binaries.has("mysql")
npm_simple_set = binaries.get("npm-simple")
assert len(npm_simple_set) == 1
npm_simple = list(npm_simple_set)[0]
assert npm_simple.command() == (
''.join(effective_command("docker-compose")) +
" run --rm --workdir=/app/. --label traefik.enable=false node"
).split()
assert npm_simple.command("serve") == (
''.join(effective_command("docker-compose")) +
' run --rm --workdir=/app/. --label traefik.enable=false node'
).split()
assert npm_simple.command("run serve") == (
''.join(effective_command("docker-compose")) +
' run --rm --workdir=/app/. --label traefik.enable=false node'
).split()
npm_conditions_set = binaries.get("npm-conditions")
assert len(npm_conditions_set) == 1
npm_conditions = list(npm_conditions_set)[0]
assert npm_conditions.command() == (
''.join(effective_command("docker-compose")) +
" run --rm --workdir=/app/. --label traefik.enable=false node"
).split()
assert npm_conditions.command("serve") == (
''.join(effective_command("docker-compose")) +
' run --rm --workdir=/app/. --label traefik.enable=false node'
).split()
assert npm_conditions.command("run serve") == (
''.join(effective_command("docker-compose")) +
' run --rm --workdir=/app/. node').split()
mysql_set = binaries.get("mysql")
assert len(mysql_set) == 1
mysql = list(mysql_set)[0]
assert mysql.command() == (
''.join(effective_command("docker-compose")) +
' run --rm --workdir=/app/. db mysql -hdb -uproject-management-tool -pproject-management-tool'
).split()
def test_github_django(self, project_loader):
project_loader("github-django")
features.register(CookiecutterFeature())
load_registered_features()
action = CookiecutterAction()
action.execute()
assert os.path.isdir('my_awesome_project')
assert os.path.isfile(os.path.join('my_awesome_project', 'setup.cfg'))
def test_empty_skip_outside_additions(self, project_loader):
project_loader("empty")
features.register(CoreFeature())
features.register(GitignoreFeature())
load_registered_features()
action = UpdateGitignoreAction()
action.execute(target="../outside/to-ignore.yml")
assert not os.path.exists('.gitignore')
def test_empty_project_without_core(self, project_loader):
project_loader("empty")
features.register(FileFeature())
features.register(JsonnetFeature())
load_registered_features()
register_actions_in_event_bus(True)
action = FileWalkAction()
action.initialize()
action.execute()
def test_empty_project_without_core(self, project_loader):
project_loader("empty")
features.register(GitignoreFeature())
load_registered_features()
action = UpdateGitignoreAction()
action.execute(target="./to-ignore.yml")
action.execute(target="./to-ignore-2.yml")
assert os.path.exists('.gitignore')
assert expect_gitignore('.gitignore', '/to-ignore.yml',
'/to-ignore-2.yml')
def test_extra_services(self, project_loader):
project_loader("extra-services")
features.register(CoreFeature())
features.register(TraefikFeature())
features.register(DockerFeature())
features.register(JsonnetFeature())
load_registered_features()
install_action = TraefikExtraServicesAction()
install_action.initialize()
install_action.execute()
files = {
"api": {
"generated": "sub.project.test.extra-service.api.toml",
"expected": "sub.project.test.extra-service.api.expected.toml"
},
"rule": {
"generated": "rule.project.test.extra-service.web.toml",
"expected":
"rule.project.test.extra-service.web.expected.toml",
"replaces": {
"{{ip}}": config.data.get('docker.debug.host')
}
},
"secured": {
"generated":
"secured.project.test.extra-service.redirect.toml",
"expected":
"secured.project.test.extra-service.redirect.expected.toml"
},
"secured_path_prefix": {
"generated":
"secured.project.test.extra-service.path_prefix.toml",
"expected":
"secured.project.test.extra-service.path_prefix.expected.toml"
},
"secured_path_prefix_with_redirect": {
"generated":
"secured.project.test.extra-service.path_prefix_with_redirect.toml",
"expected":
"secured.project.test.extra-service.path_prefix_with_redirect.expected.toml"
}
}
for file in files:
generated = os.path.join(
config.data['traefik']['config_directory'],
files.get(file).get('generated'))
assert os.path.exists(generated)
expected = Path(
os.path.join(config.data['traefik']['config_directory'],
files.get(file).get('expected'))).read_text()
if files.get(file).get('replaces'):
for replace in files.get(file).get('replaces'):
expected = expected.replace(
replace,
files.get(file).get('replaces').get(replace))
assert expected == Path(generated).read_text()
def test_retrieve_environment_data(self):
features.register(DockerFeature())
load_registered_features()
action = actions.get(
'docker:display-info') # type:DockerDisplayInfoAction
assert {} == action._retrieve_environment_data(Dotty({}))
assert {} == action._retrieve_environment_data(Dotty({'toto': 'toto'}))
assert {
'AZERTY': '123'
} == action._retrieve_environment_data(
Dotty({'environment': {
'AZERTY': '123'
}}))
def test_binary_workdir(self, project_loader):
project_loader("binary-workdir")
features.register(DockerFeature())
load_registered_features()
register_actions_in_event_bus(True)
action = actions.get('docker:emit-docker-compose-config'
) # type:EmitDockerComposeConfigAction
action.execute()
assert len(list(binaries.all())) == 2
assert binaries.has("npm")
assert binaries.has("node")
def test_run_activate_deactivate_project(self, capsys: CaptureFixture,
project_loader):
project_loader("project")
features.register(CoreFeature())
features.register(ShellFeature())
load_registered_features()
action = ActivateAction(self.build_shell_integration())
action.execute()
capture = capsys.readouterr()
assert capture.out
assert not capture.err
filepath = re.match(self.filepath_regex, capture.out).group(1)
with open(filepath, 'r', encoding='utf-8') as file:
script = file.read()
export_match = re.findall(self.export_regex, script, re.MULTILINE)
env = dict(export_match)
system_path = env.get('PATH', '')
first = system_path.split(os.pathsep)[0]
assert first == os.path.normpath(os.path.join(os.getcwd(), "./bin")) \
or first == os.path.normpath(os.path.join(os.getcwd(), "./.bin"))
os.environ.update(env)
deactivate_action = DeactivateAction(self.build_shell_integration())
deactivate_action.execute()
capture = capsys.readouterr()
assert capture.out
assert not capture.err
filepath = re.match(self.filepath_regex, capture.out).group(1)
with open(filepath, 'r', encoding='utf-8') as file:
script = file.read()
export_match = re.findall(self.export_regex, script, re.MULTILINE)
env = dict(export_match)
system_path = env.get('PATH', '').split(os.pathsep)
first = system_path[0]
assert first != os.path.normpath(os.path.join(os.getcwd(), "./bin")) or \
first != os.path.normpath(os.path.join(os.getcwd(), "./.bin"))
