Tests, tests, tests

Author: Emmanouil Konstantinidis

tests/models.py

@@ -0,0 +1,49 @@
+import uuid
+from django.db import models
+from django.contrib.auth.models import AbstractBaseUser
+
+
+class User(AbstractBaseUser):
+    created = models.DateTimeField(auto_now_add=True, db_index=True)
+    modified = models.DateTimeField(auto_now=True)
+
+    email = models.EmailField(unique=True, verbose_name='email address', max_length=255)
+    full_name = models.CharField(max_length=255)
+
+    is_active = models.BooleanField(default=False)
+    is_admin = models.BooleanField(default=False)
+
+    USERNAME_FIELD = 'email'
+    REQUIRED_FIELDS = ['email', 'full_name']
+
+
+class Organisation(models.Model):
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    created = models.DateTimeField(auto_now_add=True)
+    modified = models.DateTimeField(auto_now=True)
+
+    name = models.CharField(unique=True, max_length=100)
+    slug = models.SlugField(unique=True, null=True, blank=True)
+    members = models.ManyToManyField(User, through='Membership', through_fields=('organisation', 'user'))
+
+    is_active = models.BooleanField(default=False)
+
+
+class Membership(models.Model):
+
+    class Meta:
+        unique_together = ("organisation", "user")
+
+    MEMBER_ROLES = (
+        ("ADMIN", "Admin"),
+        ("USER", "User")
+    )
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    joined = models.DateTimeField(auto_now_add=True)
+
+    organisation = models.ForeignKey(Organisation)
+    user = models.ForeignKey(User)
+    role = models.CharField(choices=MEMBER_ROLES, max_length=20, default="USER")
+    is_owner = models.BooleanField(default=False)

tests/serializers.py

@@ -0,0 +1,58 @@
+from rest_framework import serializers
+from tests.models import User, Organisation, Membership
+
+
+class UserRegistrationSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = User
+        fields = ('email', 'full_name', 'password',)
+        extra_kwargs = {'password': {'write_only': True}}
+
+
+class UserProfileSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = User
+        fields = ('email', 'full_name', 'password', 'is_active')
+        extra_kwargs = {
+            'password': {'write_only': True}
+        }
+        read_only_fields = ('is_active',)
+
+
+class ResetPasswordSerializer(serializers.ModelSerializer):
+
+    id = serializers.CharField()
+    token = serializers.CharField()
+
+    class Meta:
+        model = User
+        fields = ('id', 'token', 'password',)
+        extra_kwargs = {'password': {'write_only': True}}
+
+
+class CreateOrganisationSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Organisation
+        fields = ('name', 'slug',)
+
+
+class OrganisationMembersSerializer(serializers.ModelSerializer):
+    user = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Membership
+        fields = ('joined', 'user', 'is_owner', 'role')
+
+    def get_user(self, obj):
+        serializer = UserProfileSerializer(obj.user)
+        return serializer.data
+
+
+class OrganisationDetailSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Organisation
+        fields = ('name', 'slug', 'is_active')

tests/settings.py

@@ -25,6 +25,10 @@
 
 ROOT_URLCONF = 'tests.urls'
 
+REST_FRAMEWORK_DOCS = {
+    'HIDDEN': False
+}
+
 # Static files (CSS, JavaScript, Images)
 # https://docs.djangoproject.com/en/1.8/howto/static-files/
 

tests/tests.py

@@ -1,33 +1,41 @@
 from django.core.urlresolvers import reverse
-from django.test import TestCase
+from django.test import TestCase, override_settings
 
 
-class SimpleTest(TestCase):
-
-    def test_details(self):
-        self.assertEqual(1, 1)
+class DRFDocsViewTests(TestCase):
 
+    SETTINGS_HIDE_DOCS = {
+        'HIDDEN': True  # Default: False
+    }
 
-class DRFDocsViewTests(TestCase):
     def setUp(self):
         super(DRFDocsViewTests, self).setUp()
 
-    def test_index_view_with_no_questions(self):
+    def test_index_view_with_endpoints(self):
         """
-        Should load the drf focs view
+        Should load the drf focs view with all the endpoints.
+        NOTE: Views that do **not** inherit from DRF's "APIView" are not included.
         """
         response = self.client.get(reverse('drfdocs'))
 
