merged [default] with [dev] branch

Author: userzimmermann

robottools/library/context/__init__.py

@@ -28,6 +28,8 @@
   # From .method:
   'contextmethod']
 
+from moretools import qualname
+
 from robottools.library.session.metaoptions import Meta
 from robottools.library.keywords import KeywordsDict
 
@@ -66,6 +68,9 @@ class ContextHandlerMeta(type):
     ##     return type.__new__(metacls, clsname, bases, clsattrs)
 
     def __init__(cls, clsname, bases, clsattrs):
+        excname = cls.__name__ + 'Error'
+        cls.ContextError = type(excname, (RuntimeError, ), {})
+
         try:
             names = cls.contexts
         except AttributeError:
@@ -87,12 +92,17 @@ def switch_context(self, name):
                     break
             for context in cls.contexts:
                 if context.name == name:
+                    if switch_func: # Custom switch hook
+                        try:
+                            switch_func(self, name)
+                        except Exception as exc:
+                            raise cls.ContextError(
+                                "Couldn't switch context to %s (%s: %s)"
+                                % (repr(name), qualname(type(exc)), exc))
                     self.contexts.remove(current)
                     self.contexts.append(context)
-                    if switch_func: # Custom switch hook
-                        switch_func(self, name)
                     return
-            raise ValueError(name)
+            raise cls.ContextError("Context not found: %s" % repr(name))
 
         keyword_name = switch_context.__name__ = 'switch_' + clsname.lower()
         cls.keywords[keyword_name] = switch_context

robottools/library/keywords/__init__.py

@@ -31,6 +31,8 @@
   # from .errors:
   'InvalidKeywordOption', 'KeywordNotDefined']
 
+import sys
+from six import reraise
 from itertools import chain
 from textwrap import dedent
 
@@ -130,6 +132,8 @@ def __call__(self, *args, **kwargs):
         """Call the Keyword's actual function with the given arguments.
         """
         func = self.func
+        # the exception to finally reraise (if any)
+        error = None
         # look for explicit <session>= and <context>= switching options
         # in kwargs and store the currently active
         # session aliases and context names
@@ -145,62 +149,100 @@ def __call__(self, *args, **kwargs):
             except KeyError:
                 pass
             else:
-                current_sessions[identifier, plural_identifier] = getattr(
-                  self.libinstance, identifier)
-                getattr(self.libinstance, 'switch_' + identifier)(sname)
+                previous = getattr(self.libinstance, identifier)
+                switch = getattr(self.libinstance, 'switch_' + identifier)
+                try:
+                    switch(sname)
+                except hcls.SessionError:
+                    error = sys.exc_info()
+                    # don't switch any more sessions
+                    break
+                # store previous session for switching back later
+                current_sessions[identifier, plural_identifier] = previous
+        # only perform explicit context switching
+        # if explicit session switching didn't raise any error
         current_contexts = {}
-        for hcls in self.context_handlers:
-            if not getattr(hcls, 'auto_explicit', False):
-                continue
-            identifier = hcls.__name__.lower()
-            try:
-                ctxname = kwargs.pop(identifier)
-            except KeyError:
-                pass
+        if error is None:
+            for hcls in self.context_handlers:
+                if not getattr(hcls, 'auto_explicit', False):
+                    continue
+                identifier = hcls.__name__.lower()
+                try:
+                    ctxname = kwargs.pop(identifier)
+                except KeyError:
+                    pass
+                else:
+                    previous = getattr(self.libinstance, identifier)
+                    switch = getattr(self.libinstance,
+                                     'switch_' + identifier)
+                    try:
+                        switch(ctxname)
+                    except hcls.ContextError:
+                        error = sys.exc_info()
+                        # don't switch any more contexts
+                        break
+                    # store previous context for switching back later
+                    current_contexts[identifier] = previous
+        # only call the acutal keyword func
+        # if explicit session and context switching didn't raise any error
+        if error is None:
+            # Look for arg type specs:
+            if func.argtypes:
+                casted = []
+                for arg, argtype in zip(args, func.argtypes):
+                    if not isinstance(arg, argtype):
+                        arg = argtype(arg)
+                    casted.append(arg)
+                args = tuple(casted) + args[len(func.argtypes):]
+            # Look for context specific implementation of the Keyword function
+            for context, context_func in dictitems(func.contexts):
+                if context in self.libinstance.contexts:
+                    func = context_func
+            # Does the keyword support **kwargs?
+            if self.func.argspec.keywords or not kwargs:
+                try:
+                    result = func(self.libinstance, *args, **kwargs)
+                except Exception:
+                    error = sys.exc_info()
             else:
