From 2785a5ccfc48aa7c1a7fc246afcd1b3c9b400048 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9rome=20Perrin?= <jerome@nexedi.com>
Date: Mon, 26 Oct 2015 19:36:19 +0100
Subject: [PATCH] testBusinessTemplate: use better assert methods (assertIn)
---
product/ERP5/tests/testBusinessTemplate.py | 230 ++++++++++-----------
1 file changed, 115 insertions(+), 115 deletions(-)
diff --git a/product/ERP5/tests/testBusinessTemplate.py b/product/ERP5/tests/testBusinessTemplate.py
index 83a5e13d62..4e31be6655 100644
--- a/product/ERP5/tests/testBusinessTemplate.py
+++ b/product/ERP5/tests/testBusinessTemplate.py
@@ -399,17 +399,17 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
skins_tool = self.getSkinsTool()
for skin_name, selection in skins_tool.getSkinPaths():
if skin_name == 'View':
- self.assertFalse('erp5_csv_style' in selection)
- self.assertFalse('erp5_core' not in selection)
- self.assertFalse('erp5_xhtml_style' not in selection)
+ self.assertNotIn('erp5_csv_style', selection)
+ self.assertIn('erp5_core', selection)
+ self.assertIn('erp5_xhtml_style', selection)
if skin_name == 'Print':
- self.assertFalse('erp5_xhtml_style' in selection)
- self.assertFalse('erp5_csv_style' in selection)
- self.assertFalse('erp5_core' not in selection)
+ self.assertIn('erp5_xhtml_style', selection)
+ self.assertIn('erp5_csv_style', selection)
+ self.assertNotIn('erp5_core', selection)
if skin_name == 'CSV':
- self.assertFalse('erp5_xhtml_style' in selection)
- self.assertFalse('erp5_core' not in selection)
- self.assertFalse('erp5_csv_style' not in selection)
+ self.assertNotIn('erp5_xhtml_style', selection)
+ self.assertIn('erp5_core', selection)
+ self.assertIn('erp5_csv_style', selection)
def stepCheckNoTrashBin(self, sequence=None, **kw):
"""
@@ -436,7 +436,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
trash_ids = list(trash.objectIds())
self.assertEqual(len(trash.objectIds()), 1)
bt_id = sequence.get('import_bt').getId()
- self.assertTrue(bt_id not in trash_ids[0])
+ self.assertNotIn(bt_id, trash_ids[0])
# portal types
def stepCreatePortalType(self, sequence=None, **kw):
@@ -1528,7 +1528,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
object_id = sequence.get('object_ptype_id')
object_pt = pt._getOb(object_id)
action_id = sequence.get('first_action_id')
- self.assertTrue(action_id in [x.getReference()
+ self.assertIn(action_id, [x.getReference()
for x in object_pt.getActionInformationList()])
def stepCheckFirstActionNotExists(self, sequence=None, **kw):
@@ -1539,7 +1539,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
object_id = sequence.get('object_ptype_id')
object_pt = pt._getOb(object_id)
action_id = sequence.get('first_action_id')
- self.assertFalse(action_id in [x.getReference()
+ self.assertNotIn(action_id, [x.getReference()
for x in object_pt.getActionInformationList()])
def stepCheckSecondActionExists(self, sequence=None, **kw):
@@ -1550,7 +1550,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
object_id = sequence.get('object_ptype_id')
object_pt = pt._getOb(object_id)
action_id = sequence.get('second_action_id')
- self.assertTrue(action_id in [x.getReference()
+ self.assertIn(action_id, [x.getReference()
for x in object_pt.getActionInformationList()])
def stepCheckSecondActionNotExists(self, sequence=None, **kw):
@@ -1561,7 +1561,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
object_id = sequence.get('object_ptype_id')
object_pt = pt._getOb(object_id)
action_id = sequence.get('second_action_id')
- self.assertFalse(action_id in [x.getReference()
+ self.assertNotIn(action_id, [x.getReference()
for x in object_pt.getActionInformationList()])
def stepAddSecondActionToBusinessTemplate(self, sequence=None, **kw):
@@ -1713,7 +1713,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
zsql_method = catalog._getOb(method_id, None)
self.assertNotEqual(zsql_method, None)
# check catalog properties
- self.assertTrue(method_id in catalog.sql_uncatalog_object)
+ self.assertIn(method_id, catalog.sql_uncatalog_object)
# check filter
filter_dict = catalog.filter_dict[method_id]
self.assertEqual(filter_dict['filtered'], 1)
@@ -1729,7 +1729,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
zsql_method = catalog._getOb(method_id, None)
self.assertNotEqual(zsql_method, None)
# check catalog properties
- self.assertTrue(method_id in catalog.sql_uncatalog_object)
+ self.assertIn(method_id, catalog.sql_uncatalog_object)
# check filter
filter_dict = catalog.filter_dict[method_id]
self.assertEqual(filter_dict['filtered'], 1)
@@ -1748,9 +1748,9 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
zsql_method = catalog._getOb(method_id, None)
self.assertTrue(zsql_method is None)
# check catalog properties
- self.assertTrue(method_id not in catalog.sql_uncatalog_object)
+ self.assertNotIn(method_id, catalog.sql_uncatalog_object)
# check filter
- self.assertTrue(method_id not in catalog.filter_dict.keys())
+ self.assertNotIn(method_id, catalog.filter_dict.keys())
def stepRemoveCatalogMethod(self, sequence=None, **kw):
"""
@@ -1768,10 +1768,10 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
sql_uncatalog_object.remove(method_id)
sql_uncatalog_object.sort()
catalog.sql_uncatalog_object = tuple(sql_uncatalog_object)
- self.assertTrue(method_id not in catalog.sql_uncatalog_object)
+ self.assertNotIn(method_id, catalog.sql_uncatalog_object)
# remove filter
del catalog.filter_dict[method_id]
- self.assertTrue(method_id not in catalog.filter_dict.keys())
+ self.assertNotIn(method_id, catalog.filter_dict.keys())
# Related key, Result key and table, and others
def stepCreateKeysAndTable(self, sequence=list, **kw):
@@ -1799,84 +1799,84 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
sql_search_tables.append(result_table)
sql_search_tables.sort()
catalog.sql_search_tables = tuple(sql_search_tables)
- self.assertTrue(result_table in catalog.sql_search_tables)
+ self.assertIn(result_table, catalog.sql_search_tables)
# result key
if result_key not in catalog.sql_search_result_keys:
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.assertTrue(result_key in catalog.sql_search_result_keys)
+ self.assertIn(result_key, catalog.sql_search_result_keys)
# related key
if related_key not in catalog.sql_catalog_related_keys:
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.assertTrue(related_key in catalog.sql_catalog_related_keys)
+ self.assertIn(related_key, catalog.sql_catalog_related_keys)
# search keys
if search_key not in catalog.sql_catalog_search_keys:
sql_catalog_search_keys = list(catalog.sql_catalog_search_keys)
sql_catalog_search_keys.append(search_key)
sql_catalog_search_keys.sort()
catalog.sql_catalog_search_keys = tuple(sql_catalog_search_keys)
- self.assertTrue(search_key in catalog.sql_catalog_search_keys)
+ self.assertIn(search_key, catalog.sql_catalog_search_keys)
# keyword keys
if keyword_key not in catalog.sql_catalog_keyword_search_keys:
sql_catalog_keyword_keys = list(catalog.sql_catalog_keyword_search_keys)
sql_catalog_keyword_keys.append(keyword_key)
sql_catalog_keyword_keys.sort()
catalog.sql_catalog_keyword_search_keys = tuple(sql_catalog_keyword_keys)
- self.assertTrue(keyword_key in catalog.sql_catalog_keyword_search_keys)
+ self.assertIn(keyword_key, catalog.sql_catalog_keyword_search_keys)
# full_text keys
if full_text_key not in catalog.sql_catalog_full_text_search_keys:
sql_catalog_full_text_keys = list(catalog.sql_catalog_full_text_search_keys)
sql_catalog_full_text_keys.append(full_text_key)
sql_catalog_full_text_keys.sort()
catalog.sql_catalog_full_text_search_keys = tuple(sql_catalog_full_text_keys)
- self.assertTrue(full_text_key in catalog.sql_catalog_full_text_search_keys)
+ self.assertIn(full_text_key, catalog.sql_catalog_full_text_search_keys)
# request
if request_key not in catalog.sql_catalog_request_keys:
sql_catalog_request_keys = list(catalog.sql_catalog_request_keys)
sql_catalog_request_keys.append(request_key)
sql_catalog_request_keys.sort()
catalog.sql_catalog_request_keys = tuple(sql_catalog_request_keys)
- self.assertTrue(request_key in catalog.sql_catalog_request_keys)
+ self.assertIn(request_key, catalog.sql_catalog_request_keys)
# multivalue
if multivalue_key not in catalog.sql_catalog_multivalue_keys:
sql_catalog_multivalue_keys = list(catalog.sql_catalog_multivalue_keys)
sql_catalog_multivalue_keys.append(multivalue_key)
sql_catalog_multivalue_keys.sort()
catalog.sql_catalog_multivalue_keys = tuple(sql_catalog_multivalue_keys)
- self.assertTrue(multivalue_key in catalog.sql_catalog_multivalue_keys)
+ self.assertIn(multivalue_key, catalog.sql_catalog_multivalue_keys)
# topic keys
if topic_key not in catalog.sql_catalog_topic_search_keys:
sql_catalog_topic_keys = list(catalog.sql_catalog_topic_search_keys)
sql_catalog_topic_keys.append(topic_key)
sql_catalog_topic_keys.sort()
catalog.sql_catalog_topic_search_keys = tuple(sql_catalog_topic_keys)
- self.assertTrue(topic_key in catalog.sql_catalog_topic_search_keys)
+ self.assertIn(topic_key, catalog.sql_catalog_topic_search_keys)
# scriptable keys
if scriptable_key not in catalog.sql_catalog_scriptable_keys:
sql_catalog_scriptable_keys = list(catalog.sql_catalog_scriptable_keys)
sql_catalog_scriptable_keys.append(scriptable_key)
sql_catalog_scriptable_keys.sort()
catalog.sql_catalog_scriptable_keys = tuple(sql_catalog_scriptable_keys)
- self.assertTrue(scriptable_key in catalog.sql_catalog_scriptable_keys)
+ self.assertIn(scriptable_key, catalog.sql_catalog_scriptable_keys)
# role keys
if role_key not in catalog.sql_catalog_role_keys:
sql_catalog_role_keys = list(catalog.sql_catalog_role_keys)
sql_catalog_role_keys.append(role_key)
sql_catalog_role_keys.sort()
catalog.sql_catalog_role_keys = tuple(sql_catalog_role_keys)
- self.assertTrue(role_key in catalog.sql_catalog_role_keys)
+ self.assertIn(role_key, catalog.sql_catalog_role_keys)
# local_role keys
if local_role_key not in catalog.sql_catalog_local_role_keys:
sql_catalog_local_role_keys = list(catalog.sql_catalog_local_role_keys)
sql_catalog_local_role_keys.append(local_role_key)
sql_catalog_local_role_keys.sort()
catalog.sql_catalog_local_role_keys = tuple(sql_catalog_local_role_keys)
- self.assertTrue(local_role_key in catalog.sql_catalog_local_role_keys)
+ self.assertIn(local_role_key, catalog.sql_catalog_local_role_keys)
sequence.edit(related_key=related_key, result_key=result_key,
result_table=result_table, search_key=search_key,
@@ -1915,10 +1915,10 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
# method related configuration
self.assertEqual(catalog.sql_getitem_by_uid, 'z_getitem_by_uid_2')
# table related configuration
- self.assertTrue('translation' in catalog.sql_search_tables)
+ self.assertIn('translation', catalog.sql_search_tables)
# column related configuration
- self.assertTrue('catalog.reference'
- in catalog.sql_search_result_keys)
+ self.assertIn('catalog.reference',
+ catalog.sql_search_result_keys)
def stepModifyRelatedKey(self, sequence):
catalog = self.getCatalogTool().getSQLCatalog()
@@ -1943,8 +1943,8 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
# stepModifyRelatedKey added related_key_2 and removed related_key
# but the reinstallation of the BT replaced related_key_2 with
# related_key:
- self.assertTrue(related_key in related_key_list)
- self.assertFalse(related_key_2 in related_key_list)
+ self.assertIn(related_key, related_key_list)
+ self.assertNotIn(related_key_2, related_key_list)
# make sure there's only one entry
self.assertTrue(related_key.startswith('fake_id |'), related_key)
self.assertEqual(len([key for key in related_key_list
@@ -1955,8 +1955,8 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
related_key = sequence['related_key']
related_key_2 = sequence['related_key_2']
related_key_list = list(catalog.sql_catalog_related_keys)
- self.assertTrue(related_key in related_key_list)
- self.assertFalse(related_key_2 in related_key_list)
+ self.assertIn(related_key, related_key_list)
+ self.assertNotIn(related_key_2, related_key_list)
# we manually duplicate the key in the list, creating an invalid situation
self.assertEqual(len([key for key in related_key_list
if key.startswith('fake_id |')]), 1)
@@ -1975,8 +1975,8 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
# This also means that an uninstallation of a BT does not
# accidentally removes an overriding key from another BT that
# depends on it.
- self.assertFalse(related_key in related_key_list)
- self.assertTrue(related_key_2 in related_key_list)
+ self.assertNotIn(related_key, related_key_list)
+ self.assertIn(related_key_2, related_key_list)
self.assertEqual(len([key for key in related_key_list
if key.startswith('fake_id |')]), 1)
@@ -1995,19 +1995,19 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
sql_search_result_keys.remove(result_key)
sql_search_result_keys.sort()
catalog.sql_search_result_keys = tuple(sql_search_result_keys)
- self.assertTrue(result_key not in catalog.sql_search_result_keys)
+ self.assertNotIn(result_key, catalog.sql_search_result_keys)
# search 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.assertFalse(result_table in catalog.sql_search_tables)
+ self.assertNotIn(result_table, catalog.sql_search_tables)
# related key
related_key_2 = sequence['related_key_2']
sql_catalog_related_keys = list(catalog.sql_catalog_related_keys)
sql_catalog_related_keys.remove(related_key_2)
catalog.sql_catalog_related_keys = tuple(sql_catalog_related_keys)
- self.assertFalse(related_key_2 in catalog.sql_catalog_related_keys)
+ self.assertNotIn(related_key_2, catalog.sql_catalog_related_keys)
def stepAddKeysAndTableToBusinessTemplate(self, sequence=None, **kw):
"""
@@ -2090,73 +2090,73 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
sql_search_result_keys.remove(result_key)
sql_search_result_keys.sort()
catalog.sql_search_result_keys = tuple(sql_search_result_keys)
- self.assertTrue(result_key not in catalog.sql_search_result_keys)
+ self.assertNotIn(result_key, 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.assertTrue(related_key not in catalog.sql_catalog_related_keys)
+ self.assertNotIn(related_key, 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.assertTrue(result_table not in catalog.sql_search_tables)
+ self.assertNotIn(result_table, catalog.sql_search_tables)
# search keys
sql_catalog_search_keys = list(catalog.sql_catalog_search_keys)
sql_catalog_search_keys.remove(search_key)
sql_catalog_search_keys.sort()
catalog.sql_catalog_search_keys = tuple(sql_catalog_search_keys)
- self.assertTrue(search_key not in catalog.sql_catalog_search_keys)
+ self.assertNotIn(search_key, catalog.sql_catalog_search_keys)
# keyword keys
sql_catalog_keyword_keys = list(catalog.sql_catalog_keyword_search_keys)
sql_catalog_keyword_keys.remove(keyword_key)
sql_catalog_keyword_keys.sort()
catalog.sql_catalog_keyword_search_keys = tuple(sql_catalog_keyword_keys)
- self.assertTrue(keyword_key not in catalog.sql_catalog_keyword_search_keys)
+ self.assertNotIn(keyword_key, catalog.sql_catalog_keyword_search_keys)
# full_text keys
sql_catalog_full_text_keys = list(catalog.sql_catalog_full_text_search_keys)
sql_catalog_full_text_keys.remove(full_text_key)
sql_catalog_full_text_keys.sort()
catalog.sql_catalog_full_text_search_keys = tuple(sql_catalog_full_text_keys)
- self.assertTrue(full_text_key not in catalog.sql_catalog_full_text_search_keys)
+ self.assertNotIn(full_text_key, catalog.sql_catalog_full_text_search_keys)
# request
sql_catalog_request_keys = list(catalog.sql_catalog_request_keys)
sql_catalog_request_keys.remove(request_key)
sql_catalog_request_keys.sort()
catalog.sql_catalog_request_keys = tuple(sql_catalog_request_keys)
- self.assertTrue(request_key not in catalog.sql_catalog_request_keys)
+ self.assertNotIn(request_key, catalog.sql_catalog_request_keys)
# multivalue
sql_catalog_multivalue_keys = list(catalog.sql_catalog_multivalue_keys)
sql_catalog_multivalue_keys.remove(multivalue_key)
sql_catalog_multivalue_keys.sort()
catalog.sql_catalog_multivalue_keys = tuple(sql_catalog_multivalue_keys)
- self.assertTrue(multivalue_key not in catalog.sql_catalog_multivalue_keys)
+ self.assertNotIn(multivalue_key, catalog.sql_catalog_multivalue_keys)
# topic keys
sql_catalog_topic_keys = list(catalog.sql_catalog_topic_search_keys)
sql_catalog_topic_keys.remove(topic_key)
sql_catalog_topic_keys.sort()
catalog.sql_catalog_topic_search_keys = tuple(sql_catalog_topic_keys)
- self.assertTrue(topic_key not in catalog.sql_catalog_topic_search_keys)
+ self.assertNotIn(topic_key, catalog.sql_catalog_topic_search_keys)
# scriptable keys
sql_catalog_scriptable_keys = list(catalog.sql_catalog_scriptable_keys)
sql_catalog_scriptable_keys.remove(scriptable_key)
sql_catalog_scriptable_keys.sort()
catalog.sql_catalog_scriptable_keys = tuple(sql_catalog_scriptable_keys)
- self.assertTrue(scriptable_key not in catalog.sql_catalog_scriptable_keys)
+ self.assertNotIn(scriptable_key, catalog.sql_catalog_scriptable_keys)
# role keys
sql_catalog_role_keys = list(catalog.sql_catalog_role_keys)
sql_catalog_role_keys.remove(role_key)
sql_catalog_role_keys.sort()
catalog.sql_catalog_role_keys = tuple(sql_catalog_role_keys)
- self.assertTrue(role_key not in catalog.sql_catalog_role_keys)
+ self.assertNotIn(role_key, catalog.sql_catalog_role_keys)
# local_role keys
sql_catalog_local_role_keys = list(catalog.sql_catalog_local_role_keys)
sql_catalog_local_role_keys.remove(local_role_key)
sql_catalog_local_role_keys.sort()
catalog.sql_catalog_local_role_keys = tuple(sql_catalog_local_role_keys)
- self.assertTrue(local_role_key not in catalog.sql_catalog_local_role_keys)
+ self.assertNotIn(local_role_key, catalog.sql_catalog_local_role_keys)
def stepCheckKeysAndTableExists(self, sequence=list, **kw):
"""
@@ -2190,29 +2190,29 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
catalog = self.getCatalogTool().getSQLCatalog()
self.assertTrue(catalog is not None)
# result key
- self.assertTrue(result_key in catalog.sql_search_result_keys)
+ self.assertIn(result_key, catalog.sql_search_result_keys)
# related key
- self.assertTrue(related_key in catalog.sql_catalog_related_keys)
+ self.assertIn(related_key, catalog.sql_catalog_related_keys)
# result table
- self.assertTrue(result_table in catalog.sql_search_tables)
+ self.assertIn(result_table, catalog.sql_search_tables)
# search key
- self.assertTrue(search_key in catalog.sql_catalog_search_keys)
+ self.assertIn(search_key, catalog.sql_catalog_search_keys)
# keyword key
- self.assertTrue(keyword_key in catalog.sql_catalog_keyword_search_keys)
+ self.assertIn(keyword_key, catalog.sql_catalog_keyword_search_keys)
# full text key
- self.assertTrue(full_text_key in catalog.sql_catalog_full_text_search_keys)
+ self.assertIn(full_text_key, catalog.sql_catalog_full_text_search_keys)
# request key
- self.assertTrue(request_key in catalog.sql_catalog_request_keys)
+ self.assertIn(request_key, catalog.sql_catalog_request_keys)
# multivalue key
- self.assertTrue(multivalue_key in catalog.sql_catalog_multivalue_keys)
+ self.assertIn(multivalue_key, catalog.sql_catalog_multivalue_keys)
# topic key
- self.assertTrue(topic_key in catalog.sql_catalog_topic_search_keys)
+ self.assertIn(topic_key, catalog.sql_catalog_topic_search_keys)
# scriptable key
- self.assertTrue(scriptable_key in catalog.sql_catalog_scriptable_keys)
+ self.assertIn(scriptable_key, catalog.sql_catalog_scriptable_keys)
# role key
- self.assertTrue(role_key in catalog.sql_catalog_role_keys)
+ self.assertIn(role_key, catalog.sql_catalog_role_keys)
# local_role key
- self.assertTrue(local_role_key in catalog.sql_catalog_local_role_keys)
+ self.assertIn(local_role_key, catalog.sql_catalog_local_role_keys)
def stepCheckKeysAndTableRemoved(self, sequence=list, **kw):
"""
@@ -2246,29 +2246,29 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
catalog = self.getCatalogTool().getSQLCatalog()
self.assertTrue(catalog is not None)
# result key
- self.assertTrue(result_key not in catalog.sql_search_result_keys)
+ self.assertTrue(result_key, catalog.sql_search_result_keys)
# related key
- self.assertTrue(related_key not in catalog.sql_catalog_related_keys)
+ self.assertTrue(related_key, catalog.sql_catalog_related_keys)
# result table
- self.assertTrue(result_table not in catalog.sql_search_tables)
+ self.assertTrue(result_table, catalog.sql_search_tables)
# search key
- self.assertTrue(search_key not in catalog.sql_catalog_search_keys)
+ self.assertTrue(search_key, catalog.sql_catalog_search_keys)
# keyword key
- self.assertTrue(keyword_key not in catalog.sql_catalog_keyword_search_keys)
+ self.assertTrue(keyword_key, catalog.sql_catalog_keyword_search_keys)
# full text key
- self.assertTrue(full_text_key not in catalog.sql_catalog_full_text_search_keys)
+ self.assertTrue(full_text_key, catalog.sql_catalog_full_text_search_keys)
# request key
- self.assertTrue(request_key not in catalog.sql_catalog_request_keys)
+ self.assertTrue(request_key, catalog.sql_catalog_request_keys)
# multivalue key
- self.assertTrue(multivalue_key not in catalog.sql_catalog_multivalue_keys)
+ self.assertTrue(multivalue_key, catalog.sql_catalog_multivalue_keys)
# topic key
- self.assertTrue(topic_key not in catalog.sql_catalog_topic_search_keys)
+ self.assertTrue(topic_key, catalog.sql_catalog_topic_search_keys)
# scriptable key
- self.assertTrue(scriptable_key not in catalog.sql_catalog_scriptable_keys)
+ self.assertTrue(scriptable_key, catalog.sql_catalog_scriptable_keys)
# role key
- self.assertTrue(role_key not in catalog.sql_catalog_role_keys)
+ self.assertTrue(role_key, catalog.sql_catalog_role_keys)
# local_role key
- self.assertTrue(local_role_key not in catalog.sql_catalog_local_role_keys)
+ self.assertTrue(local_role_key, catalog.sql_catalog_local_role_keys)
# Roles
def stepCreateRole(self, sequence=None, **kw):
@@ -2280,7 +2280,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
role_list = list(p.__ac_roles__)
role_list.append(new_role)
p.__ac_roles__ = tuple(role_list)
- self.assertTrue(new_role in p.__ac_roles__)
+ self.assertIn(new_role, p.__ac_roles__)
sequence.edit(role=new_role)
def stepRemoveRole(self, sequence=None, **kw):
@@ -2293,7 +2293,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
role_list = list(p.__ac_roles__)
role_list.remove(role)
p.__ac_roles__ = tuple(role_list)
- self.assertTrue(role not in p.__ac_roles__)
+ self.assertNotIn(role, p.__ac_roles__)
def stepAddRoleToBusinessTemplate(self, sequence=None, **kw):
"""
@@ -2312,7 +2312,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
role = sequence.get('role', None)
self.assertTrue(role is not None)
p = self.getPortal()
- self.assertTrue(role in p.__ac_roles__)
+ self.assertIn(role, p.__ac_roles__)
def stepCheckRoleRemoved(self, sequence=None, **kw):
"""
@@ -2321,7 +2321,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
role = sequence.get('role', None)
self.assertTrue(role is not None)
p = self.getPortal()
- self.assertTrue(role not in p.__ac_roles__)
+ self.assertNotIn(role, p.__ac_roles__)
# Local Roles
def stepCreateLocalRoles(self, sequence=None, **kw):
@@ -2391,7 +2391,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
sql_connection = self.getSQLConnection()
result = sql_connection.manage_test(sql)
for line in result:
- self.assertTrue((line.uid, line.role) not in before_update_local_roles)
+ self.assertNotIn((line.uid, line.role), before_update_local_roles)
def stepCheckLocalRolesRemoved(self, sequence=None, **kw):
"""
@@ -2438,13 +2438,13 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
Check migration of Property Sheets from the Filesystem to ZODB
"""
property_sheet_tool = self.getPortalObject().portal_property_sheets
- self.assertTrue('UnitTest' in property_sheet_tool.objectIds())
+ self.assertIn('UnitTest', property_sheet_tool.objectIds())
property_list = property_sheet_tool.UnitTest.contentValues()
self.assertEqual(len(property_list), 1)
- self.assertTrue(property_list[0].getReference() == 'ps_prop1')
- self.assertTrue(property_list[0].getElementaryType() == 'string')
+ self.assertEqual(property_list[0].getReference(), 'ps_prop1')
+ self.assertEqual(property_list[0].getElementaryType(), 'string')
def stepRemovePropertySheet(self, sequence=None, sequencer_list=None, **kw):
"""
@@ -2504,7 +2504,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
"""
ps_id = sequence.get('ps_title', None)
self.assertFalse(ps_id is None)
- self.assertFalse(ps_id in self.getPortalObject().portal_property_sheets.objectIds())
+ self.assertNotIn(ps_id, self.getPortalObject().portal_property_sheets.objectIds())
def stepCreateUpdatedPropertySheet(self, sequence=None, **kw):
"""
@@ -2921,29 +2921,29 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
ps = self.getSkinsTool()
skin_id = sequence.get('skin_folder_id')
# a new skin selection is added
- self.assertTrue('Foo' in ps.getSkinSelections())
+ self.assertIn('Foo', ps.getSkinSelections())
# and it contains good layers
layers = ps.getSkinPath('Foo').split(',')
- self.assertTrue(skin_id in layers, layers)
- self.assertTrue('erp5_core' in layers, layers)
- self.assertFalse('erp5_xhtml_style' in layers, layers)
+ self.assertIn(skin_id, layers)
+ self.assertIn('erp5_core', layers)
+ self.assertNotIn('erp5_xhtml_style', layers)
skin_folder = ps._getOb(skin_id, None)
skin_selection_list = skin_folder.getProperty(
'business_template_registered_skin_selections', ())
- self.assertTrue('Foo' in skin_selection_list)
+ self.assertIn('Foo', skin_selection_list)
def stepCheckStaticSkinSelection(self, sequence=None, **kw):
ps = self.getSkinsTool()
skin_id = sequence.get('skin_folder_id')
static_skin_id = sequence.get('static_skin_folder_id')
# a new skin selection is added
- self.assertTrue('Foo' in ps.getSkinSelections())
+ self.assertIn('Foo', ps.getSkinSelections())
# and it contains good layers
layers = ps.getSkinPath('Foo').split(',')
- self.assertTrue(skin_id in layers, layers)
- self.assertTrue('erp5_core' in layers, layers)
- self.assertFalse('erp5_xhtml_style' in layers, layers)
- self.assertTrue(static_skin_id in layers, layers)
+ self.assertIn(skin_id, layers)
+ self.assertIn('erp5_core', layers)
+ self.assertNotIn('erp5_xhtml_style', layers)
+ self.assertIn(static_skin_id, layers)
def stepCreateCustomWorkflow(self, sequence=None, **kw):
"""
@@ -2973,8 +2973,8 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
"""
pt = self.getTemplateTool()
template = pt.newContent(portal_type='Business Template')
- self.assertTrue(template.getBuildingState() == 'draft')
- self.assertTrue(template.getInstallationState() == 'not_installed')
+ self.assertEquals(template.getBuildingState(), 'draft')
+ self.assertEquals(template.getInstallationState(), 'not_installed')
template.edit(title='custom geek template',
version='1.0',
description='custom bt for unit_test')
@@ -3180,7 +3180,7 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
python_script_id = sequence.get('python_script_id')
skin_folder_id = sequence.get('skin_folder_id')
folder = self.portal.portal_skins[skin_folder_id]
- self.assertTrue(python_script_id not in folder.objectIds())
+ self.assertNotIn(python_script_id, folder.objectIds())
def stepSetOldSitePropertyValue(self, sequence=None, **kw):
"""Set the old value to a site property."""
@@ -3221,13 +3221,13 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
"""
Check that a skin selection has been removed.
"""
- self.assertTrue('Foo' not in self.portal.portal_skins.getSkinSelections())
+ self.assertNotIn('Foo', self.portal.portal_skins.getSkinSelections())
def stepCheckSkinSelectionNotRemoved(self, sequence=None, **kw):
"""
Check that a skin selection has not been removed.
"""
- self.assertTrue('Foo' in self.portal.portal_skins.getSkinSelections())
+ self.assertIn('Foo', self.portal.portal_skins.getSkinSelections())
def stepUserDisableSkinSelectionRegistration(self, sequence=None, **kw):
"""
@@ -3253,9 +3253,9 @@ class BusinessTemplateMixin(ERP5TypeTestCase, LogInterceptor):
select_skin_to_be_changed_list = sequence.get('select_skin_to_be_changed_list')
select_skin_not_to_be_changed_list = sequence.get('select_skin_not_to_be_changed_list')
for skin_name in select_skin_to_be_changed_list:
- self.assertTrue(skin_folder_id in self.portal.portal_skins.getSkinPath(skin_name))
+ self.assertIn(skin_folder_id, self.portal.portal_skins.getSkinPath(skin_name))
for skin_name in select_skin_not_to_be_changed_list:
- self.assertTrue(skin_folder_id not in self.portal.portal_skins.getSkinPath(skin_name))
+ self.assertNotIn(skin_folder_id, self.portal.portal_skins.getSkinPath(skin_name))
def stepCheckSkinFolderPriorityOn(self, sequence=None, **kw):
"""
@@ -6424,11 +6424,11 @@ class TestBusinessTemplate(BusinessTemplateMixin):
# This type provider, will be automatically registered on types tool during
# business template installation, because it contains type information
- self.assertTrue('dummy_type_provider' in types_tool.type_provider_list)
+ self.assertIn('dummy_type_provider', types_tool.type_provider_list)
# The type is reinstalled
- self.assertTrue('Dummy Type' in type_provider.objectIds())
+ self.assertIn('Dummy Type', type_provider.objectIds())
# is available from types tool
- self.assertTrue('Dummy Type' in [ti.getId() for
+ self.assertIn('Dummy Type', [ti.getId() for
ti in types_tool.listTypeInfo()])
dummy_type = types_tool.getTypeInfo('Dummy Type')
@@ -6459,7 +6459,7 @@ class TestBusinessTemplate(BusinessTemplateMixin):
new_bt.uninstall()
self.assertNotEquals(None, types_tool.getTypeInfo('Base Category'))
self.assertEqual(None, types_tool.getTypeInfo('Dummy Type'))
- self.assertFalse('dummy_type_provider' in types_tool.type_provider_list)
+ self.assertNotIn('dummy_type_provider', types_tool.type_provider_list)
def test_type_provider_2(self):
self.portal.newContent(id='dummy_type_provider', portal_type="Types Tool")
@@ -6500,7 +6500,7 @@ class TestBusinessTemplate(BusinessTemplateMixin):
# This type provider, will be automatically registered on types tool during
# business template installation, because it contains type information
- self.assertTrue('dummy_type_provider' in types_tool.type_provider_list)
+ self.assertIn('dummy_type_provider', types_tool.type_provider_list)
# Create a business template that has the same title but does not
# contain type_provider.
@@ -6521,7 +6521,7 @@ class TestBusinessTemplate(BusinessTemplateMixin):
new_bt.install(force=0, object_to_update={'dummy_type_provider':'remove'})
self.assertNotEquals(None, types_tool.getTypeInfo('Base Category'))
- self.assertFalse('dummy_type_provider' in types_tool.type_provider_list)
+ self.assertNotIn('dummy_type_provider', types_tool.type_provider_list)
def test_global_action(self):
# Tests that global actions are properly exported and reimported
@@ -7526,7 +7526,7 @@ class TestDocumentTemplateItem(BusinessTemplateMixin):
def stepCheckZodbDocumentRemoved(self, sequence=None, **kw):
component_tool = self.getPortalObject().portal_components
- self.assertFalse(sequence['document_id'] in component_tool.objectIds())
+ self.assertNotIn(sequence['document_id'], component_tool.objectIds())
def stepRemoveZodbDocument(self, sequence=None, **kw):
self.portal.portal_components.manage_delObjects([sequence['document_id']])
@@ -7559,7 +7559,7 @@ class TestDocumentTemplateItem(BusinessTemplateMixin):
first_line = source_code.split('\n', 1)[0]
with open(xml_path) as f:
for line in f:
- self.assertFalse(first_line in line)
+ self.assertNotIn(first_line, line)
def test_BusinessTemplateWithZodbDocument(self):
sequence_list = SequenceList()
@@ -7697,7 +7697,7 @@ class TestDocumentTemplateItem(BusinessTemplateMixin):
[component_id])
component_tool = self.getPortalObject().portal_components
- self.assertTrue(component_id in component_tool.objectIds())
+ self.assertIn(component_id, component_tool.objectIds())
component = getattr(component_tool, component_id)
self.assertEqual(component.getReference(), sequence['document_title'])
--
2.30.9