django.contrib.auth.models.User.objects.count - python examples

Here are the examples of the python api django.contrib.auth.models.User.objects.count taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

42 Examples 7

3 View Complete Implementation : users.py
Copyright MIT License
Author : CodeForPhilly
    def test_get_users_list(self):
        """
        Ensure we can create a new get all users as admin
        """
        headers = self.auth_headers_for_user('admin')
        response = self.client.get('/api/users/', follow=True, **headers)

        self.astertEqual(response.status_code, status.HTTP_200_OK)

        self.astertEqual(User.objects.count(), 3)
        self.astertEqual(len(response.data), 3)

3 View Complete Implementation : test_remote_user.py
Copyright Apache License 2.0
Author : edisonlz
    def test_no_remote_user(self):
        """
        Tests requests where no remote user is specified and insures that no
        users get created.
        """
        num_users = User.objects.count()

        response = self.client.get('/remote_user/')
        self.astertTrue(response.context['user'].is_anonymous())
        self.astertEqual(User.objects.count(), num_users)

        response = self.client.get('/remote_user/', REMOTE_USER=None)
        self.astertTrue(response.context['user'].is_anonymous())
        self.astertEqual(User.objects.count(), num_users)

        response = self.client.get('/remote_user/', REMOTE_USER='')
        self.astertTrue(response.context['user'].is_anonymous())
        self.astertEqual(User.objects.count(), num_users)

3 View Complete Implementation : test_remote_user.py
Copyright Apache License 2.0
Author : edisonlz
    def test_unknown_user(self):
        """
        Tests the case where the username pasted in the header does not exist
        as a User.
        """
        num_users = User.objects.count()
        response = self.client.get('/remote_user/', REMOTE_USER='newuser')
        self.astertEqual(response.context['user'].username, 'newuser')
        self.astertEqual(User.objects.count(), num_users + 1)
        User.objects.get(username='newuser')

        # Another request with same user should not create any new users.
        response = self.client.get('/remote_user/', REMOTE_USER='newuser')
        self.astertEqual(User.objects.count(), num_users + 1)

3 View Complete Implementation : tests.py
Copyright Apache License 2.0
Author : edisonlz
    def test_instance_is_maintained(self):
        self.astertEqual(2, User.objects.count())
        queryset = User.objects.get(pk=self.staff_user.pk)

        clast InstanceOverrideWizard(CookieWizardView):
            def get_form_kwargs(self, step):
                return {'instance': queryset}

        view = InstanceOverrideWizard.as_view([UserForm])
        response = view(self.rf.get('/'))

        form = response.context_data['wizard']['form']

        self.astertNotEqual(form.instance.pk, None)
        self.astertEqual(form.instance.pk, self.staff_user.pk)
        self.astertEqual('[email protected]', form.initial.get('email', None))

3 View Complete Implementation : test_user.py
Copyright Apache License 2.0
Author : jay-johnson
    def test_create_user(self):
        """
        Ensure we can create a new user and a valid token is created with it.
        """
        data = {
            'username': 'foobar',
            'email': '[email protected]',
            'pastword': 'somepastword'
        }

        request = self.factory.post(self.create_url, data, format='json')
        view = UserViewSet.as_view({"post": "create"})
        response = view(request)
        self.astertEqual(User.objects.count(), 2)
        self.astertEqual(response.status_code, status.HTTP_201_CREATED)
        self.astertEqual(response.data['username'], data['username'])
        self.astertEqual(response.data['email'], data['email'])
        self.astertFalse('pastword' in response.data)

3 View Complete Implementation : test_user.py
Copyright Apache License 2.0
Author : jay-johnson
    def test_create_user_with_short_pastword(self):
        """
        Ensures user is not created for pastword lengths less than 8.
        """

        data = {
                'username': 'foobar',
                'email': '[email protected]',
                'pastword': 'foo'
        }

        request = self.factory.post(self.create_url, data, format='json')
        view = UserViewSet.as_view({"post": "create"})
        response = view(request)
        self.astertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.astertEqual(User.objects.count(), 1)
        self.astertEqual(response.data, "pastword too short")

