Exemplos de subclass_exception em Python

Exemplo n.º 1

from celery.utils.serialization import UnpickleableExceptionWrapper
from celery.utils.serialization import get_pickleable_exception as gpe


class wrapobject(object):

    def __init__(self, *args, **kwargs):
        self.args = args


if sys.version_info[0] == 3 or getattr(sys, 'pypy_version_info', None):
    Oldstyle = None
else:
    Oldstyle = types.ClassType(bytes_if_py2('Oldstyle'), (), {})
Unpickleable = subclass_exception(
    bytes_if_py2('Unpickleable'), KeyError, 'foo.module',
)
Impossible = subclass_exception(
    bytes_if_py2('Impossible'), object, 'foo.module',
)
Lookalike = subclass_exception(
    bytes_if_py2('Lookalike'), wrapobject, 'foo.module',
)


class test_nulldict:

    def test_nulldict(self):
        x = _nulldict()
        x['foo'] = 1
        x.update(foo=1, bar=2)

Exemplo n.º 2

from celery.result import result_from_tuple
from celery.utils import uuid

from celery.tests.case import AppCase, Mock, SkipTest, patch


class wrapobject(object):
    def __init__(self, *args, **kwargs):
        self.args = args


if sys.version_info[0] == 3 or getattr(sys, 'pypy_version_info', None):
    Oldstyle = None
else:
    Oldstyle = types.ClassType('Oldstyle', (), {})
Unpickleable = subclass_exception('Unpickleable', KeyError, 'foo.module')
Impossible = subclass_exception('Impossible', object, 'foo.module')
Lookalike = subclass_exception('Lookalike', wrapobject, 'foo.module')


class test_serialization(AppCase):
    def test_create_exception_cls(self):
        self.assertTrue(serialization.create_exception_cls('FooError', 'm'))
        self.assertTrue(
            serialization.create_exception_cls('FooError', 'm', KeyError))


class test_BaseBackend_interface(AppCase):
    def setup(self):
        self.b = BaseBackend(self.app)

Exemplo n.º 3

Arquivo: test_base.py Projeto: gitter-badger/celery

from celery import states
from celery.backends.base import BaseBackend, KeyValueStoreBackend
from celery.backends.base import BaseDictBackend, DisabledBackend
from celery.utils import uuid

from celery.tests.utils import unittest


class wrapobject(object):

    def __init__(self, *args, **kwargs):
        self.args = args


Oldstyle = types.ClassType("Oldstyle", (), {})
Unpickleable = subclass_exception("Unpickleable", KeyError, "foo.module")
Impossible = subclass_exception("Impossible", object, "foo.module")
Lookalike = subclass_exception("Lookalike", wrapobject, "foo.module")
b = BaseBackend()


class test_serialization(unittest.TestCase):

    def test_create_exception_cls(self):
        self.assertTrue(serialization.create_exception_cls("FooError", "m"))
        self.assertTrue(serialization.create_exception_cls("FooError",
                                                            "m",
                                                            KeyError))


class test_BaseBackend_interface(unittest.TestCase):

Exemplo n.º 4

Arquivo: test_base.py Projeto: CheeseL0ver/celery

from celery.utils import uuid
from celery.utils.functional import pass1

from celery.tests.case import ANY, AppCase, Case, Mock, SkipTest, call, patch


class wrapobject(object):

    def __init__(self, *args, **kwargs):
        self.args = args

if sys.version_info[0] == 3 or getattr(sys, 'pypy_version_info', None):
    Oldstyle = None
else:
    Oldstyle = types.ClassType('Oldstyle', (), {})
Unpickleable = subclass_exception('Unpickleable', KeyError, 'foo.module')
Impossible = subclass_exception('Impossible', object, 'foo.module')
Lookalike = subclass_exception('Lookalike', wrapobject, 'foo.module')


class test_nulldict(Case):

    def test_nulldict(self):
        x = _nulldict()
        x['foo'] = 1
        x.update(foo=1, bar=2)
        x.setdefault('foo', 3)


class test_serialization(AppCase):

Exemplo n.º 5

