tests/columns.py

   1 # -*- coding: utf-8 -*-
   2 """Test the core table functionality."""
   3 from attest import Tests, Assert
   4 from django_attest import TransactionTestContext
   5 from django.test.client import RequestFactory
   6 from django.template import Context, Template
   7 from django.core.exceptions import ImproperlyConfigured
   8 import django_tables2 as tables
   9 from django_tables2 import utils, A
  10 from .testapp.models import Person
  11 from django.utils.translation import ugettext_lazy
  12 from django.utils.translation import ugettext
  13
  14
  15 general = Tests()
  16
  17
  18 @general.test
  19 def sortable():
  20     class SimpleTable(tables.Table):
  21         name = tables.Column()
  22     Assert(SimpleTable([]).columns['name'].sortable) is True
  23
  24     class SimpleTable(tables.Table):
  25         name = tables.Column()
  26
  27         class Meta:
  28             sortable = False
  29     Assert(SimpleTable([]).columns['name'].sortable) is False
  30
  31     class SimpleTable(tables.Table):
  32         name = tables.Column()
  33
  34         class Meta:
  35             sortable = True
  36     Assert(SimpleTable([]).columns['name'].sortable) is True
  37
  38
  39 @general.test
  40 def translation():
  41     """
  42     Tests different types of values for the ``verbose_name`` property of a
  43     column.
  44     """
  45     class TranslationTable(tables.Table):
  46         normal = tables.Column(verbose_name=ugettext("Normal"))
  47         lazy = tables.Column(verbose_name=ugettext("Lazy"))
  48
  49     table = TranslationTable([])
  50     Assert("Normal") == table.columns["normal"].header
  51     Assert("Lazy") == table.columns["lazy"].header
  52
  53
  54 @general.test
  55 def sequence():
  56     """
  57     Ensures that the sequence of columns is configurable.
  58     """
  59     class TestTable(tables.Table):
  60         a = tables.Column()
  61         b = tables.Column()
  62         c = tables.Column()
  63     Assert(["a", "b", "c"]) == TestTable([]).columns.names()
  64     Assert(["b", "a", "c"]) == TestTable([], sequence=("b", "a", "c")).columns.names()
  65
  66     class TestTable2(TestTable):
  67         class Meta:
  68             sequence = ("b", "a", "c")
  69     Assert(["b", "a", "c"]) == TestTable2([]).columns.names()
  70     Assert(["a", "b", "c"]) == TestTable2([], sequence=("a", "b", "c")).columns.names()
  71
  72     # BAD, all columns must be specified, or must use "..."
  73     with Assert.raises(ValueError):
  74         class TestTable3(TestTable):
  75             class Meta:
  76                 sequence = ("a", )
  77     with Assert.raises(ValueError):
  78         TestTable([], sequence=("a", ))
  79
  80     # GOOD, using a single "..." allows you to only specify some columns. The
  81     # remaining columns are ordered based on their definition order
  82     class TestTable4(TestTable):
  83         class Meta:
  84             sequence = ("...", )
  85     Assert(["a", "b", "c"]) == TestTable4([]).columns.names()
  86     Assert(["a", "b", "c"]) == TestTable([], sequence=("...", )).columns.names()
  87
  88     class TestTable5(TestTable):
  89         class Meta:
  90             sequence = ("b", "...")
  91     Assert(["b", "a", "c"]) == TestTable5([]).columns.names()
  92     Assert(["b", "a", "c"]) == TestTable([], sequence=("b", "...")).columns.names()
  93
  94     class TestTable6(TestTable):
  95         class Meta:
  96             sequence = ("...", "b")
  97     Assert(["a", "c", "b"]) == TestTable6([]).columns.names()
  98     Assert(["a", "c", "b"]) == TestTable([], sequence=("...", "b")).columns.names()
  99
 100     class TestTable7(TestTable):
 101         class Meta:
 102             sequence = ("b", "...", "a")
 103     Assert(["b", "c", "a"]) == TestTable7([]).columns.names()
 104     Assert(["b", "c", "a"]) == TestTable([], sequence=("b", "...", "a")).columns.names()
 105
 106     # Let's test inheritence
 107     class TestTable8(TestTable):
 108         d = tables.Column()
 109         e = tables.Column()
 110         f = tables.Column()
 111
 112         class Meta:
 113             sequence = ("d", "...")
 114
 115     class TestTable9(TestTable):
 116         d = tables.Column()
 117         e = tables.Column()
 118         f = tables.Column()
 119
 120     Assert(["d", "a", "b", "c", "e", "f"]) == TestTable8([]).columns.names()
 121     Assert(["d", "a", "b", "c", "e", "f"]) == TestTable9([], sequence=("d", "...")).columns.names()
 122
 123
 124 linkcolumn = Tests()
 125 linkcolumn.context(TransactionTestContext())
 126
 127 @linkcolumn.test
 128 def unicode():
 129     """Test LinkColumn"""
 130     # test unicode values + headings
 131     class UnicodeTable(tables.Table):
 132         first_name = tables.LinkColumn('person', args=[A('pk')])
 133         last_name = tables.LinkColumn('person', args=[A('pk')], verbose_name=u'äÚ¨´ˆÁ˜¨ˆ˜˘Ú…Ò˚ˆπ∆ˆ´')
 134
 135     dataset = [
 136         {'pk': 1, 'first_name': u'Brädley', 'last_name': u'∆yers'},
 137         {'pk': 2, 'first_name': u'Chr…s', 'last_name': u'DÒble'},
 138     ]
 139
 140     table = UnicodeTable(dataset)
 141     request = RequestFactory().get('/some-url/')
 142     template = Template('{% load django_tables2 %}{% render_table table %}')
 143     html = template.render(Context({'request': request, 'table': table}))
 144
 145     Assert(u'Brädley' in html)
 146     Assert(u'∆yers' in html)
 147     Assert(u'Chr…s' in html)
 148     Assert(u'DÒble' in html)
 149
 150     # Test handling queryset data with a null foreign key
 151
 152
 153 @linkcolumn.test
 154 def null_foreign_key():
 155     """
 156
 157     """
 158     class PersonTable(tables.Table):
 159         first_name = tables.Column()
 160         last_name = tables.Column()
 161         occupation = tables.LinkColumn('occupation', args=[A('occupation.pk')])
 162
 163     Person.objects.create(first_name='bradley', last_name='ayers')
 164
 165     table = PersonTable(Person.objects.all())
 166     table.as_html()
 167
 168
 169 columns = Tests([general, linkcolumn])