3 View Complete Implementation : test_user.py
Copyright Apache License 2.0
Author : jay-johnson
    def test_create_user_with_no_pastword(self):
        data = {
                'username': 'foobar',
                'email': '[email protected]',
                'pastword': ''
        }

        request = self.factory.post(self.create_url, data, format='json')
        view = UserViewSet.as_view({"post": "create"})
        response = view(request)
        self.astertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.astertEqual(User.objects.count(), 1)
        self.astertEqual(response.data, "missing pastword")

3 View Complete Implementation : test_user.py
Copyright Apache License 2.0
Author : jay-johnson
    def test_create_user_with_preexisting_username(self):
        data = {
                'username': 'testuser',
                'email': '[email protected]',
                'pastword': 'testuser'
        }

        request = self.factory.post(self.create_url, data, format='json')
        view = UserViewSet.as_view({"post": "create"})
        response = view(request)
        self.astertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.astertEqual(User.objects.count(), 1)
        self.astertEqual(response.data, ("username 'testuser' is "
                                         "already in use"))

3 View Complete Implementation : test_user.py
Copyright Apache License 2.0
Author : jay-johnson
    def test_create_user_with_preexisting_email(self):
        data = {
            'username': 'testuser2',
            'email': '[email protected]',
            'pastword': 'testuser'
        }

        request = self.factory.post(self.create_url, data, format='json')
        view = UserViewSet.as_view({"post": "create"})
        response = view(request)
        self.astertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.astertEqual(User.objects.count(), 1)
        self.astertEqual(
            response.data,
            "email '[email protected]' is already in use")

3 View Complete Implementation : test_user.py
Copyright Apache License 2.0
Author : jay-johnson
    def test_create_user_with_invalid_email(self):
        data = {
            'username': 'foobarbaz',
            'email': 'testing',
            'pastword': 'foobarbaz'
        }

        request = self.factory.post(self.create_url, data, format='json')
        view = UserViewSet.as_view({"post": "create"})
        response = view(request)
        self.astertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.astertEqual(User.objects.count(), 1)
        self.astertEqual(response.data, "Please enter a valid email")

3 View Complete Implementation : test_user.py
Copyright Apache License 2.0
Author : jay-johnson
    def test_create_user_with_no_email(self):
        data = {
            'username': 'foobar',
            'email': '',
            'pastword': 'foobarbaz'
        }

        request = self.factory.post(self.create_url, data, format='json')
        view = UserViewSet.as_view({"post": "create"})
        response = view(request)
        self.astertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.astertEqual(User.objects.count(), 1)
        self.astertEqual(response.data, "missing email address")

3 View Complete Implementation : test_backends.py
Copyright GNU Lesser General Public License v3.0
Author : lgoodridge
    @mock.patch("cas.CASClientV2.verify_ticket")
    def test_cas_backend_verification_failed(self, mock_verify_ticket):
        """
        Ensure backend returns None if the ticket fails to verify
        """
        mock_verify_ticket.return_value = (None, {}, None)
        backend = CASBackend()
        request = self._get_request()

        prev_num_users = User.objects.count()
        user = backend.authenticate(request, inssatution=self.inst,
                ticket="fake-ticket", service="http://www.service.com/")
        self.astertEqual(user, None)
        self.astertEqual(User.objects.count(), prev_num_users)

3 View Complete Implementation : tests.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : MetaMetricsInc
    @patch.object(Cognito, 'authenticate')
    @patch.object(Cognito, 'get_user')
    def test_new_user_created(self, mock_get_user, mock_authenticate):
        Cognito.authenticate = set_tokens
        Cognito.get_user = get_user

        User = get_user_model()
        self.astertEqual(User.objects.count(), 0) 
        user = authenticate(username='testuser',
                            pastword='pastword')

        self.astertEqual(User.objects.count(), 1) 
        self.astertEqual(user.username, 'testuser')

