def model_table(): """ The ``model`` option on a table causes the table to dynamically add columns based on the fields. """ class OccupationTable(tables.Table): class Meta: model = Occupation Assert(["id", "name", "region"]) == OccupationTable.base_columns.keys() class OccupationTable2(tables.Table): extra = tables.Column() class Meta: model = Occupation Assert(["id", "name", "region", "extra"]) == OccupationTable2.base_columns.keys() # be aware here, we already have *models* variable, but we're importing # over the top from django.db import models class ComplexModel(models.Model): char = models.CharField(max_length=200) fk = models.ForeignKey("self") m2m = models.ManyToManyField("self") class ComplexTable(tables.Table): class Meta: model = ComplexModel Assert(["id", "char", "fk"]) == ComplexTable.base_columns.keys()
def colon_notation(self): import brownie.itools module = import_string('brownie:itools') Assert(module).is_(brownie.itools) func = import_string('brownie.itools:chain') Assert(func).is_(brownie.itools.chain)
def writeline_flushed(self): self.set_writer(stream=FlushStream()) self.writer.writeline('foo') self.writer.writeline('foo', flush=True) Assert(self.stream.contents) == ['foo\n', True, 'foo\n', True] self.writer.writeline('foo', flush=False) Assert(self.stream.contents) == ['foo\n', True, 'foo\n', True, 'foo\n']
def sort(self): foo, bar = [3, 1, 2], [4, 6, 5] s = self.sequence_cls([foo, bar]) s.sort() Assert(s) == [1, 2, 3, 4, 5, 6] Assert(foo) == [1, 2, 3] Assert(bar) == [4, 5, 6]
def exhausted(self): l = LazyList(range(10)) Assert(l.exhausted) == True l = LazyList(self._genrange(10)) Assert(l.exhausted) == False l[-1] Assert(l.exhausted) == True
def getslice(self): s = self.sequence_cls([[0, 1, 2], [3, 4, 5]]) Assert(s[:]) == range(6) Assert(s[:3]) == s[:-3] == [0, 1, 2] Assert(s[3:]) == s[-3:] == [3, 4, 5] Assert(s[2:]) == [2, 3, 4, 5] Assert(s[-2:]) == [4, 5]
def delslice(self): foo, bar = [0, 1, 2], [3, 4, 5] s = self.sequence_cls([foo, bar]) del s[2:4] Assert(s) == [0, 1, 4, 5] Assert(foo) == [0, 1] Assert(bar) == [4, 5]
def difference(self): a = OrderedSet('abc') Assert(a.difference('abc')) == OrderedSet() Assert(a.difference('a', 'b', 'c')) == OrderedSet() Assert(a - OrderedSet('ab')) == OrderedSet('c') with Assert.raises(TypeError): a - 'abc'
def symmetric_difference_update(self): old = s = OrderedSet('abc') s ^= OrderedSet('def') Assert(s) == OrderedSet('abcdef') Assert(s).is_(old) with Assert.raises(TypeError): s ^= 'ghi'
def union(self): a = OrderedSet('abc') b = OrderedSet('def') Assert(a.union('def', 'ghi')) == OrderedSet('abcdefghi') Assert(a | b) == OrderedSet('abcdef') with Assert.raises(TypeError): a | 'abc'
def intersection_update(self): old = s = OrderedSet('abc') with Assert.raises(TypeError): s &= 'ab' s &= OrderedSet('ab') Assert(s) == OrderedSet('ab') Assert(s).is_(old)
def decorate(self): @LRUCache.decorate(2) def foo(*args, **kwargs): time.sleep(.1) return args, kwargs tests = [(('foo', 'bar'), {}), (('foo', 'bar'), { 'spam': 'eggs' }), ((1, 2), {})] times = [] for test in tests: args, kwargs = test old = time.time() Assert(foo(*args, **kwargs)) == test new = time.time() uncached_time = new - old old = time.time() Assert(foo(*args, **kwargs)) == test new = time.time() cached_time = new - old Assert(cached_time) < uncached_time times.append((uncached_time, cached_time)) old = time.time() foo(*tests[0][0], **tests[0][1]) new = time.time() Assert(new - old) > times[0][1]
def multiple_thread_contexts(self): csm = ThreadContextStackManager() def make_func(name): def func(csm, queue, event): csm.push_thread(name) queue.put(list(csm.iter_current_stack())) event.wait() func.__name__ = name return func foo_queue = Queue() bar_queue = Queue() foo_event = Event() bar_event = Event() foo_thread = Thread(target=make_func('foo'), args=(csm, foo_queue, foo_event)) bar_thread = Thread(target=make_func('bar'), args=(csm, bar_queue, bar_event)) foo_thread.start() # during that time foo should have pushed an object on # the thread local stack time.sleep(1) bar_thread.start() foo_event.set() bar_event.set() Assert(foo_queue.get()) == ['foo'] Assert(bar_queue.get()) == ['bar'] Assert(list(csm.iter_current_stack())) == []
def context_inheritance(self): class FooContextManager(ContextStackManagerEventletMixin, ContextStackManagerThreadMixin, ContextStackManagerBase): pass csm = FooContextManager() csm.push_application('foo') def foo(csm, queue): csm.push_thread('bar') queue.put(list(csm.iter_current_stack())) eventlet.spawn(bar, csm, queue).wait() queue.put(list(csm.iter_current_stack())) def bar(csm, queue): csm.push_coroutine('baz') queue.put(list(csm.iter_current_stack())) queue = Queue() thread = Thread(target=foo, args=(csm, queue)) thread.start() Assert(queue.get()) == ['bar', 'foo'] Assert(queue.get()) == ['baz', 'bar', 'foo'] Assert(queue.get()) == ['bar', 'foo'] Assert(list(csm.iter_current_stack())) == ['foo']
def delslice(self): data = range(10) l = LazyList(self._genrange(10)) del data[3:6] del l[3:6] Assert(l.exhausted) == False Assert(l) == data
def pop(self): s = OrderedSet() with Assert.raises(KeyError): s.pop() s = OrderedSet([1, 2, 3]) Assert(s.pop()) == 3 Assert(s.pop(last=False)) == 1
def inplace_multiply(self): old = a = LazyList(self._genrange(10)) b = range(10) a *= 5 b *= 5 Assert(a) == b Assert(a).is_(old)
def inplace_update(self): old = s = OrderedSet() with Assert.raises(TypeError): s |= 'abc' s |= OrderedSet('abc') Assert(s) == OrderedSet('abc') Assert(s).is_(old)
def index(self): s = self.sequence_cls([[1, 1, 2], [3, 1, 4]]) Assert(s.index(1)) == 0 Assert(s.index(1, 1)) == 1 Assert(s.index(1, 2)) == 4 with Assert.raises(ValueError): s.index(1, 2, 3)
def forms_simple(): str = forms.String()('kukuku') Assert(str.data) == 'kukuku' FT = forms.Tuple(forms.String(), forms.String()) ft = FT() widgets = [widget.render() for widget in ft.widgets()] Assert(widgets) == [ '<input id="form__0" name="form__0" parent="" value="">', '<input id="form__1" name="form__1" parent="" value="">' ] ft = FT(('kuku', 'kuku')) widgets = [widget.render() for widget in ft.widgets()] Assert(widgets) == [ '<input id="form__0" name="form__0" parent="" value="kuku">', '<input id="form__1" name="form__1" parent="" value="kuku">' ] FL = forms.List(forms.String()) fl = FL(['kuku', 'dsfasfd', 'xcvxczvx']) widgets = [widget.render() for widget in fl.widgets() if widget.render()] Assert(widgets) == [ '<input id="form__0" name="form__0" parent="" value="kuku">', '<input id="form__1" name="form__1" parent="" value="dsfasfd">', '<input id="form__2" name="form__2" parent="" value="xcvxczvx">' ]
def reverse(self): foo, bar = [1, 2, 3], [4, 5, 6] s = self.sequence_cls([foo, bar]) s.reverse() Assert(s) == [6, 5, 4, 3, 2, 1] Assert(foo) == [6, 5, 4] Assert(bar) == [3, 2, 1]
def simple_dict(): PD = procrustes.Dict({'a': I, 'b': S}) pd = PD({'a': None, 'b': 'Lorem Ipsum'}) Assert(pd.data) == {'a': None, 'b': 'Lorem Ipsum'} pd = PD({'b': 'Lorem Ipsum'}) Assert(pd.data) == {'a': None, 'b': 'Lorem Ipsum'}
def _replace(self): nt = namedtuple('foo', ['spam', 'eggs']) t = nt(1, 2) Assert(t._replace(spam=3)) == (3, 2) Assert(t._replace(eggs=4)) == (1, 4) with Assert.raises(ValueError): t._replace(foo=1)
def tuple_dict(): PT = procrustes.Tuple(I, S, I) PD = procrustes.Dict({'a': I, 'b': S, 'c': PT}) pd = PD({'b': 'kuku', 'c': (None, 'Lorem', 91)}) Assert(pd.data) == {'a': None, 'c': (None, 'Lorem', None), 'b': 'kuku'} pd = PD({'b': 'kuku', 'c': (None, 'Lorem', 90)}) Assert(pd.data) == {'a': None, 'c': (None, 'Lorem', 90), 'b': 'kuku'}
def unicode(): """Test LinkColumn""" # test unicode values + headings class UnicodeTable(tables.Table): first_name = tables.LinkColumn('person', args=[A('pk')]) last_name = tables.LinkColumn('person', args=[A('pk')], verbose_name=u'äÚ¨´ˆÁ˜¨ˆ˜˘Ú…Ò˚ˆπ∆ˆ´') dataset = [ { 'pk': 1, 'first_name': u'Brädley', 'last_name': u'∆yers' }, { 'pk': 2, 'first_name': u'Chr…s', 'last_name': u'DÒble' }, ] table = UnicodeTable(dataset) request = RequestFactory().get('/some-url/') template = Template('{% load django_tables2 %}{% render_table table %}') html = template.render(Context({'request': request, 'table': table})) Assert(u'Brädley' in html) Assert(u'∆yers' in html) Assert(u'Chr…s' in html) Assert(u'DÒble' in html)
def test_unique(): tests = [('aabbcc', 'abc'), ('aa', 'a'), (([1, 2], [1, 2], [3, 4], 5, 5, 5), ([1, 2], [3, 4], 5))] for test, result in tests: Assert(list(unique(test))) == list(result) Assert(list(unique('aaabbbbccc', seen='ab'))) == ['c']
def mixed_arbitary_arguments(self): func = curried(lambda a, b, c, *args, **kwargs: (a, b, c, args, kwargs)) Assert(func(1, 2, 3)) == (1, 2, 3, (), {}) Assert(func(1, 2, 3, 4, 5)) == (1, 2, 3, (4, 5), {}) Assert(func(1, 2, 3, foo=4)) == (1, 2, 3, (), dict(foo=4)) Assert(func(1, 2, 3, 4, foo=5)) == (1, 2, 3, (4, ), dict(foo=5))
def setitem(self): data = ['foo', 'bar', 'baz'] l = LazyList(iter(data)) l[0] = 'spam' Assert(l.exhausted) == False Assert(l[0]) == 'spam' Assert(l) != data
def table(self): content = [['foo', 'bar'], ['spam', 'eggs']] self.writer.table(content) self.writer.table(content, padding=2) self.writer.table(content, ['hello', 'wo\nrld']) Assert(self.stream.getvalue()) == textwrap.dedent("""\ foo | bar spam | eggs foo | bar spam | eggs hello | wo\\nrld ------+-------- foo | bar spam | eggs """) with Assert.raises(ValueError): self.writer.table([]) with Assert.raises(ValueError): self.writer.table([['foo', 'bar'], ['spam']]) with Assert.raises(ValueError): self.writer.table([['foo', 'bar']], ['spam']) self.set_writer(stream=FlushStream()) self.writer.table(content) Assert(len(self.stream.contents)) == 2 Assert.isinstance(self.stream.contents[0], basestring) Assert(self.stream.contents[1]) == True
def field_choices_used_to_translated_value(): """ When a model field uses the ``choices`` option, a table should render the "pretty" value rather than the database value. See issue #30 for details. """ LANGUAGES = ( ('en', 'English'), ('ru', 'Russian'), ) from django.db import models class Article(models.Model): name = models.CharField(max_length=200) language = models.CharField(max_length=200, choices=LANGUAGES) def __unicode__(self): return self.name class ArticleTable(tables.Table): class Meta: model = Article table = ArticleTable([ Article(name='English article', language='en'), Article(name='Russian article', language='ru') ]) Assert('English') == table.rows[0]['language'] Assert('Russian') == table.rows[1]['language']