def test_browser__EventView__8(address_book, EventViewConfigurationFactory,
EventFactory, FieldFactory, PersonFactory,
DateTime, browser):
"""It renders the selected fields."""
field_name = FieldFactory(address_book, IEvent, 'Int', u'seats').__name__
EventFactory(
address_book, **{
'datetime': DateTime.now,
field_name: 42,
'external_persons': [u'Berta Vimladil'],
'persons': set([PersonFactory(address_book, u'Tester')]),
'text': u'to be canceled',
})
event_entity = IEntity(IEvent)
EventViewConfigurationFactory(address_book,
u'-1 day for 1 week',
start=-1,
duration=7,
fields=[
event_entity.getRawField('persons'),
event_entity.getRawField(field_name)
])
browser.login('cal-visitor')
browser.open(browser.CALENDAR_EVENT_VIEWS_URL)
assert '>Berta Vimladil, Tester<' in browser.ucontents
assert '>42<' in browser.ucontents
assert 'to be canceled' not in browser.ucontents
def test_person__PersonEditGroup__1(person_data, browser):
"""`PersonEditGroup` respects the user defined field sort order."""
browser.login('editor')
postal_address_entity = IEntity(IPostalAddress)
# When switching the address prefix and the street name of the postal
# address the person edit form changes accordingly:
with zope.component.hooks.site(person_data):
postal_address_entity.setFieldOrder(('street', 'address_prefix'))
browser.open(browser.PERSON_EDIT_URL)
assert [
'Person_0.first_name', 'Person_0.last_name', 'Person_0.birth_date',
'Person_0.keywords:list', 'Person_0.notes',
'defaults.default_postal_address:list',
'defaults.default_phone_number:list',
'defaults.default_email_address:list',
'defaults.default_home_page_address:list', 'Postaladdress_0.street',
'Postaladdress_0.address_prefix', 'Postaladdress_0.city',
'Postaladdress_0.zip', 'Postaladdress_0.country:list',
'Postaladdress_1.street', 'Postaladdress_1.address_prefix',
'Postaladdress_1.city', 'Postaladdress_1.zip',
'Postaladdress_1.country:list', 'Phonenumber_0.number',
'Phonenumber_1.number', 'Emailaddress_0.email', 'Emailaddress_1.email',
'Homepageaddress_0.url', 'Homepageaddress_1.url', 'buttons.apply',
'buttons.clone_person', 'buttons.archive_person',
'buttons.delete_person', 'buttons.delete_entry', 'buttons.export',
'buttons.cancel'
] == form_fields_names(browser)
def entity_values(iface):
entity = IEntity(iface)
for name, field in entity.getRawFields():
bound = get_bound_schema_field(person, entity, field)
value = bound.get(bound.context)
if value and field.title != 'country':
yield field.title, value
def test_calendar__CalendarView__1(address_book, FieldFactory, browser):
"""It allows to select fields for display in the calendar."""
field = FieldFactory(
address_book, IEvent, u'Int', u'reservations').__name__
browser.login('cal-editor')
browser.open(browser.CALENDAR_MASTERDATA_URL)
browser.getLink('Calendar view').click()
assert browser.CALENDAR_MASTERDATA_EDIT_DISPLAY_URL == browser.url
browser.getControl('Additional event fields').displayValue = [
'persons',
'reservations',
]
browser.getControl('Save').click()
assert 'Data successfully updated.' == browser.message
browser.open(browser.CALENDAR_MASTERDATA_EDIT_DISPLAY_URL)
assert browser.getControl('Additional event fields').displayValue == [
'persons',
'reservations',
]
# It does not break on selected but deleted user defined field:
with zope.component.hooks.site(address_book):
event_entity = IEntity(IEvent)
event_entity.removeField(event_entity.getRawField(field))
browser.open(browser.CALENDAR_MASTERDATA_EDIT_DISPLAY_URL)
assert browser.getControl('Additional event fields').displayValue == [
'persons',
]
def test_person__PersonDefaultsEntity__getRawFields__1(address_book):
"""It returns the fields in default sort order if no order is defined."""
entity = IEntity(IPersonDefaults)
assert ([
'default_postal_address',
'default_phone_number',
'default_email_address',
'default_home_page_address',
] == [x[0] for x in entity.getRawFields()])
def get_table_event(event, field_names=[], request_kw={}):
request = RequestFactory(**request_kw)
event_entity = IEntity(IEvent)
ICalendarDisplaySettings(
address_book.calendar).event_additional_fields = [
event_entity.getRawField(x) for x in field_names
]
event_description = IEventDescription(event)
return zope.component.getMultiAdapter((event_description, request),
name='table-event')
def test_person__PersonDefaultsEntity__getRawFields__3(address_book):
"""It returns the fields in default order if called whih `sorted=False`."""
entity = IEntity(IPersonDefaults)
zope.component.getUtility(IEntityOrder).up(IEntity(IPhoneNumber))
assert ([
'default_postal_address',
'default_phone_number',
'default_email_address',
'default_home_page_address',
] == [x[0] for x in entity.getRawFields(sorted=False)])
def test_simple__CompleteExport__5(address_book, ):
"""`CompleteExport` respects the user defined field sort order."""
person_entity = IEntity(IPerson)
person_entity.setFieldOrder(('last_name', 'first_name'))
export = icemac.addressbook.export.xls.simple.CompleteExport([]).export()
xls_workbook = xlrd.open_workbook(file_contents=export)
work_sheet_0 = xls_workbook.sheet_by_index(0)
assert (2, 5) == (work_sheet_0.nrows, work_sheet_0.ncols)
assert ([
[u'person', '', '', '', ''],
[u'last name', u'first name', u'birth date', u'keywords', u'notes']
] == [work_sheet_0.row_values(rx) for rx in range(work_sheet_0.nrows)])
def test_person__AddGroup__1(address_book, browser):
"""`AddGroup` respects the user definded field sort order."""
browser.login('editor')
person_entity = IEntity(IPerson)
# When switching the first name and the last name of the person the person
# add form changes accordingly:
person_entity.setFieldOrder(('last_name', 'first_name'))
browser.open(browser.PERSON_ADD_URL)
assert [
'Person.last_name', 'Person.first_name', 'Person.birth_date',
'Person.keywords:list', 'Person.notes', 'Postaladdress.address_prefix',
'Postaladdress.street', 'Postaladdress.city', 'Postaladdress.zip',
'Postaladdress.country:list', 'Phonenumber.number',
'Emailaddress.email', 'Homepageaddress.url', 'buttons.add',
'buttons.cancel'
] == form_fields_names(browser)
def test_person__PersonEditForm__11(person_data, browser):
"""`PersonEditForm` respects the user defined entity sort order."""
browser.login('editor')
person_entity = IEntity(IPerson)
with zope.component.hooks.site(person_data):
order = zope.component.getUtility(IEntityOrder)
# When moving the person one position down, the sort order changes
# accordingly:
order.down(person_entity, delta=1)
browser.open(browser.PERSON_EDIT_URL)
assert [
'defaults.default_postal_address:list',
'defaults.default_phone_number:list',
'defaults.default_email_address:list',
'defaults.default_home_page_address:list', 'Person_0.first_name',
'Person_0.last_name', 'Person_0.birth_date', 'Person_0.keywords:list',
'Person_0.notes', 'Postaladdress_0.address_prefix',
'Postaladdress_0.street', 'Postaladdress_0.city',
'Postaladdress_0.zip', 'Postaladdress_0.country:list',
'Postaladdress_1.address_prefix', 'Postaladdress_1.street',
'Postaladdress_1.city', 'Postaladdress_1.zip',
'Postaladdress_1.country:list', 'Phonenumber_0.number',
'Phonenumber_1.number', 'Emailaddress_0.email', 'Emailaddress_1.email',
'Homepageaddress_0.url', 'Homepageaddress_1.url', 'buttons.apply',
'buttons.clone_person', 'buttons.archive_person',
'buttons.delete_person', 'buttons.delete_entry', 'buttons.export',
'buttons.cancel'
] == form_fields_names(browser)
def test_simple__CompleteExport__4(address_book, PersonFactory,
PhoneNumberFactory):
"""`CompleteExport` respects the user defined entity sort order."""
person = PersonFactory(address_book, u'Tester')
PhoneNumberFactory(person, number=u'+48-123-321', set_as_default=True)
PhoneNumberFactory(person, number=u'+321-48-84', set_as_default=False)
entity_order = zope.component.getUtility(IEntityOrder)
phone_number_entity = IEntity(IPhoneNumber)
entity_order.up(phone_number_entity, 1)
export = icemac.addressbook.export.xls.simple.CompleteExport([person
]).export()
xls_workbook = xlrd.open_workbook(file_contents=export)
work_sheet_0 = xls_workbook.sheet_by_index(0)
assert (3, 7) == (work_sheet_0.nrows, work_sheet_0.ncols)
assert ([
[
u'person', '', '', '', '', u'main phone number',
u'other phone number'
],
[
u'first name', u'last name', u'birth date', u'keywords', u'notes',
u'number', u'number'
], ['', u'Tester', '', '', '', u'+48-123-321', u'+321-48-84']
] == [work_sheet_0.row_values(rx) for rx in range(work_sheet_0.nrows)])
def test_calendar__EventDescription__getInfo__2(address_book, EventFactory,
DateTime, CategoryFactory,
selected_user_field,
utc_time_zone_pref):
"""It ignores a selected but later deleted user defined field."""
ed = IEventDescription(
EventFactory(
address_book, **{
'datetime': DateTime.now,
'text': u'Text1',
'category': CategoryFactory(address_book, u'bar'),
selected_user_field: 42
}))
event_entity = IEntity(IEvent)
event_entity.removeField(event_entity.getRawField(selected_user_field))
assert ['Text1'] == ed.getInfo()
def test_event___get_field_name_on_IEvent__2(address_book, FieldFactory):
"""It returns `None` if the fields do not match exactly."""
FieldFactory(address_book, IEvent, u'Choice', u'foo', values=[u'a'])
revent_field = FieldFactory(address_book,
IRecurringEvent,
u'Choice',
u'foo',
values=[u'a', u'b'])
assert None is _get_field_name_on_IEvent(revent_field, IEntity(IEvent))
def test_event___get_field_name_on_IEvent__1(address_book, FieldFactory):
"""It only returns the field name if the title type and the value match ...
between event and recurring event.
"""
event_field = FieldFactory(address_book, IEvent, u'Bool', u'foo')
revent_field = FieldFactory(address_book, IRecurringEvent, u'Bool', u'foo')
assert (event_field.__name__ == _get_field_name_on_IEvent(
revent_field, IEntity(IEvent)))
def test_entities__PersistentEntities__getMainEntities__2(entityOrder):
"""`getMainEntities()` respects a changed sort order."""
entityOrder.up(IEntity(IPhoneNumber))
assert ([
u'person', u'phone number', u'postal address', u'e-mail address',
u'home page address'
] == getMainEntities_titles(True))
# The unordered variant still returns the default order:
assert DEFAULT_ORDER == getMainEntities_titles(False)
def test_fields__SaveSortorder__1(address_book, FieldFactory, browser):
"""The sort order of the fields of the entities can be changed globally.
To show that the sort order includes user defined fields.
The places where fields are displayed in order are changed accordingly.
"""
FieldFactory(address_book, IPerson, 'Bool', u'grown-up')
# There is no field order saved yet:
assert [] == IEntity(IPerson).getFieldOrder()
browser.login('mgr')
# The sort order is changed using JavaScript (tested using Selenium). When
# the user hits the `Save sortorder` button a URL is generated and sent to
# the server:
browser.open(browser.ENTITY_PERSON_LIST_FIELDS_URL +
'/@@save-sortorder.html?f:list=last_name&f:list=Field-1')
assert 'Saved sortorder.' == browser.message
with zope.component.hooks.site(address_book):
assert [u'last_name', u'Field-1'] == IEntity(IPerson).getFieldOrder()
def test_entities__EntityOrder__get__4(entityOrder, AddressBookFactory):
"""It accesses the address book in `zope.component.hooks.site`."""
other_address_book = AddressBookFactory('other_address_book')
# Changes in an address book ...
person = IEntity(IPerson)
assert 1 == entityOrder.get(person)
entityOrder.down(person)
assert 2 == entityOrder.get(person)
# ... are not reflected in another address book:
with zope.component.hooks.site(other_address_book):
assert 1 == entityOrder.get(person)
def test_simple__DefaultsExport__5(address_book):
"""`DefaultsExport` respects the user defined field sort order."""
person_entity = IEntity(IPerson)
person_entity.setFieldOrder(('last_name', 'first_name'))
export = icemac.addressbook.export.xls.simple.DefaultsExport([]).export()
xls_workbook = xlrd.open_workbook(file_contents=export)
work_sheet_0 = xls_workbook.sheet_by_index(0)
assert (2, 13) == (work_sheet_0.nrows, work_sheet_0.ncols)
assert [[
u'person', '', '', '', '', u'postal address', '', '', '', '',
u'phone number', u'e-mail address', u'home page address'
],
[
u'last name', u'first name', u'birth date', u'keywords',
u'notes', u'address prefix', u'street', u'city', u'zip',
u'country', u'number', u'e-mail address', u'URL'
]] == [
work_sheet_0.row_values(rx) for rx in range(work_sheet_0.nrows)
]
def _get_prefs_mock(*columns, **kw):
"""Get a mock for the preferences.
columns ... show these columns in person lists
has to be tuples (<entity interface>, <field name>)
**kw might have the following keys:
order_by ... order the columns in person lists by this tuple of
(<entity interface>, <field name>)
Default: (IPerson, 'last_name')
"""
prefs_mock = Mock()
prefs_mock.personListTab.batch_size = 20
prefs_mock.personLists.sort_direction = 'ascending'
prefs_mock.personLists.columns = [
tokenize(IEntity(iface), field_name) for iface, field_name in columns
]
order_entitiy, order_field = kw.pop('order_by', (IPerson, 'last_name'))
prefs_mock.personLists.order_by = tokenize(IEntity(order_entitiy),
order_field)
if 'sort_direction' in kw:
prefs_mock.personLists.sort_direction = kw['sort_direction']
return prefs_mock
def test_browser__CategoryEditForm__13(address_book, browser):
"""The orderBy field of CategoryEditForm respects changes in sort order."""
phone_number_entity = IEntity(IPhoneNumber)
order = zope.component.getUtility(IEntityOrder)
# When moving the phone number one position down, the sort order in the
# order by field changes accordingly:
order.down(phone_number_entity)
browser.login('visitor')
browser.open(browser.PREFS_URL)
assert ([
'person -- first name', 'person -- last name', 'person -- birth date',
'person -- keywords', 'person -- notes',
'postal address -- address prefix', 'postal address -- street',
'postal address -- city', 'postal address -- zip',
'postal address -- country', 'e-mail address -- e-mail address',
'phone number -- number', 'home page address -- URL'
] == browser.getControl('order by').displayOptions)
def test_person__PersonAddForm__9(address_book, browser):
"""`PersonAddForm` respects the the user defined entity sort order."""
browser.login('editor')
postal_address_entity = IEntity(IPostalAddress)
order = zope.component.getUtility(IEntityOrder)
# When moving the postal address two positions up, the sort order in the
# person add form changes accordingly:
order.up(postal_address_entity, delta=2)
browser.open(browser.PERSON_ADD_URL)
assert [
'Postaladdress.address_prefix', 'Postaladdress.street',
'Postaladdress.city', 'Postaladdress.zip',
'Postaladdress.country:list', 'Person.first_name', 'Person.last_name',
'Person.birth_date', 'Person.keywords:list', 'Person.notes',
'Phonenumber.number', 'Emailaddress.email', 'Homepageaddress.url',
'buttons.add', 'buttons.cancel'
] == form_fields_names(browser)
def test_person__DefaultSelectGroup__2(person_data, browser):
"""`DefaultSelectGroup` respects the user defined entity sort order."""
browser.login('editor')
# The default sort order is tested in test_person__PersonEditForm__10!
postal_address_entity = IEntity(IPostalAddress)
with zope.component.hooks.site(person_data):
order = zope.component.getUtility(IEntityOrder)
# When moving the postal address one position down, the sort order
# changes accordingly:
order.down(postal_address_entity, delta=1)
browser.open(browser.PERSON_EDIT_URL)
assert ([
'default_phone_number', 'default_postal_address',
'default_email_address', 'default_home_page_address'
] == [
x.replace('defaults.', '').replace(':list', '')
for x in form_fields_names(browser) if x.startswith('defaults.')
])
def test_entities__entity_by_name__6(stubEntities, entityAdapters):
"""`entity_by_name` adapts from unicode entity name."""
assert stubEntities.duck == IEntity(u'IcemacAddressbookTestsConftestDuck')
def minimalEntity(address_book):
"""Get an entity which is not registered in the address book."""
return IEntity(IEntities)
def test_entities__Entity__removeField__3(entity_with_field, field):
"""It removes the adapter registrations for the field."""
entity_with_field.removeField(field)
assert None is zope.component.queryMultiAdapter(
(entity, Dummy()), IField, name=u'Field')
assert None is IEntity(field, None)
def test_entities__entity_for_field__1(address_book, field):
"""It adapts a field to its entity."""
address_book_entity.addField(field)
adapted_field = IEntity(field)
assert address_book_entity == adapted_field
def test_entities__entity_by_obj__2(stubEntities, entityAdapters):
"""`entity_by_obj` returns the instance for a known instance."""
assert stubEntities.kwack == IEntity(Kwack())
def test_entities__entity_by_obj__1(stubEntities, entityAdapters):
"""`entity_by_obj` raises a ValueError for an unknown instance."""
obj = persistent.Persistent()
with pytest.raises(ValueError):
IEntity(obj)
def test_entities__entity_by_interface__2(stubEntities, entityAdapters):
"""`entity_by_interface` returns the entity for a known interface."""
assert stubEntities.kwack == IEntity(IKwack)
def test_entities__entity_by_interface__1(stubEntities, entityAdapters):
"""`entity_by_interface` returns a minimal entity for unknown interface."""
entity = IEntity(IDog)
assert None is entity.title
assert IDog is entity.interface
assert None is entity.class_name
