单元测试之Mockito不常用的几种用法

• 单元测试之Mockito不常用的几种用法

1. 如何实现抽象类静态方法的Mock

/**
 * Copyright (C), 2002-2019, ****电子商务有限公司
 * FileName: PayControllerTest.java
 * Author:   liu bin
 * Date:     2019/1/21 9:17
 * Description: //
 * History: //修改记录
 * <author>              <time>           <version>            <desc>
 * 修改人姓名             修改时间           版本号               描述
 */
package com.*.*.web.controller;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;

import base.BaseTestNG;

import com.*.ids.client.util.AuthUtils;
import com.*.pg.business.PayBusiness;
import com.*.pg.esb.dto.PayResponseDto;

/**
 * 前台支付controller单元测试<br>
 * 〈功能详细描述〉
 *
 * @author liu bin
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@RunWith(PowerMockRunner.class)
@PrepareForTest({ AuthUtils.class })
public class PayControllerTest extends BaseTestNG {

    @InjectMocks
    private PayController payController;

    @Mock
    private PayBusiness payBusiness;

    private MockHttpServletRequest request;

    private MockHttpServletResponse response;

    @Before
    public void setUp() {
        request = new MockHttpServletRequest();
        request.setCharacterEncoding("UTF-8");
        request.setRemoteUser("12345678");
        String version = "version";
        String versionNum = "1";
        request.setParameter(version, versionNum);
        response = new MockHttpServletResponse();
        MockitoAnnotations.initMocks(this);
        PowerMockito.mockStatic(AuthUtils.class);
    }

    @Test(expected = Exception.class)
    public void testPay() throws IOException {
        String b2cOrderId = "12345678";
        String b2cOrderIdEmpty = "";
        PayResponseDto payResponse = new PayResponseDto();
        payResponse.setBuyerUserNo("88416534");
        Mockito.when(
                payBusiness.pay(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString()))
                .thenReturn(payResponse);
        payController.pay(b2cOrderId, request, response);

        Mockito.when(AuthUtils.getCurrentUserAttribute((HttpServletRequest) Mockito.anyObject(), Mockito.anyString()))
                .thenReturn("test");
        payController.pay(b2cOrderId, request, response);

        Mockito.doThrow(Exception.class).when(payBusiness)
                .pay(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
        payController.pay(b2cOrderId, request, response);

        payController.pay(b2cOrderIdEmpty, request, response);
    }
}

/**
 * Copyright (C), 2002-2019, ****电子商务有限公司
 * FileName: AuthUtils.java
 * Author:   liu bin
 * Date:     2018/11/21 9:47
 * Description: //
 * History: //修改记录
 * <author>              <time>           <version>            <desc>
 * 修改人姓名             修改时间           版本号               描述
 */
package com.*.ids.client.util;

import com.*.ids.client.config.ConfigException;
import com.*.ids.client.config.Configuration;
import com.*.ids.client.principal.IdsPrincipal;
import com.*.ids.client.storage.StorageAccessor;
import java.io.IOException;
import java.net.URLEncoder;
import java.security.Principal;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public abstract class AuthUtils {
    public AuthUtils() {
    }

    public static void loginAsPrincipal(ServletContext servletContext, HttpServletResponse response, String principalName, String targetUrl, Map<String, String> attributes) throws IOException, ServletException, ConfigException {
        Configuration configuration = Configuration.getInstance(servletContext);
        String appCode = configuration.getAppCode();
        if (StringUtils.isEmpty(appCode)) {
            throw new ConfigException("app-code can not find in ids-config.xml, please contact ids manager to get proper appCode.");
        } else {
            StorageAccessor storageAccessor = configuration.getStorageAccessor();
            String authCode = RandomGenerator.nextId();
            storageAccessor.saveAuthCode(authCode, principalName);
            String serviceUrl = configuration.getAuthUrl();
            serviceUrl = RequestUtils.setParameter(serviceUrl, "targetUrl", URLEncoder.encode(targetUrl, "UTF-8"));
            String authServerUrl = configuration.getAuthServerUrl();
            StringBuilder redirectUrl = new StringBuilder(StringUtils.removeEnd(authServerUrl, "/"));
            redirectUrl.append("/login?service=").append(URLEncoder.encode(serviceUrl, "UTF-8"));
            redirectUrl.append("&authCode=").append(authCode);
            redirectUrl.append("&appCode=").append(appCode);
            if (attributes != null && attributes.size() > 0) {
                Iterator var13 = attributes.entrySet().iterator();

                while(var13.hasNext()) {
                    Entry<String, String> entry = (Entry)var13.next();
                    if (StringUtils.isNotBlank((String)entry.getKey()) && StringUtils.isNotBlank((String)entry.getValue())) {
                        redirectUrl.append("&").append((String)entry.getKey()).append("=").append((String)entry.getValue());
                    }
                }
            }

            response.sendRedirect(redirectUrl.toString());
        }
    }

    public static void loginAsPrincipal(ServletContext servletContext, HttpServletResponse response, String principalName, String targetUrl) throws IOException, ServletException, ConfigException {
        loginAsPrincipal(servletContext, response, principalName, targetUrl, (Map)null);
    }

    public static boolean checkPermission(ServletContext servletContext, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        Configuration configuration = Configuration.getInstance(servletContext);
        String accessDeniedUrl = configuration.getAccessDeniedRedirectUrl();
        String[] permitRoles = configuration.getPermitRoles();
        String roleAttrName = configuration.getRoleAttributeName();
        if (!StringUtils.isBlank(roleAttrName) && !StringUtils.isBlank(accessDeniedUrl) && permitRoles != null && permitRoles.length != 0) {
            Principal principal = request.getUserPrincipal();
            if (principal != null && principal instanceof IdsPrincipal) {
                IdsPrincipal idsPrincipal = (IdsPrincipal)principal;
                String rolesStr = idsPrincipal.getAttribute(roleAttrName);
                if (StringUtils.isBlank(rolesStr)) {
                    return true;
                } else {
                    String[] roles = StringUtils.split(rolesStr, ",");
                    if (roles.length == 0) {
                        return true;
                    } else {
                        String[] var14 = roles;
                        int var13 = roles.length;

                        for(int var12 = 0; var12 < var13; ++var12) {
                            String role = var14[var12];
                            String[] var18 = permitRoles;
                            int var17 = permitRoles.length;

                            for(int var16 = 0; var16 < var17; ++var16) {
                                String permitRole = var18[var16];
                                if (role.trim().equals(permitRole.trim())) {
                                    return true;
                                }
                            }
                        }

                        StringBuilder accessDeniedUrlWrappered = new StringBuilder(accessDeniedUrl);
                        RequestUtils.addParameter(accessDeniedUrlWrappered, "permitRoles", URLEncoder.encode(StringUtils.join(Arrays.asList(permitRoles), ","), "UTF-8"));
                        RequestUtils.addParameter(accessDeniedUrlWrappered, "currentRoles", URLEncoder.encode(rolesStr, "UTF-8"));
                        response.sendRedirect(accessDeniedUrlWrappered.toString());
                        return false;
                    }
                }
            } else {
                return true;
            }
        } else {
            return true;
        }
    }

    public static String getCurrentUserAttribute(HttpServletRequest request, String key) {
        Principal principal = request.getUserPrincipal();
        if (principal != null && principal instanceof IdsPrincipal) {
            IdsPrincipal idsPrincipal = (IdsPrincipal)principal;
            return StringUtils.isNotBlank(idsPrincipal.getAttribute(key)) ? idsPrincipal.getAttribute(key) : null;
        } else {
            return null;
        }
    }
}

 

