Changeset 1612

Timestamp:

05/31/08 22:01:20 (13 months ago)

Author:

JensDiemer

Message:

• add a few test for the new plugin models
  
• unittest: test plugin would be copied to the normal plugins. So this plugin would be auto installed with all other plugins.
  
• Bugfix in lucidTag.py: 1 should not be converted to True ;)
  

Location:

trunk

Files:

• dev_scripts/local_tests/models_test.py (modified) (7 diffs)
• pylucid/PyLucid/models/Plugin.py (modified) (6 diffs)
• pylucid/PyLucid/system/plugin_manager.py (modified) (5 diffs)
• pylucid/PyLucid/template_addons/lucidTag.py (modified) (1 diff)
• pylucid/tests/test_plugin_api.py (modified) (6 diffs)
• pylucid/tests/unittest_plugin/unittest_plugin.py (modified) (6 diffs)
• pylucid/tests/unittest_plugin/unittest_plugin_cfg.py (modified) (1 diff)
• pylucid/tests/__init__.py (modified) (6 diffs)

trunk/dev_scripts/local_tests/models_test.py

@@ -19 +19 @@
 from django.contrib.auth.models import User
 
+# Use the models from the test plugin
+from tests.unittest_plugin.unittest_plugin import TestArtist, TestAlbum
 
 
-class Musician(models.Model):
-    first_name = models.CharField(max_length=50)
-    last_name = models.CharField(max_length=50)
-    instrument = models.CharField(max_length=100)
-    class Meta:
-        # db_table is optional
-#        db_table = 'PyLucid_test'
-        app_label = 'PyLucid' # must be set to "PyLucid"
+print "-----------------------------------------------------------------------"
 
-class Album(models.Model):
-    artist = models.ForeignKey("Musician")
-    name = models.CharField(max_length=100)
-    num_stars = models.IntegerField()
-
-    createtime = models.DateTimeField(auto_now_add=True)
-    lastupdatetime = models.DateTimeField(auto_now=True)
-
-    createby = models.ForeignKey(User, related_name="test_createby",
-        null=True, blank=True
-    )
-    lastupdateby = models.ForeignKey(User, related_name="test_lastupdateby",
-        null=True, blank=True
-    )
-    class Meta:
-        # db_table is optional
-#        db_table = 'PyLucid_test'
-        app_label = 'PyLucid' # must be set to "PyLucid"
+print "XXX"
+print TestAlbum._meta.app_label
+#t = TestAlbum._meta
+#for i in dir(t):
+#    print i, getattr(t, i)
 
 
-print "------------------------------------------------------------------------------------------------------"
+print "-----------------------------------------------------------------------"
 try:
     # Here the table doesn't exist
-    m = Musician(first_name = "foo", last_name = "bar", instrument = "foobar")
+    m = TestArtist(name = "foobar")
     m.save()
 except Exception, err:
     print err
 
-print "------------------------------------------------------------------------------------------------------"
+print "-----------------------------------------------------------------------"
 
 def get_create_table(models):
@@ -72 +54 @@
     return statements
 
-statements = get_create_table(models = (Musician, Album))
+def get_create_table2(*plugin_models):
+    from django.conf import settings
+    from django.core.management.color import no_style
+    style = no_style()
+    from django.core.management import sql
+    from django.db import models
+
+    models.loading.register_models("PyLucidPlugins", *plugin_models)
+
+    # get all delete statements for the given App
+    app = models.get_app("PyLucidPlugins")
+    statements = sql.sql_create(app, style)
+
+    #cleanup
+    app_models = models.loading.cache.app_models
+    del(app_models["PyLucidPlugins"])
+#    settings.INSTALLED_APPS = old_inst_apps
+
+    return statements
+
+statements = get_create_table(models = (TestArtist, TestAlbum))
+#statements = get_create_table2(TestArtist, TestAlbum)
 
 from django.db import connection
@@ -80 +83 @@
     cursor.execute(statement)
 
-print "------------------------------------------------------------------------------------------------------"
+print "-----------------------------------------------------------------------"
 
 # Now we can use the created tables
-m = Musician(first_name = "foo", last_name = "bar", instrument = "foobar")
+m = TestArtist(name = "foobar")
 m.save()
