# -*- coding: utf-8 -*- ############################################################################## # # Copyright (c) 2010 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 # consequences resulting from its eventual inadequacies and bugs # End users who are looking for a ready-to-use solution with commercial # garantees and support are strongly adviced to contract a Free Software # Service Company # # This program is Free Software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # ############################################################################## import os import shutil import unittest import random import tempfile from App.config import getConfiguration from Products.ERP5VCS.WorkingCopy import getVcsTool from Products.ERP5.Document.BusinessTemplate import \ BusinessTemplateMissingDependency from Products.ERP5.Tool.TemplateTool import BusinessTemplateUnknownError from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase class TestTemplateTool(ERP5TypeTestCase): """Test the template tool """ test_tool_id = 'test_portal_templates' def getBusinessTemplateList(self): return ('erp5_core_proxy_field_legacy', 'erp5_full_text_mroonga_catalog', 'erp5_base', 'erp5_stock_cache', 'erp5_csv_style') def getTitle(self): return "Template Tool" def afterSetUp(self): self.templates_tool = self.portal.portal_templates self.setupAutomaticBusinessTemplateRepository( searchable_business_template_list=["erp5_core", "erp5_base"]) if getattr(self.portal, self.test_tool_id, None) is not None: self.portal.manage_delObjects(ids=[self.test_tool_id]) self.portal.newContent(portal_type='Template Tool', id=self.test_tool_id) self.dummy_template_tool = getattr(self.portal, self.test_tool_id) def beforeTearDown(self): self.tic() mark_replaced_bt_list = ["erp5_odt_style", "erp5_pdm", 'erp5_accounting', 'erp5_workflow', 'erp5_configurator', 'erp5_configurator_ung', 'erp5_ingestion_mysql_innodb_catalog', "erp5_configurator_standard"] for bt_name in mark_replaced_bt_list: bt = self.templates_tool.getInstalledBusinessTemplate(bt_name) if (bt is not None) and bt.getInstallationState() in ['installed', 'replaced']: self.templates_tool.manage_delObjects([bt.getId()]) self.tic() bt = self.templates_tool.getInstalledBusinessTemplate("erp5_base") if bt.getInstallationState() == "replaced": bt.install(force=1) self.tic() def checkFolderReindexAllActivityPresense(self): message_list = [m for m in self.portal.portal_activities.getMessageList() if m.method_id == 'Folder_reindexAll'] self.assertNotEquals(len(message_list), 0) def checkFolderReindexAllActivityNotPresent(self): message_list = [m for m in self.portal.portal_activities.getMessageList() if m.method_id == 'Folder_reindexAll'] self.assertEqual(len(message_list), 0) def testUpdateBT5FromRepository(self): """ Test the list of bt5 returned for upgrade """ # edit bt5 revision so that it will be marked as updatable erp5_base = self.templates_tool.getInstalledBusinessTemplate('erp5_base', strict=True) erp5_base._setRevision('') self.assertTrue("erp5_base" in (bt.getTitle() for bt in self.templates_tool.getRepositoryBusinessTemplateList(update_only=True))) erp5_base.replace() self.assertFalse("erp5_base" in (bt.getTitle() for bt in self.templates_tool.getRepositoryBusinessTemplateList(update_only=True))) self.abort() def test_download_http(self): test_web = self.portal.portal_templates.download( 'http://www.erp5.org/dists/snapshot/test_bt5/test_web.bt5') self.assertEqual(test_web.getPortalType(), 'Business Template') self.assertEqual(test_web.getTitle(), 'test_web') self.assertEqual(len(test_web.getRevision()), 28) def _svn_setup_ssl(self): """ Function used to trust in svn.erp5.org. """ for trust_dict in [ # for subversion 1.6 {'failures': 8, 'finger_print': 'a1:f7:c6:bb:51:69:84:28:ac:58:af:9d:05:73:de:24:45:4d:a1:bb', 'hostname': 'roundcube.nexedi.com', 'issuer_dname': 'Nexedi SA, Marcq en Baroeul, Nord Pas de Calais, FR', 'realm': 'https://svn.erp5.org:443', 'valid_from': 'Thu, 22 May 2008 13:43:01 GMT', 'valid_until': 'Sun, 20 May 2018 13:43:01 GMT'}, # for subversion 1.8 {'failures': 8, 'finger_print': 'A1:F7:C6:BB:51:69:84:28:AC:58:AF:9D:05:73:DE:24:45:4D:A1:BB', 'hostname': 'mail.nexedi.com', 'issuer_dname': 'Nexedi SA, Marcq en Baroeul, Nord Pas de Calais, FR(webmaster@nexedi.com)', 'realm': 'https://svn.erp5.org:443', 'valid_from': 'May 22 13:43:01 2008 GMT', 'valid_until': 'May 20 13:43:01 2018 GMT'} ]: getVcsTool("svn").__of__(self.portal).acceptSSLServer(trust_dict) def test_download_svn(self): # if the page looks like a svn repository, template tool will use pysvn to # get the bt5. self._svn_setup_ssl() bt5_url = 'https://svn.erp5.org/repos/public/erp5/trunk/bt5/test_web' test_web = self.portal.portal_templates.download(bt5_url) self.assertEqual(test_web.getPortalType(), 'Business Template') self.assertEqual(test_web.getTitle(), 'test_web') self.assertEqual(len(test_web.getRevision()), 28) def test_updateBusinessTemplateFromUrl_simple(self): """ Test updateBusinessTemplateFromUrl method By default if a new business template has revision != previous one the new bt5 is not installed, only imported. """ self._svn_setup_ssl() template_tool = self.portal.portal_templates old_bt = template_tool.getInstalledBusinessTemplate('erp5_csv_style') # fake different revision old_bt.setRevision('') url = 'https://svn.erp5.org/repos/public/erp5/trunk/bt5/erp5_csv_style' template_tool.updateBusinessTemplateFromUrl(url) new_bt = template_tool.getInstalledBusinessTemplate('erp5_csv_style') self.assertNotEquals(old_bt, new_bt) self.assertEqual('erp5_csv_style', new_bt.getTitle()) # Test Another time with definning an ID old_bt = new_bt old_bt.setRevision('') template_tool.updateBusinessTemplateFromUrl(url, id="new_erp5_csv_style") new_bt = template_tool.getInstalledBusinessTemplate('erp5_csv_style') self.assertNotEquals(old_bt, new_bt) self.assertEqual('erp5_csv_style', new_bt.getTitle()) self.assertEqual('new_erp5_csv_style', new_bt.getId()) # Test if the new instance with same revision is not installed. old_bt = new_bt template_tool.updateBusinessTemplateFromUrl(url, id="not_installed_bt5") new_bt = template_tool.getInstalledBusinessTemplate('erp5_csv_style') self.assertEqual(old_bt, new_bt) self.assertEqual('erp5_csv_style', new_bt.getTitle()) self.assertEqual('new_erp5_csv_style', new_bt.getId()) not_installed_bt5 = template_tool['not_installed_bt5'] self.assertEqual('erp5_csv_style', not_installed_bt5.getTitle()) self.assertEqual(not_installed_bt5.getInstallationState(), "not_installed") self.assertEqual(not_installed_bt5.getRevision(), new_bt.getRevision()) def test_updateBusinessTemplateFromUrl_keep_list(self): """ Test updateBusinessTemplateFromUrl method """ self._svn_setup_ssl() template_tool = self.portal.portal_templates url = 'https://svn.erp5.org/repos/public/erp5/trunk/bt5/test_core' # don't install test_file keep_original_list = ('portal_skins/erp5_test/test_file', ) template_tool.updateBusinessTemplateFromUrl(url, keep_original_list=keep_original_list) bt = template_tool.getInstalledBusinessTemplate('test_core') self.assertNotEquals(None, bt) erp5_test = self.portal.portal_skins['erp5_test'] self.assertFalse(erp5_test.hasObject('test_file')) def test_updateBusinessTemplateFromUrl_after_before_script(self): """ Test updateBusinessTemplateFromUrl method """ from Products.ERP5Type.tests.utils import createZODBPythonScript portal = self.getPortal() self._svn_setup_ssl() createZODBPythonScript(portal.portal_skins.custom, 'BT_dummyA', 'scripts_params=None', '# Script body\n' 'return context.setDescription("MODIFIED")') createZODBPythonScript(portal.portal_skins.custom, 'BT_dummyB', 'scripts_params=None', '# Script body\n' 'return context.setChangeLog("MODIFIED")') createZODBPythonScript(portal.portal_skins.custom, 'BT_dummyC', 'scripts_params=None', '# Script body\n' 'return context.getPortalObject().setTitle("MODIFIED")') template_tool = self.portal.portal_templates url = 'https://svn.erp5.org/repos/public/erp5/trunk/bt5/test_html_style' # don't install test_file before_triggered_bt5_id_list = ['BT_dummyA', 'BT_dummyB'] after_triggered_bt5_id_list = ['BT_dummyC'] template_tool.updateBusinessTemplateFromUrl(url, before_triggered_bt5_id_list=before_triggered_bt5_id_list, after_triggered_bt5_id_list=after_triggered_bt5_id_list) bt = template_tool.getInstalledBusinessTemplate('test_html_style') self.assertNotEquals(None, bt) self.assertEqual(bt.getDescription(), 'MODIFIED') self.assertEqual(bt.getChangeLog(), 'MODIFIED') self.assertEqual(portal.getTitle(), 'MODIFIED') def test_CompareVersions(self): """Tests compare version on template tool. """ compareVersions = self.getPortal().portal_templates.compareVersions self.assertEqual(0, compareVersions('1', '1')) self.assertEqual(0, compareVersions('1.2', '1.2')) self.assertEqual(0, compareVersions('1.2rc3', '1.2rc3')) self.assertEqual(0, compareVersions('1.0.0', '1.0')) self.assertEqual(-1, compareVersions('1.0', '1.0.1')) self.assertEqual(-1, compareVersions('1.0rc1', '1.0')) self.assertEqual(-1, compareVersions('1.0a', '1.0.1')) self.assertEqual(-1, compareVersions('1.1', '2.0')) def test_CompareVersionStrings(self): """Test compareVersionStrings on template tool""" compareVersionStrings = \ self.getPortal().portal_templates.compareVersionStrings self.assertTrue(compareVersionStrings('1.1', '> 1.0')) self.assertFalse(compareVersionStrings('1.1rc1', '= 1.0')) self.assertFalse(compareVersionStrings('1.0rc1', '> 1.0')) self.assertFalse(compareVersionStrings('1.0rc1', '>= 1.0')) self.assertTrue(compareVersionStrings('1.0rc1', '>= 1.0rc1')) def test_getInstalledBusinessTemplate_installed(self): test_bt = self.portal.portal_templates.newContent( portal_type='Business Template', title='erp5_test_bt_%s' % self.id()) test_bt.install() self.tic() self.assertEqual(test_bt, self.portal.portal_templates.getInstalledBusinessTemplate('erp5_test_bt_%s' % self.id())) def test_getInstalledBusinessTemplate_erp5_core_installed(self): erp5_core = self.portal.portal_templates.getInstalledBusinessTemplate('erp5_core') self.assertNotEqual(None, erp5_core) self.assertEqual('Business Template', erp5_core.getPortalType()) def test_getInstalledBusinessTemplate_not_installed(self): self.assertEquals(None, self.portal.portal_templates.getInstalledBusinessTemplate('not_installed')) def test_getInstalledBusinessTemplate_provision(self): test_bt = self.portal.portal_templates.newContent( portal_type='Business Template', title='test_bt_%s' % self.id(), provision_list=['erp5_test_bt_%s' % self.id()]) test_bt.install() self.tic() self.assertEqual(test_bt, self.portal.portal_templates.getInstalledBusinessTemplate('erp5_test_bt_%s' % self.id())) def test_getInstalledBusinessTemplate_replaced(self): test_bt_v1 = self.portal.portal_templates.newContent( portal_type='Business Template', title='test_bt_%s' % self.id(), version='1') test_bt_v1.install() self.tic() test_bt_v2 = self.portal.portal_templates.newContent( portal_type='Business Template', title='test_bt_%s' % self.id(), version='2') test_bt_v2.install() self.assertEqual('replaced', test_bt_v1.getInstallationState()) self.tic() self.assertEqual(test_bt_v2, self.portal.portal_templates.getInstalledBusinessTemplate('test_bt_%s' % self.id())) def test_getInstalledBusinessTemplate_uninstalled(self): test_bt = self.portal.portal_templates.newContent( portal_type='Business Template', title='test_bt_%s' % self.id()) test_bt.install() test_bt.uninstall() self.tic() self.assertEqual(None, self.portal.portal_templates.getInstalledBusinessTemplate('test_bt_%s' % self.id())) def test_getInstalledBusinessTemplate_replaced_then_uninstalled(self): test_bt_v1 = self.portal.portal_templates.newContent( portal_type='Business Template', title='test_bt_%s' % self.id(), version='1') test_bt_v1.install() self.tic() test_bt_v2 = self.portal.portal_templates.newContent( portal_type='Business Template', title='test_bt_%s' % self.id(), version='2') test_bt_v2.install() self.assertEqual('replaced', test_bt_v1.getInstallationState()) self.tic() test_bt_v2.uninstall() self.assertEqual(None, self.portal.portal_templates.getInstalledBusinessTemplate('test_bt_%s' % self.id())) def test_revision(self): template_tool = self.portal.portal_templates getInstalledRevision = template_tool.getInstalledBusinessTemplateRevision self.assertEqual(None, getInstalledRevision('erp5_toto')) available_bt, = template_tool.getRepositoryBusinessTemplateList( template_list=('test_core',)) revision = available_bt.getRevision() self.assertEqual('ZjtyN3qfJKXd8TjB7JPX/mG0FkE=', revision) installed_bt = template_tool.download("%s/%s" % (available_bt.repository, available_bt.filename)) self.assertEqual(revision, installed_bt.getRevision()) installed_bt.install() self.assertEqual(revision, getInstalledRevision('test_core')) bt = installed_bt.Base_createCloneDocument(batch_mode=1) bt.build(update_revision=False) root = tempfile.mkdtemp() try: bt.export(root, local=1) with open(os.path.join(root, 'bt', 'title')) as f: self.assertTrue('test_core', f.read()) # We don't export revision anymore. self.assertFalse(os.path.exists(os.path.join(root, 'bt', 'revision'))) # Computed at download ... self.assertEqual(revision, template_tool.download(root).getRevision()) finally: shutil.rmtree(root) bt._setVersion("2.0") # ... at building by default ... bt.build() revision = bt.getRevision() self.assertEqual('9rVhiz7Agr5G7L1jegm9yLuUD9U=', revision) self.portal.portal_skins.erp5_test.manage_renameObject('test_file', 'test_file2') bt.build(update_revision=False) self.assertEqual(revision, bt.getRevision()) # ... and at export. bt.export(str(random.random())) self.assertEqual('dhgvzCfmibJEiy5M+5axf9ZM3gA=', bt.getRevision()) self.abort() def test_getInstalledBusinessTemplateList(self): templates_tool = self.getPortal().portal_templates bt5_list = templates_tool.getInstalledBusinessTemplateList() another_bt_list = [i for i in templates_tool.contentValues() \ if i.getInstallationState() == 'installed'] self.assertEqual(len(bt5_list), len(another_bt_list)) for bt in bt5_list: self.assertTrue(bt in another_bt_list) self.assertEqual(bt5_list, templates_tool._getInstalledBusinessTemplateList()) def test_getInstalledBusinessTemplateTitleList(self): templates_tool = self.getPortal().portal_templates bt5_list = templates_tool.getInstalledBusinessTemplateTitleList() another_bt_list = [i.getTitle() for i in templates_tool.contentValues() \ if i.getInstallationState() == 'installed'] bt5_list.sort() another_bt_list.sort() self.assertEqual(bt5_list, another_bt_list) for bt in bt5_list: self.assertTrue(bt in another_bt_list) new_list = templates_tool._getInstalledBusinessTemplateList(only_title=1) new_list.sort() self.assertEqual(bt5_list, new_list) def test_getBusinessTemplateUrl(self): """ Test if this method can find which repository is the business template """ # How to define an existing and use INSTANCE_HOME_REPOSITORY? url_list = ['https://svn.erp5.org/repos/public/erp5/trunk/bt5', 'http://www.erp5.org/dists/snapshot/bt5', 'http://www.erp5.org/dists/release/5.4.5/bt5', "INSTANCE_HOME_REPOSITORY", 'file:///opt/does/not/exist'] exist_bt5 = 'erp5_base' not_exist_bt5 = "erp5_not_exist" template_tool = self.portal.portal_templates getBusinessTemplateUrl = template_tool.getBusinessTemplateUrl # Test Exists self.assertEqual(getBusinessTemplateUrl(url_list, exist_bt5), 'https://svn.erp5.org/repos/public/erp5/trunk/bt5/erp5_base') self.assertEqual(getBusinessTemplateUrl(url_list[1:], exist_bt5), 'http://www.erp5.org/dists/snapshot/bt5/erp5_base.bt5') self.assertEqual(getBusinessTemplateUrl(url_list[2:], exist_bt5), 'http://www.erp5.org/dists/release/5.4.5/bt5/erp5_base.bt5') INSTANCE_HOME = getConfiguration().instancehome local_bt = None if os.path.exists(INSTANCE_HOME + "/bt5/erp5_base"): local_bt = 'file://' + INSTANCE_HOME + "/bt5/erp5_base" self.assertEqual(getBusinessTemplateUrl(url_list[3:], exist_bt5), local_bt) self.assertEqual(getBusinessTemplateUrl(url_list[4:], exist_bt5), None) # Test Not exists self.assertEqual(getBusinessTemplateUrl(url_list, not_exist_bt5), None) self.assertEqual(getBusinessTemplateUrl(url_list[1:], not_exist_bt5), None) self.assertEqual(getBusinessTemplateUrl(url_list[2:], not_exist_bt5), None) self.assertEqual(getBusinessTemplateUrl(url_list[3:], not_exist_bt5), None) self.assertEqual(getBusinessTemplateUrl(url_list[4:], not_exist_bt5), None) def test_resolveBusinessTemplateListDependency(self): """ Test API able to return a complete list of bt5s to setup a sub set of business templates. """ repository = "dummy_repository" template_tool = self.dummy_template_tool # setup dummy internal repository data to make unit test independant # from any real repository def addRepositoryEntry(**kw): kw['id'] = '%s.bt5' % kw['title'] kw.setdefault('version', '1') kw.setdefault('provision_list', ()) kw.setdefault('dependency_list', ()) kw.setdefault('revision', '1') return kw template_tool.repository_dict[repository] = ( addRepositoryEntry(title='foo', dependency_list=()), addRepositoryEntry(title='bar', dependency_list=('foo',)), addRepositoryEntry(title='baz', dependency_list=('bar',)), addRepositoryEntry(title='biz', dependency_list=()), addRepositoryEntry(title='ca1', provision_list=('sql',)), addRepositoryEntry(title='ca2', provision_list=('sql',)), addRepositoryEntry(title='a', dependency_list=()), addRepositoryEntry(title='b', dependency_list=('a'), revision='5'), addRepositoryEntry(title='end', dependency_list=('baz','sql', 'b')), ) # Simulate that we have some installed bt. for bt_id in ('foo', 'ca1', 'b'): bt = template_tool.newContent(portal_type='Business Template', title=bt_id, revision='4', id=bt_id) bt.install() bt5_id_list = ['baz'] bt5_list = template_tool.resolveBusinessTemplateListDependency(bt5_id_list) self.assertEqual([(repository, 'foo.bt5'), (repository, 'bar.bt5'), (repository, 'baz.bt5')], bt5_list) bt5_id_list = ['foo'] bt5_list = template_tool.resolveBusinessTemplateListDependency( bt5_id_list) self.assertEqual([(repository, 'foo.bt5')], bt5_list) bt5_id_list = ['biz', 'end'] bt5_list = template_tool.resolveBusinessTemplateListDependency(bt5_id_list) self.assertEqual([(repository, 'foo.bt5'), (repository, 'a.bt5'), (repository, 'bar.bt5'), (repository, 'b.bt5'), (repository, 'ca1.bt5'), (repository, 'baz.bt5'), (repository, 'end.bt5'), (repository, 'biz.bt5')], bt5_list) # By removing ca1, we remove the choice for the "sql" provider. # Therefore template tool does not know any more what to take for "sql". template_tool.manage_delObjects(['ca1']) self.commit() self.assertRaises(BusinessTemplateMissingDependency, template_tool.resolveBusinessTemplateListDependency, bt5_id_list) bt5_id_list = ['erp5_do_not_exist'] self.assertRaises(BusinessTemplateUnknownError, template_tool.resolveBusinessTemplateListDependency, bt5_id_list) def test_installBusinessTemplatesFromRepository_simple(self): """ Simple test for portal_templates.installBusinessTemplatesFromRepository """ bt5_name = 'erp5_odt_style' self.tic() bt = self.templates_tool.getInstalledBusinessTemplate(bt5_name, strict=True) self.assertEqual(bt, None) operation_log = \ self.templates_tool.installBusinessTemplateListFromRepository([bt5_name]) self.assertTrue("Installed %s with" % bt5_name in operation_log[-1]) bt = self.templates_tool.getInstalledBusinessTemplate(bt5_name, strict=True) self.assertNotEquals(bt, None) self.assertEqual(bt.getTitle(), bt5_name) # Repeat operation, the bt5 should be ignored self.templates_tool.installBusinessTemplateListFromRepository([bt5_name]) bt_old = self.templates_tool.getInstalledBusinessTemplate(bt5_name, strict=True) self.assertEqual(bt.getId(), bt_old.getId()) # Repeat operation, new bt5 should be inslalled due only_different = False operation_log = self.templates_tool.installBusinessTemplateListFromRepository( [bt5_name], only_different=False) self.assertTrue("Installed %s with" % bt5_name in operation_log[-1]) bt_new = self.templates_tool.getInstalledBusinessTemplate(bt5_name, strict=True) self.assertNotEquals(bt.getId(), bt_new.getId()) def test_installBusinessTemplatesFromRepository_update_catalog(self): """ Test if update catalog is trigger when needed. """ try: bt5_name = 'erp5_ingestion_mysql_innodb_catalog' template_tool = self.portal.portal_templates self.tic() bt = template_tool.getInstalledBusinessTemplate(bt5_name) self.assertEqual(bt, None) operation_log = template_tool.installBusinessTemplateListFromRepository([bt5_name], only_different=False, update_catalog=0) self.assertTrue("Installed %s with" % bt5_name in operation_log[0]) bt = template_tool.getInstalledBusinessTemplate(bt5_name) self.assertNotEquals(bt.getId(), None) self.commit() self.checkFolderReindexAllActivityNotPresent() # Before launch activities make sure email table is created even # catalog is not created. catalog_tool = self.portal.portal_catalog catalog_tool.erp5_mysql_innodb.z0_drop_email() catalog_tool.erp5_mysql_innodb.z_create_email() self.tic() bt5_name = 'erp5_odt_style' operation_log = template_tool.installBusinessTemplateListFromRepository([bt5_name], only_different=False, update_catalog=1) self.assertTrue("Installed %s with" % bt5_name in operation_log[-1]) bt = template_tool.getInstalledBusinessTemplate(bt5_name) self.assertEqual(bt.getTitle(), bt5_name) self.commit() self.checkFolderReindexAllActivityPresense() self.tic() # Install again should not force catalog to be updated operation_log = template_tool.installBusinessTemplateListFromRepository( [bt5_name], only_different=False) self.assertTrue("Installed %s with" % bt5_name in operation_log[-1]) bt = template_tool.getInstalledBusinessTemplate(bt5_name) self.assertNotEquals(bt, None) self.assertEqual(bt.getTitle(), bt5_name) self.commit() self.checkFolderReindexAllActivityNotPresent() self.tic() finally: # Make sure no broken catalog it will be left behind and propaguated to # the next tests. if len(self.portal.portal_activities.getMessageList())>0: self.portal.portal_activities.manageClearActivities() self.commit() self.portal.ERP5Site_reindexAll(clear_catalog=1) self.tic() def test_installBusinessTemplatesFromRepository_activate(self): """ Test if update catalog is trigger when needed. """ bt5_name_list = ['erp5_odt_style', 'erp5_pdm'] self.tic() for bt5_name in bt5_name_list: bt = self.templates_tool.getInstalledBusinessTemplate(bt5_name) self.assertEqual(bt, None) self.templates_tool.installBusinessTemplateListFromRepository( bt5_name_list, activate=True) for bt5_name in bt5_name_list: bt = self.templates_tool.getInstalledBusinessTemplate(bt5_name) self.assertEqual(bt, None) self.tic() for bt5_name in bt5_name_list: bt = self.templates_tool.getInstalledBusinessTemplate(bt5_name) self.assertNotEquals(bt, None) self.assertEqual(bt.getTitle(), bt5_name) def test_installBusinessTemplatesFromRepository_install_dependency(self): """Test if dependencies are automatically installed properly """ # erp5_configurator_{ung,standard} depends on erp5_configurator which in # turn depends on erp5_workflow bt5_name_list = ['erp5_configurator_ung', 'erp5_configurator_standard'] template_tool = self.portal.portal_templates for repos in template_tool.getRepositoryList(): if "bootstrap" not in repos: repository = repos self.tic() for bt5_name in bt5_name_list: bt = template_tool.getInstalledBusinessTemplate(bt5_name) self.assertEqual(bt, None) bt = template_tool.getInstalledBusinessTemplate("erp5_configurator") self.assertEqual(bt, None) bt = template_tool.getInstalledBusinessTemplate("erp5_workflow") self.assertEqual(bt, None) self.assertRaises(BusinessTemplateMissingDependency, template_tool.installBusinessTemplateListFromRepository, bt5_name_list) # Try fail in activities. self.assertRaises(BusinessTemplateMissingDependency, template_tool.installBusinessTemplateListFromRepository, bt5_name_list, True, True, True) for bt5_name in bt5_name_list: bt = template_tool.getInstalledBusinessTemplate(bt5_name) self.assertEqual(bt, None) dependency_list = template_tool.getDependencyList( (repository, bt5_name)) self.assertNotEquals(dependency_list, []) template_tool.installBusinessTemplateListFromRepository( bt5_name_list, install_dependency=True) for bt5_name in bt5_name_list: bt = template_tool.getInstalledBusinessTemplate(bt5_name) self.assertNotEquals(bt, None) bt = template_tool.getInstalledBusinessTemplate("erp5_configurator") self.assertNotEquals(bt, None) bt = template_tool.getInstalledBusinessTemplate("erp5_workflow") self.assertNotEquals(bt, None) self.abort() # Same as above but also check that dependencies are properly resolved if # one of the dependency is explicitly added to the list of bt5 to be # installed template_tool.installBusinessTemplateListFromRepository( bt5_name_list + ['erp5_workflow'], install_dependency=True) for bt5_name in bt5_name_list: bt = template_tool.getInstalledBusinessTemplate(bt5_name) self.assertNotEquals(bt, None) bt = template_tool.getInstalledBusinessTemplate("erp5_configurator") self.assertNotEquals(bt, None) bt = template_tool.getInstalledBusinessTemplate("erp5_workflow") self.assertNotEquals(bt, None) self.abort() def test_installBusinessTemplateListFromRepository_ignore_when_installed(self): """Check that install one business template, this method does not download many business templates that are already installed """ template_tool = self.portal.portal_templates before = {bt.getTitle(): bt.getId() for bt in template_tool.getInstalledBusinessTemplateList()} bt_title = 'erp5_calendar' template_tool.installBusinessTemplateListFromRepository([bt_title], install_dependency=True) self.tic() after = {bt.getTitle(): bt.getId() for bt in template_tool.getInstalledBusinessTemplateList()} del after[bt_title] self.assertEqual(before, after) def test_sortBusinessTemplateList(self): """Check sorting of a list of business template by their dependencies """ template_tool = self.portal.portal_templates bt5list = template_tool.resolveBusinessTemplateListDependency(('erp5_credential',)) # add some entropy by disorder bt5list returned by # resolveBusinessTemplateListDependency position_list = range(len(bt5list)) new_bt5_list = [] while position_list: position = random.choice(position_list) position_list.remove(position) new_bt5_list.append(bt5list[position]) ordered_list = template_tool.sortBusinessTemplateList(new_bt5_list) # group orders first_group = range(0, 5) second_group = range(5, 11) third_group = range(11, 12) fourth_group = range(12, 14) fifth_group = range(14, 15) expected_position_dict = { 'erp5_property_sheets': first_group, 'erp5_core_proxy_field_legacy': first_group, 'erp5_mysql_innodb_catalog': first_group, 'erp5_core': first_group, 'erp5_xhtml_style': first_group, 'erp5_jquery': second_group, 'erp5_jquery_ui': second_group, 'erp5_full_text_mroonga_catalog': second_group, 'erp5_ingestion_mysql_innodb_catalog': second_group, 'erp5_base': second_group, 'erp5_knowledge_pad': second_group, 'erp5_ingestion': third_group, 'erp5_web': fourth_group, 'erp5_crm': fourth_group, 'erp5_credential': fifth_group} for bt in ordered_list: self.assertTrue(ordered_list.index(bt) in expected_position_dict[bt[1]], 'Expected positions for %r: %r, got %r' % (bt[1], expected_position_dict[bt[1]], ordered_list.index(bt))) def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(TestTemplateTool)) return suite