软件测试-单元测试

软件测试

单元测试报告

 

 

 

 

 

 

班级: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 - 用户管理

程序结构

功能点

涉及的方法

商品分类管理

方法1List<Group> getAllGroups();

功能说明:获取所有商品分类信息用于页面的展示

输出:输出所有商品分类的集合

异常:输出空的字符串

 

方法2int addGroup(Group group);

     功能说明:添加商品分类

     参数描述:group:商品类别的实体类

     输出:影响的行数

     异常:输出0

     流程:将输入的商品分类添加到数据库

方法3 Group getGroupByGroupId(Integer id);

     功能说明:添加商品分类

     参数描述:id:商品对应的id

     输出:商品类实体

     异常:输出空的字符串

     流程:根据输入的id输出对应的商品类实体

 

方法4 int updateGroup(Group group)

     功能说明:修改商品分类信息

     参数描述:group:商品类别的实体类;

     输出:影响的行数

     异常:输出0

     流程:输入实体类,在数据库修改数据;

 

方法5int deleteGroupById(Integer id);

     功能说明:根据id删除商品分类信息

     参数描述:id:商品类的id

     输出:影响的行数

     异常:输出0

     流程:根据输入的id删除对应的商品分类

供应商管理

方法1List<Provider> getAllProviders();

     功能说明:获取所有供应商

     参数描述:

     输出:供应商实体类的集合

     异常:输出空的字符串

     流程:输出所有的供应商

 

方法2List<Product> getProviderRecordsByProviderId(Integer providerId);

     功能说明:根据供应商id查询出该供应商供应的商品

     参数描述: providerId :供应商所对应的id

     输出:供应商对应的所有商品集合

     异常:输出空的字符串

     流程:根据供应商的id查询所对应的商品

 

方法3Provider getProviderByProviderId(Integer providerId)

     功能说明:根据供应商id查询出该供应商实体

     参数描述: providerId :供应商所对应的id

     输出:供应商实体

     异常:输出空的字符串

     流程:根据id查询对应的供应商

 

方法4List<Provider> getProviderByProviderPhoneNumber(String phoneNumber);

     功能说明:根据供应商联系人电话号码查询出该供应商

     参数描述: phoneNumber:供应商所对应的电话号码

     输出:供应商实体

     异常:输出空的字符串

     流程:根据电话号码查询对应的供应商

 

方法5int deleteProviderByProviderId(Integer providerId);

     功能说明:根据供应商id删除供应商

     参数描述:providerId:供应商所对应的id

     输出:影响行数

     异常:输出0

     流程:根据输入的id删除对应的供应商

 

方法6int addProvider(Provider provider);

     功能说明:添加供应商

     参数描述: provider:供应商实体类

     输出:影响行数

     异常:输出0

     流程:根据电话号码查询对应的供应商

 

方法7int updateProvider(Provider provider);

     功能说明:修改供应商

     参数描述: provider:供应商实体类

     输出:影响行数

     异常:输出0

     流程:将输入的供应商在数据库修改

 

销售管理

方法1int 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();

     功能说明:获取所有商品信息

     参数描述:

     输出:商品信息的集合

     异常:输出空字符串

     流程:输出所有的商品信息

 

方法2Product getProductByProductName(String productName);

     功能说明:获取所有商品信息

     参数描述:productNamea:商品名称

     输出:商品信息的实体

     异常:输出空字符串

     流程:根据商品名称查询对应的商品信息

 

方法3 int addProduct(Product product);

     功能说明:新增商品信息

     参数描述:product:商品实体

     输出:影响行数

     异常:输出空字符串

     流程:将输入的商品信息添加到数据库

 

方法4float getProductSalePriceByProductId(Integer id);

     功能说明:根据商品的编号获取到该商品的价格

     参数描述: id:商品的 id

     输出:商品的价格

     异常:输出空字符串

     流程:根据输入的商品id查询对应的价格

 

方法5Check getProductByProductIdToCheckService(Integer productId);

     功能说明:根据商品id查询商品的信息之后封装到CheckTO类中, 用于结算服务显示

     参数描述: productId:商品的 id

     输出:商品的结算实体类Check

     异常:输出空字符串

     流程:输出商品的结算信息

 

方法6 int deleteProductByProductId(Integer productId);

     功能说明:按照商品id删除商品

     参数描述: productId:商品的 id

     输出:影响行数

     异常:输出0

     流程:根据输入的id删除对应的商品

 

方法7int updateProductByProductId(Product product);

     功能说明: 按照商品id修改商品

     参数描述:product:商品的实体信息

     输出:影响行数

     异常:输出0

     流程:根据输入的商品信息修改对应id的商品信息

 

方法8 Product getProductByProductId(Integer productId);

     功能说明: 按照商品id修改商品

     参数描述:productId:商品的Id

     输出:商品实体类

     异常:输出空字符串

     流程:根据输入的商品id输出对应的商品信息

 

 

 

方法9List<Product>getProductByProductNameOrProductGroup(string productName,Integer groupId);

     功能说明:用于搜索显示, 根据商品名称查询后显示

     参数描述:productId:商品的Id

               productName:商品的名称

     输出:商品实体类的集合

     异常:输出空字符串

     流程:根据输入的商品id和商品名称查询出对应的商品信息。

 

方法10int 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更新商品对应的库存

 

用户管理

方法1User 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     

备注:

 

 

 

posted @ 2025-06-12 16:58  chrisrmas、  阅读(8)  评论(0)    收藏  举报