def test_properties_functionfield01(self):
user = self.user
entity = CremeEntity.objects.create(user=user)
pp_ff = function_field_registry.get(CremeEntity,
'get_pretty_properties')
self.assertIsNotNone(pp_ff)
self.assertIsInstance(pp_ff, FunctionField)
self.assertEqual(_('Properties'), str(pp_ff.verbose_name))
self.assertFalse(pp_ff.is_hidden)
ptype1 = CremePropertyType.create(str_pk='test-prop_awesome',
text='Awesome')
CremeProperty.objects.create(type=ptype1, creme_entity=entity)
ptype2 = CremePropertyType.create(str_pk='test-prop_wonderful',
text='Wonderful')
CremeProperty.objects.create(type=ptype2, creme_entity=entity)
with self.assertNumQueries(1):
result = pp_ff(entity, user)
self.assertIsInstance(result, FunctionFieldResultsList)
self.assertEqual(
f'<ul>'
f'<li><a href="{ptype1.get_absolute_url()}">{ptype1.text}</a>'
f'</li><li><a href="{ptype2.get_absolute_url()}">{ptype2.text}</a></li>'
f'</ul>',
result.for_html(),
)
self.assertEqual('Awesome/Wonderful', result.for_csv())
def test_properties_functionfield02(self): # Prefetch with populate_entities()
user = self.user
create_entity = CremeEntity.objects.create
entity1 = create_entity(user=user)
entity2 = create_entity(user=user)
# pp_ff = CremeEntity.function_fields.get('get_pretty_properties')
pp_ff = function_field_registry.get(CremeEntity, 'get_pretty_properties')
ptype1 = CremePropertyType.create(str_pk='test-prop_awesome', text='Awesome')
ptype2 = CremePropertyType.create(str_pk='test-prop_wonderful', text='Wonderful')
create_prop = CremeProperty.objects.create
create_prop(type=ptype1, creme_entity=entity1)
create_prop(type=ptype2, creme_entity=entity1)
create_prop(type=ptype2, creme_entity=entity2)
pp_ff.populate_entities([entity1, entity2], user)
with self.assertNumQueries(0):
result1 = pp_ff(entity1, user)
result2 = pp_ff(entity2, user)
self.assertEqual('<ul><li><a href="{}">{}</a></li><li><a href="{}">{}</a></li></ul>'.format(
ptype1.get_absolute_url(), ptype1.text,
ptype2.get_absolute_url(), ptype2.text,
),
result1.for_html()
)
self.assertEqual('<ul><li><a href="{}">{}</a></li></ul>'.format(
ptype2.get_absolute_url(), ptype2.text,
),
result2.for_html()
)
def test_create04(self):
"Generate pk."
pk = 'test-prop_foobar'
CremePropertyType.create(str_pk=pk, text='is delicious')
text = 'is wonderful'
ptype = CremePropertyType.create(str_pk=pk, text=text, generate_pk=True)
self.assertEqual(pk + '1', ptype.id)
self.assertEqual(text, ptype.text)
def test_delete_type02(self):
self.login()
ptype = CremePropertyType.create('test-foobar',
'is beautiful', [],
is_custom=True)
response = self.assertPOST200(
ptype.get_delete_absolute_url(),
data={'id': ptype.id},
follow=True,
)
self.assertDoesNotExist(ptype)
self.assertRedirects(response, CremePropertyType.get_lv_absolute_url())
def test_delete_type02(self):
self.login(is_superuser=False, admin_4_apps=['creme_core'])
ptype = CremePropertyType.create(
'test-foobar',
'is beautiful',
[],
is_custom=True,
)
response = self.assertPOST200(ptype.get_delete_absolute_url(),
follow=True)
self.assertDoesNotExist(ptype)
self.assertRedirects(response, CremePropertyType.get_lv_absolute_url())
def test_create03(self):
"A property with the same name already exists"
self.login()
name = 'Industry'
pname = _('is in the segment «{}»').format(name)
CremePropertyType.create('commercial-marketsegmenttestcase01', pname)
response = self.assertPOST200(self.ADD_SEGMENT_URL, data={'name': name})
self.assertFormError(response, 'form', 'name',
_('A property with the name «%(name)s» already exists') % {'name': pname}
)
def test_edit03(self):
"A property with the same name already exists"
self.login()
segment = self._create_segment('in-dus-try')
name = 'Industry'
pname = _('is in the segment «{}»').format(name)
CremePropertyType.create('commercial-marketsegmenttestcase01', pname)
response = self.assertPOST200(segment.get_edit_absolute_url(), data={'name': name})
self.assertFormError(response, 'form', 'name',
_('A property with the name «%(name)s» already exists') % {'name': pname}
)
def test_reload_ptype_bricks01(self):
user = self.login()
ptype = CremePropertyType.create(str_pk='test-prop_murica',
text='is american')
rita = FakeContact.objects.create(user=user,
last_name='Vrataski',
first_name='Rita')
CremeProperty.objects.create(type=ptype, creme_entity=rita)
brick_id = 'block_creme_core-tagged-creme_core-fakecontact'
url = reverse('creme_core__reload_ptype_bricks', args=(ptype.id, ))
response = self.assertGET200(url, data={'brick_id': brick_id})
with self.assertNoException():
results = response.json()
self.assertIsList(results, length=1)
result = results[0]
self.assertIsList(result, length=2)
self.assertEqual(brick_id, result[0])
document = self.get_html_tree(result[1])
brick_node = self.get_brick_node(document, brick_id)
self.assertInstanceLink(brick_node, rita)
self.assertGET404(url, data={'brick_id': 'invalid_brickid'})
self.assertGET404(
url,
data={'brick_id': 'block_creme_core-tagged-persons-invalidmodel'})
self.assertGET404(
url, data={'brick_id': 'block_creme_core-tagged-persons-civility'})
def test_delete_related01(self):
user = self.login(is_superuser=False)
ptype = CremePropertyType.create(str_pk='test-prop_foobar',
text='hairy')
entity = FakeContact.objects.create(user=user, last_name='Vrataski')
prop = CremeProperty.objects.create(type=ptype, creme_entity=entity)
get_ct = ContentType.objects.get_for_model
ct = get_ct(CremeProperty)
response = self.assertPOST200(
reverse('creme_core__delete_related_to_entity', args=(ct.id, )),
follow=True,
data={'id': prop.id},
)
self.assertRedirects(response, entity.get_absolute_url())
self.assertDoesNotExist(prop)
# ---
self.assertPOST409(
reverse('creme_core__delete_related_to_entity',
args=(get_ct(CremeEntity).id, )),
follow=True,
data={'id': entity.id},
)
self.assertPOST409(
reverse('creme_core__delete_related_to_entity',
args=(get_ct(CremePropertyType).id, )),
follow=True,
data={'id': ptype.id},
)
def test_edit_type03(self):
"Not allowed"
self.login(is_superuser=False)
ptype = CremePropertyType.create('test-foobar',
'is beautiful',
is_custom=True)
self.assertGET403(ptype.get_edit_absolute_url())
def test_delete_from_type(self):
user = self.login()
ptype = CremePropertyType.create(str_pk='test-prop_foobar',
text='hairy')
create_entity = partial(CremeEntity.objects.create, user=user)
entity1 = create_entity()
entity2 = create_entity()
create_prop = partial(CremeProperty.objects.create, type=ptype)
prop1 = create_prop(creme_entity=entity1)
prop2 = create_prop(creme_entity=entity2)
response = self.assertPOST200(
reverse('creme_core__remove_property'),
follow=True,
data={
'ptype_id': ptype.id,
'entity_id': entity1.id
},
)
self.assertRedirects(response, ptype.get_absolute_url())
self.assertDoesNotExist(prop1)
self.assertStillExists(prop2)
def test_delete_type01(self):
self.login()
ptype = CremePropertyType.create('test-foobar',
'is beautiful', [],
is_custom=False)
self.assertPOST404(ptype.get_delete_absolute_url(),
data={'id': ptype.id})
def test_edit02(self):
"Edit a custom type"
self.login()
get_ct = ContentType.objects.get_for_model
pt = CremePropertyType.create('test-foobar', 'is beautiful', [get_ct(FakeContact)], is_custom=True)
url = self._build_edit_url(pt)
response = self.assertGET200(url)
# self.assertTemplateUsed(response, 'creme_core/generics/blockform/edit_popup.html')
self.assertTemplateUsed(response, 'creme_core/generics/blockform/edit-popup.html')
context = response.context
# self.assertEqual(_('Edit the type «{property}»').format(property=pt),
self.assertEqual(pgettext('creme_config-property', 'Edit the type «{object}»').format(object=pt),
context.get('title')
)
self.assertEqual(_('Save the modifications'), context.get('submit_label'))
# ---
ct_orga = get_ct(FakeOrganisation)
text = 'is very beautiful'
response = self.client.post(url, data={'text': text,
'subject_ctypes': [ct_orga.id],
}
)
self.assertNoFormError(response)
pt = self.refresh(pt)
self.assertEqual(text, pt.text)
self.assertEqual([ct_orga.id], [ct.id for ct in pt.subject_ctypes.all()])
def test_edit_type04(self):
"Not super-user"
self.login(is_superuser=False, admin_4_apps=('creme_core', ))
ptype = CremePropertyType.create('test-foobar',
'is beautiful',
is_custom=True)
self.assertGET200(ptype.get_edit_absolute_url())
def test_reload_ptype_bricks02(self):
"Misc brick + info brick"
user = self.login()
ptype = CremePropertyType.create(
str_pk='test-prop_murica',
text='is american',
subject_ctypes=[FakeOrganisation],
)
rita = FakeContact.objects.create(user=user,
last_name='Vrataski',
first_name='Rita')
CremeProperty.objects.create(type=ptype, creme_entity=rita)
misc_brick_id = 'block_creme_core-misc_tagged_entities'
info_brick_id = 'block_creme_core-property_type_info'
response = self.assertGET200(
reverse('creme_core__reload_ptype_bricks', args=(ptype.id, )),
data={'brick_id': [misc_brick_id, info_brick_id]},
)
with self.assertNoException():
# result = json.loads(response.content)
result = response.json()
self.assertEqual(2, len(result))
doc1 = self.get_html_tree(result[0][1])
self.get_brick_node(doc1, misc_brick_id)
doc2 = self.get_html_tree(result[1][1])
self.get_brick_node(doc2, info_brick_id)
def test_delete01(self):
self.login()
pt = CremePropertyType.create('test-foobar',
'is beautiful', [],
is_custom=False)
self.assertPOST404(self.DELETE_URL, data={'id': pt.id})
def _create_persons(self):
user = self.user
create = partial(FakeContact.objects.create, user=user)
create(
last_name='Langley', first_name='Asuka',
birthday=datetime(year=1981, month=7, day=25),
)
rei = create(
last_name='Ayanami', first_name='Rei',
birthday=datetime(year=1981, month=3, day=26),
)
misato = create(
last_name='Katsuragi', first_name='Misato',
birthday=datetime(year=1976, month=8, day=12),
)
nerv = FakeOrganisation.objects.create(user=user, name='Nerv')
ptype = CremePropertyType.create(str_pk='test-prop_kawaii', text='Kawaii')
CremeProperty.objects.create(type=ptype, creme_entity=rei)
Relation.objects.create(
user=user,
subject_entity=misato,
type_id=REL_SUB_HAS,
object_entity=nerv,
)
def test_delete_property01(self):
user = self.user
gainax = FakeOrganisation.objects.create(user=user, name='Gainax')
old_count = HistoryLine.objects.count()
sleep(1) # Ensure that 'modified' field is not 'now()'
ptype = CremePropertyType.create(str_pk='test-prop_make_animes', text='make animes')
prop = CremeProperty.objects.create(type=ptype, creme_entity=gainax)
hlines = self._get_hlines()
self.assertEqual(old_count + 1, len(hlines))
self.assertEqual(TYPE_PROP_ADD, hlines[-1].type)
prop.delete()
hlines = self._get_hlines()
self.assertEqual(old_count + 2, len(hlines))
hline = hlines[-1]
self.assertEqual(gainax.id, hline.entity.id)
self.assertEqual(str(gainax), hline.entity_repr)
self.assertEqual(TYPE_PROP_DEL, hline.type)
self.assertEqual([ptype.id], hline.modifications)
self.assertEqual(False, hline.line_type.is_about_relation)
self.assertGreater(hline.date, gainax.modified)
ptype.text = ptype.text.title()
ptype.save()
self.assertEqual([_(u'Delete property “{}”').format(ptype.text)],
hline.get_verbose_modifications(user)
)
def test_detailview02(self):
"Misc brick"
user = self.login()
ptype = CremePropertyType.create(
str_pk='test-prop_murica',
text='is american',
subject_ctypes=[FakeContact],
)
rita = FakeContact.objects.create(user=user,
last_name='Vrataski',
first_name='Rita')
udf = FakeOrganisation.objects.create(user=user,
name='US Defense Force')
create_prop = partial(CremeProperty.objects.create, type=ptype)
create_prop(creme_entity=rita)
create_prop(creme_entity=udf)
response = self.assertGET200(ptype.get_absolute_url())
doc = self.get_html_tree(response.content)
contacts_brick_node = self.get_brick_node(
doc, 'block_creme_core-tagged-creme_core-fakecontact')
self.assertInstanceLink(contacts_brick_node, rita)
self.assertNoInstanceLink(contacts_brick_node, udf)
misc_brick_node = self.get_brick_node(
doc, 'block_creme_core-misc_tagged_entities')
self.assertInstanceLink(misc_brick_node, udf)
self.assertNoInstanceLink(misc_brick_node, rita)
self.assertNoBrick(
doc, 'block_creme_core-tagged-creme_core-fakeorganisation')
def test_edit01(self):
"Edit a not custom type +> error"
self.login()
get_ct = ContentType.objects.get_for_model
pt = CremePropertyType.create('test-foobar', 'is beautiful', [get_ct(FakeContact)], is_custom=False)
self.assertGET404(self._build_edit_url(pt))
def test_segment_create02(self):
"Collision with property type name"
user = self.login()
strategy = Strategy.objects.create(user=user, name='Strat#1')
name = 'Industry'
pname = _('is in the segment «{}»').format(name)
CremePropertyType.create('commercial-test_segment_create02', pname)
response = self.assertPOST200(
self._build_add_segmentdesc_url(strategy),
data={'name': name},
)
self.assertFormError(
response, 'form', 'name',
_('A property with the name «%(name)s» already exists') %
{'name': pname})
def save(self):
get_data = self.cleaned_data.get
ptype = CremePropertyType.create(self.instance.id, get_data('text'),
get_data('subject_ctypes'),
is_custom=True,
is_copiable=get_data('is_copiable'),
)
super().save()
return ptype
def save(self):
get_data = self.cleaned_data.get
ptype = CremePropertyType.create('creme_config-userproperty',
get_data('text'), get_data('subject_ctypes'),
is_custom=True, generate_pk=True,
is_copiable=get_data('is_copiable'),
)
super().save()
return ptype
def test_inneredit(self):
user = self.login()
ptype = CremePropertyType.create(str_pk='test-prop_foobar',
text='hairy')
entity = CremeEntity.objects.create(user=user)
prop = CremeProperty.objects.create(type=ptype, creme_entity=entity)
build_url = self.build_inneredit_url
self.assertGET(400, build_url(prop, 'type'))
self.assertGET(400, build_url(prop, 'creme_entity'))
def test_delete_type03(self):
"Not allowed to admin <creme_core>."
self.login(is_superuser=False)
ptype = CremePropertyType.create(
'test-foobar',
'is beautiful',
[],
is_custom=True,
)
self.assertPOST403(ptype.get_delete_absolute_url(), follow=True)
def test_create03(self):
"Update existing."
pk = 'test-prop_foobar'
CremePropertyType.create(str_pk=pk, text='is delicious',
subject_ctypes=[FakeOrganisation],
)
text = 'is very delicious'
ptype = CremePropertyType.create(str_pk=pk, text=text,
is_copiable=False,
is_custom=True,
subject_ctypes=[FakeContact],
)
self.assertEqual(text, ptype.text)
self.assertTrue(ptype.is_custom)
self.assertFalse(ptype.is_copiable)
self.assertListEqual([FakeContact],
[ct.model_class() for ct in ptype.subject_ctypes.all()]
)
def test_manager_safe_create(self):
text = 'is happy'
ptype = CremePropertyType.create(str_pk='test-prop_foobar', text=text)
entity = CremeEntity.objects.create(user=self.user)
CremeProperty.objects.safe_create(type=ptype, creme_entity=entity)
self.get_object_or_fail(CremeProperty, type=ptype.id, creme_entity=entity.id)
with self.assertNoException():
CremeProperty.objects.safe_create(type=ptype, creme_entity=entity)
def test_edit_type01(self):
"is_custom=False"
self.login()
ptype = CremePropertyType.create(
'test-foobar',
'is beautiful',
[ContentType.objects.get_for_model(FakeContact)],
is_custom=False,
)
self.assertGET404(ptype.get_edit_absolute_url())
def test_create01(self):
pk = 'test-prop_foobar'
text = 'is delicious'
ptype = CremePropertyType.create(str_pk=pk, text=text)
self.assertIsInstance(ptype, CremePropertyType)
self.assertEqual(pk, ptype.id)
self.assertEqual(text, ptype.text)
self.assertFalse(ptype.is_custom)
self.assertTrue(ptype.is_copiable)
self.assertFalse(ptype.subject_ctypes.all())
def test_detailview01(self):
user = self.login()
ptype = CremePropertyType.create(str_pk='test-prop_murica',
text='is american')
create_contact = partial(FakeContact.objects.create, user=user)
tagged_contact = create_contact(last_name='Vrataski',
first_name='Rita')
untagged_contact = create_contact(last_name='Kiriya',
first_name='Keiji')
tagged_orga = FakeOrganisation.objects.create(user=user,
name='US Defense Force')
create_prop = partial(CremeProperty.objects.create, type=ptype)
create_prop(creme_entity=tagged_contact)
create_prop(creme_entity=tagged_orga)
response = self.assertGET200(ptype.get_absolute_url())
self.assertTemplateUsed(response, 'creme_core/view_property_type.html')
self.assertTemplateUsed(response, 'creme_core/bricks/ptype-info.html')
self.assertTemplateUsed(response,
'creme_core/bricks/tagged-entities.html')
self.assertEqual(
reverse('creme_core__reload_ptype_bricks', args=(ptype.id, )),
response.context.get('bricks_reload_url'),
)
with self.assertNoException():
ctxt_ptype = response.context['object']
self.assertEqual(ptype, ctxt_ptype)
doc = self.get_html_tree(response.content)
self.get_brick_node(doc, 'block_creme_core-property_type_info')
contacts_brick_node = self.get_brick_node(
doc,
'block_creme_core-tagged-creme_core-fakecontact',
)
self.assertBrickHasNotClass(contacts_brick_node, 'is-empty')
self.assertInstanceLink(contacts_brick_node, tagged_contact)
self.assertNoInstanceLink(contacts_brick_node, untagged_contact)
self.assertNoInstanceLink(contacts_brick_node, tagged_orga)
orgas_brick_node = self.get_brick_node(
doc,
'block_creme_core-tagged-creme_core-fakeorganisation',
)
self.assertInstanceLink(orgas_brick_node, tagged_orga)
self.assertNoInstanceLink(orgas_brick_node, tagged_contact)
self.assertNoBrick(doc, 'block_creme_core-tagged-billing-fakeimage')
self.assertNoBrick(doc, 'block_creme_core-misc_tagged_entities')