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)