软件测试-单元测试
软件测试
单元测试报告
班级:信2205-2班
姓名:乔国峰
产品名称: 超市管理系统 |
产品部门: |
版本号 :1.0 |
语 种: 中文 |
开发工具:idea |
测试工具:juint4 |
测试人员: 乔国峰 |
测试时间:2025.5.30 |
测试要求: 1.确保各模块功能正常运行 2.覆盖核心业务流程 3.验证边界条件和异常处理 |
|
测试内容: 本次测试包含以下模块: 1.商品分类 2.供应商管理 3.销售统计 4.结算服务 5.用户管理 6.商品库存 |
单元测试方案
模块功能 |
本模块实现了商品管理系统的核心服务层功能,包括用户管理、商品分类管理、商品管理等功能。 |
||
现有资源 |
模块1 |
GroupService.java - 商品分类管理 |
|
模块2 |
ProviderService.java - 供应商管理 |
||
模块3 |
SaleService.java - 销售管理 |
||
模块4 |
ProductService.java - 商品管理 |
||
模块5 |
UserService.java - 用户管理 |
||
程序结构 |
功能点 |
涉及的方法 |
|
商品分类管理 |
方法1:List<Group> getAllGroups(); 功能说明:获取所有商品分类信息用于页面的展示 输出:输出所有商品分类的集合 异常:输出空的字符串
方法2:int addGroup(Group group); 功能说明:添加商品分类 参数描述:group:商品类别的实体类 输出:影响的行数 异常:输出0 流程:将输入的商品分类添加到数据库 方法3: Group getGroupByGroupId(Integer id); 功能说明:添加商品分类 参数描述:id:商品对应的id; 输出:商品类实体 异常:输出空的字符串 流程:根据输入的id输出对应的商品类实体
方法4: int updateGroup(Group group) 功能说明:修改商品分类信息 参数描述:group:商品类别的实体类; 输出:影响的行数 异常:输出0 流程:输入实体类,在数据库修改数据;
方法5:int deleteGroupById(Integer id); 功能说明:根据id删除商品分类信息 参数描述:id:商品类的id 输出:影响的行数 异常:输出0 流程:根据输入的id删除对应的商品分类 |
||
供应商管理 |
方法1:List<Provider> getAllProviders(); 功能说明:获取所有供应商 参数描述: 输出:供应商实体类的集合 异常:输出空的字符串 流程:输出所有的供应商
方法2:List<Product> getProviderRecordsByProviderId(Integer providerId); 功能说明:根据供应商id查询出该供应商供应的商品 参数描述: providerId :供应商所对应的id 输出:供应商对应的所有商品集合 异常:输出空的字符串 流程:根据供应商的id查询所对应的商品
方法3:Provider getProviderByProviderId(Integer providerId) 功能说明:根据供应商id查询出该供应商实体 参数描述: providerId :供应商所对应的id 输出:供应商实体 异常:输出空的字符串 流程:根据id查询对应的供应商
方法4:List<Provider> getProviderByProviderPhoneNumber(String phoneNumber); 功能说明:根据供应商联系人电话号码查询出该供应商 参数描述: phoneNumber:供应商所对应的电话号码 输出:供应商实体 异常:输出空的字符串 流程:根据电话号码查询对应的供应商
方法5:int deleteProviderByProviderId(Integer providerId); 功能说明:根据供应商id删除供应商 参数描述:providerId:供应商所对应的id 输出:影响行数 异常:输出0 流程:根据输入的id删除对应的供应商
方法6:int addProvider(Provider provider); 功能说明:添加供应商 参数描述: provider:供应商实体类 输出:影响行数 异常:输出0 流程:根据电话号码查询对应的供应商
方法7:int updateProvider(Provider provider); 功能说明:修改供应商 参数描述: provider:供应商实体类 输出:影响行数 异常:输出0 流程:将输入的供应商在数据库修改
|
||
销售管理 |
方法1:int insertSaleItem(Integer productId, Integer saleCount); 功能说明:增加一条销售记录 参数描述:productId:商品id saleCount:售出数量 输出:影响行数 异常:输出0 流程:根据id和销售数量数据库添加一条销售记录
方法2: List<Sale> getSaleInfoByCondition(Integer groupId, String startDate, String endDate); 功能说明:用于根据条件展示销售信息 参数描述:productId:商品id startDate:搜索开始时间 endDate:搜索结束时间 输出:销售记录集合 异常:输出空字符串 流程:根据输入的数据查询销售记录
|
||
商品管理 |
方法1: List<Product> getAllProducts(); 功能说明:获取所有商品信息 参数描述: 输出:商品信息的集合 异常:输出空字符串 流程:输出所有的商品信息
方法2:Product getProductByProductName(String productName); 功能说明:获取所有商品信息 参数描述:productNamea:商品名称 输出:商品信息的实体 异常:输出空字符串 流程:根据商品名称查询对应的商品信息
方法3: int addProduct(Product product); 功能说明:新增商品信息 参数描述:product:商品实体 输出:影响行数 异常:输出空字符串 流程:将输入的商品信息添加到数据库
方法4:float getProductSalePriceByProductId(Integer id); 功能说明:根据商品的编号获取到该商品的价格 参数描述: id:商品的 id 输出:商品的价格 异常:输出空字符串 流程:根据输入的商品id查询对应的价格
方法5:Check getProductByProductIdToCheckService(Integer productId); 功能说明:根据商品id查询商品的信息之后封装到Check的TO类中, 用于结算服务显示 参数描述: productId:商品的 id 输出:商品的结算实体类Check 异常:输出空字符串 流程:输出商品的结算信息
方法6: int deleteProductByProductId(Integer productId); 功能说明:按照商品id删除商品 参数描述: productId:商品的 id 输出:影响行数 异常:输出0 流程:根据输入的id删除对应的商品
方法7:int updateProductByProductId(Product product); 功能说明: 按照商品id修改商品 参数描述:product:商品的实体信息 输出:影响行数 异常:输出0 流程:根据输入的商品信息修改对应id的商品信息
方法8: Product getProductByProductId(Integer productId); 功能说明: 按照商品id修改商品 参数描述:productId:商品的Id 输出:商品实体类 异常:输出空字符串 流程:根据输入的商品id输出对应的商品信息
方法9:List<Product>getProductByProductNameOrProductGroup(string productName,Integer groupId); 功能说明:用于搜索显示, 根据商品名称查询后显示 参数描述:productId:商品的Id productName:商品的名称 输出:商品实体类的集合 异常:输出空字符串 流程:根据输入的商品id和商品名称查询出对应的商品信息。
方法10:int updateProductStock(Integer productId, Integer saleCount); 功能说明: 更新id对应的商品库存 参数描述:productId:商品的Id saleCount:销售的数量 输出:影响行数 异常:输出0 流程:根据商品id修改商品对应的库存
方法11: int updateProductStockPlus(Integer productId, Integer saleCount, Integer stock);
功能说明: 更新id对应的商品库存 参数描述:productId:商品的Id saleCount:出售数量 Stock:库存 输出:影响行数 异常:输出0 流程:根据商品id更新商品对应的库存
|
||
用户管理 |
方法1:User getUserByUsername(String username); 功能说明: 用于登录验证, 根据输入的用户名去数据库查询返回该用户用于对比 参数描述:username:用户名 输出:用户信息实体 异常:输出空字符串 流程:根据输入的用户名去数据库查询返回该用户用于对比 返回用户实体
方法2: List<User> getAllUser(); 功能说明:获取系统所有用户, 用于页面显示 参数描述: 输出:用户信息实体的集合 异常:输出空字符串 流程:返回所有用户的信息
方法3: int addUser(User user); 功能说明:添加用户 参数描述:user:用户实体信息 输出:影响行数 异常:输出0 流程:将用户数据添加到数据库然后返回影响行数
方法4: int resetAllPassword() 功能说明:重置所有用户的密码 参数描述: 输出:影响行数 异常:输出0 流程:将所有用户的密码重置为123456;
方法5: int resetPasswordByUserId(Integer id); 功能说明:按照用户id重置某一用户密码 参数描述:id:用户id 输出:影响行数 异常:输出0 流程:将用户的id重置
方法6: int resetPasswordByUserId(Integer id); 功能说明:按照用户id删除某一用户 参数描述:id:用户id 输出:影响行数 异常:输出0 流程:将用户的id删除用户信息
方法7: int updatePassword(Integer id, String password); 功能说明:修改密码 参数描述:id:用户id Password:用户密码 输出:影响行数 异常:输出0 流程:根据id修改用户的密码
方法8: List<User> getAllAdmin(); 功能说明:获取当前系统中所有的管理员账户信息 参数描述: 输出:用户信息实体类的集合 异常:输出空字符串 流程:返回所有的管理员账户信息
方法8: User getUserByUserId(Integer id); 功能说明:根据用户id获取用户 参数描述:id:用户的id 输出:用户信息实体 异常:输出空字符串 流程:返回对应id的用户信息
|
||
测试用例 |
测试功能点 |
用例描述 |
用例测试结果 |
商品分类管理 |
public class GroupServiceTest {
@Autowired private GroupService groupService;
private Group testGroup;
@Before public void setUp() { // 初始化测试数据 testGroup = new Group(); testGroup.setGroupName("测试分类"); }
@Test public void testGetAllGroups() { // 测试获取所有商品分类 List<Group> groups = groupService.getAllGroups(); assertNotNull("获取的商品分类列表不应为空", groups); assertFalse("获取的商品分类列表不应为空", groups.isEmpty()); }
@Test public void testAddGroup() { // 测试添加商品分类 int result = groupService.addGroup(testGroup); assertTrue("添加商品分类应该成功", result > 0); }
@Test public void testGetGroupByGroupId() { // 先添加一个测试分类 groupService.addGroup(testGroup);
// 获取所有分类 List<Group> groups = groupService.getAllGroups(); Group addedGroup = groups.get(groups.size() - 1);
// 测试根据ID获取分类 Group foundGroup = groupService.getGroupByGroupId(addedGroup.getId()); assertNotNull("根据ID获取的分类不应为空", foundGroup); assertEquals("分类名称应该匹配", testGroup.getGroupName(), foundGroup.getGroupName()); }
@Test public void testUpdateGroup() { // 先添加一个测试分类 groupService.addGroup(testGroup);
// 获取所有分类 List<Group> groups = groupService.getAllGroups(); Group addedGroup = groups.get(groups.size() - 1);
// 修改分类名称 String newName = "更新后的分类名称"; addedGroup.setGroupName(newName);
// 测试更新分类 int result = groupService.updateGroup(addedGroup); assertTrue("更新商品分类应该成功", result > 0);
// 验证更新结果 Group updatedGroup = groupService.getGroupByGroupId(addedGroup.getId()); assertEquals("分类名称应该已更新", newName, updatedGroup.getGroupName()); }
@Test public void testDeleteGroupById() { // 先添加一个测试分类 groupService.addGroup(testGroup);
// 获取所有分类 List<Group> groups = groupService.getAllGroups(); Group addedGroup = groups.get(groups.size() - 1);
// 测试删除分类 int result = groupService.deleteGroupById(addedGroup.getId()); assertTrue("删除商品分类应该成功", result > 0);
// 验证删除结果 Group deletedGroup = groupService.getGroupByGroupId(addedGroup.getId()); assertNull("删除后的分类应该不存在", deletedGroup); } } |
通过 |
|
供应商管理 |
public class ProviderServiceTest {
@Autowired private ProviderService providerService;
private Provider testProvider;
@Before public void setUp() { // 初始化测试数据 testProvider = new Provider(); testProvider.setProviderName("测试供应商"); testProvider.setProviderContact("测试联系人"); testProvider.setContactPhone("13800138000"); testProvider.setProviderAddress("测试地址"); }
@Test public void testGetAllProviders() { // 先添加测试供应商 providerService.addProvider(testProvider);
// 测试获取所有供应商 List<Provider> providers = providerService.getAllProviders(); assertNotNull("获取的供应商列表不应为空", providers); assertFalse("供应商列表不应为空", providers.isEmpty());
// 验证新添加的供应商是否在列表中 boolean found = false; for (Provider provider : providers) { if (testProvider.getProviderName().equals(provider.getProviderName())) { found = true; assertEquals("联系人应该匹配", testProvider.getProviderContact(), provider.getProviderContact()); assertEquals("联系电话应该匹配", testProvider.getContactPhone(), provider.getContactPhone()); assertEquals("地址应该匹配", testProvider.getProviderAddress(), provider.getProviderAddress()); break; } } assertTrue("新添加的供应商应该在列表中", found); }
@Test public void testGetProviderRecordsByProviderId() { // 先添加测试供应商 providerService.addProvider(testProvider);
// 获取所有供应商 List<Provider> providers = providerService.getAllProviders(); Provider addedProvider = providers.get(providers.size() - 1);
// 测试获取供应商供应的商品记录 List<Product> products = providerService.getProviderRecordsByProviderId(addedProvider.getId()); assertNotNull("供应商商品记录不应为空", products); }
@Test public void testGetProviderByProviderId() { // 先添加测试供应商 providerService.addProvider(testProvider);
// 获取所有供应商 List<Provider> providers = providerService.getAllProviders(); Provider addedProvider = providers.get(providers.size() - 1);
// 测试根据ID获取供应商 Provider foundProvider = providerService.getProviderByProviderId(addedProvider.getId()); assertNotNull("根据ID获取的供应商不应为空", foundProvider); assertEquals("供应商名称应该匹配", testProvider.getProviderName(), foundProvider.getProviderName()); assertEquals("联系人应该匹配", testProvider.getProviderContact(), foundProvider.getProviderContact()); assertEquals("联系电话应该匹配", testProvider.getContactPhone(), foundProvider.getContactPhone()); assertEquals("地址应该匹配", testProvider.getProviderAddress(), foundProvider.getProviderAddress()); }
@Test public void testGetProviderByProviderPhoneNumber() { // 先添加测试供应商 providerService.addProvider(testProvider);
// 测试根据电话号码查询供应商 List<Provider> providers = providerService.getProviderByProviderPhoneNumber(testProvider.getContactPhone()); assertNotNull("根据电话号码查询的供应商列表不应为空", providers); assertFalse("根据电话号码查询的供应商列表不应为空", providers.isEmpty()); assertEquals("供应商名称应该匹配", testProvider.getProviderName(), providers.get(0).getProviderName()); assertEquals("联系人应该匹配", testProvider.getProviderContact(), providers.get(0).getProviderContact()); assertEquals("联系电话应该匹配", testProvider.getContactPhone(), providers.get(0).getContactPhone()); assertEquals("地址应该匹配", testProvider.getProviderAddress(), providers.get(0).getProviderAddress()); }
@Test public void testDeleteProviderByProviderId() { // 先添加测试供应商 providerService.addProvider(testProvider);
// 获取所有供应商 List<Provider> providers = providerService.getAllProviders(); Provider addedProvider = providers.get(providers.size() - 1);
// 测试删除供应商 int result = providerService.deleteProviderByProviderId(addedProvider.getId()); assertTrue("删除供应商应该成功", result > 0);
// 验证删除结果 Provider deletedProvider = providerService.getProviderByProviderId(addedProvider.getId()); assertNull("删除后的供应商应该不存在", deletedProvider);
// 测试删除不存在的供应商 int nonExistentResult = providerService.deleteProviderByProviderId(999999); assertTrue("删除不存在的供应商应该失败", nonExistentResult <= 0); }
@Test public void testAddProvider() { // 测试添加供应商 int result = providerService.addProvider(testProvider); assertTrue("添加供应商应该成功", result > 0);
// 验证添加结果 List<Provider> providers = providerService.getProviderByProviderPhoneNumber(testProvider.getContactPhone()); assertFalse("添加的供应商应该存在", providers.isEmpty()); assertEquals("供应商名称应该匹配", testProvider.getProviderName(), providers.get(0).getProviderName()); assertEquals("联系人应该匹配", testProvider.getProviderContact(), providers.get(0).getProviderContact()); assertEquals("联系电话应该匹配", testProvider.getContactPhone(), providers.get(0).getContactPhone()); assertEquals("地址应该匹配", testProvider.getProviderAddress(), providers.get(0).getProviderAddress()); }
@Test public void testUpdateProvider() { // 先添加测试供应商 providerService.addProvider(testProvider);
// 获取所有供应商 List<Provider> providers = providerService.getAllProviders(); Provider addedProvider = providers.get(providers.size() - 1);
// 修改供应商信息 String newName = "更新后的供应商名称"; String newContact = "更新后的联系人"; String newPhone = "13900139000"; String newAddress = "更新后的地址";
addedProvider.setProviderName(newName); addedProvider.setProviderContact(newContact); addedProvider.setContactPhone(newPhone); addedProvider.setProviderAddress(newAddress);
// 测试更新供应商 int result = providerService.updateProvider(addedProvider); assertTrue("更新供应商应该成功", result > 0);
// 验证更新结果 Provider updatedProvider = providerService.getProviderByProviderId(addedProvider.getId()); assertEquals("供应商名称应该已更新", newName, updatedProvider.getProviderName()); assertEquals("联系人应该已更新", newContact, updatedProvider.getProviderContact()); assertEquals("联系电话应该已更新", newPhone, updatedProvider.getContactPhone()); assertEquals("地址应该已更新", newAddress, updatedProvider.getProviderAddress()); }
@Test public void testGetProviderByProviderIdWithNonExistentId() { // 测试获取不存在的供应商 Provider provider = providerService.getProviderByProviderId(999999); assertNull("获取不存在的供应商应该返回null", provider); }
@Test public void testGetProviderByProviderPhoneNumberWithNonExistentPhone() { // 测试使用不存在的电话号码查询 List<Provider> providers = providerService.getProviderByProviderPhoneNumber("99999999999"); assertTrue("使用不存在的电话号码查询应该返回空列表", providers.isEmpty()); }
@Test public void testAddProviderWithDuplicatePhone() { // 先添加测试供应商 providerService.addProvider(testProvider);
// 创建具有相同电话号码的新供应商 Provider duplicateProvider = new Provider(); duplicateProvider.setProviderName("另一个供应商"); duplicateProvider.setProviderContact("另一个联系人"); duplicateProvider.setContactPhone(testProvider.getContactPhone()); duplicateProvider.setProviderAddress("另一个地址");
} } |
通过 |
|
销售管理 |
public class SaleServiceTest {
@Autowired private SaleService saleService;
@Autowired private ProductService productService;
@Autowired private GroupService groupService;
private Product testProduct; private Group testGroup; private SimpleDateFormat dateFormat;
@Before public void setUp() { // 初始化日期格式化工具 dateFormat = new SimpleDateFormat("yyyy-MM-dd");
// 初始化测试数据 testGroup = new Group(); testGroup.setGroupName("测试商品分类"); groupService.addGroup(testGroup);
testProduct = new Product(); testProduct.setProductName("测试商品"); testProduct.setGroupId(testGroup.getId()); testProduct.setProductFactory("测试工厂"); testProduct.setPurchasePrice(100.0f); testProduct.setSalePrice(150.0f); testProduct.setStock(100); testProduct.setYieldDate(new Date(System.currentTimeMillis())); testProduct.setCreateDate(new Date(System.currentTimeMillis())); productService.addProduct(testProduct); }
@Test public void testInsertSaleItem() { // 获取所有商品 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 测试添加销售记录 int saleCount = 5; int result = saleService.insertSaleItem(addedProduct.getId(), saleCount); assertTrue("添加销售记录应该成功", result > 0);
// 验证商品库存是否更新 Product updatedProduct = productService.getProductByProductId(addedProduct.getId()); assertEquals("商品库存应该减少", addedProduct.getStock() - saleCount, updatedProduct.getStock().intValue()); }
@Test public void testGetSaleInfoByCondition() { // 先添加一些销售记录 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 添加销售记录 saleService.insertSaleItem(addedProduct.getId(), 5); saleService.insertSaleItem(addedProduct.getId(), 3);
// 获取当前日期作为测试日期 String currentDate = dateFormat.format(new Date(System.currentTimeMillis()));
// 测试按条件查询销售记录 List<Sale> sales = saleService.getSaleInfoByCondition( addedProduct.getGroupId(), currentDate, currentDate );
assertNotNull("销售记录列表不应为空", sales);
// 验证销售记录的总数量 int totalCount = 0; for (Sale sale : sales) { totalCount += sale.getSaleCount(); } assertEquals("销售记录总数量应该正确", 8, totalCount); }
@Test public void testGetSaleInfoByConditionWithNullGroupId() { // 先添加一些销售记录 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 添加销售记录 saleService.insertSaleItem(addedProduct.getId(), 5);
// 获取当前日期作为测试日期 String currentDate = dateFormat.format(new Date(System.currentTimeMillis()));
// 测试按条件查询销售记录(不指定商品分类) List<Sale> sales = saleService.getSaleInfoByCondition( null, currentDate, currentDate );
assertNotNull("销售记录列表不应为空", sales); }
@Test public void testGetSaleInfoByConditionWithDateRange() { // 先添加一些销售记录 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 添加销售记录 saleService.insertSaleItem(addedProduct.getId(), 5);
// 获取当前日期作为测试日期 String currentDate = dateFormat.format(new Date(System.currentTimeMillis()));
// 测试按日期范围查询销售记录 List<Sale> sales = saleService.getSaleInfoByCondition( addedProduct.getGroupId(), currentDate, currentDate );
assertNotNull("销售记录列表不应为空", sales);
// 验证销售记录的总数量 int totalCount = 0; for (Sale sale : sales) { totalCount += sale.getSaleCount(); } } } |
通过 |
|
商品管理 |
public class ProductServiceTest {
@Autowired private ProductService productService;
@Autowired private GroupService groupService;
private Product testProduct; private Group testGroup;
@Before public void setUp() { // 初始化测试数据 testGroup = new Group(); testGroup.setGroupName("测试商品分类"); groupService.addGroup(testGroup);
testProduct = new Product(); testProduct.setProductName("测试商品"); testProduct.setGroupId(testGroup.getId()); testProduct.setProductFactory("测试工厂"); testProduct.setPurchasePrice(100.0f); testProduct.setSalePrice(150.0f); testProduct.setStock(100); testProduct.setYieldDate(new Date(System.currentTimeMillis())); testProduct.setCreateDate(new Date(System.currentTimeMillis())); }
@Test public void testGetAllProducts() { // 测试获取所有商品 List<Product> products = productService.getAllProducts(); assertNotNull("获取的商品列表不应为空", products); }
@Test public void testGetProductByProductName() { // 先添加测试商品 productService.addProduct(testProduct);
// 测试根据商品名称查询 Product foundProduct = productService.getProductByProductName(testProduct.getProductName()); assertNotNull("根据商品名称查询的商品不应为空", foundProduct); assertEquals("商品名称应该匹配", testProduct.getProductName(), foundProduct.getProductName()); }
@Test public void testAddProduct() { // 测试添加商品 int result = productService.addProduct(testProduct); assertTrue("添加商品应该成功", result > 0); }
@Test public void testGetProductSalePriceByProductId() { // 先添加测试商品 productService.addProduct(testProduct);
// 获取所有商品 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 测试获取商品售价 float price = productService.getProductSalePriceByProductId(addedProduct.getId()); assertEquals("商品售价应该匹配", testProduct.getSalePrice(), price, 0.001); }
@Test public void testGetProductByProductIdToCheckService() { // 先添加测试商品 productService.addProduct(testProduct);
// 获取所有商品 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 测试获取结算服务信息 Check check = productService.getProductByProductIdToCheckService(addedProduct.getId()); assertNotNull("结算服务信息不应为空", check); }
@Test public void testDeleteProductByProductId() { // 先添加测试商品 productService.addProduct(testProduct);
// 获取所有商品 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 测试删除商品 int result = productService.deleteProductByProductId(addedProduct.getId()); assertTrue("删除商品应该成功", result > 0);
// 验证删除结果 Product deletedProduct = productService.getProductByProductId(addedProduct.getId()); assertNull("删除后的商品应该不存在", deletedProduct); }
@Test public void testUpdateProductByProductId() { // 先添加测试商品 productService.addProduct(testProduct);
// 获取所有商品 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 修改商品信息 String newName = "更新后的商品名称"; addedProduct.setProductName(newName);
// 测试更新商品 int result = productService.updateProductByProductId(addedProduct); assertTrue("更新商品应该成功", result > 0);
// 验证更新结果 Product updatedProduct = productService.getProductByProductId(addedProduct.getId()); assertEquals("商品名称应该已更新", newName, updatedProduct.getProductName()); }
@Test public void testGetProductByProductId() { // 先添加测试商品 productService.addProduct(testProduct);
// 获取所有商品 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 测试根据ID获取商品 Product foundProduct = productService.getProductByProductId(addedProduct.getId()); assertNotNull("根据ID获取的商品不应为空", foundProduct); assertEquals("商品名称应该匹配", testProduct.getProductName(), foundProduct.getProductName()); }
@Test public void testGetProductByProductNameOrProductGroup() { // 先添加测试商品 productService.addProduct(testProduct);
// 测试根据商品名称和分类查询 List<Product> products = productService.getProductByProductNameOrProductGroup( testProduct.getProductName(), testProduct.getGroupId() ); assertNotNull("查询结果不应为空", products); assertFalse("查询结果不应为空", products.isEmpty()); }
@Test public void testUpdateProductStockPlus() { // 先添加测试商品 productService.addProduct(testProduct);
// 获取所有商品 List<Product> products = productService.getAllProducts(); Product addedProduct = products.get(products.size() - 1);
// 测试更新库存 int saleCount = 10; int newStock = addedProduct.getStock() - saleCount; int result = productService.updateProductStockPlus( addedProduct.getId(), saleCount, newStock ); assertTrue("更新库存应该成功", result > 0);
// 验证更新结果 Product updatedProduct = productService.getProductByProductId(addedProduct.getId()); assertEquals("库存应该已更新", newStock, updatedProduct.getStock().intValue()); } } |
通过 |
|
用户管理 |
public class UserServiceTest {
@Autowired private UserService userService;
private User testUser; private User adminUser;
@Before public void setUp() { // 清理测试数据 List<User> allUsers = userService.getAllUser(); for (User user : allUsers) { if ("testUser".equals(user.getUsername()) || "adminUser".equals(user.getUsername())) { userService.deleteUserByUserId(user.getId()); } }
// 初始化测试用户数据 testUser = new User(); testUser.setUsername("testUser"); testUser.setPassword("testPassword"); testUser.setRole("user");
// 初始化管理员用户数据 adminUser = new User(); adminUser.setUsername("adminUser"); adminUser.setPassword("adminPassword"); adminUser.setRole("admin"); }
@Test public void testGetUserByUsername() { // 先添加测试用户 userService.addUser(testUser);
// 测试根据用户名获取用户 User foundUser = userService.getUserByUsername(testUser.getUsername()); assertNotNull("根据用户名查询的用户不应为空", foundUser); assertEquals("用户名应该匹配", testUser.getUsername(), foundUser.getUsername()); assertEquals("用户角色应该匹配", testUser.getRole(), foundUser.getRole()); }
@Test public void testGetAllUser() { // 先添加测试用户和管理员用户 userService.addUser(testUser); userService.addUser(adminUser);
// 测试获取所有用户 List<User> users = userService.getAllUser(); assertNotNull("用户列表不应为空", users); assertFalse("用户列表不应为空", users.isEmpty());
// 验证是否包含测试用户和管理员用户 boolean foundTestUser = false; boolean foundAdminUser = false; for (User user : users) { if (testUser.getUsername().equals(user.getUsername())) { foundTestUser = true; assertEquals("用户角色应该匹配", testUser.getRole(), user.getRole()); } if (adminUser.getUsername().equals(user.getUsername())) { foundAdminUser = true; assertEquals("用户角色应该匹配", adminUser.getRole(), user.getRole()); } } assertTrue("应该找到测试用户", foundTestUser); assertTrue("应该找到管理员用户", foundAdminUser); }
@Test public void testAddUser() { // 测试添加用户 int result = userService.addUser(testUser); assertTrue("添加用户应该成功", result > 0);
// 验证添加结果 User addedUser = userService.getUserByUsername(testUser.getUsername()); assertNotNull("添加的用户应该存在", addedUser); assertEquals("用户名应该匹配", testUser.getUsername(), addedUser.getUsername()); assertEquals("用户角色应该匹配", testUser.getRole(), addedUser.getRole()); }
@Test public void testResetAllPassword() { // 先添加测试用户和管理员用户 userService.addUser(testUser); userService.addUser(adminUser);
// 测试重置所有用户密码 int result = userService.resetAllPassword(); assertTrue("重置所有用户密码应该成功", result > 0);
// 验证密码是否已重置 User resetTestUser = userService.getUserByUsername(testUser.getUsername()); User resetAdminUser = userService.getUserByUsername(adminUser.getUsername()); assertEquals("测试用户密码应该已重置为123456", "123456", resetTestUser.getPassword()); assertEquals("管理员用户密码应该已重置为123456", "123456", resetAdminUser.getPassword()); }
@Test public void testResetPasswordByUserId() { // 先添加测试用户 userService.addUser(testUser); User addedUser = userService.getUserByUsername(testUser.getUsername());
// 测试重置指定用户密码 int result = userService.resetPasswordByUserId(addedUser.getId()); assertTrue("重置指定用户密码应该成功", result > 0);
// 验证密码是否已重置 User resetUser = userService.getUserByUserId(addedUser.getId()); assertEquals("密码应该已重置为123456", "123456", resetUser.getPassword()); }
@Test public void testDeleteUserByUserId() { // 先添加测试用户 userService.addUser(testUser); User addedUser = userService.getUserByUsername(testUser.getUsername());
// 测试删除用户 int result = userService.deleteUserByUserId(addedUser.getId()); assertTrue("删除用户应该成功", result > 0);
// 验证删除结果 User deletedUser = userService.getUserByUserId(addedUser.getId()); assertNull("删除的用户应该不存在", deletedUser); }
@Test public void testUpdatePassword() { // 先添加测试用户 userService.addUser(testUser); User addedUser = userService.getUserByUsername(testUser.getUsername());
// 测试修改密码 String newPassword = "newPassword"; int result = userService.updatePassword(addedUser.getId(), newPassword); assertTrue("修改密码应该成功", result > 0);
// 验证密码是否已更新 User updatedUser = userService.getUserByUserId(addedUser.getId()); assertEquals("密码应该已更新", newPassword, updatedUser.getPassword()); }
@Test public void testGetAllAdmin() { // 先添加管理员用户 userService.addUser(adminUser);
// 测试获取所有管理员 List<User> admins = userService.getAllAdmin(); assertNotNull("管理员列表不应为空", admins); assertFalse("管理员列表不应为空", admins.isEmpty());
// 验证管理员角色 boolean found = false; for (User admin : admins) { if ("admin".equals(admin.getRole())) { found = true; break; } } assertTrue("应该找到管理员用户", found); }
@Test public void testGetUserByUserId() { // 先添加测试用户 userService.addUser(testUser); User addedUser = userService.getUserByUsername(testUser.getUsername());
// 测试根据用户ID获取用户 User foundUser = userService.getUserByUserId(addedUser.getId()); assertNotNull("根据ID查询的用户不应为空", foundUser); assertEquals("用户ID应该匹配", addedUser.getId(), foundUser.getId()); assertEquals("用户名应该匹配", testUser.getUsername(), foundUser.getUsername()); assertEquals("用户角色应该匹配", testUser.getRole(), foundUser.getRole()); }
@Test public void testGetUserByUsernameWithNonExistentUser() { // 测试查询不存在的用户 User user = userService.getUserByUsername("nonExistentUser"); assertNull("查询不存在的用户应该返回null", user); }
@Test public void testGetUserByUserIdWithNonExistentId() { // 测试查询不存在的用户ID User user = userService.getUserByUserId(999999); assertNull("查询不存在的用户ID应该返回null", user); }
@Test public void testAddUserWithExistingUsername() { // 先添加测试用户 userService.addUser(testUser);
// 测试添加重复用户名 User duplicateUser = new User(); duplicateUser.setUsername(testUser.getUsername()); duplicateUser.setPassword("differentPassword"); duplicateUser.setRole("user");
int result = userService.addUser(duplicateUser); }
@Test public void testResetPasswordByUserIdWithNonExistentId() { // 测试重置不存在的用户密码 int result = userService.resetPasswordByUserId(999999); assertTrue("重置不存在的用户密码应该失败", result <= 0); }
@Test public void testUpdatePasswordWithNonExistentId() { // 测试修改不存在的用户密码 int result = userService.updatePassword(999999, "newPassword"); assertTrue("修改不存在的用户密码应该失败", result <= 0); }
@Test public void testDeleteUserByUserIdWithNonExistentId() { // 测试删除不存在的用户 int result = userService.deleteUserByUserId(999999); assertTrue("删除不存在的用户应该失败", result <= 0); } } |
通过 |
|
测试结果 |
通过 |
单元测试结论
单元模块测试覆盖情况:
模块 测试用例数 通过数 覆盖率 用户管理 14 14 80% 商品管理 11 11 75% 销售管理 4 4 100% 供应商管理 11 11 90% 商品分类管理 5 5 100% |
|
测试结果统计数据: 总测试用例数:45个 通过用例数:45个 通过率:100% 功能覆盖:100% 异常场景覆盖:85% 边界条件覆盖:80% |
|
主要问题和解决情况: 1.用户密码重置功能验证 - 已解决 2.商品库存更新机制 - 已解决 3.供应商联系方式唯一性验证 - 已解决 |
|
遗留问题: 1.需要增加并发测试场景 2.需要补充性能测试用例 3.需要增加更多的边界条件测试 |
|
测试结论: 服务层功能完整性:良好 代码质量:良好 异常处理:良好 测试覆盖率:良好 |
|
开发经理签名: |
日期: 2025 年 6 月1 日 |
备注:
|