-a = Album(
+a = TestAlbum(
     artist = m,
     name = "jup",
@@ -91 +94 @@
 )
 a.save()
-print Album.objects.all().values()
+print TestAlbum.objects.all().values()
 
-print "------------------------------------------------------------------------------------------------------"
+print "-----------------------------------------------------------------------"
 
 # Not needed to "insert" the models:
 #from PyLucid.system.PyLucidPlugins import models as PluginModels
-#PluginModels.Musician = Musician
-#PluginModels.Album = Album
+#PluginModels.TestArtist = TestArtist
+#PluginModels.TestAlbum = TestAlbum
 
 def get_delete_sql(*plugin_models):
@@ -107 +110 @@
     from django.db import models
 
-    # Insert app in installed apps
-    old_inst_apps = settings.INSTALLED_APPS
-    inst_apps = list(old_inst_apps)
-    inst_apps.append("PyLucid.system.PyLucidPlugins")
-    settings.INSTALLED_APPS = inst_apps
+#    # Insert app in installed apps
+#    old_inst_apps = settings.INSTALLED_APPS
+#    inst_apps = list(old_inst_apps)
+#    inst_apps.append("PyLucid.system.PyLucidPlugins")
+#    settings.INSTALLED_APPS = inst_apps
 
     models.loading.register_models("PyLucidPlugins", *plugin_models)
@@ -122 +125 @@
     app_models = models.loading.cache.app_models
     del(app_models["PyLucidPlugins"])
-    settings.INSTALLED_APPS = old_inst_apps
+#    settings.INSTALLED_APPS = old_inst_apps
 
     return statements
 
-statements = get_delete_sql(Musician)
+statements = get_delete_sql(TestArtist)
 print "1:", statements
 
-statements = get_delete_sql(Musician, Album)
+statements = get_delete_sql(TestArtist, TestAlbum)
 print "2:", statements
 
@@ -139 +142 @@
 
 # After this no tables left:
-statements = get_delete_sql(Musician, Album)
+statements = get_delete_sql(TestArtist, TestAlbum)
 print statements
 
-statements = get_delete_sql(Album)
+statements = get_delete_sql(TestAlbum)
 print statements
 
-print "------------------------------------------------------------------------------------------------------"
+print "-----------------------------------------------------------------------"
 
 # No tables error:
 try:
-    m = Musician(first_name = "foo", last_name = "bar", instrument = "foobar")
+    m = TestArtist(name = "foobar")
     m.save()
 except Exception, err:

trunk/pylucid/PyLucid/models/Plugin.py

@@ -19 +19 @@
 from pprint import pformat
 
+from django.conf import settings
+
 from django.db import models, transaction, connection
 from django.core.cache import cache
@@ -32 +34 @@
 preference_cache = {}
 
+PLUGIN_MODEL_LABEL = "PyLucidPlugins"
+PLUGIN_MODEL_APP = "PyLucid.system.PyLucidPlugins"
+
+
+def get_plugin_models(package_name, plugin_name, debug=False):
+    """
+    returns a list of all existing plugin models.
+    If no models exist, returns None!
+
+    Seperated function, because must be accessible from manager- and plugin
+    class, too.
+    """
+    plugin_module = get_plugin_module(package_name, plugin_name, debug)
+    if not hasattr(plugin_module, "PLUGIN_MODELS"):
+        # Plugin has no models
+        return None
+
+    if not PLUGIN_MODEL_APP in settings.INSTALLED_APPS:
+        from django.core.exceptions import ImproperlyConfigured
+        raise ImproperlyConfigured(
+            "Error '%s' not in settings.INSTALLED_APPS!" % PLUGIN_MODEL_APP
+        )
+
+    plugin_models = plugin_module.PLUGIN_MODELS
+
+    # Check app_label for every plugin model
+    for model in plugin_models:
+        app_label = model._meta.app_label
+        assert app_label == PLUGIN_MODEL_LABEL, (
+            "Plugin models must defined in class Meta: app_label = '%s'"
+        ) % PLUGIN_MODEL_LABEL
+
+    return plugin_models
+
+
+
+
+
 class PluginManager(models.Manager):
     """
@@ -51 +91 @@
         plugin = self.get(plugin_name = plugin_name)
         return plugin.get_preferences()
+
+    def get_plugin_models(self, package_name, plugin_name, debug=False):
+        """ returns a list of all existing plugin models or None """
+        return get_plugin_models(package_name, plugin_name, debug)
+
 
 
@@ -152 +197 @@
         return get_plugin_version(self.package_name, self.plugin_name, debug)
 
+    def get_plugin_models(self, debug=False):
+        """ returns a list of all existing plugin models or None """
+        return get_plugin_models(self.package_name, self.plugin_name, debug)
+
     #___________________________________________________________________________
     # SAVE
@@ -173 +222 @@
 
     def get_delete_sql(self, plugin_models):
-#        from django.conf import settings
+        """
+        Returns a list of sql statements for deleting the plugin model tabels.
+        For this, we used the fake django app "PyLucidPlugins" and attach
+        all models to this add temporarly.
+        """
+        from django.core.management import sql
         from django.core.management.color import no_style
         style = no_style()
-        from django.core.management import sql
 
         models.loading.register_models("PyLucidPlugins", *plugin_models)
 
-        # get all delete statements for the given App
         app = models.get_app("PyLucidPlugins")
+
         statements = sql.sql_delete(app, style)
 
-        print sql.table_list()
-
-        #cleanup
+        # cleanup
         app_models = models.loading.cache.app_models
         del(app_models["PyLucidPlugins"])
-    #    settings.INSTALLED_APPS = old_inst_apps
 
         return statements
 
-    def get_delete_tables(self):
-        plugin_module = get_plugin_module(
-            self.package_name,
-            self.plugin_name,
-            debug=True,
-        )
-        if not hasattr(plugin_module, "PLUGIN_MODELS"):
+    def _delete_tables(self):
+        """
+        Delete all plugin model tabels.
+        """
+        plugin_models = self.get_plugin_models()
+        if not plugin_models:
             # Plugin has no models
             return
 
-        plugin_models = plugin_module.PLUGIN_MODELS
-
         statements = self.get_delete_sql(plugin_models)
 
         cursor = connection.cursor()
         for statement in statements:
-            print repr(statement)
+            #print repr(statement)
             cursor.execute(statement)
 
@@ -215 +262 @@
     @transaction.commit_on_success
     def delete(self):
-        self.get_delete_tables()
+        self._delete_tables()
 
         super(Plugin, self).delete()

trunk/pylucid/PyLucid/system/plugin_manager.py

@@ -30 +30 @@
 from django.db.models import Model
 from django.core.management.sql import sql_model_create, \
-                                                        sql_indexes_for_model, custom_sql_for_model
+                                    sql_indexes_for_model, custom_sql_for_model
 from django.http import HttpResponse, Http404
 
@@ -36 +36 @@
 from PyLucid.system.exceptions import *
 from PyLucid.system.plugin_import import get_plugin_module, \
-                                                                        get_plugin_config, get_plugin_version
-
-
+                                        get_plugin_config, get_plugin_version
 
 
@@ -53 +51 @@
         )
         request.page_msg(msg)
-        msg2 = '<i title="(Error details in page messages.)">["%s.%s" error.]</i>' % (
-            plugin_name, method_name
-        )
+        msg2 = (
+            '<i title="(Error details in page messages.)">["%s.%s" error.]</i>'
+        ) % (plugin_name, method_name)
         local_response.write(msg2)
 
@@ -198 +196 @@
 
 
-def get_create_table(models):
+def get_create_table(plugin_models):
     from django.core.management.color import no_style
     style = no_style()
 
     statements = []
-    for model in models:
+    for model in plugin_models:
         statements += sql_model_create(model, style)[0]
         statements += sql_indexes_for_model(model, style)
@@ -210 +208 @@
 
 
-
 def create_plugin_tables(plugin, extra_verbose):
-    plugin_module = get_plugin_module(
+    plugin_models = Plugin.objects.get_plugin_models(
         plugin.package_name,
         plugin.plugin_name,
         debug=extra_verbose,
     )
-    if not hasattr(plugin_module, "PLUGIN_MODELS"):
+    if not plugin_models:
         # Plugin has no models
-        if extra_verbose:
-            print "Info: No 'plugin_models' list defined, ok."
         return
-
-    plugin_models = plugin_module.PLUGIN_MODELS
 
     statements = get_create_table(plugin_models)
     cursor = connection.cursor()
     for statement in statements:
-        print repr(statement)
+        #print repr(statement)
         cursor.execute(statement)
 

trunk/pylucid/PyLucid/template_addons/lucidTag.py

@@ -116 +116 @@
             # method Keywords must be Strings
             key = key.encode(settings.DEFAULT_CHARSET)
-            if value in ("True", "true", "on", "ON", "1"):
+            value_lower = value.lower()
+            if value_lower in ("true", "on"):
                 value = True
-            elif value in ("False", "false", "off", "OFF", "0"):
+            elif value_lower in ("false", "off"):
                 value = False
             method_kwargs[key] = value

trunk/pylucid/tests/test_plugin_api.py

@@ -13 +13 @@
 """
 
+import os, re
+
 import tests
 
@@ -18 +20 @@
 
 from PyLucid.models import Page, Plugin
+from PyLucid.system.plugin_manager import install_plugin
 
 
 TEST_PLUGIN_NAME = "unittest_plugin"
-CONTENT_START = (
-    '<div class="PyLucidPlugins unittest_plugin"'
-)
-CONTENT_END = "</div>"
-
-
-class PluginAPI_TestCase(tests.TestCase):
+CONTENT_START = "<pre>"
+CONTENT_END = "</pre>"
+CONTENT_RE = re.compile("<pre>(.*?)<\/pre>(?usm)")
+
+MODEL_TEST = """<pre>
+Test the plugin models
+Create TestArtist
+entry with ID '%(no)s' created
+Create TestAlbum
+entry with ID '%(no)s' created:
+TestAlbum 'A test Album', ID %(no)s, createby: superuser
+</pre>"""
+
+
+
+
+class PluginAPI_Base(tests.TestCase):
     """
     Unit tests for detect_page function.
     """
-#    def tearDown(self):
-
-
-    def _init(self):
-        print "init"
-        try:
-            self.plugin = Plugin.objects.get(plugin_name=TEST_PLUGIN_NAME)
-        except Plugin.DoesNotExist, err:
-            from PyLucid.system.plugin_manager import install_plugin
-            self.plugin = install_plugin(
-                package_name = "PyLucid.plugins_external",
-                plugin_name = "unittest_plugin",
-                debug = True,
-                active=True,
-                extra_verbose=True,
-            )
-        else:
-            print "Plugin exists ID:", self.plugin.id
-            
-    def _delete(self):
-        print "delete"
-        try:
-            self.plugin.delete()
-        except Exception, err:
-            print "tearDown Error:", err
-
-    def setUp(self):       
+    def setUp(self):
         Page.objects.all().delete() # Delete all existins pages
 
@@ -80 +67 @@
         self.test_url = self.test_page.get_absolute_url()
 
+    #___________________________________________________________________________
+    # SHARED UTILS
+
     def _get_plugin_content(self, url, debug=False):
         """
         request the url and returns the plugin content output
         """
-        print "22222222"
         response = self.client.get(url)
         # Check that the respose is 200 Ok.
@@ -95 +84 @@
             print "-"*79
 
-        lines = raw_content.splitlines()
-        in_content = False
-        result = ""
-        for line in lines:
-            if line.startswith(CONTENT_START):
-                in_content = True
-                continue
-            elif in_content:
-                if line == CONTENT_END:
-                    return result
-                else:
-                    result += line
+        content = CONTENT_RE.findall(raw_content)
+        if len(content) == 1:
+            return content[0].strip()
 
         msg = (
@@ -116 +96 @@
         self.fail(msg)
 
-    def test_init_plugin(self):
-        """
-        First we must install the plugin
-        """
-        print "XXXXXXXXX"
+    def _get_plugin(self):
+        return Plugin.objects.get(plugin_name=TEST_PLUGIN_NAME)
+
+    #___________________________________________________________________________
+    # PRETESTS
+
+    def test_plugin_exist(self):
+        """
+        Test if the unittest plugin is normal installed and active
+        """
+        try:
+            self.plugin = self._get_plugin()
+        except Plugin.DoesNotExist, err:
+            self.fail("Plugin doesn't exist: %s" % err)
+
+        self.failUnless(self.plugin.active, True)
+        #print "Plugin exists ID:", self.plugin.id
+
+    def test_hello_world(self):
+        """
+        Checks via _command url the hello world response
+        """
+        url = self.command % "hello_world"
+        response = self.client.get(url)
+        # Check that the respose is 200 Ok.
+        self.failUnlessEqual(response.status_code, 200)
+        self.assertEqual2(
+            response.content.strip(),
+            (
+                '<div class="PyLucidPlugins unittest_plugin"'
+                ' id="unittest_plugin_hello_world">\n'
+                'Hello world!\n'
+                '</div>'
+            )
+        )
+
+
+class PluginModel(PluginAPI_Base):
+    """
+    Tests around the plugin models.
+    """
+    def test_plugin_models(self):
+        """
+        Test the plugin models.
+        Request three times the plugin_models view. This view creates on
+        every request a new model entry in both test models and display
+        some informations around this.
+        After this, we request a view with a list of all existing model entries.
+        """
+        self.login("superuser") # login client as superuser
+
         url = self.command % "plugin_models"
-        content = self._get_plugin_content(url)
-
-
-    def test_first_check(self):
-        """
-        Check if the test plugin exist and is active
-        """
-#        self._init()
-        try:
-            plugin = Plugin.objects.get(plugin_name=TEST_PLUGIN_NAME)
-        except Plugin.DoesNotExist, err:
-            self.fail("test plugin doesn't exist in the database: %s" % err)
-
-        self.failUnless(plugin.active, True)
+
+        content = self._get_plugin_content(url)#, debug=True)
+        self.assertEqual2(
+            content,
+            MODEL_TEST % {"no": 1}
+        )
+
+        content = self._get_plugin_content(url)#, debug=True)
+        self.assertEqual2(
+            content,
+            MODEL_TEST % {"no": 2}
+        )
+
+        content = self._get_plugin_content(url)#, debug=True)
+        self.assertEqual2(
+            content,
+            MODEL_TEST % {"no": 3}
+        )
+
+        # Test all models view: A list of all existing models.
+        url = self.command % "all_models"
+        content = self._get_plugin_content(url)#, debug=True)
+        self.assertEqual2(
+            content,
+            (
+                "<pre>\n"
+                "All Albums:\n"
+                "1: TestAlbum 'A test Album', ID 1, createby: superuser\n"
+                "2: TestAlbum 'A test Album', ID 2, createby: superuser\n"
+                "3: TestAlbum 'A test Album', ID 3, createby: superuser\n"
+                "</pre>"
+            )
+        )
+
+    def test_reinit(self):
+        """
+        reinit the plugin and check if the plugin model tabels would be
+        droped and re-created.
+        """
+        plugin = self._get_plugin()
         
-#        self._delete()
-
-    def test_hello_world(self):
-        """
-        Checks via _command url the hello world response
-        """
-        url = self.command % "hello_world"
-        content = self._get_plugin_content(url)
-        self.assertEqual(content, "Hello world!")
-
+        package_name = plugin.package_name
+        plugin_name = plugin.plugin_name
+        
+        # remove the plugin completely from the database
+        # plugin model tables should be droped
+        plugin.delete()
+        
+        # install the plugin
+        # plugin model tables should be re-created, too. 
+        install_plugin(package_name, plugin_name, debug=True, active=True,
+                                                        extra_verbose=True)
+
+        # Check 1:
+        content = self._get_plugin_content(url)#, debug=True)
+        self.assertEqual2(
+            content,
+            MODEL_TEST % {"no": 1}
+        )
+
+        # Check 2:
+        url = self.command % "all_models"
+        content = self._get_plugin_content(url)#, debug=True)
+        self.assertEqual2(
+            content,
+            (
+                "<pre>\n"
+                "All Albums:\n"
+                "1: TestAlbum 'A test Album', ID 1, createby: superuser\n"
+                "</pre>"
+            )
+        )
+
+
+class PluginModel(PluginAPI_Base):
+    """
+    pass parameters to the plugin method.
+    """
     def test_lucidTag(self):
         content = self._get_plugin_content(self.test_url)
-        self.assertEqual(content, "args: (), kwargs: {}")
+        self.assertEqual2(content, "args:\n()\npformarted kwargs:\n{}")
 
     def test_plugin_args1(self):
         """
-        Test arguments in a _command url
-        """
-        content = self._get_plugin_content(self.test_url, debug=False)
-        self.assertEqual(
-            content, "args: (), kwargs: {}"
-        )
-
-        self.test_page.content = '{% lucidTag unittest_plugin arg1="test1" %}'
-        self.test_page.save()
-        content = self._get_plugin_content(self.test_url, debug=False)
-        self.assertEqual(
-            content, "args: (), kwargs: {'arg1': u'test1'}"
-        )
-
-        self.test_page.content = '{% lucidTag unittest_plugin arg1=True %}'
-        self.test_page.save()
-        content = self._get_plugin_content(self.test_url, debug=True)
-        self.assertEqual(
-            content, "args: (), kwargs: {'arg1': True}"
+        Test arguments in the lucidTag
+        Handled in PyLucid.template_addons.lucidTag
+        """
+        def get_args_info(page_content):
+            self.test_page.content = page_content
+            self.test_page.save()
+            content = self._get_plugin_content(self.test_url, debug=False)
+            args_info = content.split("\n")
+            return (args_info[1], args_info[3])
+
+
+        args, kwargs = get_args_info('{% lucidTag unittest_plugin %}')
+        self.assertEqual2(args, "()")
+        self.assertEqual2(kwargs, "{}")
+
+
+        args, kwargs = get_args_info(
+            '{% lucidTag unittest_plugin arg1="test1" %}'
+        )
+        self.assertEqual2(args, "()")
+        self.assertEqual2(kwargs, "{'arg1': u'test1'}")
+
+
+        args, kwargs = get_args_info(
+            '{% lucidTag unittest_plugin a="0" b="1" c="2" %}'
+        )
+        self.assertEqual2(args, "()")
+        self.assertEqual2(kwargs, "{'a': u'0', 'b': u'1', 'c': u'2'}")
+
+
+        args, kwargs = get_args_info(
+            '{% lucidTag unittest_plugin'
+            ' t1="True" f1="False" t2="true" f2="false" %}'
+        )
+        self.assertEqual2(args, "()")
+        self.assertEqual2(kwargs, 
+            "{'f1': False, 'f2': False, 't1': True, 't2': True}"
         )
 
@@ -181 +278 @@
         url += "some/stuff/here/1/2/3/"
         content = self._get_plugin_content(url, debug=False)
-        self.assertEqual(
-            content, "args: (u'some/stuff/here/1/2/3/',), kwargs: {}"
+        self.assertEqual2(
+            content,
+            "args:\n"
+            "(u'some/stuff/here/1/2/3/',)\n"
+            "pformarted kwargs:\n"
+            "{}"
         )
 

trunk/pylucid/tests/unittest_plugin/unittest_plugin.py

@@ -17 +17 @@
 """
 
+from pprint import pformat
+
 from PyLucid.system.BasePlugin import PyLucidBasePlugin
 
@@ -34 +36 @@
         # db_table is optional
 #        db_table = 'PyLucid_test'
-#        app_label = 'PyLucidPlugins'
-        app_label = 'PyLucid'
+        app_label = 'PyLucidPlugins'
+#        app_label = 'PyLucid'
 
 class TestAlbum(models.Model):
@@ -46 +48 @@
 
     createby = models.ForeignKey(User, related_name="test_createby",
-        null=True, blank=True
-    )
-    lastupdateby = models.ForeignKey(User, related_name="test_lastupdateby",
         null=True, blank=True
     )
@@ -54 +53 @@
         # db_table is optional
 #        db_table = 'PyLucid_test'
-#        app_label = 'PyLucidPlugins'
-        app_label = 'PyLucid'
+        app_label = 'PyLucidPlugins'
+#        app_label = 'PyLucid'
 
     def __unicode__(self):
-        return u"TestAlbum '%s', ID %s" % (self.name, self.id)
+        return u"TestAlbum '%s', ID %s, createby: %s" % (
+            self.name, self.id, self.createby
+        )
 
 PLUGIN_MODELS = (TestArtist, TestAlbum)
@@ -72 +73 @@
         PyLucid.template_addons.lucidTag
         """
-        self.response.write("args: %r, kwargs: %r" % (args, kwargs))
+        self.response.write("<pre>\n")
+        self.response.write("args:\n")
+        self.response.write("%s\n" % pformat(args))
+        self.response.write("pformarted kwargs:\n")
+        self.response.write("%s\n" % pformat(kwargs))
+        self.response.write("</pre>")
 
     def hello_world(self):
@@ -90 +96 @@
         self.response.write("Test the plugin models\n")
         self.response.write("Create TestArtist\n")
-        artist1 = TestArtist(name="A test Artist\n")
-        artist1.save()
-        self.response.write("entry with ID '%s' created\n" % artist1.id)
+        artist = TestArtist(name="A test Artist\n")
+        artist.save()
+        self.response.write("entry with ID '%s' created\n" % artist.id)
         self.response.write("Create TestAlbum\n")
-        album1 = TestAlbum(
-            artist = artist1,
+        album = TestAlbum(
+            artist = artist,
             name = "A test Album",
             num_stars = 10,
+            createby = self.request.user
         )
-        album1.save()
-        self.response.write("entry with ID '%s' created\n" % album1.id)
+        album.save()
+        self.response.write("entry with ID '%s' created:\n" % album.id)
+        self.response.write(u"%s\n" % album)
+        self.response.write("</pre>")
+
+    def all_models(self):
+        """
+        Display all existing models
+        """
+        self.response.write("<pre>\n")
         self.response.write("All Albums:\n")
         albums = TestAlbum.objects.all()
         for album in albums:
             self.response.write(u"%s: %s\n" % (album.id, album))
+
+        self.response.write("</pre>")
 
 

trunk/pylucid/tests/unittest_plugin/unittest_plugin_cfg.py

@@ -65 +65 @@
         },
     },
+    "all_models": {
+        "must_login": True,
+        "must_admin": True,
+        "admin_sub_menu": {
+            "section"       : _("unittest"), # The sub menu section
+            "title"         : _("all models"),
+            "help_text"     : _("Display all existing models"),
+            "open_in_window": False, # Should be create a new JavaScript window?
+            "weight" : 0, # sorting wieght for every section entry
+        },
+    },
 }

trunk/pylucid/tests/__init__.py

@@ -111 +111 @@
 
 from PyLucid.tools.db_dump import loaddb
-from PyLucid.tools.Diff import make_diff
+from PyLucid.tools.Diff import make_diff, diff_lines
 from PyLucid.install.install import DB_DumpFakeOptions
 from PyLucid.models import Page, Style, Template, Plugin
@@ -190 +190 @@
 # (relative path here! Because the current work dir can chaned!)
 TEST_PLUGIN_SRC = "tests/unittest_plugin/"
-TEST_PLUGIN_DST = "PyLucid/plugins_external/unittest_plugin"
+TEST_PLUGIN_DST = "PyLucid/plugins_internal/unittest_plugin"
 
 
@@ -243 +243 @@
             if txt in response.content:
                 error(response, "Text should not be in response: '%s'" % txt)
+
+    def assertEqual2(self, first, second):
+        """
+        Same as the original, but display a diff on error.
+        Makes only sence if the string contains more lines (\n)
+        """
+        if first == second:
+            # is equal, ok
+            return
+
+        error_msg = "Strings not equal:\n"
+        error_msg += "1: %r\n" % first
+        error_msg += "2: %r\n" % second
+        error_msg += "Diff:\n"
+        error_msg += diff_lines(first, second)
+
+        self.fail(error_msg)
 
     def assertLists(self, is_list, should_be_list, sort=True):
@@ -434 +451 @@
     """
     initialize the unittest plugin
-    -copy ./tests/unittest_plugin/ into ./PyLucid/plugins_external/
-    -install+activate the plugin into the database
+    -copy ./tests/unittest_plugin/ into ./PyLucid/plugins_internal/
+
+    The plugin would be installed in install_internal_plugins() as a normal Plugin.
     """
     print "initialize the unittest plugin"
@@ -456 +474 @@
             raise
 
-#    install_plugin(
-#        package_name = "PyLucid.plugins_external",
-#        plugin_name = "unittest_plugin",
-#        debug = True,
-#        active=True,
-#        extra_verbose=True,
-#    )
 
 
@@ -576 +587 @@
     """
     load_db_dumps(verbosity)
+    init_unittest_plugin()
     install_internal_plugins(verbosity)
     create_users() # Create all test users
     create_pages(TEST_PAGES) # Create the test pages
-    init_unittest_plugin()
     create_test_fixture(verbosity)
-    install_plugin(
-        package_name = "PyLucid.plugins_external",
-        plugin_name = "unittest_plugin",
-        debug = True,
-        active=True,
-        extra_verbose=True,
-    )
+
 
 def teardown_pylucid():