Changeset 2068

Show
Ignore:
Timestamp:
06/25/09 13:17:49 (8 months ago)
Author:
JensDiemer
Message:
  • bugfix in pylucid_test_data.create_design()
  • add colorscheme arg in Design test
  • auto code cleanup
Location:
branches/0.9/pylucid_project/tests
Files:
2 modified

Legend:

Unmodified
Added
Removed
  • branches/0.9/pylucid_project/tests/test_Design.py

    r2043 r2068  
    2222    def __init__(self, *args, **kwargs): 
    2323        super(DesignTest, self).__init__(*args, **kwargs) 
    24          
     24 
    2525        self.test_css = EditableHtmlHeadFile.objects.get(filepath=pylucid_test_data.TEST_CSS_FILEPATH) 
    2626        self.test_js = EditableHtmlHeadFile.objects.get(filepath=pylucid_test_data.TEST_JS_FILEPATH) 
    2727 
    28     def _assert_headfiles(self, test_css_url, test_js_url): 
     28    def _assert_headfiles(self, colorscheme, test_css_url, test_js_url): 
    2929        """ Test get_absolute_url() and head links in reponse content """ 
    30         self.failUnlessEqual(self.test_css.get_absolute_url(), test_css_url) 
    31         self.failUnlessEqual(self.test_js.get_absolute_url(), test_js_url) 
    32              
     30        self.failUnlessEqual(self.test_css.get_absolute_url(colorscheme), test_css_url) 
     31        self.failUnlessEqual(self.test_js.get_absolute_url(colorscheme), test_js_url) 
     32 
    3333        # Test urls in the page content 
    3434        response = self.client.get("/") 
     
    3737                '1-rootpage content', # PageContent 
    3838                '<title>1-rootpage title', 
    39                  
     39 
    4040                # Design head file links: 
    4141                CSS_LINK % test_css_url, 
     
    4646            ), 
    4747        ) 
    48          
     48 
    4949    def test_cached(self): 
    5050        """ 
    5151        Test the stylesheet link, if the css file was cached into the filesystem. 
    52         """        
     52        """ 
     53        colorscheme = None 
     54 
    5355        # Create the cache file, if not exist 
    5456        for headfile in (self.test_css, self.test_js): 
    55             cachepath = headfile.get_cachepath() 
     57            cachepath = headfile.get_cachepath(colorscheme) 
    5658            if not os.path.isfile(cachepath): 
    57                 os.makedirs(os.path.dirname(cachepath)) # Cache dir doesn't exist? 
     59                cachedir = os.path.dirname(cachepath) 
     60                if not os.path.isdir(cachedir): 
     61                    os.makedirs() 
    5862                headfile.save() # The save method should create the cache file 
    5963            # Check if file exist 
    60             self.failUnless(os.path.isfile(cachepath), "Can't create cache file???") 
     64            self.failUnless(os.path.isfile(cachepath), "Cache file %r doesn't not exist?!?!" % cachepath) 
    6165 
    6266        # Test get_absolute_url() and head links in reponse content 
    63         self._assert_headfiles( 
     67        self._assert_headfiles(colorscheme, 
    6468            "/media/PyLucid/headfile_cache/unittest/test.css", 
    6569            "/media/PyLucid/headfile_cache/unittest/test.js" 
    66         )             
     70        ) 
    6771 
    6872 
     
    7175        Test the stylesheet link, if the css file was *not* cached into the filesystem. 
    7276        """ 
     77        colorscheme = None 
     78 
    7379        # remove style cache file, if exist 
    7480        for headfile in (self.test_css, self.test_js): 
    75             cachepath = headfile.get_cachepath() 
     81            cachepath = headfile.get_cachepath(colorscheme) 
    7682            if os.path.isfile(cachepath): 
    7783                os.remove(cachepath) 
     
    7985 
    8086        # Test get_absolute_url() and head links in reponse content 
    81         self._assert_headfiles( 
     87        self._assert_headfiles(colorscheme, 
    8288            "/headfile/unittest/test.css", 
    8389            "/headfile/unittest/test.js" 
  • branches/0.9/pylucid_project/tests/test_tools/pylucid_test_data.py

    r2040 r2068  
    3333        self.verbosity = verbosity 
    3434        self.index = 1 
    35          
     35 
    3636    def __iter__(self): 
    3737        return self 
    38      
     38 
    3939    def next(self): 
    4040        try: 
     
    4848            id=self.index, defaults={"name": site_name, "domain": domain} 
    4949        ) 
    50         if self.verbosity>=2: 
     50        if self.verbosity >= 2: 
    5151            if created: 
    5252                print("sites entry '%s' created." % site) 
     
    5555 
    5656            print "Activate site: %r (ID:%s)" % (site, site.pk) 
    57              
     57 
    5858        settings.SITE_ID = site.pk 
    5959        Site.objects.clear_cache() 
    60          
     60 
    6161        current_site = Site.objects.get_current() 
    6262        assert current_site == site 
    63      
     63 
    6464        return site 
    65          
     65 
    6666 
    6767class TestLanguages(object): 
     
    7272        self.verbosity = verbosity 
    7373        self.index = 0 
    74          
     74 
    7575    def __iter__(self): 
    7676        return self 
    77      
     77 
    7878    def next(self): 
    7979        try: 
     
    8181        except IndexError: 
    8282            raise StopIteration 
    83          
     83 
    8484        self.index += 1 
    85          
     85 
    8686        language, created = Language.objects.get_or_create( 
    8787            code=lang_code, defaults={"description": description} 
    8888        ) 
    89         if self.verbosity>=2: 
     89        if self.verbosity >= 2: 
    9090            if created: 
    9191                print("Language '%s' created." % lang_code) 
     
    123123    "site_template/normal.html": { 
    124124        "content": \ 
    125 """<html><head><title>{{ page_title }} """+SITEINFO_TAG+"""</title> 
     125"""<html><head><title>{{ page_title }} """ + SITEINFO_TAG + """</title> 
    126126<meta name="robots" content="{{ robots }}" /> 
    127127<meta name="keywords" content="{{ page_keywords }}" /> 
     
    158158    TEST_CSS_FILEPATH: { 
    159159        "description": "CSS file for unittests.", 
    160         "content": ".test1 { color:red; } /* "+SITEINFO_TAG+" */", 
     160        "content": ".test1 { color: #ff0000; } /* " + SITEINFO_TAG + " */", 
    161161    }, 
    162162    TEST_JS_FILEPATH: { 
     
    168168    "unittest_design": { 
    169169        "template_name": "site_template/normal.html", 
    170         "headfiles": (TEST_CSS_FILEPATH,TEST_JS_FILEPATH), 
     170        "headfiles": (TEST_CSS_FILEPATH, TEST_JS_FILEPATH), 
    171171    }, 
    172172} 
     
    216216        user.is_superuser = is_superuser 
    217217        user.save() 
    218         if verbosity>=2: 
     218        if verbosity >= 2: 
    219219            print "Test user %r created." % user 
    220220        return user 
    221          
     221 
    222222    for usertype, userdata in TEST_USERS.iteritems(): 
    223223        user = create_user(verbosity, **userdata) 
     
    229229    for template_name, data in template_dict.iteritems(): 
    230230        template, created = Template.objects.get_or_create( 
    231             name = template_name, defaults = data 
     231            name=template_name, defaults=data 
    232232        ) 
    233233        if created: 
    234234            template.content = template.content.replace(SITEINFO_TAG, site.name) 
    235235            template.save() 
    236             if verbosity>=2: 
     236            if verbosity >= 2: 
    237237                print("template '%s' created" % template_name) 
    238         elif verbosity>=2: 
     238        elif verbosity >= 2: 
    239239                print("template '%s' exist" % template_name) 
    240                  
    241         if verbosity>=2: 
     240 
     241        if verbosity >= 2: 
    242242            print("add template on site: %s" % site.name) 
    243243        template.sites.add(site) 
    244                  
     244 
    245245        template_map[template_name] = template 
    246246    return template_map 
     
    251251    for filepath, data in headfile_dict.iteritems(): 
    252252        headfile = EditableHtmlHeadFile( 
    253             filepath = filepath, 
    254             description = data["description"], 
    255             content = data["content"], 
     253            filepath=filepath, 
     254            description=data["description"], 
     255            content=data["content"], 
    256256        ) 
    257257        headfile.save() 
    258258        headfile.site.add(site) 
    259         if verbosity>=2: 
     259        if verbosity >= 2: 
    260260            print("EditableStaticFile '%s' created on site: %s" % (filepath, site.name)) 
    261          
    262         headfile_map[filepath+site.name] = headfile 
     261 
     262        headfile_map[filepath + site.name] = headfile 
    263263    return headfile_map 
    264264 
    265265 
    266 def create_design(verbosity, design_dict, site, template_map, headfile_map):    
     266def create_design(verbosity, design_dict, site, template_map, headfile_map): 
    267267    design_map = {} 
    268268    for design_name, data in design_dict.iteritems(): 
     
    270270        assert template_name in template_map 
    271271        design, created = Design.objects.get_or_create( 
    272             name = design_name, defaults = {"template": template_name,} 
    273         ) 
    274         if created: 
    275             design.save() 
    276             design.site.add(site) 
    277             if verbosity>=2: 
    278                 print("design '%s' created." % design_name) 
    279             # Add headfiles 
    280             for filename in data["headfiles"]: 
    281                 headfile = headfile_map[filename+site.name] 
    282                 design.headfiles.add(headfile) 
    283                 if verbosity>=2: 
    284                     print("Add headfile '%s'." % headfile) 
    285             design.save() 
    286         elif verbosity>=2: 
     272            name=design_name, defaults={"template": template_name, } 
     273        ) 
     274        design.site.add(site) 
     275        if verbosity >= 2: 
     276            if created: 
     277                print("Design '%s' created." % design_name) 
     278            else: 
    287279                print("Design '%s' exist." % design_name) 
    288          
     280 
     281        # Add headfiles 
     282        for filename in data["headfiles"]: 
     283            headfile = headfile_map[filename + site.name] 
     284            design.headfiles.add(headfile) 
     285            if verbosity >= 2: 
     286                print("Add headfile '%s'." % headfile) 
     287        design.save() 
     288 
    289289        design_map[design_name] = design 
    290290    return design_map 
     
    303303    for page_data in pages: 
    304304        slug = page_data["slug"] 
    305          
     305 
    306306        #____________________________________________________ 
    307307        if "plugin" in page_data: 
     
    309309        else: 
    310310            page_type = PageTree.PAGE_TYPE 
    311          
     311 
    312312        tree_entry, created = PageTree.objects.get_or_create( 
    313313            site=site, slug=slug, parent=parent, 
     
    318318        ) 
    319319        url = tree_entry.get_absolute_url() 
    320         if verbosity>=2: 
     320        if verbosity >= 2: 
    321321            if created: 
    322322                #tree_entry.save() 
     
    324324            else: 
    325325                print("PageTree '%s' exist." % url) 
    326          
     326 
    327327        # Create PageMeta, PageContent for the PageTree entry in all test languages 
    328328        for language in TestLanguages(): 
    329329            # Create PageMeta: 
    330330            default_dict = create_meta(slug=tree_entry.slug, lang_code=language.code, site_name=site.name, 
    331                 keys = ("title", "description", "keywords") 
     331                keys=("title", "description", "keywords") 
    332332            ) 
    333333            pagemeta_entry, created = PageMeta.objects.get_or_create( 
    334                 page = tree_entry, lang = language, 
    335                 defaults = default_dict 
     334                page=tree_entry, lang=language, 
     335                defaults=default_dict 
    336336            ) 
    337             if verbosity>=2: 
     337            if verbosity >= 2: 
    338338                if created: 
    339339                    #pagemeta_entry.save() 
     
    345345                # It's a plugin page 
    346346                pluginpage, created = PluginPage.objects.get_or_create( 
    347                     page = tree_entry, 
    348                     lang = language, 
    349                     defaults = {"pagemeta": pagemeta_entry, "app_label": page_data["plugin"]}, 
     347                    page=tree_entry, 
     348                    lang=language, 
     349                    defaults={"pagemeta": pagemeta_entry, "app_label": page_data["plugin"]}, 
    350350                ) 
    351                 if verbosity>=2: 
     351                if verbosity >= 2: 
    352352                    if created: 
    353353                        print("PluginPage '%s' created." % pluginpage) 
     
    357357                # Create PageContent: 
    358358                default_dict = create_meta(slug=tree_entry.slug, lang_code=language.code, site_name=site.name, 
    359                     keys = ("content",) 
     359                    keys=("content",) 
    360360                ) 
    361361                default_dict["markup"] = PageContent.MARKUP_CREOLE 
    362362                content_entry, created = PageContent.objects.get_or_create( 
    363                     page = tree_entry, 
    364                     lang = language, 
    365                     pagemeta = pagemeta_entry, 
    366                     defaults = default_dict 
     363                    page=tree_entry, 
     364                    lang=language, 
     365                    pagemeta=pagemeta_entry, 
     366                    defaults=default_dict 
    367367                ) 
    368368                content_entry.content = content_entry.content.replace(SITEINFO_TAG, site.name) 
    369369                content_entry.save() 
    370                 if verbosity>=2: 
     370                if verbosity >= 2: 
    371371                    if created: 
    372372                        print("PageContent '%s' created." % content_entry) 
    373373                    else: 
    374374                        print("PageContent '%s' exist." % content_entry) 
    375          
     375 
    376376        if "sub-pages" in page_data: 
    377             if verbosity>=2: 
     377            if verbosity >= 2: 
    378378                print "--- create sub pages ---" 
    379379            create_pages(verbosity, design_map, site, 
    380380                pages=page_data["sub-pages"], parent=tree_entry 
    381381            ) 
    382             if verbosity>=2: 
     382            if verbosity >= 2: 
    383383                print "---" 
    384384 
     
    391391    headfile_map = create_headfiles(verbosity, TEST_HEADFILES, site) 
    392392    design_map = create_design(verbosity, TEST_DESIGNS, site, template_map, headfile_map) 
    393      
     393 
    394394    # Create PageTree, PageMeta and PageContent in every test language 
    395395    create_pages(verbosity, design_map, site, pages=TEST_PAGES) 
    396      
    397      
     396 
     397 
    398398#def get_fake_request(usertype): 
    399399#    """ Create a fake HttpRequest instance. Needed in some UpdateInfoBaseModel save() methods """ 
     
    405405def create_pylucid_test_data(site=None, verbosity=True): 
    406406    """ create complete test data for "running" PyLucid """ 
    407     if verbosity>=2: 
     407    if verbosity >= 2: 
    408408        print "\nCreate complete test data for 'running' PyLucid" 
    409                
     409 
    410410    create_testusers(verbosity) 
    411      
     411 
    412412#    request = get_fake_request(usertype="superuser") 
    413      
     413 
    414414    for site in TestSites(verbosity): 
    415415        if verbosity: 
    416416            print("------------------------------------") 
    417417            print("create test data for site: %r" % site) 
    418              
     418 
    419419        create_test_data(site, verbosity) 
    420420 
     
    426426if __name__ == "__main__": 
    427427    from django.db import connection 
    428      
     428 
    429429    db_name = connection.creation.create_test_db(verbosity=True, autoclobber=False) 
    430430    print "\nTest database '%s' created" % db_name 
    431     create_pylucid_test_data() 
     431    create_pylucid_test_data(verbosity=2)