def test_annon_user_action():
with mock.patch('awx.main.signals.get_current_user') as u_mock:
u_mock.return_value = AnonymousUser()
inv = Inventory.objects.create(name='ainventory')
entry = inv.activitystream_set.filter(operation='create').first()
assert not entry.actor
def test_display_name_anonymous(self):
eq_(u'', display_name(AnonymousUser()))
def test_checkout_version():
checkout = Checkout(Mock(), AnonymousUser(), 'tracking_code')
storage = checkout.for_storage()
assert storage['version'] == Checkout.VERSION
def test_checkout_is_shipping_required():
cart = Mock(is_shipping_required=Mock(return_value=True))
checkout = Checkout(cart, AnonymousUser(), 'tracking_code')
assert checkout.is_shipping_required is True
def test_node_manager(self):
""" test manager methods of Node model """
# published()
Node.objects.published
count = Node.objects.published().filter(layer=1).count()
# no unplished nodes on that layer, so the count should be the same
self.assertEqual(count, Node.objects.filter(layer=1).count())
# unpublish the first
node = Node.objects.published().filter(layer=1)[0]
node.is_published = False
node.save()
# should be -1
self.assertEqual(count - 1,
Node.objects.published().filter(layer=1).count())
# Ensure GeoManager distance is available
pnt = Node.objects.get(slug='pomezia').geometry
Node.objects.filter(geometry__distance_lte=(pnt, 7000))
# access level manager
user = User.objects.get(pk=1, is_superuser=True)
# superuser can see all nodes
self.assertEqual(Node.objects.all().count(),
Node.objects.accessible_to(user).count())
# same but passing only user_id
user_1 = User.objects.get(pk=1)
self.assertEqual(Node.objects.all().count(),
Node.objects.accessible_to(user_1).count())
# simulate non authenticated user
self.assertEqual(8,
Node.objects.accessible_to(AnonymousUser()).count())
# public nodes
self.assertEqual(8, Node.objects.access_level_up_to('public').count())
# public and registered
self.assertEqual(9,
Node.objects.access_level_up_to('registered').count())
# public, registered and community
self.assertEqual(10,
Node.objects.access_level_up_to('community').count())
### --- START CHAINING! WOOOO --- ###
# 9 because we unpublished one
self.assertEqual(
9,
Node.objects.published().access_level_up_to('community').count())
self.assertEqual(
9,
Node.objects.access_level_up_to('community').published().count())
# user 1 is admin and can see all the nodes, published() is the same as writing filter(is_published=True)
count = Node.objects.all().filter(is_published=True).count()
self.assertEqual(
count,
Node.objects.published().accessible_to(user_1).count())
self.assertEqual(
count,
Node.objects.accessible_to(user_1).published().count())
# chain with geographic query
count = Node.objects.all().filter(is_published=True).filter(
layer_id=1).count()
self.assertEqual(
count,
Node.objects.filter(geometry__distance_lte=(
pnt, 70000)).accessible_to(user_1).published().count())
self.assertEqual(
count,
Node.objects.accessible_to(user_1).filter(
geometry__distance_lte=(pnt, 70000)).published().count())
self.assertEqual(
count,
Node.objects.accessible_to(user_1).published().filter(
geometry__distance_lte=(pnt, 70000)).count())
self.assertEqual(
count,
Node.objects.filter(geometry__distance_lte=(
pnt, 70000)).accessible_to(user_1).published().count())
# slice, first, last, find
self.assertEqual(Node.objects.last().__class__.__name__, 'Node')
self.assertEqual(Node.objects.last(), Node.objects.order_by('-id')[0])
self.assertEqual(Node.objects.first().__class__.__name__, 'Node')
self.assertEqual(Node.objects.first(), Node.objects.order_by('id')[0])
self.assertEqual(Node.objects.find(1), Node.objects.get(pk=1))
self.assertEqual(list(Node.objects.slice('name', 5)),
list(Node.objects.order_by('name')[0:5]))
self.assertEqual(list(Node.objects.slice('-name', 5)),
list(Node.objects.order_by('-name')[0:5]))
# chained
self.assertEqual(
Node.objects.published().first(),
Node.objects.filter(is_published=True).order_by('id')[0])
self.assertEqual(
Node.objects.published().last(),
Node.objects.filter(is_published=True).order_by('-id')[0])
self.assertEqual(
Node.objects.published().access_level_up_to('public').first(),
Node.objects.filter(is_published=True,
access_level__lte=0).order_by('id')[0])
self.assertEqual(
Node.objects.published().access_level_up_to('public').last(),
Node.objects.filter(is_published=True,
access_level__lte=0).order_by('-id')[0])
def test_checkout_discount(request_cart, sale, product_in_stock):
variant = product_in_stock.variants.get()
request_cart.add(variant, 1)
checkout = Checkout(request_cart, AnonymousUser(), 'tracking_code')
assert checkout.get_total() == Price(currency="USD", net=5)
def test_checkout_version_with_from_storage(storage_data, expected_storage):
checkout = Checkout.from_storage(storage_data, Mock(), AnonymousUser(),
'tracking_code')
storage = checkout.for_storage()
assert storage == expected_storage
def test_ajax_status_anon_user(self):
request = self.request_factory.get("dummy")
request.user = AnonymousUser()
self.assertRaises(PermissionDenied, ajax_status, request)
def test_anonymous(self):
req = RequestFactory().get('/')
req.user = AnonymousUser()
resp = views.AdminView.as_view()(req)
assert 'login' in resp.url
def test_ajax_enable_anon_user(self):
request = self.request_factory.post("dummy")
request.user = AnonymousUser()
self.assertRaises(PermissionDenied, ajax_enable, request)
self.assertNotPrefExists(self.user)
def test_ajax_disable_anon_user(self):
self.create_prefs()
request = self.request_factory.post("dummy")
request.user = AnonymousUser()
self.assertRaises(PermissionDenied, ajax_disable, request)
self.assertPrefValid(self.user)
def test_for_unregistered_user(self): # same path as for logged out user
self.assertEqual(
None, anonymous_id_for_user(AnonymousUser(), self.course.id))
self.assertIsNone(user_by_anonymous_id(None))
def test_user_somehow_not_authenticated(self):
EmailUserRestriction.objects.create(email_pattern='*****@*****.**')
request = RequestFactory().get('/')
request.user = AnonymousUser()
assert not EmailUserRestriction.allow_request(request)
def test_user_somehow_not_authenticated(self):
request = RequestFactory().get('/')
request.user = AnonymousUser()
assert not DisposableEmailDomainRestriction.allow_request(request)
def global_settings(request):
"""
Storing standard AMO-wide information used in global headers, such as
account links and settings.
"""
account_links = []
tools_links = []
context = {}
tools_title = ugettext('Tools')
is_reviewer = False
if request.user.is_authenticated():
user = request.user
profile = request.user
is_reviewer = (acl.check_addons_reviewer(request) or
acl.check_personas_reviewer(request))
account_links.append({'text': ugettext('My Profile'),
'href': profile.get_url_path()})
if user.is_artist:
account_links.append({'text': ugettext('My Themes'),
'href': profile.get_user_url('themes')})
account_links.append({'text': ugettext('Account Settings'),
'href': reverse('users.edit')})
account_links.append({
'text': ugettext('My Collections'),
'href': reverse('collections.user', args=[user.username])})
if user.favorite_addons:
account_links.append(
{'text': ugettext('My Favorites'),
'href': reverse('collections.detail',
args=[user.username, 'favorites'])})
account_links.append({
'text': ugettext('Log out'),
'href': reverse('users.logout') + '?to=' + urlquote(request.path),
})
if request.user.is_developer:
tools_links.append({'text': ugettext('Manage My Submissions'),
'href': reverse('devhub.addons')})
links = [
{'text': ugettext('Submit a New Add-on'),
'href': reverse('devhub.submit.agreement')},
{'text': ugettext('Submit a New Theme'),
'href': reverse('devhub.themes.submit')},
{'text': ugettext('Developer Hub'),
'href': reverse('devhub.index')},
]
links.append({'text': ugettext('Manage API Keys'),
'href': reverse('devhub.api_key')})
tools_links += links
if is_reviewer:
tools_links.append({'text': ugettext('Reviewer Tools'),
'href': reverse('editors.home')})
if (acl.action_allowed(request, amo.permissions.ADMIN) or
acl.action_allowed(request, amo.permissions.ADMIN_TOOLS_VIEW)):
tools_links.append({'text': ugettext('Admin Tools'),
'href': reverse('zadmin.index')})
context['user'] = request.user
else:
context['user'] = AnonymousUser()
context.update({'account_links': account_links,
'settings': settings,
'amo': amo,
'tools_links': tools_links,
'tools_title': tools_title,
'ADMIN_MESSAGE': get_config('site_notice'),
'is_reviewer': is_reviewer})
return context
def test_user_is_author_false_if_not_authenticated(self):
serializer = ContentSerializer(
context={"request": Mock(user=AnonymousUser())})
self.assertFalse(serializer.get_user_is_author(None))
return_value=Price(shipping_cost, currency=settings.DEFAULT_CURRENCY)))
monkeypatch.setattr(Checkout, 'shipping_method', shipping_method_mock)
checkout = Checkout(cart, AnonymousUser(), 'tracking_code')
deliveries = list(checkout.deliveries)
assert deliveries[0][1] == Price(shipping_cost,
currency=settings.DEFAULT_CURRENCY)
assert deliveries[0][2] == Price(items_cost + shipping_cost,
currency=settings.DEFAULT_CURRENCY)
assert deliveries[0][0][0][0] == partition
@pytest.mark.parametrize('user, shipping', [
(Mock(default_shipping_address='user_shipping'), 'user_shipping'),
(AnonymousUser(), None),
])
def test_checkout_shipping_address_with_anonymous_user(user, shipping):
checkout = Checkout(Mock(), user, 'tracking_code')
assert checkout._shipping_address is None
assert checkout.shipping_address == shipping
assert checkout._shipping_address == shipping
@pytest.mark.parametrize('address_objects, shipping', [
(Mock(get=Mock(return_value='shipping')), 'shipping'),
(Mock(get=Mock(side_effect=Address.DoesNotExist)), None),
])
def test_checkout_shipping_address_with_storage(address_objects, shipping,
monkeypatch):
monkeypatch.setattr('saleor.checkout.core.Address.objects',
def test_user_has_shared_false_if_anonymous_user(self):
serializer = ContentSerializer(
context={"request": Mock(user=AnonymousUser())})
self.assertFalse(serializer.get_user_has_shared(None))
def test_note_form(note_value):
checkout = Checkout(Mock(), AnonymousUser(), 'tracking_code')
form = NoteForm({'note': note_value}, checkout=checkout)
form.is_valid()
form.set_checkout_note()
assert checkout.note == note_value.strip()
def test_show_for_anon_when_require_auth_false(self):
request = self.factory.get('/')
request.user = AnonymousUser()
response = formList(request, username=self.user.username)
self.assertEqual(response.status_code, 200)
def test_checkout_clear_storage():
checkout = Checkout(Mock(), AnonymousUser(), 'tracking_code')
checkout.storage['new'] = 1
checkout.clear_storage()
assert checkout.storage is None
assert checkout.modified is True
def handle_no_permission(self):
from django.contrib.auth.models import AnonymousUser
if not self.request.user == AnonymousUser():
self.login_url = "bases:sin_privilegios"
return HttpResponseRedirect(reverse_lazy(self.login_url))
def setUp(self):
self.curr_auth = settings.AUTHENTICATION_BACKENDS
settings.AUTHENTICATION_BACKENDS = tuple(
self.curr_auth) + (self.backend, )
self.user1 = AnonymousUser()
def handle_no_permission(self):
from django.contrib.auth.models import AnonymousUser
if not self.request.user == AnonymousUser():
self.login_url = 'usuario:forbidden'
return HttpResponseRedirect(reverse_lazy(self.login_url))
def test_profile_avatar_anonymous(self):
email_hash = '00000000000000000000000000000000'
gravatar_url = 'https://secure.gravatar.com/avatar/%s?s=200' % (
email_hash)
assert profile_avatar(AnonymousUser()).startswith(gravatar_url)
def test_decorator_returns_not_found_for_unauthenticated_request(self):
request = self.factory.get('/bar/')
request.user = AnonymousUser()
with self.assertRaises(Http404):
dummy_spotify_auth_required_raise_exc_view(request)
return_value=shipping_price))
monkeypatch.setattr(Checkout, 'shipping_method', shipping_method_mock)
checkout = Checkout(cart, AnonymousUser(), 'tracking_code')
deliveries = list(checkout.deliveries)
assert deliveries[0][1] == shipping_price
assert deliveries[0][2] == TaxedMoney(net=cost_with_shipping,
gross=cost_with_shipping)
assert deliveries[0][0][0][0] == partition
@pytest.mark.parametrize(
'user, shipping',
[(Mock(default_shipping_address='user_shipping'), 'user_shipping'),
(AnonymousUser(), None)])
def test_checkout_shipping_address_with_anonymous_user(user, shipping):
checkout = Checkout(Mock(), user, 'tracking_code')
assert checkout._shipping_address is None
assert checkout.shipping_address == shipping
assert checkout._shipping_address == shipping
@pytest.mark.parametrize(
'address_objects, shipping',
[(Mock(get=Mock(return_value='shipping')), 'shipping'),
(Mock(get=Mock(side_effect=Address.DoesNotExist)), None)])
def test_checkout_shipping_address_with_storage(address_objects, shipping,
monkeypatch):
monkeypatch.setattr('saleor.checkout.core.Address.objects',
address_objects)
def test_guard(self):
request = self.factory.get('/get/create_rider/1')
request.user = AnonymousUser()
response = get_request_list(request, 1, "create_rider")
self.assertEqual(response.status_code, 401)
def test_checkout_discount(request_cart, sale, product_in_stock):
variant = product_in_stock.variants.get()
request_cart.add(variant, 1)
checkout = Checkout(request_cart, AnonymousUser(), 'tracking_code')
assert checkout.get_total() == TaxedMoney(net=Money(5, 'USD'),
gross=Money(5, 'USD'))
def setUp(self):
self.dummy_user = AnonymousUser()
DummyFolder().create_dummy_folder(id=1)
