# 字段查询
class TestFieldQuery(TestCase):
	def setUp(self) -> None:
		Request.objects.create(url='/api/request/demo1',data={'name':'小明','age':18,'addr':'nanjing','father':{'name':'xiaogang','age':40}})
	def test_contains_query(self):
		req = Request.objects.filter(url__contains='demo')
		print(req)
	def test_in_query(self):
		req = Request.objects.filter(url__in=['/api/request/demo1','/api/request/demo2'])
		print(req)

# 查找标签是xxx的用例
res1=Case.objects.filter(tags__name='smoketest')

#跨关系查询
class TestOverRelations(TestCase):
	def setUp(self) -> None:
		# 创建套件和用例
		self.suite_conf = Config.objects.create(name='套件1')
		self.suite = Suite.objects.create(config=self.suite_conf)
		self.config = Config.objects.create(name='用例1')
		self.case = Case.objects.create(config=self.config,suite=self.suite)
    
	# 查找某套件下的用例步骤
	def test_case_step(self):
		Step.objects.create(belong_case=self.case,name='步骤1')
		Step.objects.create(belong_case=self.case,name='步骤2')
		Step.objects.create(belong_case=self.case,name='步骤3')
		steps=Step.objects.filter(belong_case__suite__config__name='套件1')
		print(steps)

# settings.py

INSTALLED_APPS = [
    'rest_framework'
]

from django.db import models
class Request(models.Model):
	...
	class Meta:   # 模型元类的作用：为模型增加额外的信息，如模型对应表名，
		ordering = ['id']   # 数据根据ID排序
		db_table = ['reqquest']   # 模型对应的数据库表名，不设置则默认为app名_模型名

# serializer.py

from rest_framework import serializers
from sqtp.models import Step, Request


class RequestSerializer(serializers.Serializer):
	method_choices = (     # method可选字段，二维元组
        (0, 'GET'),        # 参数1：保存在数据库中的值，参数2：对外显示的值
        (1, 'POST'),
        (2, 'PUT'),
        (3, 'DELETE'),
    )
    step = serializers.RelatedField(queryset=Step.objects.all(),allow_null=True)
    method = serializers.ChoiceField(choices=method_choices, default=0)
    url = serializers.CharField()
    params = serializers.JSONField(allow_null=True)
    headers = serializers.JSONField(allow_null=True)
    cookies = serializers.JSONField(allow_null=True)
    data = serializers.JSONField(allow_null=True)
    json = serializers.JSONField(allow_null=True)
    
    def create(self, validated_data):
        """
		根据提供的验证过的数据创建并返回一个新的`Snippet`实例。
		"""
        return Request.objects.create(**validated_data)
    
    def update(self, instance, validated_data):
        """
		根据提供的验证过的数据创建并返回一个新的`Snippet`实例。
		"""
        instance.step =validated_data.get('step',instance.step)
        instance.method =validated_data.get('method',instance.method)
        instance.url =validated_data.get('url',instance.url)
        instance.params =validated_data.get('params',instance.params)
        instance.headers =validated_data.get('headers',instance.headers)
        instance.cookies =validated_data.get('cookies',instance.cookies)
        instance.data =validated_data.get('data',instance.data)
        instance.json =validated_data.get('json',instance.json)

# sqtp/test_serializers.py

from django.test import TestCase
from sqtp.models import Step, Request
from sqtp.serializers import RequestSerializer
from rest_framework.renderers import JSONRenderer
from rest_framework.parsers import JSONParser


class TestRequestSerializer(TestCase):
    req1=Request.objects.create(url='/demo1',data={'name':'小明','age':18,'addr':'nanjing'}) 
    req2=Request.objects.create(url='/demo1',params={'name':'小明','age':18,'addr':'nanjing'})
    
    # 序列化:数据对象-->>python原生数据类型
    req1_serializer = RequestSerializer(req1)
    print(req1_serializer.data) # 序列化数据存储在序列化对象的data属性中
    
    # 序列化:python原生数据类型-->>json
    content = JSONRenderer().render(req1_serializer.data)
    print(content)                                                 

