平台数据模型设计

一、 数据库配置

1. 搭建 MySQL 数据库

数据库搭建(🚀CentOS 8 搭建 MySQL 8)

2. 创建数据库

1
CREATE DATABASE `course_autotp` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

3. 安装 pymysqlclient 模块

1
2
3
# 链接 mysql 数据库需要此模块,此模块安装不了的,参考附录的方法

pip install mysqlclient

4. 配置 数据库参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'course_autotp', # 数据库名称
'USER': 'root', # 用户名
'PASSWORD': 'xxxx', # 密码
'HOST': '158.247.205.137',
'PORT': '3306',
'TEST': {
'CHARSET': 'utf8', # 数据库的编码配置
'COLLATION': 'utf8_general_ci',
}
}
}

二、 数据库设计

1. 一对一 关系

1对1就是1个模型关联另一个模型,他们之间的关系是1对1

一对一关联与多对一关联非常类似。若在模型中定义了 OneToOneField ,该模型的实例只需通过其属
性就能访问关联对象

1
2
3
4
5
6
class EntryDetail(models.Model):
entry = models.OneToOneField(Entry, on_delete=models.CASCADE)
details = models.TextField()

ed = EntryDetail.objects.get(id=2)
ed.entry # Returns the related Entry object.

不同点在于 “反向” 查询。一对一关联所关联的对象也能访问 Manager 对象,但这个 Manager 仅代表
一个对象,而不是对象的集合(QuerySet):

1
2
e = Entry.objects.get(id=2)
e.entrydetail # returns the related EntryDetail object

若未为关联关系指定对象,Django 会抛出 DoesNotExist 异常。

实例能通过为正向关联指定关联对象一样的方式指定给反向关联:

1
e.entrydetail = ed

2. 模型代码设计

其中,request,step和config参考HR对应部分的字段,由于其中会出现很多嵌套字段,所以1层的字段
就用json数据类型来代替

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
from django.db import models


class Config(models.Model):
name = models.CharField('名称', max_length=128)
# 可 null 可空白
base_url = models.CharField('IP/域名', max_length=512, null=True, blank=True)
variables = models.JSONField('变量', null=True)
parameters = models.JSONField('参数', null=True) # 用于参数化
verify = models.BooleanField('https校验', default=False)
export = models.JSONField('用例返回值', null=True)
def __str__(self):
return self.name


class Step(models.Model):
# 同模型中,两个字段关联一个模型时,需要指定 related_name, 且名字不能相同
# 属于哪个用例
belong_case = models.ForeignKey('Case', on_delete=models.CASCADE, related_name='test_steps')
# 引用那条用例
linked_case = models.ForeignKey('Case', on_delete=models.SET_NULL, null=True, related_name='linked_steps')
name = models.CharField('名称', max_length=128)
variables = models.JSONField('变量', null=True)
extract = models.JSONField('请求返回值', null=True)
validate = models.JSONField('校验项', null=True)
setup_hooks = models.JSONField('初始化', null=True)
teardown_hooks = models.JSONField('清除', null=True)
def __str__(self):
return self.name


class Request(models.Model):
method_choices = ( # method 可选字段, 二维元组
(0, 'GET'), # 参数 1 : 保存在数据库中的值 ,参数 2 : 对位显示的值
(1, 'POST'),
(2, 'PUT'),
(3, 'DELETE'),
)
step = models.OneToOneField(Step, on_delete=models.CASCADE, null=True, , related_name='testrequest')
method = models.SmallIntegerField('请求方法', choices=method_choices, default=0)
url = models.CharField('请求路径', default='/', max_length=1000)
params = models.JSONField('url参数', null=True)
headers = models.JSONField('请求头', null=True)
cookies = models.JSONField('cookies', null=True)
data = models.JSONField('data参数', null=True)
json = models.JSONField('json参数', null=True)
def __str__(self):
return self.url


class Case(models.Model):
config = models.OneToOneField(Config, on_delete=models.DO_NOTHING)
suite = models.ForeignKey('Suite', on_delete=models.DO_NOTHING, null=True)
file_path = models.CharField('用例文件路径', max_length=1000, default='demo_case.json')
def __str__(self):
return self.config.name


