抽奖系统测试

寻星探路

发布于 2025-12-17 19:36:21

1390

文章被收录于专栏：CSDN博客CSDN博客

一、测试目标的概述

1、项目背景

这是了一款可供企业级的抽奖平台，支持活动创建、人员管理、奖品分配、多轮抽奖流程及实时通知。系统可承载大量的抽奖请求，保障数据一致性与高并发性能，满足企业营销活动需求。

2、项目结构

管理员模块：登录、注册
普通用户模块：用户列表、普通用户注册
奖品模块：奖品列表、奖品创建
活动模块：活动列表、创建活动
抽奖模块：抽奖活动、中奖者页面展示

3.测试环境

操作系统：Windows 11
浏览器：Edge、Chrome
测试工具：Selenium、JMeter、postman

二、测试用例

三、功能测试

1、手动测试

1.1登录页面测试

测试场景一：手机号和密码都为不填预期结果：系统提示手机号、密码为空

测试场景二：手机号填写正确和密码填写正确（手机号格式不正确）预期结果：弹窗提醒“登录失败登录方式不存在”

测试场景三：手机号填写错误和密码填写正确（手机号格式正确）预期结果：弹窗提醒“登录失败用户不存在”

测试场景四：手机号正确，密码错误（密码格式正确）预期结果：弹窗提醒“登录失败密码错误”

测试场景五：手机号正确，密码正确预期结果：跳转到活动中心页

1.2注册管理员用户页面测试

测试场景一：所有都为空预测场景：系统提示为空

测试场景二：邮箱格式错误，其他正确预测场景：系统提示请输入有效的邮箱地址

测试场景三：手机号格式错误，其他正确预测场景：弹窗提醒“注册失败手机号错误”

测试场景四：全部正确预测场景：弹窗“注册成功，点击确定”，成功跳转登录页

1.3用户列表页面测试

测试场景一：点击人员列表预测场景：正常显示人员列表

1.4注册普通用户页面测试

测试场景一：姓名、邮箱和手机号都为空预期结果：系统提示姓名、邮箱、手机号为空

测试场景二：邮箱格式错误，手机号正确填写预期结果：系统提示“请输入有效的邮箱地址”

测试场景三：邮箱格式正确、手机号格式不对预期结果：弹窗提示”手机号格式问题“

测试场景四：全部正确填写预期结果：跳转人员列表

1.5奖品列表页面测试

测试场景一：点击奖品列表预测场景：正常显示奖品列表

1.6创建奖品页面测试

测试场景一：全部空着提交预测场景：弹窗“创建失败”
测试场景二：只填奖品名称、其他不填预测场景：弹窗“创建失败”

测试场景三：只填写奖品名称、奖品图片，其他不填预测场景：弹窗“创建失败”

测试场景四：只填写奖品名称、奖品图片、奖品价格，其他不填预测场景：弹窗“创建失败”

测试场景五：全部正常填写预测场景：弹窗“创建成功”

1.7活动页面测试

测试场景一：点击活动列表预测场景：正常显示活动列表

1.8创建活动页面测试

测试场景一：都空着预测场景：系统提示为空

测试场景二：填写活动名称和奖品描述，未圈选奖品和人员预测场景：弹窗提醒"请至少选择一个奖品"

测试场景三：填写活动名称和奖品描述，圈选奖品，未圈选人员预测场景：弹窗提醒"请至少选择一个人员"

测试场景四：填写活动名称和奖品描述，圈选奖品，圈选人员（圈选人员人数比奖品少）预测场景：弹窗提醒”创建失败！活动关联的奖品及人员数量设置异常“

测试场景五：填写活动名称和奖品描述，圈选奖品，圈选人员（圈选人员人数比奖品多）预测场景：弹窗提示创建成功，跳转活动列表

1.9抽奖页面测试

测试场景一：正常抽奖流程预期结果：展示中奖者名单

1.10中奖者展示页面测试

测试用例一：查看抽奖结束后的名单预期结果：展示名单

2、自动化测试

2.1测试 JWT 密钥生成功能

package com.example.lotterysystem;

import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.io.Encoders;
import io.jsonwebtoken.security.Keys;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.security.Key;

@SpringBootTest
public class JWTTest {

    /**生成密钥*/
    @Test
    public void genKey(){
        // 创建了一个密钥对象，使用HS256签名算法。
        Key key = Keys.secretKeyFor(SignatureAlgorithm.HS256);
        // 将密钥编码为Base64字符串。
        String secretString = Encoders.BASE64.encode(key.getEncoded());
        System.out.println(secretString);
        // 结果：dVnsmy+SIX6pNptQdeclDSJ26EMSPEIhvZYKBTTug4k=
    }

}

2.2加密相关测试

package com.example.lotterysystem;

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.digest.DigestUtil;
import cn.hutool.crypto.symmetric.AES;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.nio.charset.StandardCharsets;

@SpringBootTest
public class EncryptTest {

