Mock Assist

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.RandomUtil;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.choerodon.core.domain.Page;
import io.choerodon.core.oauth.CustomUserDetails;
import io.choerodon.core.oauth.DetailsHelper;
import io.choerodon.mybatis.domain.Config;
import io.choerodon.mybatis.helper.EntityHelper;
import lombok.SneakyThrows;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.hzero.boot.platform.code.builder.CodeRuleBuilder;
import org.junit.jupiter.api.Assertions;
import org.mockito.Mock;
import org.powermock.api.mockito.PowerMockito;
import org.springframework.core.io.ClassPathResource;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.jwt.Jwt;
import org.springframework.security.jwt.JwtHelper;
import org.springframework.util.ObjectUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;

import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.when;

public class MockAssist {

    private static final String DEFAULT_TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InN1d3giLCJwYXNzd29yZCI6bnVsbCwidXNlclR5cGUiOiJQIiwiYXV0aG9yaXRpZXMiOltdLCJhY2NvdW50Tm9uRXhwaXJlZCI6dHJ1ZSwiYWNjb3VudE5vbkxvY2tlZCI6dHJ1ZSwiY3JlZGVudGlhbHNOb25FeHBpcmVkIjp0cnVlLCJlbmFibGVkIjp0cnVlLCJ1c2VySWQiOjMyNywicmVhbE5hbWUiOiLoi4_mlofotKQiLCJlbWFpbCI6bnVsbCwidGltZVpvbmUiOiJHTVQrOCIsImxhbmd1YWdlIjoiemhfQ04iLCJyb2xlSWQiOjg0LCJyb2xlTGFiZWxzIjpbIlRFTkFOVF9BRE1JTiJdLCJyb2xlSWRzIjpbODRdLCJzaXRlUm9sZUlkcyI6W10sInRlbmFudFJvbGVJZHMiOls4NF0sInJvbGVNZXJnZUZsYWciOmZhbHNlLCJ0ZW5hbnRJZCI6MTgsInRlbmFudE51bSI6IlNBTlktV0xQVCIsInRlbmFudElkcyI6WzAsMTgsMl0sImltYWdlVXJsIjpudWxsLCJvcmdhbml6YXRpb25JZCI6MCwiY2xpZW50SWQiOm51bGwsImNsaWVudE5hbWUiOiJjbGllbnQiLCJjbGllbnRBdXRob3JpemVkR3JhbnRUeXBlcyI6bnVsbCwiY2xpZW50UmVzb3VyY2VJZHMiOm51bGwsImNsaWVudFNjb3BlIjpudWxsLCJjbGllbnRSZWdpc3RlcmVkUmVkaXJlY3RVcmkiOm51bGwsImNsaWVudEFjY2Vzc1Rva2VuVmFsaWRpdHlTZWNvbmRzIjpudWxsLCJjbGllbnRSZWZyZXNoVG9rZW5WYWxpZGl0eVNlY29uZHMiOm51bGwsImNsaWVudEF1dG9BcHByb3ZlU2NvcGVzIjpudWxsLCJhZGRpdGlvbkluZm8iOnsiRkFDVE9SWSI6WzE3LDE4XX0sImFkZGl0aW9uSW5mb01lYW5pbmciOm51bGwsImFwaUVuY3J5cHRGbGFnIjoxLCJhcGlSZXBsYXlGbGFnIjowLCJtZW51SWRGbGFnIjowLCJhZG1pbiI6ZmFsc2V9.uhzZJBUjnMKYfYMDlh8jO_rbaZwCKEEgzVRhha_HeWc";

    public static void init(Object... objs) {
        if (ObjectUtils.isEmpty(objs)) {
            return;
        }
        for (Object obj : objs) {
            doMock(obj);
        }
    }

    @SneakyThrows
    public static void initStatic(Class<?>... values) {
        if (ObjectUtils.isEmpty(values)) {
            return;
        }
        for (Class<?> value : values) {
            if (value.equals(WmsUtil.class)) {
                PowerMockito.mockStatic(WmsUtil.class);
                PowerMockito.doNothing().when(WmsUtil.class, "validate", any(), any());
            } else if (value.equals(InterfaceHelper.class)) {
                PowerMockito.mockStatic(InterfaceHelper.class);
                LesOutInterfaceLog outLog = new LesOutInterfaceLog();
                outLog.setStatus(InterfaceLogStatusEnum.FINISH.getCode());
                PowerMockito.when(InterfaceHelper.sendAndSaveOutInterface(any(), any())).thenReturn(outLog);
                PowerMockito.when(InterfaceHelper.createOutLog(anyLong(), anyString(),
                        anyString(), anyString(), anyString(), anyString(),
                        anyString(), anyString())).thenReturn(outLog);
            }
        }
    }

    @SafeVarargs
    public static void initEntities(Class<? extends WmsDomain>... entities) {
        for (Class<? extends WmsDomain> entity : entities) {
            EntityHelper.initEntityNameMap(entity, "", new Config());
        }
    }

