#3211 [SDL 0234] Proxy Library RPC Generation (#3213)

* #3211 [SDL 0234] Proxy Library RPC Generation

  * Split existing `InterfaceGenerator` into `InterfaceParser` and `InterfaceGenerator`
  * Moved InterfaceParser into `smartdevicelink/rpc_spec`
  * Rejoined `InterfaceParser` as `tools/rpc_spec` Git submodule from `smartdevicelink/rpc_spec`
  * Refactored `InterfaceGenerator` to use Parser from `tools/rpc_spec` Git submodule and be compatible with Python 3.5

* Replaced url SSH to HTTPS in submodule

* refactoring according to comments in pull/202

* move common parsers to rpc_spec repo

* change cmake argument

* fix cmake argument list

* fix cmake argument list

* fix cmake argument list

* small refactoring as requested in code review

* adding *.xsd

* adding *.xsd

* xmlschema dependency added for python interface generator

* align changes from parser rpc_spec

* align changes from parser rpc_spec

* align with rpc_spec

* moved xmlschema python dependency installation to build script

* installing all python requirements

* Corrected requirements file

* Additional dependencies for requirements

* Correcting requirements

* adding jsoncpp submodule

* fixing unit tests

* fixing unit tests

* rename CodeFormatAndQuality

* updated rpc_spec reference

Co-authored-by: Aleksandr Mishchenko <amishchenko@luxoft.com>
Co-authored-by: Kostiantyn Sologubov <ksologubov@luxoft.com>

1 files changed, 52 insertions, 36 deletions

diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py
index f2fecdb901..90700fdbb9 100755
--- a/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py
+++ b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py
@@ -1,13 +1,25 @@
 """JSONRPC XML parser unit test."""
 import os
+import sys
 import unittest
-
-import generator.Model
-import generator.parsers.JSONRPC
+from pathlib import Path
+
+sys.path.append(Path(__file__).absolute().parents[3].as_posix())
+sys.path.append(Path(__file__).absolute().parents[4].joinpath('rpc_spec/InterfaceParser').as_posix())
+try:
+    import generator.parsers.JSONRPC
+    from model.array import Array
+    from model.boolean import Boolean
+    from model.enum_subset import EnumSubset
+    from model.integer import Integer
+    from model.float import Float
+    from model.string import String
+except ModuleNotFoundError as error:
+    print('{}.\nJSONRPC\tProbably you did not initialize submodule'.format(error))
+    sys.exit(1)
 
 
 class TestJSONRPCVParser(unittest.TestCase):
-
     """Test for JSONRPC xml parser."""
 
     class _Issue:
@@ -21,7 +33,7 @@ class TestJSONRPCVParser(unittest.TestCase):
     def setUp(self):
         """Test initialization."""
         self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \
-            "/valid_JSONRPC.xml"
+                              "/valid_JSONRPC.xml"
         self.parser = generator.parsers.JSONRPC.Parser()
 
     def test_valid_xml(self):
@@ -37,7 +49,7 @@ class TestJSONRPCVParser(unittest.TestCase):
                               "interface1_design_description": "dd",
                               "interface2_attribute": "value",
                               "interface2_description":
-                              "Description of interface2",
+                                  "Description of interface2",
                               "interface2_todos": "i2 todo"},
                              interface.params)
 
@@ -217,7 +229,7 @@ class TestJSONRPCVParser(unittest.TestCase):
             name="member1",
             description=["Param1 description"])
         self.assertTrue(member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.Integer)
+        self.assertIsInstance(member.param_type, Integer)
         self.assertIsNone(member.param_type.min_value)
         self.assertIsNone(member.param_type.max_value)
 
@@ -226,13 +238,13 @@ class TestJSONRPCVParser(unittest.TestCase):
         self.verify_base_item(item=member, name="member2",
                               platform="member2 platform")
         self.assertTrue(member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.Boolean)
+        self.assertIsInstance(member.param_type, Boolean)
 
         self.assertIn("member3", struct.members)
         member = struct.members["member3"]
         self.verify_base_item(item=member, name="member3")
         self.assertEqual(False, member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.Double)
