[qatl] added method named 'tl.getTestCasesForTestPlan' + test FAILED (#…

…20)

qatestlink/core/models/tl_models.py

@@ -288,3 +288,43 @@ def __repr__(self):
             self.name,
             self.notes,
             self.testplan_id)
+
+
+class TCase(ModelBase):
+    """TODO: doc class"""
+
+    _res_members = None
+
+    # Testlink object properties
+    id = None
+    name = None
+    notes = None
+
+
+    def __init__(self, res_members):
+        """TODO: doc method"""
+        super(TCase, self).__init__()
+        if res_members is None:
+            raise Exception('Bad param, res_member can\'t be None')
+        if len(res_members) <= 0:
+            raise Exception(
+                'Bad param, res_member can\'t be empty list')
+        self._res_members = res_members
+        self._load()
+
+    def _load(self):
+        for res_member in self._res_members:
+            name = res_member.name
+            value = res_member.value
+            if name == 'id':
+                self.id = value
+            if name == 'name':
+                self.name = value
+            if name == 'notes':
+                self.notes = value
+
+    def __repr__(self):
+        return "TCase: id={}, name={}, notes={}".format(
+            self.id,
+            self.name,
+            self.notes)

qatestlink/core/testlink_manager.py

@@ -166,4 +166,16 @@ def api_tplan_tsuites(self, tplan_id, dev_key=None):
         self._xml_manager.parse_errors(res.text)
         res_as_models = self._xml_manager.res_tplan_tsuites(
             res.status_code, res.text, as_models=True)
-        return res_as_models
+        return res_as_models
+
+    def api_tplan_tcases(self, tplan_id, dev_key=None):
+        """Call to method named 'tl.getTestCasesForTestPlan'"""
+        if dev_key is None:
+            dev_key = self._settings.get('dev_key')
+        req_data = self._xml_manager.req_tplan_tcases(
+            dev_key, tplan_id)
+        res = self._conn.post(self._xml_manager.headers, req_data)
+        self._xml_manager.parse_errors(res.text)
+        res_as_models = self._xml_manager.res_tplan_tcases(
+            res.status_code, res.text, as_models=True)
+        return res_as_models

qatestlink/core/xmls/response_handler.py

