def test_icon_registry02(self):
"get_4_instance()"
icon_reg = IconRegistry()
icon_reg.register(FakeContact, 'images/contact_%(size)s.png')
icon_reg.register(FakeOrganisation, 'images/organisation_%(size)s.png')
phone_label = 'Contact with phone'
email_label = 'Contact with email'
icon_reg.register_4_instance(
FakeContact, lambda instance: ('phone', phone_label)
if instance.phone else ('email', email_label))
c = FakeContact(first_name='Casca', last_name='Mylove')
icon1 = icon_reg.get_4_instance(instance=c,
theme='icecream',
size_px=22)
self.assertIsInstance(icon1, Icon)
self.assertIn('icecream/images/email_22', icon1.url)
self.assertEqual(email_label, icon1.label)
c.phone = '123456'
icon2 = icon_reg.get_4_instance(instance=c,
theme='icecream',
size_px=22)
self.assertIn('icecream/images/phone_22', icon2.url)
self.assertEqual(phone_label, icon2.label)
o = FakeOrganisation(name='Midland')
icon3 = icon_reg.get_4_instance(instance=o,
theme='icecream',
size_px=22)
self.assertIn('icecream/images/organisation_22', icon3.url)
self.assertEqual('Test Organisation', icon3.label)
def test_fk_printer01(self):
user = self.login()
c = FakeContact()
field1 = c._meta.get_field('sector')
FKPrinter = field_printers.FKPrinter
printer = FKPrinter(none_printer=FKPrinter.print_fk_null_html,
default_printer=field_printers.simple_print_html,
)
self.assertEqual('', printer(c, None, user, field1))
sector = FakeSector.objects.first()
self.assertEqual(str(sector), printer(c, sector, user, field1))
# entity without specific handler ---
img = FakeImage.objects.create(user=user, name='Img#1')
field2 = c._meta.get_field('image')
self.assertEqual(str(img), printer(c, img, user, field2))
# null_label ---
field3 = c._meta.get_field('is_user')
self.assertEqual(
'<em>{}</em>'.format(pgettext('persons-is_user', 'None')),
printer(c, None, user, field3)
)
def test_print_text_html(self):
c = FakeContact()
user = CremeUser()
field = c._meta.get_field('description')
self.assertEqual('', field_printers.print_text_html(c, None, user, field))
text = 'See you <b>space</b> cowboy...\nThe real folk blues: www.bebop.org'
with override_settings(URLIZE_TARGET_BLANK=True):
p1 = field_printers.print_text_html(c, user=user, field=field, fval=text)
self.assertEqual(
'<p>See you <b>space</b> cowboy...<br>The real folk blues: '
'<a target="_blank" rel="noopener noreferrer" href="http://www.bebop.org">www.bebop.org</a>'
'</p>',
p1
)
with override_settings(URLIZE_TARGET_BLANK=False):
p2 = field_printers.print_text_html(c, user=user, field=field, fval=text)
self.assertEqual(
'<p>See you <b>space</b> cowboy...<br>The real folk blues: '
'<a href="http://www.bebop.org">www.bebop.org</a>'
'</p>',
p2
)
def test_entity_edition03(self):
"ValidationError + cancel_url."
user = self.login()
contact = FakeContact.objects.create(
user=user,
first_name='Spik',
last_name='Spiegel',
)
url = contact.get_edit_absolute_url()
lv_url = FakeContact.get_lv_absolute_url()
response = self.assertGET200(url,
HTTP_REFERER='http://testserver' + lv_url)
self.assertEqual(lv_url, response.context.get('cancel_url'))
response = self.client.post(
url,
follow=True,
data={
'user': user.id,
'first_name': 'Spike',
# 'last_name': last_name, # NB: Missing
'cancel_url': lv_url,
},
)
self.assertFormError(response, 'form', 'last_name',
_('This field is required.'))
self.assertEqual(lv_url, response.context.get('cancel_url'))
def test_export_error_invalid_hfilter(self):
self.login()
lv_url = FakeContact.get_lv_absolute_url()
build_url = partial(self._build_dl_url,
ct_or_model=self.ct,
list_url=lv_url)
# HeaderFilter does not exist
self.assertGET404(build_url())
# HeaderFilter not given
self.assertGET404(build_url(hfilter_id=None))
# Unknown HeaderFilter id
self.assertGET404(build_url(hfilter_id='test-hf_contact-unknown'))
# HeaderFilter with wrong content type
hf = HeaderFilter.objects.create_if_needed(
pk='test-hf_contact_test_invalid_hfilter',
name='Contact view',
model=FakeContact,
cells_desc=[
(EntityCellRegularField, {
'name': 'last_name'
}),
(EntityCellRegularField, {
'name': 'created'
}),
],
)
self.assertGET404(
build_url(ct_or_model=FakeEmailCampaign, hfilter_id=hf.id))
def test_cell_render04(self):
"Assignment"
user = self.login()
ripley = FakeContact(user=user,
first_name='Helen',
last_name='Ripley',
email='*****@*****.**')
cell = EntityCellRegularField.build(model=FakeContact, name='email')
with self.assertNoException():
template = Template(
r'{% load creme_cells %}'
r'{% cell_render cell=cell instance=helen user=user as cell_content %}'
r'{{cell_content}}')
render = template.render(
Context({
'cell': cell,
'helen': ripley,
'user': user
}))
self.assertEqual(
'<a href="mailto:[email protected]">[email protected]</a>',
render.strip())
# TODO: missing argument ?
def setUpClass(cls):
super().setUpClass()
cls.factory = RequestFactory()
cls.user = CremeUser(username='******', email='*****@*****.**',
first_name='Yui', last_name='Kawa',
)
cls.url = FakeContact.get_lv_absolute_url()
def test_changed02(self):
baction = BatchAction(FakeContact, 'last_name', 'rm_substr', value='Foobar')
first_name = 'Haruhi'
last_name = 'Suzumiya'
haruhi = FakeContact(first_name=first_name, last_name=last_name)
self.assertFalse(baction(haruhi))
self.assertEqual(last_name, haruhi.last_name)
self.assertEqual(first_name, haruhi.first_name)
def test_print_boolean_csv(self):
c = FakeContact()
user = CremeUser()
field = c._meta.get_field('is_a_nerd')
self.assertEqual('', print_boolean_csv(c, None, user, field))
self.assertEqual(_('Yes'), print_boolean_csv(c, True, user, field))
self.assertEqual(_('No'), print_boolean_csv(c, False, user, field))
def test_print_foreignkey_csv02(self):
"No view credentials."
user = self.login(is_superuser=False)
c = FakeContact()
img = FakeImage.objects.create(user=user, name='Img#1')
field = c._meta.get_field('image')
self.assertEqual(settings.HIDDEN_VALUE,
print_foreignkey_csv(c, img, user, field))
def test_edit01(self):
self.login()
field1 = 'first_name'
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=True,
cells_desc=[
EntityCellRegularField.build(model=FakeContact, name=field1)
],
)
url = hf.get_edit_absolute_url()
response = self.assertGET200(url)
self.assertTemplateUsed(response,
'creme_core/forms/header-filter.html')
self.assertIn(
_('Edit the view of list «%(view)s»') % {'view': hf.name},
response.content.decode())
with self.assertNoException():
context = response.context
cells_f = context['form'].fields['cells']
submit_label = context['submit_label']
self.assertCellsEqual(hf.cells, cells_f.initial)
self.assertEqual(_('Save the modified view'), submit_label)
name = 'Entity view v2'
field2 = 'last_name'
response = self.client.post(
url,
data={
'name':
name,
'cells':
'regular_field-{},'
'regular_field-{}'.format(
field1,
field2,
),
},
)
self.assertNoFormError(response, status=302)
hf = self.refresh(hf)
self.assertEqual(name, hf.name)
self.assertTrue(hf.is_custom)
cells = hf.cells
self.assertEqual(2, len(cells))
self.assertEqual(field1, cells[0].value)
self.assertEqual(field2, cells[1].value)
self.assertRedirects(response, FakeContact.get_lv_absolute_url())
def test_print_date(self):
c = FakeContact()
user = CremeUser()
field = c._meta.get_field('birthday')
self.assertEqual('', print_date(c, None, user, field))
value = date(year=2019, month=8, day=21)
self.assertEqual(date_format(value, 'DATE_FORMAT'),
print_date(c, value, user, field))
def test_button_registry01(self):
class TestButton1(Button):
id_ = Button.generate_id('creme_core', 'test_button_registry_1')
class TestButton2(Button):
id_ = Button.generate_id('creme_core', 'test_button_registry_2')
def ok_4_display(self, entity):
return False
class TestButton3(Button):
id_ = Button.generate_id('creme_core', 'test_button_registry_3')
class TestButton4(Button):
id_ = Button.generate_id('creme_core', 'test_button_registry_4')
registry = ButtonsRegistry()
registry.register(TestButton1, TestButton2, TestButton3, TestButton4)
class DuplicatedTestButton(Button):
id_ = TestButton1.id_
with self.assertRaises(ButtonsRegistry.RegistrationError):
registry.register(DuplicatedTestButton)
get = registry.get_button
self.assertIsInstance(get(TestButton1.id_), TestButton1)
self.assertIsInstance(get(TestButton2.id_), TestButton2)
self.assertIsNone(
get(
Button.generate_id('creme_core',
'test_button_registry_invalid')))
c = FakeContact(first_name='Casca', last_name='Mylove')
buttons = [
*registry.get_buttons(
[
TestButton3.id_,
TestButton2.id_, # No because ok_4_display() returns False
'test_button_registry_invalid',
TestButton1.id_,
],
entity=c,
),
]
self.assertIsList(buttons, length=2)
self.assertIsInstance(buttons[0], TestButton3)
self.assertIsInstance(buttons[1], TestButton1)
all_button_items = [*registry]
self.assertEqual(4, len(all_button_items))
button_item = all_button_items[0]
self.assertIsInstance(button_item[1], Button)
self.assertEqual(button_item[0], button_item[1].id_)
def test_print_boolean_html(self):
c = FakeContact()
user = CremeUser()
field = c._meta.get_field('is_a_nerd')
self.assertEqual('', print_boolean_html(c, None, user, field))
self.assertEqual(
'<input type="checkbox" checked disabled/>{}'.format(_('Yes')),
print_boolean_html(c, True, user, field))
self.assertEqual('<input type="checkbox" disabled/>{}'.format(_('No')),
print_boolean_html(c, False, user, field))
def test_print_unsafehtml_html(self):
c = FakeContact()
user = CremeUser()
field = c._meta.get_field('description')
self.assertEqual('', field_printers.print_unsafehtml_html(c, None, user, field))
self.assertEqual(
'<p><p>See you space cowboy...</p></p>',
field_printers.print_unsafehtml_html(
c, user=user, field=field,
fval='<p>See you space cowboy...</p>',
)
)
def test_cell_4_regularfield04(self):
"No assignment"
user = self.login()
ripley = FakeContact(user=user, first_name='Helen', last_name='Ripley')
with self.assertNoException():
template = Template(
r'{% load creme_cells %}'
r'{% cell_4_regularfield instance=helen field="first_name" %}')
render = template.render(Context({'helen': ripley}))
self.assertEqual(_(u'First name'), render.strip())
def test_fk_printer02(self):
"CremeEntity."
user = self.create_user()
c = FakeContact()
field = c._meta.get_field('image')
printer = FKPrinter(
none_printer=FKPrinter.print_fk_null_html,
default_printer=simple_print_html,
).register(CremeEntity, FKPrinter.print_fk_entity_html)
img = FakeImage.objects.create(user=user, name='Img#1')
self.assertEqual(f'<a href="{img.get_absolute_url()}">{img}</a>',
printer(c, img, user, field))
def test_simple_print_csv(self):
c = FakeContact()
user = CremeUser()
field = c._meta.get_field('first_name')
self.assertEqual(
'',
field_printers.simple_print_csv(c, fval=None, user=user, field=field)
)
value = 'Rei'
self.assertEqual(
value,
field_printers.simple_print_csv(c, value, user, field)
)
def test_print_email_html(self):
c = FakeContact()
user = CremeUser()
field = c._meta.get_field('email')
self.assertEqual('', print_email_html(c, None, user, field))
value1 = '*****@*****.**'
self.assertEqual(f'<a href="mailto:{value1}">{value1}</a>',
print_email_html(c, value1, user, field))
value2 = '</a><script>Muhahaha</script>[email protected]'
self.assertEqual(
'<a href="mailto:{email}">{email}</a>'.format(
email=escape(value2)),
print_email_html(c, value2, user, field))
def test_simple_print_html(self):
c = FakeContact()
user = CremeUser()
field = c._meta.get_field('first_name')
self.assertEqual('', field_printers.simple_print_html(c, fval=None, user=user, field=field))
value = 'Rei'
self.assertEqual(
value,
field_printers.simple_print_html(c, value, user, field)
)
self.assertEqual(
'<b>Rei<b>',
field_printers.simple_print_html(c, '<b>Rei<b>', user, field)
)
def test_cell_4_regularfield03(self):
"By instance"
user = self.login()
ripley = FakeContact(user=user, first_name='Helen', last_name='Ripley')
with self.assertNoException():
template = Template(
r'{% load creme_cells %}'
r'{% cell_4_regularfield instance=helen field="first_name" as fname_cell %}'
r'{% cell_4_regularfield instance=helen field="last_name" as lname_cell %}'
r'{{fname_cell.key}}#{{lname_cell.key}}')
render = template.render(Context({'helen': ripley}))
self.assertEqual('regular_field-first_name#regular_field-last_name',
render.strip())
def test_cell_render01(self):
"Direct render ; default output."
user = self.create_user()
ripley = FakeContact(user=user, first_name='Helen', last_name='Ripley')
cell = EntityCellRegularField.build(model=FakeContact, name='last_name')
with self.assertNoException():
template = Template(
r'{% load creme_cells %}'
r'{% cell_render cell=cell instance=helen user=user %}'
)
render = template.render(Context({
'cell': cell, 'helen': ripley, 'user': user,
}))
self.assertEqual(ripley.last_name, render.strip())
def test_print_foreignkey_csv01(self):
user = self.create_user()
c = FakeContact()
field1 = c._meta.get_field('sector')
self.assertEqual('', print_foreignkey_csv(c, None, user, field1))
sector = FakeSector.objects.first()
self.assertEqual(str(sector),
print_foreignkey_csv(c, sector, user, field1))
# entity (credentials OK)
img = FakeImage.objects.create(user=user, name='Img#1')
field2 = c._meta.get_field('image')
self.assertEqual(str(img), print_foreignkey_csv(c, img, user, field2))
def test_entity_creation02(self):
"ValidationError + cancel_url"
user = self.login()
url = reverse('creme_core__create_fake_contact')
lv_url = FakeContact.get_lv_absolute_url()
response = self.assertGET200(url, HTTP_REFERER='http://testserver' + lv_url)
self.assertEqual(lv_url, response.context.get('cancel_url'))
response = self.client.post(url, follow=True,
data={'user': user.id,
# 'last_name': name, # NB: Missing
'cancel_url': lv_url,
}
)
self.assertFormError(response, 'form', 'last_name', _('This field is required.'))
self.assertEqual(lv_url, response.context.get('cancel_url'))
def test_manager_compatible01(self):
orig_compat_ids = self.build_compatible_set()
orig_internal_compat_ids = self.build_compatible_set(
include_internals=True)
create_rtype = RelationType.create
rtype = create_rtype(
('test-subject_foobar', 'manages', [FakeContact]),
('test-object_foobar', 'is managed by', [FakeOrganisation]))[0]
internal_rtype = create_rtype(
('test-subject_foobar_2', 'manages internal', [FakeContact]),
('test-object_foobar_2', 'is managed by internal',
[FakeOrganisation]),
is_internal=True,
)[0]
compatibles_ids = self.build_compatible_set()
self.assertEqual(len(orig_compat_ids) + 1, len(compatibles_ids))
self.assertIn(rtype.id, compatibles_ids)
compatibles_internal_ids = self.build_compatible_set(
include_internals=True)
self.assertEqual(
len(orig_internal_compat_ids) + 2, len(compatibles_internal_ids))
self.assertIn(rtype.id, compatibles_internal_ids)
self.assertIn(internal_rtype.id, compatibles_internal_ids)
contact_ct = self.contact_ct
self.assertTrue(rtype.is_compatible(contact_ct.id))
self.assertTrue(rtype.is_compatible(contact_ct))
self.assertTrue(rtype.is_compatible(str(contact_ct.id)))
self.assertTrue(rtype.is_compatible(FakeContact))
self.assertTrue(rtype.is_compatible(FakeContact()))
orga_ct = ContentType.objects.get_for_model(FakeOrganisation)
self.assertFalse(rtype.is_compatible(orga_ct.id))
self.assertFalse(rtype.is_compatible(orga_ct))
self.assertFalse(rtype.is_compatible(str(orga_ct.id)))
self.assertFalse(rtype.is_compatible(FakeOrganisation))
self.assertFalse(rtype.is_compatible(FakeOrganisation()))
# Model as argument
self.assertSetEqual(
compatibles_ids,
self.build_compatible_set(FakeContact),
)
def test_cell_render03(self):
"Direct render ; CSV output."
user = self.create_user()
ripley = FakeContact(
user=user, first_name='Helen', last_name='Ripley',
email='*****@*****.**',
)
cell = EntityCellRegularField.build(model=FakeContact, name='email')
with self.assertNoException():
template = Template(
r'{% load creme_cells %}'
r'{% cell_render cell=cell instance=helen user=user output="csv" %}'
)
render = template.render(Context({
'cell': cell, 'helen': ripley, 'user': user,
}))
self.assertEqual(ripley.email, render.strip())
def test_cell_render02(self):
"Direct render ; html output"
user = self.login()
ripley = FakeContact(user=user,
first_name='Helen',
last_name='Ripley',
email='*****@*****.**')
cell = EntityCellRegularField.build(model=FakeContact, name='email')
with self.assertNoException():
template = Template(
r'{% load creme_cells %}'
r'{% cell_render cell=cell instance=helen user=user output="html" %}'
)
render = template.render(
Context({
'cell': cell,
'helen': ripley,
'user': user
}))
self.assertEqual(
'<a href="mailto:[email protected]">[email protected]</a>',
render.strip())
def test_create02(self):
user = self.login()
lv_url = FakeContact.get_lv_absolute_url()
# Create a view to post the entity filter
HeaderFilter.create(
pk='creme_core-tests_views_header_filter_test_create02',
name='A FakeContact view', # Starts with "A" => first
model=FakeContact,
cells_desc=[
(EntityCellRegularField, {
'name': 'last_name'
}),
(EntityCellRegularField, {
'name': 'first_name'
}),
(EntityCellRegularField, {
'name': 'email'
}),
],
)
# Set a filter in the session (should be kept)
efilter = EntityFilter.create(
'creme_core-tests_views_header_filter_test_create02',
name='Misato',
model=FakeContact,
is_custom=True,
conditions=[
# EntityFilterCondition.build_4_field(
# model=FakeContact,
# operator=EntityFilterCondition.EQUALS,
# name='first_name', values=['Misato'],
# ),
RegularFieldConditionHandler.build_condition(
model=FakeContact,
field_name='first_name',
operator=EQUALS,
values=['Misato'],
),
],
)
response = self.assertPOST200(lv_url, data={'filter': efilter.id})
self.assertEqual(efilter.id,
response.context['list_view_state'].entity_filter_id)
# --
ct = self.contact_ct
loves = RelationType.create(('test-subject_love', 'Is loving'),
('test-object_love', 'Is loved by'))[0]
customfield = CustomField.objects.create(
name='Size (cm)',
field_type=CustomField.INT,
content_type=ct,
)
# funcfield = FakeContact.function_fields.get('get_pretty_properties')
funcfield = function_field_registry.get(FakeContact,
'get_pretty_properties')
url = self._build_add_url(ct)
response = self.assertGET200(url)
with self.assertNoException():
cells_f = response.context['form'].fields['cells']
build_4_field = partial(EntityCellRegularField.build,
model=FakeContact)
self.assertCellsEqual([
build_4_field(name='first_name'),
build_4_field(name='last_name'),
EntityCellRelation(
model=FakeContact,
rtype=RelationType.objects.get(pk=FAKE_REL_SUB_EMPLOYED_BY),
),
], cells_f.initial)
field_name = 'first_name'
name = 'DefaultHeaderFilter'
response = self.client.post(url,
follow=True,
data={
'name':
name,
'user':
user.id,
'is_private':
'on',
'cells':
'relation-{rtype},'
'regular_field-{rfield},'
'function_field-{ffield},'
'custom_field-{cfield}'.format(
rfield=field_name,
cfield=customfield.id,
rtype=loves.id,
ffield=funcfield.name,
)
})
self.assertNoFormError(response)
hfilter = self.get_object_or_fail(HeaderFilter, name=name)
self.assertEqual(user, hfilter.user)
self.assertTrue(hfilter.is_private)
cells = hfilter.cells
self.assertEqual(4, len(cells))
cell = cells[0]
self.assertIsInstance(cell, EntityCellRelation)
self.assertEqual(loves.id, cell.value)
cell = cells[1]
self.assertIsInstance(cell, EntityCellRegularField)
self.assertEqual(field_name, cell.value)
cell = cells[2]
self.assertIsInstance(cell, EntityCellFunctionField)
self.assertEqual(funcfield.name, cell.value)
cell = cells[3]
self.assertIsInstance(cell, EntityCellCustomField)
self.assertEqual(str(customfield.id), cell.value)
self.assertRedirects(response, lv_url)
# --
context = self.assertGET200(lv_url).context
selected_hfilter = context['header_filters'].selected
self.assertIsInstance(selected_hfilter, HeaderFilter)
self.assertEqual(hfilter.id, selected_hfilter.id)
lvs = context['list_view_state']
self.assertEqual(hfilter.id, lvs.header_filter_id)
self.assertEqual(efilter.id, lvs.entity_filter_id)
def test_list_view_export_with_filter01(self):
user = self.login()
hf = self._build_hf_n_contacts()
efilter = EntityFilter.objects.smart_update_or_create(
'test-filter01',
'Red',
FakeContact,
user=user,
is_custom=False,
conditions=[
RegularFieldConditionHandler.build_condition(
model=FakeContact,
field_name='last_name',
operator=ISTARTSWITH,
values=['Wong'],
)
],
)
existing_hline_ids = [
*HistoryLine.objects.values_list('id', flat=True)
]
response = self.assertGET200(
self._build_contact_dl_url(
list_url=FakeContact.get_lv_absolute_url(),
efilter_id=efilter.id))
result = [force_str(line) for line in response.content.splitlines()]
self.assertEqual(2, len(result))
self.assertEqual('"","Wong","Edward","","is a girl"', result[1])
# History
hlines = HistoryLine.objects.exclude(id__in=existing_hline_ids)
self.assertEqual(1, len(hlines))
hline = hlines[0]
self.assertListEqual([1, hf.name, efilter.name], hline.modifications)
self.assertListEqual(
[
_('Export of {count} «{model}» (view «{view}» & filter «{filter}»)'
).format(
count=1,
model='Test Contact',
view=hf.name,
filter=efilter.name,
),
],
hline.get_verbose_modifications(user),
)
self.assertHTMLEqual(
format_html(
'<div class="history-line history-line-mass_export">{}<div>',
_('Export of «%(counted_instances)s» (view «%(view)s» & filter «%(filter)s»)'
) % {
'counted_instances':
_('{count} {model}').format(
count=1,
model='Test Contact',
),
'view':
hf.name,
'filter':
efilter.name,
},
),
html_history_registry.line_explainers([hline], user)[0].render(),
)
def test_export_error_invalid_ctype(self):
self.login()
lv_url = FakeContact.get_lv_absolute_url()
self.assertGET404(self._build_dl_url(ct_or_model=None,
list_url=lv_url))