-        # print()
-        # print()
-        # print(response)
-        # print(response["context"])
-        # print(response.context)
-        # print(dir(response))
-        # print()
-        # print()
-
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.context["endpoints"], [])
-        # self.assertContains(response, "No polls are available.")
-        # self.assertQuerysetEqual(response.context['latest_question_list'], [])
+        self.assertEqual(len(response.context["endpoints"]), 8)
+
+        # Test the login view
+        self.assertEqual(response.context["endpoints"][0].name_parent, "accounts")
+        self.assertEqual(response.context["endpoints"][0].allowed_methods, ['POST', 'OPTIONS'])
+        self.assertEqual(response.context["endpoints"][0].path, "/accounts/login/")
+        self.assertEqual(len(response.context["endpoints"][0].fields), 2)
+        self.assertEqual(response.context["endpoints"][0].fields[0]["type"], "CharField")
+        self.assertTrue(response.context["endpoints"][0].fields[0]["required"])
+
+    @override_settings(REST_FRAMEWORK_DOCS=SETTINGS_HIDE_DOCS)
+    def test_index_view_docs_hidden(self):
+        """
+        Should prevent the docs from loading the "HIDDEN" is set
+        to "False" in settings
+        """
+        response = self.client.get(reverse('drfdocs'))
+
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(response.reason_phrase, "NOT FOUND")

tests/urls.py

@@ -4,10 +4,19 @@
 
 accounts_urls = [
     url(r'^login/$', views.LoginView.as_view(), name="login"),
+    url(r'^register/$', views.UserRegistrationView.as_view(), name="register"),
+    url(r'^reset-password/$', view=views.PasswordResetView.as_view(), name="reset-password"),
+    url(r'^reset-password/confirm/$', views.PasswordResetConfirmView.as_view(), name="reset-password-confirm"),
+
+    url(r'^user/profile/$', views.UserProfileView.as_view(), name="profile"),
+
+    url(r'^test/$', views.TestView.as_view(), name="test-view"),
 ]
 
 organisations_urls = [
-
+    url(r'^create/$', view=views.CreateOrganisationView.as_view(), name="create"),
+    url(r'^(?P<slug>[\w-]+)/members/$', view=views.OrganisationMembersView.as_view(), name="members"),
+    url(r'^(?P<slug>[\w-]+)/leave/$', view=views.LeaveOrganisationView.as_view(), name="leave")
 ]
 
 urlpatterns = [

tests/views.py

@@ -1,9 +1,13 @@
+from django.shortcuts import get_object_or_404
 from django.views.generic.base import TemplateView
-from rest_framework import parsers, renderers
+from rest_framework import parsers, renderers, generics, status
 from rest_framework.authtoken.models import Token
 from rest_framework.authtoken.serializers import AuthTokenSerializer
+from rest_framework.permissions import AllowAny
 from rest_framework.response import Response
 from rest_framework.views import APIView
+from tests.models import User, Organisation, Membership
+from tests import serializers
 
 
 class TestView(TemplateView):
@@ -27,3 +31,70 @@ def post(self, request):
         user = serializer.validated_data['user']
         token, created = Token.objects.get_or_create(user=user)
         return Response({'token': token.key})
+
+
+class UserRegistrationView(generics.CreateAPIView):
+
+    permission_classes = (AllowAny,)
+    serializer_class = serializers.UserRegistrationSerializer
+
+
+class UserProfileView(generics.RetrieveUpdateAPIView):
+
+    serializer_class = serializers.UserProfileSerializer
+
+    def get_object(self):
+        return self.request.user
+
+
+class PasswordResetView(APIView):
+
+    permission_classes = (AllowAny,)
+    queryset = User.objects.all()
+
+    def get_object(self):
+        email = self.request.data.get('email')
+        obj = get_object_or_404(self.queryset, email=email)
+        return obj
+
+    def post(self, request, *args, **kwargs):
+        user = self.get_object()
+        user.send_reset_password_email()
+        return Response({}, status=status.HTTP_200_OK)
+
+
+class PasswordResetConfirmView(APIView):
+
+    permission_classes = (AllowAny,)
+    serializer_class = serializers.ResetPasswordSerializer
+
+    def post(self, request, *args, **kwargs):
+        serializer = serializers.ResetPasswordSerializer(data=request.data)
+        if not serializer.is_valid():
+            return Response({'errors': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
+        return Response({"msg": "Password updated successfully."}, status=status.HTTP_200_OK)
+
+
+class CreateOrganisationView(generics.CreateAPIView):
+
+    serializer_class = serializers.CreateOrganisationSerializer
+
+
+class OrganisationMembersView(generics.ListAPIView):
+
+    serializer_class = serializers.OrganisationMembersSerializer
+
+    def get_queryset(self):
+        organisation = Organisation.objects.order_by('?').first()
+        return Membership.objects.filter(organisation=organisation)
+
+
+class LeaveOrganisationView(generics.DestroyAPIView):
+
+    def get_object(self):
+        return Membership.objects.order_by('?').first()
+
+    def delete(self, request, *args, **kwargs):
+        instance = self.get_object()
+        self.perform_destroy(instance)
+        return Response(status=status.HTTP_204_NO_CONTENT)