    // 密码 hash  sha256
    @Test
    void sha256Test() {
        String encrypt =  DigestUtil.sha256Hex("123456789");
        System.out.println("经过sha256 hash 处理后的结果为：" + encrypt);
        //15e2b0d3c33891ebb0f1ef609ec419420c20e320ce94c65fbc8c3312448eb225
    }



    // 手机号 对称加密 aes
    @Test
    void aesTest() {
        // 密钥： 16（128） 24（192） 32（256）
        byte[] KET = "123456789abcedfg".getBytes(StandardCharsets.UTF_8);

        // 加密
        AES aes = SecureUtil.aes(KET);
        String encrypt = aes.encryptHex("123456789");
        System.out.println("经过 aes 加密后的结果为：" + encrypt);
        // 5837c858272b4eb353c461ab902a0601

        // 解密
        System.out.println("经过 aes 解密后的结果为：" + aes.decryptStr(encrypt));
        // 123456789

    }


}

2.3JSON 序列化与反序列化功能

package com.example.lotterysystem;

import com.example.lotterysystem.common.pojo.CommonResult;
import com.example.lotterysystem.common.utils.JacksonUtil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;

@SpringBootTest
public class JacksonTest {



    @Test
    void jacksonTest() {

        ObjectMapper objectMapper = new ObjectMapper();

        CommonResult<String> result = CommonResult.error(500, "系统错误");
        String str;

        // 序列化
        try {
            str = objectMapper.writeValueAsString(result);
            System.out.println(str);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }

        // 反序列化
        try {
            CommonResult<String> readResult = objectMapper.readValue(str,
                    CommonResult.class);
            System.out.println(readResult.getCode() + readResult.getMsg());
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }

        // List 序列化
        List<CommonResult<String>> commonResults = Arrays.asList(
                CommonResult.success("success1"),
                CommonResult.success("success2")
        );
        try {
            str = objectMapper.writeValueAsString(commonResults);
            System.out.println(str);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }

        // List 反序列化
        JavaType javaType = objectMapper.getTypeFactory()
                .constructParametricType(List.class, CommonResult.class);
        try {
            commonResults = objectMapper.readValue(str, javaType);
            for (CommonResult<String> commonResult : commonResults) {
                System.out.println(commonResult.getData());
            }
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }

    }

    @Test
    void JacksonUtilTest() {

        CommonResult<String> result = CommonResult.success("success");
        String str;

        // 序列化
        str = JacksonUtil.writeValueAsString(result);
        System.out.println(str);

        // 反序列化
        result = JacksonUtil.readValue(str, CommonResult.class);
        System.out.println(result.getData());

        // 序列化List
        List<CommonResult<String>> commonResults = Arrays.asList(
                CommonResult.success("success1"),
                CommonResult.success("success2")
        );
        str = JacksonUtil.writeValueAsString(commonResults);
        System.out.println(str);

        // 反序列化List
        commonResults = JacksonUtil.readListValue(str, CommonResult.class);
        for (CommonResult<String> commonResult : commonResults) {
            System.out.println(commonResult.getData());
        }
    }


}

2.4测试邮件发送功能

package com.example.lotterysystem;

import com.example.lotterysystem.common.utils.MailUtil;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class MailTest {

    @Autowired
    private MailUtil mailUtil;

    @Test
    void sendMessage() {
        mailUtil.sendSampleMail("2689241679@qq.com", "标题", "正文");
    }

}

2.5其他相关配置

package com.example.lotterysystem;

import com.example.lotterysystem.controller.param.DrawPrizeParam;
import com.example.lotterysystem.controller.param.ShowWinningRecordsParam;
import com.example.lotterysystem.service.DrawPrizeService;
import com.example.lotterysystem.service.activitystatus.ActivityStatusManager;
import com.example.lotterysystem.service.dto.ConvertActivityStatusDTO;
import com.example.lotterysystem.service.dto.WinningRecordDTO;
import com.example.lotterysystem.service.enums.ActivityPrizeStatusEnum;
import com.example.lotterysystem.service.enums.ActivityStatusEnum;
import com.example.lotterysystem.service.enums.ActivityUserStatusEnum;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@SpringBootTest
public class DrawPrizeTest {

    @Autowired
    private DrawPrizeService drawPrizeService;

    @Autowired
    private ActivityStatusManager activityStatusManager;


    @Test
    void drawPrize() {
//        DrawPrizeParam param = new DrawPrizeParam();
//        param.setActivityId(1L);
//        param.setPrizeId(1L);
//        param.setPrizeTiers("FIRST_PRIZE");
//        param.setWinningTime(new Date());
//        List<DrawPrizeParam.Winner> winnerList = new ArrayList<>();
//        DrawPrizeParam.Winner winner = new DrawPrizeParam.Winner();
//        winner.setUserId(1L);
//        winner.setUserName("xxx");
//        winnerList.add(winner);
//        param.setWinnerList(winnerList);
//        drawPrizeService.drawPrize(param);

        // 1、正向流程
        // 2、处理过程中发生异常：回滚
        // 3、处理过程中发生异常：消息堆积-》处理异常-》消息重发
        DrawPrizeParam param = new DrawPrizeParam();
        param.setActivityId(25L);
        param.setPrizeId(19L);
        param.setWinningTime(new Date());
        List<DrawPrizeParam.Winner> winnerList = new ArrayList<>();
        DrawPrizeParam.Winner winner = new DrawPrizeParam.Winner();
        winner.setUserId(45L);
        winner.setUserName("杨康");
        winnerList.add(winner);
        param.setWinnerList(winnerList);
        drawPrizeService.drawPrize(param);

    }

