decorator decoApiCallAddDevKey registers argument 'devKey' lczub#8

Author: Luiko Czub

src/testlink/testlinkapigeneric.py

@@ -20,7 +20,9 @@
 import xmlrpclib
 from functools import wraps
 from .testlinkhelper import TestLinkHelper, VERSION
-import testlinkerrors, testlinkargs
+#from .testlinkargs import registerMethod, registerArgOptional, getMethodsWithPositionalArgs
+from .testlinkargs import *
+import testlinkerrors #, testlinkargs
 
 
 # # Default Definition which (python) API-Method expects which positional arguments
@@ -68,7 +70,7 @@ def decoApiCallWithoutArgs(methodAPI):
     """ Decorator for calling server methods without arguments """ 
 
     # register methods without positional and optional arguments 
-    testlinkargs.registerMethod(methodAPI.__name__)
+    registerMethod(methodAPI.__name__)
 
     @wraps(methodAPI)  
     def wrapperWithoutArgs(self):
@@ -89,8 +91,7 @@ def decoApiCallWithArgs(methodAPI):
         """ Decorator for calling a server method with arguments """
 
         # register methods positional and optional arguments 
-        testlinkargs.registerMethod(methodAPI.__name__, 
-                                    argNamesPositional, argNamesOptional)
+        registerMethod(methodAPI.__name__, argNamesPositional, argNamesOptional)
         # define the method server call           
         @wraps(methodAPI)  
         def wrapperWithArgs(self, *argsPositional, **argsOptional):
@@ -101,6 +102,8 @@ def wrapperWithArgs(self, *argsPositional, **argsOptional):
 
 def decoApiCallAddDevKey(methodAPI):
     """ Decorator to expand parameter list with devKey"""
+    # register additional optional argument devKey 
+    registerArgOptional(methodAPI.__name__, 'devKey')
     @wraps(methodAPI)  
     def wrapperAddDevKey(self, *argsPositional, **argsOptional):
         if not ('devKey' in argsOptional):
@@ -186,7 +189,7 @@ def __init__(self, server_url, devKey, **args):
                                        verbose, allow_none)
         self.devKey = devKey
         self._server_url = server_url
-        self._positionalArgNames = testlinkargs.getMethodsWithPositionalArgs()
+        self._positionalArgNames = getMethodsWithPositionalArgs()
 
 
 

src/testlink/testlinkargs.py

@@ -17,6 +17,9 @@
 #
 # ------------------------------------------------------------------------
 
+from .testlinkerrors import TLArgError
+
+
 __doc__ = """ This modul is used as a 'singleton' to register the supported
 TestLink API methods and there (positional and optional) arguments """
 
@@ -31,10 +34,19 @@
 #  mandatory Args
 _apiMethodsArgs = {}
 
-def resetRegister():
+def _resetRegister():
     " clears all entries in _apiMethodsArgs"
     _apiMethodsArgs.clear()
 