    @SneakyThrows
    public static void initMocks(Object testClass) {
        if (testClass == null) {
            return;
        }
        Field[] fields = FieldUtils.getAllFields(testClass.getClass());
        List<Object> objects = new ArrayList<>();
        for (Field field : fields) {
            Mock annotation = field.getAnnotation(Mock.class);
            if (annotation != null) {
                field.setAccessible(true);
                objects.add(field.get(testClass));
            }
        }
        objects.forEach(MockAssist::doMock);
    }

    @SneakyThrows
    public static <T> T load(String filename, Class<T> clazz) {
        ClassPathResource resource = new ClassPathResource("mocks/" + filename);
        String json = IOUtils.toString(resource.getInputStream(), StandardCharsets.UTF_8);
        return JSON.parseObject(json, clazz);
    }

    @SneakyThrows
    public static void loadUser(String jwt) {
        if (StringUtils.isBlank(jwt)) {
            return;
        }
        Jwt decode = JwtHelper.decode(jwt);
        ObjectMapper objectMapper = new ObjectMapper();
        CustomUserDetails userDetails = objectMapper.readValue(decode.getClaims().replace("\"password\":null", "\"password\":\"default\""), CustomUserDetails.class);
        DetailsHelper.setCustomUserDetails(userDetails);
    }

    public static void loadUser() {
        loadUser(DEFAULT_TOKEN);
    }

    @SuppressWarnings("unchecked")
    @SneakyThrows
    public static <T> T mock(Class<T> clazz, Map<String, Object> values, String... fields) {
        Object random = random(clazz);
        if (random != null) {
            return (T) random;
        }
        T obj = clazz.newInstance();
        List<String> fieldList;
        Map<String, BeanPropertyInfo> fieldsMap = BeanUtil.getBeanPropertyMap(clazz);
        if (ObjectUtil.isNotEmpty(fields)) {
            fieldList = Arrays.stream(fields).collect(Collectors.toList());
        } else {
            fieldList = fieldsMap.keySet().stream()
                    .filter(k -> fieldsMap.get(k).getProperty() != null)
                    .filter(k -> support(fieldsMap.get(k).getProperty().getPropertyType()))
                    .collect(Collectors.toList());
        }
        for (String field : fieldList) {
            if (fieldsMap.containsKey(field)) {
                BeanPropertyInfo info = fieldsMap.get(field);
                Class<?> propertyType = info.getProperty().getPropertyType();
                if (values != null && values.containsKey(field)) {
                    info.getProperty().getWriteMethod().invoke(obj, values.get(field));
                } else {
                    info.getProperty().getWriteMethod().invoke(obj, random(propertyType));
                }
            }
        }
        return obj;
    }

    public static <T> T mock(Class<T> clazz, String... fields) {
        return mock(clazz, null, fields);
    }

    public static <T> List<T> mockList(Class<T> clazz, int count) {
        return mockList(clazz, null, count);
    }

    public static <T> List<T> mockList(Class<T> clazz, String... fields) {
        return mockList(clazz, null, 1, fields);
    }

    public static <T> List<T> mockList(Class<T> clazz, Map<String, Object> values, String... fields) {
        return mockList(clazz, values, 1, fields);
    }

    public static <T> List<T> mockList(Class<T> clazz, Map<String, Object> values, int count, String... fields) {
        if (count <= 0) {
            return Collections.emptyList();
        }
        List<T> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            list.add(mock(clazz, values, fields));
        }
        return list;
    }

    public static <T> Set<T> mockSet(Class<T> clazz, int count) {
        return new HashSet<>(mockList(clazz, null, count));
    }
    private static Object random(Class<?> propertyType) {
        if (Long.class.equals(propertyType)) {
            return RandomUtil.randomLong(0, 10);
        } else if (Integer.class.equals(propertyType)) {
            return RandomUtil.randomInt(0, 10);
        } else if (String.class.equals(propertyType)) {
            return RandomUtil.randomString(10);
        } else if (BigDecimal.class.equals(propertyType)) {
            return RandomUtil.randomBigDecimal(BigDecimal.valueOf(10));
        } else if (Date.class.equals(propertyType)) {
            return new Date();
        }
        return null;
    }

    private static boolean support(Class<?> clazz) {
        return Long.class.equals(clazz) || Integer.class.equals(clazz) || String.class.equals(clazz) || BigDecimal.class.equals(clazz) || Date.class.equals(clazz);
    }
    public static void verify(HttpStatus expected, ResponseEntity<?> actual) {
        Assertions.assertEquals(expected, actual.getStatusCode());
    }

    public static void verify(ResponseEntity<?> actual) {
        Assertions.assertEquals(HttpStatus.OK, actual.getStatusCode());
    }

    public static void verifyRemove(ResponseEntity<?> actual) {
        Assertions.assertEquals(HttpStatus.NO_CONTENT, actual.getStatusCode());
    }

    public static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
        try {
            return PowerMockito.method(clazz, methodName, parameterTypes);
        } catch (Exception e) {
            return null;
        }
    }

}