← Back to branch summary

~ubuntu-branches/debian/jessie/sqlalchemy/jessie

« back to all changes in this revision

Viewing changes to test/orm/test_utils.py

  • Committer: Package Import Robot
  • Author(s): Piotr Ożarowski, Jakub Wilk, Piotr Ożarowski
  • Date: 2013-07-06 20:53:52 UTC
  • mfrom: (1.4.23) (16.1.17 experimental)
  • Revision ID: package-import@ubuntu.com-20130706205352-ryppl1eto3illd79
Tags: 0.8.2-1
[ Jakub Wilk ]
* Use canonical URIs for Vcs-* fields.

[ Piotr Ożarowski ]
* New upstream release
* Upload to unstable
* Build depend on python3-all instead of -dev, extensions are not built for
  Python 3.X 

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/orm/test_utils.py
1
 
from test.lib.testing import assert_raises, assert_raises_message
2
 
from sqlalchemy.orm import interfaces, util
 
1
from sqlalchemy.testing import assert_raises, assert_raises_message
 
2
from sqlalchemy.orm import util
3
3
from sqlalchemy import Column
4
4
from sqlalchemy import Integer
5
5
from sqlalchemy import MetaData
6
6
from sqlalchemy import Table
7
 
from sqlalchemy.orm import aliased
 
7
from sqlalchemy.orm import aliased, with_polymorphic
8
8
from sqlalchemy.orm import mapper, create_session
9
 
from test.lib import testing
10
 
from test.lib import fixtures
 
9
from sqlalchemy.testing import fixtures
11
10
from test.orm import _fixtures
12
 
from test.lib.testing import eq_
13
 
 
 
11
from sqlalchemy.testing import eq_, is_
 
12
from sqlalchemy.orm.util import PathRegistry
 
13
from sqlalchemy import inspect
14
14
 
15
15
class AliasedClassTest(fixtures.TestBase):
16
16
    def point_map(self, cls):
229
229
        eq_(key, (User, (1,)))
230
230
 
231
231
 
 
232
class PathRegistryTest(_fixtures.FixtureTest):
 
233
    run_setup_mappers = 'once'
 
234
    run_inserts = None
 
235
    run_deletes = None
 
236
 
 
237
 
 
238
    @classmethod
 
239
    def setup_mappers(cls):
 
240
        cls._setup_stock_mapping()
 
241
 
 
242
    def test_root_registry(self):
 
243
        umapper = inspect(self.classes.User)
 
244
        is_(
 
245
            util.RootRegistry()[umapper],
 
246
            umapper._path_registry
 
247
        )
 
248
        eq_(
 
249
            util.RootRegistry()[umapper],
 
250
            util.PathRegistry.coerce((umapper,))
 
251
        )
 
252
 
 
253
    def test_expand(self):
 
254
        umapper = inspect(self.classes.User)
 
255
        amapper = inspect(self.classes.Address)
 
256
        path = PathRegistry.coerce((umapper,))
 
257
 
 
258
        eq_(
 
259
            path[umapper.attrs.addresses][amapper]
 
260
                [amapper.attrs.email_address],
 
261
            PathRegistry.coerce((umapper, umapper.attrs.addresses,
 
262
                                amapper, amapper.attrs.email_address))
 
263
        )
 
264
 
 
265
    def test_entity_boolean(self):
 
266
        umapper = inspect(self.classes.User)
 
267
        path = PathRegistry.coerce((umapper,))
 
268
        is_(bool(path), True)
 
269
 
 
270
    def test_key_boolean(self):
 
271
        umapper = inspect(self.classes.User)
 
272
        path = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
273
        is_(bool(path), True)
 
274
 
 
275
    def test_aliased_class(self):
 
276
        User = self.classes.User
 
277
        ua = aliased(User)
 
278
        ua_insp = inspect(ua)
 
279
        path = PathRegistry.coerce((ua_insp, ua_insp.mapper.attrs.addresses))
 
280
        assert path.parent.is_aliased_class
 
281
 
 
282
    def test_indexed_entity(self):
 
283
        umapper = inspect(self.classes.User)
 
284
        amapper = inspect(self.classes.Address)
 
285
        path = PathRegistry.coerce((umapper, umapper.attrs.addresses,
 
286
                                amapper, amapper.attrs.email_address))
 
287
        is_(path[0], umapper)
 
288
        is_(path[2], amapper)
 
289
 
 
290
    def test_indexed_key(self):
 
291
        umapper = inspect(self.classes.User)
 
292
        amapper = inspect(self.classes.Address)
 
293
        path = PathRegistry.coerce((umapper, umapper.attrs.addresses,
 
294
                                amapper, amapper.attrs.email_address))
 
295
        eq_(path[1], umapper.attrs.addresses)
 
296
        eq_(path[3], amapper.attrs.email_address)
 
297
 
 
298
    def test_slice(self):
 
299
        umapper = inspect(self.classes.User)
 
300
        amapper = inspect(self.classes.Address)
 
301
        path = PathRegistry.coerce((umapper, umapper.attrs.addresses,
 
302
                                amapper, amapper.attrs.email_address))
 
303
        eq_(path[1:3], (umapper.attrs.addresses, amapper))
 
304
 
 
305
    def test_addition(self):
 
306
        umapper = inspect(self.classes.User)
 
307
        amapper = inspect(self.classes.Address)
 
308
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
309
        p2 = PathRegistry.coerce((amapper, amapper.attrs.email_address))
 
310
        eq_(
 
311
            p1 + p2,
 
312
            PathRegistry.coerce((umapper, umapper.attrs.addresses,
 
313
                                amapper, amapper.attrs.email_address))
 
314
        )
 
315
 
 
316
    def test_length(self):
 
317
        umapper = inspect(self.classes.User)
 
318
        amapper = inspect(self.classes.Address)
 
319
        pneg1 = PathRegistry.coerce(())
 
320
        p0 = PathRegistry.coerce((umapper,))
 
321
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
322
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
323
        p3 = PathRegistry.coerce((umapper, umapper.attrs.addresses,
 
324
                                amapper, amapper.attrs.email_address))
 
325
 
 
326
        eq_(len(pneg1), 0)
 
327
        eq_(len(p0), 1)
 
328
        eq_(len(p1), 2)
 
329
        eq_(len(p2), 3)
 
330
        eq_(len(p3), 4)
 
331
        eq_(pneg1.length, 0)
 
332
        eq_(p0.length, 1)
 
333
        eq_(p1.length, 2)
 
334
        eq_(p2.length, 3)
 
335
        eq_(p3.length, 4)
 
336
 
 
337
    def test_eq(self):
 
338
        umapper = inspect(self.classes.User)
 
339
        amapper = inspect(self.classes.Address)
 
340
        u_alias = inspect(aliased(self.classes.User))
 
341
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
342
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
343
        p3 = PathRegistry.coerce((umapper, umapper.attrs.name))
 
344
        p4 = PathRegistry.coerce((u_alias, umapper.attrs.addresses))
 
345
        p5 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
346
        p6 = PathRegistry.coerce((amapper, amapper.attrs.user, umapper,
 
347
                                umapper.attrs.addresses))
 
348
        p7 = PathRegistry.coerce((amapper, amapper.attrs.user, umapper,
 
349
                                umapper.attrs.addresses,
 
350
                                amapper, amapper.attrs.email_address))
 
351
 
 
352
        is_(p1 == p2, True)
 
353
        is_(p1 == p3, False)
 
354
        is_(p1 == p4, False)
 
355
        is_(p1 == p5, False)
 
356
        is_(p6 == p7, False)
 
357
        is_(p6 == p7.parent.parent, True)
 
358
 
 
359
        is_(p1 != p2, False)
 
360
        is_(p1 != p3, True)
 
361
        is_(p1 != p4, True)
 
362
        is_(p1 != p5, True)
 
363
 
 
364
    def test_contains_mapper(self):
 
365
        umapper = inspect(self.classes.User)
 
