def test_invalid_grammar(self):
with testtools.ExpectedException(
grammar.errors.GrammarSyntaxError,
self.expected_exception):
processor = grammar.GrammarProcessor(
self.grammar, snapcraft.ProjectOptions(), self.checker)
processor.process()
def test(
self,
monkeypatch,
on_arch,
to_arch,
body,
else_bodies,
host_arch,
expected_packages,
):
monkeypatch.setattr(platform, "machine", lambda: host_arch)
monkeypatch.setattr(platform, "architecture", lambda: ("64bit", "ELF"))
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(target_deb_arch="armhf"), lambda x: True
)
statements = [
on.OnStatement(on=on_arch, body=None, processor=processor),
to.ToStatement(to=to_arch, body=None, processor=processor),
]
statement = compound.CompoundStatement(
statements=statements, body=body, processor=processor
)
for else_body in else_bodies:
statement.add_else(else_body)
assert statement.process() == expected_packages
def get_build_environment(self) -> List[Dict[str, str]]:
if not self.__build_environment:
processor = grammar.GrammarProcessor(
self._get_property("build-environment"), self._project, lambda x: True,
)
self.__build_environment = processor.process()
return self.__build_environment
def test_basic_grammar(self, platform_machine_mock,
platform_architecture_mock):
platform_machine_mock.return_value = self.host_arch
platform_architecture_mock.return_value = ('64bit', 'ELF')
processor = grammar.GrammarProcessor(
self.grammar, snapcraft.ProjectOptions(), self.checker)
self.assertThat(
processor.process(), Equals(self.expected_packages))
def test_try_statement_grammar(self):
processor = grammar.GrammarProcessor(None, snapcraft.ProjectOptions(),
self.checker)
statement = _try.TryStatement(body=self.body, processor=processor)
for else_body in self.else_bodies:
statement.add_else(else_body)
self.assertThat(statement.process(), Equals(self.expected_packages))
def test_basic_grammar(self, monkeypatch, grammar_entry, host_arch,
expected_packages):
monkeypatch.setattr(platform, "machine", lambda: host_arch)
monkeypatch.setattr(platform, "architecture", lambda: ("64bit", "ELF"))
processor = grammar.GrammarProcessor(grammar_entry,
snapcraft.ProjectOptions(),
lambda x: "invalid" not in x)
assert processor.process() == expected_packages
def get_build_packages(self) -> Set[str]:
if not self.__build_packages:
processor = grammar.GrammarProcessor(
self._build_package_grammar, self._project,
repo.Repo.build_package_is_valid,
transformer=package_transformer)
self.__build_packages = processor.process()
return self.__build_packages
def test_invalid_grammar(self, grammar_entry, expected_exception):
processor = grammar.GrammarProcessor(grammar_entry,
snapcraft.ProjectOptions(),
lambda x: True)
with pytest.raises(grammar.errors.GrammarSyntaxError) as error:
processor.process()
assert re.match(expected_exception, str(error.value))
def test_try_statement_grammar(self, body, else_bodies, expected_packages):
processor = grammar.GrammarProcessor(None, snapcraft.ProjectOptions(),
lambda x: "invalid" not in x)
statement = _try.TryStatement(body=body, processor=processor)
for else_body in else_bodies:
statement.add_else(else_body)
assert statement.process() == expected_packages
def get_build_packages(self) -> Set[str]:
if not self.__build_packages:
processor = grammar.GrammarProcessor(
self._build_package_grammar,
self._project,
repo.Repo.build_package_is_valid,
)
self.__build_packages = set(processor.process())
return self.__build_packages
def get_source(self) -> str:
if not self.__source:
# The grammar is array-based, even though we only support a single
# source.
processor = grammar.GrammarProcessor(self._source_grammar,
self._project, lambda s: True)
source_array = processor.process()
if len(source_array) > 0:
self.__source = source_array.pop()
return self.__source
def get_build_packages(self) -> Set[str]:
if not self.__build_packages:
processor = grammar.GrammarProcessor(
self._get_property("build-packages"),
self._project,
self._repo.build_package_is_valid,
)
self.__build_packages = set(processor.process())
return self.__build_packages
def get_stage_snaps(self) -> Set[str]:
if not self.__stage_snaps:
processor = grammar.GrammarProcessor(
self._get_property("stage-snaps"),
self._project,
repo.snaps.SnapPackage.is_valid_snap,
)
self.__stage_snaps = set(processor.process())
return self.__stage_snaps
def test_on_duplicates_raises(self):
"""Test that multiple identical selector sets is an error."""
with testtools.ExpectedException(
grammar.errors.GrammarSyntaxError,
"Invalid grammar syntax: found duplicate 'on amd64,i386' "
'statements. These should be merged.'):
processor = grammar.GrammarProcessor(
self.grammar, snapcraft.ProjectOptions(), self.checker)
processor.process()
def get_build_snaps(self) -> Set[str]:
if not self.__build_snaps:
processor = grammar.GrammarProcessor(
getattr(self._plugin, "build_snaps", []),
self._project,
repo.snaps.SnapPackage.is_valid_snap,
)
self.__build_snaps = processor.process()
return self.__build_snaps
def test_duplicates(entry):
"""Test that multiple identical selector sets is an error."""
processor = grammar.GrammarProcessor(entry, snapcraft.ProjectOptions(),
lambda x: True)
with pytest.raises(grammar.errors.GrammarSyntaxError) as error:
processor.process()
expected = ("Invalid grammar syntax: found duplicate 'on amd64,i386' "
"statements. These should be merged.")
assert expected in str(error.value)
def get_stage_packages(self) -> Set[str]:
if not self.__stage_packages:
processor = grammar.GrammarProcessor(
self._get_property("stage-packages"),
self._project,
self._repo.build_package_is_valid,
transformer=package_transformer,
)
self.__stage_packages = set(processor.process())
return self.__stage_packages
def get_stage_packages(self) -> Set[str]:
if not self.__stage_packages:
processor = grammar.GrammarProcessor(
getattr(self._plugin, "stage_packages", []),
self._project,
self._repo.is_valid,
transformer=package_transformer,
)
self.__stage_packages = processor.process()
return self.__stage_packages
def test_else_fail(self):
processor = grammar.GrammarProcessor(None, snapcraft.ProjectOptions(),
self.checker)
statement = _try.TryStatement(body=['invalid'], processor=processor)
statement.add_else(None)
with testtools.ExpectedException(
grammar.errors.UnsatisfiedStatementError,
"Unable to satisfy 'try', failure forced"):
statement.process()
def test_else_fail():
processor = grammar.GrammarProcessor(None, snapcraft.ProjectOptions(),
lambda x: "invalid" not in x)
statement = _try.TryStatement(body=["invalid"], processor=processor)
statement.add_else(None)
with pytest.raises(grammar.errors.UnsatisfiedStatementError) as error:
statement.process()
assert "Unable to satisfy 'try', failure forced" in str(error.value)
def test_on_statement_invalid_grammar(self):
with testtools.ExpectedException(
grammar.errors.OnStatementSyntaxError,
self.expected_exception):
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(), self.checker)
statement = on.OnStatement(
on=self.on, body=self.body, processor=processor)
for else_body in self.else_bodies:
statement.add_else(else_body)
statement.process()
def test(self, monkeypatch, to_arch, body, else_bodies, target_arch,
expected_packages):
monkeypatch.setattr(platform, "machine", lambda: "x86_64")
monkeypatch.setattr(platform, "architecture", lambda: ("64bit", "ELF"))
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(target_deb_arch=target_arch),
lambda x: True)
statement = to.ToStatement(to=to_arch, body=body, processor=processor)
for else_body in else_bodies:
statement.add_else(else_body)
assert statement.process() == expected_packages
def test(self, on_arch, body, else_bodies, expected_exception):
with pytest.raises(grammar.errors.OnStatementSyntaxError) as error:
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(), lambda x: "invalid" not in x
)
statement = on.OnStatement(on=on_arch, body=body, processor=processor)
for else_body in else_bodies:
statement.add_else(else_body)
statement.process()
assert re.match(expected_exception, str(error.value))
def test_on_statement_grammar(self, platform_machine_mock,
platform_architecture_mock):
platform_machine_mock.return_value = self.host_arch
platform_architecture_mock.return_value = ('64bit', 'ELF')
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(), self.checker)
statement = on.OnStatement(
on=self.on, body=self.body, processor=processor)
for else_body in self.else_bodies:
statement.add_else(else_body)
self.assertThat(statement.process(), Equals(self.expected_packages))
def test(self, monkeypatch, on_arch, body, else_bodies, host_arch,
expected_packages):
monkeypatch.setattr(platform, "machine", lambda: host_arch)
monkeypatch.setattr(platform, "architecture", lambda: ("64bit", "ELF"))
processor = grammar.GrammarProcessor(None, snapcraft.ProjectOptions(),
lambda x: True)
statement = on.OnStatement(on=on_arch, body=body, processor=processor)
for else_body in else_bodies:
statement.add_else(else_body)
assert statement.process() == expected_packages
def test_else_fail(monkeypatch):
monkeypatch.setattr(platform, "machine", lambda: "x86_64")
monkeypatch.setattr(platform, "architecture", lambda: ("64bit", "ELF"))
processor = grammar.GrammarProcessor(None, snapcraft.ProjectOptions(),
lambda x: True)
statement = on.OnStatement(on="on i386", body=["foo"], processor=processor)
statement.add_else(None)
with pytest.raises(grammar.errors.UnsatisfiedStatementError) as error:
statement.process()
assert str(error.value) == "Unable to satisfy 'on i386', failure forced"
def test(self, to_arch, body, else_bodies, target_arch, expected_exception):
with pytest.raises(grammar.errors.ToStatementSyntaxError) as error:
processor = grammar.GrammarProcessor(
None,
snapcraft.ProjectOptions(target_deb_arch=target_arch),
lambda x: True,
)
statement = to.ToStatement(to=to_arch, body=body, processor=processor)
for else_body in else_bodies:
statement.add_else(else_body)
statement.process()
assert re.match(expected_exception, str(error.value))
def test_to_statement_grammar(self, platform_machine_mock,
platform_architecture_mock):
platform_machine_mock.return_value = 'x86_64'
platform_architecture_mock.return_value = ('64bit', 'ELF')
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(target_deb_arch=self.target_arch),
self.checker)
statement = to.ToStatement(to=self.to,
body=self.body,
processor=processor)
for else_body in self.else_bodies:
statement.add_else(else_body)
self.assertThat(statement.process(), Equals(self.expected_packages))
def test_to_statement_invalid_grammar(self):
with testtools.ExpectedException(grammar.errors.ToStatementSyntaxError,
self.expected_exception):
processor = grammar.GrammarProcessor(
None,
snapcraft.ProjectOptions(target_deb_arch=self.target_arch),
self.checker)
statement = to.ToStatement(to=self.to,
body=self.body,
processor=processor)
for else_body in self.else_bodies:
statement.add_else(else_body)
statement.process()
def test_else_fail(self, platform_machine_mock,
platform_architecture_mock):
platform_machine_mock.return_value = 'x86_64'
platform_architecture_mock.return_value = ('64bit', 'ELF')
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(), self.checker)
statement = on.OnStatement(
on='on i386', body=['foo'], processor=processor)
statement.add_else(None)
with testtools.ExpectedException(
grammar.errors.UnsatisfiedStatementError,
"Unable to satisfy 'on i386', failure forced"):
statement.process()
