[TIL]KDT_20230428

📚 KDT WEEK 4 DAY 5 TIL

• RelatedField
• 투표(Votes)기능 구현하기
• Validation
• Testing

 

---

 

🟥 RelatedField

Serializer에서 외래키로 연결된 다른 필드를 불러올 때, 어떤 옵션으로 가져올지 이 기능으로 정할 수 있다.

 

1. PrimaryKeyRealatedField

questions = serializers.PrimaryKeyRelatedField(many=True, queryset=Question.objects.all())

PrimaryKey, 즉 id의 값을 보여준다.

 

2. StringRelatedField

questions = serializers.StringRelatedField(many=True, read_only=True) # __str__ 참조됨

해당 모델(questions)에 정의된 __str__에 따라 이름으로 보여준다.

 

3. SlugRelatedField

questions = serializers.SlugRelatedField(many=True, read_only=True, slug_field="pub_date") # 특정 필드가져옴

해당 오브젝트(question)의 특정 필드 값(pub_date)를 보여준다.

 

4. HyperlinkedRelatedField

questions = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='question-detail') 

ulrs.py의 name과 일치하는 view_name을 작성하면, 해당 오브젝트(question)과 연결되는 url을 보여준다.

 

결과

HyperlinkedRealtedFiled 로 url을 나타낸 모습

 

---

 

이번엔 Serializer를 정의하여 관련모델 표기해보기

class ChoiceSerializer(serializers.ModelSerializer):
    class Meta:
        model = Choice
        fields = ['choice_text', 'votes']

class QuestionSerializer(serializers.ModelSerializer):
    owner = serializers.ReadOnlyField(source='owner.username')
    choices = ChoiceSerializer(many=True, read_only = True) # Question에서 choice를 표시하기 위해서

    class Meta:
        model = Question
        fields = ['id', 'question_text', 'pub_date','owner', 'choices'] # ModelSerializer를 통해 자동으로 생성

Question에 연결된 choice들을 나타내기 위해서 ChoiceSerializer를 만들고, 위처럼 작성한다.

choices = ChoiceSerializer과 fields에 'choices'를 추가해주었다.

 

+

사실 choices로 이름을 정한 것은, Choice 모델에서 정의한 부분과 관련이 있다.

class Choice(models.Model):

    question = models.ForeignKey(Question, related_name='choices',on_delete=models.CASCADE)

Chocie 모델안에서 question에 related_name을 'choices'로 정의했기 때문에 가능한 일이다.

위처럼 related_name의 정의가 없다면, shell에서 동작하듯 choice_set으로 불러와야한다.

 

 

---

 

🟦 투표 기능 구현하기

기능 구현을 위해 누가 어떤 질문에 어떤 것을 투표했는지를 담고 있는 객체, Vote 모델을 만들어보자.

 