366
        amapper = inspect(self.classes.Address)
 
367
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
368
        assert p1.contains_mapper(umapper)
 
369
        assert not p1.contains_mapper(amapper)
 
370
 
 
371
    def _registry(self):
 
372
        class Reg(dict):
 
373
            @property
 
374
            def _attributes(self):
 
375
                return self
 
376
        return Reg()
 
377
 
 
378
    def test_path(self):
 
379
        umapper = inspect(self.classes.User)
 
380
        amapper = inspect(self.classes.Address)
 
381
 
 
382
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
383
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
384
        p3 = PathRegistry.coerce((amapper, amapper.attrs.email_address))
 
385
 
 
386
        eq_(
 
387
            p1.path, (umapper, umapper.attrs.addresses)
 
388
        )
 
389
        eq_(
 
390
            p2.path, (umapper, umapper.attrs.addresses, amapper)
 
391
        )
 
392
        eq_(
 
393
            p3.path, (amapper, amapper.attrs.email_address)
 
394
        )
 
395
 
 
396
    def test_registry_set(self):
 
397
        reg = self._registry()
 
398
        umapper = inspect(self.classes.User)
 
399
        amapper = inspect(self.classes.Address)
 
400
 
 
401
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
402
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
403
        p3 = PathRegistry.coerce((amapper, amapper.attrs.email_address))
 
404
 
 
405
        p1.set(reg, "p1key", "p1value")
 
406
        p2.set(reg, "p2key", "p2value")
 
407
        p3.set(reg, "p3key", "p3value")
 
408
        eq_(
 
409
            reg,
 
410
            {
 
411
                ('p1key', p1.path): 'p1value',
 
412
                ('p2key', p2.path): 'p2value',
 
413
                ('p3key', p3.path): 'p3value',
 
414
            }
 
415
        )
 
416
 
 
417
    def test_registry_get(self):
 
418
        reg = self._registry()
 
419
        umapper = inspect(self.classes.User)
 
420
        amapper = inspect(self.classes.Address)
 
421
 
 
422
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
423
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
424
        p3 = PathRegistry.coerce((amapper, amapper.attrs.email_address))
 
425
        reg.update(
 
426
            {
 
427
                ('p1key', p1.path): 'p1value',
 
428
                ('p2key', p2.path): 'p2value',
 
429
                ('p3key', p3.path): 'p3value',
 
430
            }
 
431
        )
 
432
 
 
433
        eq_(p1.get(reg, "p1key"), "p1value")
 
434
        eq_(p2.get(reg, "p2key"), "p2value")
 
435
        eq_(p2.get(reg, "p1key"), None)
 
436
        eq_(p3.get(reg, "p3key"), "p3value")
 
437
        eq_(p3.get(reg, "p1key"), None)
 
438
 
 
439
    def test_registry_contains(self):
 
440
        reg = self._registry()
 
441
        umapper = inspect(self.classes.User)
 
442
        amapper = inspect(self.classes.Address)
 
443
 
 
444
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
445
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
446
        p3 = PathRegistry.coerce((amapper, amapper.attrs.email_address))
 
447
        reg.update(
 
448
            {
 
449
                ('p1key', p1.path): 'p1value',
 
450
                ('p2key', p2.path): 'p2value',
 
451
                ('p3key', p3.path): 'p3value',
 
452
            }
 
453
        )
 
454
        assert p1.contains(reg, "p1key")
 
455
        assert not p1.contains(reg, "p2key")
 
456
        assert p3.contains(reg, "p3key")
 
457
        assert not p2.contains(reg, "fake")
 
458
 
 
459
    def test_registry_setdefault(self):
 
460
        reg = self._registry()
 
461
        umapper = inspect(self.classes.User)
 
462
        amapper = inspect(self.classes.Address)
 
463
 
 
464
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
465
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
466
        reg.update(
 
467
            {
 
468
                ('p1key', p1.path): 'p1value',
 
469
            }
 
470
        )
 
471
 
 
472
        p1.setdefault(reg, "p1key", "p1newvalue_a")
 