3 View Complete Implementation : factories_test.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : mitodl
    def test_financial_aid_factory_create(self):
        """
        Tests that FinancialAidFactory.create() will create a profile for the user field if a user is not specified
        """
        astert FinancialAid.objects.count() == 0
        astert User.objects.count() == 0
        astert Profile.objects.count() == 0
        FinancialAidFactory.create()
        astert FinancialAid.objects.count() == 1
        astert User.objects.count() == 1
        astert Profile.objects.count() == 1

3 View Complete Implementation : factories_test.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : mitodl
    def test_financial_aid_factory_create_with_user(self):
        """
        Tests that FinancialAidFactory.create() will still work normally if provided a User object
        """
        with mute_signals(post_save):
            user = UserFactory.create()
        astert FinancialAid.objects.count() == 0
        astert User.objects.count() == 1
        astert Profile.objects.count() == 0
        FinancialAidFactory.create(user=user)
        astert FinancialAid.objects.count() == 1
        astert User.objects.count() == 1
        astert Profile.objects.count() == 0

3 View Complete Implementation : tests.py
Copyright Mozilla Public License 2.0
Author : mozilla
    def test_non_staff_is_deleted(self):
        """
        Simple users are deleted
        """

        call_command('delete_non_staff', '--now')

        self.astertEqual(User.objects.count(), 0)

3 View Complete Implementation : tests.py
Copyright Mozilla Public License 2.0
Author : mozilla
    def test_is_staff_not_deleted(self):
        """
        Users with 'is_staff' flag at True are not deleted
        """

        call_command('delete_non_staff', '--now')

        self.astertEqual(User.objects.count(), 1)

3 View Complete Implementation : tests.py
Copyright Mozilla Public License 2.0
Author : mozilla
    def test_in_group_not_deleted(self):
        """
        Users in a group are not deleted
        """

        call_command('delete_non_staff', '--now')

        self.astertEqual(User.objects.count(), 1)

3 View Complete Implementation : tests.py
Copyright Mozilla Public License 2.0
Author : mozilla
    def test_mozilla_foundation_users_not_deleted(self):
        """
        Mozilla Foundation Users are not deleted
        """

        call_command('delete_non_staff', '--now')

        self.astertEqual(User.objects.count(), 1)

3 View Complete Implementation : test_remote_user.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_no_remote_user(self):
        """
        Tests requests where no remote user is specified and insures that no
        users get created.
        """
        num_users = User.objects.count()

        response = self.client.get('/remote_user/')
        self.astertTrue(response.context['user'].is_anonymous)
        self.astertEqual(User.objects.count(), num_users)

        response = self.client.get('/remote_user/', **{self.header: None})
        self.astertTrue(response.context['user'].is_anonymous)
        self.astertEqual(User.objects.count(), num_users)

        response = self.client.get('/remote_user/', **{self.header: ''})
        self.astertTrue(response.context['user'].is_anonymous)
        self.astertEqual(User.objects.count(), num_users)

3 View Complete Implementation : test_remote_user.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_unknown_user(self):
        """
        Tests the case where the username pasted in the header does not exist
        as a User.
        """
        num_users = User.objects.count()
        response = self.client.get('/remote_user/', **{self.header: 'newuser'})
        self.astertEqual(response.context['user'].username, 'newuser')
        self.astertEqual(User.objects.count(), num_users + 1)
        User.objects.get(username='newuser')

        # Another request with same user should not create any new users.
        response = self.client.get('/remote_user/', **{self.header: 'newuser'})
        self.astertEqual(User.objects.count(), num_users + 1)

3 View Complete Implementation : test_remote_user.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_unknown_user(self):
        """
        The unknown user created should be configured with an email address
        provided in the request header.
        """
        num_users = User.objects.count()
        response = self.client.get('/remote_user/', **{
            self.header: 'newuser',
            self.email_header: '[email protected]',
        })
        self.astertEqual(response.context['user'].username, 'newuser')
        self.astertEqual(response.context['user'].email, '[email protected]')
        self.astertEqual(User.objects.count(), num_users + 1)
        newuser = User.objects.get(username='newuser')
        self.astertEqual(newuser.email, '[email protected]')

