def test_property(self):
head1("准备测试property的序列化")
info("测试用pro")
data = {}
serializer1 = serializers.TestPropertySerializer(data=data)
serializer1.is_valid()
serializer1.save()
def test_local(self):
return
# 别测了. 有bug. 如果你设置user_tz=False, 你就别用timezone参数啊
head1("\n## 测试使用local是的timezone")
data = {'time': '2020-06-10T03:45:13.026Z'} # 当作本地时间的
serializer = serializers.LocalModelSerializer(data=data)
import ipdb
ipdb.set_trace()
serializer.is_valid(raise_exception=True)
info(serializer.validated_data)
return
for data in [
{
'time': '2020-06-10T03:45:13.026Z'
}, # 正常
{
'time': '2020-06-10 03:45:13'
}, # 没有时区,就是正常的
{
'time': '2020-06-10T03:45:13.026+08:00'
}, # 只有这个会转化
{
'time': '2020-06-10T03:45:13.026Z'
} # 当作本地时间的
]:
info("输入: ")
info(data)
serializer = serializers.LocalModelSerializer(data=data)
serializer.is_valid(raise_exception=True)
info(serializer.validated_data)
instance = serializer.save()
info("转化")
info(serializers.LocalModelSerializer(instance).data)
def test_datetime(self):
head1("\n## 测试DateTimeField")
list1("* 准备测试datetime field")
data = {'time': timezone.now(), 'duration': 3600.1}
serializer = serializers.DateTimeModelSerializer(data=data)
serializer.is_valid(raise_exception=True)
info("datetime的对象可以直接当作data传进去")
data = {'time': timezone.now().isoformat(), 'duration': 3600.1}
serializer = serializers.DateTimeModelSerializer(data=data)
serializer.is_valid(raise_exception=True)
info("datetime的国际化时间可以直接传进去")
list1("* 准备测试input_formats")
data = {"time": "2019-01-01", "duration": 3600.1}
serializer = serializers.DateTimeModelSerializer(data=data)
serializer.is_valid(raise_exception=True)
info(serializer.validated_data)
data = {"time": "2019年1月1日", "duration": 3600.1}
serializer = serializers.DateTimeModelSerializer(data=data)
serializer.is_valid(raise_exception=True)
info(serializer.validated_data)
info("可以输入日期格式, 会自动变成local的00点00分00秒")
list1("* 准备测试duration field")
info("duration可以直接传入一个小数，代表多少秒")
serializer.save()
info(serializer.data)
data = {'time': timezone.now(), 'duration': "11 001:2:3.5"}
serializer2 = serializers.DateTimeModelSerializer(data=data)
serializer2.is_valid(raise_exception=True)
serializer2.save()
info("也可以传入符合格式的字符串(前面多写或者少写几个0没关系")
info(serializer2.data)
def test_extra2(self):
head1("## 测试如果meta里面多了不是model的字段怎么办")
info("当前的text数量: {}".format(BasicModel.objects.count()))
instance = BasicModel.objects.create()
serializer = serializers.TestExtraFieldSerializer(instance,
data={
"text": "text",
"num": 123
})
serializer.is_valid(raise_exception=True)
serializer.save()
info(serializer.data) # 会直接返回num
info("现在的text数量: {}".format(BasicModel.objects.count()))
head1("## 那么如果覆盖了save函数怎么办")
info("会报错，因为save已经被覆盖了，所以之后调用save()会报错")
serializer = serializers.TestOverWriteSaveSerializer(
instance, data={
"text": "text_oversave",
"num": 123,
"save": 343
})
serializer.is_valid(raise_exception=True)
# import ipdb
# ipdb.set_trace()
# serializer.save()
info(serializer.data)
def test_user_modal(self):
head1("## 准备测试用户model")
list1("* 测试model的fields username")
user = User.objects.create()
info("直接创建用户成功")
info("用户的username为空字符串")
self.assertEqual(user.username, "")
def test_multichoice_filter(self):
head("# 准备测试multichoice filter")
head1("## 过滤CharField")
models.TestFilter.objects.create(_type="类型1")
fenlei1 = models.BasicModel.objects.create(text="分类1")
fenlei2 = models.BasicModel.objects.create(text="分类2")
fenlei3 = models.BasicModel.objects.create(text="分类3")
instance1 = models.TestFilter.objects.create(_type="类型1")
instance2 = models.TestFilter.objects.create(_type="类型2")
instance3 = models.TestFilter.objects.create(_type="类型3")
instance1.basic_model.add(fenlei1)
instance2.basic_model.add(fenlei2)
instance3.basic_model.add(fenlei3)
client = Client()
info("找到类型1和类型2的")
response = client.get("/testapp/testfilter/?_type=类型1&_type=类型2",
headers={"accept": "application/json"})
info(response.data)
head1("## 过滤ManyToManyField")
response = client.get(
"/testapp/testfilter/?basic_model=1&basic_model=2",
headers={"accept": "application/json"})
info(response.data)
response = client.get(
"/testapp/testfilter/?basic_model=1&basic_model=3",
headers={"accept": "application/json"})
info(response.data)
def test_auth_views(self):
head1("## 准备测试使用auth的view进行登录")
client = APIClient()
response = client.post(
"/account/login/",
data={
"username": "******",
"password": "******"
},
format="json",
)
self.assertEqual(
Token.objects.get(key=response.json()["token"]).user, self.user1)
self.assertIsNotNone(response.cookies.get('sessionid'))
self.assertIsInstance(response.json()["token"], str)
response = client.post(
"/account/login/",
data={
"username": "******",
"password": "******"
},
format="json",
)
self.assertEqual(
Token.objects.get(key=response.json()["token"]).user, self.user2)
def test_null(self):
head1("## 测试Null")
data_list = [
{},
{
"can": ""
},
{
"can": "can"
}, # 有null为null，有blank为""
{
"can": "can",
"can_null": None
},
{
"can": "can",
"can_null": ""
},
{
"can": "can",
"can_blank": None
},
{
"can": "can",
"can_default": ""
},
]
for data in data_list:
serializer = serializers.TestNullSerializer(data=data)
print("准备处理: %s" % data)
if serializer.is_valid(raise_exception=False):
serializer.save()
out.write(style.SUCCESS(serializer.data))
else:
out.write(style.ERROR(serializer.errors))
def test_onetoone_field(self):
head1("\n## 测试OneToOneField")
text = models.BasicModel.objects.create(text="text")
onetoone = models.TestOneToOneField.objects.create(text=text)
text.delete()
# CASCADE null=False|True, 此时可以用text.testonetoonefield 但是调用 text.testonetoonefield.refresh_from_db 就会报错
out.write(style.HTTP_INFO("text已经删除"))
out.write(style.HTTP_INFO(models.TestOneToOneField.objects.all()))
def test_decimal(self):
head1("# 准备测试decimal这个field")
list1("* 测试基础的maxj_digits, decimal_palces超出会怎么样")
data = {"deci": "0.333"}
s = TestDecimalSerializer(data=data)
s.is_valid()
info(s.errors)
info("如果数字数量超出了,会报错, 就算小数位数只有1分,整数部分仍然不能多一位, 反之整数部分小了,小数部分也不能变多")
info("默认不能传入空字符串和None")
def test_path(self):
head1("\n## 测试使用path")
list1("* 测试如果是int的converter遇到")
client = Client()
info("使用负数传入就不支持了")
response = client.get("/testapp/testint/1/")
self.assertEqual(response.resolver_match.kwargs, {"pk": 1})
response = client.get("/testapp/testint/-1/")
self.assertEqual(response.status_code, 200)
def test_template(self):
head1("\n## 测试模板")
list1("* 测试不同的url,的参数的传递")
client = Client()
info("通过request.resolver_match.kwargs可以获取到url里面额外的参数")
response = client.get("/testapp/url/")
self.assertEqual(response.template_name, ["testapp/测试模板.html"])
info("根据这个参数来判断要使用admin的template还是普通的template")
response2 = client.get("/testapp/url2/")
self.assertEqual(response2.template_name, ["testapp/测试模板_admin.html"])
def test_method(self):
head1("## 准备测试method里面的数据")
list1("* 测试如果SerializerMethodField不返回数据会怎么样")
data = {"text": 'text'}
s = serializers.TestMethodSerializer(data=data)
s.is_valid()
s.save()
out.write(style.HTTP_INFO(s.data))
out.write(style.ERROR(s.errors))
return
def test_cache_control(self):
head1("## 准备测试cache_control")
info("不可以使用cache_control来缓存函数")
start = time.time()
service.slow_function(3)
end = time.time()
info("第一次执行`slow_function`的时间: {}".format(end - start))
start = time.time()
service.slow_function(3)
end = time.time()
info("第二次执行`slow_function`的时间: {}".format(end - start))
def setUp(self):
head1("## 准备测试时间的过滤和排序")
self.test_date_list = [
"2018-05-20T23:59:59+08:00", # 2018-05-20T15:59:59+00:00"
"2018-05-21T00:00:00+08:00", # 2018-05-20T16:00:00+00:00"
"2018-05-21T23:59:59+08:00", # 2018-05-21T15:59:59+00:00
"2018-05-22T00:00:00+08:00", # 2018-05-21T16:00:00+00:00
"2018-05-22T00:00:00+00:00", # 2018-05-22T00:00:00+00:00
"2018-05-22T23:00:00+08:00", # 2018-05-22T15:00:00+00:00
]
for date in self.test_date_list:
datetime_obj = DateTimeModel.objects.create(time=date)
info(datetime_obj)
def test_viewset_post(self):
head("# 准备测试ViewSet的post请求")
head1("## 看看post调用的是create还是post")
info("如果是post请求，调用的是create函数")
response = client.post(
"/testapp/testfilter/?format=json",
headers={"accept": "application/json"},
json={
"_type": "类型1"
}
)
info(f"服务器返回的状态码: {response.status_code}")
info(f"服务器返回的状态码: {response.content.decode('UTF-8')}")
def test_auth_views(self):
head1("## 准备测试使用auth的view进行登录")
client = Client()
response = client.post(
"/api-auth/login/",
data={
"username": "******",
"password": "******"
},
header={"content-type": "application/json; charset=utf-8"})
self.assertIsNotNone(response.cookies.get('sessionid'))
response = client.get("/testapp/movie/")
self.assertEqual(response.context['user'], self.user)
response = client.get("/api-auth/logout/", )
self.assertFalse(response.context['user'].is_authenticated)
def test_many(self):
head1("## 准备测试多对多")
list1("* 有数据后批量创建")
BasicModel.objects.create(text='1')
BasicModel.objects.create(text='2')
a = serializers.ManySerializer(data={'texts': ['1', '3']})
a.is_valid(raise_exception=True)
# a.save(texts=[])
a.save()
success("保存成功")
info(a.instance.texts.all())
success("保存后,如果这个text对应id的basicmodel存在,就会添加")
BasicModel.objects.create(text='text')
a.instance.texts.add(*BasicModel.objects.all())
# print(serializers.ManyDetailSerializer(a.instance).data)
list1("* 准备测试空数组的多对多")
b = serializers.ManySerializer(data={'texts': []})
b.is_valid(raise_exception=True)
b.save()
info("保存成功")
def test_datetimefield_filter_date(self):
head1("### 准备测试通过`_date`来过滤时间")
list1("* 普通时间直接过滤2018-05-21")
queryset = DateTimeModel.objects.filter(time__date="2018-05-21")
for instance in queryset:
info(instance)
info("返回了当前时区下时间为2018-05-21的时间")
# new_date = timezone.now() - timezone.timedelta(0, 12*3600)
new_date = timezone.datetime(2018, 5, 21, 23, 0, 0, 0, timezone.utc)
info(new_date)
list2("* utc时间下2018-05-21 23:00:00.date过滤")
date = new_date.date()
info(date)
queryset2 = DateTimeModel.objects.filter(time__date=new_date.date())
for instance in queryset2:
info(instance)
list2("* utc时间下2018-05-21 23:00:00用时间直接过滤")
queryset3 = DateTimeModel.objects.filter(time__date=new_date)
for instance in queryset3:
info(instance)
info("直接输入时间，会先把先把时间转化成本地时区，然后再过滤")
list2("* 当地时区下过滤")
def test_manytomany_field(self):
head1("\n## 测试ManyToManyField")
list1("* 如果symmetrical=True默认")
student = Student.objects.create(name="George")
student2 = Student.objects.create(name="Li Lei")
student3 = Student.objects.create(name="Han Mei")
student2.friends.add(student)
student2.friends.add(student3)
student3.friends.add(student2)
print("student2的好友有:", end=" ")
print(student2.friends.all())
print("认为我是好友的有(只能是一样的):", end=" ")
# print(student2.student_set.all()) 这个会报错
print(student2.friends.all())
list1("* 如果symmetrical=False")
teacher = Teacher.objects.create(name="王主任")
teacher2 = Teacher.objects.create(name="小李主任")
teacher3 = Teacher.objects.create(name="小红主任")
teacher2.teachers.add(teacher)
teacher2.teachers.add(teacher3)
teacher3.teachers.add(teacher)
print("给teacher3指导过的有:", end=" ")
print(teacher3.teachers.all())
print("teacher3指导过的人有:", end=" ")
# import ipdb
# ipdb.set_trace()
print(teacher3.teacher_set.all())
list1("* 检查是否存在")
new_student = Student.objects.create(name="New Student")
print("现在new_student的friends里面有没有George", student
in new_student.friends.all())
result = new_student.friends.add(student)
print("add以后现在new_student的friends里面有没有George", student
in new_student.friends.all())
print("但是add的return: ", result)
head1("ManyToManyField测试完毕")
def test_default(self):
head1("## 测试如果有default会得到什么结果")
for i in [
{},
{
"text": ""
},
{
"text": " "
},
{
"text": None
},
{
"text": "123"
},
]:
serializer = serializers.TestDefaultSerializer(data=i)
info("i= {}".format(i))
if serializer.is_valid():
info("serializer.validated_data: {}".format(
serializer.validated_data))
else:
info("不合法")
def test_datetime_field(self):
head1("\n## 测试和时间有关的Field")
list1("* 测试DurationField")
datetime_obj = models.DateTimeModel.objects.create(time=timezone.now())
info(isinstance(datetime_obj.duration, timedelta))
def test_datetimefield_order(self):
head1("### 准备测试时间的排序")
def test_viewset_permission(self):
head("# 准备测试ViewSet的permission")
head1("## 看看detail的请求时候，permission里面有没有action")
obj = models.BasicModel.objects.create(text="类型1")
res = apiclient.get(
"/testapp/modelviewset/{}/".format(obj.id), format="json")
def test_request_data(self):
head1("准备测试request.data")
list1("* 测试request.data类型,是否可变")
client = Client()
response = client.post("/testapp/basicmodel/", {"text": "text"})
def test_paginator(self):
head1("## 准备测试paginator的函数")
res = apiclient.get("/testapp/paginator/", format="json")