class Vote(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
    choice = models.ForeignKey(Choice, on_delete=models.CASCADE)
    voter = models.ForeignKey(User, on_delete=models.CASCADE)

    # question과 voter에 대해 하나의 레코드를 생성
    # voter가 하나씩만 만들 수 있게 제약조건을 만들어주는 것임.
    class Meta:
        constraints = [
            models.UniqueConstraint(fields=['question', 'voter'], name='unique_voter_for_questions')
        ]

 

하나의 User가 같은 Question에 여러번 투표하는 것을 막기 위해, 제약조건(Constratins)를 작성해주었다.

제약조건은 위처럼, Meta 클래스안에 리스트형태로 구현한다.

이렇게 question과 voter를 묶어놓으면, 하나의 User가 Choice만 바꿔서 같은 Question에 투표할 수 없게될 것이다!

 

이제 Choice에서는 자신의 vote필드가 아닌 Vote 모델을 통해 투표수를 보여줘야할 것이다.

 

class ChoiceSerializer(serializers.ModelSerializer):
    votes_count = serializers.SerializerMethodField() # 값이 메소드에 의해서 결정됨

    class Meta:
        model = Choice
        fields = ['choice_text', 'votes_count']

    def get_votes_count(self, obj): # obj = choice
        return obj.vote_set.count() # choice가 vote와 외래키로 연결되어있기 때문에 _set 사용

serializers.SerializerMethodField()는 이 변수가 함수의 값에 의해 결정된다고 말해주는 것이다.

 

아래에 get_변수이름()의 메소드에서 return 값을 통해 votes_count에 저장될 것이다!

 

태스트를 위해 Shell에서 user,question,choice를 임의로 하나 저장해두고 아래와 같이 입력했다.

>>> Vote.objects.create(voter=user,question=question,choice=choice)
<Vote: Vote object (1)>

 

결과

shell에서 동작한 결과가 잘 나타나고 있다.

 

---

 

Vote 생성 및 수정 API 만들기

API 생성을 위해 먼저 Serializer를 생성해야한다.

 

▶ polls_api/serializers.py

from polls.models import Question,Choice, Vote

class VoteSerializer(serializers.ModelSerializer):    
    voter = serializers.ReadOnlyField(source='voter.username')
        
    class Meta:
        model = Vote
        fields = ['id', 'question', 'choice', 'voter']

voter는 로그인 사용자를 토대로 정의되거나 수정되므로 ReadonlyField를 넣어주었다.

 

다음으로 화면 구현을 위해 views.py에 Question처럼 VoteList와 VoteDetail을 만들었다.

 

▶ polls_api/views.py

#내가 작성한 Vote들만 보여주는 기능
class VoteList(generics.ListCreateAPIView):
    serializer_class = VoteSerializer
    permission_classes = [permissions.IsAuthenticated] # 로그인한 유저만 볼 수 있도록 제한

    def get_queryset(self, *args, **kwargs): #리스트를 표현할 때 사용할 쿼리셋 정의
        return Vote.objects.filter(voter=self.request.user)
    
    def perform_create(self, serializer):
        serializer.save(voter=self.request.user)


class VoteDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Vote.objects.all()
    serializer_class = VoteSerializer
    permission_classes = [permissions.IsAuthenticated, IsVoter] #투표한 사람만 CRUD 가능해야함

VoteList는 vote들의 목록을 보여줄 것이다.

vote가 생성될 때는 현재 로그인한 사용자의 데이터를 넣어야 하므로 perform_create를 오버라이딩해야한다.

 

VoteDetail는 vote id를 통해 만들어진 상세페이지이다.

여기서는 permission에 IsVoter라는 특별한 함수를 넣어주었다.

 

▶ polls_api/permissions.py

class IsVoter(permissions.BasePermission):
    def has_object_permission(self, request, view, obj):
        return obj.voter == request.user # 오브젝트의 소유자가 요청한 사용자 인가? 맞으면 True

permissions에서 미리 정의해둔 함수를 가져다 사용했던 것이다.

 

views.py를 정의했으니, urls.py에 path를 지정하는 것도 잊지 말아야 한다.

urlpatterns = [
    ...
    path('vote/', VoteList.as_view()),
    path('vote/<int:pk>/', VoteDetail.as_view()),
]

 

결과

Question 페이지와 거의 비슷하다. 똑같이 CRUD도 자유롭다.

 

 

---

 

🟨 Validation

몇 가지 오류를 수정해보겠다.

 

1. question과 user가 같은 값이 들어왔을 때 400 에러가 아닌 500 에러가 나타나는 현상 방지

 

▶ polls_api/serializers.py

from rest_framework.validators import UniqueTogetherValidator

class VoteSerializer(serializers.ModelSerializer):

    class Meta:
        model = Vote
        fields = ['id', 'question', 'choice', 'voter']
        validators = [
            UniqueTogetherValidator(
                queryset = Vote.objects.all(),
                fields=['question', 'voter']
            )
        ]

Serializer에 validators를 추가해주면 400 Bad request  에러로 올바르게 나타난다.

 

하지만 이번에는 에러메시지가 이상하다.

"voter" : "This field is required."

라고 나오지만, voter는 상관이 없고 question과 voter의 UniqueVailidation에 대한 오류로 바꿔줘야한다.

 

▶ polls_api/views.py

from rest_framework import status
from rest_framework.response import Response

class VoteList(generics.ListCreateAPIView):
    serializer_class = VoteSerializer
    permission_classes = [permissions.IsAuthenticated]
    
    def get_queryset(self, *args, **kwargs):
        return Vote.objects.filter(voter=self.request.user)
    
    def create(self, request, *args, **kwargs):
        new_data = request.data.copy()
        new_data['voter'] = request.user.id
        serializer = self.get_serializer(data=new_data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

views.py에서 VoteList 클래스에 create 함수를 오바라이딩해주어야한다.

에러의 이유가 부모 클래스에서 정의된 create 메서드에 있기 때문이다.

 

우리가 오버라이딩 perform_create 메서드에 user 데이터를 넣어주었데,

create 메서드에서는 .is_valid가 .perform_create 메서드보다 먼저 실행되기 때문에 user 값이 없다고 에러가 뜨는 것이다.

 

따라서 위처럼 create함수에서 perfrom_create 메서드에서 user 값을 넣지않고,

애초에 new_data 변수를 만들어 요청받은 user 값을 그대로 넣어준다.

 

+ 그리고, serializer에게 voter값이 잘 전달되도록 VoteSerializer에 vote의 Readonly 제한도 없애줘야한다.

 

2. 로그인된 user가 자신의 vote 객체를 다른 user의 이름으로 바꿀 수 있는 문제

 

▶ polls_api/views.py

class VoteDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Vote.objects.all()
    serializer_class = VoteSerializer
    permission_classes = [permissions.IsAuthenticated, IsVoter] #투표한 사람만 CRUD 가능해야함

    def perform_update(self, serializer):
        serializer.save(voter=self.request.user)

perform_update 메서드를 오버라이딩한다.

이렇게하면, 유저가 다른 유저의 이름을 넣을 순 있어도 로그인된 유저의 이름으로 고정되어 들어가긴 한다..

 

 

3. vote를 수정할때 question과 choice가 서로 맞지 않는데 수정되는 문제

▶ polls_api/serializers.py

class VoteSerializer(serializers.ModelSerializer):

    def validate(self, attrs): # validation 수행, attrs에 데이터를 담아온다.
        if attrs['choice'].question.id != attrs['question'].id:
            raise serializers.ValidationError("Qeustion과 Choice가 조합이 맞지 않습니다.")
        return attrs

    class Meta:
        model = Vote
        fields = ['id', 'question', 'choice', 'voter']
        validators = [
            UniqueTogetherValidator(
                queryset = Vote.objects.all(),
                fields=['question', 'voter']
            )
        ]

VoteSerializer에 validate 함수를 추가해주어야한다. 이는 validation을 수행하는 함수이다.

Serializer에서 validation을 수행함으로써 오류가나면 해당 오류 텍스트를 띄울 수가 있다.

 

---

 

🟧 Testing

컴퓨터가 스스로 테스트를 돌려주는 자동화 기능

django에서 지원하는 TestCase와 rest_framework의 APITestCase를 이용해서 자동화 테스트 파일을 만들어본다!

 

Test 코드를 작성할때는 다음을 주의하면서 작성한다.

• 정의된 테스트 함수의 이름은 "test_"로 시작해야하며, 그 이름을 잘 명시해야 한다.
• TestCase는 Test를 위한 별도의 데이터베이스를 이용한다.
• 각 테스트는 모두 별개로 동작한다.

테스트를 위한 assert 메서드

• .assertEqual() : 두 인자가 서로 같은지 확인한다. == 와 같이 검사한다.
• .assertIsNotNone() : 인자가 None이 아니면 True를 리턴한다.
• .assertTrue() : 인자값이 True인지 확인한다.
• .assertLess(): 두 개의 인자를 받는다. 오른쪽의 인자가 왼쪽의 인자보다 작은지 확인한다.

테스트의 동작 확인은 shell에서

>>> python manage.py test

로 확인할 수 있다.

 

▶ polls_api/tests.py

from django.test import TestCase
from polls_api.serializers import QuestionSerializer

class QuestionSerializerTestCase(TestCase):
    # def test_a(self): # test_ 로 시작하는 함수만 테스트라고 인식함 # 성공하면 . 실패하면 F

    def test_with_valid_data(self):
        serializer = QuestionSerializer(data={'question_text' : 'abc'})
        self.assertEqual(serializer.is_valid(), True) # question_text를 입력하고 create할때, is_valid한 상황인가?
        new_question = serializer.save() # id가 자동저장될 것임
        self.assertIsNotNone(new_question.id) # id가 비어있는가?

    # question_text가 비어있도록 생성하면 is_valid()가 False인가?
    def test_with_invalid_data(self):
        serializer = QuestionSerializer(data={'question_text' : ''})
        self.assertEqual(serializer.is_valid(), False)

QuestionSerializer를 테스트하기 위한 코드이다.

Test를 해보니, 모두 패스했다.

 

class VoteSerializerTest(TestCase):

    def setUp(self): # 테스트가 실행될때마다 한번씩 반복되어 실행함, *self를 사용함에 주의* 테스트마다 독립적수행
        self.user = User.objects.create(username='testuser')
        self.question = Question.objects.create(
            question_text ='abc',
            owner = self.user
        )
        self.choice1 = Choice.objects.create(
            question=self.question,
            choice_text = '1'
        )

    # create vote Test
    def test_vote_serializer(self):
        data ={
            'question' : self.question.id,
            'choice' : self.choice1.id,
            'voter' : self.user.id
        }
        serializer = VoteSerializer(data= data)
        self.assertTrue(serializer.is_valid())
        vote = serializer.save()

        self.assertEqual(vote.question, self.question)
        self.assertEqual(vote.choice, self.choice1)
        self.assertEqual(vote.voter, self.user)


    # question, user의 UniqueValidation Test
    def test_vote_serializer_with_duplicate_vote(self): # 메소드를 잘 적어줘야 에러발생했을 때 알기 쉬움

        choice2 = Choice.objects.create( # 새롭게 들어갈 Vote용
            question=self.question,
            choice_text = '2'
        )
        Vote.objects.create(question=self.question, choice=self.choice1, voter=self.user) # 미리 하나 만들어둠

        data ={
            'question' : self.question.id,
            'choice' : choice2.id,
            'voter' : self.user.id
        }
        serializer = VoteSerializer(data= data)
        self.assertFalse(serializer.is_valid()) # question과 user가 동일한 vote를 또 생성할 수 있을까?

    # question과 choice의 unmatch Test
    def test_vote_serializer_with_unmatched_question_and_choice(self):
        question2 = Question.objects.create(
            question_text ='abc',
            owner = self.user
        )
        choice2 = Choice.objects.create(
            question=question2,
            choice_text = '1'
        )
        data ={
            'question' : self.question.id,
            'choice' : choice2.id,
            'voter' : self.user.id
        }
        serializer = VoteSerializer(data= data)
        self.assertFalse(serializer.is_valid())

VoteSerializer를 테스트하는 코드이다.

엄청 길지만 대부분 변수들을 초기화하는 내용이고, 직관적이다.

 

중요한건, setUp() 메서드를 사용했다.

• setUp() 메서드는 각 테스트가 시작되기 전에 한번씩 실행되는 메서드이다.
• 반복되는 코드나 자주 초기화되는 변수를 넣어주면 좋다.
• 사용된 변수는 그 클래스안에서 self.변수명 을 통해 불러와야한다.

 

이번엔 APITestCase를 이용하여 View를 테스트한 코드이다.

# View의 경우 APITestCase가 필요
class QuestionListTest(APITestCase):
    def setUp(self):
        self.question_data = {'question_text' : 'some question'}
        self.url = reverse('question-list') # 메소드안에서는 reverse.lazy가 아닌 reverse 사용하기.

    def test_create_question(self):
        user = User.objects.create(username = 'testuser', password ="testpass")
        self.client.force_authenticate(user=user) # 사용자를 로그인 시키는 기능 (APITestCase 기능)
        response = self.client.post(self.url, self.question_data) # 해당 데이터를 url로 post 요청

        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(Question.objects.count(), 1)

        question = Question.objects.first()
        self.assertLess((timezone.now() - question.pub_date).total_seconds(), 1) # assertLess는 뒤의 인자보다 작은가? 확인함

    # 사용자 로그인없이 question을 만들었을 때
    def test_create_question_without_authentication(self):
        response = self.client.post(self.url, self.question_data)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_list_questions(self):
        question = Question.objects.create(question_text='Question1')
        Choice.objects.create(question=question, choice_text='choice1')
        Question.objects.create(question_text='Question2')
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data),2)

사용자를 로그인 상태로 두는 함수를 사용하기위해 APITestCase의 상속이 필요했다.

 

+ 파이썬에서 작성한 테스트 코드의 커버리지를 측정할 수 있는 도구가 있다.

>>> pip install coverage

>>> coverage run manage.py test

>>> coverage report

두 번째 명령어로 test를 실행하고, 세 번째 명령어로 test의 결과 커버리지를 확인할 수 있다.

 

결과

serializer와 views 테스트가 부족한걸 알 수 있다!

 

---

🤔 공부하면서 어려웠던 내용

오늘은 작성한 코드를 보완하거나 테스트해볼 수 있었다.

어떻게보면 가장 귀찮지만 중요한 작업이라고 생각한다.

백프로 완성된 코드는 없는 법이니까.. 😇