Changeset 3031

Show
Ignore:
Timestamp:
02/10/08 16:30:42 (10 months ago)
Author:
bgranger
Message:

Getting the new client and API to pass tests.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/engineservice.py

    r3029 r3031  
    476476    def setProperties(self, properties): 
    477477        msg = """engine: %r 
    478 method: setProperties(**properties) 
     478method: setProperties(properties) 
    479479properties.keys() = %r""" % (self.id, properties.keys()) 
    480480        return self.executeAndRaise(msg, self.properties.update, properties) 
    481481     
    482     def getProperties(self, keys): 
    483         msg = """engine %r 
    484 method: getProperties(*keys) 
     482    def getProperties(self, keys=None): 
     483        msg = """engine %r 
     484method: getProperties(keys) 
    485485keys = %r""" % (self.id, keys) 
    486         if not keys: 
     486        if keys is None: 
    487487            keys = self.properties.keys() 
    488488        return self.executeAndRaise(msg, self.properties.subDict, *keys) 
    489489     
    490     def _doDel(self, *keys): 
     490    def _doDel(self, keys): 
    491491        for key in keys: 
    492492            del self.properties[key] 
    …… 
    496496method: delProperties(*keys) 
    497497keys = %r""" % (self.id, keys) 
    498         return self.executeAndRaise(msg, self._doDel, *keys) 
    499      
    500     def _doHas(self, *keys): 
     498        return self.executeAndRaise(msg, self._doDel, keys) 
     499     
     500    def _doHas(self, keys): 
    501501        return [self.properties.has_key(key) for key in keys] 
    502502     
    503503    def hasProperties(self, keys): 
    504504        msg = """engine %r 
    505 method: hasProperties(*keys) 
     505method: hasProperties(keys) 
    506506keys = %r""" % (self.id, keys) 
    507         return self.executeAndRaise(msg, self._doHas, *keys) 
     507        return self.executeAndRaise(msg, self._doHas, keys) 
    508508     
    509509    def clearProperties(self): 

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/magic.py

    r2230 r3031  
    5858        print NO_ACTIVE_CONTROLLER 
    5959    else: 
    60         targets = activeController.magicTargets 
    6160        try: 
    6261            index = int(parameter_s) 
    6362        except: 
    6463            index = None 
    65         result = activeController.getResult(targets, index) 
     64        result = activeController.getResult(index) 
    6665        return result 
    6766 
    …… 
    8281        print NO_ACTIVE_CONTROLLER 
    8382    else: 
    84         targets = activeController.magicTargets 
    8583        print "Executing command on Controller" 
    86         result = activeController.execute(targets, parameter_s) 
     84        result = activeController.execute(parameter_s) 
    8785        return result 
    8886 
    …… 
    108106    else: 
    109107        try: 
    110             result = self.activeController.execute(self.activeController.magicTargets, source) 
     108            result = self.activeController.execute(source) 
    111109        except: 
    112110            self.showtraceback() 

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/multiengine.py

    r3029 r3031  
    512512 
    513513class SynchronousMultiEngine(PendingDeferredManager): 
    514     """Adapt an `IMultiEngine` -> `ISynchronousMultiEngine`""" 
     514    """Adapt an `IMultiEngine` -> `ISynchronousMultiEngine` 
     515     
     516    Warning, this class uses a decorator that currently uses **kwargs.   
     517    Because of this block must be passed as a kwarg, not positionally. 
     518    """ 
    515519     
    516520    implements(ISynchronousMultiEngine) 
    …… 
    645649        method = getattr(self.smultiengine, methodname) 
    646650        d = method(*args, **kwargs) 
    647         d.addCallback(lambda did: self.smultiengine.getPendingDeferred(did,True)) 
     651        d.addCallback(lambda did: self.smultiengine.getPendingDeferred(did, True)) 
    648652        return d         
    649653     
    …… 
    659663     
    660664    def pull(self, keys, targets='all'): 
    661         return self._submitThenBlock('pull', keys, targets=targets) 
     665        return self._submitThenBlock('pull', keys, targets) 
    662666     
    663667    def pushFunction(self, namespace, targets='all'): 
    …… 
    936940            mapClass = Map.styles[style] 
    937941            mapObject = mapClass() 
    938             deferred_id_list = [] 
     942            d_list = [] 
    939943            for index, engineid in enumerate(engines): 
    940944                partition = mapObject.getPartition(seq, index, nEngines) 
    …… 
    943947                else: 
    944948                    d = self.smultiengine.push({key: partition}, targets=engineid, block=False) 
    945                 d.addCallback(lambda did: deferred_id_list.append(did)) 
    946             d_list = [self.smultiengine.getPendingDeferred(did, True) for did in deferred_id_list] 
    947             return gatherBoth(d_list, 
     949                d.addCallback(lambda did: self.smultiengine.getPendingDeferred(did, True)) 
     950                d_list.append(d) 
     951            d = gatherBoth(d_list, 
    948952                              fireOnOneErrback=1, 
    949953                              consumeErrors=1, 
    950954                              logErrors=0) 
     955            d.addCallback(lambda lop: [i[0] for i in lop]) 
     956            return d 
    951957         
    952958        d = self._process_targets(targets) 
    …… 
    959965         
    960966        def do_gather(engines): 
    961             nEngines = len(engines)     
    962             deferred_id_list = [] 
     967            nEngines = len(engines)  
     968            d_list = [] 
    963969            for engineid in engines: 
    964970                d = self.smultiengine.pull(key, targets=engineid, block=False) 
    965                 d.addCallback(lambda did: deferred_id_list.append(did)) 
     971                d.addCallback(lambda did: self.smultiengine.getPendingDeferred(did, True)) 
     972                d_list.append(d) 
    966973            mapClass = Map.styles[style] 
    967974            mapObject = mapClass() 
    968             d_list = [self.smultiengine.getPendingDeferred(did, True) for did in deferred_id_list]            
    969975            d = gatherBoth(d_list, 
    970976                           fireOnOneErrback=1, 
    …… 
    979985     
    980986    def map(self, func, seq, style='basic', targets='all'): 
    981         deferred_id_list = [] 
     987        d_list = [] 
    982988        if isinstance(func, FunctionType): 
    983             d = self.smultiengine.pushFunction(_ipython_map_func=func, targets=targets, block=False) 
    984             d.addCallback(lambda did: deferred_id_list.append(did)) 
     989            d = self.smultiengine.pushFunction(dict(_ipython_map_func=func), targets=targets, block=False) 
     990            d.addCallback(lambda did: self.smultiengine.getPendingDeferred(did, True)) 
    985991            sourceToRun = '_ipython_map_seq_result = map(_ipython_map_func, _ipython_map_seq)' 
    986992        elif isinstance(func, str): 
     993            d = defer.succeed(None) 
    987994            sourceToRun = \ 
    988                 '_ipython_map_seq_result = map(%s, _ipython_map_seq)' % \ 
    989                 func 
     995                '_ipython_map_seq_result = map(%s, _ipython_map_seq)' % func 
    990996        else: 
    991997            raise TypeError("func must be a function or str") 
    992998         
    993         self.smultiengine.scatter('_ipython_map_seq', seq, style, targets=targets) 
    994         self.smultiengine.execute(sourceToRun, targets=targets, block=False) 
    995         self.smultiengine.gather('_ipython_map_seq_result', style, targets=targets, block=False) 
    996         d_list = [self.smultiengine.getPendingDeferred(did, True) for did in deferred_id_list]            
    997         d = gatherBoth(d_list, 
    998                        fireOnOneErrback=1, 
    999                        consumeErrors=1, 
    1000                        logErrors=0) 
     999        d.addCallback(self.scatter('_ipython_map_seq', seq, style, targets=targets)) 
     1000        d.addCallback(lambda did: self.smultiengine.getPendingDeferred(did, True)) 
     1001        d.addCallback(self.smultiengine.execute(sourceToRun, targets=targets, block=False)) 
     1002        d.addCallback(self.gather('_ipython_map_seq_result', style, targets=targets)) 
     1003        d.addCallback(lambda did: self.smultiengine.getPendingDeferred(did, True)) 
    10011004        return d 
    10021005 

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/multiengineclient.py

    r3029 r3031  
    377377        if block is None: 
    378378            raise error.MissingBlockArgument("'block' keyword argument is missing") 
    379         result = blockingCallFromThread(function, block, *args, **kwargs) 
     379        result = blockingCallFromThread(function, *args, **kwargs) 
    380380        if not block: 
    381381            result = PendingResult(self, result) 

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/multienginexmlrpc.py

    r3029 r3031  
    132132     
    133133    @packageResult 
    134     def xmlrpc_getPendingDeferred(self, request, deferredID, block=True): 
     134    def xmlrpc_getPendingDeferred(self, request, deferredID, block): 
    135135        return self.smultiengine.getPendingDeferred(deferredID, block) 
    136136        
    …… 
    150150            d = defer.fail(failure.Failure()) 
    151151        else: 
    152             d = self.smultiengine.push(namespace, targets, block) 
     152            d = self.smultiengine.push(namespace, targets=targets, block=block) 
    153153        return d 
    154154     

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/pendingdeferred.py

    r3028 r3031  
    112112                return pd 
    113113            elif not pd.called and not block: # pd has not fired, but we should not block 
    114                 return defer.fail(failure.Failure(error.ResultNotCompleted("Result not completed: %i" % deferredID))) 
     114                return defer.fail(failure.Failure(error.ResultNotCompleted("Result not completed: %r" % deferredID))) 
    115115            else:    # pd has fired 
    116116                #log.msg("pendingDeferred has been called: %s: %s" % (deferredID, repr(pd.result))) 

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/tests/engineservicetest.py

    r3021 r3031  
    3434    EngineGetResultTestGenerator) 
    3535 
    36 class FailingEngineError(Exception): 
    37     pass 
    38  
    39 class FailingEngineService(object, service.Service): 
    40     """An EngineSerivce whose methods always raise FailingEngineError. 
    41      
    42     This class is used in tests to see if errors propagate correctly. 
    43     """ 
    44      
    45     zi.implements(es.IEngineBase) 
    46                  
    47     def __init__(self, shellClass=None, mpi=None): 
    48         self.id = None 
    49         self.properties={} 
    50      
    51     def _setID(self, id): 
    52         self._id = id 
    53          
    54     def _getID(self): 
    55         return self._id 
    56          
    57     id = property(_getID, _setID) 
    58          
    59     def startService(self): 
    60         pass 
    61              
    62     def execute(self, lines): 
    63         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
    64  
    65     def push(self, **namespace): 
    66         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
    67  
    68     def pull(self, *keys): 
    69         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
    70          
    71     def getResult(self, i=None): 
    72         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
    73      
    74     def reset(self): 
    75         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
    76      
    77     def kill(self): 
    78         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
    79  
    80     def keys(self): 
    81         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
    82  
    83     def pushSerialized(self, **sNamespace): 
    84         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
    85      
    86     def pullSerialized(self, *keys): 
    87         return defer.fail(failure.Failure(FailingEngineError("error text"))) 
     36 
     37#------------------------------------------------------------------------------- 
     38# Tests 
     39#------------------------------------------------------------------------------- 
     40 
    8841     
    8942# A sequence of valid commands run through execute 
    …… 
    153106             
    154107    def testIEngineCoreDeferreds(self): 
    155         commands = [(self.engine.execute, ('a=5',)),  
    156             (self.engine.pull, ('a',)), 
    157             (self.engine.getResult, ()), 
    158             (self.engine.keys, ())] 
    159         dList = [] 
    160         for c in commands: 
    161             d = c[0](*c[1]) 
    162             self.assert_(isinstance(d, defer.Deferred)) 
    163             dList.append(d) 
    164         d = self.engine.push(a=5) 
    165         self.assert_(isinstance(d, defer.Deferred)) 
    166         dList.append(d) 
    167         D = defer.DeferredList(dList) 
    168         return D 
    169          
     108        d = self.engine.execute('a=5') 
     109        d.addCallback(lambda _: self.engine.pull('a')) 
     110        d.addCallback(lambda _: self.engine.getResult()) 
     111        d.addCallback(lambda _: self.engine.keys()) 
     112        d.addCallback(lambda _: self.engine.push(dict(a=10))) 
     113        return d 
     114     
    170115    def testExecute(self): 
    171116        eTester = EngineExecuteTestGenerator(validCommands, self) 
    …… 
    195140        d.addCallback(lambda _: self.engine.pull('l')) 
    196141        d.addErrback(lambda f: self.assertRaises(pickle.PicklingError, f.raiseException)) 
    197         d.addCallback(lambda _: self.engine.push(l=lambda x: x)) 
     142        d.addCallback(lambda _: self.engine.push(dict(l=lambda x: x))) 
    198143        d.addErrback(lambda f: self.assertRaises(pickle.PicklingError, f.raiseException)) 
    199144        return d 
    …… 
    206151            return 
    207152        a = numpy.random.random(1000) 
    208         d = self.engine.push(a=a) 
     153        d = self.engine.push(dict(a=a)) 
    209154        d.addCallback(lambda _: self.engine.pull('a')) 
    210155        d.addCallback(lambda b: b==a) 
    …… 
    214159    def testPushFunction(self): 
    215160                     
    216         d = self.engine.pushFunction(f=testf) 
     161        d = self.engine.pushFunction(dict(f=testf)) 
    217162        d.addCallback(lambda _: self.engine.execute('result = f(10)')) 
    218163        d.addCallback(lambda _: self.engine.pull('result')) 
    …… 
    221166 
    222167    def testPullFunction(self): 
    223         d = self.engine.pushFunction(f=testf, g=testg) 
    224         d.addCallback(lambda _: self.engine.pullFunction('f','g')) 
     168        d = self.engine.pushFunction(dict(f=testf, g=testg)) 
     169        d.addCallback(lambda _: self.engine.pullFunction(('f','g'))) 
    225170        d.addCallback(lambda r: self.assertEquals(r[0](10), testf(10))) 
    226171        return d 
    …… 
    228173    def testPushFunctionGlobal(self): 
    229174        """Make sure that pushed functions pick up the user's namespace for globals.""" 
    230         d = self.engine.push(globala=globala) 
    231         d.addCallback(lambda _: self.engine.pushFunction(g=testg)) 
     175        d = self.engine.push(dict(globala=globala)) 
     176        d.addCallback(lambda _: self.engine.pushFunction(dict(g=testg))) 
    232177        d.addCallback(lambda _: self.engine.execute('result = g(10)')) 
    233178        d.addCallback(lambda _: self.engine.pull('result')) 
    …… 
    280225    def testIEngineSerializedDeferreds(self): 
    281226        dList = [] 
    282         d = self.engine.pushSerialized(key=newserialized.serialize(12345)) 
     227        d = self.engine.pushSerialized(dict(key=newserialized.serialize(12345))) 
    283228        self.assert_(isinstance(d, defer.Deferred)) 
    284229        dList.append(d) 
    …… 
    293238        d = defer.succeed(None) 
    294239        for o in objs: 
    295             self.engine.pushSerialized(key=newserialized.serialize(o)) 
     240            self.engine.pushSerialized(dict(key=newserialized.serialize(o))) 
    296241            value = self.engine.pullSerialized('key') 
    297242            value.addCallback(lambda serial: newserialized.IUnSerialized(serial).getObject()) 
    …… 
    357302    def testGetSetProperties(self): 
    358303        dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5)) 
    359         d = self.engine.setProperties(**dikt) 
     304        d = self.engine.setProperties(dikt) 
    360305        d.addCallback(lambda r: self.engine.getProperties()) 
    361306        d = self.assertDeferredEquals(d, dikt) 
    362         d.addCallback(lambda r: self.engine.getProperties('c')) 
     307        d.addCallback(lambda r: self.engine.getProperties(('c',))) 
    363308        d = self.assertDeferredEquals(d, {'c': dikt['c']}) 
    364         d.addCallback(lambda r: self.engine.setProperties(c=False)) 
    365         d.addCallback(lambda r: self.engine.getProperties('c', 'd')) 
     309        d.addCallback(lambda r: self.engine.setProperties(dict(c=False))) 
     310        d.addCallback(lambda r: self.engine.getProperties(('c', 'd'))) 
    366311        d = self.assertDeferredEquals(d, dict(c=False, d=None)) 
    367312        return d 
    …… 
    369314    def testClearProperties(self): 
    370315        dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5)) 
    371         d = self.engine.setProperties(**dikt) 
     316        d = self.engine.setProperties(dikt) 
    372317        d.addCallback(lambda r: self.engine.clearProperties()) 
    373318        d.addCallback(lambda r: self.engine.getProperties()) 
    …… 
    377322    def testDelHasProperties(self): 
    378323        dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5)) 
    379         d = self.engine.setProperties(**dikt) 
    380         d.addCallback(lambda r: self.engine.delProperties('b','e')) 
    381         d.addCallback(lambda r: self.engine.hasProperties(*'abcde')) 
     324        d = self.engine.setProperties(dikt) 
     325        d.addCallback(lambda r: self.engine.delProperties(('b','e'))) 
     326        d.addCallback(lambda r: self.engine.hasProperties(('a','b','c','d','e'))) 
    382327        d = self.assertDeferredEquals(d, [True, False, True, True, False]) 
    383328        return d 
    384329     
    385330    def testStrictDict(self): 
    386         s = """import ipython1.kernel.api as kernel 
    387 p = kernel.getEngine(%s).properties"""%self.engine.id 
     331        s = """from ipython1.kernel.engineservice import getEngine 
     332p = getEngine(%s).properties"""%self.engine.id 
    388333        d = self.engine.execute(s) 
    389334        d.addCallback(lambda r: self.engine.execute("p['a'] = lambda _:None")) 

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/tests/multienginetest.py

    r3028 r3031  
    7979    def testIEngineMultiplexerDeferreds(self): 
    8080        self.addEngine(1) 
    81         d = self.multiengine.execute(0, 'a=5') 
    82         d.addCallback(lambda _: self.multiengine.push(0, a=5)) 
    83         d.addCallback(lambda _: self.multiengine.push(0, a=5, b='asdf', c=[1,2,3])) 
    84         d.addCallback(lambda _: self.multiengine.pull(0, 'a', 'b', 'c')) 
     81        d = self.multiengine.execute('a=5', targets=0) 
     82        d.addCallback(lambda _: self.multiengine.push(dict(a=5),targets=0)) 
     83        d.addCallback(lambda _: self.multiengine.push(dict(a=5, b='asdf', c=[1,2,3]),targets=0)) 
     84        d.addCallback(lambda _: self.multiengine.pull(('a','b','c'),targets=0)) 
    8585        d.addCallback(lambda _: self.multiengine.getResult(0)) 
    8686        d.addCallback(lambda _: self.multiengine.reset(0)) 
    8787        d.addCallback(lambda _: self.multiengine.keys(0)) 
    88         d.addCallback(lambda _: self.multiengine.pushSerialized(0, a=newserialized.serialize(10))) 
    89         d.addCallback(lambda _: self.multiengine.pullSerialized(0, 'a')) 
     88        d.addCallback(lambda _: self.multiengine.pushSerialized(dict(a=newserialized.serialize(10)),targets=0)) 
     89        d.addCallback(lambda _: self.multiengine.pullSerialized('a',targets=0)) 
    9090        d.addCallback(lambda _: self.multiengine.clearQueue(0)) 
    9191        d.addCallback(lambda _: self.multiengine.queueStatus(0)) 
    …… 
    9595         self.addEngine(1) 
    9696         badID = 100 
    97          d = self.multiengine.execute(badID, 'a=5') 
    98          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
    99          d.addCallback(lambda _: self.multiengine.push(badID, a=5)) 
    100          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
    101          d.addCallback(lambda _: self.multiengine.pull(badID, 'a'))      
    102          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
    103          d.addCallback(lambda _: self.multiengine.getResult(badID))    
    104          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
    105          d.addCallback(lambda _: self.multiengine.reset(badID))      
     97         d = self.multiengine.execute('a=5', targets=badID) 
     98         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
     99         d.addCallback(lambda _: self.multiengine.push(dict(a=5), targets=badID)) 
     100         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
     101         d.addCallback(lambda _: self.multiengine.pull('a', targets=badID))      
     102         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
     103         d.addCallback(lambda _: self.multiengine.getResult(targets=badID))    
     104         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
     105         d.addCallback(lambda _: self.multiengine.reset(targets=badID))      
    106106         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))    
    107          d.addCallback(lambda _: self.multiengine.keys(badID))      
    108          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
    109          d.addCallback(lambda _: self.multiengine.pushSerialized(badID, a=newserialized.serialize(10))) 
    110          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
    111          d.addCallback(lambda _: self.multiengine.pullSerialized(badID, 'a')) 
    112          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
    113          d.addCallback(lambda _: self.multiengine.queueStatus(badID)) 
     107         d.addCallback(lambda _: self.multiengine.keys(targets=badID))      
     108         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
     109         d.addCallback(lambda _: self.multiengine.pushSerialized(dict(a=newserialized.serialize(10)), targets=badID)) 
     110         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
     111         d.addCallback(lambda _: self.multiengine.pullSerialized('a', targets=badID)) 
     112         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
     113         d.addCallback(lambda _: self.multiengine.queueStatus(targets=badID)) 
    114114         d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException)) 
    115115         return d 
    …… 
    117117    def testNoEnginesRegistered(self): 
    118118        badID = 'all' 
    119         d = self.multiengine.execute(badID, 'a=5') 
    120         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
    121         d.addCallback(lambda _: self.multiengine.push(badID, a=5)) 
    122         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
    123         d.addCallback(lambda _: self.multiengine.pull(badID, 'a'))      
    124         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
    125         d.addCallback(lambda _: self.multiengine.getResult(badID))    
    126         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
    127         d.addCallback(lambda _: self.multiengine.reset(badID))      
     119        d = self.multiengine.execute('a=5', targets=badID) 
     120        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
     121        d.addCallback(lambda _: self.multiengine.push(a=5, targets=badID)) 
     122        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
     123        d.addCallback(lambda _: self.multiengine.pull('a', targets=badID))      
     124        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
     125        d.addCallback(lambda _: self.multiengine.getResult(targets=badID))    
     126        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
     127        d.addCallback(lambda _: self.multiengine.reset(targets=badID))      
    128128        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))    
    129         d.addCallback(lambda _: self.multiengine.keys(badID))      
    130         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
    131         d.addCallback(lambda _: self.multiengine.pushSerialized(badID, a=newserialized.serialize(10))) 
    132         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
    133         d.addCallback(lambda _: self.multiengine.pullSerialized(badID, 'a')) 
    134         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
    135         d.addCallback(lambda _: self.multiengine.queueStatus(badID)) 
     129        d.addCallback(lambda _: self.multiengine.keys(targets=badID))      
     130        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
     131        d.addCallback(lambda _: self.multiengine.pushSerialized(dict(a=newserialized.serialize(10)), targets=badID)) 
     132        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
     133        d.addCallback(lambda _: self.multiengine.pullSerialized('a', targets=badID)) 
     134        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
     135        d.addCallback(lambda _: self.multiengine.queueStatus(targets=badID)) 
    136136        d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException)) 
    137137        return d         

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/tests/test_enginepb.py

    r3010 r3031  
    113113        # Test that smaller size is allows 
    114114        toSend = (sizeLimit-1)*'0' 
    115         d = self.engine.push(a=toSend) 
     115        d = self.engine.push(dict(a=toSend)) 
    116116        d.addCallback(lambda _: self.engine.pull('a')) 
    117117        d.addCallback(lambda r: self.assert_(r==toSend)) 
    …… 
    121121        # Test for failure at the SIZE_LIMIT 
    122122        toSend = (sizeLimit)*'0' 
    123         d.addCallback(lambda _: self.engine.push(a=toSend)) 
     123        d.addCallback(lambda _: self.engine.push(dict(a=toSend))) 
    124124        d.addErrback(lambda f: self.assertRaises(PBMessageSizeError, f.raiseException)) 
    125125        d.addCallback(lambda _: self.engine.execute("a=%i*'0'" % ((sizeLimit-1),))) 

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/tests/test_engineservice.py

    r3010 r3031  
    3232    IEngineSerializedTestCase, \ 
    3333    IEngineQueuedTestCase, \ 
    34     IEnginePropertiesTestCase, \ 
    35     FailingEngineService, \ 
    36     FailingEngineError 
     34    IEnginePropertiesTestCase 
    3735     
    3836 
    …… 
    6260    def tearDown(self): 
    6361        return self.rawEngine.stopService() 
    64          
    65 class FailingEngineServiceTest(DeferredTestCase): 
    66      
    67     def setUp(self): 
    68         self.failingEngine = FailingEngineService() 
    69         self.engine = es.IEngineQueued(self.failingEngine) 
    7062 
    71     def testFailingMethods(self): 
    72         dList = [self.engine.execute('a=5')] 
    73         for d in dList: 
    74             d.addErrback(lambda f: self.assertRaises(FailingEngineError, f.raiseException)) 
    75         return defer.DeferredList(dList) 
    7663  

  • ipython1/branches/ipython1-client-r3021/ipython1/kernel/tests/test_pendingdeferred.py

    r2791 r3031  
    5252        return defer.succeed('blahblah' + bahz) 
    5353 
    54 class TwoPhaseFoo(pd.PendingDeferredAdapter): 
     54class TwoPhaseFoo(pd.PendingDeferredManager): 
    5555     
    5656    def __init__(self, foo): 
    5757        self.foo = foo 
    58         pd.PendingDeferredAdapter.__init__(self) 
     58        pd.PendingDeferredManager.__init__(self) 
    5959 
    6060    @pd.twoPhase 
    …… 
    7272         
    7373    def testBasic(self): 
    74         pdm = pd.PendingDeferredManager(0) 
    75         for i in range(10): 
    76             id = pdm.getNextDeferredID() 
    77             self.assert_(id==i) 
     74        pdm = pd.PendingDeferredManager() 
    7875        dDict = {} 
    7976        for i in range(10): 
    8077            d = defer.Deferred() 
    81             pdm.savePendingDeferred(i, d) 
    82             dDict[i] = d 
    83         for i in range(5): 
    84             d = pdm.getPendingDeferred(i,block=True) 
    85             dDict[i].callback('foo') 
     78            did = pdm.getNextDeferredID() 
     79            pdm.savePendingDeferred(did, d) 
     80            dDict[did] = d 
     81        for did in dDict.keys()[0:5]: 
     82            d = pdm.getPendingDeferred(did,block=True) 
     83            dDict[did].callback('foo') 
    8684            d.addCallback(lambda r: self.assert_(r=='foo')) 
    87         for i in range(5,10): 
    88             d = pdm.getPendingDeferred(i,block=False) 
     85        for did in dDict.keys()[5:10]: 
     86            d = pdm.getPendingDeferred(did,block=False) 
    8987            d.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException)) 
    90         for i in range(5,10): 
    91             dDict[i].callback('foo') 
    92             d = pdm.getPendingDeferred(i,block=False) 
     88        for did in dDict.keys()[5:10]: 
     89            dDict[did].callback('foo') 
     90            d = pdm.getPendingDeferred(did,block=False) 
    9391            d.addCallback(lambda r: self.assert_(r=='foo')) 
    94         for i in range(10): 
    95             d = pdm.getPendingDeferred(i,False) 
     92        for did in dDict.keys(): 
     93            d = pdm.getPendingDeferred(did,False) 
    9694            d.addErrback(lambda f: self.assertRaises(error.InvalidDeferredID, f.raiseException)) 
    97              
    98     def testPDA(self): 
    99         f = Foo() 
    100         tpf = TwoPhaseFoo(f) 
    101         clientID = tpf.registerClient() 
    102         self.assert_(clientID==0) 
    103         d = tpf.bar(clientID, True, 'hi there') 
    104         d.addCallback(lambda r: self.assertEquals(r, 'blahblahhi there')) 
    105         d = tpf.bar(clientID, False, 'foobah') 
    106         d.addCallback(lambda r:  
    107             self.assertEquals(len(tpf.pdManagers[clientID].pendingDeferreds.keys()), 1)) 
    108         d.addCallback(lambda r: tpf.flush(clientID)) 
    109         d.addCallback(lambda r:  
    110             self.assertEquals(len(tpf.pdManagers[clientID].pendingDeferreds.keys()), 0)) 
    111         tpf.unregisterClient(clientID) 
    112         d = tpf.bar(1000, True, 'boo') 
    113         d.addErrback(lambda f: self.assertRaises(error.InvalidClientID, f.raiseException)) 
    114          
    115          
     95 
     96 
    11697         
    11798#------------------------------------------------------------------------------- 

  • ipython1/branches/ipython1-client-r3021/ipython1/testutils/testgenerator.py

    r2789 r3031  
    125125         
    126126    def computeOutput(self, i): 
    127         d = self.testCaseInstance.engine.push(a=i) 
     127        d = self.testCaseInstance.engine.push(dict(a=i)) 
    128128        d.addCallback(lambda r: self.testCaseInstance.engine.pull('a')) 
    129129        return d