Django

Code

Changeset 3661

Show
Ignore:
Timestamp:
08/27/06 08:59:47 (2 years ago)
Author:
russellm
Message:

Refs #2333 - Modified runtests script to use new testing framework. Migrated existing tests to use Django testing framework. All the 'othertests' have been migrated into 'regressiontests', and converted into doctests/unittests, as appropriate.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/trunk/tests/modeltests/basic/models.py

    r3217 r3661  
    1414        return self.headline 
    1515 
    16 API_TESTS = """ 
    17  
     16__test__ = {'API_TESTS': """ 
    1817# No articles are in the system yet. 
    1918>>> Article.objects.all() 
    …… 
    315314[<Article: Article 6>, <Article: Default headline>, <Article: Article 7>, <Article: Updated article 8>] 
    316315 
    317 """ 
     316"""} 
    318317 
    319318from django.conf import settings 
    …… 
    322321 
    323322if building_docs or settings.DATABASE_ENGINE == 'postgresql': 
    324     API_TESTS += """ 
     323    __test__['API_TESTS'] += """ 
    325324# In PostgreSQL, microsecond-level precision is available. 
    326325>>> a9 = Article(headline='Article 9', pub_date=datetime(2005, 7, 31, 12, 30, 45, 180)) 
    …… 
    331330 
    332331if building_docs or settings.DATABASE_ENGINE == 'mysql': 
    333     API_TESTS += """ 
     332    __test__['API_TESTS'] += """ 
    334333# In MySQL, microsecond-level precision isn't available. You'll lose 
    335334# microsecond-level precision once the data is saved. 
    …… 
    340339""" 
    341340 
    342 API_TESTS += """ 
     341__test__['API_TESTS'] += """ 
    343342 
    344343# You can manually specify the primary key when creating a new object. 

  • django/trunk/tests/modeltests/choices/models.py

    r3075 r3661  
    2424        return self.name 
    2525 
    26 API_TESTS = """ 
     26__test__ = {'API_TESTS':""" 
    2727>>> a = Person(name='Adrian', gender='M') 
    2828>>> a.save() 
    …… 
    3737>>> s.get_gender_display() 
    3838'Female' 
    39 """ 
     39"""} 

  • django/trunk/tests/modeltests/custom_columns/models.py

    r3075 r3661  
    1616        return '%s %s' % (self.first_name, self.last_name) 
    1717 
    18 API_TESTS = """ 
     18__test__ = {'API_TESTS':""" 
    1919# Create a Person. 
    2020>>> p = Person(first_name='John', last_name='Smith') 
    …… 
    5151    ... 
    5252AttributeError: 'Person' object has no attribute 'last' 
    53 """ 
     53"""} 

  • django/trunk/tests/modeltests/custom_managers/models.py

    r3075 r3661  
    5959        return self.name 
    6060 
    61 API_TESTS = """ 
     61__test__ = {'API_TESTS':""" 
    6262>>> p1 = Person(first_name='Bugs', last_name='Bunny', fun=True) 
    6363>>> p1.save() 
    …… 
    105105>>> Car._default_manager.order_by('name') 
    106106[<Car: Corvette>, <Car: Neon>] 
    107 """ 
     107"""} 

  • django/trunk/tests/modeltests/custom_methods/models.py

    r3075 r3661  
    3737        return [self.__class__(*row) for row in cursor.fetchall()] 
    3838 
    39 API_TESTS = """ 
     39__test__ = {'API_TESTS':""" 
    4040# Create a couple of Articles. 
    4141>>> from datetime import date 
    …… 
    5656>>> b.articles_from_same_day_2() 
    5757[<Article: Area man programs in Python>] 
    58 """ 
     58"""} 

  • django/trunk/tests/modeltests/custom_pk/models.py

    r3130 r3661  
    2828        return self.name 
    2929 
    30 API_TESTS = """ 
     30__test__ = {'API_TESTS':""" 
    3131>>> dan = Employee(employee_code='ABC123', first_name='Dan', last_name='Jones') 
    3232>>> dan.save() 
    …… 
    8989[<Business: Sears>] 
    9090 
    91 """ 
     91"""} 

  • django/trunk/tests/modeltests/empty/models.py

    r3548 r3661  
    1111    pass 
    1212 
    13 API_TESTS = """ 
     13__test__ = {'API_TESTS':""" 
    1414>>> m = Empty() 
    1515>>> m.id 
    …… 
    2424>>> existing.save() 
    2525 
    26 """ 
     26"""} 

  • django/trunk/tests/modeltests/field_defaults/models.py

    r3031 r3661  
    2020        return self.headline 
    2121 
    22 API_TESTS = """ 
     22__test__ = {'API_TESTS':""" 
    2323>>> from datetime import datetime 
    2424 
    …… 
    4949>>> d.seconds < 5 
    5050True 
    51 """ 
     51"""} 

  • django/trunk/tests/modeltests/generic_relations/models.py

    r3160 r3661  
    5454        return self.name 
    5555         
    56 API_TESTS = """ 
     56__test__ = {'API_TESTS':""" 
    5757# Create the world in 7 lines of code... 
    5858>>> lion = Animal(common_name="Lion", latin_name="Panthera leo") 
    …… 
    106106>>> TaggedItem.objects.filter(content_type__pk=ctype.id, object_id=quartz.id) 
    107107[<TaggedItem: clearish>] 
    108 """ 
     108"""} 

  • django/trunk/tests/modeltests/get_latest/models.py

    r3075 r3661  
    3030        return self.name 
    3131 
    32 API_TESTS = """ 
     32__test__ = {'API_TESTS':""" 
    3333# Because no Articles exist yet, get_latest() raises ArticleDoesNotExist. 
    3434>>> Article.objects.latest() 
    …… 
    7777>>> Person.objects.latest('birthday') 
    7878<Person: Stephanie> 
    79 """ 
     79"""} 

  • django/trunk/tests/modeltests/get_or_create/models.py

    r3092 r3661  
    1616        return '%s %s' % (self.first_name, self.last_name) 
    1717 
    18 API_TESTS = """ 
     18__test__ = {'API_TESTS':""" 
    1919# Acting as a divine being, create an Person. 
    2020>>> from datetime import date 
    …… 
    5050>>> Person.objects.count() 
    51512 
    52 """ 
     52"""} 

  • django/trunk/tests/modeltests/invalid_models/models.py

    r3215 r3661  
    7979 
    8080 
    81 error_log = """invalid_models.fielderrors: "charfield": CharFields require a "maxlength" attribute. 
     81model_errors = """invalid_models.fielderrors: "charfield": CharFields require a "maxlength" attribute. 
    8282invalid_models.fielderrors: "floatfield": FloatFields require a "decimal_places" attribute. 
    8383invalid_models.fielderrors: "floatfield": FloatFields require a "max_digits" attribute. 

  • django/trunk/tests/modeltests/lookup/models.py

    r3552 r3661  
    1616        return self.headline 
    1717 
    18 API_TESTS = r""" 
     18__test__ = {'API_TESTS':r""" 
    1919# Create a couple of Articles. 
    2020>>> from datetime import datetime 
    …… 
    192192[<Article: Article with \ backslash>] 
    193193 
    194 """ 
     194"""} 

  • django/trunk/tests/modeltests/m2m_and_m2o/models.py

    r3321 r3661  
    2222 
    2323 
    24 API_TESTS = """ 
     24__test__ = {'API_TESTS':""" 
    2525>>> Issue.objects.all() 
    2626[] 
    …… 
    6363>>> Issue.objects.filter(Q(client=r.id) | Q(cc__id__exact=r.id)) 
    6464[<Issue: 1>, <Issue: 2>, <Issue: 3>] 
    65 """ 
     65"""} 

  • django/trunk/tests/modeltests/m2m_intermediary/models.py

    r3075 r3661  
    3535        return '%s (%s)' % (self.reporter, self.position) 
    3636 
    37 API_TESTS = """ 
     37__test__ = {'API_TESTS':""" 
    3838# Create a few Reporters. 
    3939>>> r1 = Reporter(first_name='John', last_name='Smith') 
    …… 
    6666>>> r1.writer_set.all() 
    6767[<Writer: John Smith (Main writer)>] 
    68 """ 
     68"""} 

  • django/trunk/tests/modeltests/m2m_multiple/models.py

    r3075 r3661  
    2929        return self.headline 
    3030 
    31 API_TESTS = """ 
     31__test__ = {'API_TESTS':""" 
    3232>>> from datetime import datetime 
    3333 
    …… 
    7777>>> c4.secondary_article_set.all() 
    7878[<Article: Area man steals>, <Article: Area man runs>] 
    79 """ 
     79"""} 

  • django/trunk/tests/modeltests/m2m_recursive/models.py

    r3215 r3661  
    2323        return self.name 
    2424 
    25 API_TESTS = """ 
     25__test__ = {'API_TESTS':""" 
    2626>>> a = Person(name='Anne') 
    2727>>> a.save() 
    …… 
    190190[<Person: Chuck>] 
    191191 
    192 """ 
     192"""} 

  • django/trunk/tests/modeltests/m2o_recursive2/models.py

    r3075 r3661  
    1818        return self.full_name 
    1919 
    20 API_TESTS = """ 
     20__test__ = {'API_TESTS':""" 
    2121# Create two Person objects -- the mom and dad in our family. 
    2222>>> dad = Person(full_name='John Smith Senior', mother=None, father=None) 
    …… 
    4141>>> kid.fathers_child_set.all() 
    4242[] 
    43 """ 
     43"""} 

  • django/trunk/tests/modeltests/m2o_recursive/models.py

    r3075 r3661  
    2020        return self.name 
    2121 
    22 API_TESTS = """ 
     22__test__ = {'API_TESTS':""" 
    2323# Create a few Category objects. 
    2424>>> r = Category(id=None, name='Root category', parent=None) 
    …… 
    3838>>> c.parent 
    3939<Category: Root category> 
    40 """ 
     40"""} 

  • django/trunk/tests/modeltests/manipulators/models.py

    r3075 r3661  
    2222        return self.name 
    2323 
    24 API_TESTS = """ 
     24__test__ = {'API_TESTS':""" 
    2525>>> from django.utils.datastructures import MultiValueDict 
    2626 
    …… 
    8989>>> a2.release_date 
    9090datetime.date(2005, 2, 13) 
    91 """ 
     91"""} 

  • django/trunk/tests/modeltests/many_to_many/models.py

    r3246 r3661  
    2929        ordering = ('headline',) 
    3030 
    31 API_TESTS = """ 
     31__test__ = {'API_TESTS':""" 
    3232# Create a couple of Publications. 
    3333>>> p1 = Publication(id=None, title='The Python Journal') 
    …… 
    232232[<Article: NASA uses Python>] 
    233233 
    234 """ 
     234"""} 

  • django/trunk/tests/modeltests/many_to_one/models.py

    r3248 r3661  
    2626        ordering = ('headline',) 
    2727 
    28 API_TESTS = """ 
     28__test__ = {'API_TESTS':""" 
    2929# Create a few Reporters. 
    3030>>> r = Reporter(first_name='John', last_name='Smith', email='john@example.com') 
    …… 
    264264[] 
    265265 
    266 """ 
     266"""} 

  • django/trunk/tests/modeltests/many_to_one_null/models.py

    r3075 r3661  
    2424        return self.headline 
    2525 
    26 API_TESTS = """ 
     26__test__ = {'API_TESTS':""" 
    2727# Create a Reporter. 
    2828>>> r = Reporter(name='John Smith') 
    …… 
    122122[<Article: First>, <Article: Fourth>] 
    123123 
    124 """ 
     124"""} 

  • django/trunk/tests/modeltests/model_inheritance/models.py

    r3075 r3661  
    2727        return "%s the italian restaurant" % self.name 
    2828 
    29 API_TESTS = """ 
     29__test__ = {'API_TESTS':""" 
    3030# Make sure Restaurant has the right fields in the right order. 
    3131>>> [f.name for f in Restaurant._meta.fields] 
    …… 
    5151 
    5252 
    53 """ 
     53"""} 

  • django/trunk/tests/modeltests/mutually_referential/models.py

    r2809 r3661  
    1515    parent = ForeignKey(Parent) 
    1616 
    17 API_TESTS = """ 
     17__test__ = {'API_TESTS':""" 
    1818# Create a Parent 
    1919>>> q = Parent(name='Elizabeth') 
    …… 
    3030>>> q.delete() 
    3131 
    32 """ 
     32"""} 

  • django/trunk/tests/modeltests/one_to_one/models.py

    r3246 r3661  
    3131        return "%s the waiter at %s" % (self.name, self.restaurant) 
    3232 
    33 API_TESTS = """ 
     33__test__ = {'API_TESTS':""" 
    3434# Create a couple of Places. 
    3535>>> p1 = Place(name='Demon Dogs', address='944 W. Fullerton') 
    …… 
    152152>>> r = Restaurant.objects.get(pk=1) 
    153153>>> r.delete() 
    154 """ 
     154"""} 

  • django/trunk/tests/modeltests/ordering/models.py

    r3075 r3661  
    2525        return self.headline 
    2626 
    27 API_TESTS = """ 
     27__test__ = {'API_TESTS':""" 
    2828# Create a couple of Articles. 
    2929>>> from datetime import datetime 
    …… 
    6565>>> Article.objects.order_by('?') 
    6666[...] 
    67 """ 
     67"""} 

  • django/trunk/tests/modeltests/or_lookups/models.py

    r3075 r3661  
    2424        return self.headline 
    2525 
    26 API_TESTS = """ 
     26__test__ = {'API_TESTS':""" 
    2727>>> from datetime import datetime 
    2828>>> from django.db.models import Q 
    …… 
    102102>>> Article.objects.complex_filter(Q(pk=1) | Q(pk=2)) 
    103103[<Article: Hello>, <Article: Goodbye>] 
    104 """ 
     104"""} 

  • django/trunk/tests/modeltests/pagination/models.py

    r3075 r3661  
    1616        return self.headline 
    1717 
    18 API_TESTS = """ 
     18__test__ = {'API_TESTS':""" 
    1919# prepare a list of objects for pagination 
    2020>>> from datetime import datetime 
    …… 
    65659 
    6666 
    67 """ 
     67"""} 

  • django/trunk/tests/modeltests/properties/models.py

    r3145 r3661  
    2121    full_name_2 = property(_get_full_name, _set_full_name) 
    2222 
    23 API_TESTS = """ 
     23__test__ = {'API_TESTS':""" 
    2424>>> a = Person(first_name='John', last_name='Lennon') 
    2525>>> a.save() 
    …… 
    3838>>> a2.first_name 
    3939'Paul' 
    40 """ 
     40"""} 

  • django/trunk/tests/modeltests/reserved_names/models.py

    r3075 r3661  
    2525        return self.when 
    2626 
    27 API_TESTS = """ 
     27__test__ = {'API_TESTS':""" 
    2828>>> import datetime 
    2929>>> day1 = datetime.date(2005, 1, 1) 
    …… 
    5454>>> Thing.objects.filter(where__month=1) 
    5555[<Thing: a>] 
    56 """ 
     56"""} 

  • django/trunk/tests/modeltests/reverse_lookup/models.py

    r3075 r3661  
    2828        return self.name 
    2929 
    30 API_TESTS = """ 
     30__test__ = {'API_TESTS':""" 
    3131>>> john = User(name="John Doe") 
    3232>>> john.save() 
    …… 
    5757    ... 
    5858TypeError: Cannot resolve keyword 'choice' into field 
    59 """ 
     59"""} 

  • django/trunk/tests/modeltests/save_delete_hooks/models.py

    r3075 r3661  
    2525        print "After deletion" 
    2626 
    27 API_TESTS = """ 
     27__test__ = {'API_TESTS':""" 
    2828>>> p1 = Person(first_name='John', last_name='Smith') 
    2929>>> p1.save() 
    …… 
    4040>>> Person.objects.all() 
    4141[] 
    42 """ 
     42"""} 

  • django/trunk/tests/modeltests/serializers/models.py

    r3237 r3661  
    3838        return self.headline 
    3939 
    40 API_TESTS = """ 
     40__test__ = {'API_TESTS':""" 
    4141# Create some data: 
    4242>>> from datetime import datetime 
    …… 
    119119[<Article: Just kidding; I love TV poker>, <Article: Time to reform copyright>] 
    120120 
    121 """ 
     121"""} 

  • django/trunk/tests/modeltests/str/models.py

    r3072 r3661  
    1818        return self.headline 
    1919 
    20 API_TESTS = """ 
     20__test__ = {'API_TESTS':""" 
    2121# Create an Article. 
    2222>>> from datetime import datetime 
    …… 
    2929>>> a 
    3030<Article: Area man programs in Python> 
    31 """ 
     31"""} 

  • django/trunk/tests/modeltests/transactions/models.py

    r3075 r3661  
    1818        return "%s %s" % (self.first_name, self.last_name) 
    1919 
    20 API_TESTS = """ 
     20__test__ = {'API_TESTS':""" 
    2121>>> from django.db import connection, transaction 
    22 """ 
     22"""} 
    2323 
    2424from django.conf import settings 
    …… 
    2727 
    2828if building_docs or settings.DATABASE_ENGINE != 'mysql': 
    29     API_TESTS += """ 
     29    __test__['API_TESTS'] += """ 
    3030# the default behavior is to autocommit after each save() action 
    3131>>> def create_a_reporter_then_fail(first, last): 

  • django/trunk/tests/modeltests/validation/models.py

    r3075 r3661  
    2121        return self.name 
    2222 
    23 API_TESTS = """ 
     23__test__ = {'API_TESTS':""" 
    2424 
    2525>>> import datetime 
    …… 
    147147{'email': ['Enter a valid e-mail address.']} 
    148148 
    149 """ 
     149"""} 

  • django/trunk/tests/regressiontests/cache/tests.py

    r2687 r3661  
    33 
    44from django.core.cache import cache 
    5 import time 
     5import time, unittest 
    66 
    77# functions/classes for complex data type tests         
    …… 
    1212        return 24 
    1313 
    14 # simple set/get 
    15 cache.set("key", "value") 
    16 assert cache.get("key") == "value" 
     14class Cache(unittest.TestCase): 
     15    def test_simple(self): 
     16        # simple set/get 
     17        cache.set("key", "value") 
     18        self.assertEqual(cache.get("key"), "value") 
    1719 
    18 # get with non-existent keys 
    19 assert cache.get("does not exist") is None 
    20 assert cache.get("does not exist", "bang!") == "bang!" 
     20    def test_non_existent(self): 
     21        # get with non-existent keys 
     22        self.assertEqual(cache.get("does not exist"), None) 
     23        self.assertEqual(cache.get("does not exist", "bang!"), "bang!") 
    2124 
    22 # get_many 
    23 cache.set('a', 'a') 
    24 cache.set('b', 'b') 
    25 cache.set('c', 'c') 
    26 cache.set('d', 'd') 
    27 assert cache.get_many(['a', 'c', 'd']) == {'a' : 'a', 'c' : 'c', 'd' : 'd'} 
    28 assert cache.get_many(['a', 'b', 'e']) == {'a' : 'a', 'b' : 'b'} 
     25    def test_get_many(self): 
     26        # get_many 
     27        cache.set('a', 'a') 
     28        cache.set('b', 'b') 
     29        cache.set('c', 'c') 
     30        cache.set('d', 'd') 
     31        self.assertEqual(cache.get_many(['a', 'c', 'd']), {'a' : 'a', 'c' : 'c', 'd' : 'd'}) 
     32        self.assertEqual(cache.get_many(['a', 'b', 'e']), {'a' : 'a', 'b' : 'b'}) 
    2933 
    30 # delete 
    31 cache.set("key1", "spam") 
    32 cache.set("key2", "eggs") 
    33 assert cache.get("key1") == "spam" 
    34 cache.delete("key1") 
    35 assert cache.get("key1") is None 
    36 assert cache.get("key2") == "eggs" 
     34    def test_delete(self): 
     35        # delete 
     36        cache.set("key1", "spam") 
     37        cache.set("key2", "eggs") 
     38        self.assertEqual(cache.get("key1"), "spam") 
     39        cache.delete("key1") 
     40        self.assertEqual(cache.get("key1"), None) 
     41        self.assertEqual(cache.get("key2"), "eggs") 
    3742 
    38 # has_key 
    39 cache.set("hello", "goodbye") 
    40 assert cache.has_key("hello") == True 
    41 assert cache.has_key("goodbye") == False 
     43    def test_has_key(self): 
     44        # has_key 
     45        cache.set("hello", "goodbye") 
     46        self.assertEqual(cache.has_key("hello"), True) 
     47        self.assertEqual(cache.has_key("goodbye"), False) 
    4248 
    43 # test data types 
    44 stuff = { 
    45     'string'    : 'this is a string', 
    46     'int'       : 42, 
    47     'list'      : [1, 2, 3, 4], 
    48     'tuple'     : (1, 2, 3, 4), 
    49     'dict'      : {'A': 1, 'B' : 2}, 
    50     'function'  : f, 
    51     'class'     : C, 
    52 } 
    53 for (key, value) in stuff.items(): 
    54     cache.set(key, value) 
    55     assert cache.get(key) == value 
     49    def test_data_types(self): 
     50        # test data types 
     51        stuff = { 
     52            'string'    : 'this is a string', 
     53            'int'       : 42, 
     54            'list'      : [1, 2, 3, 4], 
     55            'tuple'     : (1, 2, 3, 4), 
     56            'dict'      : {'A': 1, 'B' : 2}, 
     57            'function'  : f, 
     58            'class'     : C, 
     59        } 
     60        for (key, value) in stuff.items(): 
     61            cache.set(key, value) 
     62            self.assertEqual(cache.get(key), value) 
    5663     
    57 # expiration 
    58 cache.set('expire', 'very quickly', 1) 
    59 time.sleep(2) 
    60 assert cache.get("expire") == None 
     64    def test_expiration(self): 
     65        # expiration 
     66        cache.set('expire', 'very quickly', 1) 
     67        time.sleep(2) 
     68        self.assertEqual(cache.get("expire"), None) 
     69 
     70if __name__ == '__main__': 
     71    unittest.main() 

  • django/trunk/tests/regressiontests/db_typecasts/tests.py

    r2809 r3661  
    22 
    33from django.db.backends import util as typecasts 
    4 import datetime 
     4import datetime, unittest 
    55 
    66TEST_CASES = { 
    …… 
    4646} 
    4747 
    48 for k, v in TEST_CASES.items(): 
    49     for inpt, expected in v: 
    50         got = getattr(typecasts, k)(inpt) 
    51         assert got == expected, "In %s: %r doesn't match %r. Got %r instead." % (k, inpt, expected, got) 
     48class DBTypeCasts(unittest.TestCase): 
     49    def test_typeCasts(self): 
     50        for k, v in TEST_CASES.items(): 
     51            for inpt, expected in v: 
     52                got = getattr(typecasts, k)(inpt) 
     53                assert got == expected, "In %s: %r doesn't match %r. Got %r instead." % (k, inpt, expected, got) 
     54 
     55if __name__ == '__main__': 
     56    unittest.main()