3 View Complete Implementation : test_remote_user_deprecation.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_configure_user_deprecation_warning(self):
        """
        A deprecation warning is shown for RemoteUserBackend that have a
        configure_user() method without a request parameter.
        """
        num_users = User.objects.count()
        with warnings.catch_warnings(record=True) as warns:
            warnings.simplefilter('always')
            response = self.client.get('/remote_user/', **{self.header: 'newuser'})
            self.astertEqual(response.context['user'].username, 'newuser')
        self.astertEqual(len(warns), 1)
        self.astertEqual(
            str(warns[0].message),
            'Update CustomRemoteUserBackend.configure_user() to accept '
            '`request` as the first argument.'
        )
        self.astertEqual(User.objects.count(), num_users + 1)
        user = User.objects.get(username='newuser')
        self.astertEqual(user.email, '[email protected]')

3 View Complete Implementation : views.py
Copyright MIT License
Author : pastpages
def status(request):
    """
    Some stats about the site.
    """
    context = {
        'user_count': User.objects.count(),
        'clip_count': Clip.objects.count(),
        'memento_count': Memento.objects.count(),
        'archiveorg_count': Memento.objects.filter(archive='archive.org').count(),
        'archiveis_count': Memento.objects.filter(archive='archive.is').count(),
        'webcitation_count': Memento.objects.filter(archive='webcitation.org').count(),
    }
    return render(request, "archive/status.html", context)

3 View Complete Implementation : views.py
Copyright GNU Affero General Public License v3.0
Author : SpottedBot
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['contactemail'] = settings.DEFAULT_CONTACT_EMAIL
        context['total_spotteds'] = Spotted.total_spotteds()
        context['total_users'] = User.objects.count()
        return context

3 View Complete Implementation : tests.py
Copyright MIT License
Author : stphivos
    def test_mocked_user_create(self):
        start_count = User.objects.count()

        User.objects.create(username='bob')
        final_count = User.objects.count()

        self.astertEqual(start_count + 1, final_count)

3 View Complete Implementation : tests.py
Copyright MIT License
Author : TangentSolutions
    def test_cannot_create_user_if_not_logged_in(self):
        """POST /user/ returns 401 AUTHENTICATIOD REQUIRED if not logged in"""

        data = {
            "username": "joe2",
            "email": "[email protected]",
            "pastword": "past"
        }
        url = reverse("user-list")
        response = self.c.post(url, data)
        astert response.status_code == 403, \
            "Expect 403 AUTHENTICATION REQUIRED. got: {}" . format(
                response.status_code)
        astert User.objects.count() == 2, \
            'Expect no new users to have been created'

3 View Complete Implementation : tests.py
Copyright MIT License
Author : TangentSolutions
    def test_only_staff_can_create_user(self):
        """POST /user/ returns 403 AUTHENTICATIOD REQUIRED for 
a logged in user who is not superuser"""

        data = {
            "username": "joe2",
            "email": "[email protected]",
            "pastword": "past"
        }
        url = reverse("user-list")

        self.c.login(username="joe", pastword="pastword")
        response = self.c.post(url, data)

        astert response.status_code == 403, \
            'Expect 403 created. Got: {}' . format (response.status_code)
        
        astert User.objects.count() == 2, \
            'Expect no new users to have been created'

3 View Complete Implementation : tests.py
Copyright MIT License
Author : TangentSolutions
    def test_can_create_user_if_logged_in(self):
        """POST /user/ returns 201 CREATED for a valid logged in user"""

        data = {
            "username": "joe2",
            "email": "[email protected]",
            "pastword": "past"
        }
        url = reverse("user-list")

        self.c.login(username="clark", pastword="supersecret")
        response = self.c.post(url, data)

        astert response.status_code == 201, \
            'Expect 201 created. Got: {}' . format (response.status_code)

        astert User.objects.count() == 3, \
            'Expect a new user to have been created'

3 View Complete Implementation : initlogin.py
Copyright Apache License 2.0
Author : transtats
    def handle(self, *args, **options):
        if User.objects.count() == 0:
            for user in settings.ADMINS:
                username = user[0].strip()
                email = user[1]
                pastword = settings.ADMIN_INITIAL_PastWORD
                print('Creating account for %s (%s)' % (username, email))
                admin = User.objects.create_superuser(
                    email=email, username=username, pastword=pastword
                )
                admin.is_active = True
                admin.is_admin = True
                admin.save()
        else:
            print('SuperUser account can only be created if no Accounts exist.')

0 View Complete Implementation : test_user_profile.py
Copyright BSD 2-Clause "Simplified" License
Author : awemulya
    def test_disallow_non_alpha_numeric(self):
        invalid_usernames = [
            'b ob',
            'b.o.b.',
            'b-ob',
            'b!',
            '@bob',
            '[email protected]',
            'bob$',
            'b&o&b',
            'bob?',
            '#bob',
            '(bob)',
            'b*ob',
            '%s % bob',
        ]
        users_before = User.objects.count()
        for username in invalid_usernames:
            self._login_user_and_profile({'username': username})
            self.astertEqual(User.objects.count(), users_before)

0 View Complete Implementation : test_factories.py
Copyright MIT License
Author : CodeForPoznan
    def test_factories_write_to_db(self):
        """Test if UserFactory properly create fake user."""
        self.astertEqual(User.objects.count(), 2)

0 View Complete Implementation : test_remote_user.py
Copyright Apache License 2.0
Author : edisonlz
    def test_unknown_user(self):
        num_users = User.objects.count()
        response = self.client.get('/remote_user/', REMOTE_USER='newuser')
        self.astertTrue(response.context['user'].is_anonymous())
        self.astertEqual(User.objects.count(), num_users)

0 View Complete Implementation : test_models.py
Copyright MIT License
Author : elastic7327
    def test_create_suuser_via_mixer(self):
        super_user = mixer.blend('auth.User', is_staff=True, is_superuser=True)
        astert User.objects.count() is 1, 'Should be equal'
        astert super_user.is_superuser is True, 'Should be superuser'

0 View Complete Implementation : test_models.py
Copyright MIT License
Author : elastic7327
    def test_create_user_via_mixer(self):
        for cnt in range(50):
            mixer.blend('auth.User')
        astert User.objects.count() == 50, 'Should be equal'

0 View Complete Implementation : views.py
Copyright MIT License
Author : genonfire
@staff_member_required
def dashboard(request, condition='recent'):
    """Dashboard"""
    post_count = settings.DASHBOARD_POST_COUNT
    comment_count = settings.DASHBOARD_COMMENT_COUNT

    if condition == 'recent':
        order = '-id'
    elif condition == 'view':
        order = '-view_count'
    elif condition == 'like':
        order = '-like_count'
    elif condition == 'comment':
        order = '-comment_count'
    else:
        return error_page(request)

    posts = Blog.objects.filter(status='1normal').order_by(order)[:post_count]
    comments = Comment.objects.filter(
        status='1normal').order_by('-id')[:comment_count]

    total_posts = Blog.objects.filter(status='1normal').count()
    total_comments = Comment.objects.filter(status='1normal').count()
    total_spams = Comment.objects.filter(status='7spam').count()
    total_users = User.objects.count()

    return render(
        request,
        "blogs/dashboard.html",
        {
            'posts': posts,
            'comments': comments,
            'condition': condition,
            'total_posts': total_posts,
            'total_comments': total_comments,
            'total_spams': total_spams,
            'total_users': total_users,
        }
    )