class Suite(models.Model):
config = models.OneToOneField(Config, on_delete=models.DO_NOTHING)
file_path = models.CharField('套件文件路径', max_length=1000, default='demo_suite.json')
def __str__(self):
return self.config.name

3. 同步数据库

生成 数据库 同步 文件

1
python manage.py makemigrations

同步数据库

1
python manage.py migrate

三、 反向查询概念解析

1. 正向查询

模型查询其关联的项目叫做正向查询(外键定义在模型)

例如:步骤查询其所在的用例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# test.py

class TestRelatedQuery(TestCase):
def setUp(self) -> None:
# 创建套件和用例
self.config = Config.objects.create(name='用例1')
self.case = Case.objects.create(config=self.config)

self.config_suite = Config.objects.create(name='套件1')
self.suite = Suite.objects.create(config=self.config_suite)

def test_case_suite(self):
# 用例关联套件
self.case.suite = self.suite
# 保存数据库
self.case.save()
print(self.case.suite) # 正向查询-- 查询所属套件
print(self.case.config) # 正向查询 -- 查询配置

2. 反向查询

反过来,项目查询下面的模型叫做反向查询,通过反向查询的结果QuerySet

  • 未指定 related_name 时

    • 多对多 或 多对一

      modelobj.field_set.all()

    • 一对一

      modelobj.field

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class TestRelatedQuery(TestCase):
def setUp(self) -> None:
# 创建套件和用例
self.config = Config.objects.create(name='用例1')
self.case = Case.objects.create(config=self.config)
self.config_suite = Config.objects.create(name='套件1')
self.suite = Suite.objects.create(config=self.config_suite)

def test_case_suite(self):
self.case.suite = self.suite # 用例关联套件
self.case.save() # 保存数据库

# 反向查询 --- 多对一 或 多对多
# 套件查询关联的用例 --- 数据对象.多方属性_set.all() --- 返回的是 QuerySet(查询集)
print(self.suite.case_set.all())

# 反向查询 --- 一对一
# 配置对应的用例 --- 数据对象.反向关系模型小写
print(self.config.case)

方式2:指定related_name时

modelobj.related_name.all()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class TestRelatedQuery(TestCase):
def setUp(self) -> None:
# 创建套件和用例
self.config = Config.objects.create(name='用例1')
self.case = Case.objects.create(config=self.config)

self.config_suite = Config.objects.create(name='套件1')
self.suite = Suite.objects.create(config=self.config_suite)

def test_step_case(self):
self.step = 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')
# 多对多 反向查询
print(self.case.test_steps.all())

def test_step_request(self):
self.step = Step.objects.create(belong_case=self.case, name='步骤1')
self.request = Request.objects.create(url='/demo/example', step=self.step)

# 一对一 关系反向查询
print(self.step.testrequest)

四、 json 字段操作

1、 增

1
2
3
4
5
6
class TestJsonOperate(TestCase):
def test_add(self):
req1 = Request.objects.create(url='/demo1', data={'name': '小明', 'age': '18', 'addr': '新世纪大道'})
print(req1.data)
req2 = Request.objects.create(url='/demo1', params={'name': '小明', 'age': '18', 'addr': '新世纪大道'})
print(req2.params)

2. 改

1
2
3
4
5
6
7
8
9
10
11
12
def test_update(self):
req1 = Request.objects.create(url='/demo1', data={'name': '小明', 'age': '18', 'addr': '新世纪大道'})

# 整体修改
req1.data = {'city': 'beijing'}
req1.save()
print(req1.data)

# 局部修改
req1.data['name'] = '小红'
req1.save()
print(req1.data)

3. 删

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def test_delete(self):
req1 = Request.objects.create(url='/demo1', data={'name': '小明', 'age': '18', 'addr': '新世纪大道'})
req1.data = None # sql 的 none
req1.save()
print(req1.data)
# 查询的时候关系 字段 等于 sql 的 null
res = Request.objects.filter(data__isnull=True)
print(res)

req1.data = Value('null') # json 的 none
req1.save()
# 查询的关系 字段 等于 json 的 null
res = Request.objects.filter(data=None)
print(res)

4. 查

1
2
3
4
def test_query(self):
req1 = Request.objects.create(url='/demo1', data={'name': '小明', 'age': '18', 'addr': '新世纪大道','father':{'age':40}})
res = Request.objects.filter(data__father__age=40)
print(res)