From c516580a87adec68350bc5596240f49bb7d15cef Mon Sep 17 00:00:00 2001 From: Juan Madurga Date: Sun, 13 Mar 2016 10:39:19 +0100 Subject: [PATCH 1/7] REST API for Bot and EnvironmentVars --- .../migrations/0004_auto_20160311_1039.py | 32 ++ microbot/models/bot.py | 2 + microbot/serializers.py | 23 +- microbot/test/factories/__init__.py | 3 +- microbot/test/factories/bot.py | 7 +- microbot/test/factories/user.py | 15 + microbot/views.py | 131 +++++++- tests/test_microbot.py | 280 ++++++++++++++++-- tests/urls.py | 5 + 9 files changed, 472 insertions(+), 26 deletions(-) create mode 100644 microbot/migrations/0004_auto_20160311_1039.py create mode 100644 microbot/test/factories/user.py diff --git a/microbot/migrations/0004_auto_20160311_1039.py b/microbot/migrations/0004_auto_20160311_1039.py new file mode 100644 index 0000000..5c5eb39 --- /dev/null +++ b/microbot/migrations/0004_auto_20160311_1039.py @@ -0,0 +1,32 @@ +# -*- coding: utf-8 -*- +from __future__ import unicode_literals + +from django.db import migrations, models +from django.conf import settings + + +class Migration(migrations.Migration): + + dependencies = [ + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ('microbot', '0003_auto_20160310_0941'), + ] + + operations = [ + migrations.AddField( + model_name='bot', + name='owner', + field=models.ForeignKey(related_name='bots', default=None, to=settings.AUTH_USER_MODEL), + preserve_default=False, + ), + migrations.AlterField( + model_name='headerparam', + name='request', + field=models.ForeignKey(related_name='header_parameters', verbose_name='Request', to='microbot.Request'), + ), + migrations.AlterField( + model_name='urlparam', + name='request', + field=models.ForeignKey(related_name='url_parameters', verbose_name='Request', to='microbot.Request'), + ), + ] diff --git a/microbot/models/bot.py b/microbot/models/bot.py index 27ac617..efca34c 100644 --- a/microbot/models/bot.py +++ b/microbot/models/bot.py @@ -12,12 +12,14 @@ from django.core.urlresolvers import Resolver404 from telegram import ParseMode, ReplyKeyboardHide, ReplyKeyboardMarkup import ast +from django.conf import settings logger = logging.getLogger(__name__) @python_2_unicode_compatible class Bot(models.Model): + owner = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='bots') token = models.CharField(_('Token'), max_length=100, db_index=True) user_api = models.OneToOneField(User, verbose_name=_("Bot User"), related_name='bot', on_delete=models.CASCADE, blank=True, null=True) diff --git a/microbot/serializers.py b/microbot/serializers.py index ea0d1a4..fa81bea 100644 --- a/microbot/serializers.py +++ b/microbot/serializers.py @@ -1,8 +1,9 @@ from rest_framework import serializers -from microbot.models import User, Chat, Message, Update +from microbot.models import User, Chat, Message, Update, Bot, EnvironmentVar from datetime import datetime import time + class UserSerializer(serializers.HyperlinkedModelSerializer): id = serializers.IntegerField() @@ -63,4 +64,22 @@ def create(self, validated_data): update, _ = Update.objects.get_or_create(update_id=validated_data['update_id'], message=message) - return update \ No newline at end of file + return update + +class UserAPISerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = User + fields = ('first_name', 'last_name', 'username') + +class BotSerializer(serializers.ModelSerializer): + info = UserAPISerializer(many=False, source='user_api', read_only=True) + + class Meta: + model = Bot + fields = ('token', 'created', 'enabled', 'info') + read_only_fields = ('created', 'info') + +class EnvironmentVarSerializer(serializers.ModelSerializer): + class Meta: + model = EnvironmentVar + fields = ('key', 'value') \ No newline at end of file diff --git a/microbot/test/factories/__init__.py b/microbot/test/factories/__init__.py index 0f765d3..a17633b 100644 --- a/microbot/test/factories/__init__.py +++ b/microbot/test/factories/__init__.py @@ -1,4 +1,5 @@ +from microbot.test.factories.user import UserFactory # noqa from microbot.test.factories.bot import BotFactory # noqa from microbot.test.factories.telegram_lib import (UserLibFactory, ChatLibFactory, # noqa MessageLibFactory, UpdateLibFactory) # noqa -from microbot.test.factories.handler import HandlerFactory, RequestFactory, UrlParamFactory, HeaderParamFactory # noqa \ No newline at end of file +from microbot.test.factories.handler import HandlerFactory, RequestFactory, UrlParamFactory, HeaderParamFactory # noqa diff --git a/microbot/test/factories/bot.py b/microbot/test/factories/bot.py index 97680a6..2fbb115 100644 --- a/microbot/test/factories/bot.py +++ b/microbot/test/factories/bot.py @@ -1,9 +1,10 @@ # coding=utf-8 -from factory import DjangoModelFactory +from factory import DjangoModelFactory, SubFactory from microbot.models import Bot - +from microbot.test.factories import UserFactory class BotFactory(DjangoModelFactory): class Meta: model = Bot - token = "204840063:AAGKVVNf0HUTFoQKcgmLrvPv4tyP8xRCkFc" \ No newline at end of file + token = "204840063:AAGKVVNf0HUTFoQKcgmLrvPv4tyP8xRCkFc" + owner = SubFactory(UserFactory) \ No newline at end of file diff --git a/microbot/test/factories/user.py b/microbot/test/factories/user.py new file mode 100644 index 0000000..e9d8772 --- /dev/null +++ b/microbot/test/factories/user.py @@ -0,0 +1,15 @@ +# coding=utf-8 +from factory import DjangoModelFactory, Sequence, PostGenerationMethodCall +from django.conf import settings + +class UserFactory(DjangoModelFactory): + class Meta: + model = settings.AUTH_USER_MODEL + + email = Sequence(lambda n: 'user%d@test.com' % n) + username = Sequence(lambda n: 'user%d' % n) + password = PostGenerationMethodCall('set_password', 'adm1n') + + is_superuser = False + is_staff = False + is_active = True \ No newline at end of file diff --git a/microbot/views.py b/microbot/views.py index ca8efd1..7f03c75 100644 --- a/microbot/views.py +++ b/microbot/views.py @@ -1,6 +1,6 @@ from rest_framework.views import APIView -from microbot.serializers import UpdateSerializer -from microbot.models import Bot +from microbot.serializers import UpdateSerializer, BotSerializer, EnvironmentVarSerializer +from microbot.models import Bot, EnvironmentVar from rest_framework.response import Response from rest_framework import status from telegram import Update @@ -8,6 +8,10 @@ import sys import traceback from microbot.tasks import handle_update +from rest_framework.permissions import IsAuthenticated +from rest_framework.authentication import TokenAuthentication +from django.http.response import Http404 +from rest_framework import exceptions logger = logging.getLogger(__name__) @@ -32,4 +36,125 @@ def post(self, request, token): else: return Response(serializer.data, status=status.HTTP_200_OK) logger.error("Validation error: %s from message %s" % (serializer.errors, request.data)) - return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) \ No newline at end of file + return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) + +class BotList(APIView): + authentication_classes = (TokenAuthentication,) + permission_classes = (IsAuthenticated,) + + def get(self, request, format=None): + bots = Bot.objects.filter(owner=request.user) + serializer = BotSerializer(bots, many=True) + return Response(serializer.data) + + def post(self, request, format=None): + serializer = BotSerializer(data=request.data) + if serializer.is_valid(): + Bot.objects.create(owner=request.user, + token=serializer.data['token'], + enabled=serializer.data['enabled']) + return Response(serializer.data, status=status.HTTP_201_CREATED) + return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) + + +class BotDetail(APIView): + authentication_classes = (TokenAuthentication,) + permission_classes = (IsAuthenticated,) + + def get_object(self, pk, user): + try: + bot = Bot.objects.get(pk=pk) + if bot.owner != user: + raise exceptions.AuthenticationFailed() + return bot + except Bot.DoesNotExist: + raise Http404 + + def get(self, request, pk, format=None): + bot = self.get_object(pk, request.user) + serializer = BotSerializer(bot) + return Response(serializer.data) + + def put(self, request, pk, format=None): + bot = self.get_object(pk, request.user) + serializer = BotSerializer(bot, data=request.data) + if serializer.is_valid(): + serializer.save() + return Response(serializer.data) + return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) + + def delete(self, request, pk, format=None): + bot = self.get_object(pk, request.user) + bot.delete() + return Response(status=status.HTTP_204_NO_CONTENT) + +class EnvironmentVarList(APIView): + authentication_classes = (TokenAuthentication,) + permission_classes = (IsAuthenticated,) + + def get_object(self, pk, user): + try: + bot = Bot.objects.get(pk=pk) + if bot.owner != user: + raise exceptions.AuthenticationFailed() + return bot + except Bot.DoesNotExist: + raise Http404 + + def get(self, request, bot_pk, format=None): + bot = self.get_object(bot_pk, request.user) + serializer = EnvironmentVarSerializer(bot.env_vars.all(), many=True) + return Response(serializer.data) + + def post(self, request, bot_pk, format=None): + bot = self.get_object(bot_pk, request.user) + serializer = EnvironmentVarSerializer(data=request.data) + if serializer.is_valid(): + EnvironmentVar.objects.create(bot=bot, + key=serializer.data['key'], + value=serializer.data['value']) + return Response(serializer.data, status=status.HTTP_201_CREATED) + return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) + +class EnvironmentVarDetail(APIView): + authentication_classes = (TokenAuthentication,) + permission_classes = (IsAuthenticated,) + + def get_bot(self, pk, user): + try: + bot = Bot.objects.get(pk=pk) + if bot.owner != user: + raise exceptions.AuthenticationFailed() + return bot + except Bot.DoesNotExist: + raise Http404 + + def get_object(self, pk, bot, user): + try: + env_var = EnvironmentVar.objects.get(pk=pk, bot=bot) + if env_var.bot.owner != user: + raise exceptions.AuthenticationFailed() + return env_var + except EnvironmentVar.DoesNotExist: + raise Http404 + + def get(self, request, bot_pk, pk, format=None): + bot = self.get_bot(bot_pk, request.user) + env_var = self.get_object(pk, bot, request.user) + serializer = EnvironmentVarSerializer(env_var) + return Response(serializer.data) + + def put(self, request, bot_pk, pk, format=None): + bot = self.get_bot(bot_pk, request.user) + env_var = self.get_object(pk, bot, request.user) + serializer = EnvironmentVarSerializer(env_var, data=request.data) + if serializer.is_valid(): + serializer.save() + return Response(serializer.data) + return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) + + def delete(self, request, bot_pk, pk, format=None): + bot = self.get_bot(bot_pk, request.user) + env_var = self.get_object(pk, bot, request.user) + env_var.delete() + return Response(status=status.HTTP_204_NO_CONTENT) diff --git a/tests/test_microbot.py b/tests/test_microbot.py index 17ddea5..bfa88d3 100644 --- a/tests/test_microbot.py +++ b/tests/test_microbot.py @@ -9,6 +9,8 @@ from django.conf import settings from rest_framework.authtoken.models import Token from django.apps import apps +from rest_framework.test import APIRequestFactory, force_authenticate +from microbot.views import BotDetail, EnvironmentVarDetail try: from unittest import mock except ImportError: @@ -142,11 +144,11 @@ class TestRequests(LiveServerTestCase, testcases.BaseTestBot): } book_get_authorized = {'in': '/books', - 'out': {'parse_mode': 'HTML', - 'reply_markup': '', - 'text': 'ebook1' - } - } + 'out': {'parse_mode': 'HTML', + 'reply_markup': '', + 'text': 'ebook1' + } + } book_get_not_authorized = {'in': '/books', 'out': {'parse_mode': 'HTML', @@ -278,7 +280,9 @@ def test_header_parameters(self): self.assertEqual(Author.objects.count(), 0) def test_header_authentitcation(self): - user = ModelUser.objects.create_user(username='username',email='username@test.com',password='password') + user = ModelUser.objects.create_user(username='username', + email='username@test.com', + password='password') token = Token.objects.get(user=user) Book.objects.create(title="ebook1", owner=user) EnvironmentVar.objects.create(bot=self.bot, @@ -289,11 +293,13 @@ def test_header_authentitcation(self): self.header_param = factories.HeaderParamFactory(request=self.request, key='Authorization', value_template='Token {{env.token}}') - self.handler = factories.HandlerFactory(bot=self.bot, - pattern='/books', - request=self.request, - response_text_template='{% if response.list %}{% for book in response.list %}{{book.title}}{% endfor %}{% else %}not books{% endif %}', - response_keyboard_template='') + self.handler = factories.HandlerFactory( + bot=self.bot, + pattern='/books', + request=self.request, + response_text_template='''{% if response.list %}{% for book in response.list %}{{book.title}}{% endfor %} + {% else %}not books{% endif %}''', + response_keyboard_template='') self._test_message(self.book_get_authorized) def test_header_not_authenticated(self): @@ -302,9 +308,249 @@ def test_header_not_authenticated(self): self.header_param = factories.HeaderParamFactory(request=self.request, key='Authorization', value_template='Token erroneustoken') - self.handler = factories.HandlerFactory(bot=self.bot, - pattern='/books', - request=self.request, - response_text_template='{% if response.list %}{% for book in response.list %}{{book.title}}{% endfor %}{% else %}not books{% endif %}', - response_keyboard_template='') - self._test_message(self.book_get_not_authorized) \ No newline at end of file + self.handler = factories.HandlerFactory( + bot=self.bot, + pattern='/books', + request=self.request, + response_text_template='''{% if response.list %}{% for book in response.list %}{{book.title}}{% endfor %} + {% else %}not books{% endif %}''', + response_keyboard_template='') + self._test_message(self.book_get_not_authorized) + + +class BaseTestAPI(testcases.BaseTestBot): + + def _gen_token(self, token): + return 'Token %s' % str(token) + + def setUp(self): + super(BaseTestAPI, self).setUp() + self.api = '/microapi' + self.mytoken = '204840063:AAGKVVNf0HUTFoQKcgmLrvPv4tyP8xRCkFc' + self.mytoken2 = '190880460:AAELDdTxhhfPbtPRyC59qPaVF5VBX4VGVes' + +class TestBotAPI(BaseTestAPI): + + def test_get_bots_ok(self): + response = self.client.get(self.api + '/bots/', HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertEqual(self.bot.token, data[0]['token']) + self.assertEqual(self.bot.enabled, data[0]['enabled']) + self.assertEqual(self.bot.user_api.username, data[0]['info']['username']) + self.assertEqual(self.bot.user_api.first_name, data[0]['info']['first_name']) + self.assertEqual(self.bot.user_api.last_name, data[0]['info']['last_name']) + + def test_get_bots_not_auth(self): + response = self.client.get(self.api + '/bots/') + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_post_bots_ok(self): + Bot.objects.all().delete() + response = self.client.post(self.api + '/bots/', + data={'token': self.mytoken, 'enabled': 'True'}, + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + new_bot = Bot.objects.get(token=self.mytoken) + self.assertEqual(new_bot.token, self.mytoken) + self.assertTrue(new_bot.enabled) + + def test_post_bots_not_auth(self): + response = self.client.post(self.api + '/bots/', + data={'token': self.mytoken, 'enabled': 'True'}) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_bot_ok(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertEqual(self.bot.token, data['token']) + self.assertEqual(self.bot.enabled, data['enabled']) + self.assertEqual(self.bot.user_api.username, data['info']['username']) + self.assertEqual(self.bot.user_api.first_name, data['info']['first_name']) + self.assertEqual(self.bot.user_api.last_name, data['info']['last_name']) + + def test_get_bot_not_auth(self): + new_user = ModelUser.objects.create_user(username='username', + email='username@test.com', + password='password') + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_bot_not_found(self): + response = self.client.get(self.api + '/bots/12/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_put_bot_ok(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/', {'token': self.mytoken, 'enabled': 'False'}) + force_authenticate(request, user=self.bot.owner) + response = BotDetail.as_view()(request, self.bot.pk) + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertFalse(Bot.objects.get(pk=self.bot.pk).enabled) + + def test_put_bot_not_auth(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/', {'token': self.mytoken, 'enabled': 'False'}) + response = BotDetail.as_view()(request, self.bot.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_put_bot_not_found(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/12/', {'token': self.mytoken, 'enabled': 'False'}) + force_authenticate(request, user=self.bot.owner) + response = BotDetail.as_view()(request, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_delete_bot_ok(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/') + force_authenticate(request, user=self.bot.owner) + response = BotDetail.as_view()(request, self.bot.pk) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + self.assertEqual(Bot.objects.count(), 0) + + def test_delete_bot_not_auth(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/') + response = BotDetail.as_view()(request, self.bot.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_delete_bot_not_found(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/12/') + force_authenticate(request, user=self.bot.owner) + response = BotDetail.as_view()(request, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + +class TestEnvironmentVarAPI(BaseTestAPI): + + def setUp(self): + super(TestEnvironmentVarAPI, self).setUp() + self.key = "shop" + self.value = "myebookshop" + self.env_var = EnvironmentVar.objects.create(bot=self.bot, + key=self.key, + value=self.value) + + def test_get_env_vars_ok(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertEqual(self.env_var.key, data[0]['key']) + self.assertEqual(self.env_var.value, data[0]['value']) + + def test_get_env_vars_not_auth(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/') + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_post_env_vars_ok(self): + EnvironmentVar.objects.all().delete() + response = self.client.post(self.api + '/bots/' + str(self.bot.pk) + '/env/', + data={'key': self.key, 'value': self.value}, + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + new_env_var = EnvironmentVar.objects.filter(bot=self.bot)[0] + self.assertEqual(new_env_var.key, self.key) + self.assertTrue(new_env_var.value, self.value) + + def test_post_env_vars_not_auth(self): + response = self.client.post(self.api + '/bots/' + str(self.bot.pk) + '/env/', + data={'key': self.key, 'value': self.value}) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_env_var_ok(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertEqual(self.env_var.key, data['key']) + self.assertEqual(self.env_var.value, data['value']) + + def test_get_env_var_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + response = self.client.get(self.api + '/bots/' + str(new_bot.pk) + '/env/' + str(self.env_var.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_get_env_var_not_auth(self): + new_user = ModelUser.objects.create_user(username='username', + email='username@test.com', + password='password') + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_env_var_not_found(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/12/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_put_env_var_ok(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + {'key': self.key, 'value': 'new_value'}) + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(EnvironmentVar.objects.get(pk=self.env_var.pk).value, 'new_value') + + def test_put_env_var_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(new_bot.pk) + '/env/' + str(self.env_var.pk) + '/', + {'key': self.key, 'value': 'new_value'}) + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_put_env_var_not_auth(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + {'key': self.key, 'value': 'new_value'}) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_put_env_var_not_found(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/12/', + {'key': self.key, 'value': 'new_value'}) + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_delete_env_var_ok(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + self.assertEqual(EnvironmentVar.objects.count(), 0) + + def test_delete_env_var_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_delete_bot_not_auth(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_delete_bot_not_found(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/12/') + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) \ No newline at end of file diff --git a/tests/urls.py b/tests/urls.py index 722c831..ae07056 100644 --- a/tests/urls.py +++ b/tests/urls.py @@ -2,6 +2,7 @@ from django.conf.urls import include from rest_framework import routers from tests import views +from microbot import views as micro_views from rest_framework.authtoken import views as rdf_views router = routers.DefaultRouter() @@ -12,5 +13,9 @@ url(r'^api-token-auth/', rdf_views.obtain_auth_token), url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')), url(r'^api/', include(router.urls)), + url(r'^microapi/bots/$', micro_views.BotList.as_view()), + url(r'^microapi/bots/(?P[0-9]+)/$', micro_views.BotDetail.as_view()), + url(r'^microapi/bots/(?P[0-9]+)/env/$', micro_views.EnvironmentVarList.as_view()), + url(r'^microapi/bots/(?P[0-9]+)/env/(?P[0-9]+)/$', micro_views.EnvironmentVarDetail.as_view()), url(r'^microbot', include('microbot.urls', namespace="microbot")), ] \ No newline at end of file From 83c1c7c0c2df6a24400122390023547502822674 Mon Sep 17 00:00:00 2001 From: Juan Madurga Date: Sun, 13 Mar 2016 11:19:52 +0100 Subject: [PATCH 2/7] refactor API views --- microbot/views.py | 126 ++++++++++++++++++++++++---------------------- 1 file changed, 66 insertions(+), 60 deletions(-) diff --git a/microbot/views.py b/microbot/views.py index 7f03c75..4f212d6 100644 --- a/microbot/views.py +++ b/microbot/views.py @@ -38,10 +38,21 @@ def post(self, request, token): logger.error("Validation error: %s from message %s" % (serializer.errors, request.data)) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) -class BotList(APIView): +class MicrobotAPIView(APIView): authentication_classes = (TokenAuthentication,) permission_classes = (IsAuthenticated,) + def get_bot(self, pk, user): + try: + bot = Bot.objects.get(pk=pk) + if bot.owner != user: + raise exceptions.AuthenticationFailed() + return bot + except Bot.DoesNotExist: + raise Http404 + +class BotList(MicrobotAPIView): + def get(self, request, format=None): bots = Bot.objects.filter(owner=request.user) serializer = BotSerializer(bots, many=True) @@ -55,28 +66,16 @@ def post(self, request, format=None): enabled=serializer.data['enabled']) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) - - -class BotDetail(APIView): - authentication_classes = (TokenAuthentication,) - permission_classes = (IsAuthenticated,) - - def get_object(self, pk, user): - try: - bot = Bot.objects.get(pk=pk) - if bot.owner != user: - raise exceptions.AuthenticationFailed() - return bot - except Bot.DoesNotExist: - raise Http404 - + +class BotDetail(MicrobotAPIView): + def get(self, request, pk, format=None): - bot = self.get_object(pk, request.user) + bot = self.get_bot(pk, request.user) serializer = BotSerializer(bot) return Response(serializer.data) def put(self, request, pk, format=None): - bot = self.get_object(pk, request.user) + bot = self.get_bot(pk, request.user) serializer = BotSerializer(bot, data=request.data) if serializer.is_valid(): serializer.save() @@ -84,70 +83,58 @@ def put(self, request, pk, format=None): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) def delete(self, request, pk, format=None): - bot = self.get_object(pk, request.user) + bot = self.get_bot(pk, request.user) bot.delete() return Response(status=status.HTTP_204_NO_CONTENT) - -class EnvironmentVarList(APIView): - authentication_classes = (TokenAuthentication,) - permission_classes = (IsAuthenticated,) - def get_object(self, pk, user): - try: - bot = Bot.objects.get(pk=pk) - if bot.owner != user: - raise exceptions.AuthenticationFailed() - return bot - except Bot.DoesNotExist: - raise Http404 +class ListBotAPIView(MicrobotAPIView): + serializer = None + + def _query(self, bot): + raise NotImplemented + + def _creator(self, bot, serializer): + raise NotImplemented def get(self, request, bot_pk, format=None): - bot = self.get_object(bot_pk, request.user) - serializer = EnvironmentVarSerializer(bot.env_vars.all(), many=True) + bot = self.get_bot(bot_pk, request.user) + serializer = self.serializer(self._query(bot), many=True) return Response(serializer.data) def post(self, request, bot_pk, format=None): - bot = self.get_object(bot_pk, request.user) - serializer = EnvironmentVarSerializer(data=request.data) + bot = self.get_bot(bot_pk, request.user) + serializer = self.serializer(data=request.data) if serializer.is_valid(): - EnvironmentVar.objects.create(bot=bot, - key=serializer.data['key'], - value=serializer.data['value']) + self._creator(bot, serializer) return Response(serializer.data, status=status.HTTP_201_CREATED) - return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) + return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) -class EnvironmentVarDetail(APIView): - authentication_classes = (TokenAuthentication,) - permission_classes = (IsAuthenticated,) +class DetailBotAPIView(MicrobotAPIView): + model = None + serializer = None + + def _user(self, obj): + raise NotImplemented - def get_bot(self, pk, user): - try: - bot = Bot.objects.get(pk=pk) - if bot.owner != user: - raise exceptions.AuthenticationFailed() - return bot - except Bot.DoesNotExist: - raise Http404 - def get_object(self, pk, bot, user): try: - env_var = EnvironmentVar.objects.get(pk=pk, bot=bot) - if env_var.bot.owner != user: + obj = self.model.objects.get(pk=pk, bot=bot) + if self._user(obj) != user: raise exceptions.AuthenticationFailed() - return env_var + return obj except EnvironmentVar.DoesNotExist: raise Http404 def get(self, request, bot_pk, pk, format=None): bot = self.get_bot(bot_pk, request.user) - env_var = self.get_object(pk, bot, request.user) - serializer = EnvironmentVarSerializer(env_var) + obj = self.get_object(pk, bot, request.user) + serializer = self.serializer(obj) return Response(serializer.data) def put(self, request, bot_pk, pk, format=None): bot = self.get_bot(bot_pk, request.user) - env_var = self.get_object(pk, bot, request.user) - serializer = EnvironmentVarSerializer(env_var, data=request.data) + obj = self.get_object(pk, bot, request.user) + serializer = self.serializer(obj, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) @@ -155,6 +142,25 @@ def put(self, request, bot_pk, pk, format=None): def delete(self, request, bot_pk, pk, format=None): bot = self.get_bot(bot_pk, request.user) - env_var = self.get_object(pk, bot, request.user) - env_var.delete() + obj = self.get_object(pk, bot, request.user) + obj.delete() return Response(status=status.HTTP_204_NO_CONTENT) + + +class EnvironmentVarList(ListBotAPIView): + serializer = EnvironmentVarSerializer + + def _query(self, bot): + return bot.env_vars.all() + + def _creator(self, bot, serializer): + EnvironmentVar.objects.create(bot=bot, + key=serializer.data['key'], + value=serializer.data['value']) + +class EnvironmentVarDetail(DetailBotAPIView): + model = EnvironmentVar + serializer = EnvironmentVarSerializer + + def _user(self, obj): + return obj.bot.owner From 7cbfc7d3e856fee8dd00d28e86cb8e39adfb47b6 Mon Sep 17 00:00:00 2001 From: Juan Madurga Date: Sun, 13 Mar 2016 11:20:10 +0100 Subject: [PATCH 3/7] split tests --- tests/test_api.py | 248 +++++++++++++++++++++++++++++++++++++++++ tests/test_microbot.py | 242 +--------------------------------------- 2 files changed, 249 insertions(+), 241 deletions(-) create mode 100644 tests/test_api.py diff --git a/tests/test_api.py b/tests/test_api.py new file mode 100644 index 0000000..67a4774 --- /dev/null +++ b/tests/test_api.py @@ -0,0 +1,248 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +from microbot.models import Bot, EnvironmentVar +from microbot.test import testcases +from rest_framework import status +from rest_framework.test import APIRequestFactory, force_authenticate +from microbot.views import BotDetail, EnvironmentVarDetail +from django.conf import settings +from django.apps import apps + +ModelUser = apps.get_model(getattr(settings, 'AUTH_USER_MODEL', 'auth.User')) + +class BaseTestAPI(testcases.BaseTestBot): + + def _gen_token(self, token): + return 'Token %s' % str(token) + + def setUp(self): + super(BaseTestAPI, self).setUp() + self.api = '/microapi' + self.mytoken = '204840063:AAGKVVNf0HUTFoQKcgmLrvPv4tyP8xRCkFc' + self.mytoken2 = '190880460:AAELDdTxhhfPbtPRyC59qPaVF5VBX4VGVes' + +class TestBotAPI(BaseTestAPI): + + def test_get_bots_ok(self): + response = self.client.get(self.api + '/bots/', HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertEqual(self.bot.token, data[0]['token']) + self.assertEqual(self.bot.enabled, data[0]['enabled']) + self.assertEqual(self.bot.user_api.username, data[0]['info']['username']) + self.assertEqual(self.bot.user_api.first_name, data[0]['info']['first_name']) + self.assertEqual(self.bot.user_api.last_name, data[0]['info']['last_name']) + + def test_get_bots_not_auth(self): + response = self.client.get(self.api + '/bots/') + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_post_bots_ok(self): + Bot.objects.all().delete() + response = self.client.post(self.api + '/bots/', + data={'token': self.mytoken, 'enabled': 'True'}, + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + new_bot = Bot.objects.get(token=self.mytoken) + self.assertEqual(new_bot.token, self.mytoken) + self.assertTrue(new_bot.enabled) + + def test_post_bots_not_auth(self): + response = self.client.post(self.api + '/bots/', + data={'token': self.mytoken, 'enabled': 'True'}) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_bot_ok(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertEqual(self.bot.token, data['token']) + self.assertEqual(self.bot.enabled, data['enabled']) + self.assertEqual(self.bot.user_api.username, data['info']['username']) + self.assertEqual(self.bot.user_api.first_name, data['info']['first_name']) + self.assertEqual(self.bot.user_api.last_name, data['info']['last_name']) + + def test_get_bot_not_auth(self): + new_user = ModelUser.objects.create_user(username='username', + email='username@test.com', + password='password') + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_bot_not_found(self): + response = self.client.get(self.api + '/bots/12/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_put_bot_ok(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/', {'token': self.mytoken, 'enabled': 'False'}) + force_authenticate(request, user=self.bot.owner) + response = BotDetail.as_view()(request, self.bot.pk) + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertFalse(Bot.objects.get(pk=self.bot.pk).enabled) + + def test_put_bot_not_auth(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/', {'token': self.mytoken, 'enabled': 'False'}) + response = BotDetail.as_view()(request, self.bot.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_put_bot_not_found(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/12/', {'token': self.mytoken, 'enabled': 'False'}) + force_authenticate(request, user=self.bot.owner) + response = BotDetail.as_view()(request, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_delete_bot_ok(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/') + force_authenticate(request, user=self.bot.owner) + response = BotDetail.as_view()(request, self.bot.pk) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + self.assertEqual(Bot.objects.count(), 0) + + def test_delete_bot_not_auth(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/') + response = BotDetail.as_view()(request, self.bot.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_delete_bot_not_found(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/12/') + force_authenticate(request, user=self.bot.owner) + response = BotDetail.as_view()(request, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + +class TestEnvironmentVarAPI(BaseTestAPI): + + def setUp(self): + super(TestEnvironmentVarAPI, self).setUp() + self.key = "shop" + self.value = "myebookshop" + self.env_var = EnvironmentVar.objects.create(bot=self.bot, + key=self.key, + value=self.value) + + def test_get_env_vars_ok(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertEqual(self.env_var.key, data[0]['key']) + self.assertEqual(self.env_var.value, data[0]['value']) + + def test_get_env_vars_not_auth(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/') + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_post_env_vars_ok(self): + EnvironmentVar.objects.all().delete() + response = self.client.post(self.api + '/bots/' + str(self.bot.pk) + '/env/', + data={'key': self.key, 'value': self.value}, + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + new_env_var = EnvironmentVar.objects.filter(bot=self.bot)[0] + self.assertEqual(new_env_var.key, self.key) + self.assertTrue(new_env_var.value, self.value) + + def test_post_env_vars_not_auth(self): + response = self.client.post(self.api + '/bots/' + str(self.bot.pk) + '/env/', + data={'key': self.key, 'value': self.value}) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_env_var_ok(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertEqual(self.env_var.key, data['key']) + self.assertEqual(self.env_var.value, data['value']) + + def test_get_env_var_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + response = self.client.get(self.api + '/bots/' + str(new_bot.pk) + '/env/' + str(self.env_var.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_get_env_var_not_auth(self): + new_user = ModelUser.objects.create_user(username='username', + email='username@test.com', + password='password') + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_env_var_not_found(self): + response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/12/', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_put_env_var_ok(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + {'key': self.key, 'value': 'new_value'}) + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(EnvironmentVar.objects.get(pk=self.env_var.pk).value, 'new_value') + + def test_put_env_var_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(new_bot.pk) + '/env/' + str(self.env_var.pk) + '/', + {'key': self.key, 'value': 'new_value'}) + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_put_env_var_not_auth(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + {'key': self.key, 'value': 'new_value'}) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_put_env_var_not_found(self): + factory = APIRequestFactory() + request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/12/', + {'key': self.key, 'value': 'new_value'}) + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_delete_env_var_ok(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + self.assertEqual(EnvironmentVar.objects.count(), 0) + + def test_delete_env_var_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_delete_bot_not_auth(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_delete_bot_not_found(self): + factory = APIRequestFactory() + request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/12/') + force_authenticate(request, user=self.bot.owner) + response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) \ No newline at end of file diff --git a/tests/test_microbot.py b/tests/test_microbot.py index bfa88d3..24241dc 100644 --- a/tests/test_microbot.py +++ b/tests/test_microbot.py @@ -9,8 +9,6 @@ from django.conf import settings from rest_framework.authtoken.models import Token from django.apps import apps -from rest_framework.test import APIRequestFactory, force_authenticate -from microbot.views import BotDetail, EnvironmentVarDetail try: from unittest import mock except ImportError: @@ -315,242 +313,4 @@ def test_header_not_authenticated(self): response_text_template='''{% if response.list %}{% for book in response.list %}{{book.title}}{% endfor %} {% else %}not books{% endif %}''', response_keyboard_template='') - self._test_message(self.book_get_not_authorized) - - -class BaseTestAPI(testcases.BaseTestBot): - - def _gen_token(self, token): - return 'Token %s' % str(token) - - def setUp(self): - super(BaseTestAPI, self).setUp() - self.api = '/microapi' - self.mytoken = '204840063:AAGKVVNf0HUTFoQKcgmLrvPv4tyP8xRCkFc' - self.mytoken2 = '190880460:AAELDdTxhhfPbtPRyC59qPaVF5VBX4VGVes' - -class TestBotAPI(BaseTestAPI): - - def test_get_bots_ok(self): - response = self.client.get(self.api + '/bots/', HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() - self.assertEqual(self.bot.token, data[0]['token']) - self.assertEqual(self.bot.enabled, data[0]['enabled']) - self.assertEqual(self.bot.user_api.username, data[0]['info']['username']) - self.assertEqual(self.bot.user_api.first_name, data[0]['info']['first_name']) - self.assertEqual(self.bot.user_api.last_name, data[0]['info']['last_name']) - - def test_get_bots_not_auth(self): - response = self.client.get(self.api + '/bots/') - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_post_bots_ok(self): - Bot.objects.all().delete() - response = self.client.post(self.api + '/bots/', - data={'token': self.mytoken, 'enabled': 'True'}, - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - new_bot = Bot.objects.get(token=self.mytoken) - self.assertEqual(new_bot.token, self.mytoken) - self.assertTrue(new_bot.enabled) - - def test_post_bots_not_auth(self): - response = self.client.post(self.api + '/bots/', - data={'token': self.mytoken, 'enabled': 'True'}) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_get_bot_ok(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/', - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() - self.assertEqual(self.bot.token, data['token']) - self.assertEqual(self.bot.enabled, data['enabled']) - self.assertEqual(self.bot.user_api.username, data['info']['username']) - self.assertEqual(self.bot.user_api.first_name, data['info']['first_name']) - self.assertEqual(self.bot.user_api.last_name, data['info']['last_name']) - - def test_get_bot_not_auth(self): - new_user = ModelUser.objects.create_user(username='username', - email='username@test.com', - password='password') - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/', - HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_get_bot_not_found(self): - response = self.client.get(self.api + '/bots/12/', - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - - def test_put_bot_ok(self): - factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/', {'token': self.mytoken, 'enabled': 'False'}) - force_authenticate(request, user=self.bot.owner) - response = BotDetail.as_view()(request, self.bot.pk) - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertFalse(Bot.objects.get(pk=self.bot.pk).enabled) - - def test_put_bot_not_auth(self): - factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/', {'token': self.mytoken, 'enabled': 'False'}) - response = BotDetail.as_view()(request, self.bot.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_put_bot_not_found(self): - factory = APIRequestFactory() - request = factory.put(self.api + '/bots/12/', {'token': self.mytoken, 'enabled': 'False'}) - force_authenticate(request, user=self.bot.owner) - response = BotDetail.as_view()(request, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - - def test_delete_bot_ok(self): - factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/') - force_authenticate(request, user=self.bot.owner) - response = BotDetail.as_view()(request, self.bot.pk) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - self.assertEqual(Bot.objects.count(), 0) - - def test_delete_bot_not_auth(self): - factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/') - response = BotDetail.as_view()(request, self.bot.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_delete_bot_not_found(self): - factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/12/') - force_authenticate(request, user=self.bot.owner) - response = BotDetail.as_view()(request, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - -class TestEnvironmentVarAPI(BaseTestAPI): - - def setUp(self): - super(TestEnvironmentVarAPI, self).setUp() - self.key = "shop" - self.value = "myebookshop" - self.env_var = EnvironmentVar.objects.create(bot=self.bot, - key=self.key, - value=self.value) - - def test_get_env_vars_ok(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/', - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() - self.assertEqual(self.env_var.key, data[0]['key']) - self.assertEqual(self.env_var.value, data[0]['value']) - - def test_get_env_vars_not_auth(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/') - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_post_env_vars_ok(self): - EnvironmentVar.objects.all().delete() - response = self.client.post(self.api + '/bots/' + str(self.bot.pk) + '/env/', - data={'key': self.key, 'value': self.value}, - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - new_env_var = EnvironmentVar.objects.filter(bot=self.bot)[0] - self.assertEqual(new_env_var.key, self.key) - self.assertTrue(new_env_var.value, self.value) - - def test_post_env_vars_not_auth(self): - response = self.client.post(self.api + '/bots/' + str(self.bot.pk) + '/env/', - data={'key': self.key, 'value': self.value}) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_get_env_var_ok(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() - self.assertEqual(self.env_var.key, data['key']) - self.assertEqual(self.env_var.value, data['value']) - - def test_get_env_var_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - response = self.client.get(self.api + '/bots/' + str(new_bot.pk) + '/env/' + str(self.env_var.pk) + '/', - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - - def test_get_env_var_not_auth(self): - new_user = ModelUser.objects.create_user(username='username', - email='username@test.com', - password='password') - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', - HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_get_env_var_not_found(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/12/', - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - - def test_put_env_var_ok(self): - factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', - {'key': self.key, 'value': 'new_value'}) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(EnvironmentVar.objects.get(pk=self.env_var.pk).value, 'new_value') - - def test_put_env_var_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(new_bot.pk) + '/env/' + str(self.env_var.pk) + '/', - {'key': self.key, 'value': 'new_value'}) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - - def test_put_env_var_not_auth(self): - factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', - {'key': self.key, 'value': 'new_value'}) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_put_env_var_not_found(self): - factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/12/', - {'key': self.key, 'value': 'new_value'}) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - - def test_delete_env_var_ok(self): - factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - self.assertEqual(EnvironmentVar.objects.count(), 0) - - def test_delete_env_var_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - - def test_delete_bot_not_auth(self): - factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - - def test_delete_bot_not_found(self): - factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/12/') - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) \ No newline at end of file + self._test_message(self.book_get_not_authorized) \ No newline at end of file From 39368e12fa0dc1990c5514b3868c8f8001ee0bde Mon Sep 17 00:00:00 2001 From: Juan Madurga Date: Sun, 13 Mar 2016 11:59:03 +0100 Subject: [PATCH 4/7] refactor test_api --- tests/test_api.py | 116 ++++++++++++++++++++++++++++------------------ 1 file changed, 71 insertions(+), 45 deletions(-) diff --git a/tests/test_api.py b/tests/test_api.py index 67a4774..a87f799 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -23,23 +23,37 @@ def setUp(self): class TestBotAPI(BaseTestAPI): + def assertBot(self, token, enabled, username, first_name, last_name, bot=None): + if not bot: + bot = self.bot + self.assertEqual(bot.token,token) + self.assertEqual(bot.enabled, enabled) + self.assertEqual(bot.user_api.username, username) + self.assertEqual(bot.user_api.first_name, first_name) + self.assertEqual(bot.user_api.last_name, last_name) + + def _bot_list_url(self): + return '%s/bots/' % self.api + + def _bot_detail_url(self, bot_pk=None): + if not bot_pk: + bot_pk = self.bot.pk + return '%s/bots/%s/' % (self.api, bot_pk) + def test_get_bots_ok(self): - response = self.client.get(self.api + '/bots/', HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + response = self.client.get(self._bot_list_url(), HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() - self.assertEqual(self.bot.token, data[0]['token']) - self.assertEqual(self.bot.enabled, data[0]['enabled']) - self.assertEqual(self.bot.user_api.username, data[0]['info']['username']) - self.assertEqual(self.bot.user_api.first_name, data[0]['info']['first_name']) - self.assertEqual(self.bot.user_api.last_name, data[0]['info']['last_name']) + self.assertBot(data[0]['token'], data[0]['enabled'], data[0]['info']['username'], + data[0]['info']['first_name'], data[0]['info']['last_name']) def test_get_bots_not_auth(self): - response = self.client.get(self.api + '/bots/') + response = self.client.get(self._bot_list_url()) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_post_bots_ok(self): Bot.objects.all().delete() - response = self.client.post(self.api + '/bots/', + response = self.client.post(self._bot_list_url(), data={'token': self.mytoken, 'enabled': 'True'}, HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_201_CREATED) @@ -48,37 +62,34 @@ def test_post_bots_ok(self): self.assertTrue(new_bot.enabled) def test_post_bots_not_auth(self): - response = self.client.post(self.api + '/bots/', + response = self.client.post(self._bot_list_url(), data={'token': self.mytoken, 'enabled': 'True'}) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_get_bot_ok(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/', + response = self.client.get(self._bot_detail_url(), HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() - self.assertEqual(self.bot.token, data['token']) - self.assertEqual(self.bot.enabled, data['enabled']) - self.assertEqual(self.bot.user_api.username, data['info']['username']) - self.assertEqual(self.bot.user_api.first_name, data['info']['first_name']) - self.assertEqual(self.bot.user_api.last_name, data['info']['last_name']) + self.assertBot(data['token'], data['enabled'], data['info']['username'], + data['info']['first_name'], data['info']['last_name']) def test_get_bot_not_auth(self): new_user = ModelUser.objects.create_user(username='username', email='username@test.com', password='password') - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/', + response = self.client.get(self._bot_detail_url(), HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_get_bot_not_found(self): - response = self.client.get(self.api + '/bots/12/', + response = self.client.get(self._bot_detail_url(12), HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_put_bot_ok(self): factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/', {'token': self.mytoken, 'enabled': 'False'}) + request = factory.put(self._bot_detail_url(), {'token': self.mytoken, 'enabled': 'False'}) force_authenticate(request, user=self.bot.owner) response = BotDetail.as_view()(request, self.bot.pk) self.assertEqual(response.status_code, status.HTTP_200_OK) @@ -86,20 +97,20 @@ def test_put_bot_ok(self): def test_put_bot_not_auth(self): factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/', {'token': self.mytoken, 'enabled': 'False'}) + request = factory.put(self._bot_detail_url(), {'token': self.mytoken, 'enabled': 'False'}) response = BotDetail.as_view()(request, self.bot.pk) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_put_bot_not_found(self): factory = APIRequestFactory() - request = factory.put(self.api + '/bots/12/', {'token': self.mytoken, 'enabled': 'False'}) + request = factory.put(self._bot_detail_url(12), {'token': self.mytoken, 'enabled': 'False'}) force_authenticate(request, user=self.bot.owner) response = BotDetail.as_view()(request, 12) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_delete_bot_ok(self): factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/') + request = factory.delete(self._bot_detail_url()) force_authenticate(request, user=self.bot.owner) response = BotDetail.as_view()(request, self.bot.pk) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) @@ -107,13 +118,13 @@ def test_delete_bot_ok(self): def test_delete_bot_not_auth(self): factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/') + request = factory.delete(self._bot_detail_url()) response = BotDetail.as_view()(request, self.bot.pk) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_delete_bot_not_found(self): factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/12/') + request = factory.delete(self._bot_detail_url(12)) force_authenticate(request, user=self.bot.owner) response = BotDetail.as_view()(request, 12) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) @@ -128,45 +139,60 @@ def setUp(self): key=self.key, value=self.value) + def _env_list_url(self, bot_pk=None): + if not bot_pk: + bot_pk = self.bot.pk + return '%s/bots/%s/env/' % (self.api, bot_pk) + + def _env_detail_url(self, bot_pk=None, env_pk=None): + if not bot_pk: + bot_pk = self.bot.pk + if not env_pk: + env_pk = self.env_var.pk + return '%s/bots/%s/env/%s/' % (self.api, bot_pk, env_pk) + + def assertEnvVar(self, key, value, env_var=None): + if not env_var: + env_var = self.env_var + self.assertEqual(env_var.key, key) + self.assertEqual(env_var.value, value) + def test_get_env_vars_ok(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/', + response = self.client.get(self._env_list_url(), HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() - self.assertEqual(self.env_var.key, data[0]['key']) - self.assertEqual(self.env_var.value, data[0]['value']) + self.assertEnvVar(data[0]['key'], data[0]['value']) def test_get_env_vars_not_auth(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/') + response = self.client.get(self._env_list_url()) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_post_env_vars_ok(self): EnvironmentVar.objects.all().delete() - response = self.client.post(self.api + '/bots/' + str(self.bot.pk) + '/env/', + response = self.client.post(self._env_list_url(), data={'key': self.key, 'value': self.value}, HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_201_CREATED) new_env_var = EnvironmentVar.objects.filter(bot=self.bot)[0] - self.assertEqual(new_env_var.key, self.key) - self.assertTrue(new_env_var.value, self.value) + self.assertEnvVar(self.key, self.value, new_env_var) def test_post_env_vars_not_auth(self): - response = self.client.post(self.api + '/bots/' + str(self.bot.pk) + '/env/', + response = self.client.post(self._env_list_url(), data={'key': self.key, 'value': self.value}) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_get_env_var_ok(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + response = self.client.get(self._env_detail_url(), HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() - self.assertEqual(self.env_var.key, data['key']) - self.assertEqual(self.env_var.value, data['value']) + self.assertEnvVar(data['key'], data['value']) def test_get_env_var_from_other_bot(self): new_bot = Bot.objects.create(owner=self.bot.owner, token=self.mytoken2) - response = self.client.get(self.api + '/bots/' + str(new_bot.pk) + '/env/' + str(self.env_var.pk) + '/', + response = self.client.get(self._env_detail_url(new_bot.pk), HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) @@ -174,18 +200,18 @@ def test_get_env_var_not_auth(self): new_user = ModelUser.objects.create_user(username='username', email='username@test.com', password='password') - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + response = self.client.get(self._env_detail_url(), HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_get_env_var_not_found(self): - response = self.client.get(self.api + '/bots/' + str(self.bot.pk) + '/env/12/', + response = self.client.get(self._env_detail_url(env_pk=12), HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_put_env_var_ok(self): factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + request = factory.put(self._env_detail_url(), {'key': self.key, 'value': 'new_value'}) force_authenticate(request, user=self.bot.owner) response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) @@ -196,7 +222,7 @@ def test_put_env_var_from_other_bot(self): new_bot = Bot.objects.create(owner=self.bot.owner, token=self.mytoken2) factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(new_bot.pk) + '/env/' + str(self.env_var.pk) + '/', + request = factory.put(self._env_detail_url(new_bot.pk), {'key': self.key, 'value': 'new_value'}) force_authenticate(request, user=self.bot.owner) response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) @@ -204,14 +230,14 @@ def test_put_env_var_from_other_bot(self): def test_put_env_var_not_auth(self): factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/', + request = factory.put(self._env_detail_url(), {'key': self.key, 'value': 'new_value'}) response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_put_env_var_not_found(self): factory = APIRequestFactory() - request = factory.put(self.api + '/bots/' + str(self.bot.pk) + '/env/12/', + request = factory.put(self._env_detail_url(env_pk=12), {'key': self.key, 'value': 'new_value'}) force_authenticate(request, user=self.bot.owner) response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) @@ -219,7 +245,7 @@ def test_put_env_var_not_found(self): def test_delete_env_var_ok(self): factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + request = factory.delete(self._env_detail_url()) force_authenticate(request, user=self.bot.owner) response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) @@ -229,20 +255,20 @@ def test_delete_env_var_from_other_bot(self): new_bot = Bot.objects.create(owner=self.bot.owner, token=self.mytoken2) factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + request = factory.delete(self._env_detail_url(new_bot.pk)) force_authenticate(request, user=self.bot.owner) response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_delete_bot_not_auth(self): factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/' + str(self.env_var.pk) + '/') + request = factory.delete(self._env_detail_url()) response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_delete_bot_not_found(self): factory = APIRequestFactory() - request = factory.delete(self.api + '/bots/' + str(self.bot.pk) + '/env/12/') + request = factory.delete(self._env_detail_url(env_pk=12)) force_authenticate(request, user=self.bot.owner) response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) \ No newline at end of file From e9c05d79bef44fc5c570ae0366dae7a39256447e Mon Sep 17 00:00:00 2001 From: Juan Madurga Date: Mon, 14 Mar 2016 12:32:48 +0100 Subject: [PATCH 5/7] handlers to API --- microbot/serializers.py | 69 ++++++++++++++- microbot/views.py | 33 +++++-- tests/test_api.py | 191 ++++++++++++++++++++++++++++++++++++++-- tests/urls.py | 2 + 4 files changed, 279 insertions(+), 16 deletions(-) diff --git a/microbot/serializers.py b/microbot/serializers.py index fa81bea..7d0ddd4 100644 --- a/microbot/serializers.py +++ b/microbot/serializers.py @@ -1,5 +1,5 @@ from rest_framework import serializers -from microbot.models import User, Chat, Message, Update, Bot, EnvironmentVar +from microbot.models import User, Chat, Message, Update, Bot, EnvironmentVar, Handler, Request, UrlParam, HeaderParam from datetime import datetime import time @@ -82,4 +82,69 @@ class Meta: class EnvironmentVarSerializer(serializers.ModelSerializer): class Meta: model = EnvironmentVar - fields = ('key', 'value') \ No newline at end of file + fields = ('key', 'value') + +class AbsParamSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = UrlParam + fields = ('key', 'value_template') + +class RequestSerializer(serializers.HyperlinkedModelSerializer): + url_parameters = AbsParamSerializer(many=True) + header_parameters = AbsParamSerializer(many=True) + class Meta: + model = Request + fields = ('url_template', 'method', 'data', 'url_parameters', 'header_parameters') + +class HandlerSerializer(serializers.ModelSerializer): + request = RequestSerializer(many=False) + class Meta: + model = Handler + fields = ('pattern', 'response_text_template', 'response_keyboard_template', 'enabled', 'request') + + def _create_params(self, params, model, request): + for param in params: + model.objects.get_or_create(key=param['key'], + value_template=param['value_template'], + request=request) + + def _update_params(self, params, query_get): + for param in params: + instance_param = query_get(key=param['key']) + instance_param.key = param['key'] + instance_param.value_template = param['value_template'] + instance_param.save() + + def create(self, validated_data): + request, _ = Request.objects.get_or_create(**validated_data['request']) + + handler, _ = Handler.objects.get_or_create(pattern=validated_data['pattern'], + response_text_template=validated_data['response_text_template'], + response_keyboard_template=validated_data['response_keyboard_template'], + enabled=validated_data['enabled'], + request=request) + + self._create_params(validated_data['request']['url_parameters'], UrlParam, request) + self._create_params(validated_data['request']['header_parameters'], HeaderParam, request) + + + return handler + + def update(self, instance, validated_data): + instance.pattern = validated_data.get('pattern', instance.pattern) + instance.response_text_template = validated_data.get('response_text_template', instance.response_text_template) + instance.response_keyboard_template = validated_data.get('response_keyboard_template', instance.response_keyboard_template) + instance.enabled = validated_data.get('enabled', instance.enabled) + + instance.request.url_template = validated_data['request'].get('url_template', instance.request.url_template) + instance.request.method = validated_data['request'].get('method', instance.request.method) + instance.request.data = validated_data['request'].get('data', instance.request.data) + instance.request.save() + + self._update_params(validated_data['request']['url_parameters'], instance.request.url_parameters.get) + self._update_params(validated_data['request']['header_parameters'], instance.request.header_parameters.get) + + instance.save() + return instance + + \ No newline at end of file diff --git a/microbot/views.py b/microbot/views.py index 4f212d6..6217566 100644 --- a/microbot/views.py +++ b/microbot/views.py @@ -1,6 +1,7 @@ from rest_framework.views import APIView -from microbot.serializers import UpdateSerializer, BotSerializer, EnvironmentVarSerializer -from microbot.models import Bot, EnvironmentVar +from microbot.serializers import UpdateSerializer, BotSerializer, EnvironmentVarSerializer,\ + HandlerSerializer +from microbot.models import Bot, EnvironmentVar, Handler, Request from rest_framework.response import Response from rest_framework import status from telegram import Update @@ -114,7 +115,7 @@ class DetailBotAPIView(MicrobotAPIView): serializer = None def _user(self, obj): - raise NotImplemented + return obj.bot.owner def get_object(self, pk, bot, user): try: @@ -122,7 +123,7 @@ def get_object(self, pk, bot, user): if self._user(obj) != user: raise exceptions.AuthenticationFailed() return obj - except EnvironmentVar.DoesNotExist: + except self.model.DoesNotExist: raise Http404 def get(self, request, bot_pk, pk, format=None): @@ -160,7 +161,25 @@ def _creator(self, bot, serializer): class EnvironmentVarDetail(DetailBotAPIView): model = EnvironmentVar - serializer = EnvironmentVarSerializer + serializer = EnvironmentVarSerializer + - def _user(self, obj): - return obj.bot.owner +class HandlerList(ListBotAPIView): + serializer = HandlerSerializer + + def _query(self, bot): + return bot.handlers.all() + + def _creator(self, bot, serializer): + request = Request.objects.create(url_template=serializer.data['request']['url_template'], + method=serializer.data['request']['method']) + Handler.objects.create(bot=bot, + pattern=serializer.data['pattern'], + response_text_template=serializer.data['response_text_template'], + response_keyboard_template=serializer.data['response_keyboard_template'], + enabled=serializer.data['enabled'], + request=request) + +class HandlerDetail(DetailBotAPIView): + model = Handler + serializer = HandlerSerializer diff --git a/tests/test_api.py b/tests/test_api.py index a87f799..0945a15 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -1,13 +1,14 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -from microbot.models import Bot, EnvironmentVar -from microbot.test import testcases +from microbot.models import Bot, EnvironmentVar, Handler +from microbot.test import testcases, factories from rest_framework import status from rest_framework.test import APIRequestFactory, force_authenticate -from microbot.views import BotDetail, EnvironmentVarDetail +from microbot.views import BotDetail, EnvironmentVarDetail, HandlerDetail from django.conf import settings from django.apps import apps - +import json +from microbot.models.handler import HeaderParam, UrlParam ModelUser = apps.get_model(getattr(settings, 'AUTH_USER_MODEL', 'auth.User')) class BaseTestAPI(testcases.BaseTestBot): @@ -260,15 +261,191 @@ def test_delete_env_var_from_other_bot(self): response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) - def test_delete_bot_not_auth(self): + def test_delete_env_var_not_auth(self): factory = APIRequestFactory() request = factory.delete(self._env_detail_url()) response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - def test_delete_bot_not_found(self): + def test_delete_env_var_not_found(self): factory = APIRequestFactory() request = factory.delete(self._env_detail_url(env_pk=12)) force_authenticate(request, user=self.bot.owner) response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) \ No newline at end of file + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + +class TestHandlerAPI(BaseTestAPI): + + def setUp(self): + super(TestHandlerAPI, self).setUp() + self.handler = factories.HandlerFactory(bot=self.bot) + self.url_param = factories.UrlParamFactory(request=self.handler.request) + self.header_param = factories.HeaderParamFactory(request=self.handler.request) + + def _handler_list_url(self, bot_pk=None): + if not bot_pk: + bot_pk = self.bot.pk + return '%s/bots/%s/handlers/' % (self.api, bot_pk) + + def _handler_detail_url(self, bot_pk=None, handler_pk=None): + if not bot_pk: + bot_pk = self.bot.pk + if not handler_pk: + handler_pk = self.handler.pk + return '%s/bots/%s/handlers/%s/' % (self.api, bot_pk, handler_pk) + + def assertHandler(self, pattern, response_text_template, response_keyboard_template, enabled, handler=None): + if not handler: + handler = self.handler + self.assertEqual(handler.pattern, pattern) + self.assertEqual(handler.response_text_template, response_text_template) + self.assertEqual(handler.response_keyboard_template, response_keyboard_template) + self.assertEqual(handler.enabled, enabled) + + def test_get_handlers_ok(self): + response = self.client.get(self._handler_list_url(), + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertHandler(data[0]['pattern'], data[0]['response_text_template'], data[0]['response_keyboard_template'], + data[0]['enabled']) + + def test_get_handlers_not_auth(self): + response = self.client.get(self._handler_list_url()) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_post_handlers_ok(self): + Handler.objects.all().delete() + data = {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, + 'request': {'url_template': self.handler.request.url_template, 'method': self.handler.request.method, + 'url_parameters': [{'key': self.handler.request.url_parameters.all()[0].key, + 'value_template': self.handler.request.url_parameters.all()[0].value_template}], + 'header_parameters' : [{'key': self.handler.request.header_parameters.all()[0].key, + 'value_template': self.handler.request.header_parameters.all()[0].value_template}] + } + } + response = self.client.post(self._handler_list_url(), + data=json.dumps(data), + content_type='application/json', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + new_handler = Handler.objects.filter(bot=self.bot)[0] + self.assertHandler(self.handler.pattern, self.handler.response_text_template, self.handler.response_keyboard_template, + False, new_handler) + + def test_post_handlers_not_auth(self): + response = self.client.post(self._handler_list_url(), + data={'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, + 'request': self.handler.request}) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + + def test_get_handler_ok(self): + response = self.client.get(self._handler_detail_url(), + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + data = response.json() + self.assertHandler(data['pattern'], data['response_text_template'], data['response_keyboard_template'], data['enabled']) + + def test_get_handler_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + response = self.client.get(self._handler_detail_url(new_bot.pk), + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_get_handler_not_auth(self): + new_user = ModelUser.objects.create_user(username='username', + email='username@test.com', + password='password') + response = self.client.get(self._handler_detail_url(), + HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_get_handler_not_found(self): + response = self.client.get(self._handler_detail_url(handler_pk=12), + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_put_handler_ok(self): + factory = APIRequestFactory() + request = factory.put(self._handler_detail_url(), + {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, + 'request': {'url_template': self.handler.request.url_template, 'method': self.handler.request.method, + 'url_parameters': [{'key': self.handler.request.url_parameters.all()[0].key, + 'value_template': 'new_url_param_value'}], + 'header_parameters' : [{'key': self.handler.request.header_parameters.all()[0].key, + 'value_template': 'new_header_param_value'}]}}, + format='json') + force_authenticate(request, user=self.bot.owner) + response = HandlerDetail.as_view()(request, self.bot.pk, self.handler.pk) + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(Handler.objects.get(pk=self.handler.pk).enabled, False) + self.assertEqual(UrlParam.objects.get(key=self.handler.request.url_parameters.all()[0].key).value_template, 'new_url_param_value') + self.assertEqual(HeaderParam.objects.get(key=self.handler.request.header_parameters.all()[0].key).value_template, 'new_header_param_value') + + def test_put_handler_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + factory = APIRequestFactory() + request = factory.put(self._handler_detail_url(new_bot.pk), + {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, + 'request': self.handler.request}) + force_authenticate(request, user=self.bot.owner) + response = HandlerDetail.as_view()(request, new_bot.pk, self.handler.pk) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_put_handler_not_auth(self): + factory = APIRequestFactory() + request = factory.put(self._handler_detail_url(), + {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, + 'request': self.handler.request}) + response = HandlerDetail.as_view()(request, self.bot.pk, self.handler.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_put_handler_not_found(self): + factory = APIRequestFactory() + request = factory.put(self._handler_detail_url(handler_pk=12), + {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, + 'request': self.handler.request}) + force_authenticate(request, user=self.bot.owner) + response = HandlerDetail.as_view()(request, self.bot.pk, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_delete_handler_ok(self): + factory = APIRequestFactory() + request = factory.delete(self._handler_detail_url()) + force_authenticate(request, user=self.bot.owner) + response = HandlerDetail.as_view()(request, self.bot.pk, self.handler.pk) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + self.assertEqual(EnvironmentVar.objects.count(), 0) + + def test_delete_handler_from_other_bot(self): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + factory = APIRequestFactory() + request = factory.delete(self._handler_detail_url(new_bot.pk)) + force_authenticate(request, user=self.bot.owner) + response = HandlerDetail.as_view()(request, new_bot.pk, self.handler.pk) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def test_delete_handler_not_auth(self): + factory = APIRequestFactory() + request = factory.delete(self._handler_detail_url()) + response = HandlerDetail.as_view()(request, self.bot.pk, self.handler.pk) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def test_delete_handler_not_found(self): + factory = APIRequestFactory() + request = factory.delete(self._handler_detail_url(handler_pk=12)) + force_authenticate(request, user=self.bot.owner) + response = HandlerDetail.as_view()(request, self.bot.pk, 12) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + \ No newline at end of file diff --git a/tests/urls.py b/tests/urls.py index ae07056..d96c773 100644 --- a/tests/urls.py +++ b/tests/urls.py @@ -17,5 +17,7 @@ url(r'^microapi/bots/(?P[0-9]+)/$', micro_views.BotDetail.as_view()), url(r'^microapi/bots/(?P[0-9]+)/env/$', micro_views.EnvironmentVarList.as_view()), url(r'^microapi/bots/(?P[0-9]+)/env/(?P[0-9]+)/$', micro_views.EnvironmentVarDetail.as_view()), + url(r'^microapi/bots/(?P[0-9]+)/handlers/$', micro_views.HandlerList.as_view()), + url(r'^microapi/bots/(?P[0-9]+)/handlers/(?P[0-9]+)/$', micro_views.HandlerDetail.as_view()), url(r'^microbot', include('microbot.urls', namespace="microbot")), ] \ No newline at end of file From 7076511dda001239968606e7be412561a187fd28 Mon Sep 17 00:00:00 2001 From: Juan Madurga Date: Mon, 14 Mar 2016 12:46:28 +0100 Subject: [PATCH 6/7] set urls for micrbot api --- microbot/urls.py | 6 ++++++ tests/test_api.py | 2 +- tests/urls.py | 9 +-------- 3 files changed, 8 insertions(+), 9 deletions(-) diff --git a/microbot/urls.py b/microbot/urls.py index 1d0a09f..598f2fa 100644 --- a/microbot/urls.py +++ b/microbot/urls.py @@ -4,4 +4,10 @@ urlpatterns = [ url(r'^telegrambot/(?P[-_:a-zA-Z0-9]+)/$', csrf_exempt(views.WebhookView.as_view()), name='telegrambot'), + url(r'^api/bots/$', views.BotList.as_view(), name='bot-list'), + url(r'^api/bots/(?P[0-9]+)/$', views.BotDetail.as_view(), name='bot-detail'), + url(r'^api/bots/(?P[0-9]+)/env/$', views.EnvironmentVarList.as_view(), name='env-list'), + url(r'^api/bots/(?P[0-9]+)/env/(?P[0-9]+)/$', views.EnvironmentVarDetail.as_view(), name='env-list'), + url(r'^api/bots/(?P[0-9]+)/handlers/$', views.HandlerList.as_view(), name='handler-list'), + url(r'^api/bots/(?P[0-9]+)/handlers/(?P[0-9]+)/$', views.HandlerDetail.as_view(), name='handler-detail'), ] diff --git a/tests/test_api.py b/tests/test_api.py index 0945a15..0ddd3d9 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -18,7 +18,7 @@ def _gen_token(self, token): def setUp(self): super(BaseTestAPI, self).setUp() - self.api = '/microapi' + self.api = '/microbot/api' self.mytoken = '204840063:AAGKVVNf0HUTFoQKcgmLrvPv4tyP8xRCkFc' self.mytoken2 = '190880460:AAELDdTxhhfPbtPRyC59qPaVF5VBX4VGVes' diff --git a/tests/urls.py b/tests/urls.py index d96c773..2f93b82 100644 --- a/tests/urls.py +++ b/tests/urls.py @@ -2,7 +2,6 @@ from django.conf.urls import include from rest_framework import routers from tests import views -from microbot import views as micro_views from rest_framework.authtoken import views as rdf_views router = routers.DefaultRouter() @@ -13,11 +12,5 @@ url(r'^api-token-auth/', rdf_views.obtain_auth_token), url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')), url(r'^api/', include(router.urls)), - url(r'^microapi/bots/$', micro_views.BotList.as_view()), - url(r'^microapi/bots/(?P[0-9]+)/$', micro_views.BotDetail.as_view()), - url(r'^microapi/bots/(?P[0-9]+)/env/$', micro_views.EnvironmentVarList.as_view()), - url(r'^microapi/bots/(?P[0-9]+)/env/(?P[0-9]+)/$', micro_views.EnvironmentVarDetail.as_view()), - url(r'^microapi/bots/(?P[0-9]+)/handlers/$', micro_views.HandlerList.as_view()), - url(r'^microapi/bots/(?P[0-9]+)/handlers/(?P[0-9]+)/$', micro_views.HandlerDetail.as_view()), - url(r'^microbot', include('microbot.urls', namespace="microbot")), + url(r'^microbot/', include('microbot.urls', namespace="microbot")), ] \ No newline at end of file From 6ee9f2662728347b424fcc16701d38882a161bc6 Mon Sep 17 00:00:00 2001 From: Juan Madurga Date: Mon, 14 Mar 2016 13:41:32 +0100 Subject: [PATCH 7/7] refactor API tests --- tests/test_api.py | 393 ++++++++++++++++++++-------------------------- 1 file changed, 173 insertions(+), 220 deletions(-) diff --git a/tests/test_api.py b/tests/test_api.py index 0ddd3d9..b585c5b 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -22,6 +22,116 @@ def setUp(self): self.mytoken = '204840063:AAGKVVNf0HUTFoQKcgmLrvPv4tyP8xRCkFc' self.mytoken2 = '190880460:AAELDdTxhhfPbtPRyC59qPaVF5VBX4VGVes' + def _test_get_list_ok(self, url): + response = self.client.get(url, HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + return response.json() + + def _test_get_list_not_auth(self, url): + response = self.client.get(url) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def _test_post_list_ok(self, url, model, data): + model.objects.all().delete() + response = self.client.post(url, + data=json.dumps(data), + content_type='application/json', + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + return response.json() + + def _test_post_list_not_auth(self, url, data): + response = self.client.post(url, + data) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def _test_get_detail_ok(self, url): + response = self.client.get(url, + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_200_OK) + return response.json() + + def _test_get_detail_not_auth(self, url): + new_user = ModelUser.objects.create_user(username='username', + email='username@test.com', + password='password') + response = self.client.get(url, + HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def _test_get_detail_not_found(self, url): + response = self.client.get(url, + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def _test_put_detail_ok(self, url, data, view, *args): + factory = APIRequestFactory() + request = factory.put(url, data, format="json") + force_authenticate(request, user=self.bot.owner) + response = view.as_view()(request, *args) + self.assertEqual(response.status_code, status.HTTP_200_OK) + + + def _test_put_detail_not_auth(self, url, data, view, *args): + factory = APIRequestFactory() + request = factory.put(url, data) + response = view.as_view()(request, *args) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def _test_put_detail_not_found(self, url, data, view, *args): + factory = APIRequestFactory() + request = factory.put(url, data) + force_authenticate(request, user=self.bot.owner) + response = view.as_view()(request, *args) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def _test_delete_detail_ok(self, url, view, *args): + factory = APIRequestFactory() + request = factory.delete(url) + force_authenticate(request, user=self.bot.owner) + response = view.as_view()(request, *args) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + + def _test_delete_detail_not_auth(self, url, view, *args): + factory = APIRequestFactory() + request = factory.delete(url) + response = view.as_view()(request, *args) + self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + + def _test_delete_detail_not_found(self, url, view, *args): + factory = APIRequestFactory() + request = factory.delete(url) + force_authenticate(request, user=self.bot.owner) + response = view.as_view()(request, *args) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def _test_get_detail_from_other_bot(self, func_url, *args): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + response = self.client.get(func_url(new_bot.pk, *args), + HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def _test_put_detail_from_other_bot(self, func_url, data, view, *args): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + factory = APIRequestFactory() + request = factory.put(func_url(new_bot.pk), + data) + force_authenticate(request, user=self.bot.owner) + response = view.as_view()(request, new_bot.pk, *args) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + def _test_delete_detail_from_other_bot(self, func_url, view, *args): + new_bot = Bot.objects.create(owner=self.bot.owner, + token=self.mytoken2) + factory = APIRequestFactory() + request = factory.delete(func_url(new_bot.pk)) + force_authenticate(request, user=self.bot.owner) + response = view.as_view()(request, new_bot.pk, *args) + self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + + class TestBotAPI(BaseTestAPI): def assertBot(self, token, enabled, username, first_name, last_name, bot=None): @@ -42,93 +152,54 @@ def _bot_detail_url(self, bot_pk=None): return '%s/bots/%s/' % (self.api, bot_pk) def test_get_bots_ok(self): - response = self.client.get(self._bot_list_url(), HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() + data = self._test_get_list_ok(self._bot_list_url()) self.assertBot(data[0]['token'], data[0]['enabled'], data[0]['info']['username'], data[0]['info']['first_name'], data[0]['info']['last_name']) def test_get_bots_not_auth(self): - response = self.client.get(self._bot_list_url()) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_get_list_not_auth(self._bot_list_url()) def test_post_bots_ok(self): - Bot.objects.all().delete() - response = self.client.post(self._bot_list_url(), - data={'token': self.mytoken, 'enabled': 'True'}, - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self._test_post_list_ok(self._bot_list_url(), Bot, {'token': self.mytoken, 'enabled': 'True'}) new_bot = Bot.objects.get(token=self.mytoken) self.assertEqual(new_bot.token, self.mytoken) self.assertTrue(new_bot.enabled) def test_post_bots_not_auth(self): - response = self.client.post(self._bot_list_url(), - data={'token': self.mytoken, 'enabled': 'True'}) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_post_list_not_auth(self._bot_list_url(), {'token': self.mytoken, 'enabled': 'True'}) def test_get_bot_ok(self): - response = self.client.get(self._bot_detail_url(), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() + data = self._test_get_detail_ok(self._bot_detail_url()) self.assertBot(data['token'], data['enabled'], data['info']['username'], + data['info']['first_name'], data['info']['last_name']) def test_get_bot_not_auth(self): - new_user = ModelUser.objects.create_user(username='username', - email='username@test.com', - password='password') - response = self.client.get(self._bot_detail_url(), - HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_get_detail_not_auth(self._bot_detail_url()) def test_get_bot_not_found(self): - response = self.client.get(self._bot_detail_url(12), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_get_detail_not_found(self._bot_detail_url(12)) def test_put_bot_ok(self): - factory = APIRequestFactory() - request = factory.put(self._bot_detail_url(), {'token': self.mytoken, 'enabled': 'False'}) - force_authenticate(request, user=self.bot.owner) - response = BotDetail.as_view()(request, self.bot.pk) - self.assertEqual(response.status_code, status.HTTP_200_OK) + self._test_put_detail_ok(self._bot_detail_url(), {'token': self.mytoken, 'enabled': 'False'}, BotDetail, self.bot.pk) self.assertFalse(Bot.objects.get(pk=self.bot.pk).enabled) def test_put_bot_not_auth(self): - factory = APIRequestFactory() - request = factory.put(self._bot_detail_url(), {'token': self.mytoken, 'enabled': 'False'}) - response = BotDetail.as_view()(request, self.bot.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_put_detail_not_auth(self._bot_detail_url(), {'token': self.mytoken, 'enabled': 'False'}, BotDetail, self.bot.pk) def test_put_bot_not_found(self): - factory = APIRequestFactory() - request = factory.put(self._bot_detail_url(12), {'token': self.mytoken, 'enabled': 'False'}) - force_authenticate(request, user=self.bot.owner) - response = BotDetail.as_view()(request, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_put_detail_not_found(self._bot_detail_url(12), {'token': self.mytoken, 'enabled': 'False'}, BotDetail, 12) def test_delete_bot_ok(self): - factory = APIRequestFactory() - request = factory.delete(self._bot_detail_url()) - force_authenticate(request, user=self.bot.owner) - response = BotDetail.as_view()(request, self.bot.pk) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + self._test_delete_detail_ok(self._bot_detail_url(), BotDetail, self.bot.pk) self.assertEqual(Bot.objects.count(), 0) def test_delete_bot_not_auth(self): - factory = APIRequestFactory() - request = factory.delete(self._bot_detail_url()) - response = BotDetail.as_view()(request, self.bot.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_delete_detail_not_auth(self._bot_detail_url(), BotDetail, self.bot.pk) def test_delete_bot_not_found(self): - factory = APIRequestFactory() - request = factory.delete(self._bot_detail_url(12)) - force_authenticate(request, user=self.bot.owner) - response = BotDetail.as_view()(request, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_delete_detail_not_found(self._bot_detail_url(12), BotDetail, 12) + class TestEnvironmentVarAPI(BaseTestAPI): @@ -159,120 +230,59 @@ def assertEnvVar(self, key, value, env_var=None): self.assertEqual(env_var.value, value) def test_get_env_vars_ok(self): - response = self.client.get(self._env_list_url(), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() + data = self._test_get_list_ok(self._env_list_url()) self.assertEnvVar(data[0]['key'], data[0]['value']) def test_get_env_vars_not_auth(self): - response = self.client.get(self._env_list_url()) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_get_list_not_auth(self._env_list_url()) def test_post_env_vars_ok(self): - EnvironmentVar.objects.all().delete() - response = self.client.post(self._env_list_url(), - data={'key': self.key, 'value': self.value}, - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self._test_post_list_ok(self._env_list_url(), EnvironmentVar, {'key': self.key, 'value': self.value}) new_env_var = EnvironmentVar.objects.filter(bot=self.bot)[0] self.assertEnvVar(self.key, self.value, new_env_var) def test_post_env_vars_not_auth(self): - response = self.client.post(self._env_list_url(), - data={'key': self.key, 'value': self.value}) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_post_list_not_auth(self._env_list_url(), {'key': self.key, 'value': self.value}) def test_get_env_var_ok(self): - response = self.client.get(self._env_detail_url(), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() + data = self._test_get_detail_ok(self._env_detail_url()) self.assertEnvVar(data['key'], data['value']) def test_get_env_var_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - response = self.client.get(self._env_detail_url(new_bot.pk), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_get_detail_from_other_bot(self._env_detail_url) def test_get_env_var_not_auth(self): - new_user = ModelUser.objects.create_user(username='username', - email='username@test.com', - password='password') - response = self.client.get(self._env_detail_url(), - HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_get_detail_not_auth(self._env_detail_url()) def test_get_env_var_not_found(self): - response = self.client.get(self._env_detail_url(env_pk=12), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_get_detail_not_found(self._env_detail_url(env_pk=12)) def test_put_env_var_ok(self): - factory = APIRequestFactory() - request = factory.put(self._env_detail_url(), - {'key': self.key, 'value': 'new_value'}) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_200_OK) + self._test_put_detail_ok(self._env_detail_url(), {'key': self.key, 'value': 'new_value'}, EnvironmentVarDetail, self.bot.pk, self.env_var.pk) self.assertEqual(EnvironmentVar.objects.get(pk=self.env_var.pk).value, 'new_value') def test_put_env_var_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - factory = APIRequestFactory() - request = factory.put(self._env_detail_url(new_bot.pk), - {'key': self.key, 'value': 'new_value'}) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_put_detail_from_other_bot(self._env_detail_url, {'key': self.key, 'value': 'new_value'}, EnvironmentVarDetail, self.env_var.pk) def test_put_env_var_not_auth(self): - factory = APIRequestFactory() - request = factory.put(self._env_detail_url(), - {'key': self.key, 'value': 'new_value'}) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_put_detail_not_auth(self._env_detail_url(), {'key': self.key, 'value': 'new_value'}, EnvironmentVarDetail, + self.bot.pk, self.env_var.pk) def test_put_env_var_not_found(self): - factory = APIRequestFactory() - request = factory.put(self._env_detail_url(env_pk=12), - {'key': self.key, 'value': 'new_value'}) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_put_detail_not_found(self._env_detail_url(env_pk=12), {'key': self.key, 'value': 'new_value'}, EnvironmentVarDetail, self.bot.pk, 12) def test_delete_env_var_ok(self): - factory = APIRequestFactory() - request = factory.delete(self._env_detail_url()) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + self._test_delete_detail_ok(self._env_detail_url(), EnvironmentVarDetail, self.bot.pk, self.env_var.pk) self.assertEqual(EnvironmentVar.objects.count(), 0) def test_delete_env_var_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - factory = APIRequestFactory() - request = factory.delete(self._env_detail_url(new_bot.pk)) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, new_bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_delete_detail_from_other_bot(self._env_detail_url, EnvironmentVarDetail, self.env_var.pk) def test_delete_env_var_not_auth(self): - factory = APIRequestFactory() - request = factory.delete(self._env_detail_url()) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, self.env_var.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) - + self._test_delete_detail_not_auth(self._env_detail_url(), EnvironmentVarDetail, self.bot.pk, self.env_var.pk) + def test_delete_env_var_not_found(self): - factory = APIRequestFactory() - request = factory.delete(self._env_detail_url(env_pk=12)) - force_authenticate(request, user=self.bot.owner) - response = EnvironmentVarDetail.as_view()(request, self.bot.pk, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_delete_detail_not_found(self._env_detail_url(env_pk=12), EnvironmentVarDetail, self.bot.pk, 12) class TestHandlerAPI(BaseTestAPI): @@ -302,20 +312,17 @@ def assertHandler(self, pattern, response_text_template, response_keyboard_templ self.assertEqual(handler.response_keyboard_template, response_keyboard_template) self.assertEqual(handler.enabled, enabled) + + def test_get_handlers_ok(self): - response = self.client.get(self._handler_list_url(), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() + data = self._test_get_list_ok(self._handler_list_url()) self.assertHandler(data[0]['pattern'], data[0]['response_text_template'], data[0]['response_keyboard_template'], data[0]['enabled']) def test_get_handlers_not_auth(self): - response = self.client.get(self._handler_list_url()) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_get_list_not_auth(self._handler_list_url()) def test_post_handlers_ok(self): - Handler.objects.all().delete() data = {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, 'request': {'url_template': self.handler.request.url_template, 'method': self.handler.request.method, @@ -325,127 +332,73 @@ def test_post_handlers_ok(self): 'value_template': self.handler.request.header_parameters.all()[0].value_template}] } } - response = self.client.post(self._handler_list_url(), - data=json.dumps(data), - content_type='application/json', - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self._test_post_list_ok(self._handler_list_url(), Handler, data) new_handler = Handler.objects.filter(bot=self.bot)[0] self.assertHandler(self.handler.pattern, self.handler.response_text_template, self.handler.response_keyboard_template, False, new_handler) def test_post_handlers_not_auth(self): - response = self.client.post(self._handler_list_url(), - data={'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, - 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, - 'request': self.handler.request}) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + data={'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, + 'request': self.handler.request} + self._test_post_list_not_auth(self._handler_list_url(), data) def test_get_handler_ok(self): - response = self.client.get(self._handler_detail_url(), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_200_OK) - data = response.json() + data = self._test_get_detail_ok(self._handler_detail_url()) self.assertHandler(data['pattern'], data['response_text_template'], data['response_keyboard_template'], data['enabled']) def test_get_handler_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - response = self.client.get(self._handler_detail_url(new_bot.pk), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_get_detail_from_other_bot(self._handler_detail_url) def test_get_handler_not_auth(self): - new_user = ModelUser.objects.create_user(username='username', - email='username@test.com', - password='password') - response = self.client.get(self._handler_detail_url(), - HTTP_AUTHORIZATION=self._gen_token(new_user.auth_token)) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_get_detail_not_auth(self._handler_detail_url()) def test_get_handler_not_found(self): - response = self.client.get(self._handler_detail_url(handler_pk=12), - HTTP_AUTHORIZATION=self._gen_token(self.bot.owner.auth_token)) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_get_detail_not_found(self._handler_detail_url(handler_pk=12)) def test_put_handler_ok(self): - factory = APIRequestFactory() - request = factory.put(self._handler_detail_url(), - {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + data = {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, 'request': {'url_template': self.handler.request.url_template, 'method': self.handler.request.method, 'url_parameters': [{'key': self.handler.request.url_parameters.all()[0].key, 'value_template': 'new_url_param_value'}], 'header_parameters' : [{'key': self.handler.request.header_parameters.all()[0].key, - 'value_template': 'new_header_param_value'}]}}, - format='json') - force_authenticate(request, user=self.bot.owner) - response = HandlerDetail.as_view()(request, self.bot.pk, self.handler.pk) - self.assertEqual(response.status_code, status.HTTP_200_OK) + 'value_template': 'new_header_param_value'}]}} + self._test_put_detail_ok(self._handler_detail_url(), data, HandlerDetail, self.bot.pk, self.handler.pk) self.assertEqual(Handler.objects.get(pk=self.handler.pk).enabled, False) self.assertEqual(UrlParam.objects.get(key=self.handler.request.url_parameters.all()[0].key).value_template, 'new_url_param_value') self.assertEqual(HeaderParam.objects.get(key=self.handler.request.header_parameters.all()[0].key).value_template, 'new_header_param_value') def test_put_handler_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - factory = APIRequestFactory() - request = factory.put(self._handler_detail_url(new_bot.pk), - {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + data = {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, - 'request': self.handler.request}) - force_authenticate(request, user=self.bot.owner) - response = HandlerDetail.as_view()(request, new_bot.pk, self.handler.pk) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + 'request': self.handler.request} + self._test_put_detail_from_other_bot(self._handler_detail_url, data, HandlerDetail, self.handler.pk) def test_put_handler_not_auth(self): - factory = APIRequestFactory() - request = factory.put(self._handler_detail_url(), - {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + data = {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, - 'request': self.handler.request}) - response = HandlerDetail.as_view()(request, self.bot.pk, self.handler.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + 'request': self.handler.request} + self._test_put_detail_not_auth(self._handler_detail_url(), data, HandlerDetail, self.bot.pk, self.handler.pk) def test_put_handler_not_found(self): - factory = APIRequestFactory() - request = factory.put(self._handler_detail_url(handler_pk=12), - {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, - 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, - 'request': self.handler.request}) - force_authenticate(request, user=self.bot.owner) - response = HandlerDetail.as_view()(request, self.bot.pk, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + data = {'pattern': self.handler.pattern, 'response_text_template': self.handler.response_text_template, + 'response_keyboard_template': self.handler.response_keyboard_template, 'enabled': False, + 'request': self.handler.request} + self._test_put_detail_not_found(self._handler_detail_url(handler_pk=12), data, HandlerDetail, self.bot.pk, 12) def test_delete_handler_ok(self): - factory = APIRequestFactory() - request = factory.delete(self._handler_detail_url()) - force_authenticate(request, user=self.bot.owner) - response = HandlerDetail.as_view()(request, self.bot.pk, self.handler.pk) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + self._test_delete_detail_ok(self._handler_detail_url(), HandlerDetail, self.bot.pk, self.handler.pk) self.assertEqual(EnvironmentVar.objects.count(), 0) def test_delete_handler_from_other_bot(self): - new_bot = Bot.objects.create(owner=self.bot.owner, - token=self.mytoken2) - factory = APIRequestFactory() - request = factory.delete(self._handler_detail_url(new_bot.pk)) - force_authenticate(request, user=self.bot.owner) - response = HandlerDetail.as_view()(request, new_bot.pk, self.handler.pk) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_delete_detail_from_other_bot(self._handler_detail_url, HandlerDetail, self.handler.pk) def test_delete_handler_not_auth(self): - factory = APIRequestFactory() - request = factory.delete(self._handler_detail_url()) - response = HandlerDetail.as_view()(request, self.bot.pk, self.handler.pk) - self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) + self._test_delete_detail_not_auth(self._handler_detail_url(), HandlerDetail, self.bot.pk, self.handler.pk) def test_delete_handler_not_found(self): - factory = APIRequestFactory() - request = factory.delete(self._handler_detail_url(handler_pk=12)) - force_authenticate(request, user=self.bot.owner) - response = HandlerDetail.as_view()(request, self.bot.pk, 12) - self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) + self._test_delete_detail_not_found(self._handler_detail_url(handler_pk=12), HandlerDetail, self.bot.pk, 12) \ No newline at end of file