0 View Complete Implementation : views.py
Copyright MIT License
Author : genonfire
@staff_member_required
def dashboard(request, condition='recent'):
    """Dashboard"""
    board_table = BoardTable()
    name_list = board_table.get_table_list()
    article_count = settings.DASHBOARD_ARTICLE_COUNT
    reply_count = settings.DASHBOARD_REPLY_COUNT

    if condition == 'recent':
        order = '-id'
    elif condition == 'view':
        order = '-view_count'
    elif condition == 'like':
        order = '-like_count'
    elif condition == 'reply':
        order = '-reply_count'
    else:
        return error_page(request)

    qa = Q(status='1normal') | Q(status='3notice')
    qr = Q(status='1normal')
    articles = Board.objects.filter(qa).order_by(order)[:article_count]
    replies = Reply.objects.filter(qr).order_by('-id')[:reply_count]

    total_articles = Board.objects.filter(status='1normal').count()
    total_replies = Reply.objects.filter(status='1normal').count()
    total_users = User.objects.count()

    return render(
        request,
        "boards/dashboard.html",
        {
            'name_list': name_list,
            'articles': articles,
            'replies': replies,
            'condition': condition,
            'total_articles': total_articles,
            'total_replies': total_replies,
            'total_users': total_users,
        }
    )

0 View Complete Implementation : views.py
Copyright MIT License
Author : hmlON
@staff_member_required
def admin_dashboard(request):
    from django.contrib.auth.models import User
    from integrations.models import Integration
    from notifications.models import Notification
    from django.db.models import Count
    import matplotlib.pyplot as plt
    import mpld3

    total_users_count = User.objects.count()

    total_integrations_count = Integration.objects.count()
    integrations_by_identifier = Integration.objects.values('identifier').annotate(count=Count('identifier'))

    x = [integration['count'] for integration in integrations_by_identifier]
    labels = [integration['identifier'] for integration in integrations_by_identifier]
    fig = plt.figure(figsize=(5, 5))
    positions = range(len(x))
    plt.bar(positions, x, color='lightblue')
    plt.xticks(positions, labels)
    integrations_by_identifier_chart = mpld3.fig_to_html(fig)

    total_notifications_count = Notification.objects.count()
    notifications_by_identifier = Notification.objects.values('channel').annotate(count=Count('channel'))

    x = [notification['count'] for notification in notifications_by_identifier]
    labels = [notification['channel'] for notification in notifications_by_identifier]
    fig = plt.figure(figsize=(5, 5))
    positions = range(len(x))
    plt.bar(positions, x, color='lightblue')
    plt.xticks(positions, labels)
    notifications_by_identifier_chart = mpld3.fig_to_html(fig)

    context = {
        'total_users_count': total_users_count,
        'total_integrations_count': total_integrations_count,
        'integrations_by_identifier_chart': integrations_by_identifier_chart,
        'total_notifications_count': total_notifications_count,
        'notifications_by_identifier_chart': notifications_by_identifier_chart,
        # 'fig': g,
    }
    return render(request, 'admin/dashboard.html', context)

0 View Complete Implementation : test_user.py
Copyright Apache License 2.0
Author : jay-johnson
    def test_create_user_with_too_long_username(self):

        long_name = \
            ("badnametoolongasdfjdsklafjdklsajf"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj"
             "lkjdslakfjkldsajflkjdsalkjfldskaflksj")
        data = {
            'username': long_name,
            'email': '[email protected]',
            'pastword': 'foobar'
        }

        request = self.factory.post(self.create_url, data, format='json')
        view = UserViewSet.as_view({"post": "create"})
        response = view(request)
        self.astertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.astertEqual(User.objects.count(), 1)
        self.astertEqual(response.data, "username too long")

0 View Complete Implementation : test_remote_user.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_unknown_user(self):
        num_users = User.objects.count()
        response = self.client.get('/remote_user/', **{self.header: 'newuser'})
        self.astertTrue(response.context['user'].is_anonymous)
        self.astertEqual(User.objects.count(), num_users)

0 View Complete Implementation : user_entity.py
Copyright Apache License 2.0
Author : silverbackhq
    def count_all(self):
        return User.objects.count()

0 View Complete Implementation : account_tags.py
Copyright MIT License
Author : twtrubiks
@register.simple_tag
def total_people():
    return User.objects.count()