view MoinMoin/_tests/ @ 1973:4495ff257334

minor CHANGES changes
author Thomas Waldmann <tw AT waldmann-edv DOT de>
date Mon, 09 Apr 2007 01:47:48 +0200
parents bb2e053067fb
children 1339d6fdc4ff
line wrap: on
line source
# -*- coding: iso-8859-1 -*-
    MoinMoin - MoinMoin.util.pysupport Tests

    @copyright: 2004 Oliver Graf <>
    @license: GNU GPL, see COPYING for details.

import unittest, os, errno
from MoinMoin.util import pysupport
from MoinMoin._tests import TestSkiped

class ImportNameFromMoinTestCase(unittest.TestCase):
    """ Test importName of MoinMoin modules

    We don't make any testing for files, assuming that moin package is
    not broken.

    def testNonExistingModule(self):
        """ pysupport: import nonexistent module raises ImportError """
        self.assertRaises(ImportError, pysupport.importName,
                          'MoinMoin.parser.abcdefghijkl', 'Parser')

    def testNonExistingAttribute(self):
        """ pysupport: import nonexistent attritbue raises AttributeError """
        self.assertRaises(AttributeError, pysupport.importName,
                          'MoinMoin.parser.text_moin_wiki', 'NoSuchParser')

    def testExisting(self):
        """ pysupport: import name from existing module """
        from MoinMoin.parser import text_moin_wiki
        Parser = pysupport.importName('MoinMoin.parser.text_moin_wiki', 'Parser')
        self.failUnless(Parser is text_moin_wiki.Parser)

class ImportNameFromPlugin(unittest.TestCase):
    """ Base class for import plugin tests """

    name = 'Parser'

    def setUp(self):
        """ Check for valid plugin package """
        self.pluginDirectory = os.path.join(self.request.cfg.data_dir, 'plugin', 'parser')
        self.pluginModule = (self.request.cfg.siteid + '.plugin.parser.' + self.plugin)

    def checkPackage(self, path):
        for item in (path, os.path.join(path, '')):
            if not os.path.exists(item):
                raise TestSkiped("Missing or wrong permissions: %s" % item)

    def pluginExists(self):
        return (os.path.exists(self.pluginFilePath('.py')) or

    def pluginFilePath(self, suffix):
        return os.path.join(self.pluginDirectory, self.plugin + suffix)

class ImportNonExisiting(ImportNameFromPlugin):

    plugin = 'NonExistingWikiPlugin'

    def testNonEsisting(self):
        """ pysupport: import nonexistent wiki plugin fail """
        if self.pluginExists():
            raise TestSkiped('plugin exists: %s' % self.plugin)
        self.assertRaises(ImportError, pysupport.importName,

class ImportExisting(ImportNameFromPlugin):

    plugin = 'AutoCreatedMoinMoinTestPlugin'
    shouldDeleteTestPlugin = True

    def testExisting(self):
        """ pysupport: import existing wiki plugin
        Tests if a module can be imported from an arbitrary path
        like it is done in moin for plugins. Some strange bug
        in the old implementation failed on an import of os,
        cause os does a from os.path import that will stumble
        over a poisoned sys.modules.
            plugin = pysupport.importName(self.pluginModule,
            self.assertEqual(getattr(plugin, '__name__', None),,
                            'Failed to import the test plugin')

    def createTestPlugin(self):
        """ Create test plugin, skiping if plugin exists """
        if self.pluginExists():
            self.shouldDeleteTestPlugin = False
            raise TestSkiped("Won't overwrite exiting plugin: %s" %
        data = '''
# If you find this file in your wiki plugin directory, you can safely
# delete it.
import sys, os

class Parser:
            file(self.pluginFilePath('.py'), 'w').write(data)
        except Exception, err:
            raise TestSkiped("Can't create test plugin: %s" % str(err))

    def deleteTestPlugin(self):
        """ Delete plugin files ignoring missing files errors """
        if not self.shouldDeleteTestPlugin:
        for suffix in ('.py', '.pyc'):
            except OSError, err:
                if err.errno != errno.ENOENT: