diff --git a/product/ERP5/tests/testBusinessTemplate.py b/product/ERP5/tests/testBusinessTemplate.py
index b2202129b32a6a92322a6585f50cdb34dcf4b0d7..96f28838e467437b02eab90b6385516bc316cc13 100755
--- a/product/ERP5/tests/testBusinessTemplate.py
+++ b/product/ERP5/tests/testBusinessTemplate.py
@@ -1,7 +1,7 @@
 ##############################################################################
 #
-# Copyright (c) 2004 Nexedi SARL and Contributors. All Rights Reserved.
-#          Yoshinori Okuji <yo@nexedi.com>
+# Copyright (c) 2005 Nexedi SARL and Contributors. All Rights Reserved.
+#          Aurelien Calonne <aurel@nexedi.com>
 #
 # WARNING: This program as such is intended to be used by professional
 # programmers who take the whole responsability of assessing all potential
@@ -26,15 +26,11 @@
 #
 ##############################################################################
 
-#
-# Skeleton ZopeTestCase
-#
-
 from random import randint
 
 import os, sys
 if __name__ == '__main__':
-    execfile(os.path.join(sys.path[0], 'framework.py'))
+  execfile(os.path.join(sys.path[0], 'framework.py'))
 
 # Needed in order to have a log file inside the current folder
 os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log')
@@ -42,18 +38,16 @@ os.environ['EVENT_LOG_SEVERITY'] = '-300'
 
 from Testing import ZopeTestCase
 from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
-from AccessControl.SecurityManagement import newSecurityManager, noSecurityManager
-from DateTime import DateTime
-from Acquisition import aq_base, aq_inner
+from AccessControl.SecurityManagement import newSecurityManager
+from Acquisition import aq_base
 from zLOG import LOG
 from Products.ERP5Type.ERP5Type import ERP5TypeInformation
-import time
-import os
-from Products.ERP5Type import product_path
-from DateTime import DateTime
 from App.config import getConfiguration
-from Products.ERP5Type.tests.Sequence import Sequence, SequenceList
+from Products.ERP5Type.tests.Sequence import SequenceList
 from urllib import pathname2url
+from Globals import PersistentMapping
+from Products.CMFCore.Expression import Expression
+import os
 
 class TestBusinessTemplate(ERP5TypeTestCase):
   """
@@ -68,17 +62,11 @@ class TestBusinessTemplate(ERP5TypeTestCase):
     - Upgrade a template
   """
   run_all_test = 1
-  business_template_title = 'erp5_pdm'
+
   
   def getTitle(self):
     return "Business Template"
 
-  def getBusinessTemplateList(self):
-    """
-    Install erp5_pdm in order to make some test on it.
-    """
-    return (self.business_template_title, )
-
   def enableActivityTool(self):
     """
     You can override this.
@@ -86,35 +74,6 @@ class TestBusinessTemplate(ERP5TypeTestCase):
     """
     return 1
 
-  def stepTic(self,**kw):
-    self.tic()
-
-  def test_01_checkTools(self, quiet=0, run=run_all_test):
-    if not run: return
-    if not quiet:
-      message = 'Test Check Tools'
-      ZopeTestCase._print('\n%s ' % message)
-      LOG('Testing... ', 0, message)
-    self.failUnless(self.getCategoryTool() is not None)
-    self.failUnless(self.getTemplateTool() is not None)
-    self.failUnless(self.getTypeTool() is not None)
-    self.failUnless(self.getSkinsTool() is not None)
-    self.failUnless(self.getCatalogTool() is not None)
-    
-  def test_02_checkERP5Core(self, quiet=0):
-    if not quiet:
-      message = 'Test Check ERP5 Core'
-      ZopeTestCase._print('\n%s ' % message)
-      LOG('Testing... ', 0, message)
-    pt = self.getTemplateTool()
-    core = None
-    for bt in pt.objectValues(filter={'portal_type':'Business Template'}):
-      if bt.getTitle() == 'erp5_core':
-        core = bt
-    self.failUnless(core is not None)
-    self.assertEquals(core.getBuildingState(), 'built')
-    self.assertEquals(core.getInstallationState(), 'installed')
-    
   def afterSetUp(self):
     self.login()
     portal = self.getPortal()
@@ -126,52 +85,544 @@ class TestBusinessTemplate(ERP5TypeTestCase):
     user = uf.getUserById('seb').__of__(uf)
     newSecurityManager(None, user)
 
-  def makeObjects(self):
+  def stepTic(self,**kw):
+    self.tic()
+
+  def stepCommitTransaction(self, **kw):
+    get_transaction().commit()
+
+  def stepUseCoreBusinessTemplate(self, sequence=None,
+                                  sequence_list=None, **kw):
+    """
+    Define erp5_core as current bt
+    """
+    template_tool = self.getTemplateTool()
+    core_bt = None
+    for bt in template_tool.objectValues(filter={'portal_type':'Business Template'}):
+      if bt.getTitle() == 'erp5_core':
+        core_bt = bt
+        break
+    self.failIf(core_bt is None)
+    sequence.edit(current_bt=core_bt)
+
+  def stepUseExportBusinessTemplate(self, sequence=None,
+                                  sequence_list=None, **kw):
+    """
+    Define export_bt as current bt
+    """
+    bt = sequence.get('export_bt')
+    sequence.edit(current_bt=bt)
+
+  def stepUseImportBusinessTemplate(self, sequence=None,
+                                  sequence_list=None, **kw):
+    """
+    Define import_bt as current bt
+    """
+    bt = sequence.get('import_bt')
+    sequence.edit(current_bt=bt)
+    
+  def stepCheckInstalledInstallationState(self, sequence=None,
+                                        seqeunce_list=None, **kw):
+    """
+    Check if installation state is installed
+    """
+    bt = sequence.get('current_bt', None)
+    self.assertEquals(bt.getInstallationState(), 'installed')
+
+  def stepCheckNotInstalledInstallationState(self, sequence=None,
+                                        seqeunce_list=None, **kw):
+    """
+    Check if installation state is not_installed
+    """
+    bt = sequence.get('current_bt')
+    self.assertEquals(bt.getInstallationState(), 'not_installed')
+
+  def stepCheckReplacedInstallationState(self, sequence=None,
+                                        seqeunce_list=None, **kw):
+    """
+    Check if installation state is replaced
+    """
+    bt = sequence.get('current_bt')
+    self.assertEquals(bt.getInstallationState(), 'replaced')
+
+  def stepCheckModifiedBuildingState(self, sequence=None, 
+                                     sequence_list=None, **kw):
+    """
+    Check if the building state is modified.
     """
-      Make objects to create a template.
+    bt = sequence.get('current_bt')
+    self.assertEquals(bt.getBuildingState(), 'modified')
+
+  def stepCheckBuiltBuildingState(self, sequence=None, 
+                                  sequence_list=None, **kw):
+    """
+    Check if the building state is built.
+    """
+    bt = sequence.get('current_bt')
+    self.assertEquals(bt.getBuildingState(), 'built')
+
+  def stepCheckTools(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of tools
+    """
+    self.failUnless(self.getCategoryTool() is not None)
+    self.failUnless(self.getTemplateTool() is not None)
+    self.failUnless(self.getTypeTool() is not None)
+    self.failUnless(self.getSkinsTool() is not None)
+    self.failUnless(self.getCatalogTool() is not None)
+    self.failUnless(self.getTrashTool() is not None)    
+    
+  def stepCheckSkinsLayers(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check skins layers
+    """
+    skins_tool = self.getSkinsTool()
+    for skin_name, selection in skins_tool.getSkinPaths():
+      if skin_name == 'View':
+        self.failIf('erp5_pdf_style' in selection)
+        self.failIf('erp5_csv_style' in selection)
+        self.failIf('erp5_core' not in selection)
+        self.failIf('erp5_html_style' not in selection)
+      if skin_name == 'Print':
+        self.failIf('erp5_html_style' in selection)
+        self.failIf('erp5_csv_style' in selection)
+        self.failIf('erp5_core' not in selection)
+        self.failIf('erp5_pdf_style' not in selection)
+      if skin_name == 'CSV':
+        self.failIf('erp5_pdf_style' in selection)
+        self.failIf('erp5_html_style' in selection)
+        self.failIf('erp5_core' not in selection)
+        self.failIf('erp5_csv_style' not in selection)
+
+  def stepCheckNoTrashBin(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check if there is no trash bins
+    """
+    trash = self.getTrashTool()
+    self.assertEquals(len(trash.objectIds()), 0)
+
+  def stepRemoveAllTrashBins(self, sequence=None, sequence_list=None, **kw):
+    """
+    Remove all trash bins
+    """
+    trash = self.getTrashTool()
+    trash_ids = list(trash.objectIds())
+    for id in trash_ids:
+      trash.deleteContent(id)
+    self.failIf(len(trash.objectIds()) > 0)
+
+  def stepCheckTrashBin(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check trash bin presence
+    """
+    trash = self.getTrashTool()
+    trash_ids = list(trash.objectIds())
+    self.assertEquals(len(trash.objectIds()), 1)
+    bt_id = sequence.get('import_bt').getId()
+    self.failUnless(bt_id not in trash_ids[0])
+
+  # portal types
+  def stepCreatePortalType(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create Portal Type
     """
-    # Make types.
     pt = self.getTypeTool()
+    # create module object portal type
+    pt.manage_addTypeInformation(ERP5TypeInformation.meta_type, id='Geek Object', typeinfo_name='ERP5Type: ERP5 Person')
+    object_type = pt._getOb('Geek Object', None)
+    self.failUnless(object_type is not None)
+    sequence.edit(object_ptype_id=object_type.getId())
+    # create module portal type
     pt.manage_addTypeInformation(ERP5TypeInformation.meta_type, id='Geek Module', typeinfo_name='ERP5Type: ERP5 Folder')
     module_type = pt._getOb('Geek Module', None)
     self.failUnless(module_type is not None)
-    pt.manage_addTypeInformation(ERP5TypeInformation.meta_type, id='Geek', typeinfo_name='ERP5Type: ERP5 Person')
-    object_type = pt._getOb('Geek', None)
+    module_type.allowed_content_types = ('Geek Object',)
+    sequence.edit(module_ptype_id=module_type.getId())
+
+  def stepAddPortalTypeToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add types to business template
+    """
+    bt = sequence.get('current_bt', None)
+    self.failUnless(bt is not None)
+    ptype_ids = []
+    ptype_ids.append(sequence.get('object_ptype_id', ''))
+    ptype_ids.append(sequence.get('module_ptype_id', ''))
+    self.assertEqual(len(ptype_ids), 2)
+    bt.edit(template_portal_type_id_list=ptype_ids)
+    
+  def stepRemovePortalType(self, sequence=None, sequence_list=None, **kw):
+    """
+    Remove PortalType    
+    """
+    pt = self.getTypeTool()
+    object_id = sequence.get('object_ptype_id')
+    module_id = sequence.get('module_ptype_id')
+    pt.manage_delObjects([module_id, object_id])
+    module_type = pt._getOb(module_id, None)
+    self.failUnless(module_type is None)
+    object_type = pt._getOb(object_id, None)
+    self.failUnless(object_type is None)
+
+  def stepCheckPortalTypeExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of portal type
+    """
+    pt = self.getTypeTool()
+    object_id = sequence.get('object_ptype_id')
+    module_id = sequence.get('module_ptype_id')
+    module_type = pt._getOb(module_id, None)
+    self.failUnless(module_type is not None)
+    object_type = pt._getOb(object_id, None)
     self.failUnless(object_type is not None)
-    module_type.allowed_content_types = ('Geek',)
+    
+  def stepCheckPortalTypeRemoved(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check non presence of portal type
+    """
+    pt = self.getTypeTool()
+    object_id = sequence.get('object_ptype_id')
+    module_id = sequence.get('module_ptype_id')
+    module_type = pt._getOb(module_id, None)
+    self.failUnless(module_type is None)
+    object_type = pt._getOb(object_id, None)
+    self.failUnless(object_type is None)
 
-    # Make skin folders.
+  # module
+  def stepCreateModuleAndObjects(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create Module with objects
+    """
+    portal = self.getPortal()
+    id = 'geek_module'
+    n = 0
+    while id in portal.objectIds():
+      n = n + 1
+      id = "%s_%s" %('geek_module', n)      
+    module = portal.newContent(id=id, portal_type='Geek Module')
+    self.failUnless(module is not None)
+    sequence.edit(module_id=module.getId())
+    module_object_list = []
+    for i in xrange(10):
+      object = module.newContent(portal_type = 'Geek Object')
+      self.failUnless(object is not None)
+      module_object_list.append(object)
+    sequence.edit(module_object_id_list=module_object_list)
+
+  def stepAddModuleToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add module to business template
+    """
+    bt = sequence.get('current_bt', None)
+    module_id = sequence.get('module_id', None)
+    self.failUnless(module_id is not None)
+    bt.edit(template_module_id_list=[module_id])
+
+  def stepCreateModuleObjects(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create objects into module
+    """
+    portal = self.getPortal()    
+    module_id = sequence.get('module_id')
+    module = portal._getOb(module_id, None)
+    self.failUnless(module is not None)
+    module_object_list = []
+    for i in xrange(10):
+      object = module.newContent(portal_type = 'Geek Object')
+      self.failUnless(object is not None)
+      module_object_list.append(object.getId())
+    sequence.edit(module_object_id_list=module_object_list)    
+
+  def stepRemoveModule(self, sequence=None, sequence_list=None, **kw):
+    """
+    Remove Module
+    """
+    portal = self.getPortal()
+    module_id = sequence.get("module_id")
+    portal.manage_delObjects([module_id])
+    self.failIf(portal._getOb(module_id, None) is not None)
+
+  def stepCheckModuleExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of module
+    """
+    portal = self.getPortal()
+    module_id = sequence.get("module_id")
+    new_module = portal._getOb(module_id, None)
+    self.failIf(new_module is None)
+
+  def stepCheckModuleObjectsExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of objects in module
+    """
+    portal = self.getPortal()
+    module_id = sequence.get('module_id')
+    module = portal._getOb(module_id)
+    self.failUnless(module is not None)
+    object_id_list = sequence.get('module_object_id_list')
+    for object_id in object_id_list:
+      object = module._getOb(object_id, None)
+      self.failUnless(object is not None)
+
+  def stepCheckModuleObjectsRemoved(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check non presence of objects in module
+    """
+    portal = self.getPortal()
+    module_id = sequence.get('module_id')
+    module = portal._getOb(module_id)
+    self.failUnless(module is not None)
+    object_id_list = sequence.get('module_object_id_list')
+    for object_id in object_id_list:
+      object = module._getOb(object_id, None)
+      self.failUnless(object is None)
+      
+  def stepCheckModuleRemoved(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check non presence of module
+    """
+    portal = self.getPortal()
+    module_id = sequence.get("module_id")
+    self.failIf(portal._getOb(module_id, None) is not None)    
+
+  # skins folder
+  def stepCreateSkinFolder(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create a skin folder
+    """
     ps = self.getSkinsTool()
-    ps.manage_addProduct['OFSP'].manage_addFolder('local_geek')
-    skin_folder = ps._getOb('local_geek', None)
+    ps.manage_addProduct['OFSP'].manage_addFolder('erp5_geek')
+    skin_folder = ps._getOb('erp5_geek', None)
     self.failUnless(skin_folder is not None)
+    sequence.edit(skin_folder_id=skin_folder.getId())
+    # add skin in layers
     for skin_name, selection in ps.getSkinPaths():
       selection = selection.split(',')
-      if 'local_geek' not in selection:
-        selection.append('local_geek')
+      if 'erp5_geek' not in selection:
+        selection.append('erp5_geek')
       ps.manage_skinLayers(skinpath = tuple(selection), skinname = skin_name, add_skin = 1)
 
-    # Make modules.
-    portal = self.getPortal()
-    module = portal.newContent(id = 'geek', portal_type = 'Geek Module')
-    self.failUnless(module is not None)
-    object = module.newContent(id = '1', portal_type = 'Geek')
-    self.failUnless(object is not None)
+  def stepRemoveSkinFolder(self, sequence=None, sequence_list=None, **kw):
+    """
+    Remove Skin folder
+    """
+    ps = self.getSkinsTool()
+    skin_id = sequence.get('skin_folder_id')
+    ps.manage_delObjects([skin_id])
+    skin_folder = ps._getOb(skin_id, None)
+    self.failUnless(skin_folder is None)
+    for skin_name, selection in ps.getSkinPaths():
+      selection = selection.split(',')
+      if skin_id in selection:
+        selection.remove(skin_id)
+      ps.manage_skinLayers(skinpath = tuple(selection), skinname = skin_name, add_skin = 1)
+
+  def stepCheckSkinFolderExists(self, sequence=None,sequence_list=None, **kw):
+    """
+    Check presence of skin folder
+    """
+    ps = self.getSkinsTool()
+    skin_id = sequence.get('skin_folder_id')
+    skin_folder = ps._getOb(skin_id, None)
+    self.failUnless(skin_folder is not None)    
+
+  def stepCheckSkinFolderRemoved(self, sequence=None,sequence_list=None, **kw):
+    """
+    Check non presence of skin folder
+    """
+    ps = self.getSkinsTool()
+    skin_id = sequence.get('skin_folder_id')
+    skin_folder = ps._getOb(skin_id, None)
+    self.failUnless(skin_folder is None)
+
+  def stepAddSkinFolderToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add sin folder to business template
+    """
+    bt = sequence.get('current_bt', None)
+    self.failUnless(bt is not None)
+    wf_ids = []
+    wf_ids.append(sequence.get('skin_folder_id', ''))
+    self.assertEqual(len(wf_ids), 1)
+    bt.edit(template_skin_id_list=wf_ids)
 
-    # Make categories.
+  # Base Category
+  def stepCreateBaseCategory(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create Base category
+    """
     pc = self.getCategoryTool()
-    base_category = pc.newContent(portal_type = 'Base Category', id = 'geek')
+    base_category = pc.newContent(portal_type = 'Base Category')
     self.failUnless(base_category is not None)
-    category = base_category.newContent(portal_type = 'Category', id = 'computer')
-    self.failUnless(category is not None)
-    category = base_category.newContent(portal_type = 'Category', id = 'manga')
-    self.failUnless(category is not None)
-    category = base_category.newContent(portal_type = 'Category', id = 'game')
+    sequence.edit(bc_id=base_category.getId())
+
+  def stepAddBaseCategoryToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add Base category to Business template
+    """
+    bc_id = sequence.get('bc_id')
+    bt = sequence.get('current_bt')
+    bt.edit(template_base_category_list=[bc_id])
+
+  def stepAddBaseCategoryAsPathToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add Base category to Business template
+    """
+    bc_id = sequence.get('bc_id')
+    bt = sequence.get('current_bt')
+    path = 'portal_categories/'+bc_id
+    bt.edit(template_path_list=[path])
+
+  def stepRemoveBaseCategory(self, sequence=None, sequence_list=None, **kw):
+    """
+    Remove Base category
+    """
+    pc = self.getCategoryTool()
+    bc_id = sequence.get('bc_id')
+    pc.manage_delObjects([bc_id])
+    base_category = pc._getOb(bc_id, None)
+    self.failUnless(base_category is None)    
+
+  def stepCheckBaseCategoryExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of Base category
+    """
+    pc = self.getCategoryTool()
+    bc_id = sequence.get('bc_id')
+    base_category = pc._getOb(bc_id, None)
+    self.failUnless(base_category is not None)    
+
+  def stepCheckBaseCategoryRemoved(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check non presence of Base category
+    """
+    pc = self.getCategoryTool()
+    bc_id = sequence.get('bc_id')
+    base_category = pc._getOb(bc_id, None)
+    LOG('base category is', 0, base_category)
+    self.failUnless(base_category is None)    
+
+  # categories
+  def stepCreateCategories(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create categories into a base category
+    """
+    bc_id = sequence.get('bc_id')
+    pc = self.getCategoryTool()
+    base_category = pc._getOb(bc_id, None)    
+    self.failUnless(base_category is not None)
+    category_list = []
+    for i in xrange(10):
+      category = base_category.newContent(portal_type='Category')
+      self.failUnless(category is not None)
+      category_list.append(category.getId())
+    sequence.edit(category_id_list=category_list)
+
+  def stepAddCategoriesAsPathToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add Categories in path with the joker *
+    """
+    bc_id = sequence.get('bc_id')
+    bt = sequence.get('current_bt')
+    path = 'portal_categories/'+bc_id+'/*'
+    bt.edit(template_path_list=[path])
+
+  def stepCheckCategoriesExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of categories
+    """
+    bc_id = sequence.get('bc_id')
+    pc = self.getCategoryTool()
+    base_category = pc._getOb(bc_id, None)
+    self.failUnless(base_category is not None)
+    category_id_list = sequence.get('category_id_list')
+    for category_id in category_id_list:
+      category = base_category._getOb(category_id, None)
+      self.failUnless(category is not None)
+
+  def stepCheckCategoriesRemoved(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check non-presence of categories
+    """
+    bc_id = sequence.get('bc_id')
+    pc = self.getCategoryTool()
+    base_category = pc._getOb(bc_id, None)
+    self.failUnless(base_category is not None)
+    category_id_list = sequence.get('category_id_list')
+    for category_id in category_id_list:
+      category = base_category._getOb(category_id, None)
+      self.failUnless(category is None)
+
+  def stepRemoveCategories(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of categories
+    """
+    bc_id = sequence.get('bc_id')
+    pc = self.getCategoryTool()
+    base_category = pc._getOb(bc_id, None)
+    self.failUnless(base_category is not None)
+    category_id_list = sequence.get('category_id_list')
+    base_category.manage_delObjects(category_id_list)
+    for category_id in category_id_list:
+      category = base_category._getOb(category_id, None)
+      self.failUnless(category is None)
+      
+  # sub categories
+  def stepCreateSubCategories(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add sub category to a category
+    """
+    pc = self.getCategoryTool()
+    bc_id = sequence.get('bc_id')
+    base_category = pc._getOb(bc_id, None)
+    self.failUnless(base_category is not None)
+    cat_id_list = sequence.get('category_id_list')
+    # only use one category
+    cat_id = cat_id_list[0]
+    category = base_category._getOb(cat_id, None)
     self.failUnless(category is not None)
+    subcategory_list = []
+    for i in xrange(10):
+      subcategory = category.newContent(portal_type='Category')
+      self.failUnless(subcategory is not None)
+      subcategory_list.append(subcategory.getId())
+    sequence.edit(subcategory_id_list=subcategory_list, parent_category_id=category.getId())
 
-    # Make workflows.
+  def stepAddSubCategoriesAsPathToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add All Categories in path with the joker **
+    """
+    bc_id = sequence.get('bc_id')
+    bt = sequence.get('current_bt')
+    path = 'portal_categories/'+bc_id+'/**'
+    bt.edit(template_path_list=[path])
+  
+  def stepCheckSubCategoriesExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of categories
+    """
+    bc_id = sequence.get('bc_id')
+    pc = self.getCategoryTool()
+    base_category = pc._getOb(bc_id, None)
+    self.failUnless(base_category is not None)
+    parent_category_id = sequence.get('parent_category_id')
+    category = base_category._getOb(parent_category_id, None)
+    self.failUnless(category is not None)
+    subcategory_id_list = sequence.get('subcategory_id_list')
+    for subcategory_id in subcategory_id_list:
+      subcategory = category._getOb(subcategory_id, None)
+      self.failUnless(subcategory is not None)
+  
+  # workflow
+  def stepCreateWorkflow(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create a workflow
+    """
     pw = self.getWorkflowTool()
     pw.manage_addWorkflow('dc_workflow (Web-configurable workflow)', 'geek_workflow')
+    workflow = pw._getOb('geek_workflow', None)
+    self.failUnless(workflow is not None)
+    sequence.edit(workflow_id=workflow.getId())
     cbt = pw._chains_by_type
     props = {}
     if cbt is not None:
@@ -180,463 +631,1438 @@ class TestBusinessTemplate(ERP5TypeTestCase):
     props['chain_geek'] = 'geek_workflow'
     pw.manage_changeWorkflows('', props=props)
 
-    # FIXME: more objects must be created.
-
-  def removeObjects(self):
+  def stepAddWorkflowToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-      Remove objects created by makeObjects.
+    Add workflow to business template
     """
-    # Remove types.
-    pt = self.getTypeTool()
-    pt.manage_delObjects(['Geek Module', 'Geek'])
-    module_type = pt._getOb('Geek Module', None)
-    self.failUnless(module_type is None)
-    object_type = pt._getOb('Geek', None)
-    self.failUnless(object_type is None)
+    bt = sequence.get('current_bt', None)
+    self.failUnless(bt is not None)
+    wf_ids = []
+    wf_ids.append(sequence.get('workflow_id', ''))
+    self.assertEqual(len(wf_ids), 1)
+    bt.edit(template_workflow_id_list=wf_ids)
+    
+  def stepRemoveWorkflow(self, sequence=None, sequence_list=None, **kw):
+    """
+    Remove Workflow
+    """
+    wf_id = sequence.get('workflow_id')
+    pw = self.getWorkflowTool()
+    pw.manage_delObjects([wf_id])
+    workflow = pw._getOb(wf_id, None)
+    self.failUnless(workflow is None)
 
-    # Remove skin folders.
-    ps = self.getSkinsTool()
-    ps.manage_delObjects(['local_geek'])
-    skin_folder = ps._getOb('local_geek', None)
-    self.failUnless(skin_folder is None)
-    for skin_name, selection in ps.getSkinPaths():
-      selection = selection.split(',')
-      if 'local_geek' in selection:
-        selection.remove('local_geek')
-      ps.manage_skinLayers(skinpath = tuple(selection), skinname = skin_name, add_skin = 1)
+  def stepCheckWorkflowExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of Workflow
+    """
+    wf_id = sequence.get('workflow_id')
+    pw = self.getWorkflowTool()
+    workflow = pw._getOb(wf_id, None)
+    self.failUnless(workflow is not None)
 
-    # Remove modules.
-    portal = self.getPortal()
-    portal.manage_delObjects(['geek'])
-    module = portal._getOb('geek', None)
-    self.failUnless(module is None)
+  def stepCheckWorkflowRemoved(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check non presence of Workflow
+    """
+    wf_id = sequence.get('workflow_id')
+    pw = self.getWorkflowTool()
+    workflow = pw._getOb(wf_id, None)
+    self.failUnless(workflow is None)
 
-    # Remove categories.
-    pc = self.getCategoryTool()
-    pc.manage_delObjects(['geek'])
-    base_category = pc._getOb('geek', None)
-    self.failUnless(base_category is None)
+  # Actions
+  def stepCreateActions(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create actions
+    """
+    pt = self.getTypeTool()
+    object_id = sequence.get('object_ptype_id')
+    object_pt = pt._getOb(object_id)
+    object_pt.addAction(
+      id = 'become_geek'
+      , name = 'Become Geek'
+      , action = 'become_geek_action'
+      , condition = ''
+      , permission = ('View', )
+      , category = 'object_action'
+      , visible = 1
+      , optional = 0 )
+    object_pt.addAction(
+      id = 'become_nerd'
+      , name = 'Become Nerd'
+      , action = 'become_nerd_action'
+      , condition = ''
+      , permission = ('View', )
+      , category = 'object_action'
+      , visible = 1
+      , optional = 1 )
+    sequence.edit(action_id='become_geek', opt_action_id='become_nerd')
 
-    # Make workflows.
-    pw = self.getWorkflowTool()
-    pw.manage_delObjects(['geek_workflow'])
+  def stepCheckActionExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of action 
+    """
+    pt = self.getTypeTool()
+    object_id = sequence.get('object_ptype_id')
+    object_pt = pt._getOb(object_id)
+    action_id = sequence.get('action_id')
+    self.failUnless(action_id in [x.getId() for x in object_pt.listActions()])
 
-    # FIXME: more objects must be removed.
+  def stepCheckActionNotExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check non-presence of action 
+    """
+    pt = self.getTypeTool()
+    object_id = sequence.get('object_ptype_id')
+    object_pt = pt._getOb(object_id)
+    action_id = sequence.get('action_id')
+    self.failUnless(action_id not in [x.getId() for x in object_pt.listActions()])
 
-  def test_02_makeTemplate(self, quiet=0, run=run_all_test):
-    if not run: return
-    if not quiet:
-      message = 'Test Make Template'
-      ZopeTestCase._print('\n%s ' % message)
-      LOG('Testing... ', 0, message)
+  def stepCheckOptionalActionExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of optional action 
+    """
+    pt = self.getTypeTool()
+    object_id = sequence.get('object_ptype_id')
+    object_pt = pt._getOb(object_id)
+    action_id = sequence.get('opt_action_id')
+    self.failUnless(action_id in [x.getId() for x in object_pt.listActions()])
 
-    self.makeObjects()
+  def stepCheckOptionalActionNotExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check non-presence of optional action 
+    """
+    pt = self.getTypeTool()
+    object_id = sequence.get('object_ptype_id')
+    object_pt = pt._getOb(object_id)
+    action_id = sequence.get('opt_action_id')
+    self.failUnless(action_id not in [x.getId() for x in object_pt.listActions()])    
 
-    pt = self.getTemplateTool()
-    template = pt.newContent(portal_type = 'Business Template')
-    self.failUnless(template.getBuildingState() == 'draft')
-    self.failUnless(template.getInstallationState() == 'not_installed')
-    template.edit(title='geek template',
-                  template_portal_type_id_list = ['Geek Module', 'Geek'],
-                  template_skin_id_list = ['local_geek'],
-                  template_module_id_list = ['geek'],
-                  template_base_category_list = ['geek'],
-                  template_workflow_id_list = ['geek_workflow'])
-    self.failUnless(template.getBuildingState() == 'modified')
-    self.failUnless(template.getInstallationState() == 'not_installed')
-    template.build()
-    self.failUnless(template.getBuildingState() == 'built')
-    self.failUnless(template.getInstallationState() == 'not_installed')
-    # export Business Template
-    cfg = getConfiguration()
-    template_path = os.path.join(cfg.instancehome, 'tests', '%s' % (template.getTitle(),))
-    template.export(path=pathname2url(template_path), local=1)
+  def stepAddOptionalActionToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add optionpal action into the business template
+    """
+    bt = sequence.get('current_bt', None)
+    self.failUnless(bt is not None)
+    opt_action_id = sequence.get('opt_action_id', None)
+    self.failUnless(opt_action_id is not None)
+    object_ptype_id = sequence.get('object_ptype_id', None)
+    self.failUnless(object_ptype_id is not None)
+    action_path = object_ptype_id+'[id='+opt_action_id+']'
+    bt.edit(template_action_path_list=[action_path])
 
-    self.removeObjects()
-    
-    # import and install Business Template
-    pt.download(url='file:'+pathname2url(template_path), id='template_test')
-    template = pt._getOb(id='template_test')  
-    template.install()
-    self.assertEquals(template.getBuildingState(), 'built')
-    self.assertEquals(template.getInstallationState(), 'installed')
-
-    # FIXME: check installed objects here
+  # Catalog Method
+  def stepCreateCatalogMethod(self, sequence=None, sequence_list=None, **kw):
+    """
+    Create ZSQL Method into catalog
+    """
+    pc = self.getCatalogTool()
+    catalog = pc._getOb('erp5_mysql', None)
+    self.failUnless(catalog is not None)
+    method_id = "z_fake_method"
+    addSQLMethod =catalog.manage_addProduct['ZSQLMethods'].manage_addZSQLMethod
+    addSQLMethod(id=method_id,title='', connection_id='test test', arguments='', template='')
+    zsql_method = catalog._getOb(method_id, None)  
+    self.failUnless(zsql_method is not None)
+    sequence.edit(zsql_method_id = method_id)
+    # set this method in update_object properties of catalog
+    sql_uncatalog_object = list(catalog.sql_uncatalog_object)
+    sql_uncatalog_object.append(method_id)
+    sql_uncatalog_object.sort()
+    catalog.sql_uncatalog_object = tuple(sql_uncatalog_object)
+    # set filter for this method
+    expression = 'python: isMovement'
+    expr_instance = Expression(expression)
+    catalog.filter_dict[method_id] = PersistentMapping()
+    catalog.filter_dict[method_id]['filtered'] = 1
+    catalog.filter_dict[method_id]['expression'] = expression
+    catalog.filter_dict[method_id]['expression_instance'] = expr_instance
+    catalog.filter_dict[method_id]['type'] = []
     
-    template.uninstall()
-    self.assertEquals(template.getBuildingState(), 'built')
-    self.assertEquals(template.getInstallationState(), 'not_installed')
+  def stepAddCatalogMethodToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add catalog method into the business template
+    """
+    bt = sequence.get('current_bt', None)
+    self.failUnless(bt is not None)
+    method_id = sequence.get('zsql_method_id', None)
+    self.failUnless(method_id is not None)
+    bt.edit(template_catalog_method_id_list=['erp5_mysql/'+method_id])
 
-    # FIXME: check uninstalled objects here
+  def stepCheckCatalogMethodExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of ZSQL Method in catalog
+    """
+    pc = self.getCatalogTool()
+    catalog = pc._getOb('erp5_mysql', None)
+    self.failUnless(catalog is not None)
+    method_id = sequence.get('zsql_method_id', None)
+    zsql_method = catalog._getOb(method_id, None)  
+    self.failUnless(zsql_method is not None)
+    # check catalog properties
+    self.failUnless(method_id in catalog.sql_uncatalog_object)
+    # check filter
+    self.failUnless(method_id in catalog.filter_dict.keys())
+    filter_dict = catalog.filter_dict[method_id]
+    self.assertEqual(filter_dict['filtered'], 1)
+    self.assertEqual(filter_dict['expression'], 'python: isMovement')
+    self.assertEqual(filter_dict['type'], [])
 
-  def stepGetCurrentBusinessTemplate(self, sequence=None, 
-                                     sequence_list=None, **kw):
+  def stepCheckCatalogMethodRemoved(self, sequence=None, sequence_list=None, **kw):
     """
-      Get current business template.
+    Check non-presence of ZSQL Method in catalog
     """
-    template_tool = self.getTemplateTool()
-    current_bt_sql = template_tool.searchFolder(
-                              title=self.business_template_title)
-    current_bt_list = []
-    for bt in current_bt_sql:
-      ob = bt.getObject()
-      if ob.getInstallationState() == 'installed':
-        current_bt_list.append(ob)
-    self.assertEquals(len(current_bt_list), 1)
-    current_bt = current_bt_list[0]
-    sequence.edit(current_bt=current_bt)
-
-  def stepCopyBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
-    """
-      Copy business template.
-    """
-    current_bt = sequence.get('current_bt')
-    template_tool = self.getTemplateTool()
-    copy_data = template_tool.manage_copyObjects(ids=[current_bt.getId()])
-    new_id_list = template_tool.manage_pasteObjects(copy_data)
-    self.failUnless(len(new_id_list) == 1)
-    new_bt = getattr(template_tool, new_id_list[0]['new_id'])
-    sequence.edit(new_bt=new_bt)
+    pc = self.getCatalogTool()
+    catalog = pc._getOb('erp5_mysql', None)
+    self.failUnless(catalog is not None)
+    method_id = sequence.get('zsql_method_id', None)
+    zsql_method = catalog._getOb(method_id, None)  
+    self.failUnless(zsql_method is None)
+    # check catalog properties
+    self.failUnless(method_id not in catalog.sql_uncatalog_object)
+    # check filter
+    self.failUnless(method_id not in catalog.filter_dict.keys())
 
-  def stepCreateNewBaseCategory(self, sequence=None, sequence_list=None, **kw):
+    
+  def stepRemoveCatalogMethod(self, sequence=None, sequence_list=None, **kw):
     """
-      Create new base category.
+    Remove ZSQL Method from catalog
     """
-    category_tool = self.getCategoryTool()
-    new_base_category = category_tool.newContent(portal_type="Base Category",)
-    sequence.edit(new_base_category=new_base_category)
+    pc = self.getCatalogTool()
+    catalog = pc._getOb('erp5_mysql', None)
+    self.failUnless(catalog is not None)
+    method_id = sequence.get('zsql_method_id', None)
+    catalog.manage_delObjects([method_id])
+    zsql_method = catalog._getOb(method_id, None)
+    self.failUnless(zsql_method is None)
+    # remove catalog properties
+    sql_uncatalog_object = list(catalog.sql_uncatalog_object)
+    sql_uncatalog_object.remove(method_id)
+    sql_uncatalog_object.sort()
+    catalog.sql_uncatalog_object = tuple(sql_uncatalog_object)
+    self.failUnless(method_id not in catalog.sql_uncatalog_object)
+    # remove filter
+    del catalog.filter_dict[method_id]
+    self.failUnless(method_id not in catalog.filter_dict.keys())        
 
-  def stepEditNewBT(self, sequence=None, sequence_list=None, **kw):
+  # Related key, Result key and table
+  def stepCreateKeysAndTable(self, sequence=list, sequence_list=None, **kw):
     """
-    Simply edit, in order to change the building status.
+    Create some keys and tables
     """
-    new_bt = sequence.get('new_bt')
-    new_bt.edit()
+    related_key = 'fake_id | category/catalog/z_fake_method'
+    result_key = 'fake_catalog.uid'
+    result_table = 'fake_catalog'
+    catalog = self.getCatalogTool().getSQLCatalog()
+    self.failUnless(catalog is not None)
+    LOG("catalog is", 0, catalog.getId())
+    # result key
+    sql_search_result_keys = list(catalog.sql_search_result_keys)
+    sql_search_result_keys.append(result_key)
+    sql_search_result_keys.sort()
+    catalog.sql_search_result_keys = tuple(sql_search_result_keys)
+    self.failUnless(result_key in catalog.sql_search_result_keys)
+    # related key
+    sql_search_related_keys = list(catalog.sql_catalog_related_keys)
+    sql_search_related_keys.append(related_key)
+    sql_search_related_keys.sort()
+    catalog.sql_catalog_related_keys = tuple(sql_search_related_keys)
+    self.failUnless(related_key in catalog.sql_catalog_related_keys)
+    # result table
+    sql_search_tables = list(catalog.sql_search_tables)
+    sql_search_tables.append(result_table)
+    sql_search_tables.sort()
+    catalog.sql_search_tables = tuple(sql_search_tables)
+    self.failUnless(result_table in catalog.sql_search_tables)
+    sequence.edit(related_key=related_key, result_key=result_key, result_table=result_table)
+    
+  def stepAddKeysAndTableToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add some related, result key and tables to Business Temlpate
+    """
+    bt = sequence.get('current_bt', None)
+    self.failUnless(bt is not None)
+    related_key = sequence.get('related_key', None)
+    self.failUnless(related_key is not None)
+    result_key = sequence.get('result_key', None)
+    self.failUnless(result_key is not None)
+    result_table = sequence.get('result_table', None)
+    self.failUnless(result_table is not None)
+    bt.edit(template_catalog_related_key_list=[related_key],
+            template_catalog_result_key_list=[result_key],
+            template_catalog_result_table_list=[result_table]
+            )
 
-  def stepAddNewBaseCategoryToNewBT(self, sequence=None, 
-                                    sequence_list=None, **kw):
+  def stepRemoveKeysAndTable(self, sequence=list, sequence_list=None, **kw):
     """
-    Add the base category to the business template.
+    Remove some keys and tables
     """
-    new_bt = sequence.get('new_bt')
-    new_base_category = sequence.get('new_base_category')
-    base_category_id_list = list(new_bt.getTemplateBaseCategoryList())
-    base_category_id_list.append(new_base_category.getId())
-    new_bt.edit(template_base_category_list=base_category_id_list)
-    sequence.edit(installed_base_cat_id=new_base_category.getId())
+    related_key = sequence.get('related_key', None)
+    self.failUnless(related_key is not None)
+    result_key = sequence.get('result_key', None)
+    self.failUnless(result_key is not None)
+    result_table = sequence.get('result_table', None)
+    self.failUnless(result_table is not None)
+    catalog = self.getCatalogTool().getSQLCatalog()
+    self.failUnless(catalog is not None)
+    # result key
+    sql_search_result_keys = list(catalog.sql_search_result_keys)
+    sql_search_result_keys.remove(result_key)
+    sql_search_result_keys.sort()
+    catalog.sql_search_result_keys = tuple(sql_search_result_keys)
+    self.failUnless(result_key not in catalog.sql_search_result_keys)
+    # related key
+    sql_search_related_keys = list(catalog.sql_catalog_related_keys)
+    sql_search_related_keys.remove(related_key)
+    sql_search_related_keys.sort()
+    catalog.sql_catalog_related_keys = tuple(sql_search_related_keys)
+    self.failUnless(related_key not in catalog.sql_catalog_related_keys)
+    # result table
+    sql_search_tables = list(catalog.sql_search_tables)
+    sql_search_tables.remove(result_table)
+    sql_search_tables.sort()
+    catalog.sql_search_tables = tuple(sql_search_tables)
+    self.failUnless(result_table not in catalog.sql_search_tables)
 
-  def stepAddCategoryToBaseCategory(self, sequence=None,
-                                    sequence_list=None, **kw):
+  def stepCheckKeysAndTableExists(self, sequence=list, sequence_list=None, **kw):
     """
-    Add a category to a base category
+    Check presence of some keys and tables
     """
-    subcategory_id = "fake subcategory"
-    new_base_category = sequence.get('new_base_category')
-#     portal_categories = self.getCategoryTool()
-#     base_category = portal_categories._getOb('fake_base_category')
-    LOG('new_base_catory', 0, new_base_category)
-    subcategory = new_base_category.newContent(portal_type="Category",
-                                           id=subcategory_id)
-    sequence.edit(subcategory_id=subcategory.getId())
+    related_key = sequence.get('related_key', None)
+    self.failUnless(related_key is not None)
+    result_key = sequence.get('result_key', None)
+    self.failUnless(result_key is not None)
+    result_table = sequence.get('result_table', None)
+    self.failUnless(result_table is not None)
+    catalog = self.getCatalogTool().getSQLCatalog()
+    self.failUnless(catalog is not None)
+    # result key
+    self.failUnless(result_key in catalog.sql_search_result_keys)
+    # related key
+    self.failUnless(related_key in catalog.sql_catalog_related_keys)
+    # result table
+    self.failUnless(result_table in catalog.sql_search_tables)
 
-  def stepCheckIfSubCategoryExists(self, sequence=None,
-                                  sequence_list=None, **kw):
+  def stepCheckKeysAndTableRemoved(self, sequence=list, sequence_list=None, **kw):
     """
-    Check if subcategory still exists
+    Check non-presence of some keys and tables
     """
-    base_category_id = sequence.get('installed_base_cat_id')
-    LOG("base_cat_id", 0, base_category_id)
-    portal_categories = self.getCategoryTool()
-    base_category = portal_categories._getOb(base_category_id)
-    subcategory_id = sequence.get('subcategory_id')
-    self.failUnless(subcategory_id in base_category.contentIds())
+    related_key = sequence.get('related_key', None)
+    self.failUnless(related_key is not None)
+    result_key = sequence.get('result_key', None)
+    self.failUnless(result_key is not None)
+    result_table = sequence.get('result_table', None)
+    self.failUnless(result_table is not None)
+    catalog = self.getCatalogTool().getSQLCatalog()
+    self.failUnless(catalog is not None)
+    # result key
+    self.failUnless(result_key not in catalog.sql_search_result_keys)
+    # related key
+    self.failUnless(related_key not in catalog.sql_catalog_related_keys)
+    # result table
+    self.failUnless(result_table not in catalog.sql_search_tables)
 
-  def stepCheckModifiedBuildingState(self, sequence=None, 
-                                     sequence_list=None, **kw):
+  # Roles
+  def stepCreateRole(self, sequence=None, sequence_list=None, **kw):
     """
-    Check if the building state is modified.
+    Create a role
     """
-    new_bt = sequence.get('new_bt')
-    self.assertEquals(new_bt.getBuildingState(), 'modified')
+    new_role = "Unit Tester"
+    p = self.getPortal()
+    role_list = list(p.__ac_roles__)
+    role_list.append(new_role)
+    p.__ac_roles__ = tuple(role_list)
+    self.failUnless(new_role in p.__ac_roles__)
+    sequence.edit(role=new_role)
 
-  def stepCheckBuiltBuildingState(self, sequence=None, 
-                                  sequence_list=None, **kw):
+  def stepRemoveRole(self, sequence=None, sequence_list=None, **kw):
     """
-    Check if the building state is built.
+    Remove a role
     """
-    new_bt = sequence.get('new_bt')
-    self.assertEquals(new_bt.getBuildingState(), 'built')
+    role = sequence.get('role', None)
+    self.failUnless(role is not None)
+    p = self.getPortal()
+    role_list = list(p.__ac_roles__)
+    role_list.remove(role)
+    p.__ac_roles__ = tuple(role_list)
+    self.failUnless(role not in p.__ac_roles__)
 
-  def stepBuildNewBT(self, sequence=None, sequence_list=None, **kw):
+  def stepAddRoleToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Add Role to Business Template
+    """
+    role = sequence.get('role', None)
+    self.failUnless(role is not None)
+    bt = sequence.get('current_bt', None)
+    self.failUnless(bt is not None)
+    bt.edit(template_role_list=[role])
+
+  def stepCheckRoleExists(self, sequence=None, sequence_list=None, **kw):
+    """
+    Check presence of role
+    """
+    role = sequence.get('role', None)
+    self.failUnless(role is not None)
+    p = self.getPortal()
+    self.failUnless(role in p.__ac_roles__)
+    
+  def stepCheckRoleRemoved(self, sequence=None, sequence_list=None, **kw):
     """
-    Build the business template.
+    Check non-presence of role
     """
-    new_bt = sequence.get('new_bt')
-    new_bt.build()
+    role = sequence.get('role', None)
+    self.failUnless(role is not None)
+    p = self.getPortal()
+    self.failUnless(role not in p.__ac_roles__)
 
-  def stepExportNewBT(self, sequence=None, sequence_list=None, **kw):
+  # Document, Property Sheet, Extension And Test
+  # they use the same class so only one test is required for them
+  def stepCreatePropertySheet(self, sequence=None, sequence_list=None, **kw):
     """
-    Export the business template.
+    Create a Property Sheet
     """
-    new_bt = sequence.get('new_bt')
+    ps_title = 'UnitTest'
+    ps_data =  ' \nclass UnitTest: \n  """ \n  Fake property sheet for unit test \n \
+    """ \n  _properties = ( \n  ) \n  _categories = ( \n  ) \n\n'
     cfg = getConfiguration()
-    template_path = os.path.join(cfg.instancehome, 
-                                 'tests', '%s' % (new_bt.getTitle(),))
-    sequence.edit(template_path=template_path)
-    new_bt.export(path=template_path, local=1)
+    file_path = os.path.join(cfg.instancehome, 'PropertySheet', ps_title+'.py')
+    if os.path.exists(file_path):
+      os.remove(file_path)
+    f = file(file_path, 'w')
+    f.write(ps_data)
+    f.close()
+    self.failUnless(os.path.exists(file_path))
+    sequence.edit(ps_title=ps_title, ps_path=file_path)
 
-  def stepImportNewBT(self, sequence=None, sequence_list=None, **kw):
+  def stepAddPropertySheetToBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-    Import the business template.
+    Add Property Sheet to Business Template
     """
-    template_tool = self.getTemplateTool()
-    new_bt = sequence.get('new_bt')
-    template_path = sequence.get('template_path')
-    import_bt_id = "import_%s" % new_bt.getId()
-    template_tool.download(url='file:'+pathname2url(template_path), id=import_bt_id)
-    import_bt = template_tool._getOb(id=import_bt_id)
-    self.assertEquals(import_bt.getPortalType(), 'Business Template')
-    sequence.edit(new_bt=import_bt)
-    template_tool.deleteContent(new_bt.getId())
+    bt = sequence.get('current_bt', None)
+    self.failUnless(bt is not None)
+    ps_title = sequence.get('ps_title', None)
+    self.failUnless(ps_title is not None)
+    bt.edit(template_property_sheet_id_list=[ps_title])
 
-  def stepInstallNewBT(self, sequence=None, sequence_list=None, **kw):
+  def stepRemovePropertySheet(self, sequence=None, sequencer_list=None, **kw):
     """
-    Build the business template.
+    Remove Property Sheet
     """
-    new_bt = sequence.get('new_bt')
-    new_bt.install()
+    ps_path = sequence.get('ps_path', None)
+    self.failUnless(ps_path is not None)
+    self.failUnless(os.path.exists(ps_path))
+    os.remove(ps_path)
+    self.failIf(os.path.exists(ps_path))
 
-  def stepCommitTransaction(self, **kw):
-    get_transaction().commit()
+  def stepCheckPropertySheetExists(self, sequence=None, sequencer_list=None, **kw):
+    """
+    Check presence of Property Sheet
+    """
+    ps_path = sequence.get('ps_path', None)
+    self.failUnless(ps_path is not None)
+    self.failUnless(os.path.exists(ps_path))
 
-  def stepSwitchBT(self, sequence=None, sequence_list=None, **kw):
+  def stepCheckPropertySheetRemoved(self, sequence=None, sequencer_list=None, **kw):
     """
-    Replace the current BT by the new.
-    And delete the old one.
+    Check presence of Property Sheet
+    """
+    ps_path = sequence.get('ps_path', None)
+    self.failUnless(ps_path is not None)
+    self.failIf(os.path.exists(ps_path))
+    
+  # Busines templates
+  def stepImportBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-    new_bt = sequence.get('new_bt')
-    current_bt = sequence.get('current_bt')
+    Import Business Template from a dir
+    """
+    template_path = sequence.get('template_path')
     template_tool = self.getTemplateTool()
-    template_tool.deleteContent(current_bt.getId())
-    sequence.edit(
-         current_bt=new_bt,
-         new_bt=None)
+    exported_bt_id = sequence.get('export_bt').getId()
+    import_id = 'imported_%s' %exported_bt_id
+    n = 0
+    while import_id in template_tool.objectIds():
+      n = n + 1    
+      import_id = "%s_%s" %(import_id, n)
+    template_tool.download(url='file:'+template_path, id=import_id)
+    import_bt = template_tool._getOb(id=import_id)
+    self.failIf(import_bt is None)
+    self.assertEquals(import_bt.getPortalType(), 'Business Template')
+    sequence.edit(import_bt=import_bt)
+    
+  def stepInstallBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
+    """
+    Install importzed business template
+    """
+    import_bt = sequence.get('import_bt')
+    import_bt.install(force=1)
 
-  def stepRemoveBaseCategoryFromNewBT(self, sequence=None, 
-                                      sequence_list=None, **kw):
+  def stepCreateNewBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-    Remove a base category from the business template.
+    Create a new Business Template
     """
-    new_bt = sequence.get('new_bt')
-#     new_base_category = sequence.get('new_base_category')
-    base_category_id_list = list(new_bt.getTemplateBaseCategoryList())
-    new_bt.edit(template_base_category_list=base_category_id_list[1:])
-    sequence.edit(installed_base_cat_id=base_category_id_list[0])
+    pt = self.getTemplateTool()
+    template = pt.newContent(portal_type='Business Template')
+    self.failUnless(template.getBuildingState() == 'draft')
+    self.failUnless(template.getInstallationState() == 'not_installed')
+    template.edit(title='geek template',
+                  version='1.0',
+                  description='bt for unit_test')
+    sequence.edit(export_bt=template)
 
-  def stepCheckIfBaseCategoryIsInstalled(self, sequence=None, 
-                                         sequence_list=None, **kw):
+  def stepBuildBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-    Check if a base category is installed.
+    Build Business Template
     """
-    base_category_id = sequence.get('installed_base_cat_id')
-    LOG('base_category_id', 0, base_category_id)
-    portal_categories = self.getCategoryTool()
-    LOG("category list", 0, portal_categories.contentIds())
-    self.failUnless(base_category_id in portal_categories.contentIds())
+    template = sequence.get('current_bt')  
+    template.build()
 
-  def stepCheckIfBaseCategoryIsNotInstalled(self, sequence=None, 
-                                         sequence_list=None, **kw):
+  def stepSaveBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-    Check if a base category is not installed.
+    Export Business Template
     """
-    base_category_id = sequence.get('installed_base_cat_id')
-    portal_categories = self.getCategoryTool()
-    self.failIf(base_category_id in portal_categories.contentIds())
+    template = sequence.get('current_bt')
+    cfg = getConfiguration()
+    bt_title = pathname2url(template.getTitle())
+    template_path = os.path.join(cfg.instancehome, 'tests', '%s' % (bt_title,))
+    template.export(path=template_path, local=1)
+    sequence.edit(template_path=template_path)
+    self.failUnless(os.path.exists(template_path))
 
-  def stepCheckIfTrashBinExists(self, sequence=None, sequence_list=None, **kw):
+  def stepCheckObjectPropertiesInBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-    Check If we create a trash bin at upgrade
+    Check that ac_local_roles, uid and _owner are set to None
     """
-    new_bt = sequence.get('new_bt')
-    self.failUnless(len(new_bt.portal_trash.objectIds()) == 1)
+    bt = sequence.get('current_bt')
+    item_list = [
+      '_workflow_item',
+      '_catalog_method_item',
+      '_portal_type_item',
+      '_category_item',
+      '_skin_item',
+      '_path_item',
+      '_action_item',
+    ]
+    for item_name in item_list:
+      item = getattr(bt, item_name)
+      if item is not None:
+        for key, data in item._objects.items():
+          if hasattr(data, '__ac_local_roles__'):
+            self.failUnless(data.__ac_local_roles__ is None)
+          if hasattr(data, '_owner'):
+            self.failUnless(data._owner is None)
+          if hasattr(aq_base(data), 'uid'):
+            self.failUnless(data.uid is None)
 
-  def stepRemoveAllTrashBins(self, sequence=None, sequence_list=None, **kw):
+  def stepRemoveBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-    Remove all previous trash bins generated
+    Remove current Business Template
     """
-    current_bt = sequence.get('current_bt')
-    trash = current_bt.getPortalObject().portal_trash
-    trash_ids = trash.objectIds()
-    for id in list(trash_ids):
-        trash.deleteContent(id)    
-    self.failIf(len(trash.objectIds()) > 0)
-    
-  def test_03_update(self, quiet=0, run=run_all_test):
+    bt_id = sequence.get('current_bt').getId()
+    template_tool = self.getTemplateTool()
+    template_tool.manage_delObjects([bt_id])
+    bt = template_tool._getOb(bt_id, None)
+    self.failUnless(bt is None)
+
+  def stepUninstallBusinessTemplate(self, sequence=None, sequence_list=None, **kw):
     """
-    Update BT
+    Uninstall current Business Template
     """
+    bt = sequence.get('current_bt')
+    bt.uninstall()
+
+  # tests
+  def test_01_checkNewSite(self, quiet=0, run=run_all_test):
     if not run: return
     if not quiet:
-      message = 'Test Update Template'
+      message = 'Test Check New Site'
       ZopeTestCase._print('\n%s ' % message)
       LOG('Testing... ', 0, message)
     sequence_list = SequenceList()
     sequence_string = '\
-                      GetCurrentBusinessTemplate \
-                      CopyBusinessTemplate \
-                      Tic \
-                      InstallNewBT \
-                      SwitchBT \
-                      '
+                       UseCoreBusinessTemplate  \
+                       CheckTools \
+                       CheckBuiltBuildingState \
+                       CheckInstalledInstallationState \
+                       CheckSkinsLayers \
+                       CheckNoTrashBin \
+                       '
     sequence_list.addSequenceString(sequence_string)
-    sequence_list.play(self)
+    sequence_list.play(self)    
 
-  def test_04_importExport(self, quiet=0, run=run_all_test):
-    """
-    Built, export/import, install
-    """
+  # test of portal types
+  def test_02_BusinessTemplateWithPortalTypes(self, quiet=0, run=run_all_test):
     if not run: return
     if not quiet:
-      message = 'Test Import/Export'
+      message = 'Test Business Template With Portal Types'
       ZopeTestCase._print('\n%s ' % message)
       LOG('Testing... ', 0, message)
     sequence_list = SequenceList()
     sequence_string = '\
-                      GetCurrentBusinessTemplate \
-                      CopyBusinessTemplate \
-                      EditNewBT \
-                      BuildNewBT \
-                      CheckBuiltBuildingState \
-                      ExportNewBT \
-                      ImportNewBT \
-                      Tic \
-                      InstallNewBT \
-                      SwitchBT \
-                      '
+                       CreatePortalType \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddPortalTypeToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemovePortalType \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckPortalTypeExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckPortalTypeRemoved \
+                       '
     sequence_list.addSequenceString(sequence_string)
-    sequence_list.play(self)
+    sequence_list.play(self)    
 
-  def test_05_addNewBaseCategory(self, quiet=0, run=run_all_test):
-    """
-    Test replacing a bt when the new one has a new base category.
-    This base category must be of course installed
-    """
+  # test of skins
+  def test_03_BusinessTemplateWithSkins(self, quiet=0, run=run_all_test):
     if not run: return
     if not quiet:
-      message = 'Test Update with new objects'
+      message = 'Test Business Template With Skin Folder'
       ZopeTestCase._print('\n%s ' % message)
       LOG('Testing... ', 0, message)
     sequence_list = SequenceList()
     sequence_string = '\
-                      GetCurrentBusinessTemplate \
-                      CopyBusinessTemplate \
-                      CreateNewBaseCategory \
-                      AddNewBaseCategoryToNewBT \
-                      CheckModifiedBuildingState \
-                      BuildNewBT \
-                      CheckBuiltBuildingState \
-                      ExportNewBT \
-                      ImportNewBT \
-                      Tic \
-                      InstallNewBT \
-                      CheckIfBaseCategoryIsInstalled \
-                      SwitchBT \
-                      '
+                       CreateSkinFolder \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddSkinFolderToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveSkinFolder \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckSkinFolderExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckSkinFolderRemoved \
+                       '
     sequence_list.addSequenceString(sequence_string)
-    sequence_list.play(self)
+    sequence_list.play(self)    
 
-  def test_06_removeBaseCategory(self, quiet=0, run=run_all_test):
-    """
-    Test replacing a bt when the new one has a base category left.
-    This base category must be kept on the site.
-    """
+  # test of workflow
+  def test_04_BusinessTemplateWithWorkflow(self, quiet=0, run=run_all_test):
     if not run: return
     if not quiet:
-      message = 'Test Update with less objects'
+      message = 'Test Business Template With Workflow'
       ZopeTestCase._print('\n%s ' % message)
       LOG('Testing... ', 0, message)
     sequence_list = SequenceList()
     sequence_string = '\
-                      GetCurrentBusinessTemplate \
-                      CopyBusinessTemplate \
-                      RemoveBaseCategoryFromNewBT \
-                      CheckModifiedBuildingState \
-                      BuildNewBT \
-                      CheckBuiltBuildingState \
-                      ExportNewBT \
-                      ImportNewBT \
-                      Tic \
-                      InstallNewBT \
-                      CheckIfBaseCategoryIsInstalled \
-                      SwitchBT \
-                      '
+                       CreateWorkflow \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddWorkflowToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveWorkflow \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckWorkflowExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckWorkflowRemoved \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
+
+  # test of module
+  def test_05_BusinessTemplateWithModule(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template With Module'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    sequence_string = '\
+                       CreatePortalType \
+                       CreateModuleAndObjects \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddPortalTypeToBusinessTemplate \
+                       AddModuleToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemovePortalType \
+                       RemoveModule \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckPortalTypeExists \
+                       CheckModuleExists \
+                       CheckModuleObjectsRemoved \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckModuleRemoved \
+                       CheckPortalTypeRemoved \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
+
+  # test of categories
+  def test_06_BusinessTemplateWithBaseCategory(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template With Base Category'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    sequence_string = '\
+                       CreateBaseCategory \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddBaseCategoryToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveBaseCategory \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckBaseCategoryExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckBaseCategoryRemoved \
+                       '
     sequence_list.addSequenceString(sequence_string)
     sequence_list.play(self)
+    
+  # test of actions
+  def test_07_BusinessTemplateWithoutOptionalAction(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template Without Optional Action'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    sequence_string = '\
+                       CreatePortalType \
+                       CreateActions \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       AddPortalTypeToBusinessTemplate \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemovePortalType \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckPortalTypeExists \
+                       CheckActionExists \
+                       CheckOptionalActionNotExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckPortalTypeRemoved \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
 
-  def test_07_installWithoutExport(self, quiet=0, run=run_all_test):
-    """
-    Built, install
-    Check the diff
-    """
+  def test_08_BusinessTemplateWithOptionalAction(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template With Optional Action'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    sequence_string = '\
+                       CreatePortalType \
+                       CreateActions \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       AddOptionalActionToBusinessTemplate \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemovePortalType \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       CreatePortalType \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckActionNotExists \
+                       CheckOptionalActionExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckOptionalActionNotExists \
+                       RemovePortalType \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
+
+  def test_09_BusinessTemplateWithPath(self, quiet=0, run=run_all_test):
     if not run: return
     if not quiet:
-      message = 'Test Build and Update without export'
+      message = 'Test Business Template With A Simple Path'
       ZopeTestCase._print('\n%s ' % message)
       LOG('Testing... ', 0, message)
     sequence_list = SequenceList()
+    # a simple path
     sequence_string = '\
-                      GetCurrentBusinessTemplate \
-                      CopyBusinessTemplate \
-                      EditNewBT \
-                      BuildNewBT \
-                      CheckBuiltBuildingState \
-                      Tic \
-                      InstallNewBT \
-                      SwitchBT \
-                      '
+                       CreateBaseCategory \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       AddBaseCategoryAsPathToBusinessTemplate \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveBaseCategory \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckBaseCategoryExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckBaseCategoryRemoved \
+                       '
     sequence_list.addSequenceString(sequence_string)
     sequence_list.play(self)
 
+  def test_10_BusinessTemplateWithPathAndJoker1(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template With Path And Joker *'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()    
+    # path with subobjects
+    sequence_string = '\
+                       CreateBaseCategory \
+                       CreateCategories \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       AddCategoriesAsPathToBusinessTemplate \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveCategories \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckCategoriesExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckCategoriesRemoved \
+                       RemoveBaseCategory \
+                       '    
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)
 
-  def test_08_checkNoSubobjectsUninstall(self, quiet=0, run=run_all_test):
-    """
-    Test if we don't remove subobjects when upgrading a
-    business tempalte
-    """
+  def test_11_BusinessTemplateWithPathAndJoker2(self, quiet=0, run=run_all_test):
     if not run: return
     if not quiet:
-      message = 'Test if subobjects remains after upgrade'
+      message = 'Test Business Template With Path And Joker **'
       ZopeTestCase._print('\n%s ' % message)
       LOG('Testing... ', 0, message)
     sequence_list = SequenceList()
+    # path with subobject recursively
     sequence_string = '\
-                      GetCurrentBusinessTemplate \
-                      RemoveAllTrashBins \
-                      CopyBusinessTemplate \
-                      CreateNewBaseCategory \
-                      AddCategoryToBaseCategory \
-                      AddNewBaseCategoryToNewBT \
-                      EditNewBT \
-                      BuildNewBT \
-                      CheckBuiltBuildingState \
-                      ExportNewBT \
-                      ImportNewBT \
-                      Tic \
-                      InstallNewBT \
-                      CheckIfBaseCategoryIsInstalled \
-                      CheckIfSubCategoryExists \
-                      CheckIfTrashBinExists \
-                      SwitchBT \
-                      '
+                       CreateBaseCategory \
+                       CreateCategories \
+                       CreateSubCategories \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       AddSubCategoriesAsPathToBusinessTemplate \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveCategories \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckCategoriesExists \
+                       CheckSubCategoriesExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckCategoriesRemoved \
+                       RemoveBaseCategory \
+                       '
     sequence_list.addSequenceString(sequence_string)
     sequence_list.play(self)    
 
+  def test_12_BusinessTemplateWithCatalogMethod(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template With Catalog Method, Related Key, Result Key And Table'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    sequence_string = '\
+                       CreateCatalogMethod \
+                       CreateKeysAndTable \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddCatalogMethodToBusinessTemplate \
+                       AddKeysAndTableToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveCatalogMethod \
+                       RemoveKeysAndTable \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckCatalogMethodExists \
+                       CheckKeysAndTableExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckKeysAndTableRemoved \
+                       CheckCatalogMethodRemoved \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
+
+  def test_13_BusinessTemplateWithRole(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template With Role'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    sequence_string = '\
+                       CreateRole \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddRoleToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveRole \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckRoleExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckRoleRemoved \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
+
+  def test_14_BusinessTemplateWithPropertySheet(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template With Property Sheet'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    sequence_string = '\
+                       CreatePropertySheet \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddPropertySheetToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemovePropertySheet \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckPropertySheetExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckPropertySheetRemoved \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
+
+
+  def test_15_BusinessTemplateWithAllItems(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Business Template With All Items'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    sequence_string = '\
+                       CreatePortalType \
+                       CreateModuleAndObjects \
+                       CreateSkinFolder \
+                       CreateBaseCategory \
+                       CreateCategories \
+                       CreateSubCategories \
+                       CreateWorkflow \
+                       CreateActions \
+                       CreateCatalogMethod \
+                       CreateKeysAndTable \
+                       CreateRole \
+                       CreatePropertySheet \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddPortalTypeToBusinessTemplate \
+                       AddModuleToBusinessTemplate \
+                       AddSkinFolderToBusinessTemplate \
+                       AddBaseCategoryToBusinessTemplate \
+                       AddSubCategoriesAsPathToBusinessTemplate \
+                       AddWorkflowToBusinessTemplate \
+                       AddOptionalActionToBusinessTemplate \
+                       AddCatalogMethodToBusinessTemplate \
+                       AddKeysAndTableToBusinessTemplate \
+                       AddRoleToBusinessTemplate \
+                       AddPropertySheetToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemovePortalType \
+                       RemoveModule \
+                       RemoveSkinFolder \
+                       RemoveBaseCategory \
+                       RemoveWorkflow \
+                       RemoveCatalogMethod \
+                       RemoveKeysAndTable \
+                       RemoveRole \
+                       RemovePropertySheet \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckPortalTypeExists \
+                       CheckModuleExists \
+                       CheckSkinFolderExists \
+                       CheckBaseCategoryExists \
+                       CheckCategoriesExists \
+                       CheckSubCategoriesExists \
+                       CheckWorkflowExists \
+                       CheckOptionalActionExists \
+                       CheckCatalogMethodExists \
+                       CheckKeysAndTableExists \
+                       CheckRoleExists \
+                       CheckPropertySheetExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckPortalTypeRemoved \
+                       CheckModuleRemoved \
+                       CheckSkinFolderRemoved \
+                       CheckBaseCategoryRemoved \
+                       CheckWorkflowRemoved \
+                       CheckCatalogMethodRemoved \
+                       CheckKeysAndTableRemoved \
+                       CheckRoleRemoved \
+                       CheckPropertySheetRemoved \
+                       CheckSkinsLayers \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
+
+
+
+  def test_16_SubobjectsAfterUpgradOfBusinessTemplate(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Upgrade Of Business Template Keeps Subobjects'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    # check if subobjects in module and catalog still remains after an update
+    sequence_string = '\
+                       CreatePortalType \
+                       CreateModuleAndObjects \
+                       CreateBaseCategory \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddPortalTypeToBusinessTemplate \
+                       AddModuleToBusinessTemplate \
+                       AddBaseCategoryToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemoveModule \
+                       RemoveBaseCategory \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckPortalTypeExists \
+                       CheckModuleExists \
+                       CheckModuleObjectsRemoved \
+                       CheckBaseCategoryExists \
+                       CreateModuleObjects \
+                       CreateCategories \
+                       CreateSubCategories \
+                       CreateNewBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckPortalTypeExists \
+                       CheckModuleExists \
+                       CheckBaseCategoryExists \
+                       CheckModuleObjectsExists \
+                       CheckCategoriesExists \
+                       CheckSubCategoriesExists \
+                       UninstallBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckPortalTypeRemoved \
+                       CheckModuleRemoved \
+                       CheckBaseCategoryRemoved \
+                       CheckSkinsLayers \
+                       '    
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)
+
+
+
+
+  def test_17_upgradeBusinessTemplateWithAllItems(self, quiet=0, run=run_all_test):
+    if not run: return
+    if not quiet:
+      message = 'Test Upgrade Business Template With All Items'
+      ZopeTestCase._print('\n%s ' % message)
+      LOG('Testing... ', 0, message)
+    sequence_list = SequenceList()
+    # by default action is backup, so everything will be replace
+    sequence_string = '\
+                       CreatePortalType \
+                       CreateModuleAndObjects \
+                       CreateSkinFolder \
+                       CreateBaseCategory \
+                       CreateCategories \
+                       CreateSubCategories \
+                       CreateWorkflow \
+                       CreateActions \
+                       CreateCatalogMethod \
+                       CreateKeysAndTable \
+                       CreateRole \
+                       CreatePropertySheet \
+                       CreateNewBusinessTemplate \
+                       UseExportBusinessTemplate \
+                       AddPortalTypeToBusinessTemplate \
+                       AddModuleToBusinessTemplate \
+                       AddSkinFolderToBusinessTemplate \
+                       AddBaseCategoryToBusinessTemplate \
+                       AddSubCategoriesAsPathToBusinessTemplate \
+                       AddWorkflowToBusinessTemplate \
+                       AddOptionalActionToBusinessTemplate \
+                       AddCatalogMethodToBusinessTemplate \
+                       AddKeysAndTableToBusinessTemplate \
+                       AddRoleToBusinessTemplate \
+                       AddPropertySheetToBusinessTemplate \
+                       CheckModifiedBuildingState \
+                       CheckNotInstalledInstallationState \
+                       BuildBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       CheckObjectPropertiesInBusinessTemplate \
+                       SaveBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       RemovePortalType \
+                       RemoveModule \
+                       RemoveSkinFolder \
+                       RemoveBaseCategory \
+                       RemoveWorkflow \
+                       RemoveCatalogMethod \
+                       RemoveKeysAndTable \
+                       RemoveRole \
+                       RemovePropertySheet \
+                       RemoveBusinessTemplate \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckSkinsLayers \
+                       CheckPortalTypeExists \
+                       CheckModuleExists \
+                       CheckSkinFolderExists \
+                       CheckBaseCategoryExists \
+                       CheckCategoriesExists \
+                       CheckSubCategoriesExists \
+                       CheckWorkflowExists \
+                       CheckOptionalActionExists \
+                       CheckCatalogMethodExists \
+                       CheckKeysAndTableExists \
+                       CheckRoleExists \
+                       CheckPropertySheetExists \
+                       RemoveAllTrashBins \
+                       ImportBusinessTemplate \
+                       UseImportBusinessTemplate \
+                       CheckBuiltBuildingState \
+                       CheckNotInstalledInstallationState \
+                       InstallBusinessTemplate \
+                       Tic \
+                       CheckInstalledInstallationState \
+                       CheckBuiltBuildingState \
+                       CheckTrashBin \
+                       CheckPortalTypeExists \
+                       CheckModuleExists \
+                       CheckSkinFolderExists \
+                       CheckBaseCategoryExists \
+                       CheckCategoriesExists \
+                       CheckSubCategoriesExists \
+                       CheckWorkflowExists \
+                       CheckOptionalActionExists \
+                       CheckCatalogMethodExists \
+                       CheckKeysAndTableExists \
+                       CheckRoleExists \
+                       CheckPropertySheetExists \
+                       CheckSkinsLayers \
+                       '
+    sequence_list.addSequenceString(sequence_string)
+    sequence_list.play(self)    
 
 if __name__ == '__main__':
-    framework()
+  framework()
 else:
-    import unittest
-    def test_suite():
-        suite = unittest.TestSuite()
-        suite.addTest(unittest.makeSuite(TestBusinessTemplate))
-        return suite
+  import unittest
+  def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(TestBusinessTemplate))
+    return suite