def setUp(self):
"""
Перед выполнением тестов создается два обычных пользователя и бот,
создаются списки и покупки для пользователей
"""
# создание тестового обычного пользователя с токеном и клиентом
self.common_user = CustomUser.objects.create_user(
telegram_id=123456, password='******')
self.common_user_token = Token.generate_key(1)
Token.objects.create(user=self.common_user, key=self.common_user_token)
self.common_user_client = Client(HTTP_AUTHORIZATION='Token {}'.format(
self.common_user_token),
HTTP_ACCEPT_LANGUAGE='en-US')
# создание тестового обыного пользователя
self.another_common_user = CustomUser.objects.create_user(
telegram_id=666666, password='******')
self.not_authorized_client = Client(HTTP_ACCEPT_LANGUAGE='en-US')
# создание бота с токеном и клиентом
self.bot = CustomUser.objects.create_user(telegram_id=777777,
password='******',
is_bot=True)
self.bot_token = Token.generate_key(1)
Token.objects.create(user=self.bot, key=self.bot_token)
self.bot_client = Client(HTTP_AUTHORIZATION='Token {}'.format(
self.bot_token),
HTTP_ACCEPT_LANGUAGE='en-US')
# создание списков покупок
self.common_user_products = PurchasesList.objects.create(
author=self.common_user, title='products')
self.common_user_birthday = PurchasesList.objects.create(
author=self.common_user, title='birthday')
self.common_user_car = PurchasesList.objects.create(
author=self.common_user, title='car')
self.another_user_list = PurchasesList.objects.create(
author=self.another_common_user, title='some_list')
# создание покупок
self.cheese = Purchase.objects.create(
purchase_list=self.common_user_products, title='chesee')
self.milk = Purchase.objects.create(
purchase_list=self.common_user_products, title='milk')
self.bread = Purchase.objects.create(
purchase_list=self.common_user_products, title='bread')
self.cake = Purchase.objects.create(
purchase_list=self.common_user_birthday, title='cake')
self.another_purchase = Purchase.objects.create(
purchase_list=self.another_user_list, title='another_purchase')
def token_generate():
queryset = MyUser.objects.all()
Token.objects.filter(user__in=queryset).delete()
new_tokens = [
Token(user=u, key=Token.generate_key()) for u in queryset.iterator()
]
Token.objects.bulk_create(new_tokens)
def post(self, request, format=None):
serializer = LoginSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
token = Token.generate_key()
return Response({
'token': token,
})
def client(django_user_model):
""" create user to token and DRF client """
user = django_user_model.objects.create_user(
username='******', password='******')
token = Token.generate_key(user)
client = APIClient()
client.force_authenticate(user=user, token=token)
return client
def post(self, request, format=None):
serializer = RegisterSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
id = 4
token = Token.generate_key()
return Response({
'id': id,
'token': token,
})
def post(self, request, format=None):
data = JSONParser().parse(request)
username = data['username']
password = data['password']
from django.contrib.auth import authenticate
from rest_framework.authtoken.models import Token
user = authenticate(username=username, password=password)
if user is not None:
return HttpResponse(Token.generate_key(user))
else:
return HttpResponse("Invalid!")
def create_token(application, token='', valid_days=1000, scope='read write'):
expires = timezone.now() + timedelta(days=valid_days)
if not token or not isinstance(token, basestring):
token = Token.generate_key(Token(application.user.username))
return AccessToken.objects.create(user=application.user,
token=token,
application=application,
expires=expires,
scope=scope)
def post(self, request, *args, **kwargs):
serializer = RequestForRegistrationSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user_email = serializer.validated_data['email']
confirm_code = Token.generate_key(self.request)
UserConfirmCodeDb.objects.update_or_create(
email=user_email,
confirm_code=confirm_code,
)
send_mail(
'Registration on Yamdb',
f'Your access token: {confirm_code}.',
None,
[user_email]
)
return Response(f'Email was sent to {user_email}',
status=status.HTTP_200_OK)
def get_token(strategy, user, response, *args, **kwargs):
try:
token = Token.objects.get(user=user)
except Token.DoesNotExist:
log.info("Create auth token for social user %s", user)
token = Token(user=user)
token.key = token.generate_key()
token.save()
up = UserProfile.objects.create(login=user.username)
up.save()
user.is_superuser = True
user.save()
log.info("authorize social user %s", user)
login(strategy.request,
user,
backend='django.contrib.auth.backends.ModelBackend')
return render(strategy.request, 'token.html', {
'login': user.username,
'token': token.key
})
def test_generate_key_returns_string(self):
"""Ensure generate_key returns a string"""
token = Token()
key = token.generate_key()
self.assertTrue(isinstance(key, six.string_types))
class AdminDashboardViewsTestCase(TestCase):
def setUp(self):
self.client = APIClient()
self.option = mommy.make('main.Option')
self.items = mommy.make('main.Item', make_m2m=True, _quantity=50)
self.item = mommy.make('main.Item', make_m2m=True)
self.item_json = ItemSerializer(self.item).data
self.status = mommy.make('main.Status')
self.admin_user = mommy.make('main.ShopUser')
self.admin_user.is_staff = True
self.admin_user.save()
self.reg_user = mommy.make('main.ShopUser')
# Generate token for token auth based on the user in the requests
self.admin_token = Token()
self.admin_token.key = self.admin_token.generate_key()
self.admin_token.user_id = self.admin_user.id
self.admin_token.save()
self.reg_token = Token()
self.reg_token.key = self.reg_token.generate_key()
self.reg_token.user_id = self.reg_user.id
self.reg_token.save()
def test_admin_create_item_view(self):
Item.objects.get(id=self.item.id).delete()
self.client.force_authenticate(self.admin_user, self.admin_token)
request = self.client.post(reverse('create_item'), data=self.item_json, format='json')
item = Item.objects.get(pk=52)
self.assertEqual(request.status_code, 201)
self.assertEqual(item.name, self.item_json['name'])
self.assertEqual(item.description, self.item_json['description'])
self.assertEqual(item.weight, decimal.Decimal(self.item_json['weight']))
self.assertEqual(item.price, decimal.Decimal(self.item_json['price']))
self.assertEqual(item.options.count(), len(self.item_json['options']))
def test_admin_create_view_as_reg_user(self):
Item.objects.get(id=self.item.id).delete()
self.client.force_authenticate(self.reg_user, self.reg_token)
request = self.client.post(reverse('create_item'), data=self.item_json, format='json')
self.assertEqual(request.status_code, 403)
with self.assertRaises(ObjectDoesNotExist):
Item.objects.get(pk=52)
def test_admin_item_list(self):
self.client.force_authenticate(self.admin_user, self.admin_token)
request = self.client.get(reverse('create_item'))
data = json.loads(request.content)
self.assertEqual(request.status_code, 200)
self.assertEqual('count' in data, True)
self.assertEqual('next' in data, True)
self.assertEqual(len(data['results']), 25)
for result in data['results']:
self.assertEqual('id' in result, True)
self.assertEqual('name' in result, True)
self.assertEqual('description' in result, True)
self.assertEqual('weight' in result, True)
self.assertEqual('price' in result, True)
self.assertEqual('options' in result, True)
self.assertEqual('tags' in result, True)
def test_admin_item_list_as_reg_user(self):
self.client.force_authenticate(self.reg_user, self.reg_token)
request = self.client.get(reverse('create_item'))
self.assertEqual(request.status_code, 403)
def test_admin_option_list(self):
self.client.force_authenticate(self.admin_user, self.admin_token)
request = self.client.get(reverse('create_option'))
data = json.loads(request.content)
self.assertEqual(request.status_code, 200)
self.assertEqual(data['count'], 256)
self.assertEqual(data['results'][0]['name'], self.option.name)
def test_admin_option_list_as_reg_user(self):
self.client.force_authenticate(self.reg_user, self.reg_token)
request = self.client.get(reverse('create_option'))
self.assertEqual(request.status_code, 403)
def test_admin_option_detail(self):
self.client.force_authenticate(self.admin_user, self.admin_token)
request = self.client.get(reverse('option_detail_update', args=(1,)))
data = json.loads(request.content)
self.assertEqual(request.status_code, 200)
self.assertEqual(data['id'], self.option.id)
self.assertEqual(data['name'], self.option.name)
def test_admin_option_detail_as_reg_user(self):
self.client.force_authenticate(self.reg_user, self.reg_token)
request = self.client.get(reverse('option_detail_update', args=(1,)))
self.assertEqual(request.status_code, 403)
def test_admin_status_list(self):
self.client.force_authenticate(self.admin_user, self.admin_token)
request = self.client.get(reverse('create_status'))
data = json.loads(request.content)
self.assertEqual(request.status_code, 200)
self.assertEqual(data['count'], 1)
self.assertEqual(data['results'][0]['status'], self.status.status)
self.assertEqual(data['results'][0]['description'], self.status.description)
def test_admin_status_list_as_reg_user(self):
self.client.force_authenticate(self.reg_user, self.reg_token)
request = self.client.get(reverse('create_status'))
self.assertEqual(request.status_code, 403)
def test_admin_status_detail(self):
self.client.force_authenticate(self.admin_user, self.admin_token)
request = self.client.get(reverse('status_detail_update', args=(1,)))
data = json.loads(request.content)
self.assertEqual(request.status_code, 200)
self.assertEqual(data['status'], self.status.status)
self.assertEqual(data['id'], self.status.id)
self.assertEqual(data['description'], self.status.description)
def test_admin_status_detail_as_reg_user(self):
self.client.force_authenticate(self.reg_user, self.reg_token)
request = self.client.get(reverse('status_detail_update', args=(1,)))
self.assertEqual(request.status_code, 403)
def save(self, *args, **kwargs):
if not self.key:
self.key = Token.generate_key()
return super().save(*args, **kwargs)