+def _getMethodsArgDefinition(methodName):
+    """ returns argument definition for api methodName """
+    
+    try:
+        return _apiMethodsArgs[methodName]
+    except KeyError:
+        raise TLArgError('apiMethod %s not registered!' % methodName)
+    
+    
 def registerMethod(methodName, apiArgsPositional=[], apiArgsOptional=[], 
                         otherArgsMandatory=[]):
     """ extend _apiMethodsArgs with a new definition structure for METHODNAME
@@ -48,7 +60,7 @@ def registerMethod(methodName, apiArgsPositional=[], apiArgsOptional=[],
     print 'register args for', methodName
 
     if methodName in _apiMethodsArgs:
-        raise StandardError('apiMethod %s already registered!' % methodName)
+        raise TLArgError('apiMethod %s already registered!' % methodName)
 
     allArgs = apiArgsPositional[:]
     for argName in apiArgsOptional:
@@ -57,6 +69,13 @@ def registerMethod(methodName, apiArgsPositional=[], apiArgsOptional=[],
     _apiMethodsArgs[methodName] = (apiArgsPositional[:], allArgs, 
                                    otherArgsMandatory[:])
 
+def registerArgOptional(methodName, argName):
+    """ Update _apiMethodsArgs[methodName] with additional optional argument """ 
+       
+    allArgs = _getMethodsArgDefinition(methodName)[1]
+    if not argName in allArgs:
+        allArgs.append(argName)
+    
 
 def getMethodsWithPositionalArgs():
     """ returns a dictionary with method names and there positional args """
@@ -66,3 +85,7 @@ def getMethodsWithPositionalArgs():
         if argdef[0]:
             positionalArgNames[mname] = argdef[0][:]
     return positionalArgNames
+
+def getApiArgsForMethod(methodName):
+    """ returns list with all argument name api methodName """
+    return _getMethodsArgDefinition(methodName)[1][:]

test/utest/testlinkapigeneric_offline_test.py

@@ -210,7 +210,7 @@ def test_decoApiCallWithArgs(self):
         def DummyMethod(a_api):
             "a dummy api method with 3 positional args and 1 optional arg"
             pass
-        posArgs = testlinkapigeneric.testlinkargs.getMethodsWithPositionalArgs()
+        posArgs = testlinkapigeneric.getMethodsWithPositionalArgs()
         print posArgs
         self.assertEqual(['Uno', 'due', 'tre'], posArgs['DummyMethod'])
 
@@ -227,15 +227,20 @@ def orig_funcname2(a_api):
 
     def test_decoApiCallAddDevKey(self):
         " decorator test: argsOptional should be extended with devKey"
+        testlinkapigeneric.registerMethod('a_func')
         @testlinkapigeneric.decoApiCallAddDevKey
         def a_func(a_api, *argsPositional, **argsOptional):
             return argsPositional, argsOptional
-        
+        # check method argument definition
+        allArgs = testlinkapigeneric.getApiArgsForMethod('a_func')
+        self.assertEqual(['devKey'], allArgs)
+        # check call arguments
         response = a_func(self.api)
         self.assertEqual({'devKey' : self.api.devKey}, response[1])
 
     def test_noWrapperName_decoApiCallAddDevKey(self):
         " decorator test: original function name should be unchanged "
+        testlinkapigeneric.registerMethod('orig_funcname3')
         @testlinkapigeneric.decoApiCallAddDevKey
         def orig_funcname3(a_api, *argsPositional, **argsOptional):
             "orig doc string"

test/utest/testlinkargstest.py

@@ -22,7 +22,8 @@
 
 
 import unittest
-from testlink.testlinkapigeneric import testlinkargs
+# from testlink.testlinkapigeneric import testlinkargs
+from testlink import testlinkargs
 
 
 class testlinkargsTestCase(unittest.TestCase):
@@ -34,13 +35,13 @@ def setUp(self):
         # module under test
         self.mut = testlinkargs
         # reset the args cache
-        self.mut.resetRegister()
+        self.mut._resetRegister()
 
 
-    def test_resetRegister(self):
+    def test__resetRegister(self):
         self.mut._apiMethodsArgs['BigBird'] = 'not a Small Bird'
         self.assertIsNotNone(self.mut._apiMethodsArgs.get('BigBird'))
-        self.mut.resetRegister()
+        self.mut._resetRegister()
         self.assertIsNone(self.mut._apiMethodsArgs.get('BigBird'))
 
     def test_registerMethod(self):
@@ -75,6 +76,32 @@ def test_getMethodsWithPositionalArgs(self):
                           'Method_1pos_2opt' : ['Uno']}, 
                          a_def )
 
+    def test_registerMethod_ErrorAlreadyDefined(self):
+        self.mut.registerMethod('DummyMethod', ['Uno', 'due', 'tre'],  
+                                ['quad','tre'], ['cinque'])
+        with self.assertRaisesRegexp(testlinkargs.TLArgError, 
+                                     'DummyMethod already registered'):
+            self.mut.registerMethod('DummyMethod')
+            
+    def test_registerArgOptional(self):
+        self.mut.registerMethod('DummyMethod', ['Uno', 'due', 'tre'],  
+                                ['quad','tre'], ['cinque'])
+        self.mut.registerArgOptional('DummyMethod', 'sei')
+        a_def = self.mut._apiMethodsArgs['DummyMethod']
+        self.assertEqual((['Uno', 'due', 'tre'], 
+                          ['Uno', 'due', 'tre', 'quad', 'sei'],
+                          ['cinque']), a_def )
+
+    def test_registerArgOptional_ErrorUnknownMethod(self):
+        with self.assertRaisesRegexp(testlinkargs.TLArgError, 
+                                     'DummyMethod not registered'):
+            self.mut.registerArgOptional('DummyMethod', 'sei')
+
+    def test_getApiArgsForMethod(self):
+        self.mut.registerMethod('DummyMethod', ['Uno', 'due', 'tre'],  
+                                ['quad','tre'], ['cinque'])
+        allArgs = self.mut.getApiArgsForMethod('DummyMethod')
+        self.assertEqual(['Uno', 'due', 'tre', 'quad'], allArgs )
 
 if __name__ == "__main__":
     #import sys;sys.argv = ['', 'Test.testName']