    @Test
    void statusConvert() {

        ConvertActivityStatusDTO convertActivityStatusDTO = new ConvertActivityStatusDTO();
        convertActivityStatusDTO.setActivityId(24L);
        convertActivityStatusDTO.setTargetActivityStatus(ActivityStatusEnum.COMPLETED);
        convertActivityStatusDTO.setPrizeId(19L);
        convertActivityStatusDTO.setTargetPrizeStatus(ActivityPrizeStatusEnum.COMPLETED);
        List<Long> userIds = Arrays.asList(45L);
        convertActivityStatusDTO.setUserIds(userIds);
        convertActivityStatusDTO.setTargetUserStatus(ActivityUserStatusEnum.COMPLETED);
        activityStatusManager.handlerEvent(convertActivityStatusDTO);

    }

    @Test
    void saveWinningRecords(){
        DrawPrizeParam param = new DrawPrizeParam();
        param.setActivityId(24L);
        param.setPrizeId(19L);
        param.setWinningTime(new Date());
        List<DrawPrizeParam.Winner> winnerList = new ArrayList<>();
        DrawPrizeParam.Winner winner = new DrawPrizeParam.Winner();
        winner.setUserId(45L);
        winner.setUserName("杨康");
        winnerList.add(winner);
        param.setWinnerList(winnerList);
        drawPrizeService.saveWinnerRecords(param);
    }


    @Test
    void showWinningRecords() {
        ShowWinningRecordsParam param = new ShowWinningRecordsParam();
        param.setActivityId(25L);
        param.setPrizeId(18L);
        List<WinningRecordDTO> list = drawPrizeService.getRecords(param);
        for (WinningRecordDTO dto : list) {
            // 中奖者_奖品_等级
            System.out.println(dto.getWinnerName()
                    + "_" + dto.getPrizeName()
                    + "_" +dto.getPrizeTier().getMessage());
        }
    }


}

package com.example.lotterysystem;

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class LogTest {
    private final static Logger logger = LoggerFactory.getLogger(LogTest.class);

    @Test
    void logTest() {
        System.out.println("hello world");
        logger.info("hello world");
    }

}

package com.example.lotterysystem;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class LotterySystemApplicationTests {

	@Test
	void contextLoads() {
	}

}

package com.example.lotterysystem;

import com.example.lotterysystem.common.utils.RedisUtil;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;

@SpringBootTest
public class RedisTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisUtil redisUtil;


    @Test
    void redisTest() {
        stringRedisTemplate.opsForValue().set("key1", "value1");
        System.out.println("从redis获取值" +  stringRedisTemplate.opsForValue().get("key1"));
    }

    @Test
    void redisUtil() {
        redisUtil.set("key2", "value2");
        redisUtil.set("key3", "value3", 60L);
        System.out.println("has key2:" + redisUtil.hasKey("key2"));
        System.out.println("has key3:" + redisUtil.hasKey("key3"));
        System.out.println("key2:" + redisUtil.get("key2"));
        System.out.println("key3:" + redisUtil.get("key3"));
        redisUtil.del("key2");
        System.out.println("has key2:" + redisUtil.hasKey("key2"));
        System.out.println("has key3:" + redisUtil.hasKey("key3"));
    }


}

package com.example.lotterysystem;

import com.example.lotterysystem.common.utils.JacksonUtil;
import com.example.lotterysystem.dao.dataobject.Encrypt;
import com.example.lotterysystem.dao.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;

@SpringBootTest
public class SqlTest {

    @Autowired
    private UserMapper userMapper;


    @Test
    void mailCount() {
        int count = userMapper.countByMail("123@qq.com");
        System.out.println("mailCount=" + count);
    }

    @Test
    void phoneCount() {
        int count = userMapper.countByPhone(new Encrypt("13111111111"));
        System.out.println("phoneCount=" + count);
    }

}

package com.example.lotterysystem;

import com.example.lotterysystem.service.UserService;
import com.example.lotterysystem.service.dto.UserDTO;
import com.example.lotterysystem.service.enums.UserIdentityEnum;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;


@SpringBootTest
public class UserTest {

    @Autowired
    private UserService userService;

    @Test
    void findBaseUserList() {

        List<UserDTO> userDTOList = userService.findUserInfo(UserIdentityEnum.ADMIN);
        for (UserDTO userDTO : userDTOList) {
            System.out.println(userDTO.getUserId() + " " + userDTO.getUserName() + " " + userDTO.getIdentity().name());
        }
    }

}