Arquivo: test_base.py Projeto: EdwardBetts/celery

from celery.utils.functional import pass1

from celery.tests.case import ANY, AppCase, Case, Mock, call, patch, skip


class wrapobject(object):

    def __init__(self, *args, **kwargs):
        self.args = args

if sys.version_info[0] == 3 or getattr(sys, 'pypy_version_info', None):
    Oldstyle = None
else:
    Oldstyle = types.ClassType(module_name_t('Oldstyle'), (), {})
Unpickleable = subclass_exception(
    module_name_t('Unpickleable'), KeyError, 'foo.module',
)
Impossible = subclass_exception(
    module_name_t('Impossible'), object, 'foo.module',
)
Lookalike = subclass_exception(
    module_name_t('Lookalike'), wrapobject, 'foo.module',
)


class test_nulldict(Case):

    def test_nulldict(self):
        x = _nulldict()
        x['foo'] = 1
        x.update(foo=1, bar=2)

Exemplo n.º 6

from celery import states
from celery.backends.base import BaseBackend, KeyValueStoreBackend
from celery.backends.base import BaseDictBackend
from celery.utils import gen_unique_id

from celery.tests.utils import unittest


class wrapobject(object):
    def __init__(self, *args, **kwargs):
        self.args = args


Oldstyle = types.ClassType("Oldstyle", (), {})
Unpickleable = subclass_exception("Unpickleable", KeyError, "foo.module")
Impossible = subclass_exception("Impossible", object, "foo.module")
Lookalike = subclass_exception("Lookalike", wrapobject, "foo.module")
b = BaseBackend()


class test_serialization(unittest.TestCase):
    def test_create_exception_cls(self):
        self.assertTrue(serialization.create_exception_cls("FooError", "m"))
        self.assertTrue(
            serialization.create_exception_cls("FooError", "m", KeyError))


class test_BaseBackend_interface(unittest.TestCase):
    def test_get_status(self):
        self.assertRaises(NotImplementedError, b.get_status,

Exemplo n.º 7

Arquivo: test_base.py Projeto: gjames2467/celery

from celery.tests.case import (
    ANY, AppCase, Case, Mock, call, patch, skip_if_python3,
)


class wrapobject(object):

    def __init__(self, *args, **kwargs):
        self.args = args

if sys.version_info[0] == 3 or getattr(sys, 'pypy_version_info', None):
    Oldstyle = None
else:
    Oldstyle = types.ClassType(module_name_t('Oldstyle'), (), {})
Unpickleable = subclass_exception(
    module_name_t('Unpickleable'), KeyError, 'foo.module',
)
Impossible = subclass_exception(
    module_name_t('Impossible'), object, 'foo.module',
)
Lookalike = subclass_exception(
    module_name_t('Lookalike'), wrapobject, 'foo.module',
)


class test_nulldict(Case):

    def test_nulldict(self):
        x = _nulldict()
        x['foo'] = 1
        x.update(foo=1, bar=2)

Exemplo n.º 8

Arquivo: test_base.py Projeto: m4ddav3/celery

from celery.utils import uuid
from celery.utils.functional import pass1

from celery.tests.case import ANY, AppCase, Case, Mock, call, patch, skip


class wrapobject(object):
    def __init__(self, *args, **kwargs):
        self.args = args


if sys.version_info[0] == 3 or getattr(sys, "pypy_version_info", None):
    Oldstyle = None
else:
    Oldstyle = types.ClassType(bytes_if_py2("Oldstyle"), (), {})
Unpickleable = subclass_exception(bytes_if_py2("Unpickleable"), KeyError, "foo.module")
Impossible = subclass_exception(bytes_if_py2("Impossible"), object, "foo.module")
Lookalike = subclass_exception(bytes_if_py2("Lookalike"), wrapobject, "foo.module")


class test_nulldict(Case):
    def test_nulldict(self):
        x = _nulldict()
        x["foo"] = 1
        x.update(foo=1, bar=2)
        x.setdefault("foo", 3)


class test_serialization(AppCase):
    def test_create_exception_cls(self):
        self.assertTrue(serialization.create_exception_cls("FooError", "m"))