性能测试基础数据准备

根据我们测试系统的不同，准备测试数据大概分为这么几类
1、数据库铺底数据
2、待上传的文件

1 数据库铺底数据

数据库铺底数据可以分为这么几种情况
1、需要我们插入的
2、需要之前业务跑进去之后，我们拿出来用的

1.1 需要插入数据库的

如果是mysql数据库，可以参考另一篇文章，采用批量操作+事务的方式 插入大量数据
大量插入mysql数据

1.2 需要我们从数据库拿出来用的

这时候，我们可以直接把需要的字段从数据库拷贝出来存到txt中，lr或者jmeter读取就可以
但是，当数据量到了几十万、上百万，存到文件显得太笨了
这里提供一种解决方案：
修改数据库中需要拿出来的字段的值为连续递增的值，在lr中使用unique number，在jmeter中使用计数器即可
如何批量修改字段的值为递增的呢？
如下：

set @id=1024000000;
UPDATE contract_info set id =( select @id := @id +1 as nid),
user_account='19900000000',
user_id='19900000000',
present_user_id='19900000000'
where contract_name ='测试合同添加到草稿箱' and `status` ='drafts';

2 准备待上传的文件

测试文件服务，我们需要准备文件
这里，有个问题，一般文件服务都会对上传的文件进行md5校验，如果相同，不写磁盘，直接添加软连接
所以，我们这里有两种处理方案

1. 找开发把md5校验去掉，每次都传相同的文件
2. 自己生成不同的文件

如果是第一种情况，可以略过了
现在说自己生成不同的文件，python是个好东西，有很多开箱即用的模块，导入用起来

2.1 批量生成docx、xls、pptx、png

批量生成docx文件
批量生成xls文件
批量生成pptx文件
批量生成png文件

首先，需要有一个源文件，然后就可以生成了
添加共享锁，避免出现生成多个文件添加的水印等内容一样，造成md5重复的问题
代码如下：

# -*- encoding: utf-8 -*-
import threading
from docx import Document
import xlrd
from xlutils.copy import copy
from pptx import Presentation
from PIL import Image, ImageDraw, ImageFont

"""
    通过一个源文件，生成n多个文件，每个文件md5不同
    支持docx、xls、pptx、png
    10个线程并发，提高生成速度
"""


def start(type):

    if type == "docx":
        document = Document(filepath + source_file)  # 打开源文件
        for i in range(10):
            t = threading.Thread(target=create_docx, args=(document, i,))
            t.start()
    elif type == "xls":
        for i in range(10):
            t = threading.Thread(target=create_xls, args=(i,))
            t.start()
    elif type == "pptx":
        prs = Presentation(filepath + source_file)  # 打开源文件
        for i in range(10):
            t = threading.Thread(target=create_pptx, args=(prs, i,))
            t.start()
    elif type == "png":
        for i in range(10):
            # t = threading.Thread(target=create_png, args=(i,))
            t = threading.Thread(target=add_text_to_image, args=(i,))
            t.start()


def create_docx(document, i):
    # 开始循环
    for j in range(block):
        p = document.paragraphs[-1].clear()  # 删掉最后一个段落
        # 添加最后一个段落XXXX:        i
        mutex_lock.acquire()
        p.add_run("XXXX:        " + str(i * block + j))
        document.save(filepath + str(i * block + j) + ".docx")  # 保存文档
        mutex_lock.release()


def create_xls(i):
    # 打开excel源文件
    old_excel = xlrd.open_workbook(
        filepath + source_file, formatting_info=True)
    # 将操作文件对象拷贝，变成可写的workbook对象
    new_excel = copy(old_excel)
    # 获得第一个sheet的对象
    ws = new_excel.get_sheet(0)
    for j in range(block):
        # 写入数据
        mutex_lock.acquire()
        ws.write(0, 0, i * block + j)
        # 另存为excel文件，并将文件命名，可以重新命名，应该也可以覆盖掉
        new_excel.save(filepath + str(i * block + j) + ".xls")
        mutex_lock.release()


def create_pptx(prs, i):
    slide1 = prs.slides[0]
    for j in range(block):
        mutex_lock.acquire()
        slide1.shapes.title.text = "第" + str(i * block + j) + "个pptx"
        prs.save(filepath + str(i * block + j) + ".pptx")
        mutex_lock.release()


# 废弃
def create_png(i):
    source_image = Image.open(filepath + source_file)  # 打开源文件
    for j in range(block):
        mutex_lock.acquire()
        size = 500 + i * block + j
        source_image.resize((size, size), Image.ANTIALIAS).save(
            filepath + str(i * block + j) + ".png"
        )
        mutex_lock.release()


def add_text_to_image(i):
    for j in range(block):
        img = Image.open(filepath + source_file)
        # 创建一个可以在给定图像上绘图的对象
        draw = ImageDraw.Draw(img)
        mutex_lock.acquire()
        # 绘制文本
        draw.text(
            (50, 100), str(i * block + j), (255, 0, 0),
            font=fontStyle
        )
        img.save(filepath + str(i * block + j) + ".png")
        mutex_lock.release()