2、匿名内部类如何实现Mock

package com.*.pg.service.cache.impl;

import base.BaseTestNG;
import com.*.framework.sedis.ShardedJedisAction;
import com.*.framework.sedis.ShardedJedisClient;
import com.*.pg.base.ShardedRedisService;
import com.*.pg.constant.Constant;
import com.*.pg.entity.OrderBean;
import com.*.pg.service.OrderService;
import com.*.pg.service.cache.OrderListItemPageParam;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.BinaryShardedJedis;
import redis.clients.jedis.BuilderFactory;
import redis.clients.jedis.Client;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.Response;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;

import java.util.ArrayList;
import java.util.List;

/**
 * 〈一句话功能简述〉<br> 
 * 〈功能详细描述〉
 *
 * @author liu bin
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class LotteryOrderListItemCacheWorkerTest extends BaseTestNG{

    @InjectMocks
    private LotteryOrderListItemCacheWorker worker;

    @Mock
    private ShardedRedisService shardedRedisService;

    @Mock
    private OrderService orderService;

    @Mock
    private ShardedJedis shardedJedis;

    @SuppressWarnings({ "rawtypes", "unchecked" })
    @Test
    @PrepareForTest(ShardedJedisPipeline.class)
    public void testWrite2(){
        OrderListItemPageParam param = new OrderListItemPageParam();
        param.setCustNo("6121084508");
        param.setHistory("1");
        param.setPage(Constant.NUM_1);
        param.setSize(10);
        List<OrderBean> orderBeans = new ArrayList<OrderBean>();
        OrderBean orderBean = new OrderBean();
        orderBean.setB2cOrderId("111");
        orderBean.setCreateTime("2018-1-1 12:00:00");
        orderBeans.add(orderBean);
        Mockito.when(orderService.getOrderIdListByActType(Mockito.anyString(),Mockito.anyInt(),Mockito.anyInt(),Mockito.anyString())).thenReturn(orderBeans);
        Mockito.when(shardedRedisService.key(Mockito.anyString(), Mockito.anyString()))
                .thenReturn("123");
        Client pipeClient = Mockito.mock(Client.class);
        ShardedJedisPipeline pipeline= PowerMockito.spy(new ShardedJedisPipeline());
        try {
            PowerMockito.doReturn(pipeClient).when(pipeline, "getClient", Mockito.anyString());
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
        BinaryShardedJedis by = new BinaryShardedJedis(shards);
        pipeline.setShardedJedis(by);
        ShardedJedisClient client = Mockito.mock(ShardedJedisClient.class);
        Mockito.doReturn(client).when(shardedRedisService).getShardedJedisClient();
        Mockito.doReturn(pipeline).when(shardedJedis).pipelined();
        Response rsp = new Response(BuilderFactory.STRING);
        Mockito.when(pipeline.zadd("123",1, "")).thenReturn(rsp);
        Mockito.when(shardedRedisService.getShardedJedisClient().execute(Mockito.any(ShardedJedisAction.class)))
                .thenAnswer(new Answer() {
                    @Override
                    public Object answer(InvocationOnMock invocation) throws Throwable {
                        Object[] args = invocation.getArguments();
                        ShardedJedisAction arg = (ShardedJedisAction) args[0];
                        return arg.doAction(shardedJedis);
                    }
                });
        worker.write(param);
    }
}