[issue-305] add testcases and update license_expression parser

Signed-off-by: Meret Behrens <meret.behrens@tngtech.com>
spdx · meretp · Dec 28, 2022 · Nov 25, 2022 · Dec 14, 2022 · Dec 14, 2022
commit e6332cbcc2fc38b832833cec3c84e4a6b45e4127
diff --git a/src/parser/json/license_expression_parser.py b/src/parser/json/license_expression_parser.py
@@ -13,17 +13,37 @@
 from src.model.license_expression import LicenseExpression
 from src.model.spdx_no_assertion import SpdxNoAssertion
 from src.model.spdx_none import SpdxNone
-from src.parser.json.dict_parsing_functions import construct_or_raise_parsing_error
+from src.parser.error import SPDXParsingError
+from src.parser.json.dict_parsing_functions import construct_or_raise_parsing_error, append_parsed_field_or_log_error, \
+    raise_parsing_error_if_logger_has_messages
+from src.parser.logger import Logger
 
 
 class LicenseExpressionParser:
-    def parse_license_expression(self, license_expression: Union[str, List[str]]) -> Union[LicenseExpression, SpdxNoAssertion, SpdxNone, List[LicenseExpression]]:
-        if license_expression == SpdxNone().__str__():
+    def parse_license_expression(self, license_expression_str_or_list: Union[str, List[str]]) -> Union[
+        LicenseExpression, SpdxNoAssertion, SpdxNone, List[LicenseExpression]]:
+        if license_expression_str_or_list == SpdxNone().__str__():
             return SpdxNone()
-        if license_expression == SpdxNoAssertion().__str__():
+        if license_expression_str_or_list == SpdxNoAssertion().__str__():
             return SpdxNoAssertion()
-        elif isinstance(license_expression, str):
-            license_expression = construct_or_raise_parsing_error(LicenseExpression, dict(expression_string=license_expression))
+        elif isinstance(license_expression_str_or_list, list):
+            return self.parse_license_expressions(license_expression_str_or_list)
+
+        else:
+            license_expression = construct_or_raise_parsing_error(LicenseExpression,
+                                                                  dict(
+                                                                      expression_string=license_expression_str_or_list))
             return license_expression
-        elif isinstance(license_expression, list):
-            return list(map(self.parse_license_expression, license_expression))
+
+    def parse_license_expressions(self, license_expression_str_or_list: List[str]) -> List[LicenseExpression]:
+        license_expressions = []
+        logger = Logger()
+        for license_expression_str in license_expression_str_or_list:
+            try:
+                license_expressions = append_parsed_field_or_log_error(logger, license_expressions,
+                                                                       license_expression_str,
+                                                                       self.parse_license_expression)
+            except SPDXParsingError as err:
+                logger.append(err.get_messages())
+        raise_parsing_error_if_logger_has_messages(logger)
+        return license_expressions
diff --git a/tests/parser/test_actor_parser.py b/tests/parser/test_actor_parser.py
@@ -15,21 +15,34 @@
 from src.parser.json.actor_parser import ActorParser
 
 
-def test_actor_parser():
+@pytest.mark.parametrize("actor_string,expected_type,expected_name,expected_mail", [
+    ("Person: Jane Doe (jane.doe@example.com)", ActorType.PERSON, "Jane Doe", "jane.doe@example.com"),
+    ("Organization: Example organization (organization@exaple.com)", ActorType.ORGANIZATION, "Example organization",
+     "organization@exaple.com"),
+    ("Organization: Example organization ( )", ActorType.ORGANIZATION, "Example organization", None),
+    ("Tool: Example tool ", ActorType.TOOL, "Example tool", None)])
+def test_actor_parser(actor_string, expected_type, expected_name, expected_mail):
     actor_parser = ActorParser()
-    actor_string = "Person: Jane Doe (jane.doe@example.com)"
 
     actor = actor_parser.parse_actor(actor_string)
 
-    assert actor.actor_type == ActorType.PERSON
-    assert actor.name == "Jane Doe"
-    assert actor.email == "jane.doe@example.com"
+    assert actor.actor_type == expected_type
+    assert actor.name == expected_name
+    assert actor.email == expected_mail
 
-def test_invalid_actor():
+
+@pytest.mark.parametrize("actor_string,expected_message", [
+    ("Perso: Jane Doe (jane.doe@example.com)",
+     "Actor Perso: Jane Doe (jane.doe@example.com) doesn't match any of person, organization or tool."),
+    ("Toole Example Tool ()",
+     "Actor Toole Example Tool () doesn't match any of person, organization or tool.")
+])
+def test_invalid_actor(actor_string, expected_message):
     actor_parser = ActorParser()
