Example #1
0
 def test_flex_should_not_explode_on_unicode_formatting(self):
     if sys.version_info >= (3, 0):
         formatted = _format_args(
                 'method', {'kargs' : (chr(0x86C7),), 'kwargs' : {}})
         assertEqual('method("蛇")', formatted)
     else:
         formatted = _format_args(
                 'method', {'kargs' : (unichr(0x86C7),), 'kwargs' : {}})
         assertEqual('method("%s")' % unichr(0x86C7), formatted)
Example #2
0
 def _verify_call_order(self, flex_objects):
     for exp in flex_objects[self.mock]:
         if (exp.method == self.method and
                 not _match_args(self.args, exp.args) and
                 not exp._times_called):
             raise CallOrderError(
                     '%s called before %s' %
                     (_format_args(self.method, self.args),
                      _format_args(exp.method, exp.args)))
         if (exp.method == self.method and
                 self.args and exp.args and    # ignore default stub case
                 _match_args(self.args, exp.args)):
             break
Example #3
0
    def _verify(self, final=True):
        """Verify that this expectation has been met.

        Args:
            final: boolean, True if no further calls to this method expected
            (skip checking at_least expectations when False)

        Raises:
            CallOrderError
        """
        if self._verified:
            return  # ensure we only raise one error per failed expectation
        failed = False
        message = ''
        expected_calls = self._expected_calls
        if expected_calls[EXACTLY] is not None:
            message = 'exactly %s' % expected_calls[EXACTLY]
            if final:
                if self._times_called != expected_calls[EXACTLY]:
                    failed = True
            else:
                if self._times_called > expected_calls[EXACTLY]:
                    failed = True
        else:
            if final and expected_calls[AT_LEAST] is not None:
                message = 'at least %s' % expected_calls[AT_LEAST]
                if self._times_called < expected_calls[AT_LEAST]:
                    failed = True
            if expected_calls[AT_MOST] is not None:
                if message:
                    message += ' and '
                message += 'at most %s' % expected_calls[AT_MOST]
                if self._times_called > expected_calls[AT_MOST]:
                    failed = True
        if not failed:
            return
        else:
            self._verified = True
            self.__raise(
                MethodCallError,
                '%s expected to be called %s times, called %s times' %
                    (_format_args(self.method, self.args),
                    message,
                    self._times_called))
Example #4
0
File: wrap.py Project: has207/flex
 def mock_method(runtime_self, *kargs, **kwargs):
     arguments = {'kargs': kargs, 'kwargs': kwargs}
     expectation = self.__get_expectation(method, arguments)
     if expectation:
         if not expectation._runnable():
             raise StateError(
                 '%s expected to be called when %s is True' %
                 (method, _get_runnable_name(expectation._runnable)))
         expectation._times_called += 1
         expectation._verify(final=False)
         _pass_thru = expectation._pass_thru
         _replace_with = expectation._replace_with
         if _pass_thru:
             return pass_thru(expectation, *kargs, **kwargs)
         elif _replace_with:
             return _replace_with(*kargs, **kwargs)
         yield_values = expectation._action['yield_values']
         return_values = expectation._action['return_values']
         if yield_values:
             return generator_method(yield_values)
         elif return_values:
             return_value = return_values[0]
             del return_values[0]
             return_values.append(return_value)
         else:
             return_value = ReturnValue()
         if return_value.raises:
             if _isclass(return_value.raises):
                 raise return_value.raises(
                         *return_value.value['kargs'],
                         **return_value.value['kwargs'])
             else:
                 raise return_value.raises
         else:
             return return_value.value
     else:
         # make sure to clean up expectations to ensure none of them
         # interfere with the runner's error reporing mechanism
         # e.g. open()
         for mock_object, expectations in _flex_objects.items():
             for expectation in expectations:
                 expectation._reset()
         raise MethodSignatureError(_format_args(method, arguments))
Example #5
0
 def __str__(self):
     return ('%s -> (%s)' %
             (_format_args(self.method, self.args),
             ', '.join(['%s' % x for x in self._action['return_values']])))