-                current_contexts[identifier] = getattr(
-                  self.libinstance, identifier)
-                getattr(self.libinstance, 'switch_' + identifier)(ctxname)
-        # Look for arg type specs:
-        if func.argtypes:
-            casted = []
-            for arg, argtype in zip(args, func.argtypes):
-                if not isinstance(arg, argtype):
-                    arg = argtype(arg)
-                casted.append(arg)
-            args = tuple(casted) + args[len(func.argtypes):]
-        # Look for context specific implementation of the Keyword function:
-        for context, context_func in dictitems(func.contexts):
-            if context in self.libinstance.contexts:
-                func = context_func
-        # Does the keyword support **kwargs?
-        if self.func.argspec.keywords or not kwargs:
-            result = func(self.libinstance, *args, **kwargs)
-        else:
-            # resolve **kwargs to positional args...
-            posargs = []
-            # (argspec.args start index includes self)
-            for name in self.func.argspec.args[1 + len(args):]:
-                if name in kwargs:
-                    posargs.append(kwargs.pop(name))
-            # and turn the rest into *varargs in 'key=value' style
-            varargs = ['%s=%s' % (key, kwargs.pop(key))
-                       for key in list(kwargs)
-                       if key not in self.func.argspec.args]
-            result = func(self.libinstance, *chain(args, posargs, varargs),
-                          # if **kwargs left ==> TypeError from Python
-                          **kwargs)
-        # Switch back contexts and sessions (reverse order):
+                # resolve **kwargs to positional args...
+                posargs = []
+                # (argspec.args start index includes self)
+                for name in self.func.argspec.args[1 + len(args):]:
+                    if name in kwargs:
+                        posargs.append(kwargs.pop(name))
+                # and turn the rest into *varargs in 'key=value' style
+                varargs = ['%s=%s' % (key, kwargs.pop(key))
+                           for key in list(kwargs)
+                           if key not in self.func.argspec.args]
+                try:
+                    result = func(self.libinstance,
+                                  *chain(args, posargs, varargs),
+                                  # if **kwargs left ==> TypeError from Python
+                                  **kwargs)
+                except:
+                    error = sys.exc_info()
+        # finally try to switch back contexts and sessions (in reverse order)
+        # before either returning result or reraising any error catched above
         for identifier, ctxname in dictitems(current_contexts):
-            getattr(self.libinstance, 'switch_' + identifier)(ctxname)
+            switch = getattr(self.libinstance, 'switch_' + identifier)
+            # don't catch anything here. just step out on error
+            switch(ctxname)
         for (identifier, plural_identifier), session in dictitems(
                 current_sessions
         ):
             for sname, sinstance in dictitems(getattr(
                     self.libinstance, plural_identifier
             )):
                 if sinstance is session:
-                    getattr(self.libinstance, 'switch_' + identifier)(sname)
+                    switch = getattr(self.libinstance, 'switch_' + identifier)
+                    # don't catch anything here. just step out on error
+                    switch(sname)
+        # was an error catched on initial session or context switching
+        # or on calling the actual keyword func?
+        if error is not None:
+            reraise(*error)
+        # great! everything went fine :)
         return result
 
     def __repr__(self):

robottools/library/session/__init__.py

@@ -63,7 +63,7 @@ def switch_session(cls, name):
         """
         name = str(name)
         try:
-            session = cls.session = cls.sessions[name]
+            session = cls.sessions[name]
         except KeyError:
             raise cls.SessionError('Session not found: %s' % repr(name))
         return session

robottools/library/session/meta.py

@@ -29,7 +29,7 @@
 import re
 from copy import deepcopy
 
-from moretools import dictitems
+from moretools import qualname, dictitems
 
 from robottools.library.keywords import KeywordsDict
 from .metaoptions import Meta
@@ -61,7 +61,7 @@ def __new__(mcs, clsname, bases, clsattrs):
         clsattrs['meta'] = meta
 
         excname = meta.upper_identifier_name + 'Error'
-        clsattrs['SessionError'] = type(excname, (RuntimeError,), {})
+        clsattrs['SessionError'] = type(excname, (RuntimeError, ), {})
 
         # The handler's dictionary of opened sessions
         clsattrs['sessions'] = {}
@@ -190,9 +190,21 @@ def switch_session(self, name):
                     if session is previous:
                         break
                 else:
-                    close_func(self, previous)
+                    try:
+                        close_func(self, previous)
+                    except Exception as exc:
+                        raise cls.SessionError(
+                            "Couldn't close unnamed session "
+                            "on switching to %s (%s: %s)"
+                            % (repr(name), qualname(type(exc)), exc))
             if switch_func:
-                switch_func(self, active)
+                try:
+                    switch_func(self, active)
+                except Exception as exc:
+                    raise cls.SessionError(
+                        "Couldn't switch session to %s (%s: %s)"
+                        % (repr(name), qualname(type(exc)), exc))
+            cls.session = active
 
         keywordname = 'switch_' + meta.identifier_name
         cls.keywords[keywordname] = switch_session