view MoinMoin/_tests/ @ 51:54d5932d5a03

merge moin--main--1.3--patch-930: fix error handling in plugins, fix broken chart action Patches applied: * fix error handling in plugins, fix broken chart action * merge from main * fix error handling in plugins * merge from main * update changes with chart action fix imported from: moin--main--1.5--patch-52
author Nir Soffer <>
date Thu, 29 Sep 2005 00:36:27 +0000
parents 77665d8e2254
children 016a8a3ef354
line wrap: on
line source
# -*- coding: iso-8859-1 -*-
    MoinMoin - MoinMoin.util.pysupport Tests

    @copyright: 2004 by Jürgen Hermann <>
    @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,

    def testNonExistingAttribute(self):
        """ pysupport: import nonexistent attritbue raises AttributeError """
        self.assertRaises(AttributeError, pysupport.importName,

    def testExisting(self):
        """ pysupport: import name from existing module """
        from MoinMoin.parser import wiki
        Parser = pysupport.importName('', 'Parser')
        self.failUnless(Parser is 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.' +

    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: