django.contrib.auth.models.AnonymousUser

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

176 Examples 7

Example 1

Project: django-affect Source File: utils_tests.py
    def test_query_args_exact_match(self):
        self.crit.query_args = {'foo': 'bar'}
        self.crit.save()
        request = RequestFactory().get('', {'foo': 'bar'})
        request.user = AnonymousUser()

        self.assertIs(
            meets_criteria(request, 'test_crit'), True)

Example 2

Project: djangosnippets.org Source File: tests.py
    def test_cab_tags(self):
        t = Template("""{% load cab_tags %}{% if snippet|is_bookmarked:user %}Y{% else %}N{% endif %}""")
        c = Context({'snippet': self.snippet1, 'user': self.user_a})
        rendered = t.render(c)

        self.assertEqual(rendered, 'Y')

        Bookmark.objects.filter(user=self.user_a,
                                snippet=self.snippet1).delete()

        rendered = t.render(c)
        self.assertEqual(rendered, 'N')

        c = Context({'snippet': self.snippet1, 'user': AnonymousUser()})
        rendered = t.render(c)
        self.assertEqual(rendered, 'N')

Example 3

Project: tri.table Source File: helpers.py
def verify_table_html(expected_html, query=None, find=None, links=None, **kwargs):
    """
    Verify that the table renders to the expected markup, modulo formatting
    """
    if find is None:
        find = dict(class_='listview')
        if not expected_html.strip():
            expected_html = "<table/>"

    request = RequestFactory().get("/", query)
    request.user = AnonymousUser()
    actual_html = render_table(request=request, links=links, **kwargs)

    prettified_actual = reindent(BeautifulSoup(actual_html).find(**find).prettify()).strip()
    prettified_expected = reindent(BeautifulSoup(expected_html).find(**find).prettify()).strip()

    assert prettified_expected == prettified_actual

Example 4

Project: write-it Source File: popit_writeit_relation_tests.py
    def test_post_has_to_be_the_owner_of_the_instance(self):
        '''Only the owner of an instance can resync'''
        url = reverse('resync-from-popit', subdomain=self.writeitinstance.slug, kwargs={
            'popit_api_pk': self.popit_api_instance.pk})
        request = self.request_factory.post(url)
        request.subdomain = self.writeitinstance.slug
        request.user = AnonymousUser()
        with self.assertRaises(Http404):
            ReSyncFromPopit.as_view()(request, popit_api_pk=self.popit_api_instance.pk)

        other_user = User.objects.create_user(username="other_user", password="s3cr3t0")

        request = self.request_factory.post(url)
        request.subdomain = self.writeitinstance.slug
        request.user = other_user
        with self.assertRaises(Http404):
            ReSyncFromPopit.as_view()(request, popit_api_pk=self.popit_api_instance.pk)

Example 5

Project: Wooey Source File: test_utils.py
Function: test_anonymous_users
    def test_anonymous_users(self):
        from .. import settings as wooey_settings
        from django.contrib.auth.models import AnonymousUser
        user = AnonymousUser()
        script_version = self.translate_script
        script = script_version.script
        d = utils.valid_user(script, user)
        self.assertTrue(d['valid'])
        wooey_settings.WOOEY_ALLOW_ANONYMOUS = False
        d = utils.valid_user(script, user)
        self.assertFalse(d['valid'])

Example 6

Project: betty-cropper Source File: middleware.py
Function: process_request
    def process_request(self, request):
        if "HTTP_X_BETTY_API_KEY" in request.META:
            api_key = request.META["HTTP_X_BETTY_API_KEY"]
            try:
                token = ApiToken.objects.get(public_token=api_key)
            except ApiToken.DoesNotExist:
                request.user = AnonymousUser()
            else:
                request.user = token.get_user()

Example 7

Project: storybase Source File: storybase_featured.py
@register.simple_tag(takes_context=True)
def featured_items(context, count=4, img_width=335, objects=None):
    if objects is None:
        stories = Story.objects.on_homepage().order_by('-created')
        news = NewsItem.objects.on_homepage().order_by('-created')
        projects = Project.objects.on_homepage().order_by('-created')
        objects = chain(stories, news, projects)
    if 'user' in context:
        user = context['user']
    else:
        user = AnonymousUser()
    normalized = [obj.normalize_for_view(img_width) for obj in objects
                  if obj.has_perm(user, 'view')]
    template = get_template('storybase/featured_object.html')
    context = Context({
        'objects': normalized,
    })
    return template.render(context)

Example 8

Project: Django--an-app-at-a-time Source File: context_processors.py
Function: auth
def auth(request):
    """
    Returns context variables required by apps that use Django's authentication
    system.

    If there is no 'user' attribute in the request, uses AnonymousUser (from
    django.contrib.auth).
    """
    if hasattr(request, 'user'):
        user = request.user
    else:
        from django.contrib.auth.models import AnonymousUser
        user = AnonymousUser()

    return {
        'user': user,
        'perms': PermWrapper(user),
    }

Example 9

Project: django-oscar Source File: utils.py
Function: request
    def request(self, user=None, basket=None, **request):
        request = super(RequestFactory, self).request(**request)
        request.user = user or AnonymousUser()
        request.session = SessionStore()
        request._messages = FallbackStorage(request)

        # Mimic basket middleware
        request.strategy = self.selector.strategy(
            request=request, user=request.user)
        request.basket = basket or self.Basket()
        request.basket.strategy = request.strategy
        request.basket_hash = Signer().sign(basket.pk) if basket else None
        request.cookies_to_delete = []

        return request

Example 10

Project: shuup Source File: test_contacts.py
@pytest.mark.django_db
def test_anonymity(admin_user, regular_user):
    assert not get_person_contact(admin_user).is_anonymous
    assert not get_person_contact(regular_user).is_anonymous
    assert get_person_contact(None).is_anonymous
    assert get_person_contact(AnonymousUser()).is_anonymous
    assert AnonymousContact().is_anonymous

Example 11

Project: django-calendartools Source File: test_defaults.py
    def test_permission_check(self):
        assert not change_event_permission_check(self.mock_request)
        perm = Permission.objects.get(codename='change_event')

        self.user.user_permissions.add(perm)
        # reloading user to purge the _perm_cache
        self.mock_request.user = User.objects.get(pk=self.user.pk)
        assert change_event_permission_check(self.mock_request)

        self.mock_request.user = AnonymousUser()
        assert not change_event_permission_check(self.mock_request)

        self.mock_request.user = User.objects.create(
            username='Super', is_superuser=True
        )
        assert add_occurrence_permission_check(self.mock_request)

Example 12

Project: django-object-events Source File: tags_tests.py
    def test_tag(self):
        # create context mock
        request = RequestFactory().get('/')
        request.user = AnonymousUser()
        SessionMiddleware().process_request(request)
        request.session.save()
        context = RequestContext(request)

        # Returns empty dict if there is no authenticated user
        self.assertEqual(render_notifications(context), '\n')

        # Returns notifications.html
        request.user = UserFactory()
        ObjectEventFactory(user=request.user)
        self.assertTrue(render_notifications(context))

Example 13

Project: django-mailserver Source File: auth.py
Function: get_user
def get_user(request):
    from django.contrib.auth.models import AnonymousUser
    user = authenticate(request=request)
    if user is None:
        user = AnonymousUser()
        user.email, user.first_name = request['From']
    return user

Example 14

Project: google-app-engine-django Source File: middleware.py
  def __get__(self, request, obj_type=None):
    if not hasattr(request, '_cached_user'):
      user = users.get_current_user()
      if user:
        request._cached_user = User.get_djangouser_for_user(user)
      else:
        request._cached_user = AnonymousUser()
    return request._cached_user

Example 15

Project: reviewboard Source File: test_actions.py
    def test_should_render_with_anonymous(self):
        """Testing ShipItAction.should_render with authenticated user"""
        request = RequestFactory().request()
        request.user = AnonymousUser()

        self.assertFalse(self.action.should_render({'request': request}))

Example 16

Project: django-lazysignup Source File: tests.py
    def test_authenticated_user_class(self):
        # We should find that the class of request.user is that of
        # LAZSIGNUP_CUSTOM_USER
        request = HttpRequest()
        request.user = AnonymousUser()
        SessionMiddleware().process_request(request)
        lazy_view(request)
        self.assertEqual(get_user_model(), type(request.user))

Example 17

Project: django-organizations Source File: utils.py
def request_factory_login(factory, user=None):
    """Based on this gist: https://gist.github.com/964472"""
    #engine = import_module(settings.SESSION_ENGINE)
    request = factory.request()
    #request.session = engine.SessionStore()
    #request.session[SESSION_KEY] = user.id
    request.user = user or AnonymousUser()
    return request

Example 18

Project: cmsplugin-filer Source File: tests.py
    def test_select_files(self):
        folder = Folder.objects.create(name='test')
        obj1 = self.get_filer_object(filer_class=Image)
        obj1.folder = folder
        obj1.save()
        __, filepath = mkstemp()
        file_obj = DjangoFile(open(filepath, 'rb'), name='test_file')
        obj2 = self.get_filer_object(filer_class=File, file_obj=file_obj)
        obj2.folder = folder
        obj2.save()
        filer_folder_plugin = self._create_plugin(folder=folder)
        plugin = filer_folder_plugin.get_plugin_class_instance()
        files = plugin.get_folder_files(folder, AnonymousUser())
        self.assertEqual(files.count(), 1)
        imgs = plugin.get_folder_images(folder, AnonymousUser())
        self.assertEqual(imgs.count(), 1)
        self.assertFalse(imgs[0] == files[0])

Example 19

Project: wiggum Source File: test_middleware.py
    def test_not_jwt(self):
        request = RequestFactory().get("/middleware")
        # Set no session request
        anon = AnonymousUser()
        request.user = anon
        request.session = SessionStore()

        result = self.middleware.process_request(request)
        self.assertIsNone(result)
        self.assertEqual(anon, request.user)

Example 20

Project: django-leonardo Source File: views.py
    def logout(self):
        messages.success(self.request, _('Logout complete'))
        auth_logout(self.request)

        self.request.session.flush()
        if hasattr(self.request, 'user'):
            from django.contrib.auth.models import AnonymousUser
            self.request.user = AnonymousUser()

Example 21

Project: django-cached_authentication_middleware Source File: __init__.py
def get_cached_user(request):
    if not hasattr(request, '_cached_user'):
        try:
            key = CACHE_KEY % request.session[SESSION_KEY]
            user = cache.get(key)
        except KeyError:
            user = AnonymousUser()
        if user is None:
            user = get_user(request)
            if user_preprocessor:
                user = user_preprocessor(user, request)
            cache.set(key, user)
        request._cached_user = user
    return request._cached_user

Example 22

Project: django-star-ratings Source File: test_tempalte_tags_ratings.py
    def test_user_is_not_authenticated_with_rating_for_object___user_rating_is_none(self):
        item = mommy.make(Foo)

        request = RequestFactory().get('/')
        request.user = AnonymousUser()

        res = ratings({
            'request': request,
        }, item)

        self.assertIsNone(res['user_rating'])

Example 23

Project: Misago Source File: middleware.py
Function: process_request
    def process_request(self, request):
        if request.user.is_anonymous():
            request.user = AnonymousUser()
        elif not request.user.is_superuser:
            if get_request_ip_ban(request) or get_user_ban(request.user):
                logout(request)

Example 24

Project: cmsplugin-image-gallery Source File: cmsplugin_tests.py
    def setUp(self):
        # create context mock
        request = RequestFactory().get('/')
        request.user = AnonymousUser()
        SessionMiddleware().process_request(request)
        request.session.save()
        self.context = RequestContext(request)
        self.plugin = mixer.blend('image_gallery.GalleryPlugin')
        self.cmsplugin = CMSGalleryPlugin()

Example 25

Project: django-forms-builder Source File: tests.py
    def test_tag(self):
        """
        Test that the different formats for the ``render_built_form``
        tag all work.
        """
        form = Form.objects.create(title="Tags", status=STATUS_PUBLISHED)
        request = type(str(""), (), {"META": {}, "user": AnonymousUser()})()
        context = RequestContext(request, {"form": form})
        template = "{%% load forms_builder_tags %%}{%% render_built_form %s %%}"
        formats = ("form", "form=form", "id=form.id", "slug=form.slug")
        for format in formats:
            t = Template(template % format).render(context)
            self.assertTrue(form.get_absolute_url(), t)