@@ -66,14 +66,14 @@ def get_response_struct_members(self, xml_str):
              </..close all elements>
         """
         node_param = self.find_node('param', xml_str=xml_str)
-        node_struct = self.find_node('struct', parent=node_param)
+        node_param_value = self.find_node('value', parent=node_param)
+        node_struct = self.find_node('struct', parent=node_param_value)
         nodes_member = self.find_nodes('member', parent=node_struct)
         res_members = list()
         for node_member in nodes_member:
             res_member = ResponseMember(self.log, node_member)
             res_members.append(res_member)
         return res_members
-
 
 
 class ResponseMember(BaseHandler):
@@ -95,7 +95,7 @@ class ResponseMember(BaseHandler):
     name = None
     value = None
 
-    def __init__(self, log, node_member, is_load=True):
+    def __init__(self, log, node_member, is_load=True, is_logging=False):
         """TODO: doc method"""
         super(ResponseMember, self).__init__(log)
         if log is None:
@@ -105,15 +105,16 @@ def __init__(self, log, node_member, is_load=True):
             raise Exception('node_member param can\'t be None')
         self._node_member = node_member
         if is_load:
-            self._load()
+            self._load(is_logging=is_logging)
 
-    def _load(self):
+    def _load(self, is_logging=False):
         node_name = self.find_node(
             'name', parent=self._node_member)
         node_value = self.find_node(
             'value', parent=self._node_member)
         self.name = node_name.text
         self.value = self.parse_node_value(node_value)
-        self.log.debug(
-            'ResponseMember instance: name={}, value={}'.format(
-                self.name, self.value))
+        if is_logging:
+            self.log.debug(
+                'ResponseMember instance: name={}, value={}'.format(
+                    self.name, self.value))

qatestlink/core/xmls/xmlrpc_manager.py

@@ -12,6 +12,7 @@
 from qatestlink.core.models.tl_models import TSuite
 from qatestlink.core.models.tl_models import TPlatform
 from qatestlink.core.models.tl_models import TBuild
+from qatestlink.core.models.tl_models import TCase
 
 
 
@@ -448,3 +449,89 @@ def res_tplan_tsuites(self, status_code, res_str, as_models=True):
             tsuite = TSuite(res_members)
             tsuites.append(tsuite)
         return tsuites
+
+    def req_tplan_tcases(self, dev_key, tplan_id):
+        """
+        Obtains all test cases assigned to test plan
+         created on remote testlink database,
+         can filter by test plan id
+
+        :return:
+            List of TCase objects containing all database
+             data loaded
+        """
+        if tplan_id is None:
+            raise Exception("Can't call XMLRPC without param, tplan_id")
+        req = self._request_handler.create(
+            RouteType.TPLAN_TCASES)
+        req = self._request_handler.create_param(
+            req, 'struct', 'devKey', dev_key)
+        req = self._request_handler.add_param(
+            req, 'testplanid', tplan_id)
+        return req
+
+    def res_tplan_tcases(self, status_code, res_str, as_models=True):
+        """
+        Parse and validate response for method
+         named 'tl.getTestCasesForTestPlan', by default response list
+         of TCase objects, can response xml string too
+        :return:
+            if as_models is True
+                list of objects instanced with
+                 Model classes
+            if as_models is False
+                string xml object ready to
+                 parse/write/find/add Elements on it
+        """
+        if status_code != 200:
+            raise Exception(
+                "status_code invalid: code={}".format(
+                    status_code))
+        res = self._response_handler.create(
+            RouteType.TPLAN_TCASES, res_str)
+        if not as_models:
+            return res
+        res_members_list = self._response_handler.get_response_struct_members(
+            xml_str=res)
+        tcases = list()
+        for res_members in res_members_list:
+            # TODO: something it's wrong using get_response_struct_members
+            tcase = TCase(res_members)
+            tcases.append(tcase)
+        return tcases
+"""
+TODO: XML EXAMPLE for FIX 
+
+<?xml version="1.0"?>
+<methodResponse>
+    <params>
+        <param>
+            <value>
+                <struct>
+                    <member>
+                        <name>15</name>
+                        <value>
+                            <struct>
+                                <member>
+                                    <name>1</name>
+                                    <value>
+                                        <struct>
+                                            <member>
+                                                <name>tcase_name</name>
+                                                <value>
+                                                    <string>test_000_config_exist</string>
+                                                </value>
+                                            </member>
+                                            <member>
+                                                <name>tcase_id</name>
+                                                <value>
+                                                    <string>15</string>
+                                                </value>
+                                            </member>
+                                            <member>
+                                                <name>tc_id</name>
+                                                <value>
+                                                    <string>15</string>
+                                                </value>
+                                            </member>
+"""

tests/unitaries/suite_002_methods.py

@@ -13,6 +13,7 @@
 from qatestlink.core.models.tl_models import TSuite
 from qatestlink.core.models.tl_models import TPlatform
 from qatestlink.core.models.tl_models import TBuild
+from qatestlink.core.models.tl_models import TCase
 
 
 API_DEV_KEY = 'ae2f4839476bea169f7461d74b0ed0ac'
@@ -109,9 +110,8 @@ def test_007_method_tplan_builds(self):
             self.testlink_manager.log.debug(repr(build))
             self.assertIsInstance(build, TBuild)
 
-
     @skipIf(SKIP, 'Test SKIPPED')
-    def test_007_method_tplan_tsuites(self):
+    def test_008_method_tplan_tsuites(self):
         """TODO: doc method"""
         tsuites = self.testlink_manager.api_tplan_tsuites(
             CONFIG['tplan_id'])
@@ -121,6 +121,16 @@ def test_007_method_tplan_tsuites(self):
             self.testlink_manager.log.debug(repr(tsuite))
             self.assertIsInstance(tsuite, TSuite)
 
+    @skipIf(SKIP, 'Test SKIPPED')
+    def test_009_method_tplan_tcases(self):
+        """TODO: doc method"""
+        tcases = self.testlink_manager.api_tplan_tcases(
+            CONFIG['tplan_id'])
+        self.assertIsInstance(tcases, list)
+        self.assertGreater(len(tcases), 0)
+        for tcase in tcases:
+            self.testlink_manager.log.debug(repr(tcase))
+            self.assertIsInstance(tcase, TCase)
 
 class TestMethodsRaises(TestCase):
     """TODO: doc class"""