def test_defaulted_init(self): class X(object): def __init__(self_, a, b=123, c='abc'): self_.a = a self_.b = b self_.c = c instrumentation.register_class(X) o = X('foo') eq_(o.a, 'foo') eq_(o.b, 123) eq_(o.c, 'abc') class Y(object): unique = object() class OutOfScopeForEval(object): def __repr__(self_): # misleading repr return '123' outofscope = OutOfScopeForEval() def __init__(self_, u=unique, o=outofscope): self_.u = u self_.o = o instrumentation.register_class(Y) o = Y() assert o.u is Y.unique assert o.o is Y.outofscope
def test_inheritance(self): """tests that attributes are polymorphic""" for base in (object, MyBaseClass, MyClass): class Foo(base):pass class Bar(Foo):pass instrumentation.register_class(Foo) instrumentation.register_class(Bar) def func1(state, passive): return "this is the foo attr" def func2(state, passive): return "this is the bar attr" def func3(state, passive): return "this is the shared attr" attributes.register_attribute(Foo, 'element', uselist=False, callable_=func1, useobject=True) attributes.register_attribute(Foo, 'element2', uselist=False, callable_=func3, useobject=True) attributes.register_attribute(Bar, 'element', uselist=False, callable_=func2, useobject=True) x = Foo() y = Bar() assert x.element == 'this is the foo attr' assert y.element == 'this is the bar attr', y.element assert x.element2 == 'this is the shared attr' assert y.element2 == 'this is the shared attr'
def test_basic(self): for base in (object, MyBaseClass, MyClass): class User(base): pass register_class(User) attributes.register_attribute( User, 'user_id', uselist=False, useobject=False) attributes.register_attribute( User, 'user_name', uselist=False, useobject=False) attributes.register_attribute( User, 'email_address', uselist=False, useobject=False) u = User() u.user_id = 7 u.user_name = 'john' u.email_address = '*****@*****.**' eq_(u.user_id, 7) eq_(u.user_name, "john") eq_(u.email_address, "*****@*****.**") attributes.instance_state(u)._commit_all( attributes.instance_dict(u)) eq_(u.user_id, 7) eq_(u.user_name, "john") eq_(u.email_address, "*****@*****.**") u.user_name = 'heythere' u.email_address = '*****@*****.**' eq_(u.user_id, 7) eq_(u.user_name, "heythere") eq_(u.email_address, "*****@*****.**")
def test_collection_with_backref(self): for base in (object, MyBaseClass, MyClass): class Post(base):pass class Blog(base):pass instrumentation.register_class(Post) instrumentation.register_class(Blog) attributes.register_attribute(Post, 'blog', uselist=False, backref='posts', trackparent=True, useobject=True) attributes.register_attribute(Blog, 'posts', uselist=True, backref='blog', trackparent=True, useobject=True) b = Blog() (p1, p2, p3) = (Post(), Post(), Post()) b.posts.append(p1) b.posts.append(p2) b.posts.append(p3) self.assert_(b.posts == [p1, p2, p3]) self.assert_(p2.blog is b) p3.blog = None self.assert_(b.posts == [p1, p2]) p4 = Post() p4.blog = b self.assert_(b.posts == [p1, p2, p4]) p4.blog = b p4.blog = b self.assert_(b.posts == [p1, p2, p4]) # assert no failure removing None p5 = Post() p5.blog = None del p5.blog
def test_standard(self): class A(object): pass register_class(A) eq_(type(manager_of_class(A)), instrumentation.ClassManager)
def test_nativeext_submanager(self): class Mine(instrumentation.ClassManager): pass class A(object): __sa_instrumentation_manager__ = Mine instrumentation.register_class(A) eq_(type(instrumentation.manager_of_class(A)), Mine)
def test_instance_dict(self): class User(MyClass): pass register_class(User) attributes.register_attribute( User, "user_id", uselist=False, useobject=False ) attributes.register_attribute( User, "user_name", uselist=False, useobject=False ) attributes.register_attribute( User, "email_address", uselist=False, useobject=False ) u = User() u.user_id = 7 u.user_name = "john" u.email_address = "*****@*****.**" eq_( u.__dict__, { "_my_state": u._my_state, "_goofy_dict": { "user_id": 7, "user_name": "john", "email_address": "*****@*****.**", }, }, )
def test_customfinder_pass(self): class A(object): pass def find(cls): return None instrumentation.instrumentation_finders.insert(0, find) instrumentation.register_class(A) eq_(type(instrumentation.manager_of_class(A)), instrumentation.ClassManager)
def register(self, cls, canary): original_init = cls.__init__ instrumentation.register_class(cls) ne_(cls.__init__, original_init) manager = instrumentation.manager_of_class(cls) def init(state, args, kwargs): canary.append((cls, 'init', state.class_)) event.listen(manager, 'init', init, raw=True)
def test_nativeext_interfaceexact(self): class A(object): __sa_instrumentation_manager__ = ( instrumentation.InstrumentationManager ) register_class(A) ne_(type(manager_of_class(A)), instrumentation.ClassManager)
def test_null_instrumentation(self): class Foo(MyBaseClass): pass instrumentation.register_class(Foo) attributes.register_attribute(Foo, "name", uselist=False, useobject=False) attributes.register_attribute(Foo, "bars", uselist=True, trackparent=True, useobject=True) assert Foo.name == attributes.manager_of_class(Foo)['name'] assert Foo.bars == attributes.manager_of_class(Foo)['bars']
def test_customfinder_greedy(self): class Mine(instrumentation.ClassManager): pass class A(object): pass def find(cls): return Mine instrumentation.instrumentation_finders.insert(0, find) register_class(A) eq_(type(instrumentation.manager_of_class(A)), Mine)
def test_single_down(self): class A(object): pass instrumentation.register_class(A) mgr_factory = lambda cls: instrumentation.ClassManager(cls) class B(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) assert_raises_message(TypeError, "multiple instrumentation implementations", instrumentation.register_class, B)
def test_diamond_b2(self): mgr_factory = lambda cls: instrumentation.ClassManager(cls) class A(object): pass class B1(A): pass class B2(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) class C(object): pass instrumentation.register_class(B2) assert_raises_message(TypeError, "multiple instrumentation implementations", instrumentation.register_class, B1)
def test_subclassed(self): class MyEvents(events.InstanceEvents): pass class MyClassManager(instrumentation.ClassManager): dispatch = event.dispatcher(MyEvents) instrumentation.instrumentation_finders.insert(0, lambda cls: MyClassManager) class A(object): pass instrumentation.register_class(A) manager = instrumentation.manager_of_class(A) assert issubclass(manager.dispatch._parent_cls.__dict__['dispatch'].events, MyEvents)
def test_single_down(self): class A(object): pass register_class(A) mgr_factory = lambda cls: instrumentation.ClassManager(cls) class B(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) assert_raises_message(TypeError, "multiple instrumentation implementations", register_class, B)
def test_instance_dict(self): class User(MyClass): pass instrumentation.register_class(User) attributes.register_attribute(User, 'user_id', uselist = False, useobject=False) attributes.register_attribute(User, 'user_name', uselist = False, useobject=False) attributes.register_attribute(User, 'email_address', uselist = False, useobject=False) u = User() u.user_id = 7 u.user_name = 'john' u.email_address = '*****@*****.**' self.assert_(u.__dict__ == {'_my_state':u._my_state, '_goofy_dict':{'user_id':7, 'user_name':'john', 'email_address':'*****@*****.**'}}, u.__dict__)
def test_collection_with_backref(self): for base in (object, MyBaseClass, MyClass): class Post(base): pass class Blog(base): pass register_class(Post) register_class(Blog) attributes.register_attribute( Post, "blog", uselist=False, backref="posts", trackparent=True, useobject=True, ) attributes.register_attribute( Blog, "posts", uselist=True, backref="blog", trackparent=True, useobject=True, ) b = Blog() (p1, p2, p3) = (Post(), Post(), Post()) b.posts.append(p1) b.posts.append(p2) b.posts.append(p3) self.assert_(b.posts == [p1, p2, p3]) self.assert_(p2.blog is b) p3.blog = None self.assert_(b.posts == [p1, p2]) p4 = Post() p4.blog = b self.assert_(b.posts == [p1, p2, p4]) p4.blog = b p4.blog = b self.assert_(b.posts == [p1, p2, p4]) # assert no failure removing None p5 = Post() p5.blog = None del p5.blog
def test_single_up(self): class A(object): pass # delay registration def mgr_factory(cls): return instrumentation.ClassManager(cls) class B(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) register_class(B) assert_raises_message( TypeError, "multiple instrumentation implementations", register_class, A)
def test_register_reserved_attribute(self): class T(object): pass instrumentation.register_class(T) manager = instrumentation.manager_of_class(T) sa = instrumentation.ClassManager.STATE_ATTR ma = instrumentation.ClassManager.MANAGER_ATTR fails = lambda method, attr: assert_raises( KeyError, getattr(manager, method), attr, property()) fails('install_member', sa) fails('install_member', ma) fails('install_descriptor', sa) fails('install_descriptor', ma)
def test_deferred(self): for base in (object, MyBaseClass, MyClass): class Foo(base): pass data = {'a': 'this is a', 'b': 12} def loader(state, keys): for k in keys: state.dict[k] = data[k] return attributes.ATTR_WAS_SET manager = register_class(Foo) manager.deferred_scalar_loader = loader attributes.register_attribute(Foo, 'a', uselist=False, useobject=False) attributes.register_attribute(Foo, 'b', uselist=False, useobject=False) if base is object: assert Foo not in instrumentation._instrumentation_factory._state_finders else: assert Foo in instrumentation._instrumentation_factory._state_finders f = Foo() attributes.instance_state(f)._expire(attributes.instance_dict(f), set()) eq_(f.a, "this is a") eq_(f.b, 12) f.a = "this is some new a" attributes.instance_state(f)._expire(attributes.instance_dict(f), set()) eq_(f.a, "this is a") eq_(f.b, 12) attributes.instance_state(f)._expire(attributes.instance_dict(f), set()) f.a = "this is another new a" eq_(f.a, "this is another new a") eq_(f.b, 12) attributes.instance_state(f)._expire(attributes.instance_dict(f), set()) eq_(f.a, "this is a") eq_(f.b, 12) del f.a eq_(f.a, None) eq_(f.b, 12) attributes.instance_state(f)._commit_all( attributes.instance_dict(f)) eq_(f.a, None) eq_(f.b, 12)
def _instrument(self, cls): manager = instrumentation.register_class(cls) canary = [] def check(target, args, kwargs): canary.append((args, kwargs)) event.listen(manager, "init", check) return cls, canary
def __init__(self, cls_, classname, dict_): self.cls = cls_ # dict_ will be a dictproxy, which we can't write to, and we need to! self.dict_ = dict(dict_) self.classname = classname self.mapped_table = None self.properties = util.OrderedDict() self.declared_columns = set() self.column_copies = {} self._setup_declared_events() # register up front, so that @declared_attr can memoize # function evaluations in .info manager = instrumentation.register_class(self.cls) manager.info['declared_attr_reg'] = {} self._scan_attributes() clsregistry.add_class(self.classname, self.cls) self._extract_mappable_attributes() self._extract_declared_columns() self._setup_table() self._setup_inheritance() self._early_mapping()
def test_uninstrument(self): class A: pass manager = instrumentation.register_class(A) attributes.register_attribute( A, "x", comparator=object(), parententity=object(), uselist=False, useobject=False, ) assert instrumentation.manager_of_class(A) is manager instrumentation.unregister_class(A) assert instrumentation.opt_manager_of_class(A) is None assert not hasattr(A, "x") with expect_raises_message( sa.orm.exc.UnmappedClassError, r"Can't locate an instrumentation manager for class .*A", ): instrumentation.manager_of_class(A) assert A.__init__ == object.__init__
def test_subclassed(self): class MyEvents(events.InstanceEvents): pass class MyClassManager(instrumentation.ClassManager): dispatch = event.dispatcher(MyEvents) instrumentation.instrumentation_finders.insert( 0, lambda cls: MyClassManager) class A(object): pass register_class(A) manager = instrumentation.manager_of_class(A) assert issubclass(manager.dispatch._events, MyEvents)
def test_uninstrument(self): class A(object):pass manager = instrumentation.register_class(A) assert instrumentation.manager_of_class(A) is manager instrumentation.unregister_class(A) assert instrumentation.manager_of_class(A) is None
def test_single_up(self): class A(object): pass # delay registration def mgr_factory(cls): return instrumentation.ClassManager(cls) class B(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) register_class(B) assert_raises_message(TypeError, "multiple instrumentation implementations", register_class, A)
def test_null_instrumentation(self): class Foo(MyBaseClass): pass register_class(Foo) attributes.register_attribute(Foo, "name", uselist=False, useobject=False) attributes.register_attribute(Foo, "bars", uselist=True, trackparent=True, useobject=True) assert Foo.name == attributes.manager_of_class(Foo)["name"] assert Foo.bars == attributes.manager_of_class(Foo)["bars"]
def get_class_bound_dispatcher(target_cls): """Python class-bound FSM dispatcher class.""" try: out_val = FSM_EVENT_DISPATCHER_CACHE[target_cls] except KeyError: out_val = register_class(target_cls).dispatch FSM_EVENT_DISPATCHER_CACHE[target_cls] = out_val return out_val
def test_inheritance(self): """tests that attributes are polymorphic""" for base in (object, MyBaseClass, MyClass): class Foo(base): pass class Bar(Foo): pass register_class(Foo) register_class(Bar) def func1(state, passive): return "this is the foo attr" def func2(state, passive): return "this is the bar attr" def func3(state, passive): return "this is the shared attr" attributes.register_attribute(Foo, "element", uselist=False, callable_=func1, useobject=True) attributes.register_attribute(Foo, "element2", uselist=False, callable_=func3, useobject=True) attributes.register_attribute(Bar, "element", uselist=False, callable_=func2, useobject=True) x = Foo() y = Bar() assert x.element == "this is the foo attr" assert y.element == "this is the bar attr", y.element assert x.element2 == "this is the shared attr" assert y.element2 == "this is the shared attr"
def test_deferred(self): for base in (object, MyBaseClass, MyClass): class Foo(base): pass data = {'a': 'this is a', 'b': 12} def loader(state, keys): for k in keys: state.dict[k] = data[k] return attributes.ATTR_WAS_SET manager = register_class(Foo) manager.deferred_scalar_loader = loader attributes.register_attribute( Foo, 'a', uselist=False, useobject=False) attributes.register_attribute( Foo, 'b', uselist=False, useobject=False) if base is object: assert Foo not in \ instrumentation._instrumentation_factory._state_finders else: assert Foo in \ instrumentation._instrumentation_factory._state_finders f = Foo() attributes.instance_state(f)._expire( attributes.instance_dict(f), set()) eq_(f.a, "this is a") eq_(f.b, 12) f.a = "this is some new a" attributes.instance_state(f)._expire( attributes.instance_dict(f), set()) eq_(f.a, "this is a") eq_(f.b, 12) attributes.instance_state(f)._expire( attributes.instance_dict(f), set()) f.a = "this is another new a" eq_(f.a, "this is another new a") eq_(f.b, 12) attributes.instance_state(f)._expire( attributes.instance_dict(f), set()) eq_(f.a, "this is a") eq_(f.b, 12) del f.a eq_(f.a, None) eq_(f.b, 12) attributes.instance_state(f)._commit_all( attributes.instance_dict(f)) eq_(f.a, None) eq_(f.b, 12)
def test_register_reserved_attribute(self): class T: pass instrumentation.register_class(T) manager = instrumentation.manager_of_class(T) sa = instrumentation.ClassManager.STATE_ATTR ma = instrumentation.ClassManager.MANAGER_ATTR def fails(method, attr): return assert_raises(KeyError, getattr(manager, method), attr, property()) fails("install_member", sa) fails("install_member", ma) fails("install_descriptor", sa) fails("install_descriptor", ma)
def test_single_down(self): class A: pass register_class(A) def mgr_factory(cls): return instrumentation.ClassManager(cls) class B(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) assert_raises_message( TypeError, "multiple instrumentation implementations", register_class, B, )
def test_alternate_finders(self): """Ensure the generic finder front-end deals with edge cases.""" class Unknown(object): pass class Known(MyBaseClass): pass instrumentation.register_class(Known) k, u = Known(), Unknown() assert instrumentation.manager_of_class(Unknown) is None assert instrumentation.manager_of_class(Known) is not None assert instrumentation.manager_of_class(None) is None assert attributes.instance_state(k) is not None assert_raises((AttributeError, KeyError), attributes.instance_state, u) assert_raises((AttributeError, KeyError), attributes.instance_state, None)
def test_basic(self): import pickle global A class A(object): pass def canary(instance): assert False try: instrumentation.register_class(A) manager = instrumentation.manager_of_class(A) event.listen(manager, 'load', canary) a = A() p_a = pickle.dumps(a) re_a = pickle.loads(p_a) finally: del A
def test_alternate_finders(self): """Ensure the generic finder front-end deals with edge cases.""" class Unknown(object): pass class Known(MyBaseClass): pass register_class(Known) k, u = Known(), Unknown() assert instrumentation.manager_of_class(Unknown) is None assert instrumentation.manager_of_class(Known) is not None assert instrumentation.manager_of_class(None) is None assert attributes.instance_state(k) is not None assert_raises((AttributeError, KeyError), attributes.instance_state, u) assert_raises((AttributeError, KeyError), attributes.instance_state, None)
def test_diamond_b2(self): mgr_factory = lambda cls: instrumentation.ClassManager(cls) class A(object): pass class B1(A): pass class B2(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) class C(object): pass register_class(B2) assert_raises_message(TypeError, "multiple instrumentation implementations", register_class, B1)
def __init__(self, registry, cls_): self.cls = cls_ self.classname = cls_.__name__ self.properties = util.OrderedDict() self.declared_attr_reg = {} instrumentation.register_class( self.cls, finalize=False, registry=registry, declarative_scan=self, init_method=registry.constructor, ) event.listen( cls_, "class_uninstrument", registry._dispose_declarative_artifacts, )
def test_diamond_c_b(self): def mgr_factory(cls): return instrumentation.ClassManager(cls) class A(object): pass class B1(A): pass class B2(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) class C(object): pass register_class(C) assert_raises_message( TypeError, "multiple instrumentation implementations", register_class, B1)
def __init__(self, registry, cls_, mapper_kw): self.cls = util.assert_arg_type(cls_, type, "cls_") self.classname = cls_.__name__ self.properties = util.OrderedDict() self.declared_attr_reg = {} if not mapper_kw.get("non_primary", False): instrumentation.register_class( self.cls, finalize=False, registry=registry, declarative_scan=self, init_method=registry.constructor, ) else: manager = attributes.manager_of_class(self.cls) if not manager or not manager.is_mapped: raise exc.InvalidRequestError( "Class %s has no primary mapper configured. Configure " "a primary mapper first before setting up a non primary " "Mapper." % self.cls)
def test_basic(self): for base in (object, MyBaseClass, MyClass): class User(base): pass register_class(User) attributes.register_attribute(User, "user_id", uselist=False, useobject=False) attributes.register_attribute(User, "user_name", uselist=False, useobject=False) attributes.register_attribute(User, "email_address", uselist=False, useobject=False) u = User() u.user_id = 7 u.user_name = "john" u.email_address = "*****@*****.**" eq_(u.user_id, 7) eq_(u.user_name, "john") eq_(u.email_address, "*****@*****.**") attributes.instance_state(u)._commit_all( attributes.instance_dict(u)) eq_(u.user_id, 7) eq_(u.user_name, "john") eq_(u.email_address, "*****@*****.**") u.user_name = "heythere" u.email_address = "*****@*****.**" eq_(u.user_id, 7) eq_(u.user_name, "heythere") eq_(u.email_address, "*****@*****.**")
def test_uninstrument(self): class A(object): pass manager = instrumentation.register_class(A) attributes.register_attribute(A, "x", uselist=False, useobject=False) assert instrumentation.manager_of_class(A) is manager instrumentation.unregister_class(A) assert instrumentation.manager_of_class(A) is None assert not hasattr(A, "x") assert A.__init__ == object.__init__
def test_basic(self): for base in (object, MyBaseClass, MyClass): class User(base): pass instrumentation.register_class(User) attributes.register_attribute(User, 'user_id', uselist = False, useobject=False) attributes.register_attribute(User, 'user_name', uselist = False, useobject=False) attributes.register_attribute(User, 'email_address', uselist = False, useobject=False) u = User() u.user_id = 7 u.user_name = 'john' u.email_address = '*****@*****.**' self.assert_(u.user_id == 7 and u.user_name == 'john' and u.email_address == '*****@*****.**') attributes.instance_state(u).commit_all(attributes.instance_dict(u)) self.assert_(u.user_id == 7 and u.user_name == 'john' and u.email_address == '*****@*****.**') u.user_name = 'heythere' u.email_address = '*****@*****.**' self.assert_(u.user_id == 7 and u.user_name == 'heythere' and u.email_address == '*****@*****.**')
def test_history(self): for base in (object, MyBaseClass, MyClass): class Foo(base): pass class Bar(base): pass instrumentation.register_class(Foo) instrumentation.register_class(Bar) attributes.register_attribute(Foo, "name", uselist=False, useobject=False) attributes.register_attribute(Foo, "bars", uselist=True, trackparent=True, useobject=True) attributes.register_attribute(Bar, "name", uselist=False, useobject=False) f1 = Foo() f1.name = 'f1' eq_(attributes.get_state_history(attributes.instance_state(f1), 'name'), (['f1'], (), ())) b1 = Bar() b1.name = 'b1' f1.bars.append(b1) eq_(attributes.get_state_history(attributes.instance_state(f1), 'bars'), ([b1], [], [])) attributes.instance_state(f1).commit_all(attributes.instance_dict(f1)) attributes.instance_state(b1).commit_all(attributes.instance_dict(b1)) eq_(attributes.get_state_history(attributes.instance_state(f1), 'name'), ((), ['f1'], ())) eq_(attributes.get_state_history(attributes.instance_state(f1), 'bars'), ((), [b1], ())) f1.name = 'f1mod' b2 = Bar() b2.name = 'b2' f1.bars.append(b2) eq_(attributes.get_state_history(attributes.instance_state(f1), 'name'), (['f1mod'], (), ['f1'])) eq_(attributes.get_state_history(attributes.instance_state(f1), 'bars'), ([b2], [b1], [])) f1.bars.remove(b1) eq_(attributes.get_state_history(attributes.instance_state(f1), 'bars'), ([b2], [], [b1]))
def test_diamond_b2(self): def mgr_factory(cls): return instrumentation.ClassManager(cls) class A: pass class B1(A): pass class B2(A): __sa_instrumentation_manager__ = staticmethod(mgr_factory) class C: pass register_class(B2) assert_raises_message( TypeError, "multiple instrumentation implementations", register_class, B1, )
def test_uninstrument(self): class A(object):pass manager = instrumentation.register_class(A) attributes.register_attribute(A, 'x', uselist=False, useobject=False) assert instrumentation.manager_of_class(A) is manager instrumentation.unregister_class(A) assert instrumentation.manager_of_class(A) is None assert not hasattr(A, 'x') # I prefer 'is' here but on pypy # it seems only == works assert A.__init__ == object.__init__
def test_basic(self): for base in (object, MyBaseClass, MyClass): class User(base): pass register_class(User) attributes.register_attribute(User, 'user_id', uselist=False, useobject=False) attributes.register_attribute(User, 'user_name', uselist=False, useobject=False) attributes.register_attribute(User, 'email_address', uselist=False, useobject=False) u = User() u.user_id = 7 u.user_name = 'john' u.email_address = '*****@*****.**' self.assert_(u.user_id == 7 and u.user_name == 'john' and u.email_address == '*****@*****.**') attributes.instance_state(u)._commit_all( attributes.instance_dict(u)) self.assert_(u.user_id == 7 and u.user_name == 'john' and u.email_address == '*****@*****.**') u.user_name = 'heythere' u.email_address = '*****@*****.**' self.assert_(u.user_id == 7 and u.user_name == 'heythere' and u.email_address == '*****@*****.**')
def test_uninstrument(self): class A(object): pass manager = instrumentation.register_class(A) attributes.register_attribute(A, 'x', uselist=False, useobject=False) assert instrumentation.manager_of_class(A) is manager instrumentation.unregister_class(A) assert instrumentation.manager_of_class(A) is None assert not hasattr(A, 'x') # I prefer 'is' here but on pypy # it seems only == works assert A.__init__ == object.__init__
def test_none(self): class A(object): pass instrumentation.register_class(A) mgr_factory = lambda cls: instrumentation.ClassManager(cls) class B(object): __sa_instrumentation_manager__ = staticmethod(mgr_factory) instrumentation.register_class(B) class C(object): __sa_instrumentation_manager__ = instrumentation.ClassManager instrumentation.register_class(C)
def test_none(self): class A(object): pass register_class(A) def mgr_factory(cls): return instrumentation.ClassManager(cls) class B(object): __sa_instrumentation_manager__ = staticmethod(mgr_factory) register_class(B) class C(object): __sa_instrumentation_manager__ = instrumentation.ClassManager register_class(C)
def test_history(self): for base in (object, MyBaseClass, MyClass): class Foo(base): pass class Bar(base): pass register_class(Foo) register_class(Bar) attributes.register_attribute(Foo, "name", uselist=False, useobject=False) attributes.register_attribute(Foo, "bars", uselist=True, trackparent=True, useobject=True) attributes.register_attribute(Bar, "name", uselist=False, useobject=False) f1 = Foo() f1.name = "f1" eq_( attributes.get_state_history(attributes.instance_state(f1), "name"), (["f1"], (), ()), ) b1 = Bar() b1.name = "b1" f1.bars.append(b1) eq_( attributes.get_state_history(attributes.instance_state(f1), "bars"), ([b1], [], []), ) attributes.instance_state(f1)._commit_all( attributes.instance_dict(f1)) attributes.instance_state(b1)._commit_all( attributes.instance_dict(b1)) eq_( attributes.get_state_history(attributes.instance_state(f1), "name"), ((), ["f1"], ()), ) eq_( attributes.get_state_history(attributes.instance_state(f1), "bars"), ((), [b1], ()), ) f1.name = "f1mod" b2 = Bar() b2.name = "b2" f1.bars.append(b2) eq_( attributes.get_state_history(attributes.instance_state(f1), "name"), (["f1mod"], (), ["f1"]), ) eq_( attributes.get_state_history(attributes.instance_state(f1), "bars"), ([b2], [b1], []), ) f1.bars.remove(b1) eq_( attributes.get_state_history(attributes.instance_state(f1), "bars"), ([b2], [], [b1]), )
def test_nativeext_interfaceexact(self): class A(object): __sa_instrumentation_manager__ = sa.orm.interfaces.InstrumentationManager instrumentation.register_class(A) ne_(type(instrumentation.manager_of_class(A)), instrumentation.ClassManager)
def test_standard(self): class A(object): pass instrumentation.register_class(A) eq_(type(instrumentation.manager_of_class(A)), instrumentation.ClassManager)