Example 26

Project: django-djangui Source File: test_utils.py
Function: test_anonymous_users
    def test_anonymous_users(self):
        from .. import settings as djangui_settings
        from django.contrib.auth.models import AnonymousUser
        user = AnonymousUser()
        script = factories.TranslateScriptFactory()
        d = utils.valid_user(script, user)
        self.assertTrue(d['valid'])
        djangui_settings.DJANGUI_ALLOW_ANONYMOUS = False
        d = utils.valid_user(script, user)
        self.assertFalse(d['valid'])

Example 27

Project: django-braces Source File: helpers.py
Function: build_request
    def build_request(self, method='GET', path='/test/', user=None, **kwargs):
        """
        Creates a request using request factory.
        """
        fn = getattr(self.factory, method.lower())
        if user is None:
            user = AnonymousUser()

        req = fn(path, **kwargs)
        req.user = user
        return req

Example 28

Project: django-invitations Source File: tests.py
    @override_settings(
        INVITATIONS_ALLOW_JSON_INVITES=True
    )
    def test_anonymous_get(self):
        request = RequestFactory().get(
            reverse('invitations:send-json-invite'),
            content_type='application/json')
        request.user = AnonymousUser()
        response = SendJSONInvite.as_view()(request)

        self.assertEqual(response.status_code, 302)

Example 29

Project: django-nonrel Source File: templatetags.py
    def test_get_flatpages_with_prefix_for_anon_user(self):
        "The flatpage template tag retrives unregistered prefixed flatpages for an anonymous user"
        out = Template(
                "{% load flatpages %}"
                "{% get_flatpages '/location/' for anonuser as location_flatpages %}"
                "{% for page in location_flatpages %}"
                "{{ page.title }},"
                "{% endfor %}"
            ).render(Context({
                'anonuser': AnonymousUser()
            }))
        self.assertEqual(out, "A Nested Flatpage,")

Example 30

Project: Resmin Source File: test_stories.py
    def setUp(self):
        self.u1 = UserFactory()
        self.u2 = UserFactory()
        self.u3 = UserFactory()
        self.au = AnonymousUser()

        self.qm = QuestionMetaFactory(owner=self.u1)

        """ Draft story. """
        self.ds = StoryFactory(
            owner=self.u1, status=Story.DRAFT, question_meta=self.qm)

        """ Published story. """
        self.ps = StoryFactory(
            owner=self.u1, status=Story.PUBLISHED, question_meta=self.qm)

        """ User 3 blocks User 1."""
        UserFollowFactory(
            status=UserFollow.BLOCKED, follower=self.u1, target=self.u1)

Example 31

Project: iCQA Source File: context.py
def auth_processor(request):
    if hasattr(request, 'user'):
        user = request.user
        if user.is_authenticated():
            messages = user.message_set.all()
        else:
            messages = None
    else:
        from django.contrib.auth.models import AnonymousUser
        user = AnonymousUser()
        messages = None

    from django.core.context_processors import PermWrapper
    return {
        'user': user,
        'messages': messages,
        'perms': PermWrapper(user),
    }

Example 32

Project: hubplus Source File: models.py
    def __init__(self, request=None):
        self.user = AnonymousUser()
        self.timezone = settings.TIME_ZONE
        if request is not None:
            self.language = get_language_from_request(request)
        else:
            self.language = settings.LANGUAGE_CODE

Example 33

Project: hue Source File: __init__.py
def get_user(request):
    """
    Returns the user model instance associated with the given request session.
    If no user is retrieved an instance of `AnonymousUser` is returned.
    """
    from .models import AnonymousUser
    try:
        user_id = request.session[SESSION_KEY]
        backend_path = request.session[BACKEND_SESSION_KEY]
        assert backend_path in settings.AUTHENTICATION_BACKENDS
        backend = load_backend(backend_path)
        user = backend.get_user(user_id) or AnonymousUser()
    except (KeyError, AssertionError):
        user = AnonymousUser()
    return user

Example 34

Project: dirigible-spreadsheet Source File: test_views.py
    def test_view_login_required(self):
        request = HttpRequest()
        request.user = AnonymousUser()
        request.META['SERVER_NAME'] = 'servername'
        request.META['SERVER_PORT'] = '80'
        actual = user_dashboard(request)

        self.assertTrue(isinstance(actual, HttpResponseRedirect))

        redirect_url = urlparse(actual['Location'])
        self.assertEquals(redirect_url.path, settings.LOGIN_URL)

Example 35

Project: django-db-tools Source File: middleware.py
Function: process_request
    def process_request(self, request):
        anon_mode =  os.environ.get('READ_ONLY_MODE', False)
        get_mode =  os.environ.get('GET_ONLY_MODE', False)

        if anon_mode:
            request.user = AnonymousUser()
        if get_mode:
            request.method = 'GET'        

Example 36

Project: django-permissionsx Source File: tests.py
    def test_template_tag_permissions_for_user_attrs_no_request(self):
        from django.contrib.auth.models import AnonymousUser
        self.user.username = 'user_username'
        context = {'user': AnonymousUser()}
        self.assertFalse(
            permissions(
                context,
                'permissionsx.tests.permissions.UserAttributesDependentPermissions'
            )
        )

Example 37

Project: mock-django Source File: http.py
Function: init
    def __init__(self, *args, **kwargs):
        super(WsgiHttpRequest, self).__init__(*args, **kwargs)
        self.user = AnonymousUser()
        self.session = {}
        self.META = {}
        self.GET = {}
        self.POST = {}

Example 38

Project: orchestra Source File: test_project_api.py
    def test_permissions(self):
        self.api_client.force_authenticate(user=AnonymousUser())

        response = self.api_client.post(
            '/orchestra/api/project/project_information/',
            {'project_id': 1},
            format='json')
        self.assertEquals(response.status_code, 403)
        returned = load_encoded_json(response.content)
        self.assertEquals(
            returned,
            {'detail': 'You do not have permission to perform this action.'})

Example 39

Project: django-lfc Source File: __init__.py
def get_user_from_session_key(session_key):
    """Returns the user from the passed session_key.

    This is a workaround for jquery.upload, which is used to mass upload images
    and files.
    """
    try:
        session_engine = __import__(settings.SESSION_ENGINE, {}, {}, [''])
        session_wrapper = session_engine.SessionStore(session_key)
        user_id = session_wrapper.get(SESSION_KEY)
        auth_backend = load_backend(session_wrapper.get(BACKEND_SESSION_KEY))
        if user_id and auth_backend:
            return auth_backend.get_user(user_id)
        else:
            return AnonymousUser()
    except AttributeError:
        return AnonymousUser()

Example 40

Project: transifex Source File: models.py
Function: for_user
    def for_user(self, user):
        """
        Filter available projects based on the user doing the query. This
        checks permissions and filters out private projects that the user
        doesn't have access to.
        """
        projects = self
        if user in [None, AnonymousUser()]:
            projects = projects.filter(private=False)
        else:
            if not user.is_superuser:
                Team = get_model('teams', 'Team')
                projects = projects.exclude(
                    Q(private=True) & ~(Q(maintainers__in=[user]) |
                    Q(team__in=Team.objects.for_user(user)))).distinct()
        return projects

Example 41

Project: channels Source File: base.py
    @classmethod
    def trigger_inbound(cls, message, **kwargs):
        """
        Triggers the binding to see if it will do something.
        Also acts as a consumer.
        """
        # Late import as it touches models
        from django.contrib.auth.models import AnonymousUser
        self = cls()
        self.message = message
        # Deserialize message
        self.action, self.pk, self.data = self.deserialize(self.message)
        self.user = getattr(self.message, "user", AnonymousUser())
        # Run incoming action
        self.run_action(self.action, self.pk, self.data)

Example 42

Project: django-user-accounts Source File: models.py
    def __init__(self, request=None):
        self.user = AnonymousUser()
        self.timezone = settings.TIME_ZONE
        if request is None:
            self.language = settings.LANGUAGE_CODE
        else:
            self.language = translation.get_language_from_request(request, check_path=True)

Example 43

