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()