+        self.assertIsInstance(member.param_type, Float)
         self.assertIsNone(member.param_type.min_value)
         self.assertAlmostEqual(20.5, member.param_type.max_value)
 
@@ -240,11 +252,11 @@ class TestJSONRPCVParser(unittest.TestCase):
         member = struct.members["member4"]
         self.verify_base_item(item=member, name="member4")
         self.assertTrue(member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsInstance(member.param_type, Array)
         self.assertIsNone(member.param_type.min_size)
         self.assertIsNone(member.param_type.max_size)
         self.assertIsInstance(member.param_type.element_type,
-                              generator.Model.Integer)
+                              Integer)
         self.assertEqual(11, member.param_type.element_type.min_value)
         self.assertEqual(100, member.param_type.element_type.max_value)
 
@@ -263,18 +275,18 @@ class TestJSONRPCVParser(unittest.TestCase):
         member = struct.members["m1"]
         self.verify_base_item(item=member, name="m1")
         self.assertTrue(member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertIsInstance(member.param_type, String)
         self.assertIsNone(member.param_type.max_length)
 
         self.assertIn("m2", struct.members)
         member = struct.members["m2"]
         self.verify_base_item(item=member, name="m2")
         self.assertTrue(member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsInstance(member.param_type, Array)
         self.assertEqual(1, member.param_type.min_size)
         self.assertEqual(50, member.param_type.max_size)
         self.assertIsInstance(member.param_type.element_type,
-                              generator.Model.String)
+                              String)
         self.assertEqual(100, member.param_type.element_type.max_length)
 
         self.assertIn("m3", struct.members)
@@ -287,7 +299,7 @@ class TestJSONRPCVParser(unittest.TestCase):
         member = struct.members["m4"]
         self.verify_base_item(item=member, name="m4")
         self.assertTrue(member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsInstance(member.param_type, Array)
         self.assertIsNone(member.param_type.min_size)
         self.assertEqual(10, member.param_type.max_size)
         self.assertIs(member.param_type.element_type,
@@ -305,7 +317,7 @@ class TestJSONRPCVParser(unittest.TestCase):
         member = struct.members["m_1"]
         self.verify_base_item(item=member, name="m_1")
         self.assertTrue(member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsInstance(member.param_type, Array)
         self.assertEqual(1, member.param_type.min_size)
         self.assertEqual(10, member.param_type.max_size)
         self.assertIs(member.param_type.element_type,
@@ -321,7 +333,7 @@ class TestJSONRPCVParser(unittest.TestCase):
         member = struct.members["m_3"]
         self.verify_base_item(item=member, name="m_3")
         self.assertTrue(member.is_mandatory)
-        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertIsInstance(member.param_type, String)
         self.assertEqual(20, member.param_type.max_length)
 
         # Functions
@@ -357,9 +369,10 @@ class TestJSONRPCVParser(unittest.TestCase):
             name="param1",
             issues=[TestJSONRPCVParser._Issue(creator="", value="")])
         self.assertEqual(False, param.is_mandatory)
-        self.assertIsInstance(param.param_type, generator.Model.String)
+        self.assertIsInstance(param.param_type, String)
         self.assertIsNone(param.param_type.max_length)
-        self.assertEqual("String default value", param.default_value)
+        self.assertIsNone(param.default_value)
+        self.assertEqual("String default value", param.param_type.default_value)
 
         self.assertIn("param2", function.params)
         param = function.params["param2"]
@@ -370,7 +383,7 @@ class TestJSONRPCVParser(unittest.TestCase):
             todos=["Param2 todo"],
             platform="param2 platform")
         self.assertTrue(param.is_mandatory)
-        self.assertIsInstance(param.param_type, generator.Model.Integer)
+        self.assertIsInstance(param.param_type, Integer)
         self.assertIsNone(param.param_type.min_value)
         self.assertIsNone(param.param_type.max_value)
         self.assertIsNone(param.default_value)
@@ -418,16 +431,18 @@ class TestJSONRPCVParser(unittest.TestCase):
         self.verify_base_item(item=param, name="p2")
         self.assertTrue(param.is_mandatory)
         self.assertIs(param.param_type, interface.enums["interface1_enum1"])
-        self.assertIs(
-            param.default_value,
-            interface.enums["interface1_enum1"].elements["element2"])
+        self.assertIsNone(param.default_value)
+        self.assertIsNone(param.param_type.default_value)
+        self.assertIs(param.param_type.elements["element2"],
+                      interface.enums["interface1_enum1"].elements["element2"])
 
         self.assertIn("p3", function.params)
         param = function.params["p3"]
         self.verify_base_item(item=param, name="p3", design_description=[""])
         self.assertTrue(param.is_mandatory)
-        self.assertIsInstance(param.param_type, generator.Model.Boolean)
-        self.assertEqual(False, param.default_value)
+        self.assertIsInstance(param.param_type, Boolean)
+        self.assertIsNone(param.default_value)
+        self.assertFalse(param.param_type.default_value)
 
         # Function notification "interface1_Function2"
 
@@ -454,14 +469,14 @@ class TestJSONRPCVParser(unittest.TestCase):
         param = function.params["n1"]
         self.verify_base_item(item=param, name="n1", todos=["n1 todo"])
         self.assertTrue(param.is_mandatory)
-        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIsInstance(param.param_type, EnumSubset)
         self.assertIs(param.param_type.enum,
                       interface.enums["interface1_enum1"])
         self.assertDictEqual(
             {"element2":
-                interface.enums["interface1_enum1"].elements["element2"],
+                 interface.enums["interface1_enum1"].elements["element2"],
              "element3":
-                interface.enums["interface1_enum1"].elements["element3"]},
+                 interface.enums["interface1_enum1"].elements["element3"]},
             param.param_type.allowed_elements)
         self.assertIsNone(param.default_value)
 
@@ -469,18 +484,18 @@ class TestJSONRPCVParser(unittest.TestCase):
         param = function.params["n2"]
         self.verify_base_item(item=param, name="n2", todos=["n2 todo"])
         self.assertTrue(param.is_mandatory)
-        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertIsInstance(param.param_type, Array)
         self.assertEqual(1, param.param_type.min_size)
         self.assertEqual(100, param.param_type.max_size)
         self.assertIsInstance(param.param_type.element_type,
-                              generator.Model.EnumSubset)
+                              EnumSubset)
         self.assertIs(param.param_type.element_type.enum,
                       interface.enums["interface1_enum1"])
         self.assertDictEqual(
             {"element1":
-                interface.enums["interface1_enum1"].elements["element1"],
+                 interface.enums["interface1_enum1"].elements["element1"],
              "element3":
-                interface.enums["interface1_enum1"].elements["element3"]},
+                 interface.enums["interface1_enum1"].elements["element3"]},
             param.param_type.element_type.allowed_elements)
         self.assertIsNone(param.default_value)
 
