8000 [issue-503] validate license_expressions only as a List of LicenseExp… · HarshvMahawar/tools-python@4a0675f · GitHub
[go: up one dir, main page]
Skip to content

Commit 4a0675f

Browse files
meretpmeretp
committed
[issue-503] validate license_expressions only as a List of LicenseExpression, SpdxNone or SpdxNoAssertion
Signed-off-by: Meret Behrens <meret.behrens@tngtech.com>
1 parent 34d0045 commit 4a0675f

File tree

4 files changed

+26
-52
lines changed

4 files changed

+26
-52
lines changed

‎src/spdx/parser/jsonlikedict/license_expression_parser.py

Lines changed: 0 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -35,17 +35,3 @@ def parse_license_expression(license_expression_str: str) -> Union[LicenseExpres
3535
raise SPDXParsingError([f"Error parsing LicenseExpression: {err.args[0]}: {license_expression_str}"])
3636

3737
return license_expression
38-
39-
def parse_license_expressions(self, license_expression_str_or_list: Union[str, List[str]]) -> Union[
40-
LicenseExpression, SpdxNone, SpdxNoAssertion, List[Union[LicenseExpression, SpdxNone, SpdxNoAssertion]]]:
41-
if not isinstance(license_expression_str_or_list, List):
42-
return self.parse_license_expression(license_expression_str_or_list)
43-
44-
license_expressions = []
45-
logger = Logger()
46-
for license_expression_str in license_expression_str_or_list:
47-
license_expressions = append_parsed_field_or_log_error(logger, license_expressions,
48-
license_expression_str,
49-
self.parse_license_expression)
50-
raise_parsing_error_if_logger_has_messages(logger)
51-
return license_expressions

‎src/spdx/validation/license_expression_validator.py

Lines changed: 10 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -19,12 +19,11 @@
1919
from spdx.validation.validation_message import ValidationMessage, ValidationContext, SpdxElementType
2020

2121

22-
def validate_license_expressions(license_expressions: Optional[
23-
Union[List[LicenseExpression], SpdxNoAssertion, SpdxNone]], document: Document, parent_id: str) -> List[ValidationMessage]:
24-
if license_expressions in [SpdxNoAssertion(), SpdxNone(), None]:
25-
return []
26-
27-
context = ValidationContext(parent_id=parent_id, element_type=SpdxElementType.LICENSE_EXPRESSION, full_element=license_expressions)
22+
def validate_license_expressions(
23+
license_expressions: List[Union[LicenseExpression, SpdxNoAssertion, SpdxNone]],
24+
document: Document, parent_id: str) -> List[ValidationMessage]:
25+
context = ValidationContext(parent_id=parent_id, element_type=SpdxElementType.LICENSE_EXPRESSION,
26+
full_element=license_expressions)
2827
validation_messages = []
2928

3029
for license_expression in license_expressions:
@@ -33,13 +32,15 @@ def validate_license_expressions(license_expressions: Optional[
3332
return validation_messages
3433

3534

36-
def validate_license_expression(license_expression: Optional[
37-
Union[LicenseExpression, SpdxNoAssertion, SpdxNone]], document: Document, parent_id: str, context: ValidationContext = None) -> List[ValidationMessage]:
35+
def validate_license_expression(
36+
license_expression: Optional[Union[LicenseExpression, SpdxNoAssertion, SpdxNone]], document: Document,
37+
parent_id: str, context: ValidationContext = None) -> List[ValidationMessage]:
3838
if license_expression in [SpdxNoAssertion(), SpdxNone(), None]:
3939
return []
4040

4141
if not context:
42-
context = ValidationContext(parent_id=parent_id, element_type=SpdxElementType.LICENSE_EXPRESSION, full_element=license_expression)
42+
context = ValidationContext(parent_id=parent_id, element_type=SpdxElementType.LICENSE_EXPRESSION,
43+
full_element=license_expression)
4344

4445
validation_messages = []
4546
license_ref_ids: List[str] = [license_ref.license_id for license_ref in document.extracted_licensing_info]

‎tests/spdx/parser/jsonlikedict/test_license_expression_parser.py

Lines changed: 13 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -11,14 +11,26 @@
1111
from unittest import TestCase
1212

1313
import pytest
14-
from license_expression import Licensing
14+
from license_expression import get_spdx_licensing
1515

1616
from spdx.model.spdx_no_assertion import SpdxNoAssertion
1717
from spdx.model.spdx_none import SpdxNone
1818
from spdx.parser.error import SPDXParsingError
1919
from spdx.parser.jsonlikedict.license_expression_parser import LicenseExpressionParser
2020

2121

22+
@pytest.mark.parametrize("license_expression_str, expected_license",
23+
[("First License", get_spdx_licensing().parse("First License")),
24+
("Second License", get_spdx_licensing().parse("Second License")),
25+
("NOASSERTION", SpdxNoAssertion()),
26+
("NONE", SpdxNone())])
27+
def test_parse_license_expression(license_expression_str, expected_license):
28+
license_expression_parser = LicenseExpressionParser()
29+
license_expression = license_expression_parser.parse_license_expression(license_expression_str)
30+
31+
assert license_expression == expected_license
32+
33+
2234
@pytest.mark.parametrize("invalid_license_expression,expected_message",
2335
[(56,
2436
["Error parsing LicenseExpression: expression must be a string and not: <class 'int'>: 56"]),
@@ -30,29 +42,3 @@ def test_parse_invalid_license_expression(invalid_license_expression, expected_m
3042
license_expression_parser.parse_license_expression(invalid_license_expression)
3143

3244
TestCase().assertCountEqual(err.value.get_messages(), expected_message)
33-
34-
35-
def test_parse_license_expressions():
36-
license_expression_parser = LicenseExpressionParser()
37-
license_expressions_list = ["First License", "Second License", "NONE", "NOASSERTION"]
38-
39-
license_expressions = license_expression_parser.parse_license_expressions(license_expressions_list)
40-
41-
assert len(license_expressions) == 4
42-
TestCase().assertCountEqual(license_expressions,
43-
[Licensing().parse("First License"), Licensing().parse("Second License"),
44-
SpdxNone(), SpdxNoAssertion()])
45-
46-
47-
@pytest.mark.parametrize("invalid_license_expressions, expected_message",
48-
[(["First Expression", 4, 6],
49-
["Error parsing LicenseExpression: expression must be a string and not: <class 'int'>: 4",
50-
"Error parsing LicenseExpression: expression must be a string and not: <class 'int'>: 6"])
51-
])
52-
def test_parse_invalid_license_expressions(invalid_license_expressions, expected_message):
53-
license_expression_parser = LicenseExpressionParser()
54-
55-
with pytest.raises(SPDXParsingError) as err:
56-
license_expression_parser.parse_license_expressions(invalid_license_expressions)
57-
58-
TestCase().assertCountEqual(err.value.get_messages(), expected_message)

‎tests/spdx/validation/test_license_expression_validator.py

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -47,9 +47,10 @@ def test_none_and_no_assertion(expression):
4747

4848

4949
@pytest.mark.parametrize("expression_list",
50-
[SpdxNone(), SpdxNoAssertion(),
50+
[[SpdxNone()], [SpdxNoAssertion()],
5151
[get_spdx_licensing().parse("MIT and GPL-3.0-only"),
52-
get_spdx_licensing().parse(FIXTURE_LICENSE_ID)]
52+
get_spdx_licensing().parse(FIXTURE_LICENSE_ID)],
53+
[SpdxNone(), get_spdx_licensing().parse("MIT"), SpdxNoAssertion()]
5354
])
5455
def test_valid_license_expressions(expression_list):
5556
document: Document = document_fixture()

0 commit comments

Comments
 (0)
0