plusone/plusone-commons
1
1
Fork 1
Code Issues 1 Pull Requests Projects Releases 4 Activity

1.0.0-RC3 #21

Merged
ZhouXY108 merged 11 commits from 1.x.x into dev 2025-02-14 19:03:05 +08:00
Conversation 0 Commits 11 Files Changed 33 +217 -401
2 changed files with 217 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit ac0f73f7f0 - Show all commits

236
src/main/java/xyz/zhouxy/plusone/commons/model/dto/UnifiedResponse.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2023-2024 the original author or authors. * Copyright 2023-2025 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -17,109 +17,107 @@
package xyz.zhouxy.plusone.commons.model.dto; package xyz.zhouxy.plusone.commons.model.dto;
import java.util.Objects; import java.util.Objects;
import java.util.function.BooleanSupplier;
import java.util.function.Supplier;
import javax.annotation.Nullable; import javax.annotation.Nullable;
import xyz.zhouxy.plusone.commons.util.AssertTools;
/** /**
* 统一结果，对返回给前端的数据进行封装。 * 统一结果，对返回给前端的数据进行封装。
* *
* <p>
* <b>SUCCESS: 2000000</b>
* </p>
*
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a> * @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
*/ */
public abstract class UnifiedResponse { public class UnifiedResponse<T> {
private Object status; private String code;
private String message; private String message;
private @Nullable Object data; private @Nullable T data;
public static UnifiedResponse success() { // ================================
return new SuccessResult(); // #region - Constructors
// ================================
private UnifiedResponse(String code, @Nullable String message) {
this(code, message, null);
} }
public static UnifiedResponse success(@Nullable String message) { private UnifiedResponse(String code, @Nullable String message, @Nullable T data) {
return new SuccessResult(message); this.code = Objects.requireNonNull(code);
}
public static UnifiedResponse success(@Nullable String message, @Nullable Object data) {
return new SuccessResult(message, data);
}
public static UnifiedResponse error(@Nullable String message) {
return new ErrorResult(message);
}
public static UnifiedResponse error(@Nullable String message, @Nullable Object data) {
return new ErrorResult(message, data);
}
public static UnifiedResponse error(Object status, @Nullable String message) {
return new ErrorResult(status, message);
}
public static UnifiedResponse error(Object status, @Nullable String message, @Nullable Object data) {
return new ErrorResult(status, message, data);
}
public static UnifiedResponse error(Object status, Throwable e) {
return new ErrorResult(status, e);
}
public static UnifiedResponse of(Object status, @Nullable String message) {
return new CustomResult(status, message);
}
public static UnifiedResponse of(Object status, @Nullable String message, @Nullable Object data) {
return new CustomResult(status, message, data);
}
public static UnifiedResponse of(final boolean isSuccess,
final Supplier<SuccessResult> successResult, final Supplier<ErrorResult> errorResult) {
AssertTools.checkNotNull(successResult, "Success supplier must not be null.");
AssertTools.checkNotNull(errorResult, "Error supplier must not be null.");
return isSuccess ? successResult.get() : errorResult.get();
}
public static UnifiedResponse of(final BooleanSupplier isSuccess,
final Supplier<SuccessResult> successResult, final Supplier<ErrorResult> errorResult) {
AssertTools.checkNotNull(isSuccess, "Conditions for success must not be null.");
AssertTools.checkNotNull(successResult, "Success supplier must not be null.");
AssertTools.checkNotNull(errorResult, "Error supplier must not be null.");
return isSuccess.getAsBoolean() ? successResult.get() : errorResult.get();
}
protected UnifiedResponse(Object status, @Nullable String message) {
setStatus(status);
setMessage(message);
}
protected UnifiedResponse(Object status, @Nullable String message, @Nullable Object data) {
setStatus(status);
setMessage(message);
setData(data);
}
private void setStatus(Object status) {
this.status = Objects.requireNonNull(status);
}
private void setMessage(@Nullable String message) {
this.message = message == null ? "" : message; this.message = message == null ? "" : message;
}
private void setData(@Nullable Object data) {
this.data = data; this.data = data;
} }
// Constructors end // ================================
// #endregion - Constructors
// ================================
// Getters public static final String SUCCESS_CODE = "2000000";
private static final String DEFAULT_SUCCESS_MSG = "SUCCESS";
public Object getStatus() { // ================================
return status; // #region - success
// ================================
public static UnifiedResponse<Void> success() {
return new UnifiedResponse<>(SUCCESS_CODE, DEFAULT_SUCCESS_MSG);
}
public static UnifiedResponse<Void> success(@Nullable String message) {
return new UnifiedResponse<>(SUCCESS_CODE, message);
}
public static <T> UnifiedResponse<T> success(@Nullable String message, @Nullable T data) {
return new UnifiedResponse<>(SUCCESS_CODE, message, data);
}
// ================================
// #endregion - success
// ================================
// ================================
// #region - error
// ================================
public static UnifiedResponse<Void> error(String code, @Nullable String message) {
return new UnifiedResponse<>(code, message);
}
public static <T> UnifiedResponse<T> error(String code, @Nullable String message, @Nullable T data) {
return new UnifiedResponse<>(code, message, data);
}
public static UnifiedResponse<Void> error(String code, Throwable e) {
return new UnifiedResponse<>(code, e.getMessage());
}
// ================================
// #endregion - error
// ================================
// ================================
// #region - of
// ================================
public static UnifiedResponse<Void> of(String code, @Nullable String message) {
return new UnifiedResponse<>(code, message);
}
public static <T> UnifiedResponse<T> of(String code, @Nullable String message, @Nullable T data) {
return new UnifiedResponse<>(code, message, data);
}
// ================================
// #endregion - of
// ================================
// ================================
// #region - Getters
// ================================
public String getCode() {
return code;
} }
public String getMessage() { public String getMessage() {
@ -127,16 +125,18 @@ public abstract class UnifiedResponse {
} }
@Nullable @Nullable
public Object getData() { public T getData() {
return data; return data;
} }
// Getters end // ================================
// #endregion - Getters
// ================================
@Override @Override
public String toString() { public String toString() {
return String.format("{status: %s, message: \"%s\", data: %s}", return String.format("{code: \"%s\", message: \"%s\", data: %s}",
transValue(this.status), this.message, transValue(this.data)); this.code, this.message, transValue(this.data));
} }
private static String transValue(Object value) { private static String transValue(Object value) {
@ -148,62 +148,4 @@ public abstract class UnifiedResponse {
} }
return String.valueOf(value); return String.valueOf(value);
} }
protected static class SuccessResult extends UnifiedResponse {
public static final String SUCCESS_STATUS = "2000000";
private static final String DEFAULT_SUCCESS_MSG = "SUCCESS";
SuccessResult() {
super(SUCCESS_STATUS, DEFAULT_SUCCESS_MSG);
}
SuccessResult(@Nullable String message) {
super(SUCCESS_STATUS, message);
}
SuccessResult(@Nullable String message, @Nullable Object data) {
super(SUCCESS_STATUS, message, data);
}
}
protected static class ErrorResult extends UnifiedResponse {
public static final String DEFAULT_ERROR_STATUS = "9999999";
ErrorResult(@Nullable String message) {
super(DEFAULT_ERROR_STATUS, message);
}
ErrorResult(@Nullable String message, @Nullable Object data) {
super(DEFAULT_ERROR_STATUS, message, data);
}
ErrorResult(Object status, @Nullable String message) {
super(status, message);
}
ErrorResult(Object status, @Nullable String message, @Nullable Object data) {
super(status, message, data);
}
ErrorResult(Object status, Throwable e) {
super(status, Objects.requireNonNull(e).getMessage());
}
}
/**
* 自定义结果
*
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
*/
protected static class CustomResult extends UnifiedResponse {
CustomResult(Object status, @Nullable String message) {
super(status, message);
}
CustomResult(Object status, @Nullable String message, @Nullable Object data) {
super(status, message, data);
}
}
} }

