Jul. 30, 2020

Follow Button Logic and Endpoint:

Now we need to prepare to import a button on HTML page to let users can manually organize their following or followed.

profiles/api:

• create directory /profiles/api
• and create 3 files
  • /profiles/api/init.py
    • (empty)
  • /profiles/api/urls.py ```python from django.urls import path

from .views import ( user_follow_view, )

urlpatterns = [ path(‘<str:username/follow’, user_follow_view), ]

   - /profiles/api/views.py
```python
import random
from django.http import HttpResponse, JsonResponse, HttpResponseRedirect
from django.shortcuts import render, redirect
from django.utils.http import is_safe_url
from django.conf import settings
from django.contrib.auth import get_user_model
from rest_framework.authentication import SessionAuthentication
from rest_framework.decorators import api_view, permission_classes, authentication_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from ..models import Profile
User = get_user_model()
ALLOWED_HOSTS = settings.ALLOWED_HOSTS
@api_view(['GET', 'POST'])
@permission_classes([IsAuthenticated])
def user_follow_view(request, username, *args, **kwargs):
    me = request.user
    other_user_qs = User.objects.filter(username=username)
    if not other_user_qs.exists():
        return Response({}, status=404)
    other = other_user_qs.first()
    profile = other.profile
    data = request.data or {}
    action = data.get("action")
    print(data)
    if action == "follow":  # if I am not following this profile
        profile.followers.add(me)  # start following
    elif action == "unfollow":  # else
        profile.followers.remove(me)  # stop following
    else:
        pass
    current_followers_qs = profile.followers.all()
    return Response({"count": current_followers_qs.count()}, status=200)
    # we don't just use profile.followers.all() here because 'User' is not JSON serializable

• add a path for api url in /Twittme/urls.py

  # ...
  urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/tweets/', include('tweets.api.urls')),
    path('', tweets_list_view),
    path('login/', login_view), 
    path('logout/', logout_view), 
    path('register/', register_view), 
    path('<int:tweet_id>', tweets_detail_view),
    re_path(r'profiles?/', include('profiles.urls')),
    re_path(r'api/profiles?/', include('profiles.api.urls')),  # new
  ]
  # ...

Test case:

to test, runserver
access http://localhost/api/profiles/[username]/follow

we apply username as “root” here,
count is 0 right now

we POST content {“action”: “follow”}

and count becomes 1

This time we POST content {“action”: “unfollow”}

count is reduced to 0

But if we POST content {“action”: “unfollow”} again

count won’t be -1

Same as {“action”: “follow”} when count is 1

count won’t be 2

That’s because it’s actually keep adding and removing the same user who follows a profile, and 1 user is either following or not following a profile.

“data” in /profiles/api/views.py will always be {“action”: “follow”} or {“action”: “unfollow”}
**

Profile Following Unit Test Cases:

In this step, we can try to setup a unit test cases for profiles/api

Test case:

• add new contents in /profiles/tests.py ```python from django.contrib.auth import get_user_model from django.test import TestCase

from rest_framework.test import APIClient # new

from .models import Profile

User = get_user_model()

class ProfileTestCase(TestCase): def setUp(self): self.user = User.objects.create_user( username=’cfe’, password=’somepassword’) self.userb = User.objects.create_user( username=’cfe-2’, password=’somepassword2’)

def get_client(self): # new
    client = APIClient()
    client.login(username=self.user.username, password='somepassword')
    return client
def test_profile_created_via_signal(self):
    qs = Profile.objects.all()
    self.assertEqual(qs.count(), 2)
def test_following(self): # new, to test following step
    first = self.user
    second = self.userb
    first.profile.followers.add(second)  # added a follower
    second_user_following_whom = second.following.all()
    # from a user, check other user is being followed.
    qs = second_user_following_whom.filter(user=first)
    # check new user has is not following anyone
    first_user_following_no_one = first.following.all()
    self.assertTrue(qs.exists())
    self.assertFalse(first_user_following_no_one.exists())
def test_follow_api_endpoint(self): # new, to test unfollowing step
    client = self.get_client()
    response = client.post(f"/api/profiles/{self.userb.username}/follow", {"action": "follow"})
    r_data = response.json()
    count = r_data.get("count")
    self.assertEqual(count, 1)
def test_unfollow_api_endpoint(self):
    first = self.user
    second = self.userb
    first.profile.followers.add(second) # add a follower
    client = self.get_client()
    response = client.post(
        f"/api/profiles/{self.userb.username}/follow",
        {"action": "unfollow"}
    )
    r_data = response.json()
    count = r_data.get("count")
    self.assertEqual(count, 0)

to test, run test case in the terminal
```bash
[root@localhost Twittme]# python3 ./manage.py test profiles
Creating test database for alias 'default'...
System check identified no issues (0 silenced).
<QueryDict: {'action': ['follow']}>
...<QueryDict: {'action': ['unfollow']}>
.
----------------------------------------------------------------------
Ran 4 tests in 3.028s
OK
Destroying test database for alias 'default'...

all cases are passed, so that the following and unfollowing step is successful.

“Not the same user”:

There is a problem that we cannot let a user follow itself.

• add this checking in /profiles/api/views.py

  @api_view(['GET', 'POST'])
  @permission_classes([IsAuthenticated])
  def user_follow_view(request, username, *args, **kwargs):
    me = request.user
    other_user_qs = User.objects.filter(username=username)
    if me.username == username: # to check is follower and followed use the same one
        my_followers = me.profile.followers.all()
        return Response({"count": my_followers.count()}, status=200)
    if not other_user_qs.exists():
        return Response({}, status=404)
    other = other_user_qs.first()
    profile = other.profile
    data = request.data or {}
    action = data.get("action")
    print(data)
    if action == "follow":  # if I am not following this profile
        profile.followers.add(me)  # start following
    elif action == "unfollow":  # else
        profile.followers.remove(me)  # stop following
    else:
        pass
    current_followers_qs = profile.followers.all()
    return Response({"count": current_followers_qs.count()}, status=200)

• add the test case about “a use cannot follow oneself” in /profiles/tests.py

  # ...
    def test_cannot_follow_api_endpoint(self): # test the setting that a user cannot follow itself
        client = self.get_client()
        response = client.post(
            f"/api/profiles/{self.user.username}/follow",
            {"action": "follow"}
        )
        r_data = response.json()
        count = r_data.get("count")
        self.assertEqual(count, 0)

  to test, run test case in the terminal ```bash [root@localhost Twittme]# python3 ./manage.py test profiles Creating test database for alias ‘default’… System check identified no issues (0 silenced). . … .

Ran 5 tests in 4.101s

OK Destroying test database for alias ‘default’…

``` all cases are passed, so that a user cannot follow itself.