-    actor_string = "Perso: Jane Doe (jane.doe@example.com)"
+    actor_string = actor_string
 
     with pytest.raises(SPDXParsingError) as err:
         _ = actor_parser.parse_actor(actor_string)
     assert err.typename == 'SPDXParsingError'
-    assert err.value.messages[0] == "Actor Perso: Jane Doe (jane.doe@example.com) doesn't match any of person, organization or tool."
+    assert err.value.messages[
+               0] == expected_message
diff --git a/tests/parser/test_checksum_parser.py b/tests/parser/test_checksum_parser.py
@@ -41,3 +41,14 @@ def test_invalid_checksum():
     assert err.typename == 'SPDXParsingError'
     assert err.value.messages[0] == "Error while parsing Checksum: ['Algorithm SHA not valid for checksum.']"
 
+def test_incomplete_checksum():
+    checksum_parser = ChecksumParser()
+    checksum_dict= {
+        "algorithm": "SHA1"
+    }
+
+    with pytest.raises(SPDXParsingError) as err:
+        _ = checksum_parser.parse_checksum(checksum_dict)
+
+    assert err.type == SPDXParsingError
+    assert err.value.messages == ["Error while constructing Checksum: ['SetterError Checksum: type of argument \"value\" must be str; got NoneType instead: None']"]
diff --git a/tests/parser/test_license_expression_parser.py b/tests/parser/test_license_expression_parser.py
@@ -8,34 +8,70 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import pytest
+
+from src.model.license_expression import LicenseExpression
 from src.model.spdx_no_assertion import SpdxNoAssertion
 from src.model.spdx_none import SpdxNone
+from src.parser.error import SPDXParsingError
 from src.parser.json.license_expression_parser import LicenseExpressionParser
 
 
 def test_license_expression_parser():
     license_expression_parser = LicenseExpressionParser()
-    license_expression_str= "License-Ref1"
+    license_expression_str = "License-Ref1"
 
-    license_expression = license_expression_parser.parse_license_expression(license_expression=license_expression_str)
+    license_expression = license_expression_parser.parse_license_expression(
+        license_expression_str_or_list=license_expression_str)
 
     assert license_expression.expression_string == "License-Ref1"
 
+
 def test_license_expression_no_assert():
     license_expression_parser = LicenseExpressionParser()
-    license_expression_str= "NOASSERTION"
+    license_expression_str = "NOASSERTION"
 
-    spdx_no_assertion = license_expression_parser.parse_license_expression(license_expression=license_expression_str)
+    spdx_no_assertion = license_expression_parser.parse_license_expression(
+        license_expression_str_or_list=license_expression_str)
 
     assert type(spdx_no_assertion) == SpdxNoAssertion
 
+
 def test_license_expression_none():
     license_expression_parser = LicenseExpressionParser()
     license_expression_str = "NONE"
 
     spdx_none = license_expression_parser.parse_license_expression(
-        license_expression=license_expression_str)
+        license_expression_str_or_list=license_expression_str)
 
     assert type(spdx_none) == SpdxNone
 
 
+@pytest.mark.parametrize("invalid_license_expression,expected_message",
+                         [(56, ["Error while constructing LicenseExpression: ['SetterError LicenseExpression: "
+                                'type of argument "expression_string" must be str; got int instead: 56\']']
+                           ),
+                          (["First Expression", 4, 6],
+                           ["Error while constructing LicenseExpression: ['SetterError LicenseExpression: "
+                            'type of argument "expression_string" must be str; got int instead: 4\']',
+                            "Error while constructing LicenseExpression: ['SetterError LicenseExpression: "
+                            'type of argument "expression_string" must be str; got int instead: 6\']'])])
+def test_invalid_license_expression(invalid_license_expression, expected_message):
+    license_expression_parser = LicenseExpressionParser()
+
+    with pytest.raises(SPDXParsingError) as err:
+        _ = license_expression_parser.parse_license_expression(invalid_license_expression)
+
+    assert err.type == SPDXParsingError
+    assert err.value.messages == expected_message
+
+
+def test_license_expressions():
+    license_expression_parser = LicenseExpressionParser()
+    license_expressions_list = ["First License", "Second License", "Third License"]
+
+    license_expressions = license_expression_parser.parse_license_expression(license_expressions_list)
+
+    assert len(license_expressions) == 3
+    assert license_expressions == [LicenseExpression("First License"), LicenseExpression("Second License"),
+                                   LicenseExpression("Third License")]