1 

     2 from django.conf import settings

     3 from django.contrib.contenttypes.models import ContentType

     4 from django.db import models

     5 from django.test import TestCase

     6 from django.contrib.auth.models import User

     7 from django.utils.translation import get_language

     8 from django.utils.translation import trans_real

     9 from django.utils.thread_support import currentThread

    10 

    11 from modeltranslation import translator

    12 

    13 class TestModel(models.Model):

    14     title = models.CharField(max_length=255)

    15     text = models.TextField(null=True)

    16 

    17 class TestTranslationOptions(translator.TranslationOptions):

    18     fields = ('title', 'text',)

    19 

    20 translator.translator.register(TestModel, TestTranslationOptions)

    21 

    22 class ModelTranslationTest(TestCase):    

    23     "Basic tests for the modeltranslation application."

    24     

    25     urls = 'modeltranslation.testurls'

    26     

    27     def setUp(self):        

    28         trans_real.activate("de")

    29                 

    30     def tearDown(self):

    31         trans_real.deactivate()

    32 

    33 

    34     def test_registration(self):

    35         self.client.post('/set_language/', data={'language': 'de'})

    36         #self.client.session['django_language'] = 'de-de'        

    37         #self.client.cookies[settings.LANGUAGE_COOKIE_NAME] = 'de-de'

    38                 

    39         langs = tuple(l[0] for l in settings.LANGUAGES)

    40         self.failUnlessEqual(2, len(langs))

    41         self.failUnless('de' in langs)

    42         self.failUnless('en' in langs)        

    43         self.failUnless(translator.translator)

    44 

    45         # Check that only one model is registered for translation

    46         self.failUnlessEqual(len(translator.translator._registry), 1)

    47                 

    48         # Try to unregister a model that is not registered

    49         self.assertRaises(translator.NotRegistered, translator.translator.unregister, User)

    50                         

    51         # Try to get options for a model that is not registered

    52         self.assertRaises(translator.NotRegistered, translator.translator.get_options_for_model, User)

    53                 

    54                             

    55     def test_translated_models(self):        

    56         # First create an instance of the test model to play with

    57         inst = TestModel.objects.create(title="Testtitle", text="Testtext")        

    58         field_names = dir(inst)

    59         self.failUnless('id' in field_names)

    60         self.failUnless('title' in field_names)

    61         self.failUnless('text' in field_names)

    62         self.failUnless('title_de' in field_names)   

    63         self.failUnless('title_en' in field_names)   

    64         self.failUnless('text_de' in field_names)   

    65         self.failUnless('text_en' in field_names)   

    66         

    67         inst.delete()

    68                                         

    69     def test_set_translation(self):

    70         self.failUnlessEqual(get_language(), "de")

    71         # First create an instance of the test model to play with

    72         title1_de = "title de"

    73         title1_en = "title en"

    74         title2_de = "title2 de"        

    75         inst1 = TestModel(title_en=title1_en, text="Testtext")

    76         inst1.title = title1_de

    77         inst2 = TestModel(title=title2_de, text="Testtext")        

    78         inst1.save()

    79         inst2.save()

    80         

    81         self.failUnlessEqual(inst1.title, title1_de)

    82         self.failUnlessEqual(inst1.title_en, title1_en)

    83         

    84         self.failUnlessEqual(inst2.title, title2_de)

    85         self.failUnlessEqual(inst2.title_en, None)        

    86         

    87         del inst1

    88         del inst2

    89         

    90         # Check that the translation fields are correctly saved and provide the

    91         # correct value when retrieving them again.

    92         n = TestModel.objects.get(title=title1_de)

    93         self.failUnlessEqual(n.title, title1_de)

    94         self.failUnlessEqual(n.title_en, title1_en)

    95         

    96     def test_titleonly(self):

    97         title1_de = "title de"

    98         n = TestModel.objects.create(title=title1_de)

    99         self.failUnlessEqual(n.title, title1_de)

   100         # Because the original field "title" was specified in the constructor 

   101         # it is directly passed into the instance's __dict__ and the descriptor 

   102         # which updates the associated default translation field is not called

   103         # and the default translation will be None.

   104         self.failUnlessEqual(n.title_de, None)

   105         self.failUnlessEqual(n.title_en, None)

   106         

   107         # Now assign the title, that triggers the descriptor and the default

   108         # translation field is updated

   109         n.title = title1_de

   110         self.failUnlessEqual(n.title, title1_de)

   111         self.failUnlessEqual(n.title_de, title1_de)

   112         self.failUnlessEqual(n.title_en, None)

   113         

   114     def test_rule1(self):                        

   115         """

   116         Rule 1: Reading the value from the original field returns the value in 

   117         translated to the current language.

   118         """

   119         title1_de = "title de"

   120         title1_en = "title en"

   121         text_de = "Dies ist ein deutscher Satz"

   122         text_en = "This is an english sentence"

   123         

   124         # Test 1.

   125         n = TestModel.objects.create(title_de=title1_de, title_en=title1_en,

   126                                      text_de=text_de, text_en=text_en)

   127         n.save()

   128         

   129         # language is set to "de" at this point

   130         self.failUnlessEqual(get_language(), "de")

   131         self.failUnlessEqual(n.title, title1_de)

   132         self.failUnlessEqual(n.title_de, title1_de)

   133         self.failUnlessEqual(n.title_en, title1_en)

   134         self.failUnlessEqual(n.text, text_de)

   135         self.failUnlessEqual(n.text_de, text_de)

   136         self.failUnlessEqual(n.text_en, text_en)

   137         # Now switch to "en"

   138         trans_real.activate("en")

   139         self.failUnlessEqual(get_language(), "en")

   140         # Title should now be return the english one (just by switching the

   141         # language)

   142         self.failUnlessEqual(n.title, title1_en)        

   143         self.failUnlessEqual(n.text, text_en)        

   144                 

   145         n = TestModel.objects.create(title_de=title1_de, title_en=title1_en,

   146                                      text_de=text_de, text_en=text_en)

   147         n.save()

   148         # language is set to "en" at this point

   149         self.failUnlessEqual(n.title, title1_en)

   150         self.failUnlessEqual(n.title_de, title1_de)

   151         self.failUnlessEqual(n.title_en, title1_en)

   152         self.failUnlessEqual(n.text, text_en)

   153         self.failUnlessEqual(n.text_de, text_de)

   154         self.failUnlessEqual(n.text_en, text_en)

   155         trans_real.activate("de")

   156         self.failUnlessEqual(get_language(), "de")

   157         self.failUnlessEqual(n.title, title1_de)

   158         self.failUnlessEqual(n.text, text_de)

   159         trans_real.deactivate()

   160                 

   161                 

   162     def test_rule2(self):                                            

   163         """

   164         Rule 2: Assigning a value to the original field also updates the value

   165         in the associated translation field of the default language

   166         """

   167         self.failUnlessEqual(get_language(), "de")

   168         title1_de = "title de"

   169         title1_en = "title en"

   170         n = TestModel.objects.create(title_de=title1_de, title_en=title1_en)                            

   171         self.failUnlessEqual(n.title, title1_de)

   172         self.failUnlessEqual(n.title_de, title1_de)

   173         self.failUnlessEqual(n.title_en, title1_en)

   174                     

   175         title2 =  "Neuer Titel"                   

   176         n.title = title2

   177         n.save()

   178         self.failUnlessEqual(n.title, title2)

   179         self.failUnlessEqual(n.title, n.title_de)

   180         

   181         trans_real.activate("en")

   182         self.failUnlessEqual(get_language(), "en")

   183         title3 = "new title"

   184         

   185         n.title = title3

   186         n.title_de = title1_de

   187         n.save()

   188         self.failUnlessEqual(n.title, title3)

   189         self.failUnlessEqual(n.title, n.title_en)

   190         self.failUnlessEqual(title1_de, n.title_de)

   191         

   192         trans_real.deactivate()                

   193                 

   194                 

   195     def test_rule3(self):

   196         """

   197         Rule 3: Assigning a value to a translation field of the default language

   198         also updates the original field - note that the value of the original 

   199         field will not be updated until the model instance is saved.

   200         """

   201         title1_de = "title de"

   202         title1_en = "title en"

   203         n = TestModel.objects.create(title_de=title1_de, title_en=title1_en)                            

   204         self.failUnlessEqual(get_language(), "de")

   205         self.failUnlessEqual(n.title, title1_de)

   206         self.failUnlessEqual(n.title_de, title1_de)

   207         self.failUnlessEqual(n.title_en, title1_en)

   208                     

   209         n.title_de = "Neuer Titel"

   210         n.save()

   211         self.failUnlessEqual(n.title, n.title_de)

   212         

   213         # Now switch to "en"

   214         trans_real.activate("en")

   215         self.failUnlessEqual(get_language(), "en")

   216         n.title_en = "New title"

   217         # the n.title field is not updated before the instance is saved

   218         n.save()

   219         self.failUnlessEqual(n.title, n.title_en)

   220         trans_real.deactivate()

   221                 

   222             

   223     def test_rule4(self):                                

   224         """

   225         Rule 4: If both fields - the original and the translation field of the 

   226         default language - are updated at the same time, the translation field 

   227         wins.

   228         """

   229         self.failUnlessEqual(get_language(), "de")

   230         title1_de = "title de"

   231         title1_en = "title en"

   232         n = TestModel.objects.create(title_de=title1_de, title_en=title1_en)                            

   233         self.failUnlessEqual(n.title, title1_de)

   234         self.failUnlessEqual(n.title_de, title1_de)

   235         self.failUnlessEqual(n.title_en, title1_en)

   236         

   237         title2_de = "neu de"

   238         title2_en = "new en"

   239         title_foo = "foo"

   240         n.title = title_foo

   241         n.title_de = title2_de

   242         n.title_en = title2_en

   243         n.save()

   244         self.failUnlessEqual(n.title, title2_de)

   245         self.failUnlessEqual(n.title_de, title2_de)

   246         self.failUnlessEqual(n.title_en, title2_en)

   247         

   248         n.title = title_foo

   249         n.save()

   250         self.failUnlessEqual(n.title, title_foo)

   251         self.failUnlessEqual(n.title_de, title_foo)

   252         self.failUnlessEqual(n.title_en, title2_en)

   253