def test_default_change_form_template(self): site = AdminSite() site.register(SimpleModel, TranslatableAdmin) admin = site._registry[SimpleModel] self.assertEqual(admin.default_change_form_template, "admin/change_form.html") # Avoid str + __proxy__ errors self.assertEqual("default/" + admin.default_change_form_template, "default/admin/change_form.html")
def test_history_form_view_accepts_additional_context(self): request = RequestFactory().post("/") request.session = "session" request._messages = FallbackStorage(request) request.user = self.user poll = Poll.objects.create(question="why?", pub_date=today) poll.question = "how?" poll.save() history = poll.history.all()[0] admin_site = AdminSite() admin = SimpleHistoryAdmin(Poll, admin_site) with patch("simple_history.admin.render") as mock_render: admin.history_form_view( request, poll.id, history.pk, extra_context={"anything_else": "will be merged into context"}, ) context = { # Verify this is set for original object "anything_else": "will be merged into context", "original": poll, "change_history": False, "title": "Revert %s" % force_text(poll), "adminform": ANY, "object_id": poll.id, "is_popup": False, "media": ANY, "errors": ANY, "app_label": "tests", "original_opts": ANY, "changelist_url": "/admin/tests/poll/", "change_url": ANY, "history_url": "/admin/tests/poll/1/history/", "add": False, "change": True, "has_add_permission": admin.has_add_permission(request), "has_change_permission": admin.has_change_permission(request, poll), "has_delete_permission": admin.has_delete_permission(request, poll), "has_file_field": True, "has_absolute_url": False, "form_url": "", "opts": ANY, "content_type_id": ANY, "save_as": admin.save_as, "save_on_top": admin.save_on_top, "root_path": getattr(admin_site, "root_path", None), } context.update(admin_site.each_context(request)) mock_render.assert_called_once_with( request, admin.object_history_form_template, context )
def test_history_form_view_getting_history_abstract_external(self): request = RequestFactory().post("/") request.session = "session" request._messages = FallbackStorage(request) request.user = self.user request.POST = {"_change_history": True} obj = ConcreteExternal.objects.create(name="test") obj.name = "new_test" obj.save() history = obj.history.all()[0] admin_site = AdminSite() admin = SimpleHistoryAdmin(ConcreteExternal, admin_site) with patch("simple_history.admin.render") as mock_render: with patch("simple_history.admin.SIMPLE_HISTORY_EDIT", True): admin.history_form_view(request, obj.id, history.pk) context = { # Verify this is set for history object "original": history.instance, "change_history": True, "title": "Revert %s" % force_text(history.instance), "adminform": ANY, "object_id": obj.id, "is_popup": False, "media": ANY, "errors": ANY, "app_label": "tests", "original_opts": ANY, "changelist_url": "/admin/tests/concreteexternal/", "change_url": ANY, "history_url": "/admin/tests/concreteexternal/{pk}/history/".format( pk=obj.pk ), "add": False, "change": True, "has_add_permission": admin.has_add_permission(request), "has_change_permission": admin.has_change_permission(request, obj), "has_delete_permission": admin.has_delete_permission(request, obj), "has_file_field": True, "has_absolute_url": False, "form_url": "", "opts": ANY, "content_type_id": ANY, "save_as": admin.save_as, "save_on_top": admin.save_on_top, "root_path": getattr(admin_site, "root_path", None), } context.update(admin_site.each_context(request)) mock_render.assert_called_once_with( request, admin.object_history_form_template, context )
def __init__(self, *args, **kwargs): BaseAdminSite.__init__(self, *args, **kwargs) self.register(db.User, UserAdmin) self.register(db.Group, GroupAdmin) self.register(db.Verbiage, VerbiageAdmin) self.register(db.NewsArticle, ArticleAdmin) self.register(db.ForumPost, ArticleAdmin) self.register(db.UserInfo, UserInfoAdmin) self.register(db.Comment, CommentAdmin) self.register(db.RideRequest, GeoAdmin) self.register(db.Ride, GeoAdmin)
def __init__(self, *args, **kwargs): BaseAdminSite.__init__(self, *args, **kwargs) self.register(db.User, UserAdmin) self.register(db.Group, GroupAdmin) self.register(db.Carousel, CarouselAdmin) self.register(db.Verbiage, VerbiageAdmin) self.register(db.NewsArticle, ArticleAdmin) self.register(db.ForumPost, ArticleAdmin) self.register(db.UserInfo, UserInfoAdmin) self.register(db.Comment, CommentAdmin) self.register(db.RideRequest, GeoAdmin) self.register(db.Ride, GeoAdmin) self.register(db.SpamText, admin.ModelAdmin) self.register(db.List, ListAdmin) self.register(db.ListMember, ListMemberAdmin)
def setUp(self): super(TestPublishableAdmin, self).setUp() self.page1 = Page.objects.create(slug='page1', title='page 1') self.page2 = Page.objects.create(slug='page2', title='page 2') self.page1.publish() self.page2.publish() self.author1 = Author.objects.create(name='a1') self.author2 = Author.objects.create(name='a2') self.author1.publish() self.author2.publish() self.admin_site = AdminSite('Test Admin') class PageBlockInline(PublishableStackedInline): model = PageBlock class PageAdmin(PublishableAdmin): inlines = [PageBlockInline] self.admin_site.register(Page, PageAdmin) self.page_admin = PageAdmin(Page, self.admin_site) # override urls, so reverse works settings.ROOT_URLCONF = patterns( '', ('^admin/', include(self.admin_site.urls)), )
def setUp(self): super(AdminTestCase, self).setUp() # Have a separate site, to avoid dependency on polymorphic wrapping or standard admin configuration self.admin_site = AdminSite() if self.model is not None: self.admin_register(self.model, self.admin_class)
def test_no_blogpage_admin(self): """ When there is no page type mounted, the admin page should still be accessable. """ date = datetime(year=2016, month=5, day=1) entry = Entry.objects.language('en-us').create(author=self.user, slug='hello-fr', publication_date=date) url = reverse(admin_urlname(entry._meta, 'change'), args=(entry.pk,)) # Make an admin site, avoid dependency on URLs admin = AdminSite() admin.register(Entry, EntryAdmin) model_admin = admin._registry[Entry] request = RequestFactory().get(url) request.user = self.user response = model_admin.change_view(request, str(entry.pk)) self.assertContains(response, 'page needs to be created first')
def get_urls(self): from django.conf.urls.defaults import patterns, url, include from obadmin.admin.urls import urlpatterns as local_urls url_patterns = local_urls url_patterns += AdminSite.get_urls(self) return url_patterns
def setUp(self): super(PublishPage, self).setUp() self.admin_site = AdminSite('Test Admin') class PageAdmin(PublishableAdmin): pass self.admin_site.register(Page, PageAdmin) self.page_admin = PageAdmin(Page, self.admin_site)
def get_urls(self): urlpatterns = DjangoAdminSite.get_urls(self) urlpatterns += patterns('', url(r'^confirm_script$', is_staff(ConfirmScriptView.as_view()), name='confirm_script'), url(r'^run_script$', is_staff(RunScriptView.as_view()), name='run_script'), url(r'^kill_script$', is_staff(KillScriptView.as_view()), name='kill_script') ) return urlpatterns
def get_urls(self): """ Add some extra URLs to the admin site, as per https://docs.djangoproject.com/en/dev/ref/contrib/admin/#adding-views-to-admin-sites """ from obadmin.admin.urls import urlpatterns as local_urls url_patterns = local_urls url_patterns += AdminSite.get_urls(self) return url_patterns
class PublishPage(TestCase): def setUp(self): super(PublishPage, self).setUp() self.admin_site = AdminSite('Test Admin') class PageAdmin(PublishableAdmin): pass self.admin_site.register(Page, PageAdmin) self.page_admin = PageAdmin(Page, self.admin_site) def test_should_be_publish(self): self.page1 = Page.objects.create(slug='page1', title='page 1') user1 = User.objects.create_superuser('test1', '*****@*****.**', 'pass') self.factory = RequestFactory() request = self.factory.post('/publish/change_view', data={'_publish': ''}) request.user = user1 self.page_admin.change_view(request, str(self.page1.id)) self.assertEqual(Page.objects.filter(Page.Q_PUBLISHED, slug=self.page1.slug).count(), 1) def test_should_be_republish(self): self.page1 = Page.objects.create(slug='page1', title='page 1') self.page1.publish() user1 = User.objects.create_superuser('test1', '*****@*****.**', 'pass') self.factory = RequestFactory() request = self.factory.post('/publish/change_view', data={'_publish': ''}) request.user = user1 self.page_admin.change_view(request, str(self.page1.id)) self.assertEqual(Page.objects.filter(Page.Q_PUBLISHED, slug=self.page1.slug).count(), 1)
def setUp(self): super(TestPublishSelectedAction, self).setUp() self.fp1 = Page.objects.create(slug='fp1', title='FP1') self.fp2 = Page.objects.create(slug='fp2', title='FP2') self.fp3 = Page.objects.create(slug='fp3', title='FP3') self.admin_site = AdminSite('Test Admin') self.page_admin = PublishableAdmin(Page, self.admin_site) # override urls, so reverse works settings.ROOT_URLCONF = patterns( '', ('^admin/', include(self.admin_site.urls)), )
class TestGetGrootPermissions(TestCase): def setUp(self): self.site = AdminSite(name='admin') def test_default_perms(self): self.site.register(Author, AuthorAdmin) author_admin = self.site._registry[Author] permissions = author_admin.get_groot_permissions(request=None) self.assertListEqual( list(permissions.values_list('codename', flat=True)), ['add_author', 'change_author', 'delete_author'], ) def test_limited_perms(self): self.site.register(Author, AuthorAdmin, groot_permissions=('add_author',)) author_admin = self.site._registry[Author] permissions = author_admin.get_groot_permissions(request=None) self.assertListEqual( list(permissions.values_list('codename', flat=True)), ['add_author'], )
def setUp(self): # Admin objects for all tests. self.factory = RequestFactory() self.admin_site = AdminSite() self.admin_user = User.objects.get(is_superuser=True) self.settings = override_settings( MIDDLEWARE_CLASSES = ( 'django.middleware.common.CommonMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', ) ) self.settings.enable()
def test_submit_inactive_account_reminder_success(self, messageUserMock, taskMock): request = RequestFactory().get("/") email = BroadcastEmail.objects.create(subject="test") admin = BroadcastEmailAdmin(model=BroadcastEmail, admin_site=AdminSite()) user = User.objects.create(username="******", password="******", email="*****@*****.**") image = Image.objects.create(user=user) image.uploaded = image.uploaded - timedelta(61) image.save() admin.submit_inactive_email_reminder( request, BroadcastEmail.objects.filter(pk=email.pk)) args, kwargs = taskMock.call_args taskMock.assert_called() self.assertEqual(["*****@*****.**"], list(args[1]))
def test_graceful_m2m_fail(self): """ Regression test for #12203/#12237 - Fail more gracefully when a M2M field that specifies the 'through' option is included in the 'fields' or the 'fieldsets' ModelAdmin options. """ class BookAdmin(admin.ModelAdmin): fields = ['authors'] errors = BookAdmin(Book, AdminSite()).check() expected = [ checks.Error( ("The value of 'fields' cannot include the ManyToManyField 'authors', " "because that field manually specifies a relationship model." ), hint=None, obj=BookAdmin, id='admin.E013', ) ] self.assertEqual(errors, expected)
def test_generic_inline_model_admin_non_generic_model(self): """ Ensure that a model without a GenericForeignKey raises problems if it's included in an GenericInlineModelAdmin definition. """ class BookInline(GenericStackedInline): model = Book class SongAdmin(admin.ModelAdmin): inlines = [BookInline] errors = SongAdmin(Song, AdminSite()).check() expected = [ checks.Error( "'admin_checks.Book' has no GenericForeignKey.", hint=None, obj=BookInline, id='admin.E301', ) ] self.assertEqual(errors, expected)
def test_readonly_and_editable(self): class SongAdmin(admin.ModelAdmin): readonly_fields = ["original_release"] list_display = ["pk", "original_release"] list_editable = ["original_release"] fieldsets = [ (None, { "fields": ["title", "original_release"], }), ] errors = SongAdmin(Song, AdminSite()).check() expected = [ checks.Error( "The value of 'list_editable[0]' refers to 'original_release', " "which is not editable through the admin.", obj=SongAdmin, id='admin.E125', ) ] self.assertEqual(errors, expected)
def test_generic_inline_model_admin_bad_fk_field(self): """ A GenericInlineModelAdmin errors if the ct_fk_field points to a nonexistent field. """ class InfluenceInline(GenericStackedInline): model = Influence ct_fk_field = 'nonexistent' class SongAdmin(admin.ModelAdmin): inlines = [InfluenceInline] errors = SongAdmin(Song, AdminSite()).check() expected = [ checks.Error( "'ct_fk_field' references 'nonexistent', which is not a field on 'admin_checks.Influence'.", obj=InfluenceInline, id='admin.E303', ) ] self.assertEqual(errors, expected)
def test_cannot_include_through(self): class FieldsetBookAdmin(admin.ModelAdmin): fieldsets = ( ('Header 1', { 'fields': ('name', ) }), ('Header 2', { 'fields': ('authors', ) }), ) errors = FieldsetBookAdmin(Book, AdminSite()).check() expected = [ checks.Error( "The value of 'fieldsets[1][1][\"fields\"]' cannot include the ManyToManyField " "'authors', because that field manually specifies a relationship model.", obj=FieldsetBookAdmin, id='admin.E013', ) ] self.assertEqual(errors, expected)
def test_acoes_deveria_ter_menu_remover_resultado_preliminar( self, menu, reverse): menu.items = [] mocked_url = mock.Mock() reverse.return_value = mocked_url def mocked_add(name, url): menu.items.append((name, url)) menu.return_value.add = mocked_add resultado_admin = admin.ResultadoPreliminarAdmin( models.ResultadoPreliminar, AdminSite()) obj = mock.Mock() obj.fase.edital.resultado_preliminar.resultado = obj delattr(obj.fase.edital, "resultado") resultado_admin.acoes(obj) self.assertEqual( ("Remover resultado preliminar do edital", mocked_url), menu.items[1])
def test_edital_display_deveria_retornar_valor_formatado(self): resultado_admin = admin.ResultadoPreliminarAdmin( models.ResultadoPreliminar, AdminSite()) self.campus_patcher = mock.patch.multiple( cursos.models.Campus, cria_usuarios_diretores=mock.DEFAULT, adiciona_permissao_diretores=mock.DEFAULT, remove_permissao_diretores=mock.DEFAULT) self.fase_analise_patcher = mock.patch.multiple( models.FaseAnalise, atualizar_grupos_permissao=mock.DEFAULT, ) self.campus_patcher.start() self.fase_analise_patcher.start() resultado = recipes.resultado_preliminar.make() self.campus_patcher.stop() self.fase_analise_patcher.stop() edital = resultado.fase.edital self.assertEqual(f"{edital.numero}/{edital.ano}", resultado_admin.edital_display(resultado))
def test_all_history_view(self): request = RequestFactory().post('/') request.session = 'session' request._messages = FallbackStorage(request) request.user = self.user poll = Poll.objects.create(question="why?", pub_date=today) poll.question = "how?" poll.save() history = poll.history.all()[0] admin_site = AdminSite() admin = AllHistoryAdmin(Poll, admin_site) admin.show_all_history = True with patch('simple_history.admin.render') as mock_render: with patch('simple_history.admin.SIMPLE_HISTORY_EDIT', True): admin.all_history_view(request, ) context = { # Verify this is set for history object not poll object 'title': 'All History: %s' % force_text(Poll._meta.verbose_name.title()), 'action_list': ANY, 'module_name': "Polls", 'root_path': getattr(admin_site, 'root_path', None), 'app_label': 'tests', 'opts': ANY, 'admin_user_view': ANY } mock_render.assert_called_once_with(request, admin.objects_history_template, context, **extra_kwargs)
def test_subscribers(self): model_admin = django_vox.admin.NotificationAdmin(models.Subscriber, AdminSite()) queryset = models.Subscriber.objects.all() get_anon_request = MockAnonRequest("GET") get_request = MockRequest("GET") bad_post_request = MockRequest("POST", {"post": "yes", "action": "notify"}) post_data = { "post": "yes", "action": "notify", "backend": "email-html", "_selected_action": 1, "subject": "foo", "content": "bar", } post_request = MockRequest("POST", post_data) with self.assertRaises(PermissionDenied): django_vox.admin.notify(model_admin, get_anon_request, queryset) result = django_vox.admin.notify(model_admin, get_request, queryset) assert 200 == result.status_code # This shouldn't actually send, because it's missing required data assert 0 == len(mail.outbox) django_vox.admin.notify(model_admin, bad_post_request, queryset) assert 0 == len(mail.outbox) # now let's actually try to send this thing django_vox.admin.notify(model_admin, post_request, queryset) assert 1 == len(mail.outbox) assert "bar" == mail.outbox[0].body # test message sending failure with self.settings(EMAIL_BACKEND="Can't import this!"): django_vox.admin.notify(model_admin, post_request, queryset) failed_message = django_vox.models.FailedMessage.objects.all() assert len(failed_message) == 1 assert ( "Can't import this! doesn't look like a module path" == failed_message[0].error )
def test_cannot_include_through(self): class FieldsetBookAdmin(admin.ModelAdmin): fieldsets = ( ("Header 1", { "fields": ("name", ) }), ("Header 2", { "fields": ("authors", ) }), ) errors = FieldsetBookAdmin(Book, AdminSite()).check() expected = [ checks.Error( "The value of 'fieldsets[1][1][\"fields\"]' cannot include the " "ManyToManyField 'authors', because that field manually specifies a " "relationship model.", obj=FieldsetBookAdmin, id="admin.E013", ) ] self.assertEqual(errors, expected)
def test_response_change(self): """ Test the response_change method that it works with a _change_history in the POST and settings.SIMPLE_HISTORY_EDIT set to True """ request = RequestFactory().post("/") request.POST = {"_change_history": True} request.session = "session" request._messages = FallbackStorage(request) request.path = "/awesome/url/" poll = Poll.objects.create(question="why?", pub_date=today) poll.question = "how?" poll.save() admin_site = AdminSite() admin = SimpleHistoryAdmin(Poll, admin_site) with patch("simple_history.admin.SIMPLE_HISTORY_EDIT", True): response = admin.response_change(request, poll) self.assertEqual(response["Location"], "/awesome/url/")
def test_generic_inline_model_admin_non_gfk_fk_field(self): """ A GenericInlineModelAdmin raises problems if the ct_fk_field points to a field that isn't part of a GenericForeignKey. """ class InfluenceInline(GenericStackedInline): model = Influence ct_fk_field = 'name' class SongAdmin(admin.ModelAdmin): inlines = [InfluenceInline] errors = SongAdmin(Song, AdminSite()).check() expected = [ checks.Error( "'admin_checks.Influence' has no GenericForeignKey using " "content type field 'content_type' and object ID field 'name'.", obj=InfluenceInline, id='admin.E304', ) ] self.assertEqual(errors, expected)
def test_fieldsets_fields_non_tuple(self): """ The first fieldset's fields must be a list/tuple. """ class NotATupleAdmin(admin.ModelAdmin): list_display = ["pk", "title"] list_editable = ["title"] fieldsets = [ (None, { "fields": "title" # not a tuple }), ] errors = NotATupleAdmin(Song, AdminSite()).check() expected = [ checks.Error( "The value of 'fieldsets[0][1]['fields']' must be a list or tuple.", obj=NotATupleAdmin, id='admin.E008', ) ] self.assertEqual(errors, expected)
def setUpTestData(cls): cls.site = AdminSite() cls.company = Company.objects.create(name='Company') company2 = Company.objects.create(name='Company2') cls.dish = Dish.objects.create(name='Dish1', company=cls.company, price=10, preparation_time='15min') cls.dish2 = Dish.objects.create(name='Dish2', company=company2, price=10, preparation_time='15min') cls.da = DishAdmin(Dish, cls.site) user = mock.Mock(spec=User) user.company = cls.company cls.request = mock.Mock(spec=Request) cls.request.user = user
def test_nonfirst_fieldset(self): """ The second fieldset's fields must be a list/tuple. """ class NotATupleAdmin(admin.ModelAdmin): fieldsets = [ (None, { "fields": ("title",) }), ('foo', { "fields": "author" # not a tuple }), ] errors = NotATupleAdmin(Song, AdminSite()).check() expected = [ checks.Error( "The value of 'fieldsets[1][1]['fields']' must be a list or tuple.", obj=NotATupleAdmin, id='admin.E008', ) ] self.assertEqual(errors, expected)
def test_exclude_inline_model_admin(self): """ Regression test for #9932 - exclude in InlineModelAdmin should not contain the ForeignKey field used in ModelAdmin.model """ class SongInline(admin.StackedInline): model = Song exclude = ['album'] class AlbumAdmin(admin.ModelAdmin): model = Album inlines = [SongInline] errors = AlbumAdmin(Album, AdminSite()).check() expected = [ checks.Error( "Cannot exclude the field 'album', because it is the foreign key " "to the parent model 'admin_checks.Album'.", obj=SongInline, id='admin.E201', ) ] self.assertEqual(errors, expected)
def test_date_field_filter(self): class Musician2(models.Model): birthday = models.DateField() class Meta: app_label = 'test' class Album2(models.Model): artist = models.ForeignKey(Musician2, on_delete=models.CASCADE, null=True, blank=True) class Meta: app_label = 'test' class TestAdmin(TestRelatedFieldAdmin): list_display = ('artist__birthday__month',) admin = TestAdmin(Album2, AdminSite()) artist = Musician2(birthday=datetime.date(2020, 2, 2)) self.assertEqual(admin.artist__birthday__month(Album2(artist=artist)), 2) self.assertEqual(admin.get_list_display(None), ('artist__birthday__month',)) admin.get_queryset(None) admin.fake_qs.select_related.assert_called_with()
def test_submit_premium_offer_discount_already_sent_too_recently( self, messageUserMock, taskMock): request = RequestFactory().get("/") email = BroadcastEmail.objects.create(subject="test") admin = BroadcastEmailAdmin(model=BroadcastEmail, admin_site=AdminSite()) user = User.objects.create(username="******", password="******") user.userprofile.premium_offer = "premium_offer_discount_20" user.userprofile.premium_offer_expiration = datetime.now() + timedelta( days=1) user.userprofile.premium_offer_sent = sent = datetime.now( ) - timedelta(days=20) user.userprofile.receive_marketing_and_commercial_material = True user.userprofile.save() admin.submit_premium_offer_discount( request, BroadcastEmail.objects.filter(pk=email.pk)) taskMock.assert_not_called() user.userprofile.refresh_from_db() self.assertEqual(sent, user.userprofile.premium_offer_sent)
def test_dynamic_inline_admins_fieldsets(self): """ Tests if ``_order`` is moved to the end of the last fieldsets fields. """ class MyModelInline(BaseDynamicInlineAdmin, InlineModelAdmin): model = RichTextPage fieldsets = ( ("Fieldset 1", { "fields": ("a", ) }), ("Fieldset 2", { "fields": ("_order", "b") }), ("Fieldset 3", { "fields": ("c") }), ) request = self._request_factory.get("/admin/") inline = MyModelInline(None, AdminSite()) fieldsets = inline.get_fieldsets(request) self.assertEqual(fieldsets[-1][1]["fields"][-1], "_order") self.assertNotIn("_order", fieldsets[1][1]["fields"])
def test_related_field(self): class Musician(models.Model): first_name = models.CharField(max_length=50) class Meta: app_label = 'test' class Album(models.Model): artist = models.ForeignKey(Musician, on_delete=models.CASCADE, null=True, blank=True) class Meta: app_label = 'test' class TestAdmin(TestRelatedFieldAdmin): list_display = ('artist__first_name',) admin = TestAdmin(Album, AdminSite()) album = Album(artist=Musician(first_name='Foo')) self.assertEqual(admin.artist__first_name(album), 'Foo') self.assertEqual(admin.get_list_display(None), ('artist__first_name',)) admin.get_queryset(None) admin.fake_qs.select_related.assert_called_with('artist')
def test_admin_defaults(self): """ Test UserAdmin default construction """ site = AdminSite() admin = UserAdmin(User, site) self.assertEqual( admin.list_display, ('id', 'email', 'first_name', 'last_name',) ) self.assertEqual(admin.list_filter, ()) self.assertEqual(admin.ordering, ('id',)) self.assertEqual( admin.search_fields, ('id', 'email', 'first_name', 'last_name') ) self.assertEqual( admin.fieldsets, ( ('Personal info', { 'fields': ('email', 'title', 'first_name', 'last_name',) }), ('Permissions', { 'fields': ('is_superuser', 'groups', 'user_permissions') }), ), ) self.assertEqual( admin.add_fieldsets, ( (None, { 'fields': ( 'email', 'title', 'first_name', 'last_name', 'password1', 'password2' ), }), ), )
def test_submit_premium_offer_discount_two_users(self, messageUserMock, taskMock): request = RequestFactory().get("/") email = BroadcastEmail.objects.create(subject="test") admin = BroadcastEmailAdmin(model=BroadcastEmail, admin_site=AdminSite()) user = User.objects.create(username="******", password="******", email="*****@*****.**") user.userprofile.premium_offer = "premium_offer_discount_20" user.userprofile.premium_offer_expiration = datetime.now() + timedelta( days=1) user.userprofile.receive_marketing_and_commercial_material = True user.userprofile.save() user2 = User.objects.create(username="******", password="******", email="*****@*****.**") user2.userprofile.premium_offer = "premium_offer_discount_50" user2.userprofile.premium_offer_expiration = datetime.now( ) + timedelta(days=1) user2.userprofile.receive_marketing_and_commercial_material = True user2.userprofile.save() admin.submit_premium_offer_discount( request, BroadcastEmail.objects.filter(pk=email.pk)) args, kwargs = taskMock.call_args taskMock.assert_called() self.assertEquals(["*****@*****.**", "*****@*****.**"], list(args[1])) user.userprofile.refresh_from_db() user2.userprofile.refresh_from_db() self.assertIsNotNone(user.userprofile.premium_offer_sent) self.assertIsNotNone(user2.userprofile.premium_offer_sent)
def setUp(self): self.users_credentials = { 'superuser': { 'username': '******', 'password': '******', }, 'goadmin': { 'username': '******', 'password': '******', }, 'moadmin': { 'username': '******', 'password': '******', } } self.mo_admin_instance = MemberOrganisationOwnerAdmin( CompanyOrganisationOwner, AdminSite() ) self.group = Group.objects.get(name=self.group_name) self.request_factory = RequestFactory() self.mixer = Mixer(locale='en') self.model_instances = self.create_required_instances()
def test_callable_field(self): class Musician1(models.Model): def get_foo(self): return 'Foo' class Meta: app_label = 'test' class Album1(models.Model): artist = models.ForeignKey(Musician1, on_delete=models.CASCADE, null=True, blank=True) class Meta: app_label = 'test' class TestAdmin(TestRelatedFieldAdmin): list_display = ('artist__get_foo',) admin = TestAdmin(Album1, AdminSite()) album = Album1(artist=Musician1()) self.assertEqual(admin.artist__get_foo(album), 'Foo') self.assertEqual(admin.get_list_display(None), ('artist__get_foo',)) admin.get_queryset(None) admin.fake_qs.select_related.assert_called_with('artist')
def setUp(self): self.factory = RequestFactory() self.user = User.objects.create_superuser(username='******', email='test@localhost', password='******') self.site = AdminSite() Booking.objects.create( event_type_id="1", spot_start="2019-01-01 14:30:00-0400", spot_end="2019-01-01 14:40:00-0400", approval_status=Booking.APPROVAL_STATUS_NEW, ) Booking.objects.create( event_type_id="2", spot_start="2019-01-01 14:40:00-0400", spot_end="2019-01-01 14:50:00-0400", approval_status=Booking.APPROVAL_STATUS_DECLINED, ) Booking.objects.create( event_type_id="2", spot_start="2019-01-01 14:50:00-0400", spot_end="2019-01-01 15:00:00-0400", approval_status=Booking.APPROVAL_STATUS_APPROVED, approval_protected=True)
def setUp(self): self.site = AdminSite(name='admin')
class TestPublishableAdmin(TestCase): def setUp(self): super(TestPublishableAdmin, self).setUp() self.page1 = Page.objects.create(slug='page1', title='page 1') self.page2 = Page.objects.create(slug='page2', title='page 2') self.page1.publish() self.page2.publish() self.author1 = Author.objects.create(name='a1') self.author2 = Author.objects.create(name='a2') self.author1.publish() self.author2.publish() self.admin_site = AdminSite('Test Admin') class PageBlockInline(PublishableStackedInline): model = PageBlock class PageAdmin(PublishableAdmin): inlines = [PageBlockInline] self.admin_site.register(Page, PageAdmin) self.page_admin = PageAdmin(Page, self.admin_site) # override urls, so reverse works settings.ROOT_URLCONF = patterns( '', ('^admin/', include(self.admin_site.urls)), ) def test_get_publish_status_display(self): page = Page.objects.create(slug="hhkkk", title="hjkhjkh") self.failUnlessEqual('Changed - not yet published', self.page_admin.get_publish_status_display(page)) page.publish() self.failUnlessEqual('Published', self.page_admin.get_publish_status_display(page)) page.save() self.failUnlessEqual('Changed', self.page_admin.get_publish_status_display(page)) page.delete() self.failUnlessEqual('To be deleted', self.page_admin.get_publish_status_display(page)) def test_queryset(self): # make sure we only get back draft objects request = None self.failUnlessEqual( set([self.page1, self.page1.public, self.page2, self.page2.public]), set(Page.objects.all()) ) self.failUnlessEqual( set([self.page1, self.page2]), set(self.page_admin.queryset(request)) ) def test_get_actions_global_delete_replaced(self): from publish.actions import delete_selected class request(object): GET = {} actions = self.page_admin.get_actions(request) self.failUnless('delete_selected' in actions) action, name, description = actions['delete_selected'] self.failUnlessEqual(delete_selected, action) self.failUnlessEqual('delete_selected', name) self.failUnlessEqual(delete_selected.short_description, description) def test_formfield_for_foreignkey(self): # foreign key forms fields in admin # for publishable models should be filtered # to hide public object request = None parent_field = None for field in Page._meta.fields: if field.name == 'parent': parent_field = field break self.failUnless(parent_field) choice_field = self.page_admin.formfield_for_foreignkey(parent_field, request) self.failUnless(choice_field) self.failUnless(isinstance(choice_field, ModelChoiceField)) self.failUnlessEqual( set([self.page1, self.page1.public, self.page2, self.page2.public]), set(Page.objects.all()) ) self.failUnlessEqual( set([self.page1, self.page2]), set(choice_field.queryset) ) def test_formfield_for_manytomany(self): request = None authors_field = None for field in Page._meta.many_to_many: if field.name == 'authors': authors_field = field break self.failUnless(authors_field) choice_field = self.page_admin.formfield_for_manytomany(authors_field, request) self.failUnless(choice_field) self.failUnless(isinstance(choice_field, ModelMultipleChoiceField)) self.failUnlessEqual( set([self.author1, self.author1.public, self.author2, self.author2.public]), set(Author.objects.all()) ) self.failUnlessEqual( set([self.author1, self.author2]), set(choice_field.queryset) ) def test_has_change_permission(self): class dummy_request(object): method = 'GET' REQUEST = {} class user(object): @classmethod def has_perm(cls, permission): return True self.failUnless(self.page_admin.has_change_permission(dummy_request)) self.failUnless( self.page_admin.has_change_permission(dummy_request, self.page1)) self.failIf(self.page_admin.has_change_permission(dummy_request, self.page1.public)) # can view deleted items self.page1.publish_state = Publishable.PUBLISH_DELETE self.failUnless( self.page_admin.has_change_permission(dummy_request, self.page1)) # but cannot modify them dummy_request.method = 'POST' self.failIf( self.page_admin.has_change_permission(dummy_request, self.page1)) def test_has_delete_permission(self): class dummy_request(object): method = 'GET' REQUEST = {} class user(object): @classmethod def has_perm(cls, permission): return True self.failUnless(self.page_admin.has_delete_permission(dummy_request)) self.failUnless( self.page_admin.has_delete_permission(dummy_request, self.page1)) self.failIf(self.page_admin.has_delete_permission(dummy_request, self.page1.public)) def test_change_view_normal(self): class dummy_request(object): method = 'GET' REQUEST = {} COOKIES = {} META = {} @classmethod def is_ajax(cls): return False @classmethod def is_secure(cls): return False class user(object): @classmethod def has_perm(cls, permission): return True @classmethod def get_and_delete_messages(cls): return [] response = self.page_admin.change_view(dummy_request, str(self.page1.id)) self.failUnless(response is not None) self.failIf('deleted' in _get_rendered_content(response)) def test_change_view_not_deleted(self): class dummy_request(object): method = 'GET' COOKIES = {} META = {} @classmethod def is_ajax(cls): return False @classmethod def is_secure(cls): return False class user(object): @classmethod def has_perm(cls, permission): return True try: self.page_admin.change_view(dummy_request, unicode(self.page1.public.id)) self.fail() except Http404: pass def test_change_view_deleted(self): class dummy_request(object): method = 'GET' REQUEST = {} COOKIES = {} META = {} @classmethod def is_ajax(cls): return False @classmethod def is_secure(cls): return False class user(object): @classmethod def has_perm(cls, permission): return True @classmethod def get_and_delete_messages(cls): return [] self.page1.delete() response = self.page_admin.change_view(dummy_request, str(self.page1.id)) self.failUnless(response is not None) self.failUnless('deleted' in _get_rendered_content(response)) def test_change_view_deleted_POST(self): class dummy_request(object): csrf_processing_done = True method = 'POST' COOKIES = {} META = {} POST = {} @classmethod def is_ajax(cls): return False @classmethod def is_secure(cls): return False self.page1.delete() try: self.page_admin.change_view(dummy_request, str(self.page1.id)) self.fail() except PermissionDenied: pass def test_change_view_delete_inline(self): block = PageBlock.objects.create(page=self.page1, content='some content') page1 = Page.objects.get(pk=self.page1.pk) page1.publish() user1 = User.objects.create_user('test1', '*****@*****.**', 'jkljkl') # fake selecting the delete tickbox for the block class dummy_request(object): csrf_processing_done = True method = 'POST' POST = { 'slug': page1.slug, 'title': page1.title, 'content': page1.content, 'pub_date_0': '2010-02-12', 'pub_date_1': '17:40:00', 'pageblock_set-TOTAL_FORMS': '2', 'pageblock_set-INITIAL_FORMS': '1', 'pageblock_set-0-id': str(block.id), 'pageblock_set-0-page': str(page1.id), 'pageblock_set-0-DELETE': 'yes' } REQUEST = POST FILES = {} COOKIES = {} META = {} @classmethod def is_ajax(cls): return False @classmethod def is_secure(cls): return False class user(object): pk = user1.pk @classmethod def is_authenticated(self): return True @classmethod def has_perm(cls, permission): return True @classmethod def get_and_delete_messages(cls): return [] class message_set(object): @classmethod def create(cls, message=''): pass class _messages(object): @classmethod def add(cls, *message): pass block = PageBlock.objects.get(id=block.id) public_block = block.public response = self.page_admin.change_view(dummy_request, str(page1.id)) self.assertEqual(302, response.status_code) # the block should have been deleted (but not the public one) self.failUnlessEqual([public_block], list(PageBlock.objects.all()))
from django.conf import settings from django.contrib.admin import AdminSite from django.contrib.auth.models import User from django.contrib.auth.admin import UserAdmin from django.contrib.flatpages.models import FlatPage from django.contrib.flatpages.admin import FlatPageAdmin site = AdminSite() class CustomUserAdmin(UserAdmin): # Remove group editing fieldsets = UserAdmin.fieldsets[:-1] def has_delete_permission(self, request, obj=None): return getattr(settings, 'BACKOFFICE', False) class CustomFlatPageAdmin(FlatPageAdmin): list_filter = [] site.register(User, CustomUserAdmin) site.register(FlatPage, CustomFlatPageAdmin)
from __future__ import unicode_literals from django.contrib.admin import AdminSite, ModelAdmin, TabularInline from admin_enhancer import admin as enhanced_admin from .models import Author, Book, Character, Theme site = AdminSite() class EnhancedModelAdmin(enhanced_admin.EnhancedModelAdminMixin, ModelAdmin): pass class CharacterInline(enhanced_admin.EnhancedAdminMixin, TabularInline): model = Character class BookAdmin(EnhancedModelAdmin): inlines = (CharacterInline,) filter_horizontal = ('themes',) site.register(Author, EnhancedModelAdmin) site.register(Book, BookAdmin) site.register(Theme, EnhancedModelAdmin)
list_filter = ["category_id", "designation"] inlines = [AttendanceInline] class AttendanceAdmin(admin.ModelAdmin): list_display = ("employee_id", "date", "shift", "project") list_filter = ["employee_id", "date", "project"] class PaymentAdmin(admin.ModelAdmin): list_display = ("paid_date", "amount", "paid_details", "project_id") list_filter = ["project_id", "amount", "paid_date"] class EmpPaymentAdmin(admin.ModelAdmin): list_display = ("employee", "amount", "type", "month", "year") list_filter = ["employee", "month", "year"] site = AdminSite() site.site_header = "Omar and Assosciates" site.register(Project, ProjectAdmin) site.register(Category) site.register(Dealer) site.register(Expense, ExpenseAdmin) site.register(Employee, EmployeeAdmin) site.register(Attendance, AttendanceAdmin) site.register(EmployeePayment, EmpPaymentAdmin) site.register(Payment, PaymentAdmin)
actions = super(PollAdmin, self).get_change_actions(request, object_id, form_url) actions = list(actions) if not request.user.is_superuser: return [] obj = self.model.objects.get(pk=object_id) if obj.question.endswith('?'): actions.remove('question_mark') return actions admin.site.register(Poll, PollAdmin) class CommentAdmin(DjangoObjectActions, admin.ModelAdmin): # Object actions ################ def hodor(self, request, obj): if not obj.comment: # bail because we need a comment return obj.comment = ' '.join(['hodor' for x in obj.comment.split()]) obj.save() change_actions = ('hodor', ) admin.site.register(Comment, CommentAdmin) support_admin = AdminSite(name='support') support_admin.register(Poll, PollAdmin)
class AdminTest(AppTestCase): """ Test the admin functions. """ def setUp(self): # Admin objects for all tests. self.factory = RequestFactory() self.admin_site = AdminSite() self.admin_user = User.objects.get(is_superuser=True) self.settings = override_settings( MIDDLEWARE_CLASSES = ( 'django.middleware.common.CommonMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', ) ) self.settings.enable() def tearDown(self): self.settings.disable() def test_add_page(self): """ Test adding an object with placeholder field via the admin. """ self.admin_site.register(PlaceholderFieldTestPage, PlaceholderFieldTestPageAdmin) modeladmin = self.admin_site._registry[PlaceholderFieldTestPage] # Get all post data. # Includes all inlines, so all inline formsets of other plugins will be added (with TOTAL_FORMS 0) contents_slot = PlaceholderFieldTestPage.contents.slot formdata = self._get_management_form_data(modeladmin) formdata.update({ 'title': 'TEST1', 'placeholder-fs-TOTAL_FORMS': '1', 'placeholder-fs-MAX_NUM_FORMS': '', # Needed for Django <= 1.4.3 'placeholder-fs-INITIAL_FORMS': '0', # Needed for Django 1.3 'placeholder-fs-0-slot': contents_slot, 'placeholder-fs-0-role': Placeholder.MAIN, 'rawhtmltestitem-TOTAL_FORMS': '1', 'rawhtmltestitem-MAX_NUM_FORMS': '', 'rawhtmltestitem-INITIAL_FORMS': '0', 'rawhtmltestitem-0-placeholder': '', # The placeholder is not defined yet, as item is not yet created. 'rawhtmltestitem-0-placeholder_slot': contents_slot, # BaseContentItemFormSet resolves the placeholder after it's created 'rawhtmltestitem-0-sort_order': '1', 'rawhtmltestitem-0-html': u'<b>foo</b>', }) # Make a POST to the admin page. response = self._post_add(modeladmin, formdata) self.assertEqual(response.status_code, 302, "No redirect, received:\n\n{0}".format(self._render_response(response))) # Check that the page exists. page = PlaceholderFieldTestPage.objects.get(title='TEST1') # Check that the placeholder is created, # and properly links back to it's parent. placeholder = page.contents self.assertEqual(placeholder.slot, contents_slot) self.assertEqual(placeholder.role, Placeholder.MAIN) self.assertEqual(placeholder.parent, page) # Check that the ContentItem is created, # and properly links back to it's parent. rawhtmltestitem = RawHtmlTestItem.objects.get(html=u'<b>foo</b>') self.assertEqual(rawhtmltestitem.placeholder, placeholder) self.assertEqual(rawhtmltestitem.parent, page) # Also check reverse relation of placeholder rawhtmltestitem = placeholder.contentitems.all()[0] self.assertEqual(rawhtmltestitem.html, u'<b>foo</b>') def _post_add(self, modeladmin, formdata): opts = modeladmin.opts url = reverse('admin:{0}_{1}_add'.format(*_get_url_format(opts))) # Build request formdata['csrfmiddlewaretoken'] = 'foo' request = self.factory.post(url, data=formdata) request.COOKIES[settings.CSRF_COOKIE_NAME] = 'foo' # Add properties which middleware would typically do request.session = {} request.user = self.admin_user MessageMiddleware().process_request(request) # Make a direct call, circumvents login page. return modeladmin.add_view(request) def _get_management_form_data(self, modeladmin): """ Return the formdata that the management forms need. """ opts = modeladmin.opts url = reverse('admin:{0}_{1}_add'.format(*_get_url_format(opts))) request = self.factory.get(url) request.user = self.admin_user if hasattr(modeladmin, 'get_inline_instances'): inline_instances = modeladmin.get_inline_instances(request) # Django 1.4 else: inline_instances = [inline_class(modeladmin.model, self.admin_site) for inline_class in modeladmin.inlines] forms = [] for inline_instance in inline_instances: FormSet = inline_instance.get_formset(request) formset = FormSet(instance=modeladmin.model()) forms.append(formset.management_form) # In a primitive way, get the form fields. # This is not exactly the same as a POST, since that runs through clean() formdata = {} for form in forms: for boundfield in form: formdata[boundfield.html_name] = boundfield.value() return formdata def _render_response(self, response): if hasattr(response, 'render'): # TemplateResponse return u"== Context ==\n{0}\n\n== Response ==\n{1}".format(pformat(response.context_data), response.render().content) else: return response.content
class AdminTestCase(TestCase): """ Testing the admin site """ #: The model to test model = None #: The admin class to test admin_class = None @classmethod def setUpClass(cls): super(AdminTestCase, cls).setUpClass() cls.admin_user = User.objects.create_superuser('admin', '*****@*****.**', password='******') def setUp(self): super(AdminTestCase, self).setUp() # Have a separate site, to avoid dependency on polymorphic wrapping or standard admin configuration self.admin_site = AdminSite() if self.model is not None: self.admin_register(self.model, self.admin_class) def tearDown(self): clear_url_caches() set_urlconf(None) def register(self, model): """Decorator, like admin.register()""" def _dec(admin_class): self.admin_register(model, admin_class) return admin_class return _dec def admin_register(self, model, admin_site): """Register an model with admin to the test case, test client and URL reversing code.""" self.admin_site.register(model, admin_site) # Make sure the URLs are reachable by reverse() clear_url_caches() set_urlconf(tuple([ url('^tmp-admin/', self.admin_site.urls) ])) def get_admin_instance(self, model): try: return self.admin_site._registry[model] except KeyError: raise ValueError("Model not registered with admin: {}".format(model)) @classmethod def tearDownClass(cls): super(AdminTestCase, cls).tearDownClass() clear_url_caches() set_urlconf(None) def get_add_url(self, model): admin_instance = self.get_admin_instance(model) return reverse(admin_urlname(admin_instance.opts, 'add')) def get_changelist_url(self, model): admin_instance = self.get_admin_instance(model) return reverse(admin_urlname(admin_instance.opts, 'changelist')) def get_change_url(self, model, object_id): admin_instance = self.get_admin_instance(model) return reverse(admin_urlname(admin_instance.opts, 'change'), args=(object_id,)) def get_history_url(self, model, object_id): admin_instance = self.get_admin_instance(model) return reverse(admin_urlname(admin_instance.opts, 'history'), args=(object_id,)) def get_delete_url(self, model, object_id): admin_instance = self.get_admin_instance(model) return reverse(admin_urlname(admin_instance.opts, 'delete'), args=(object_id,)) def admin_get_add(self, model, qs=''): """ Make a direct "add" call to the admin page, circumvening login checks. """ admin_instance = self.get_admin_instance(model) request = self.create_admin_request('get', self.get_add_url(model) + qs) response = admin_instance.add_view(request) self.assertEqual(response.status_code, 200) return response def admin_post_add(self, model, formdata, qs=''): """ Make a direct "add" call to the admin page, circumvening login checks. """ admin_instance = self.get_admin_instance(model) request = self.create_admin_request('post', self.get_add_url(model) + qs, data=formdata) response = admin_instance.add_view(request) self.assertFormSuccess(request.path, response) return response def admin_get_changelist(self, model): """ Make a direct "add" call to the admin page, circumvening login checks. """ admin_instance = self.get_admin_instance(model) request = self.create_admin_request('get', self.get_changelist_url(model)) response = admin_instance.changelist_view(request) self.assertEqual(response.status_code, 200) return response def admin_get_change(self, model, object_id, query=None, **extra): """ Perform a GET request on the admin page """ admin_instance = self.get_admin_instance(model) request = self.create_admin_request('get', self.get_change_url(model, object_id), data=query, **extra) response = admin_instance.change_view(request, str(object_id)) self.assertEqual(response.status_code, 200) return response def admin_post_change(self, model, object_id, formdata, **extra): """ Make a direct "add" call to the admin page, circumvening login checks. """ admin_instance = self.get_admin_instance(model) request = self.create_admin_request('post', self.get_change_url(model, object_id), data=formdata, **extra) response = admin_instance.change_view(request, str(object_id)) self.assertFormSuccess(request.path, response) return response def admin_get_history(self, model, object_id, query=None, **extra): """ Perform a GET request on the admin page """ admin_instance = self.get_admin_instance(model) request = self.create_admin_request('get', self.get_history_url(model, object_id), data=query, **extra) response = admin_instance.history_view(request, str(object_id)) self.assertEqual(response.status_code, 200) return response def admin_get_delete(self, model, object_id, query=None, **extra): """ Perform a GET request on the admin delete page """ admin_instance = self.get_admin_instance(model) request = self.create_admin_request('get', self.get_delete_url(model, object_id), data=query, **extra) response = admin_instance.delete_view(request, str(object_id)) self.assertEqual(response.status_code, 200) return response def admin_post_delete(self, model, object_id, **extra): """ Make a direct "add" call to the admin page, circumvening login checks. """ if not extra: extra = {'data': {'post': 'yes'}} admin_instance = self.get_admin_instance(model) request = self.create_admin_request('post', self.get_delete_url(model, object_id), **extra) response = admin_instance.delete_view(request, str(object_id)) self.assertEqual(response.status_code, 302, "Form errors in calling {0}".format(request.path)) return response def create_admin_request(self, method, url, data=None, **extra): """ Construct an Request instance for the admin view. """ factory_method = getattr(RequestFactory(), method) if data is not None: if method != 'get': data['csrfmiddlewaretoken'] = 'foo' dummy_request = factory_method(url, data=data) dummy_request.user = self.admin_user # Add the management form fields if needed. # base_data = self._get_management_form_data(dummy_request) # base_data.update(data) # data = base_data request = factory_method(url, data=data, **extra) request.COOKIES[settings.CSRF_COOKIE_NAME] = 'foo' request.csrf_processing_done = True # Add properties which middleware would typically do request.session = {} request.user = self.admin_user MessageMiddleware().process_request(request) return request def assertFormSuccess(self, request_url, response): """ Assert that the response was a redirect, not a form error. """ self.assertIn(response.status_code, [200, 302]) if response.status_code != 302: context_data = response.context_data if 'errors' in context_data: errors = response.context_data['errors'] elif 'form' in context_data: errors = context_data['form'].errors else: raise KeyError("Unknown field for errors in the TemplateResponse!") self.assertEqual(response.status_code, 302, "Form errors in calling {0}:\n{1}".format(request_url, errors.as_text())) self.assertTrue('/login/?next=' not in response['Location'], "Received login response for {0}".format(request_url))
class TestPublishSelectedAction(TestCase): def setUp(self): super(TestPublishSelectedAction, self).setUp() self.fp1 = Page.objects.create(slug='fp1', title='FP1') self.fp2 = Page.objects.create(slug='fp2', title='FP2') self.fp3 = Page.objects.create(slug='fp3', title='FP3') self.admin_site = AdminSite('Test Admin') self.page_admin = PublishableAdmin(Page, self.admin_site) # override urls, so reverse works settings.ROOT_URLCONF = patterns( '', ('^admin/', include(self.admin_site.urls)), ) def test_publish_selected_confirm(self): pages = Page.objects.exclude(id=self.fp3.id) class dummy_request(object): META = {} POST = {} class user(object): @classmethod def has_perm(cls, *arg): return True @classmethod def get_and_delete_messages(cls): return [] response = publish_selected(self.page_admin, dummy_request, pages) self.failIf(Page.objects.published().count() > 0) self.failUnless(response is not None) self.failUnlessEqual(200, response.status_code) def test_publish_selected_confirmed(self): pages = Page.objects.exclude(id=self.fp3.id) class dummy_request(object): POST = {'post': True} class user(object): @classmethod def is_authenticated(cls): return True @classmethod def has_perm(cls, *arg): return True class message_set(object): @classmethod def create(cls, message=None): self._message = message class _messages(object): @classmethod def add(cls, *message): self._message = message response = publish_selected(self.page_admin, dummy_request, pages) self.failUnlessEqual(2, Page.objects.published().count()) self.failUnless(getattr(self, '_message', None) is not None) self.failUnless(response is None) def test_convert_all_published_to_html(self): self.admin_site.register(Page, PublishableAdmin) all_published = NestedSet() page = Page.objects.create(slug='here', title='title') block = PageBlock.objects.create(page=page, content='stuff here') all_published.add(page) all_published.add(block, parent=page) converted = _convert_all_published_to_html(self.admin_site, all_published) expected = [ u'<a href="../../example_app/page/%d/">Page: here (Changed - ' u'not yet published)</a>' % page.id, [u'Page block: PageBlock object']] self.failUnlessEqual(expected, converted) def test_publish_selected_does_not_have_permission(self): self.admin_site.register(Page, PublishableAdmin) pages = Page.objects.exclude(id=self.fp3.id) class dummy_request(object): POST = {} META = {} class user(object): @classmethod def has_perm(cls, *arg): return False @classmethod def get_and_delete_messages(cls): return [] response = publish_selected(self.page_admin, dummy_request, pages) self.failIf(response is None) # publish button should not be in response self.failIf('value="publish_selected"' in response.content) self.failIf('value="Yes, Publish"' in response.content) self.failIf('form' in response.content) self.failIf(Page.objects.published().count() > 0) def test_publish_selected_does_not_have_related_permission(self): # check we can't publish when we don't have permission # for a related model (in this case authors) self.admin_site.register(Author, PublishableAdmin) author = Author.objects.create(name='John') self.fp1.authors.add(author) pages = Page.objects.draft() class dummy_request(object): POST = {'post': True} class _messages(object): @classmethod def add(cls, *args): return 'message' class user(object): pk = 1 @classmethod def is_authenticated(cls): return True @classmethod def has_perm(cls, perm): return perm != 'example_app.publish_author' try: publish_selected(self.page_admin, dummy_request, pages) self.fail() except PermissionDenied: pass self.failIf(Page.objects.published().count() > 0) def test_publish_selected_logs_publication(self): self.admin_site.register(Page, PublishableAdmin) pages = Page.objects.exclude(id=self.fp3.id) class dummy_request(object): POST = {'post': True} class user(object): pk = 1 @classmethod def is_authenticated(cls): return True @classmethod def has_perm(cls, perm): return perm != 'example_app.publish_author' class message_set(object): @classmethod def create(cls, message=None): pass class _messages(object): @classmethod def add(cls, *message): pass publish_selected(self.page_admin, dummy_request, pages) # should have logged two publications from django.contrib.admin.models import LogEntry from django.contrib.contenttypes.models import ContentType ContentType.objects.get_for_model(self.fp1).pk self.failUnlessEqual(2, LogEntry.objects.filter().count())
class AdminTest(AppTestCase): """ Test the admin functions. """ def setUp(self): # Admin objects for all tests. self.factory = RequestFactory() self.admin_site = AdminSite() self.admin_user = User.objects.get(is_superuser=True) self.settings = override_settings(MIDDLEWARE_CLASSES=( "django.middleware.common.CommonMiddleware", "django.contrib.sessions.middleware.SessionMiddleware", "django.middleware.csrf.CsrfViewMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", "django.contrib.messages.middleware.MessageMiddleware", )) self.settings.enable() def tearDown(self): self.settings.disable() def test_add_page(self): """ Test adding an object with placeholder field via the admin. """ self.admin_site.register(PlaceholderFieldTestPage, PlaceholderFieldTestPageAdmin) modeladmin = self.admin_site._registry[PlaceholderFieldTestPage] # Get all post data. # Includes all inlines, so all inline formsets of other plugins will be added (with TOTAL_FORMS 0) contents_slot = PlaceholderFieldTestPage.contents.slot formdata = self._get_management_form_data(modeladmin) formdata.update({ "title": "TEST1", "placeholder-fs-TOTAL_FORMS": "1", "placeholder-fs-0-slot": contents_slot, "placeholder-fs-0-role": Placeholder.MAIN, "rawhtmltestitem-TOTAL_FORMS": "1", "rawhtmltestitem-MAX_NUM_FORMS": "", "rawhtmltestitem-INITIAL_FORMS": "0", "rawhtmltestitem-0-placeholder": "", # The placeholder is not defined yet, as item is not yet created. "rawhtmltestitem-0-placeholder_slot": contents_slot, # BaseContentItemFormSet resolves the placeholder after it's created "rawhtmltestitem-0-sort_order": "1", "rawhtmltestitem-0-html": "<b>foo</b>", }) # Make a POST to the admin page. response = self._post_add(modeladmin, formdata) self.assertEqual( response.status_code, 302, f"No redirect, received:\n\n{self._render_response(response)}", ) # Check that the page exists. page = PlaceholderFieldTestPage.objects.get(title="TEST1") # Check that the placeholder is created, # and properly links back to it's parent. placeholder = page.contents self.assertEqual(placeholder.slot, contents_slot) self.assertEqual(placeholder.role, Placeholder.MAIN) self.assertEqual(placeholder.parent, page) # Check that the ContentItem is created, # and properly links back to it's parent. rawhtmltestitem = RawHtmlTestItem.objects.get(html="<b>foo</b>") self.assertEqual(rawhtmltestitem.placeholder, placeholder) self.assertEqual(rawhtmltestitem.parent, page) # Also check reverse relation of placeholder rawhtmltestitem = placeholder.contentitems.all()[0] self.assertEqual(rawhtmltestitem.html, "<b>foo</b>") def test_copy_language_backend(self): """ Testing how the copy button works. It calls the ``get_placeholder_data_view`` function. """ self.admin_site.register(PlaceholderFieldTestPage, PlaceholderFieldTestPageAdmin) modeladmin = self.admin_site._registry[PlaceholderFieldTestPage] page = factories.create_page() placeholder = factories.create_placeholder(page=page) item1 = factories.create_content_item(RawHtmlTestItem, placeholder=placeholder, html="AA") item2 = factories.create_content_item(RawHtmlTestItem, placeholder=placeholder, html="BB") request = self._get_request( admin_urlname(page._meta, "get_placeholder_data")) data = modeladmin.get_placeholder_data_view(request, page.pk).jsondata self.assertEqual(len(data["formset_forms"]), 2) self.assertEqual(data["formset_forms"][0]["model"], "RawHtmlTestItem") self.assertEqual(data["formset_forms"][0]["contentitem_id"], item1.pk) self.assertEqual(data["formset_forms"][1]["contentitem_id"], item2.pk) self.assertTrue("AA" in data["formset_forms"][0]["html"]) def _get_request(self, url, data=None): request = self.factory.post(url, data=data or {}) request.csrf_processing_done = True request.session = {} request.user = self.admin_user MessageMiddleware().process_request(request) return request def _post_add(self, modeladmin, formdata): opts = modeladmin.opts url = reverse(f"admin:{opts.app_label}_{opts.model_name}_add") # Build request # Add properties which middleware would typically do request = self._get_request(url, data=formdata) # Make a direct call, circumvents login page. return modeladmin.add_view(request) def _get_management_form_data(self, modeladmin): """ Return the formdata that the management forms need. """ opts = modeladmin.opts url = reverse(f"admin:{opts.app_label}_{opts.model_name}_add") request = self.factory.get(url) request.user = self.admin_user inline_instances = modeladmin.get_inline_instances(request) forms = [] for inline_instance in inline_instances: FormSet = inline_instance.get_formset(request) formset = FormSet(instance=modeladmin.model()) forms.append(formset.management_form) # In a primitive way, get the form fields. # This is not exactly the same as a POST, since that runs through clean() formdata = {} for form in forms: for boundfield in form: formdata[boundfield.html_name] = boundfield.value() return formdata def _render_response(self, response): if hasattr(response, "render"): # TemplateResponse return "== Context ==\n{}\n\n== Response ==\n{}".format( pformat(response.context_data), response.render().content) else: return response.content
# #Uncomment this to test issue #1: #from fuzziverse.user_admin import user_admin_site from django.contrib.admin import AdminSite user_admin_site = AdminSite() from nested_inline.admin import NestedStackedInline, NestedModelAdmin from fuzziverse import models class FileUploadInline(NestedStackedInline): model = models.InputTestCase min_num = 0 extra = 1 class ReportInline(NestedStackedInline): model = models.Report min_num = 0 extra = 1 class FuzzingAttemptInline(NestedStackedInline): model = models.FuzzingAttempt min_num = 0 extra = 1 inlines = [FileUploadInline] readonly_fields = ['created'] class ApplicationAdmin(NestedModelAdmin): inlines = [ReportInline, FuzzingAttemptInline] search_fields = ['name'] user_admin_site.register(models.Application, ApplicationAdmin)
def test_history_form_view_getting_history_abstract_external(self): request = RequestFactory().post("/") request.session = "session" request._messages = FallbackStorage(request) request.user = self.user request.POST = {"_change_history": True} obj = ConcreteExternal.objects.create(name="test") obj.name = "new_test" obj.save() history = obj.history.all()[0] admin_site = AdminSite() admin = SimpleHistoryAdmin(ConcreteExternal, admin_site) with patch("simple_history.admin.render") as mock_render: with patch("simple_history.admin.SIMPLE_HISTORY_EDIT", True): admin.history_form_view(request, obj.id, history.pk) context = { # Verify this is set for history object "original": history.instance, "change_history": True, "title": "Revert %s" % force_str(history.instance), "adminform": ANY, "object_id": obj.id, "is_popup": False, "media": ANY, "errors": ANY, "app_label": "tests", "original_opts": ANY, "changelist_url": "/admin/tests/concreteexternal/", "change_url": ANY, "history_url": "/admin/tests/concreteexternal/{pk}/history/".format(pk=obj.pk), "add": False, "change": True, "has_add_permission": admin.has_add_permission(request), "has_change_permission": admin.has_change_permission(request, obj), "has_delete_permission": admin.has_delete_permission(request, obj), "revert_disabled": admin.revert_disabled, "has_file_field": True, "has_absolute_url": False, "form_url": "", "opts": ANY, "content_type_id": ANY, "save_as": admin.save_as, "save_on_top": admin.save_on_top, "root_path": getattr(admin_site, "root_path", None), } context.update(admin_site.each_context(request)) mock_render.assert_called_once_with(request, admin.object_history_form_template, context)
def setUp(self) -> None: self.site = AdminSite() self.admin = admin.BankAccountAdmin(BankAccount, admin_site=self.site) self.rf = RequestFactory()
class PageAdmin(admin.ModelAdmin): inlines = [PageInline] class MenuAdmin(admin.ModelAdmin): inlines = [MenuInline] admin.site.register(Student, MyUserAdmin) admin.site.register(Course) admin.site.register(Group, GroupAdmin) admin.site.register(Enroll, EnrollAdmin) admin.site.register(Period) admin.site.register(Category) admin.site.register(MenuItem, MenuAdmin) admin.site.register(Page, PageAdmin) admin.site.site_header = _("Academica administrator site") admin_site = AdminSite(name='matricula_admin') admin_site.site_header = _("Academica administrator site") admin_site.register(Student, MyUserAdmin) admin_site.register(Course) admin_site.register(Group, GroupAdmin) admin_site.register(Enroll, EnrollAdmin) admin_site.register(Period) admin_site.register(Category) admin_site.register(MenuItem, MenuItemAdmin) admin_site.register(Page, PageAdmin)
from django.conf.urls.defaults import patterns, url, include from django.contrib.admin import AdminSite as DjangoAdminSite, ModelAdmin from .models import get_active_models, RegisteredModel urlpatterns = patterns("admin_customizer.views", url('^$', 'admin_index', name="admin_customizer-admin_index"), ) active_models, checksum = get_active_models() list_display_through = RegisteredModel._meta.get_field_by_name( "list_display")[0].rel.through._meta.db_table for slug, models in active_models.items(): admin_site = DjangoAdminSite(name=slug, app_name=slug) for registered_model in models: ct = registered_model.model DynamicModelAdmin = type( str("%(site_name)s_%(app_label)s_%(model_name)s_Admin" % dict( site_name = slug, app_label = ct.app_label, model_name = ct.model, )), (ModelAdmin,), dict( list_display = [ field.name for field in registered_model.list_display.extra( order_by = [list_display_through+'.id'] ) ], list_filter = [
from django.contrib.auth.models import User, Group from django.contrib.auth.admin import UserAdmin, GroupAdmin from django.contrib.admin import AdminSite root_site = AdminSite(name='root') root_site.register(User, UserAdmin) root_site.register(Group, GroupAdmin) tenant_site = AdminSite(name='tenant') tenant_site.register(User, UserAdmin) tenant_site.register(Group, GroupAdmin)
def setUp(self): super().setUp() self.site = AdminSite()
from django.contrib import admin from django.contrib.admin import AdminSite from django.contrib.auth.admin import UserAdmin from django.contrib.auth.models import User, Group, Permission from trancheur.models import Bond, MoneyMarket, Residual, Trade from cashflow.models import Cashflow class AdminSite(AdminSite): site_title = 'FlexInvest Admin' index_title = 'Home' branding = "admin/logo.png" admin_site = AdminSite() def deactivate_account(modeladmin, request, queryset): queryset.update(is_active=False) deactivate_account.short_description = "Deactivate selected users" def activate_account(modeladmin, request, queryset): queryset.update(is_active=True) activate_account.short_description = "Activate selected users" class UserAdmin(UserAdmin): list_display = ('username', 'is_active', 'last_login', 'date_joined',) list_filter = ('groups', 'is_active',) date_hierarchy = 'date_joined' actions = [deactivate_account, activate_account] admin_site.register(User, UserAdmin) admin_site.register(Permission)