Project: django-fluent-contents Source File: utils.py
def get_dummy_request(language=None):
    """
    Returns a Request instance populated with cms specific attributes.
    """
    if settings.ALLOWED_HOSTS and settings.ALLOWED_HOSTS != "*":
        host = settings.ALLOWED_HOSTS[0]
    else:
        host = Site.objects.get_current().domain

    request = RequestFactory().get("/", HTTP_HOST=host)
    request.session = {}
    request.LANGUAGE_CODE = language or settings.LANGUAGE_CODE
    # Needed for plugin rendering.
    request.current_page = None
    request.user = AnonymousUser()
    return request

Example 44

Project: Django-facebook Source File: tests.py
    def test_gender_matching(self):
        request = RequestMock().get('/')
        request.session = {}
        request.user = AnonymousUser()
        graph = get_persistent_graph(request, access_token='paul')
        converter = FacebookUserConverter(graph)
        base_data = converter.facebook_profile_data()
        self.assertEqual(base_data['gender'], 'male')
        data = converter.facebook_registration_data()
        self.assertEqual(data['gender'], 'm')
        action, user = connect_user(self.request, facebook_graph=graph)
        profile = try_get_profile(user)
        gender = get_user_attribute(user, profile, 'gender')
        self.assertEqual(gender, 'm')

Example 45

Project: shuup Source File: test_contacts.py
@pytest.mark.django_db
def test_omniscience(admin_user, regular_user):
    assert get_person_contact(admin_user).is_all_seeing
    assert not get_person_contact(regular_user).is_all_seeing
    assert not get_person_contact(None).is_all_seeing
    assert not get_person_contact(AnonymousUser()).is_all_seeing
    assert not AnonymousContact().is_all_seeing

Example 46

Project: talk.org Source File: context_processors.py
Function: auth
def auth(request):
    """
    Returns context variables required by apps that use Django's authentication
    system.

    If there is no 'user' attribute in the request, uses AnonymousUser (from
    django.contrib.auth).
    """
    if hasattr(request, 'user'):
        user = request.user
    else:
        from django.contrib.auth.models import AnonymousUser
        user = AnonymousUser()
    return {
        'user': user,
        'messages': user.get_and_delete_messages(),
        'perms': PermWrapper(user),
    }

Example 47

Project: PyClassLessons Source File: test_basic.py
Function: test_anonymous_user
    def test_anonymous_user(self):
        "Check the properties of the anonymous user"
        a = AnonymousUser()
        self.assertEqual(a.pk, None)
        self.assertFalse(a.is_authenticated())
        self.assertFalse(a.is_staff)
        self.assertFalse(a.is_active)
        self.assertFalse(a.is_superuser)
        self.assertEqual(a.groups.all().count(), 0)
        self.assertEqual(a.user_permissions.all().count(), 0)

Example 48

Project: django-shop Source File: customer.py
    def _get_visiting_user(self, session_key):
        """
        Since the Customer has a 1:1 relation with the User object, look for an entity for a
        User object. As its ``username`` (which must be unique), use the given session key.
        """
        username = self.encode_session_key(session_key)
        try:
            user = get_user_model().objects.get(username=username)
        except get_user_model().DoesNotExist:
            user = AnonymousUser()
        return user

Example 49

Project: jaikuenginepatch Source File: middleware.py
    def __get__(self, request, obj_type=None):
        if not hasattr(request, '_cached_user'):
            from django.contrib.auth import get_user
            from django.contrib.auth.models import AnonymousUser, User
            from google.appengine.api import users
            if self._middleware_class is HybridAuthenticationMiddleware:
                request._cached_user = get_user(request)
            else:
                request._cached_user = AnonymousUser()
            if request._cached_user.is_anonymous():
                user = users.get_current_user()
                if user:
                    request._cached_user = User.get_djangouser_for_user(user)
        return request._cached_user

Example 50

Project: cadasta-platform Source File: test_views_default_organizations.py
    def test_get_without_user(self):
        response = self.request()
        assert response.status_code == 200
        assert response.content == self.render_content(
            user=AnonymousUser(),
            object_list=sorted(self.public_orgs, key=lambda p: p.slug))
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4