473
        p1.setdefault(reg, "p1key_new", "p1newvalue_b")
 
474
        p2.setdefault(reg, "p2key", "p2newvalue")
 
475
        eq_(
 
476
            reg,
 
477
            {
 
478
                ('p1key', p1.path): 'p1value',
 
479
                ('p1key_new', p1.path): 'p1newvalue_b',
 
480
                ('p2key', p2.path): 'p2newvalue',
 
481
            }
 
482
        )
 
483
 
 
484
    def test_serialize(self):
 
485
        User = self.classes.User
 
486
        Address = self.classes.Address
 
487
        umapper = inspect(self.classes.User)
 
488
        amapper = inspect(self.classes.Address)
 
489
 
 
490
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper,
 
491
                            amapper.attrs.email_address))
 
492
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
493
        p3 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
494
        eq_(
 
495
            p1.serialize(),
 
496
            [(User, "addresses"), (Address, "email_address")]
 
497
        )
 
498
        eq_(
 
499
            p2.serialize(),
 
500
            [(User, "addresses"), (Address, None)]
 
501
        )
 
502
        eq_(
 
503
            p3.serialize(),
 
504
            [(User, "addresses")]
 
505
        )
 
506
 
 
507
    def test_deseralize(self):
 
508
        User = self.classes.User
 
509
        Address = self.classes.Address
 
510
        umapper = inspect(self.classes.User)
 
511
        amapper = inspect(self.classes.Address)
 
512
 
 
513
 
 
514
        p1 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper,
 
515
                            amapper.attrs.email_address))
 
516
        p2 = PathRegistry.coerce((umapper, umapper.attrs.addresses, amapper))
 
517
        p3 = PathRegistry.coerce((umapper, umapper.attrs.addresses))
 
518
 
 
519
        eq_(
 
520
            PathRegistry.deserialize([(User, "addresses"),
 
521
                        (Address, "email_address")]),
 
522
            p1
 
523
        )
 
524
        eq_(
 
525
            PathRegistry.deserialize([(User, "addresses"), (Address, None)]),
 
526
            p2
 
527
        )
 
528
        eq_(
 
529
            PathRegistry.deserialize([(User, "addresses")]),
 
530
            p3
 
531
        )
 
532
 
 
533
from .inheritance import _poly_fixtures
 
534
class PathRegistryInhTest(_poly_fixtures._Polymorphic):
 
535
    run_setup_mappers = 'once'
 
536
    run_inserts = None
 
537
    run_deletes = None
 
538
 
 
539
    def test_plain(self):
 
540
        Person = _poly_fixtures.Person
 
541
        Engineer = _poly_fixtures.Engineer
 
542
        pmapper = inspect(Person)
 
543
        emapper = inspect(Engineer)
 
544
 
 
545
        p1 = PathRegistry.coerce((pmapper, emapper.attrs.machines))
 
546
 
 
547
        # given a mapper and an attribute on a subclass,
 
548
        # the path converts what you get to be against that subclass
 
549
        eq_(
 
550
            p1.path,
 
551
            (emapper, emapper.attrs.machines)
 
552
        )
 
553
 
 
554
    def test_plain_compound(self):
 
555
        Company = _poly_fixtures.Company
 
556
        Person = _poly_fixtures.Person
 
557
        Engineer = _poly_fixtures.Engineer
 
558
        cmapper = inspect(Company)
 
559
        pmapper = inspect(Person)
 
560
        emapper = inspect(Engineer)
 
561
 
 
562
        p1 = PathRegistry.coerce((cmapper, cmapper.attrs.employees,
 
563
                        pmapper, emapper.attrs.machines))
 
564
 
 
565
        # given a mapper and an attribute on a subclass,
 
566
        # the path converts what you get to be against that subclass
 
567
        eq_(
 
568
            p1.path,
 
569
            (cmapper, cmapper.attrs.employees, emapper, emapper.attrs.machines)
 
570
        )
 
571
 
 
572
    def test_plain_aliased(self):
 
