def populate(self):
Report = get_report_model()
HeaderFilter.create(
pk=constants.DEFAULT_HFILTER_REPORT,
name=_('Report view'),
model=Report,
cells_desc=[
(EntityCellRegularField, {
'name': 'name'
}),
(EntityCellRegularField, {
'name': 'ct'
}),
],
)
# ---------------------------
SearchConfigItem.create_if_needed(Report, ['name'])
# ---------------------------
# NB: no straightforward way to test that this populate script has not been already run
if not BrickDetailviewLocation.objects.filter_for_model(
Report).exists():
create_bdl = partial(
BrickDetailviewLocation.objects.create_if_needed, model=Report)
LEFT = BrickDetailviewLocation.LEFT
RIGHT = BrickDetailviewLocation.RIGHT
BrickDetailviewLocation.objects.create_for_model_brick(
order=5, zone=LEFT, model=Report)
create_bdl(brick=core_bricks.CustomFieldsBrick,
order=40,
zone=LEFT)
create_bdl(brick=bricks.ReportFieldsBrick, order=50, zone=LEFT)
create_bdl(brick=bricks.ReportGraphsBrick, order=60, zone=LEFT)
create_bdl(brick=core_bricks.PropertiesBrick, order=450, zone=LEFT)
create_bdl(brick=core_bricks.RelationsBrick, order=500, zone=LEFT)
create_bdl(brick=core_bricks.HistoryBrick, order=20, zone=RIGHT)
if apps.is_installed('creme.assistants'):
logger.info(
'Assistants app is installed => we use the assistants blocks on detail view'
)
from creme.assistants import bricks as a_bricks
create_bdl(brick=a_bricks.TodosBrick, order=100, zone=RIGHT)
create_bdl(brick=a_bricks.MemosBrick, order=200, zone=RIGHT)
create_bdl(brick=a_bricks.AlertsBrick, order=300, zone=RIGHT)
create_bdl(brick=a_bricks.UserMessagesBrick,
order=400,
zone=RIGHT)
if apps.is_installed('creme.documents'):
# logger.info('Documents app is installed => we use the documents block on detail views')
from creme.documents.bricks import LinkedDocsBrick
create_bdl(brick=LinkedDocsBrick, order=600, zone=RIGHT)
def create_hf(hf_pk, name, model, status=True):
HeaderFilter.create(
pk=hf_pk,
name=name,
model=model,
cells_desc=[
(EntityCellRegularField, {
'name': 'name'
}),
EntityCellRelation(model=model,
rtype=rt_sub_bill_received),
(EntityCellRegularField, {
'name': 'number'
}),
(EntityCellRegularField, {
'name': 'status'
}) if status else None,
(EntityCellRegularField, {
'name': 'total_no_vat'
}),
(EntityCellRegularField, {
'name': 'issuing_date'
}),
(EntityCellRegularField, {
'name': 'expiration_date'
}),
],
)
def test_create03(self):
"Do not modify if it already exists"
self.login()
pk = 'tests-hf_contact'
name = 'Contact view'
hf = HeaderFilter.create(
pk=pk,
name=name,
model=FakeContact,
is_custom=False,
cells_desc=[(EntityCellRegularField, {
'name': 'last_name'
})],
)
hf = HeaderFilter.create(
pk=pk,
name='Contact view edited',
user=self.user,
model=FakeContact,
is_custom=False,
cells_desc=[
(EntityCellRegularField, {
'name': 'first_name'
}),
(EntityCellRegularField, {
'name': 'last_name'
}),
],
)
self.assertEqual(name, hf.name)
self.assertIsNone(hf.user)
self.assertEqual(1, len(hf.cells))
def test_distinct(self):
user = self.login()
create_camp = partial(FakeEmailCampaign.objects.create, user=user)
camp1 = create_camp(name='Camp#1')
camp2 = create_camp(name='Camp#2')
camp3 = create_camp(name='Camp#3')
create_ml = partial(FakeMailingList.objects.create, user=user)
ml1 = create_ml(name='Bebop staff')
ml2 = create_ml(name='Mafia staff')
camp1.mailing_lists.set([ml1, ml2])
camp2.mailing_lists.set([ml1])
HeaderFilter.create(
pk='test_hf', name='Campaign view', model=FakeEmailCampaign,
cells_desc=[(EntityCellRegularField, {'name': 'name'}),
(EntityCellRegularField, {'name': 'mailing_lists'}),
],
)
# Set the current list view state, with the quick search
lv_url = FakeEmailCampaign.get_lv_absolute_url()
response = self.assertPOST200(
lv_url,
# data={'regular_field-mailing_lists': 'staff'}
data={'search-regular_field-mailing_lists': 'staff'},
)
content = self._get_lv_content(response)
self.assertCountOccurrences(camp1.name, content, count=1) # Not 2
self.assertCountOccurrences(camp2.name, content, count=1)
self.assertNotIn(camp3.name, content)
def test_create_errors(self):
user = self.login()
# Private + no user => error
with self.assertRaises(ValueError):
HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view edited',
model=FakeContact,
is_private=True,
cells_desc=[(EntityCellRegularField, {
'name': 'last_name'
})],
)
# Private + not is_custom => error
with self.assertRaises(ValueError):
HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view edited',
user=user,
model=FakeContact,
is_private=True,
is_custom=False,
cells_desc=[(EntityCellRegularField, {
'name': 'last_name'
})],
)
def create_hf_lines(hf_pk, name, model):
build_cell = EntityCellRegularField.build
HeaderFilter.create(pk=hf_pk, name=name, model=model,
cells_desc=[build_cell(model=model, name='on_the_fly_item'),
build_cell(model=model, name='quantity'),
build_cell(model=model, name='unit_price'),
]
)
def test_export_error_invalid_efilter(self):
self.login()
build_cell = EntityCellRegularField.build
HeaderFilter.create(
pk='test-hf_contact', name='Contact view',
model=FakeContact,
cells_desc=[
build_cell(model=FakeContact, name='last_name'),
build_cell(model=FakeContact, name='first_name'),
],
)
self.assertGET404(self._build_contact_dl_url(efilter_id='test-unknown'))
def test_listview_header_filters01(self):
user = self.login()
ctype = ContentType.objects.get_for_model(FakeMailingList)
self.assertFalse(HeaderFilter.objects.filter(entity_type=ctype).first())
hf = HeaderFilter.create(pk='test_hf-ml01', name='View', model=FakeMailingList)
hfilters = HeaderFilterList(
content_type=ctype,
user=user,
)
hfilters.select_by_id(hf.id)
ctxt = listview_header_filters(
model=FakeMailingList,
user=user,
hfilters=hfilters,
show_buttons=True,
)
self.assertIsInstance(ctxt, dict)
self.assertIs(ctxt.get('model'), FakeMailingList)
self.assertIs(ctxt.get('show_buttons'), True)
self.assertIs(ctxt.get('can_edit'), True)
self.assertIs(ctxt.get('can_delete'), False)
self.assertEqual(ctxt.get('selected'), hf)
self.assertEqual([hf], ctxt.get('global_header_filters'))
self.assertFalse([*ctxt.get('my_header_filters')])
self.assertFalse([*ctxt.get('other_header_filters')])
def test_edit09(self):
"Not custom filter cannot be private + callback URL."
self.login()
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=False,
)
url = hf.get_edit_absolute_url()
self.assertGET200(url)
callback = FakeOrganisation.get_lv_absolute_url()
response = self.client.post(
url,
data={
'name': hf.name,
'user': self.user.id,
'is_private': 'on', # Should not be used
'cells': 'regular_field-last_name',
'cancel_url': callback,
})
self.assertNoFormError(response, status=302)
self.assertFalse(self.refresh(hf).is_private)
self.assertRedirects(response, callback)
def test_list_view_export05(self):
"Datetime field"
user = self.login()
hf = HeaderFilter.create(
pk='test-hf_contact_test_export05',
name='Contact view',
model=FakeContact,
cells_desc=[
(EntityCellRegularField, {
'name': 'last_name'
}),
(EntityCellRegularField, {
'name': 'created'
}),
],
)
spike = FakeContact.objects.create(user=user,
first_name='Spike',
last_name='Spiegel')
response = self.assertGET200(
self._build_contact_dl_url(hfilter_id=hf.id))
result = [force_text(line) for line in response.content.splitlines()]
self.assertEqual(2, len(result))
self.assertEqual(
result[1], '"{}","{}"'.format(
spike.last_name,
date_format(localtime(spike.created), 'DATETIME_FORMAT'),
))
def test_populate_entities_fields04(self):
"Regular fields: invalid subfields."
self.login()
cell1 = EntityCellRegularField.build(model=FakeContact,
name='last_name')
cell2 = EntityCellRegularField.build(model=FakeContact,
name='user__username')
cell2.value = 'user__invalid' # filter_string='__icontains'
hf = HeaderFilter.create(
pk='test-hf',
name=u'Contact view',
model=FakeContact,
cells_desc=[cell1, cell2],
)
create_contact = partial(FakeContact.objects.create, user=self.user)
create_contact(first_name='Nagate', last_name='Tanikaze')
create_contact(first_name='Shizuka', last_name='Hoshijiro')
hf = self.refresh(hf)
new_cells = hf.cells
self.assertEqual(1, len(new_cells))
self.assertCellEqual(cell1, hf.cells[0])
def test_print_integer02(self):
"Field with choices"
user = self.login()
invoice = FakeInvoice.objects.create(user=user, name='Invoice',
expiration_date=date(year=2012, month=12, day=15),
)
create_pline = partial(FakeInvoiceLine.objects.create, user=user, linked_invoice=invoice)
create_pline(item='Bebop', discount_unit=FAKE_PERCENT_UNIT)
create_pline(item='Swordfish', discount_unit=FAKE_AMOUNT_UNIT)
build = partial(EntityCellRegularField.build, model=FakeInvoiceLine)
hf = HeaderFilter.create(pk='test-hf_fakeinvoiceline', name='InvoiceLine view',
model=FakeInvoiceLine,
cells_desc=[build(name='item'),
build(name='discount_unit'),
],
)
response = self.assertGET200(
self._build_dl_url(FakeInvoiceLine,
list_url=FakeInvoiceLine.get_lv_absolute_url(),
hfilter_id=hf.id,
),
follow=True,
)
lines = {force_text(line) for line in response.content.splitlines()}
self.assertIn('"Bebop","{}"'.format(_('Percent')), lines)
self.assertIn('"Swordfish","{}"'.format(_('Amount')), lines)
def test_xls_export02(self):
"Other CT, other type of fields"
user = self.login()
create_orga = partial(FakeOrganisation.objects.create, user=user)
orga01 = create_orga(name='Bebop')
orga02 = create_orga(name='Swordfish', subject_to_vat=False, creation_date=date(year=2016, month=7, day=5))
build_cell = partial(EntityCellRegularField.build, model=FakeOrganisation)
cells = [build_cell(name='name'),
build_cell(name='subject_to_vat'),
build_cell(name='creation_date'),
]
hf = HeaderFilter.create(pk='test-hf_orga', name='Organisation view',
model=FakeOrganisation, cells_desc=cells,
)
response = self.assertGET200(
self._build_dl_url(FakeOrganisation,
doc_type='xls',
list_url=FakeOrganisation.get_lv_absolute_url(),
hfilter_id=hf.id,
),
follow=True,
)
it = iter(XlrdReader(None, file_contents=response.content))
self.assertEqual(next(it), [hfi.title for hfi in cells])
self.assertEqual(next(it), [orga01.name, _('Yes'), ''])
self.assertEqual(next(it), [orga02.name, _('No'), date_format(orga02.creation_date, 'DATE_FORMAT')])
with self.assertRaises(StopIteration):
next(it)
def test_list_view_export07(self):
"M2M field on CremeEntities."
user = self.login()
create_camp = partial(FakeEmailCampaign.objects.create, user=user)
camp1 = create_camp(name='Camp#1')
camp2 = create_camp(name='Camp#2')
create_camp(name='Camp#3')
create_ml = partial(FakeMailingList.objects.create, user=user)
camp1.mailing_lists.set([create_ml(name='ML#1'), create_ml(name='ML#2')])
camp2.mailing_lists.set([create_ml(name='ML#3')])
hf = HeaderFilter.create(
pk='test_hf', name='Campaign view', model=FakeEmailCampaign,
cells_desc=[(EntityCellRegularField, {'name': 'name'}),
(EntityCellRegularField, {'name': 'mailing_lists__name'}),
],
)
response = self.assertGET200(
self._build_dl_url(FakeEmailCampaign,
list_url=FakeEmailCampaign.get_lv_absolute_url(),
hfilter_id=hf.id,
),
)
result = [force_text(line) for line in response.content.splitlines()]
self.assertEqual(4, len(result))
self.assertEqual(result[1], '"Camp#1","ML#1/ML#2"')
self.assertEqual(result[2], '"Camp#2","ML#3"')
self.assertEqual(result[3], '"Camp#3",""')
def test_list_view_export06(self):
"FK field on CremeEntity."
user = self.login(is_superuser=False)
self.role.exportable_ctypes.set([self.ct])
create_img = FakeImage.objects.create
spike_face = create_img(name='Spike face', user=self.other_user, description="Spike's selfie")
jet_face = create_img(name='Jet face', user=user, description="Jet's selfie")
self.assertTrue(user.has_perm_to_view(jet_face))
self.assertFalse(user.has_perm_to_view(spike_face))
create_contact = partial(FakeContact.objects.create, user=user)
create_contact(first_name='Spike', last_name='Spiegel', image=spike_face)
create_contact(first_name='Jet', last_name='Black', image=jet_face)
create_contact(first_name='Faye', last_name='Valentine')
hf = HeaderFilter.create(
pk='test-hf_contact_test_export06', name='Contact view', model=FakeContact,
cells_desc=[(EntityCellRegularField, {'name': 'last_name'}),
(EntityCellRegularField, {'name': 'image'}),
(EntityCellRegularField, {'name': 'image__description'}),
],
)
response = self.assertGET200(self._build_contact_dl_url(hfilter_id=hf.id))
it = (force_text(line) for line in response.content.splitlines()); next(it)
self.assertEqual(next(it), '"Black","Jet face","Jet\'s selfie"')
HIDDEN_VALUE = settings.HIDDEN_VALUE
self.assertEqual(next(it), '"Spiegel","{hidden}","{hidden}"'.format(hidden=HIDDEN_VALUE))
self.assertEqual(next(it), '"Valentine","",""')
def test_populate_entities_fields01(self):
"Regular fields: no FK"
user = self.login()
hf = HeaderFilter.create(pk='test-hf',
name=u'Contact view',
model=FakeContact,
cells_desc=[
(EntityCellRegularField, {
'name': 'last_name'
}),
(EntityCellRegularField, {
'name': 'first_name'
}),
])
pos = FakePosition.objects.create(title='Pilot')
create_contact = partial(FakeContact.objects.create,
user=user,
position_id=pos.id)
contacts = [
create_contact(first_name='Nagate', last_name='Tanikaze'),
create_contact(first_name='Shizuka', last_name='Hoshijiro'),
]
with self.assertNumQueries(0):
hf.populate_entities(contacts, user)
with self.assertNumQueries(1):
contacts[0].position
def test_print_integer01(self):
"No choices"
user = self.login()
create_orga = partial(FakeOrganisation.objects.create, user=user)
for name, capital in (('Bebop', 1000), ('Swordfish', 20000),
('Redtail', None)):
create_orga(name=name, capital=capital)
build = partial(EntityCellRegularField.build, model=FakeOrganisation)
hf = HeaderFilter.create(
pk='test-hf_orga',
name='Organisation view',
model=FakeOrganisation,
cells_desc=[build(name='name'),
build(name='capital')],
)
lv_url = FakeOrganisation.get_lv_absolute_url()
response = self.assertGET200(
self._build_dl_url(
ContentType.objects.get_for_model(FakeOrganisation).id,
list_url=lv_url,
hfilter_id=hf.id,
),
follow=True,
)
lines = {force_text(line) for line in response.content.splitlines()}
self.assertIn('"Bebop","1000"', lines)
self.assertIn('"Swordfish","20000"', lines)
self.assertIn('"Redtail",""', lines)
def test_create01(self):
self.login()
name = 'Contact view'
pk = 'tests-hf_contact'
hf = HeaderFilter.create(pk=pk,
name=name,
model=FakeContact,
is_custom=True)
self.assertEqual(pk, hf.pk)
self.assertEqual(name, hf.name)
self.assertIsNone(hf.user)
self.assertEqual(self.contact_ct, hf.entity_type)
self.assertIs(hf.is_custom, True)
self.assertIs(hf.is_private, False)
self.assertEqual('[]', hf.json_cells)
self.assertFalse(hf.cells)
hf.cells = [
EntityCellRegularField.build(model=FakeContact, name='first_name')
]
hf.save()
hf = self.refresh(hf)
self.assertEqual(1, len(hf.cells))
with self.assertNoException():
deserialized = json_loads(hf.json_cells)
self.assertEqual([{
'type': 'regular_field',
'value': 'first_name'
}], deserialized)
def test_edit08(self):
"Staff users can edit all HeaderFilters + private filters must be assigned"
self.login(is_staff=True)
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=True,
is_private=True,
user=self.other_user,
)
url = hf.get_edit_absolute_url()
self.assertGET200(url)
response = self.assertPOST200(url,
follow=True,
data={
'name': hf.name,
'user': '',
'is_private': 'on',
'cells': 'regular_field-last_name',
})
self.assertFormError(
response, 'form', 'user',
_('A private view of list must be assigned to a user/team.'))
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_populate_entities_relations01(self):
user = self.login()
create_rt = RelationType.create
loved = create_rt(('test-subject_love', u'Is loving'),
('test-object_love', u'Is loved by'))[1]
hated = create_rt(('test-subject_hate', u'Is hating'),
('test-object_hate', u'Is hated by'))[1]
hf = HeaderFilter.create(
pk='test-hf',
name=u'Contact view',
model=FakeContact,
cells_desc=[
EntityCellRegularField.build(model=FakeContact,
name='last_name'),
EntityCellRelation(model=FakeContact, rtype=loved),
EntityCellRelation(model=FakeContact, rtype=hated),
],
)
create_contact = partial(FakeContact.objects.create, user=user)
nagate = create_contact(first_name='Nagate', last_name='Tanikaze')
shizuka = create_contact(first_name='Shizuka', last_name='Hoshijiro')
izana = create_contact(first_name='Izana', last_name='Shinatose')
norio = create_contact(first_name='Norio', last_name='Kunato')
create_rel = partial(Relation.objects.create, user=user)
create_rel(subject_entity=nagate, type=loved, object_entity=izana)
create_rel(subject_entity=nagate, type=hated, object_entity=norio)
create_rel(subject_entity=shizuka, type=loved, object_entity=norio)
# NB: sometimes a query to get this CT is performed when the Relations
# are retrieved. So we force the cache to be filled has he should be
ContentType.objects.get_for_model(CremeEntity)
with self.assertNumQueries(2):
hf.populate_entities([nagate, shizuka], user)
with self.assertNumQueries(0):
r1 = nagate.get_relations(loved.id, real_obj_entities=True)
r2 = nagate.get_relations(hated.id, real_obj_entities=True)
r3 = shizuka.get_relations(loved.id, real_obj_entities=True)
r4 = shizuka.get_relations(hated.id, real_obj_entities=True)
with self.assertNumQueries(0):
objs1 = [r.object_entity.get_real_entity() for r in r1]
objs2 = [r.object_entity.get_real_entity() for r in r2]
objs3 = [r.object_entity.get_real_entity() for r in r3]
objs4 = [r.object_entity.get_real_entity() for r in r4]
self.assertEqual([izana], objs1)
self.assertEqual([norio], objs2)
self.assertEqual([norio], objs3)
self.assertEqual([], objs4)
def _build_hf_n_contacts(self):
user = self.user
create_orga = partial(FakeOrganisation.objects.create, user=user)
self.organisations = organisations = {
name: create_orga(name=name)
for name in ('Bebop', 'Swordfish')
}
rtype_pilots = RelationType.create(('test-subject_pilots', 'pilots'),
('test-object_pilots', 'is piloted by')
)[0]
create_ptype = CremePropertyType.create
ptype_beautiful = create_ptype(str_pk='test-prop_beautiful', text='is beautiful')
ptype_girl = create_ptype(str_pk='test-prop_girl', text='is a girl')
create_contact = partial(FakeContact.objects.create, user=user)
self.contacts = contacts = {
first_name: create_contact(first_name=first_name, last_name=last_name)
for first_name, last_name in [('Spike', 'Spiegel'),
('Jet', 'Black'),
('Faye', 'Valentine'),
('Edward', 'Wong'),
]
}
create_rel = partial(Relation.objects.create, user=user, type=rtype_pilots,
object_entity=organisations['Bebop'],
)
create_rel(subject_entity=contacts['Jet'])
create_rel(subject_entity=contacts['Spike'])
create_rel(subject_entity=contacts['Spike'], object_entity=organisations['Swordfish'])
create_prop = CremeProperty.objects.create
create_prop(type=ptype_girl, creme_entity=contacts['Faye'])
create_prop(type=ptype_girl, creme_entity=contacts['Edward'])
create_prop(type=ptype_beautiful, creme_entity=contacts['Faye'])
cells = [
EntityCellRegularField.build(model=FakeContact, name='civility'),
EntityCellRegularField.build(model=FakeContact, name='last_name'),
EntityCellRegularField.build(model=FakeContact, name='first_name'),
EntityCellRelation(model=FakeContact, rtype=rtype_pilots),
# TODO: EntityCellCustomField
EntityCellFunctionField.build(model=FakeContact, func_field_name='get_pretty_properties'),
]
hf = HeaderFilter.create(pk='test-hf_contact', name='Contact view',
model=FakeContact, cells_desc=cells,
)
# return cells
return hf
def test_edit03(self):
"Cannot edit HeaderFilter that belongs to another user"
self.login(is_superuser=False)
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=True,
user=self.other_user,
)
self.assertGET403(hf.get_edit_absolute_url())
def test_quick_search(self):
user = self.login()
hf = HeaderFilter.create(
pk='test-hf_contact_test_quick_search',
name='Contact view',
model=FakeContact,
cells_desc=[
(EntityCellRegularField, {
'name': 'phone'
}),
(EntityCellRegularField, {
'name': 'last_name'
}),
(EntityCellRegularField, {
'name': 'first_name'
}),
],
)
create_contact = partial(FakeContact.objects.create, user=user)
spike = create_contact(first_name='Spike',
last_name='Spiegel',
phone='123233')
jet = create_contact(first_name='Jet',
last_name='Black',
phone='123455')
faye = create_contact(first_name='Faye',
last_name='Valentine',
phone='678678')
# Set the current list view state, with the quick search
response = self.assertPOST200(FakeContact.get_lv_absolute_url(),
data={
'_search': 1,
'regular_field-phone': '123',
})
content = self._get_lv_content(response)
self.assertCountOccurrences(spike.last_name, content, count=1)
self.assertCountOccurrences(jet.last_name, content, count=1)
self.assertNotIn(faye.last_name, content)
# ----------------------
response = self.assertGET200(
self._build_contact_dl_url(hfilter_id=hf.id))
it = (force_text(line) for line in response.content.splitlines())
next(it) # Header
self.assertEqual(next(it), '"123455","Black","Jet"')
self.assertEqual(next(it), '"123233","Spiegel","Spike"')
with self.assertRaises(StopIteration):
next(it)
def test_edit04(self):
"User do not have the app credentials"
user = self.login(is_superuser=False, allowed_apps=['documents'])
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=True,
user=user,
)
self.assertGET403(hf.get_edit_absolute_url())
def test_delete02(self):
"Not custom -> not deletable."
self.login()
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=False,
)
self.client.post(self.DELETE_URL, data={'id': hf.id})
self.assertStillExists(hf)
def populate(self):
RecurrentGenerator = get_rgenerator_model()
HeaderFilter.create(
pk=constants.DEFAULT_HFILTER_RGENERATOR,
model=RecurrentGenerator,
name=_('Generator view'),
cells_desc=[(EntityCellRegularField, {
'name': 'name'
})],
)
SearchConfigItem.create_if_needed(RecurrentGenerator,
['name', 'description'])
Job.objects.get_or_create(
type_id=recurrents_gendocs_type.id,
defaults={
'language': settings.LANGUAGE_CODE,
'status': Job.STATUS_OK,
},
)
def test_edit07(self):
"Private filter -> cannot be edited by another user (even a super-user)"
self.login()
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=True,
is_private=True,
user=self.other_user,
)
self.assertGET403(hf.get_edit_absolute_url())
def test_delete06(self):
"Logged as super user."
self.login()
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=True,
user=self.other_user,
)
self.client.post(self.DELETE_URL, data={'id': hf.id})
self.assertDoesNotExist(hf)
def test_delete03(self):
"Belongs to another user."
self.login(is_superuser=False)
hf = HeaderFilter.create(
pk='tests-hf_contact',
name='Contact view',
model=FakeContact,
is_custom=True,
user=self.other_user,
)
self.client.post(self.DELETE_URL, data={'id': hf.id})
self.assertStillExists(hf)
