def test_portlet_visibility_settings(self):
assignment = self.layer['right_portlets'].get('title2', False)
settings = PersistentMapping({'visible': False})
IPortletAssignmentSettings(assignment).data = settings
# get the data
adapter = getAdapter(self.layer['folder1'], IDataCollector,
name="portlet_data_adapter")
data = adapter.getData()
jsondata = json.dumps(utils.decode_for_json(data))
data = utils.encode_after_json(json.loads(jsondata))
self.assertEqual(
settings,
data['plone.rightcolumn']['title2']['settings'])
# set the data
adapter2 = getAdapter(self.layer['folder2'], IDataCollector,
name="portlet_data_adapter")
adapter2.setData(data, metadata=None)
new_assignment = self.layer['right_portlets'].get('title2', False)
self.assertEqual(
settings,
IPortletAssignmentSettings(new_assignment).data)
def _get_field_data(self, obj, json=False):
collector = self._get_collector_for(obj)
data = collector.getData()
if json:
data = utils.decode_for_json(data)
data = dumps(data)
return data
def convertToJson(self, data):
"""
Converts a dictionary to a JSON-string
@param data: data dictionary
@type data: dict
@return: JSON
@rtype: string
"""
data = decode_for_json(data)
return json.dumps(data, sort_keys=True)
def send_to_receiver(self):
data = json.dumps(
decode_for_json(self.get_settings_data())
)
realms = IConfig(api.portal.get()).getRealms()
for realm in realms:
sendJsonToRealm(
data,
realm,
'global_statusmessage_config_receiver'
)
def test_roundtrip_stores_data_persistently(self):
annotations = IAnnotations(self.layer['portal'])
component = getAdapter(self.layer['portal'], IDataCollector,
name='ftw.servicenavigation')
annotations[ANNOTATION_KEY] = EXAMPLE_DATA
wired_data = decode_for_json(component.getData())
del annotations[ANNOTATION_KEY]
component.setData(encode_after_json(wired_data))
data = annotations[ANNOTATION_KEY]
self.assertEqual(EXAMPLE_DATA, data)
self.assertIsInstance(data, Persistent)
self.assertIsInstance(data['links'], Persistent)
def test_shop_item_ranks(self):
folder = create(Builder('folder'))
category_1 = create(Builder('shop category')
.titled('Category 1')
.within(folder))
category_2 = create(Builder('shop category')
.titled('Category 2')
.within(folder))
shop_item_1 = create(Builder('shop item')
.titled('Raindrops')
.within(category_1))
shop_item_1.addToCategory(category_1)
shop_item_1.setRankForCategory(category_1, 5)
shop_item_1.addToCategory(category_2)
shop_item_1.setRankForCategory(category_2, 55)
adapter_shop_item_1 = getAdapter(shop_item_1, IDataCollector,
name='shop_categorizable_ranks_adapter')
shop_item_2 = create(Builder('shop item')
.titled('Snowflakes')
.within(category_1))
adapter_shop_item_2 = getAdapter(shop_item_2, IDataCollector,
name='shop_categorizable_ranks_adapter')
self.assertNotEqual(
adapter_shop_item_1.getData(),
adapter_shop_item_2.getData(),
)
getter_data = adapter_shop_item_1.getData()
getter_json = json.dumps(utils.decode_for_json(getter_data))
setter_data = utils.encode_after_json(json.loads(getter_json))
adapter_shop_item_2.setData(setter_data, None)
self.assertEqual(
adapter_shop_item_1.getData(),
adapter_shop_item_2.getData(),
)
def enqueue_deferred_extraction(obj, action, filepath, additional_data,
attempt=1, token=None, path=None):
callback_path = '/'.join(api.portal.get().getPhysicalPath() +
('taskqueue_publisher_extract_object',))
if obj is None and (path is None or token is None):
raise ValueError('When obj is None, path and token must be provided.')
elif obj is not None:
path = '/'.join(obj.getPhysicalPath())
# Set a token on the object so that we can make sure that we extract
# this version of the object later in the worker.
if token is None:
token = str(uuid.uuid4())
IAnnotations(obj)[TOKEN_ANNOTATION_KEY] = token
taskqueue.add(callback_path, params={
'action': action,
'filepath': filepath,
'path': path,
'attempt:int': attempt,
'token': token,
'additional_data': json.dumps(decode_for_json(dict(dict(additional_data))))})
def test_portlets_with_settings(self):
# IPortletAssignmentSettings creates settings in the annotations
ori_assignment = self.layer['right_portlets'].get('title2', False)
ori_settings = getAdapter(ori_assignment, IPortletAssignmentSettings)
ori_settings['foo'] = 'bar'
# extract the data
adapter = getAdapter(self.layer['folder1'], IDataCollector,
name="portlet_data_adapter")
getterdata = adapter.getData()
getterdata = utils.decode_for_json(getterdata)
jsondata = json.dumps(getterdata)
# set the data on the folder2
data = json.loads(jsondata)
data = utils.encode_after_json(data)
adapter2 = getAdapter(self.layer['folder2'], IDataCollector,
name="portlet_data_adapter")
adapter2.setData(data, metadata=None)
# test the assignment settings
new_assignment = self.layer['right_portlets'].get('title2', False)
new_settings = getAdapter(new_assignment, IPortletAssignmentSettings)
self.assertEqual(new_settings['foo'], 'bar')
assignment_annotations = new_assignment.__annotations__
self.assertTrue(
isinstance(assignment_annotations, OOBTree),
'annotations are not OOBTree but %s' % type(
assignment_annotations))
settings = assignment_annotations.get(ASSIGNMENT_SETTINGS_KEY)
self.assertTrue(
IPortletAssignmentSettings.providedBy(settings),
'Portlet settings is not PortletAssignmentSettings but %s' % (
type(settings)))
def enqueue_deferred_extraction(obj,
action,
filepath,
additional_data,
attempt=1,
token=None,
path=None):
callback_path = '/'.join(api.portal.get().getPhysicalPath() +
('taskqueue_publisher_extract_object', ))
if obj is None and (path is None or token is None):
raise ValueError('When obj is None, path and token must be provided.')
elif obj is not None:
path = '/'.join(obj.getPhysicalPath())
# Set a token on the object so that we can make sure that we extract
# this version of the object later in the worker.
if token is None:
token = str(uuid.uuid4())
IAnnotations(obj)[TOKEN_ANNOTATION_KEY] = token
taskqueue.add(callback_path,
params={
'action':
action,
'filepath':
filepath,
'path':
path,
'attempt:int':
attempt,
'token':
token,
'additional_data':
json.dumps(decode_for_json(dict(dict(additional_data))))
})
class PublishedControlPanelTestCase(FunctionalTestCase):
enabled_bool = True
enabled_anonymous_bool = True
type_choice = u'information'
title_textfield = u'Hello World'
message_textfield = u'This is the message to the world'
exclude_sites = None
form_data = {
'Active': enabled_bool,
'Show to anonymous users?': enabled_anonymous_bool,
'Type': type_choice,
'Title': title_textfield,
'Message': message_textfield,
}
expected_settings = {
'enabled_bool': enabled_bool,
'enabled_anonymous_bool': enabled_anonymous_bool,
'type_choice': type_choice,
'title_textfield': title_textfield,
'message_textfield': message_textfield,
'exclude_sites': exclude_sites,
}
payload = json.dumps(decode_for_json(expected_settings))
def setUp(self):
super(PublishedControlPanelTestCase, self).setUp()
self.grant('Manager')
api.portal.get_tool('portal_setup').runAllImportStepsFromProfile(
'profile-ftw.publisher.sender:default', ignore_dependencies=True)
def test_all_settings_are_tested(self):
"""
This test will fail if new settings are added to "IStatusMessageConfigForm"
without having been added in this test case.
"""
self.assertEqual(
set(self.expected_settings.keys()),
set(getFieldNames(IStatusMessageConfigForm)),
msg=
'Have you added some fields to "IStatusMessageConfigForm" without updating the test case?'
)
@browsing
def test_sender(self, browser):
intercepted_data = {}
class MockedReceiverView(BrowserView):
def __call__(self):
intercepted_data['jsondata'] = self.request.form.get(
'jsondata')
return createResponse(SuccessState())
config = IConfig(self.portal)
config.appendRealm(
Realm(1, self.portal.absolute_url(), SITE_OWNER_NAME,
SITE_OWNER_PASSWORD))
transaction.commit()
with view_registered(MockedReceiverView,
'global_statusmessage_config_receiver',
required=(IPloneSiteRoot, Interface)):
browser.login(SITE_OWNER_NAME).open(
view='@@global_statusmessage_config')
browser.fill(self.form_data)
browser.click_on('Save and publish')
self.assertDictEqual(
self.expected_settings,
encode_after_json(json.loads(intercepted_data['jsondata'])))
self.assertEqual(['Changes saved and published.'], info_messages())
@browsing
def test_receiver(self, browser):
browser.login().open(self.portal,
view='@@global_statusmessage_config_receiver',
data={'jsondata': self.payload})
registry = getUtility(IRegistry)
settings = registry.forInterface(IStatusMessageConfigForm, check=False)
self.assertDictEqual(
{
field_name: getattr(settings, field_name)
for field_name in getFieldNames(IStatusMessageConfigForm)
}, self.expected_settings)
def _get_field_data(self, obj):
collector = self._get_collector_for(obj)
data = collector.getData()
data = utils.decode_for_json(data)
data = dumps(data)
return data