if __name__ == "__main__":
    mutex_lock = threading.Lock()

    # 想要生成的文件数量
    file_count = 1000
    # 计算单个线程需要循环多少次
    block = file_count // 10

    # docx
    # filepath = 'F:\\docx2\\'
    # source_file = 'abc.docx'
    # start("docx")

    # xls
    # filepath = "F:\\xls2\\"
    # source_file = "abc.xls"
    # start("xls")

    # pptx
    # filepath = 'F:\\pptx2\\'
    # source_file = 'abc.pptx'
    # start("pptx")

    # 加水印方式生成png
    # 字体的格式 这里的simsun.ttf需要有这个字体
    fontStyle = ImageFont.truetype("simsun.ttc", 25, encoding="utf-8")
    filepath = "F:\\image2\\"
    source_file = 'origin.png'
    start("png")

2.2 批量生成指定大小的文件

我们可以直接造文本文件或者二进制文件
二进制文件生成速度非常快，文本文件相对较慢
直接上代码

'''
将改文件保存为genFile.py，在cmd中执行python genFile.py即可
'''
import os, sys
import random
import string


def createfile(filePath, fileSize, count, type):
    """批量生成文件

        Args:
            filePath: 存储生成文件的保存路径
            fileSize: 单个文件的大小，1024为1KB，1024*1024为1MB。。。
            count: 生成文件的数量
            type：文件类型
                b：二进制文件，生成速度超快
                s：普通文件，生成速度较慢

        Returns:

        Raises:

        """
    flag = False
    s = string.ascii_lowercase
    px = random.choice(s) + random.choice(s)
    for i in range(count):
        filename = os.path.join(filePath, px + str(i)+'.txt')
        if type == 'b':
            with open(filename, 'wb') as f:
                f.write(os.urandom(fileSize))
            flag = True
        elif type == 's':
            c_size = 0
            with open(filename, 'w', encoding='utf8') as f:
                while c_size < fileSize:
                    f.write(str(round(random.uniform(-1000, 1000), 2)))
                    f.write('\n')
                    c_size = os.path.getsize(filename)
            flag = True
    if flag:
        print('文件生成成功，文件名称为%s开头' % px)
    else:
        print('生成文件失败~~~~')


# print(len(sys.argv))
if len(sys.argv) < 5:
    print("命令格式如下：")
    print("python genFile.py fileType fileSize fileSizeUnit fileCount [filePath]")
    print("例如：生成10个500KB的二进制文件，存储到F盘的bbb文件夹中")
    print("python genFile.py b 500 k 10 F:\\bbb")
    sys.exit(1)
else:
    size = int(sys.argv[2])
    unit = sys.argv[3][0].lower()
    count = int(sys.argv[4])

    # 如果用户未输入保存目录
    if len(sys.argv) < 6:
        filePath = os.path.abspath(os.path.curdir)
    else:  # 如果输入了，判断目录是否存在
        if os.path.exists(sys.argv[5]):
            filePath = sys.argv[5]
        else:
            os.makedirs(sys.argv[5])
            filePath = sys.argv[5]

    sm = {'b': 1, 'k': 1024, 'm': 1024 * 1024, 'g': 1024 * 1024 * 1024, 't': 1024 * 1024 * 1024 * 1024}

    # 判断文件类型是否合法
    if sys.argv[1] == 'b' or sys.argv[1] == 's':
        createfile(filePath, size * sm[unit], count, sys.argv[1])
    else:
        print('文件类型无效，请检查')

2.3 计算文件md5

既然已经生成了文件，而且我们的要求是md5不相同，那么我们需要计算出我们生成的所有文件的md5，并且统计是否存在重复的情况。
计算md5脚本如下：

# -*- coding: utf-8 -*-

import hashlib
import os


def get_file_md5(file_name):
    """
    计算文件的md5
    :param file_name:
    :return:
    """
    m = hashlib.md5()  # 创建md5对象
    with open(file_name, 'rb') as fobj:
        while True:
            data = fobj.read(4096)
            if not data:
                break
            m.update(data)  # 更新md5对象

    return m.hexdigest()  # 返回md5对象


def get_str_md5(content):
    """
    计算字符串md5
    :param content:
    :return:
    """
    m = hashlib.md5(content)  # 创建md5对象
    return m.hexdigest()


def collect_songs(fidir, file_type):
    musics = []
    for root, dirs, files in os.walk(fidir):
        for file in files:
            if file.endswith(file_type):
                file = os.path.join(root, file)
                musics.append(file)
    return musics


files = collect_songs("F:\\image2", 'png')
# print(files)

f = open('md5.txt', 'w')

for i in files:
    md5_v = get_file_md5(i)
    f.write(md5_v + "  " + i + '\n')
f.close

生成的md5.txt在当前目录下，我们需要打开cmder的shell，通过以下命令进行排序、去重、计数，命令如下：

cat E:\\pyworkspace\\test\\md5.txt |awk '{print $1}'|sort|uniq -c |sort > 123.txt

打开当前目录下的123.txt，查看第一列是不是都是1，如果不是代表md5.txt中存在多个重复的值，也就是生成的文件有重复的。