def _copy_resource(path, resource_name=None):
LOG.debug("Writing '%s'", path)
if not resource_name:
resource_name = path.name
contents = resource_stream(__name__,
f"data/{resource_name}").read()
project.safewrite(path, contents)
def test_generate_docs_with_multiref_property(project, tmp_path_factory):
project.schema = resource_json(
__name__, "data/schema/valid/valid_multiref_property.json")
project.type_name = "AWS::Color::Red"
# tmpdir conflicts with other tests, make a unique one
project.root = tmp_path_factory.mktemp("generate_with_docs_type_complex")
mock_plugin = MagicMock(spec=["generate"])
with patch.object(project, "_plugin", mock_plugin):
project.generate()
project.generate_docs()
mock_plugin.generate.assert_called_once_with(project)
docs_dir = project.root / "docs"
readme_file = project.root / "docs" / "README.md"
assert docs_dir.is_dir()
assert readme_file.is_file()
with patch.object(project, "_plugin", mock_plugin):
project.generate()
readme_contents = readme_file.read_text(encoding="utf-8")
readme_contents_target = resource_stream(
__name__, "data/schema/target_output/multiref.md")
read_me_stripped = readme_contents.strip().replace(" ", "")
read_me_target_stripped = readme_contents_target.read().strip().replace(
" ", "")
LOG.debug("read_me_stripped %s", read_me_stripped)
LOG.debug("read_me_target_stripped %s", read_me_target_stripped)
assert project.type_name in readme_contents
assert read_me_stripped == read_me_target_stripped
def plugin():
mock_plugin = create_autospec(LanguagePlugin)
mock_plugin.project_settings_defaults.return_value = resource_stream(
__name__, "data/project_defaults.yaml")
mock_plugin.project_settings_schema.return_value = resource_json(
__name__, "data/project_schema.json")
return mock_plugin
def init_shared(self, project, src, tst, resources):
"""Writing project configuration"""
# .gitignore
path = project.root / ".gitignore"
LOG.debug("Writing .gitignore: %s", path)
contents = resource_stream(__name__, "data/java.gitignore").read()
project.safewrite(path, contents)
# pom.xml
path = project.root / "pom.xml"
LOG.debug("Writing Maven POM: %s", path)
template = self.env.get_template("init/shared/pom.xml")
artifact_id = "{}-handler".format(project.hypenated_name)
contents = template.render(
group_id=self.package_name,
artifact_id=artifact_id,
executable=EXECUTABLE,
schema_file_name=project.schema_filename,
package_name=self.package_name,
)
project.safewrite(path, contents)
# lombok.config
path = project.root / "lombok.config"
LOG.debug("Writing Lombok Config: %s", path)
template = self.env.get_template("init/shared/lombok.config")
contents = template.render()
project.safewrite(path, contents)
LOG.debug("Writing callback context")
template = self.env.get_template("init/shared/CallbackContext.java")
path = src / "CallbackContext.java"
contents = template.render(package_name=self.package_name)
project.safewrite(path, contents)
path = src / "Configuration.java"
LOG.debug("Writing configuration: %s", path)
template = self.env.get_template("init/shared/StubConfiguration.java")
contents = template.render(
package_name=self.package_name,
schema_file_name=project.schema_filename,
pojo_name="ResourceModel",
)
project.safewrite(path, contents)
# CloudFormation/SAM template for handler lambda
path = project.root / "template.yml"
LOG.debug("Writing SAM template: %s", path)
template = self.env.get_template(
"template.yml") # this template is in the CLI itself
handler_params = {
"Handler": project.entrypoint,
"Runtime": project.runtime,
"CodeUri": self.CODE_URI.format(artifact_id),
}
contents = template.render(
resource_type=project.type_name,
functions={
"TypeFunction": handler_params,
"TestEntrypoint": {
**handler_params,
"Handler": project.test_entrypoint,
},
},
)
project.safewrite(path, contents)
# generate docs
path = project.root / "README.md"
LOG.debug("Writing README: %s", path)
template = self.env.get_template("init/shared/README.md")
contents = template.render(
type_name=project.type_name,
schema_path=project.schema_path,
executable=EXECUTABLE,
)
project.safewrite(path, contents)
# log4j2
path = resources / "log4j2.xml"
LOG.debug("Writing log4j2: %s", path)
contents = resource_stream(__name__, "data/log4j2.xml").read()
project.safewrite(path, contents)
self.init_handlers(project, src, tst)
def init(self, project):
LOG.debug("Init started")
self._prompt_for_go_path(project)
self._init_settings(project)
# .gitignore
path = project.root / ".gitignore"
LOG.debug("Writing .gitignore: %s", path)
contents = resource_stream(__name__, "data/go.gitignore").read()
project.safewrite(path, contents)
# project folder structure
src = project.root / "cmd" / "resource"
LOG.debug("Making source folder structure: %s", src)
src.mkdir(parents=True, exist_ok=True)
inter = project.root / "internal"
inter.mkdir(parents=True, exist_ok=True)
# Makefile
path = project.root / "Makefile"
LOG.debug("Writing Makefile: %s", path)
template = self.env.get_template("Makefile")
contents = template.render()
project.overwrite(path, contents)
# go.mod
path = project.root / "go.mod"
LOG.debug("Writing go.mod: %s", path)
template = self.env.get_template("go.mod.tple")
contents = template.render(path=Path(
project.settings.get("import_path",
project.settings.get("importpath"))))
project.safewrite(path, contents)
# CloudFormation/SAM template for handler lambda
path = project.root / "template.yml"
LOG.debug("Writing SAM template: %s", path)
template = self.env.get_template("template.yml")
handler_params = {
"Handler": project.entrypoint,
"Runtime": project.runtime,
"CodeUri": self.CODE_URI,
}
test_handler_params = {
"Handler": project.entrypoint,
"Runtime": project.runtime,
"CodeUri": self.CODE_URI,
"Environment": "",
" Variables": "",
" MODE": "Test",
}
contents = template.render(
resource_type=project.type_name,
functions={
"TypeFunction": handler_params,
"TestEntrypoint": test_handler_params,
},
)
project.safewrite(path, contents)
LOG.debug("Writing handlers and tests")
self.init_handlers(project, src)
# README
path = project.root / "README.md"
LOG.debug("Writing README: %s", path)
template = self.env.get_template("README.md")
contents = template.render(
type_name=project.type_name,
schema_path=project.schema_path,
executable=EXECUTABLE,
files="model.go and main.go",
)
project.safewrite(path, contents)
LOG.debug("Init complete")
def init(self, project):
LOG.debug("Init started")
self._prompt_for_namespace(project)
self._init_settings(project)
# .gitignore
path = project.root / ".gitignore"
LOG.debug("Writing .gitignore: %s", path)
contents = resource_stream(__name__, "data/java.gitignore").read()
project.safewrite(path, contents)
# maven folder structure
src = (project.root / "src" / "main" /
"java").joinpath(*self.namespace)
LOG.debug("Making source folder structure: %s", src)
src.mkdir(parents=True, exist_ok=True)
tst = (project.root / "src" / "test" /
"java").joinpath(*self.namespace)
LOG.debug("Making test folder structure: %s", tst)
tst.mkdir(parents=True, exist_ok=True)
path = project.root / "pom.xml"
LOG.debug("Writing Maven POM: %s", path)
template = self.env.get_template("pom.xml")
artifact_id = "{}-handler".format(project.hypenated_name)
contents = template.render(
group_id=self.package_name,
artifact_id=artifact_id,
executable=EXECUTABLE,
schema_file_name=project.schema_filename,
package_name=self.package_name,
)
project.safewrite(path, contents)
path = project.root / "lombok.config"
LOG.debug("Writing Lombok Config: %s", path)
template = self.env.get_template("lombok.config")
contents = template.render()
project.safewrite(path, contents)
# CloudFormation/SAM template for handler lambda
path = project.root / "template.yml"
LOG.debug("Writing SAM template: %s", path)
template = self.env.get_template("template.yml")
handler_params = {
"Handler": project.entrypoint,
"Runtime": project.runtime,
"CodeUri": self.CODE_URI.format(artifact_id),
}
contents = template.render(
resource_type=project.type_name,
functions={
"TypeFunction": handler_params,
"TestEntrypoint": {
**handler_params,
"Handler": project.test_entrypoint,
},
},
)
project.safewrite(path, contents)
LOG.debug("Writing handlers and tests")
self.init_handlers(project, src, tst)
LOG.debug("Writing callback context")
template = self.env.get_template("CallbackContext.java")
path = src / "CallbackContext.java"
contents = template.render(package_name=self.package_name)
project.safewrite(path, contents)
path = src / "Configuration.java"
LOG.debug("Writing configuration: %s", path)
template = self.env.get_template("StubConfiguration.java")
contents = template.render(
package_name=self.package_name,
schema_file_name=project.schema_filename,
pojo_name="ResourceModel",
)
project.safewrite(path, contents)
# generated docs
path = project.root / "README.md"
LOG.debug("Writing README: %s", path)
template = self.env.get_template("README.md")
contents = template.render(
type_name=project.type_name,
schema_path=project.schema_path,
executable=EXECUTABLE,
)
project.safewrite(path, contents)
LOG.debug("Init complete")