573
        Person = _poly_fixtures.Person
 
574
        Engineer = _poly_fixtures.Engineer
 
575
        emapper = inspect(Engineer)
 
576
 
 
577
        p_alias = aliased(Person)
 
578
        p_alias = inspect(p_alias)
 
579
 
 
580
        p1 = PathRegistry.coerce((p_alias, emapper.attrs.machines))
 
581
        # plain AliasedClass - the path keeps that AliasedClass directly
 
582
        # as is in the path
 
583
        eq_(
 
584
            p1.path,
 
585
            (p_alias, emapper.attrs.machines)
 
586
        )
 
587
 
 
588
    def test_plain_aliased_compound(self):
 
589
        Company = _poly_fixtures.Company
 
590
        Person = _poly_fixtures.Person
 
591
        Engineer = _poly_fixtures.Engineer
 
592
        cmapper = inspect(Company)
 
593
        emapper = inspect(Engineer)
 
594
 
 
595
        c_alias = aliased(Company)
 
596
        p_alias = aliased(Person)
 
597
 
 
598
        c_alias = inspect(c_alias)
 
599
        p_alias = inspect(p_alias)
 
600
 
 
601
        p1 = PathRegistry.coerce((c_alias, cmapper.attrs.employees,
 
602
                    p_alias, emapper.attrs.machines))
 
603
        # plain AliasedClass - the path keeps that AliasedClass directly
 
604
        # as is in the path
 
605
        eq_(
 
606
            p1.path,
 
607
            (c_alias, cmapper.attrs.employees, p_alias, emapper.attrs.machines)
 
608
        )
 
609
 
 
610
    def test_with_poly_sub(self):
 
611
        Person = _poly_fixtures.Person
 
612
        Engineer = _poly_fixtures.Engineer
 
613
        emapper = inspect(Engineer)
 
614
 
 
615
        p_poly = with_polymorphic(Person, [Engineer])
 
616
        e_poly = inspect(p_poly.Engineer)
 
617
        p_poly = inspect(p_poly)
 
618
 
 
619
        p1 = PathRegistry.coerce((p_poly, emapper.attrs.machines))
 
620
 
 
621
        # polymorphic AliasedClass - the path uses _entity_for_mapper()
 
622
        # to get the most specific sub-entity
 
623
        eq_(
 
624
            p1.path,
 
625
            (e_poly, emapper.attrs.machines)
 
626
        )
 
627
 
 
628
    def test_with_poly_base(self):
 
629
        Person = _poly_fixtures.Person
 
630
        Engineer = _poly_fixtures.Engineer
 
631
        pmapper = inspect(Person)
 
632
        emapper = inspect(Engineer)
 
633
 
 
634
        p_poly = with_polymorphic(Person, [Engineer])
 
635
        p_poly = inspect(p_poly)
 
636
 
 
637
        # "name" is actually on Person, not Engineer
 
638
        p1 = PathRegistry.coerce((p_poly, emapper.attrs.name))
 
639
 
 
640
        # polymorphic AliasedClass - because "name" is on Person,
 
641
        # we get Person, not Engineer
 
642
        eq_(
 
643
            p1.path,
 
644
            (p_poly, pmapper.attrs.name)
 
645
        )
 
646
 
 
647
    def test_with_poly_use_mapper(self):
 
648
        Person = _poly_fixtures.Person
 
649
        Engineer = _poly_fixtures.Engineer
 
650
        emapper = inspect(Engineer)
 
651
 
 
652
        p_poly = with_polymorphic(Person, [Engineer], _use_mapper_path=True)
 
653
        p_poly = inspect(p_poly)
 
654
 
 
655
        p1 = PathRegistry.coerce((p_poly, emapper.attrs.machines))
 
656
 
 
657
        # polymorphic AliasedClass with the "use_mapper_path" flag -
 
658
        # the AliasedClass acts just like the base mapper
 
659
        eq_(
 
660
            p1.path,
 
661
            (emapper, emapper.attrs.machines)
 
662
        )
 
663