@@ -521,7 +536,7 @@ class TestJSONRPCVParser(unittest.TestCase):
         param = function.params["param2"]
         self.verify_base_item(item=param, name="param2")
         self.assertTrue(param.is_mandatory)
-        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertIsInstance(param.param_type, Array)
         self.assertEqual(5, param.param_type.min_size)
         self.assertEqual(25, param.param_type.max_size)
         self.assertIs(param.param_type.element_type,
@@ -555,14 +570,14 @@ class TestJSONRPCVParser(unittest.TestCase):
         param = function.params["param"]
         self.verify_base_item(item=param, name="param")
         self.assertTrue(param.is_mandatory)
-        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIsInstance(param.param_type, EnumSubset)
         self.assertIs(param.param_type.enum,
                       interface.enums["interface2_enum2"])
         self.assertDictEqual(
             {"element2":
-                interface.enums["interface2_enum2"].elements["element2"],
+                 interface.enums["interface2_enum2"].elements["element2"],
              "element3":
-                interface.enums["interface2_enum2"].elements["element3"]},
+                 interface.enums["interface2_enum2"].elements["element3"]},
             param.param_type.allowed_elements)
         self.assertIsNone(param.default_value)
 
@@ -591,5 +606,6 @@ class TestJSONRPCVParser(unittest.TestCase):
         """Return provided list or empty list if None is provided."""
         return list if list is not None else []
 
+
 if __name__ == "__main__":
     unittest.main()