382
src/test/java/xyz/zhouxy/plusone/commons/model/dto/UnifiedResponseTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2024 the original author or authors. * Copyright 2024-2025 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -30,7 +30,6 @@ import lombok.Data;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import xyz.zhouxy.plusone.commons.exception.business.BizException; import xyz.zhouxy.plusone.commons.exception.business.BizException;
import xyz.zhouxy.plusone.commons.model.dto.UnifiedResponse.SuccessResult;
@Slf4j @Slf4j
public public
@ -52,439 +51,314 @@ class UnifiedResponseTests {
@Test @Test
void testSuccess_WithoutArgument() throws Exception { void testSuccess_WithoutArgument() throws Exception {
// 1. success without argument // 1. success without argument
UnifiedResponse success = UnifiedResponse.success(); UnifiedResponse<Void> success = UnifiedResponse.success();
assertEquals(SuccessResult.SUCCESS_STATUS, success.getStatus()); assertEquals("2000000", success.getCode());
assertEquals("SUCCESS", success.getMessage()); assertEquals("SUCCESS", success.getMessage());
assertNull(success.getData()); assertNull(success.getData());
String jacksonSuccess = jackson.writeValueAsString(success); String jacksonSuccess = jackson.writeValueAsString(success);
log.info("jacksonSuccess: {}", jacksonSuccess); log.info("jacksonSuccess: {}", jacksonSuccess);
assertEquals("{\"status\":\"2000000\",\"message\":\"SUCCESS\"}", jacksonSuccess); assertEquals("{\"code\":\"2000000\",\"message\":\"SUCCESS\"}", jacksonSuccess);
} }
@Test @Test
void testSuccess_WithMessage() throws Exception { void testSuccess_WithMessage() throws Exception {
// 2. success with message // 2. success with message
UnifiedResponse successWithMessage = UnifiedResponse.success("成功"); UnifiedResponse<Void> successWithMessage = UnifiedResponse.success("成功");
assertEquals(SuccessResult.SUCCESS_STATUS, successWithMessage.getStatus()); assertEquals("2000000", successWithMessage.getCode());
assertEquals("成功", successWithMessage.getMessage()); assertEquals("成功", successWithMessage.getMessage());
assertNull(successWithMessage.getData()); assertNull(successWithMessage.getData());
String jacksonSuccessWithMessage = jackson.writeValueAsString(successWithMessage); String jacksonSuccessWithMessage = jackson.writeValueAsString(successWithMessage);
log.info("jacksonSuccessWithMessage: {}", jacksonSuccessWithMessage); log.info("jacksonSuccessWithMessage: {}", jacksonSuccessWithMessage);
assertEquals("{\"status\":\"2000000\",\"message\":\"成功\"}", jacksonSuccessWithMessage); assertEquals("{\"code\":\"2000000\",\"message\":\"成功\"}", jacksonSuccessWithMessage);
} }
@Test @Test
void testSuccess_WithMessageAndNullData() throws Exception { void testSuccess_WithMessageAndNullData() throws Exception {
// success with message and null data // success with message and null data
final UnifiedResponse successWithMessageAndNullData = UnifiedResponse.success("查询成功", null); final UnifiedResponse<Void> successWithMessageAndNullData = UnifiedResponse.success("查询成功", null);
assertEquals(SuccessResult.SUCCESS_STATUS, successWithMessageAndNullData.getStatus()); assertEquals("2000000", successWithMessageAndNullData.getCode());
assertEquals("查询成功", successWithMessageAndNullData.getMessage()); assertEquals("查询成功", successWithMessageAndNullData.getMessage());
assertNull(successWithMessageAndNullData.getData()); assertNull(successWithMessageAndNullData.getData());
final String jacksonSuccessWithMessageAndNullData = jackson.writeValueAsString(successWithMessageAndNullData); final String jacksonSuccessWithMessageAndNullData = jackson.writeValueAsString(successWithMessageAndNullData);
log.info("jacksonSuccessWithMessageAndNullData: {}", jacksonSuccessWithMessageAndNullData); log.info("jacksonSuccessWithMessageAndNullData: {}", jacksonSuccessWithMessageAndNullData);
assertEquals("{\"status\":\"2000000\",\"message\":\"查询成功\"}", jacksonSuccessWithMessageAndNullData); assertEquals("{\"code\":\"2000000\",\"message\":\"查询成功\"}", jacksonSuccessWithMessageAndNullData);
assertEquals("{status: \"2000000\", message: \"查询成功\", data: null}", successWithMessageAndNullData.toString()); assertEquals("{code: \"2000000\", message: \"查询成功\", data: null}", successWithMessageAndNullData.toString());
} }
@Test @Test
void testSuccess_WithMessageAndStringData() throws Exception { void testSuccess_WithMessageAndStringData() throws Exception {
UnifiedResponse successWithStringData = UnifiedResponse.success("查询成功", "zhouxy"); UnifiedResponse<String> successWithStringData = UnifiedResponse.success("查询成功", "zhouxy");
assertEquals(SuccessResult.SUCCESS_STATUS, successWithStringData.getStatus()); assertEquals("2000000", successWithStringData.getCode());
assertEquals("查询成功", successWithStringData.getMessage()); assertEquals("查询成功", successWithStringData.getMessage());
assertEquals("zhouxy", successWithStringData.getData()); assertEquals("zhouxy", successWithStringData.getData());
String jacksonSuccessWithStringData = jackson.writeValueAsString(successWithStringData); String jacksonSuccessWithStringData = jackson.writeValueAsString(successWithStringData);
log.info("jacksonSuccessWithStringData: {}", jacksonSuccessWithStringData); log.info("jacksonSuccessWithStringData: {}", jacksonSuccessWithStringData);
assertEquals("{\"status\":\"2000000\",\"message\":\"查询成功\",\"data\":\"zhouxy\"}", jacksonSuccessWithStringData); assertEquals("{\"code\":\"2000000\",\"message\":\"查询成功\",\"data\":\"zhouxy\"}", jacksonSuccessWithStringData);
assertEquals("{status: \"2000000\", message: \"查询成功\", data: \"zhouxy\"}", successWithStringData.toString()); assertEquals("{code: \"2000000\", message: \"查询成功\", data: \"zhouxy\"}", successWithStringData.toString());
} }
@Test @Test
void testSuccess_WithMessageAndIntegerData() throws Exception { void testSuccess_WithMessageAndIntegerData() throws Exception {
final UnifiedResponse successWithIntegerData = UnifiedResponse.success("查询成功", 1); final UnifiedResponse<Integer> successWithIntegerData = UnifiedResponse.success("查询成功", 1);
assertEquals(SuccessResult.SUCCESS_STATUS, successWithIntegerData.getStatus()); assertEquals("2000000", successWithIntegerData.getCode());
assertEquals("查询成功", successWithIntegerData.getMessage()); assertEquals("查询成功", successWithIntegerData.getMessage());
assertEquals(1, successWithIntegerData.getData()); assertEquals(1, successWithIntegerData.getData());
final String jacksonSuccessWithIntegerData = jackson.writeValueAsString(successWithIntegerData); final String jacksonSuccessWithIntegerData = jackson.writeValueAsString(successWithIntegerData);
log.info("jacksonSuccessWithIntegerData: {}", jacksonSuccessWithIntegerData); log.info("jacksonSuccessWithIntegerData: {}", jacksonSuccessWithIntegerData);
assertEquals("{\"status\":\"2000000\",\"message\":\"查询成功\",\"data\":1}", jacksonSuccessWithIntegerData); assertEquals("{\"code\":\"2000000\",\"message\":\"查询成功\",\"data\":1}", jacksonSuccessWithIntegerData);
assertEquals("{status: \"2000000\", message: \"查询成功\", data: 1}", successWithIntegerData.toString()); assertEquals("{code: \"2000000\", message: \"查询成功\", data: 1}", successWithIntegerData.toString());
} }
@Test @Test
void testSuccess_WithMessageAndData() throws Exception { void testSuccess_WithMessageAndData() throws Exception {
UnifiedResponse successWithData = UnifiedResponse.success("查询成功", pageResult); UnifiedResponse<PageResult<User>> successWithData = UnifiedResponse.success("查询成功", pageResult);
assertEquals(SuccessResult.SUCCESS_STATUS, successWithData.getStatus()); assertEquals("2000000", successWithData.getCode());
assertEquals("查询成功", successWithData.getMessage()); assertEquals("查询成功", successWithData.getMessage());
assertNotNull(successWithData.getData()); assertNotNull(successWithData.getData());
assertEquals(pageResult, successWithData.getData()); assertEquals(pageResult, successWithData.getData());
String jacksonSuccessWithData = jackson.writeValueAsString(successWithData); String jacksonSuccessWithData = jackson.writeValueAsString(successWithData);
log.info("jacksonSuccessWithData: {}", jacksonSuccessWithData); log.info("jacksonSuccessWithData: {}", jacksonSuccessWithData);
assertEquals("{\"status\":\"2000000\",\"message\":\"查询成功\",\"data\":{\"total\":108,\"content\":[{\"username\":\"zhouxy1\",\"email\":\"zhouxy1@gmail.com\"},{\"username\":\"zhouxy2\",\"email\":\"zhouxy2@gmail.com\"}]}}", jacksonSuccessWithData); assertEquals("{\"code\":\"2000000\",\"message\":\"查询成功\",\"data\":{\"total\":108,\"content\":[{\"username\":\"zhouxy1\",\"email\":\"zhouxy1@gmail.com\"},{\"username\":\"zhouxy2\",\"email\":\"zhouxy2@gmail.com\"}]}}", jacksonSuccessWithData);
} }
@Test @Test
void testSuccess_WithNullMessage() throws Exception { void testSuccess_WithNullMessage() throws Exception {
// 3. success with null message // 3. success with null message
UnifiedResponse successWithNullMessage = UnifiedResponse.success(null); UnifiedResponse<Void> successWithNullMessage = UnifiedResponse.success(null);
assertEquals(SuccessResult.SUCCESS_STATUS, successWithNullMessage.getStatus()); assertEquals("2000000", successWithNullMessage.getCode());
assertEquals("", successWithNullMessage.getMessage()); assertEquals("", successWithNullMessage.getMessage());
assertNull(successWithNullMessage.getData()); assertNull(successWithNullMessage.getData());
String jacksonSuccessWithNullMessage = jackson.writeValueAsString(successWithNullMessage); String jacksonSuccessWithNullMessage = jackson.writeValueAsString(successWithNullMessage);
log.info("jacksonSuccessWithNullMessage: {}", jacksonSuccessWithNullMessage); log.info("jacksonSuccessWithNullMessage: {}", jacksonSuccessWithNullMessage);
assertEquals("{\"status\":\"2000000\",\"message\":\"\"}", jacksonSuccessWithNullMessage); assertEquals("{\"code\":\"2000000\",\"message\":\"\"}", jacksonSuccessWithNullMessage);
} }
// success with null message and null data // success with null message and null data
@Test @Test
void testSuccess_WithNullMessageAndNullData() throws Exception { void testSuccess_WithNullMessageAndNullData() throws Exception {
final UnifiedResponse successWithNullMessageAndNullData = UnifiedResponse.success(null, null); final UnifiedResponse<Void> successWithNullMessageAndNullData = UnifiedResponse.success(null, null);
assertEquals(SuccessResult.SUCCESS_STATUS, successWithNullMessageAndNullData.getStatus()); assertEquals("2000000", successWithNullMessageAndNullData.getCode());
assertEquals("", successWithNullMessageAndNullData.getMessage()); assertEquals("", successWithNullMessageAndNullData.getMessage());
assertNull(successWithNullMessageAndNullData.getData()); assertNull(successWithNullMessageAndNullData.getData());
final String jacksonSuccessWithNullMessageAndNullData = jackson.writeValueAsString(successWithNullMessageAndNullData); final String jacksonSuccessWithNullMessageAndNullData = jackson.writeValueAsString(successWithNullMessageAndNullData);
log.info("jacksonSuccessWithNullMessageAndNullData: {}", jacksonSuccessWithNullMessageAndNullData); log.info("jacksonSuccessWithNullMessageAndNullData: {}", jacksonSuccessWithNullMessageAndNullData);
assertEquals("{\"status\":\"2000000\",\"message\":\"\"}", jacksonSuccessWithNullMessageAndNullData); assertEquals("{\"code\":\"2000000\",\"message\":\"\"}", jacksonSuccessWithNullMessageAndNullData);
assertEquals("{status: \"2000000\", message: \"\", data: null}", successWithNullMessageAndNullData.toString()); assertEquals("{code: \"2000000\", message: \"\", data: null}", successWithNullMessageAndNullData.toString());
} }
@Test @Test
void testSuccess_WithNullMessageAndData() throws Exception { void testSuccess_WithNullMessageAndData() throws Exception {
// success with null message and data // success with null message and data
final User user = new User("zhouxy", "zhouxy@code108.cn"); final User user = new User("zhouxy", "zhouxy@code108.cn");
final UnifiedResponse successWithNullMessageAndData = UnifiedResponse.success(null, user); final UnifiedResponse<User> successWithNullMessageAndData = UnifiedResponse.success(null, user);
assertEquals(SuccessResult.SUCCESS_STATUS, successWithNullMessageAndData.getStatus()); assertEquals("2000000", successWithNullMessageAndData.getCode());
assertEquals("", successWithNullMessageAndData.getMessage()); assertEquals("", successWithNullMessageAndData.getMessage());
assertEquals(user, successWithNullMessageAndData.getData()); assertEquals(user, successWithNullMessageAndData.getData());
final String jacksonSuccessWithNullMessageAndData = jackson.writeValueAsString(successWithNullMessageAndData); final String jacksonSuccessWithNullMessageAndData = jackson.writeValueAsString(successWithNullMessageAndData);
log.info("jacksonSuccessWithNullMessageAndData: {}", jacksonSuccessWithNullMessageAndData); log.info("jacksonSuccessWithNullMessageAndData: {}", jacksonSuccessWithNullMessageAndData);
assertEquals("{\"status\":\"2000000\",\"message\":\"\",\"data\":{\"username\":\"zhouxy\",\"email\":\"zhouxy@code108.cn\"}}", assertEquals("{\"code\":\"2000000\",\"message\":\"\",\"data\":{\"username\":\"zhouxy\",\"email\":\"zhouxy@code108.cn\"}}",
jacksonSuccessWithNullMessageAndData); jacksonSuccessWithNullMessageAndData);
} }
@Test @Test
void testSuccess_WithEmptyMessage() throws Exception { void testSuccess_WithEmptyMessage() throws Exception {
// 4. success with empty message // 4. success with empty message
UnifiedResponse successWithEmptyMessage = UnifiedResponse.success(""); UnifiedResponse<Void> successWithEmptyMessage = UnifiedResponse.success("");
assertEquals(SuccessResult.SUCCESS_STATUS, successWithEmptyMessage.getStatus()); assertEquals("2000000", successWithEmptyMessage.getCode());
assertEquals("", successWithEmptyMessage.getMessage()); assertEquals("", successWithEmptyMessage.getMessage());
assertNull(successWithEmptyMessage.getData()); assertNull(successWithEmptyMessage.getData());
String jacksonSuccessWithEmptyMessage = jackson.writeValueAsString(successWithEmptyMessage); String jacksonSuccessWithEmptyMessage = jackson.writeValueAsString(successWithEmptyMessage);
log.info("jacksonSuccessWithEmptyMessage: {}", jacksonSuccessWithEmptyMessage); log.info("jacksonSuccessWithEmptyMessage: {}", jacksonSuccessWithEmptyMessage);
assertEquals("{\"status\":\"2000000\",\"message\":\"\"}", jacksonSuccessWithEmptyMessage); assertEquals("{\"code\":\"2000000\",\"message\":\"\"}", jacksonSuccessWithEmptyMessage);
} }
// success with empty message and null data // success with empty message and null data
@Test @Test
void testSuccess_WithEmptyMessageAndNullData() throws Exception { void testSuccess_WithEmptyMessageAndNullData() throws Exception {
final UnifiedResponse successWithEmptyMessageAndNullData = UnifiedResponse.success("", null); final UnifiedResponse<Void> successWithEmptyMessageAndNullData = UnifiedResponse.success("", null);
assertEquals(SuccessResult.SUCCESS_STATUS, successWithEmptyMessageAndNullData.getStatus()); assertEquals("2000000", successWithEmptyMessageAndNullData.getCode());
assertEquals("", successWithEmptyMessageAndNullData.getMessage()); assertEquals("", successWithEmptyMessageAndNullData.getMessage());
assertNull(successWithEmptyMessageAndNullData.getData()); assertNull(successWithEmptyMessageAndNullData.getData());
final String jacksonSuccessWithEmptyMessageAndNullData = jackson.writeValueAsString(successWithEmptyMessageAndNullData); final String jacksonSuccessWithEmptyMessageAndNullData = jackson.writeValueAsString(successWithEmptyMessageAndNullData);
log.info("jacksonSuccessWithEmptyMessageAndNullData: {}", jacksonSuccessWithEmptyMessageAndNullData); log.info("jacksonSuccessWithEmptyMessageAndNullData: {}", jacksonSuccessWithEmptyMessageAndNullData);
assertEquals("{\"status\":\"2000000\",\"message\":\"\"}", jacksonSuccessWithEmptyMessageAndNullData); assertEquals("{\"code\":\"2000000\",\"message\":\"\"}", jacksonSuccessWithEmptyMessageAndNullData);
assertEquals("{status: \"2000000\", message: \"\", data: null}", successWithEmptyMessageAndNullData.toString()); assertEquals("{code: \"2000000\", message: \"\", data: null}", successWithEmptyMessageAndNullData.toString());
} }
// success with empty message and data // success with empty message and data
@Test @Test
void testSuccess_WithEmptyMessageAndData() throws Exception { void testSuccess_WithEmptyMessageAndData() throws Exception {
final User user = new User("zhouxy", "zhouxy@gmail.com"); final User user = new User("zhouxy", "zhouxy@gmail.com");
final UnifiedResponse successWithEmptyMessageAndData = UnifiedResponse.success("", user); final UnifiedResponse<User> successWithEmptyMessageAndData = UnifiedResponse.success("", user);
assertEquals(SuccessResult.SUCCESS_STATUS, successWithEmptyMessageAndData.getStatus()); assertEquals("2000000", successWithEmptyMessageAndData.getCode());
assertEquals("", successWithEmptyMessageAndData.getMessage()); assertEquals("", successWithEmptyMessageAndData.getMessage());
assertEquals(user, successWithEmptyMessageAndData.getData()); assertEquals(user, successWithEmptyMessageAndData.getData());
final String jacksonSuccessWithEmptyMessageAndData = jackson.writeValueAsString(successWithEmptyMessageAndData); final String jacksonSuccessWithEmptyMessageAndData = jackson.writeValueAsString(successWithEmptyMessageAndData);
log.info("jacksonSuccessWithEmptyMessageAndData: {}", jacksonSuccessWithEmptyMessageAndData); log.info("jacksonSuccessWithEmptyMessageAndData: {}", jacksonSuccessWithEmptyMessageAndData);
assertEquals("{\"status\":\"2000000\",\"message\":\"\",\"data\":{\"username\":\"zhouxy\",\"email\":\"zhouxy@gmail.com\"}}", jacksonSuccessWithEmptyMessageAndData); assertEquals("{\"code\":\"2000000\",\"message\":\"\",\"data\":{\"username\":\"zhouxy\",\"email\":\"zhouxy@gmail.com\"}}", jacksonSuccessWithEmptyMessageAndData);
}
@Test
void testError_WithMessage() throws Exception {
UnifiedResponse errorWithMessage = UnifiedResponse.error("查询失败");
assertEquals("9999999", errorWithMessage.getStatus());
assertEquals("查询失败", errorWithMessage.getMessage());
assertNull(errorWithMessage.getData());
final String jacksonErrorWithMessage = jackson.writeValueAsString(errorWithMessage);
assertEquals("{\"status\":\"9999999\",\"message\":\"查询失败\"}", jacksonErrorWithMessage);
final String gsonErrorWithMessage = gson.toJson(errorWithMessage);
assertEquals("{\"status\":\"9999999\",\"message\":\"查询失败\"}", gsonErrorWithMessage);
}
@Test
void testError_WithMessage_AndNullData() throws Exception {
UnifiedResponse errorWithMessageAndNullData = UnifiedResponse.error("查询失败", (Object) null);
assertEquals("9999999", errorWithMessageAndNullData.getStatus());
assertEquals("查询失败", errorWithMessageAndNullData.getMessage());
assertNull(errorWithMessageAndNullData.getData());
final String jacksonErrorWithMessageAndNullData = jackson.writeValueAsString(errorWithMessageAndNullData);
assertEquals("{\"status\":\"9999999\",\"message\":\"查询失败\"}", jacksonErrorWithMessageAndNullData);
final String gsonErrorWithMessageAndNullData = gson.toJson(errorWithMessageAndNullData);
assertEquals("{\"status\":\"9999999\",\"message\":\"查询失败\"}", gsonErrorWithMessageAndNullData);
}
@Test
void testError_WithMessage_AndData() throws Exception {
final User user = new User("zhouxy", "zhouxy@gmail.com");
UnifiedResponse errorWithMessageAndData = UnifiedResponse.error("查询失败", user);
assertEquals("9999999", errorWithMessageAndData.getStatus());
assertEquals("查询失败", errorWithMessageAndData.getMessage());
assertEquals(user, errorWithMessageAndData.getData());
final String jacksonErrorWithMessageAndData = jackson.writeValueAsString(errorWithMessageAndData);
assertEquals("{\"status\":\"9999999\",\"message\":\"查询失败\",\"data\":{\"username\":\"zhouxy\",\"email\":\"zhouxy@gmail.com\"}}",
jacksonErrorWithMessageAndData);
final String gsonErrorWithMessageAndData = gson.toJson(errorWithMessageAndData);
assertEquals("{\"status\":\"9999999\",\"message\":\"查询失败\",\"data\":{\"username\":\"zhouxy\",\"email\":\"zhouxy@gmail.com\"}}",
gsonErrorWithMessageAndData);
}
@Test
void testError_WithNullMessage() throws Exception {
UnifiedResponse errorWithNullMessage = UnifiedResponse.error((String) null);
assertEquals("9999999", errorWithNullMessage.getStatus());
assertEquals("", errorWithNullMessage.getMessage());
assertNull(errorWithNullMessage.getData());
final String jacksonErrorWithNullMessage = jackson.writeValueAsString(errorWithNullMessage);
assertEquals("{\"status\":\"9999999\",\"message\":\"\"}", jacksonErrorWithNullMessage);
final String gsonErrorWithNullMessage = gson.toJson(errorWithNullMessage);
assertEquals("{\"status\":\"9999999\",\"message\":\"\"}", gsonErrorWithNullMessage);
}
@Test
void testError_WithNullMessage_AndNullData() throws Exception {
UnifiedResponse errorWithNullMessageAndNullData = UnifiedResponse.error((String) null, (User) null);
assertEquals("9999999", errorWithNullMessageAndNullData.getStatus());
assertEquals("", errorWithNullMessageAndNullData.getMessage());
assertNull(errorWithNullMessageAndNullData.getData());
final String jacksonErrorWithNullMessageAndNullData = jackson.writeValueAsString(errorWithNullMessageAndNullData);
assertEquals("{\"status\":\"9999999\",\"message\":\"\"}", jacksonErrorWithNullMessageAndNullData);
final String gsonErrorWithNullMessageAndNullData = gson.toJson(errorWithNullMessageAndNullData);
assertEquals("{\"status\":\"9999999\",\"message\":\"\"}", gsonErrorWithNullMessageAndNullData);
}
@Test
void testError_WithNullMessage_AndData() throws Exception {
final User user = new User("zhouxy1", "zhouxy1@gmail.com");
UnifiedResponse errorWithNullMessageAndData = UnifiedResponse.error((String) null, user);
assertEquals("9999999", errorWithNullMessageAndData.getStatus());
assertEquals("", errorWithNullMessageAndData.getMessage());
assertEquals(user, errorWithNullMessageAndData.getData());
final String jacksonErrorWithNullMessageAndData = jackson.writeValueAsString(errorWithNullMessageAndData);
assertEquals("{\"status\":\"9999999\",\"message\":\"\",\"data\":{\"username\":\"zhouxy1\",\"email\":\"zhouxy1@gmail.com\"}}",
jacksonErrorWithNullMessageAndData);
final String gsonErrorWithNullMessageAndData = gson.toJson(errorWithNullMessageAndData);
assertEquals("{\"status\":\"9999999\",\"message\":\"\",\"data\":{\"username\":\"zhouxy1\",\"email\":\"zhouxy1@gmail.com\"}}",
gsonErrorWithNullMessageAndData);
}
@Test
void testError_WithEmptyMessage() throws Exception {
UnifiedResponse errorWithEmptyMessage = UnifiedResponse.error("");
assertEquals("9999999", errorWithEmptyMessage.getStatus());
assertEquals("", errorWithEmptyMessage.getMessage());
assertNull(errorWithEmptyMessage.getData());
final String jacksonErrorWithEmptyMessage = jackson.writeValueAsString(errorWithEmptyMessage);
assertEquals("{\"status\":\"9999999\",\"message\":\"\"}", jacksonErrorWithEmptyMessage);
final String gsonErrorWithEmptyMessage = gson.toJson(errorWithEmptyMessage);
assertEquals("{\"status\":\"9999999\",\"message\":\"\"}", gsonErrorWithEmptyMessage);
}
@Test
void testError_WithEmptyMessage_AndNullData() throws Exception {
UnifiedResponse errorWithEmptyMessageAndNullData = UnifiedResponse.error("", (User) null);
assertEquals("9999999", errorWithEmptyMessageAndNullData.getStatus());
assertEquals("", errorWithEmptyMessageAndNullData.getMessage());
assertNull(errorWithEmptyMessageAndNullData.getData());
final String jacksonErrorEmptyNullMessageAndNullData = jackson.writeValueAsString(errorWithEmptyMessageAndNullData);
assertEquals("{\"status\":\"9999999\",\"message\":\"\"}", jacksonErrorEmptyNullMessageAndNullData);
final String gsonErrorWithEmptyMessageAndNullData = gson.toJson(errorWithEmptyMessageAndNullData);
assertEquals("{\"status\":\"9999999\",\"message\":\"\"}", gsonErrorWithEmptyMessageAndNullData);
}
@Test
void testError_WithEmptyMessage_AndData() throws Exception {
final User user = new User("zhouxy1", "zhouxy1@gmail.com");
UnifiedResponse errorWithEmptyMessageAndData = UnifiedResponse.error("", user);
assertEquals("9999999", errorWithEmptyMessageAndData.getStatus());
assertEquals("", errorWithEmptyMessageAndData.getMessage());
assertEquals(user, errorWithEmptyMessageAndData.getData());
final String jacksonErrorWithEmptyMessageAndData = jackson.writeValueAsString(errorWithEmptyMessageAndData);
assertEquals("{\"status\":\"9999999\",\"message\":\"\",\"data\":{\"username\":\"zhouxy1\",\"email\":\"zhouxy1@gmail.com\"}}",
jacksonErrorWithEmptyMessageAndData);
final String gsonErrorWithEmptyMessageAndData = gson.toJson(errorWithEmptyMessageAndData);
assertEquals("{\"status\":\"9999999\",\"message\":\"\",\"data\":{\"username\":\"zhouxy1\",\"email\":\"zhouxy1@gmail.com\"}}",
gsonErrorWithEmptyMessageAndData);
} }
@Test @Test
void testError_WithStatusAndMessage() throws Exception { void testError_WithStatusAndMessage() throws Exception {
final UnifiedResponse errorWithStatusAndMessage = UnifiedResponse.error(108, "查询失败"); final UnifiedResponse<Void> errorWithStatusAndMessage = UnifiedResponse.error("108", "查询失败");
assertEquals(108, errorWithStatusAndMessage.getStatus()); assertEquals("108", errorWithStatusAndMessage.getCode());
assertEquals("查询失败", errorWithStatusAndMessage.getMessage()); assertEquals("查询失败", errorWithStatusAndMessage.getMessage());
assertNull(errorWithStatusAndMessage.getData()); assertNull(errorWithStatusAndMessage.getData());
assertEquals("{status: 108, message: \"查询失败\", data: null}", errorWithStatusAndMessage.toString()); assertEquals("{code: \"108\", message: \"查询失败\", data: null}", errorWithStatusAndMessage.toString());
final String jacksonErrorWithStatusAndMessage = jackson.writeValueAsString(errorWithStatusAndMessage); final String jacksonErrorWithStatusAndMessage = jackson.writeValueAsString(errorWithStatusAndMessage);
log.info("jacksonErrorWithStatusAndMessage: {}", jacksonErrorWithStatusAndMessage); log.info("jacksonErrorWithStatusAndMessage: {}", jacksonErrorWithStatusAndMessage);
assertEquals("{\"status\":108,\"message\":\"查询失败\"}", jacksonErrorWithStatusAndMessage); assertEquals("{\"code\":\"108\",\"message\":\"查询失败\"}", jacksonErrorWithStatusAndMessage);
final String gsonErrorWithStatusAndMessage = gson.toJson(errorWithStatusAndMessage); final String gsonErrorWithStatusAndMessage = gson.toJson(errorWithStatusAndMessage);
assertEquals("{\"status\":108,\"message\":\"查询失败\"}", gsonErrorWithStatusAndMessage); assertEquals("{\"code\":\"108\",\"message\":\"查询失败\"}", gsonErrorWithStatusAndMessage);
} }
@Test @Test
void testError_WithStatusAndMessage_AndNullData() throws Exception { void testError_WithStatusAndMessage_AndNullData() throws Exception {
final UnifiedResponse errorWithStatusAndMessageAndNullData = UnifiedResponse.error(108, "查询失败", null); final UnifiedResponse<Void> errorWithStatusAndMessageAndNullData = UnifiedResponse.error("108", "查询失败", null);
assertEquals(108, errorWithStatusAndMessageAndNullData.getStatus()); assertEquals("108", errorWithStatusAndMessageAndNullData.getCode());
assertEquals("查询失败", errorWithStatusAndMessageAndNullData.getMessage()); assertEquals("查询失败", errorWithStatusAndMessageAndNullData.getMessage());
assertNull(errorWithStatusAndMessageAndNullData.getData()); assertNull(errorWithStatusAndMessageAndNullData.getData());
assertEquals("{status: 108, message: \"查询失败\", data: null}", errorWithStatusAndMessageAndNullData.toString()); assertEquals("{code: \"108\", message: \"查询失败\", data: null}", errorWithStatusAndMessageAndNullData.toString());
final String jacksonErrorWithStatusAndMessageAndNullData = jackson.writeValueAsString(errorWithStatusAndMessageAndNullData); final String jacksonErrorWithStatusAndMessageAndNullData = jackson.writeValueAsString(errorWithStatusAndMessageAndNullData);
log.info("jacksonErrorWithStatusAndMessage: {}", jacksonErrorWithStatusAndMessageAndNullData); log.info("jacksonErrorWithStatusAndMessage: {}", jacksonErrorWithStatusAndMessageAndNullData);
assertEquals("{\"status\":108,\"message\":\"查询失败\"}", jacksonErrorWithStatusAndMessageAndNullData); assertEquals("{\"code\":\"108\",\"message\":\"查询失败\"}", jacksonErrorWithStatusAndMessageAndNullData);
final String gsonErrorWithStatusAndMessageAndNullData = gson.toJson(errorWithStatusAndMessageAndNullData); final String gsonErrorWithStatusAndMessageAndNullData = gson.toJson(errorWithStatusAndMessageAndNullData);
assertEquals("{\"status\":108,\"message\":\"查询失败\"}", gsonErrorWithStatusAndMessageAndNullData); assertEquals("{\"code\":\"108\",\"message\":\"查询失败\"}", gsonErrorWithStatusAndMessageAndNullData);
} }
@Test @Test
void testError_WithStatusAndMessage_AndData() throws Exception { void testError_WithStatusAndMessage_AndData() throws Exception {
final PageResult<User> emptyPageResult = PageResult.empty(); final PageResult<User> emptyPageResult = PageResult.empty();
final UnifiedResponse errorWithStatusAndMessageAndData = UnifiedResponse.error(108, "查询失败", emptyPageResult); final UnifiedResponse<PageResult<User>> errorWithStatusAndMessageAndData = UnifiedResponse.error("108", "查询失败", emptyPageResult);
assertEquals(108, errorWithStatusAndMessageAndData.getStatus()); assertEquals("108", errorWithStatusAndMessageAndData.getCode());
assertEquals("查询失败", errorWithStatusAndMessageAndData.getMessage()); assertEquals("查询失败", errorWithStatusAndMessageAndData.getMessage());
assertEquals(emptyPageResult, errorWithStatusAndMessageAndData.getData()); assertEquals(emptyPageResult, errorWithStatusAndMessageAndData.getData());
assertEquals("{status: 108, message: \"查询失败\", data: PageResult [total=0, content=[]]}", errorWithStatusAndMessageAndData.toString()); assertEquals("{code: \"108\", message: \"查询失败\", data: PageResult [total=0, content=[]]}", errorWithStatusAndMessageAndData.toString());
final String jacksonErrorWithStatusAndMessageAndData = jackson.writeValueAsString(errorWithStatusAndMessageAndData); final String jacksonErrorWithStatusAndMessageAndData = jackson.writeValueAsString(errorWithStatusAndMessageAndData);
assertEquals("{\"status\":108,\"message\":\"查询失败\",\"data\":{\"total\":0,\"content\":[]}}", assertEquals("{\"code\":\"108\",\"message\":\"查询失败\",\"data\":{\"total\":0,\"content\":[]}}",
jacksonErrorWithStatusAndMessageAndData); jacksonErrorWithStatusAndMessageAndData);
final String gsonErrorWithStatusAndMessageAndData = gson.toJson(errorWithStatusAndMessageAndData); final String gsonErrorWithStatusAndMessageAndData = gson.toJson(errorWithStatusAndMessageAndData);
assertEquals("{\"status\":108,\"message\":\"查询失败\",\"data\":{\"total\":0,\"content\":[]}}", assertEquals("{\"code\":\"108\",\"message\":\"查询失败\",\"data\":{\"total\":0,\"content\":[]}}",
gsonErrorWithStatusAndMessageAndData); gsonErrorWithStatusAndMessageAndData);
} }
@Test @Test
void testError_WithStatusAndNullMessage() throws Exception { void testError_WithStatusAndNullMessage() throws Exception {
UnifiedResponse errorWithStatusAndNullMessage = UnifiedResponse.error(500, (String) null); UnifiedResponse<Void> errorWithStatusAndNullMessage = UnifiedResponse.error("500", (String) null);
assertEquals(500, errorWithStatusAndNullMessage.getStatus()); assertEquals("500", errorWithStatusAndNullMessage.getCode());
assertEquals("", errorWithStatusAndNullMessage.getMessage()); assertEquals("", errorWithStatusAndNullMessage.getMessage());
assertNull(errorWithStatusAndNullMessage.getData()); assertNull(errorWithStatusAndNullMessage.getData());
final String jacksonErrorWithStatusAndNullMessage = jackson.writeValueAsString(errorWithStatusAndNullMessage); final String jacksonErrorWithStatusAndNullMessage = jackson.writeValueAsString(errorWithStatusAndNullMessage);
assertEquals("{\"status\":500,\"message\":\"\"}", jacksonErrorWithStatusAndNullMessage); assertEquals("{\"code\":\"500\",\"message\":\"\"}", jacksonErrorWithStatusAndNullMessage);
final String gsonErrorWithStatusAndNullMessage = gson.toJson(errorWithStatusAndNullMessage); final String gsonErrorWithStatusAndNullMessage = gson.toJson(errorWithStatusAndNullMessage);
assertEquals("{\"status\":500,\"message\":\"\"}", gsonErrorWithStatusAndNullMessage); assertEquals("{\"code\":\"500\",\"message\":\"\"}", gsonErrorWithStatusAndNullMessage);
} }
@Test @Test
void testError_WithStatusAndNullMessage_AndNullData() throws Exception { void testError_WithStatusAndNullMessage_AndNullData() throws Exception {
UnifiedResponse errorWithStatusAndNullMessageAndNullData = UnifiedResponse.error(500, (String) null, null); UnifiedResponse<Void> errorWithStatusAndNullMessageAndNullData = UnifiedResponse.error("500", (String) null, null);
assertEquals(500, errorWithStatusAndNullMessageAndNullData.getStatus()); assertEquals("500", errorWithStatusAndNullMessageAndNullData.getCode());
assertEquals("", errorWithStatusAndNullMessageAndNullData.getMessage()); assertEquals("", errorWithStatusAndNullMessageAndNullData.getMessage());
assertNull(errorWithStatusAndNullMessageAndNullData.getData()); assertNull(errorWithStatusAndNullMessageAndNullData.getData());
final String jacksonErrorWithStatusAndNullMessageAndNullData = jackson.writeValueAsString(errorWithStatusAndNullMessageAndNullData); final String jacksonErrorWithStatusAndNullMessageAndNullData = jackson.writeValueAsString(errorWithStatusAndNullMessageAndNullData);
assertEquals("{\"status\":500,\"message\":\"\"}", jacksonErrorWithStatusAndNullMessageAndNullData); assertEquals("{\"code\":\"500\",\"message\":\"\"}", jacksonErrorWithStatusAndNullMessageAndNullData);
final String gsonErrorWithStatusAndNullMessageAndNullData = gson.toJson(errorWithStatusAndNullMessageAndNullData); final String gsonErrorWithStatusAndNullMessageAndNullData = gson.toJson(errorWithStatusAndNullMessageAndNullData);
assertEquals("{\"status\":500,\"message\":\"\"}", gsonErrorWithStatusAndNullMessageAndNullData); assertEquals("{\"code\":\"500\",\"message\":\"\"}", gsonErrorWithStatusAndNullMessageAndNullData);
} }
@Test @Test
void testError_WithStatusAndNullMessage_AndData() throws Exception { void testError_WithStatusAndNullMessage_AndData() throws Exception {
PageResult<User> emptyPageResult = PageResult.empty(); PageResult<User> emptyPageResult = PageResult.empty();
UnifiedResponse errorWithStatusAndNullMessageAndData = UnifiedResponse.error(500, (String) null, emptyPageResult); UnifiedResponse<PageResult<User>> errorWithStatusAndNullMessageAndData = UnifiedResponse.error("500", (String) null, emptyPageResult);
assertEquals(500, errorWithStatusAndNullMessageAndData.getStatus()); assertEquals("500", errorWithStatusAndNullMessageAndData.getCode());
assertEquals("", errorWithStatusAndNullMessageAndData.getMessage()); assertEquals("", errorWithStatusAndNullMessageAndData.getMessage());
assertEquals(emptyPageResult, errorWithStatusAndNullMessageAndData.getData()); assertEquals(emptyPageResult, errorWithStatusAndNullMessageAndData.getData());
final String jacksonErrorWithStatusAndNullMessageAndData = jackson.writeValueAsString(errorWithStatusAndNullMessageAndData); final String jacksonErrorWithStatusAndNullMessageAndData = jackson.writeValueAsString(errorWithStatusAndNullMessageAndData);
assertEquals("{\"status\":500,\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", jacksonErrorWithStatusAndNullMessageAndData); assertEquals("{\"code\":\"500\",\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", jacksonErrorWithStatusAndNullMessageAndData);
final String gsonErrorWithStatusAndNullMessageAndData = gson.toJson(errorWithStatusAndNullMessageAndData); final String gsonErrorWithStatusAndNullMessageAndData = gson.toJson(errorWithStatusAndNullMessageAndData);
assertEquals("{\"status\":500,\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", gsonErrorWithStatusAndNullMessageAndData); assertEquals("{\"code\":\"500\",\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", gsonErrorWithStatusAndNullMessageAndData);
} }
@Test @Test
void testError_WithStatusAndEmptyMessage() throws Exception { void testError_WithStatusAndEmptyMessage() throws Exception {
UnifiedResponse errorWithStatusAndEmptyMessage = UnifiedResponse.error(500, ""); UnifiedResponse<Void> errorWithStatusAndEmptyMessage = UnifiedResponse.error("500", "");
assertEquals(500, errorWithStatusAndEmptyMessage.getStatus()); assertEquals("500", errorWithStatusAndEmptyMessage.getCode());
assertEquals("", errorWithStatusAndEmptyMessage.getMessage()); assertEquals("", errorWithStatusAndEmptyMessage.getMessage());
assertNull(errorWithStatusAndEmptyMessage.getData()); assertNull(errorWithStatusAndEmptyMessage.getData());
final String jacksonErrorWithStatusAndEmptyMessage = jackson.writeValueAsString(errorWithStatusAndEmptyMessage); final String jacksonErrorWithStatusAndEmptyMessage = jackson.writeValueAsString(errorWithStatusAndEmptyMessage);
assertEquals("{\"status\":500,\"message\":\"\"}", jacksonErrorWithStatusAndEmptyMessage); assertEquals("{\"code\":\"500\",\"message\":\"\"}", jacksonErrorWithStatusAndEmptyMessage);
final String gsonErrorWithStatusAndEmptyMessage = gson.toJson(errorWithStatusAndEmptyMessage); final String gsonErrorWithStatusAndEmptyMessage = gson.toJson(errorWithStatusAndEmptyMessage);
assertEquals("{\"status\":500,\"message\":\"\"}", gsonErrorWithStatusAndEmptyMessage); assertEquals("{\"code\":\"500\",\"message\":\"\"}", gsonErrorWithStatusAndEmptyMessage);
} }
@Test @Test
void testError_WithStatusAndEmptyMessage_AndNullData() throws Exception { void testError_WithStatusAndEmptyMessage_AndNullData() throws Exception {
UnifiedResponse errorWithStatusAndEmptyMessageAndNullData = UnifiedResponse.error(500, "", null); UnifiedResponse<Void> errorWithStatusAndEmptyMessageAndNullData = UnifiedResponse.error("500", "", null);
assertEquals(500, errorWithStatusAndEmptyMessageAndNullData.getStatus()); assertEquals("500", errorWithStatusAndEmptyMessageAndNullData.getCode());
assertEquals("", errorWithStatusAndEmptyMessageAndNullData.getMessage()); assertEquals("", errorWithStatusAndEmptyMessageAndNullData.getMessage());
assertNull(errorWithStatusAndEmptyMessageAndNullData.getData()); assertNull(errorWithStatusAndEmptyMessageAndNullData.getData());
final String jacksonErrorWithStatusAndEmptyMessageAndNullData = jackson.writeValueAsString(errorWithStatusAndEmptyMessageAndNullData); final String jacksonErrorWithStatusAndEmptyMessageAndNullData = jackson.writeValueAsString(errorWithStatusAndEmptyMessageAndNullData);
assertEquals("{\"status\":500,\"message\":\"\"}", jacksonErrorWithStatusAndEmptyMessageAndNullData); assertEquals("{\"code\":\"500\",\"message\":\"\"}", jacksonErrorWithStatusAndEmptyMessageAndNullData);
final String gsonErrorWithStatusAndEmptyMessageAndNullData = gson.toJson(errorWithStatusAndEmptyMessageAndNullData); final String gsonErrorWithStatusAndEmptyMessageAndNullData = gson.toJson(errorWithStatusAndEmptyMessageAndNullData);
assertEquals("{\"status\":500,\"message\":\"\"}", gsonErrorWithStatusAndEmptyMessageAndNullData); assertEquals("{\"code\":\"500\",\"message\":\"\"}", gsonErrorWithStatusAndEmptyMessageAndNullData);
} }
@Test @Test
void testError_WithStatusAndEmptyMessage_AndData() throws Exception { void testError_WithStatusAndEmptyMessage_AndData() throws Exception {
PageResult<User> emptyPageResult = PageResult.empty(); PageResult<User> emptyPageResult = PageResult.empty();
UnifiedResponse errorWithStatusAndEmptyMessageAndData = UnifiedResponse.error(500, "", emptyPageResult); UnifiedResponse<PageResult<User>> errorWithStatusAndEmptyMessageAndData = UnifiedResponse.error("500", "", emptyPageResult);
assertEquals(500, errorWithStatusAndEmptyMessageAndData.getStatus()); assertEquals("500", errorWithStatusAndEmptyMessageAndData.getCode());
assertEquals("", errorWithStatusAndEmptyMessageAndData.getMessage()); assertEquals("", errorWithStatusAndEmptyMessageAndData.getMessage());
assertEquals(emptyPageResult, errorWithStatusAndEmptyMessageAndData.getData()); assertEquals(emptyPageResult, errorWithStatusAndEmptyMessageAndData.getData());
final String jacksonErrorWithStatusAndEmptyMessageAndData = jackson.writeValueAsString(errorWithStatusAndEmptyMessageAndData); final String jacksonErrorWithStatusAndEmptyMessageAndData = jackson.writeValueAsString(errorWithStatusAndEmptyMessageAndData);
assertEquals("{\"status\":500,\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", jacksonErrorWithStatusAndEmptyMessageAndData); assertEquals("{\"code\":\"500\",\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", jacksonErrorWithStatusAndEmptyMessageAndData);
final String gsonErrorWithStatusAndEmptyMessageAndData = gson.toJson(errorWithStatusAndEmptyMessageAndData); final String gsonErrorWithStatusAndEmptyMessageAndData = gson.toJson(errorWithStatusAndEmptyMessageAndData);
assertEquals("{\"status\":500,\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", gsonErrorWithStatusAndEmptyMessageAndData); assertEquals("{\"code\":\"500\",\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", gsonErrorWithStatusAndEmptyMessageAndData);
} }
@Test @Test
void testError_WithStatusAndThrowable() throws Exception { void testError_WithStatusAndThrowable() throws Exception {
final IllegalArgumentException e = new IllegalArgumentException("ID cannot be null"); final IllegalArgumentException e = new IllegalArgumentException("ID cannot be null");
final UnifiedResponse errorWithStatusThrowable = UnifiedResponse.error(500, e); final UnifiedResponse<Void> errorWithStatusThrowable = UnifiedResponse.error("500", e);
assertEquals(500, errorWithStatusThrowable.getStatus()); assertEquals("500", errorWithStatusThrowable.getCode());
assertEquals("ID cannot be null", errorWithStatusThrowable.getMessage()); assertEquals("ID cannot be null", errorWithStatusThrowable.getMessage());
assertNull(errorWithStatusThrowable.getData()); assertNull(errorWithStatusThrowable.getData());
assertEquals("{\"status\":500,\"message\":\"ID cannot be null\"}", jackson.writeValueAsString(errorWithStatusThrowable)); assertEquals("{\"code\":\"500\",\"message\":\"ID cannot be null\"}", jackson.writeValueAsString(errorWithStatusThrowable));
assertEquals("{\"status\":500,\"message\":\"ID cannot be null\"}", gson.toJson(errorWithStatusThrowable)); assertEquals("{\"code\":\"500\",\"message\":\"ID cannot be null\"}", gson.toJson(errorWithStatusThrowable));
} }
@Test @Test
void testError_WithStatusAndNullThrowable() { void testError_WithStatusAndNullThrowable() {
assertThrows(NullPointerException.class, () -> UnifiedResponse.error(500, (Throwable) null)); assertThrows(NullPointerException.class, () -> UnifiedResponse.error("500", (Throwable) null));
} }
@Test @Test
void testError_WithNullStatus() { void testError_WithNullStatus() {
final Object nullStatus = null; final String nullStatus = null;
final String nullMessage = null; final String nullMessage = null;
final User user = new User("zhouxy", "zhouxy@gmail.com"); final User user = new User("zhouxy", "zhouxy@gmail.com");
@ -512,143 +386,143 @@ class UnifiedResponseTests {
@Test @Test
void testOf_WithStatusAndMessage() throws Exception { void testOf_WithStatusAndMessage() throws Exception {
final UnifiedResponse ofWithStatusAndMessage = UnifiedResponse.of(108, "This is a message."); final UnifiedResponse<Void> ofWithStatusAndMessage = UnifiedResponse.of("108", "This is a message.");
assertEquals(108, ofWithStatusAndMessage.getStatus()); assertEquals("108", ofWithStatusAndMessage.getCode());
assertEquals("This is a message.", ofWithStatusAndMessage.getMessage()); assertEquals("This is a message.", ofWithStatusAndMessage.getMessage());
assertNull(ofWithStatusAndMessage.getData()); assertNull(ofWithStatusAndMessage.getData());
final String jacksonOfWithStatusAndMessage = jackson.writeValueAsString(ofWithStatusAndMessage); final String jacksonOfWithStatusAndMessage = jackson.writeValueAsString(ofWithStatusAndMessage);
log.info("jacksonOfWithStatusAndMessage: {}", jacksonOfWithStatusAndMessage); log.info("jacksonOfWithStatusAndMessage: {}", jacksonOfWithStatusAndMessage);
assertEquals("{\"status\":108,\"message\":\"This is a message.\"}", jacksonOfWithStatusAndMessage); assertEquals("{\"code\":\"108\",\"message\":\"This is a message.\"}", jacksonOfWithStatusAndMessage);
assertEquals("{status: 108, message: \"This is a message.\", data: null}", ofWithStatusAndMessage.toString()); assertEquals("{code: \"108\", message: \"This is a message.\", data: null}", ofWithStatusAndMessage.toString());
final String gsonOfWithStatusAndMessage = gson.toJson(ofWithStatusAndMessage); final String gsonOfWithStatusAndMessage = gson.toJson(ofWithStatusAndMessage);
assertEquals("{\"status\":108,\"message\":\"This is a message.\"}", gsonOfWithStatusAndMessage); assertEquals("{\"code\":\"108\",\"message\":\"This is a message.\"}", gsonOfWithStatusAndMessage);
} }
@Test @Test
void testOf_WithStatusAndMessage_AndNullData() throws Exception { void testOf_WithStatusAndMessage_AndNullData() throws Exception {
final UnifiedResponse ofWithStatusAndMessageAndNullData = UnifiedResponse.of(108, "This is a message.", null); final UnifiedResponse<Void> ofWithStatusAndMessageAndNullData = UnifiedResponse.of("108", "This is a message.", null);
assertEquals(108, ofWithStatusAndMessageAndNullData.getStatus()); assertEquals("108", ofWithStatusAndMessageAndNullData.getCode());
assertEquals("This is a message.", ofWithStatusAndMessageAndNullData.getMessage()); assertEquals("This is a message.", ofWithStatusAndMessageAndNullData.getMessage());
assertNull(ofWithStatusAndMessageAndNullData.getData()); assertNull(ofWithStatusAndMessageAndNullData.getData());
final String jacksonOfWithStatusAndMessageAndNullData = jackson.writeValueAsString(ofWithStatusAndMessageAndNullData); final String jacksonOfWithStatusAndMessageAndNullData = jackson.writeValueAsString(ofWithStatusAndMessageAndNullData);
log.info("jacksonOfWithStatusAndMessage: {}", jacksonOfWithStatusAndMessageAndNullData); log.info("jacksonOfWithStatusAndMessage: {}", jacksonOfWithStatusAndMessageAndNullData);
assertEquals("{\"status\":108,\"message\":\"This is a message.\"}", jacksonOfWithStatusAndMessageAndNullData); assertEquals("{\"code\":\"108\",\"message\":\"This is a message.\"}", jacksonOfWithStatusAndMessageAndNullData);
assertEquals("{status: 108, message: \"This is a message.\", data: null}", ofWithStatusAndMessageAndNullData.toString()); assertEquals("{code: \"108\", message: \"This is a message.\", data: null}", ofWithStatusAndMessageAndNullData.toString());
final String gsonOfWithStatusAndMessageAndNullData = gson.toJson(ofWithStatusAndMessageAndNullData); final String gsonOfWithStatusAndMessageAndNullData = gson.toJson(ofWithStatusAndMessageAndNullData);
assertEquals("{\"status\":108,\"message\":\"This is a message.\"}", gsonOfWithStatusAndMessageAndNullData); assertEquals("{\"code\":\"108\",\"message\":\"This is a message.\"}", gsonOfWithStatusAndMessageAndNullData);
} }
@Test @Test
void testOf_WithStatusAndMessage_AndData() throws Exception { void testOf_WithStatusAndMessage_AndData() throws Exception {
final PageResult<User> emptyPageResult = PageResult.empty(); final PageResult<User> emptyPageResult = PageResult.empty();
final UnifiedResponse ofWithStatusAndMessageAndData final UnifiedResponse<PageResult<User>> ofWithStatusAndMessageAndData
= UnifiedResponse.of(108, "This is a message.", emptyPageResult); = UnifiedResponse.of("108", "This is a message.", emptyPageResult);
assertEquals("{status: 108, message: \"This is a message.\", data: PageResult [total=0, content=[]]}", assertEquals("{code: \"108\", message: \"This is a message.\", data: PageResult [total=0, content=[]]}",
ofWithStatusAndMessageAndData.toString()); ofWithStatusAndMessageAndData.toString());
assertEquals(108, ofWithStatusAndMessageAndData.getStatus()); assertEquals("108", ofWithStatusAndMessageAndData.getCode());
assertEquals("This is a message.", ofWithStatusAndMessageAndData.getMessage()); assertEquals("This is a message.", ofWithStatusAndMessageAndData.getMessage());
assertEquals(emptyPageResult, ofWithStatusAndMessageAndData.getData()); assertEquals(emptyPageResult, ofWithStatusAndMessageAndData.getData());
final String jacksonOfWithStatusAndMessageAndData = jackson.writeValueAsString(ofWithStatusAndMessageAndData); final String jacksonOfWithStatusAndMessageAndData = jackson.writeValueAsString(ofWithStatusAndMessageAndData);
assertEquals("{\"status\":108,\"message\":\"This is a message.\",\"data\":{\"total\":0,\"content\":[]}}", assertEquals("{\"code\":\"108\",\"message\":\"This is a message.\",\"data\":{\"total\":0,\"content\":[]}}",
jacksonOfWithStatusAndMessageAndData); jacksonOfWithStatusAndMessageAndData);
final String gsonOfWithStatusAndMessageAndData = gson.toJson(ofWithStatusAndMessageAndData); final String gsonOfWithStatusAndMessageAndData = gson.toJson(ofWithStatusAndMessageAndData);
assertEquals("{\"status\":108,\"message\":\"This is a message.\",\"data\":{\"total\":0,\"content\":[]}}", assertEquals("{\"code\":\"108\",\"message\":\"This is a message.\",\"data\":{\"total\":0,\"content\":[]}}",
gsonOfWithStatusAndMessageAndData); gsonOfWithStatusAndMessageAndData);
} }
@Test @Test
void testOf_WithStatusAndNullMessage() throws Exception { void testOf_WithStatusAndNullMessage() throws Exception {
UnifiedResponse ofWithStatusAndNullMessage = UnifiedResponse.of(108, (String) null); UnifiedResponse<Void> ofWithStatusAndNullMessage = UnifiedResponse.of("108", (String) null);
assertEquals(108, ofWithStatusAndNullMessage.getStatus()); assertEquals("108", ofWithStatusAndNullMessage.getCode());
assertEquals("", ofWithStatusAndNullMessage.getMessage()); assertEquals("", ofWithStatusAndNullMessage.getMessage());
assertNull(ofWithStatusAndNullMessage.getData()); assertNull(ofWithStatusAndNullMessage.getData());
final String jacksonOfWithStatusAndNullMessage = jackson.writeValueAsString(ofWithStatusAndNullMessage); final String jacksonOfWithStatusAndNullMessage = jackson.writeValueAsString(ofWithStatusAndNullMessage);
assertEquals("{\"status\":108,\"message\":\"\"}", jacksonOfWithStatusAndNullMessage); assertEquals("{\"code\":\"108\",\"message\":\"\"}", jacksonOfWithStatusAndNullMessage);
final String gsonOfWithStatusAndNullMessage = gson.toJson(ofWithStatusAndNullMessage); final String gsonOfWithStatusAndNullMessage = gson.toJson(ofWithStatusAndNullMessage);
assertEquals("{\"status\":108,\"message\":\"\"}", gsonOfWithStatusAndNullMessage); assertEquals("{\"code\":\"108\",\"message\":\"\"}", gsonOfWithStatusAndNullMessage);
} }
@Test @Test
void testOf_WithStatusAndNullMessage_AndNullData() throws Exception { void testOf_WithStatusAndNullMessage_AndNullData() throws Exception {
UnifiedResponse ofWithStatusAndNullMessageAndNullData = UnifiedResponse.of(108, (String) null, null); UnifiedResponse<Void> ofWithStatusAndNullMessageAndNullData = UnifiedResponse.of("108", (String) null, null);
assertEquals(108, ofWithStatusAndNullMessageAndNullData.getStatus()); assertEquals("108", ofWithStatusAndNullMessageAndNullData.getCode());
assertEquals("", ofWithStatusAndNullMessageAndNullData.getMessage()); assertEquals("", ofWithStatusAndNullMessageAndNullData.getMessage());
assertNull(ofWithStatusAndNullMessageAndNullData.getData()); assertNull(ofWithStatusAndNullMessageAndNullData.getData());
final String jacksonOfWithStatusAndNullMessageAndNullData = jackson.writeValueAsString(ofWithStatusAndNullMessageAndNullData); final String jacksonOfWithStatusAndNullMessageAndNullData = jackson.writeValueAsString(ofWithStatusAndNullMessageAndNullData);
assertEquals("{\"status\":108,\"message\":\"\"}", jacksonOfWithStatusAndNullMessageAndNullData); assertEquals("{\"code\":\"108\",\"message\":\"\"}", jacksonOfWithStatusAndNullMessageAndNullData);
final String gsonOfWithStatusAndNullMessageAndNullData = gson.toJson(ofWithStatusAndNullMessageAndNullData); final String gsonOfWithStatusAndNullMessageAndNullData = gson.toJson(ofWithStatusAndNullMessageAndNullData);
assertEquals("{\"status\":108,\"message\":\"\"}", gsonOfWithStatusAndNullMessageAndNullData); assertEquals("{\"code\":\"108\",\"message\":\"\"}", gsonOfWithStatusAndNullMessageAndNullData);
} }
@Test @Test
void testOf_WithStatusAndNullMessage_AndData() throws Exception { void testOf_WithStatusAndNullMessage_AndData() throws Exception {
PageResult<User> emptyPageResult = PageResult.empty(); PageResult<User> emptyPageResult = PageResult.empty();
UnifiedResponse ofWithStatusAndNullMessageAndData = UnifiedResponse.of(108, (String) null, emptyPageResult); UnifiedResponse<PageResult<User>> ofWithStatusAndNullMessageAndData = UnifiedResponse.of("108", (String) null, emptyPageResult);
assertEquals(108, ofWithStatusAndNullMessageAndData.getStatus()); assertEquals("108", ofWithStatusAndNullMessageAndData.getCode());
assertEquals("", ofWithStatusAndNullMessageAndData.getMessage()); assertEquals("", ofWithStatusAndNullMessageAndData.getMessage());
assertEquals(emptyPageResult, ofWithStatusAndNullMessageAndData.getData()); assertEquals(emptyPageResult, ofWithStatusAndNullMessageAndData.getData());
final String jacksonOfWithStatusAndNullMessageAndData = jackson.writeValueAsString(ofWithStatusAndNullMessageAndData); final String jacksonOfWithStatusAndNullMessageAndData = jackson.writeValueAsString(ofWithStatusAndNullMessageAndData);
assertEquals("{\"status\":108,\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", jacksonOfWithStatusAndNullMessageAndData); assertEquals("{\"code\":\"108\",\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", jacksonOfWithStatusAndNullMessageAndData);
final String gsonOfWithStatusAndNullMessageAndData = gson.toJson(ofWithStatusAndNullMessageAndData); final String gsonOfWithStatusAndNullMessageAndData = gson.toJson(ofWithStatusAndNullMessageAndData);
assertEquals("{\"status\":108,\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", gsonOfWithStatusAndNullMessageAndData); assertEquals("{\"code\":\"108\",\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", gsonOfWithStatusAndNullMessageAndData);
} }
@Test @Test
void testOf_WithStatusAndEmptyMessage() throws Exception { void testOf_WithStatusAndEmptyMessage() throws Exception {
UnifiedResponse ofWithStatusAndEmptyMessage = UnifiedResponse.of(108, ""); UnifiedResponse<Void> ofWithStatusAndEmptyMessage = UnifiedResponse.of("108", "");
assertEquals(108, ofWithStatusAndEmptyMessage.getStatus()); assertEquals("108", ofWithStatusAndEmptyMessage.getCode());
assertEquals("", ofWithStatusAndEmptyMessage.getMessage()); assertEquals("", ofWithStatusAndEmptyMessage.getMessage());
assertNull(ofWithStatusAndEmptyMessage.getData()); assertNull(ofWithStatusAndEmptyMessage.getData());
final String jacksonOfWithStatusAndEmptyMessage = jackson.writeValueAsString(ofWithStatusAndEmptyMessage); final String jacksonOfWithStatusAndEmptyMessage = jackson.writeValueAsString(ofWithStatusAndEmptyMessage);
assertEquals("{\"status\":108,\"message\":\"\"}", jacksonOfWithStatusAndEmptyMessage); assertEquals("{\"code\":\"108\",\"message\":\"\"}", jacksonOfWithStatusAndEmptyMessage);
final String gsonOfWithStatusAndEmptyMessage = gson.toJson(ofWithStatusAndEmptyMessage); final String gsonOfWithStatusAndEmptyMessage = gson.toJson(ofWithStatusAndEmptyMessage);
assertEquals("{\"status\":108,\"message\":\"\"}", gsonOfWithStatusAndEmptyMessage); assertEquals("{\"code\":\"108\",\"message\":\"\"}", gsonOfWithStatusAndEmptyMessage);
} }
@Test @Test
void testOf_WithStatusAndEmptyMessage_AndNullData() throws Exception { void testOf_WithStatusAndEmptyMessage_AndNullData() throws Exception {
UnifiedResponse ofWithStatusAndEmptyMessageAndNullData = UnifiedResponse.of(108, "", null); UnifiedResponse<Void> ofWithStatusAndEmptyMessageAndNullData = UnifiedResponse.of("108", "", null);
assertEquals(108, ofWithStatusAndEmptyMessageAndNullData.getStatus()); assertEquals("108", ofWithStatusAndEmptyMessageAndNullData.getCode());
assertEquals("", ofWithStatusAndEmptyMessageAndNullData.getMessage()); assertEquals("", ofWithStatusAndEmptyMessageAndNullData.getMessage());
assertNull(ofWithStatusAndEmptyMessageAndNullData.getData()); assertNull(ofWithStatusAndEmptyMessageAndNullData.getData());
final String jacksonOfWithStatusAndEmptyMessageAndNullData = jackson.writeValueAsString(ofWithStatusAndEmptyMessageAndNullData); final String jacksonOfWithStatusAndEmptyMessageAndNullData = jackson.writeValueAsString(ofWithStatusAndEmptyMessageAndNullData);
assertEquals("{\"status\":108,\"message\":\"\"}", jacksonOfWithStatusAndEmptyMessageAndNullData); assertEquals("{\"code\":\"108\",\"message\":\"\"}", jacksonOfWithStatusAndEmptyMessageAndNullData);
final String gsonOfWithStatusAndEmptyMessageAndNullData = gson.toJson(ofWithStatusAndEmptyMessageAndNullData); final String gsonOfWithStatusAndEmptyMessageAndNullData = gson.toJson(ofWithStatusAndEmptyMessageAndNullData);
assertEquals("{\"status\":108,\"message\":\"\"}", gsonOfWithStatusAndEmptyMessageAndNullData); assertEquals("{\"code\":\"108\",\"message\":\"\"}", gsonOfWithStatusAndEmptyMessageAndNullData);
} }
@Test @Test
void testOf_WithStatusAndEmptyMessage_AndData() throws Exception { void testOf_WithStatusAndEmptyMessage_AndData() throws Exception {
PageResult<User> emptyPageResult = PageResult.empty(); PageResult<User> emptyPageResult = PageResult.empty();
UnifiedResponse ofWithStatusAndEmptyMessageAndData = UnifiedResponse.of(108, "", emptyPageResult); UnifiedResponse<PageResult<User>> ofWithStatusAndEmptyMessageAndData = UnifiedResponse.of("108", "", emptyPageResult);
assertEquals(108, ofWithStatusAndEmptyMessageAndData.getStatus()); assertEquals("108", ofWithStatusAndEmptyMessageAndData.getCode());
assertEquals("", ofWithStatusAndEmptyMessageAndData.getMessage()); assertEquals("", ofWithStatusAndEmptyMessageAndData.getMessage());
assertEquals(emptyPageResult, ofWithStatusAndEmptyMessageAndData.getData()); assertEquals(emptyPageResult, ofWithStatusAndEmptyMessageAndData.getData());
final String jacksonOfWithStatusAndEmptyMessageAndData = jackson.writeValueAsString(ofWithStatusAndEmptyMessageAndData); final String jacksonOfWithStatusAndEmptyMessageAndData = jackson.writeValueAsString(ofWithStatusAndEmptyMessageAndData);
assertEquals("{\"status\":108,\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", jacksonOfWithStatusAndEmptyMessageAndData); assertEquals("{\"code\":\"108\",\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", jacksonOfWithStatusAndEmptyMessageAndData);
final String gsonOfWithStatusAndEmptyMessageAndData = gson.toJson(ofWithStatusAndEmptyMessageAndData); final String gsonOfWithStatusAndEmptyMessageAndData = gson.toJson(ofWithStatusAndEmptyMessageAndData);
assertEquals("{\"status\":108,\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", gsonOfWithStatusAndEmptyMessageAndData); assertEquals("{\"code\":\"108\",\"message\":\"\",\"data\":{\"total\":0,\"content\":[]}}", gsonOfWithStatusAndEmptyMessageAndData);
} }
@Test @Test
void testOf_WithNullStatus() { void testOf_WithNullStatus() {
final Object nullStatus = null; final String nullStatus = null;
final String nullMessage = null; final String nullMessage = null;
final User user = new User("zhouxy", "zhouxy@gmail.com"); final User user = new User("zhouxy", "zhouxy@gmail.com");