# 反序列化1: 将流（stream）解析为Python原生数据类型.
import io

stream = io.BytesIO(content)     # 构建1个steam流
data = JSONParser().parse(stream)     # 转成python原生数据类型

# 反序列化2: Python原生数据类型恢复成正常的对象实例。
serializer = RequestSerializer(data=data)    # 序列化器
print(serializer.is_valid())       # 校验数据是否合法
print(serializer.validated_data)   # 查看数据对象
serializer.save()    # 保存数据

# 序列化查询结果集（querysets）
serializers= RequestSerializer(Request.objects.all(),many=True)
print(serializers.data)

from rest_framework import serializers
from sqpt.models import Request, Step, Config, Case


# 请求模型的序列化器
class RequestSerializer(serializers.ModelSerializer):
    class Meta:
        model = Request  # 指定对应的模型
        # 定义可以显示和操作的字段
        fields = ['step', 'method', 'url', 'params', 'headers', 'data', 'json']

# test_serializers.py

# 在测试类中添加代码，查看序列化器的内部结构
print(repr(serializer))

from django.http import HttpResponse, JsonResponse
from django.views.decorators.csrf import csrf_exempt
from rest_framework.parsers import JSONParser
from sqtp.models import Request
from sqtp.serializers import RequestSerializer

def request_list(request):
    if request.method == 'GET':
        serializer= RequestSerializer(Request.objects.all(),many=True)
        # safe=False是为了支持{}以外的python对象转json
        return JsonResponse(serializer.data, safe=False)

from django.urls import path
from sqtp import views

urlpatterns = [
    path('requests/',views.request_list)
]

from django.urls import path,include

urlpatterns = [
    path('',include('sqtp.urls'))
]

from django.http import HttpResponse, JsonResponse
from rest_framework.decorators import api_view
from sqtp.models import Request
from rest_framework.response import Response
from sqtp.serializers import RequestSerializer

@api_view(['GET','POST'])  # 允许的请求方法
def request_list(request, format=None):
    if request.method == 'GET':
        # 构造序列化器
        serializer = RequestSerializer(Request.objects.all(), many=True)
        # 返回 json 格式数据
        # safe=False 是为了支持 {} 以外的 python 对象转 json
        return Response(serializer.data)  # 将 python 原生格式转成 json 数据

@api_view(['GET'])
def request_detail(request, _id, format=None):
    try:
        req_obj = Request.objects.get(id=_id)    # 根据 ID 查找单个数据
    except Exception:
        return Response(status=status.HTTP_404_NOT_FOUND)
    serializer = RequestSerializer(req_obj)
    return Response(serializer.data)

request.POST   # 只处理表单数据 只适用于'POST'方法
request.data   # 处理任意数据 适用于'POST'，'PUT'和'PATCH'方法

return Response(data)     # 渲染成客户端请求的内容类型。

@api_view(['GET'])
def request_list(request,format=None):
    if request.method == 'GET':
        serializer = RequestSerializer(Request.objects.all(), many=True)
        return Response(serializer.data)
    	# safe=False是为了支持{}以外的python对象转json

from django.urls import path
from sqtp import views
from rest_framework.urlpatterns import format_suffix_patterns

urlpatterns = [
    path('requests/',views.request_list)
]
urlpatterns = format_suffix_patterns(urlpatterns)

@api_view(['GET'])
def request_detail(request,_id,format=None):
    """
获取，更新或删除一个req实例。
"""
    try:
        req_obj = Request.objects.get(pk=_id)
        except Request.DoesNotExist:
            return Response(status=status.HTTP_404_NOT_FOUND) # status提供常用http状态
        码
        if request.method == 'GET':
            serializer = RequestSerializer(req_obj)
            return Response(serializer.data)

urlpatterns = [
    path('requests/', views.request_list),
    path('requests/<int:_id>', views.request_detail)
]
urlpatterns = format_suffix_patterns(urlpatterns)