Skip to content

Commit 541751b

Browse files
authored
fix: reject unresolved POST and PUT references, thx to henriquejsza #876
#876
2 parents c96950f + ef5c519 commit 541751b

2 files changed

Lines changed: 314 additions & 0 deletions

File tree

‎APIJSONORM/src/main/java/apijson/orm/AbstractObjectParser.java‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -486,6 +486,11 @@ else if (value instanceof String) { // //key{}@ getRealKey, 引用赋值路径
486486
if (target == null) { // String#equals(null)会出错
487487
Log.d(TAG, "onParse target == null >> return true;");
488488

489+
if (method == POST || method == PUT) {
490+
throw new UnsupportedOperationException("引用赋值 " + path + "/" + key + ": " + targetPath
491+
+ " 解析失败,POST 和 PUT 接口必须保证每个对象执行都成功!");
492+
}
493+
489494
if (Log.DEBUG) {
490495
parser.putWarnIfNeed(AbstractParser.KEY_REF, path + "/" + key + ": " + targetPath + " 引用赋值获取路径对应的值为 null!请检查路径是否错误!");
491496
}
Lines changed: 309 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,309 @@
1+
package apijson.orm;
2+
3+
import apijson.JSON;
4+
import apijson.JSONParser;
5+
import apijson.RequestMethod;
6+
import apijson.orm.exception.CommonException;
7+
import org.junit.AfterClass;
8+
import org.junit.BeforeClass;
9+
import org.junit.Test;
10+
11+
import java.util.ArrayList;
12+
import java.util.LinkedHashMap;
13+
import java.util.List;
14+
import java.util.Map;
15+
16+
import static org.junit.Assert.assertEquals;
17+
import static org.junit.Assert.assertFalse;
18+
import static org.junit.Assert.assertNotNull;
19+
import static org.junit.Assert.assertNull;
20+
import static org.junit.Assert.assertSame;
21+
import static org.junit.Assert.assertTrue;
22+
import static org.junit.Assert.fail;
23+
24+
public class AbstractObjectParserReferenceTest {
25+
private static final String REFERENCE_KEY = "id@";
26+
private static final String TARGET_PATH = "Privacy/id";
27+
private static final String TRAILING_KEY = "afterReference";
28+
private static final long RESOLVED_VALUE = 42L;
29+
30+
private static JSONParser<? extends Map<String, Object>, ? extends List<Object>> previousJSONParser;
31+
32+
@BeforeClass
33+
public static void installJSONParser() {
34+
previousJSONParser = JSON.DEFAULT_JSON_PARSER;
35+
JSON.DEFAULT_JSON_PARSER = new JSONParser<Map<String, Object>, List<Object>>() {
36+
@Override
37+
public Map<String, Object> createJSONObject() {
38+
return new LinkedHashMap<>();
39+
}
40+
41+
@Override
42+
public List<Object> createJSONArray() {
43+
return new ArrayList<>();
44+
}
45+
46+
@Override
47+
public Object parse(Object json) {
48+
return json;
49+
}
50+
51+
@Override
52+
@SuppressWarnings("unchecked")
53+
public Map<String, Object> parseObject(Object json) {
54+
return (Map<String, Object>) json;
55+
}
56+
57+
@Override
58+
public <T> T parseObject(Object json, Class<T> clazz) {
59+
return clazz.cast(json);
60+
}
61+
62+
@Override
63+
@SuppressWarnings("unchecked")
64+
public List<Object> parseArray(Object json) {
65+
return (List<Object>) json;
66+
}
67+
68+
@Override
69+
@SuppressWarnings("unchecked")
70+
public <T> List<T> parseArray(Object json, Class<T> clazz) {
71+
return (List<T>) json;
72+
}
73+
74+
@Override
75+
public String toJSONString(Object obj, boolean format) {
76+
return String.valueOf(obj);
77+
}
78+
};
79+
}
80+
81+
@AfterClass
82+
public static void restoreJSONParser() {
83+
JSON.DEFAULT_JSON_PARSER = previousJSONParser;
84+
}
85+
86+
@Test
87+
public void rejectsUnresolvedPostTableReference() throws Exception {
88+
Fixture fixture = newFixture(RequestMethod.POST, true, null);
89+
90+
assertUnsupportedReference(fixture);
91+
}
92+
93+
@Test
94+
public void rejectsUnresolvedPutTableReference() throws Exception {
95+
Fixture fixture = newFixture(RequestMethod.PUT, true, null);
96+
97+
assertUnsupportedReference(fixture);
98+
}
99+
100+
@Test
101+
public void rejectsUnresolvedPostNonTableReference() throws Exception {
102+
Fixture fixture = newFixture(RequestMethod.POST, false, null);
103+
104+
assertUnsupportedReference(fixture);
105+
}
106+
107+
@Test
108+
public void keepsGetTableInvalidationForUnresolvedReference() throws Exception {
109+
Fixture fixture = newFixture(RequestMethod.GET, true, null);
110+
111+
assertNull(fixture.objectParser.parse(fixture.name, false));
112+
assertEquals(TARGET_PATH, fixture.parser.lastPath);
113+
}
114+
115+
@Test
116+
public void keepsDeleteTableInvalidationForUnresolvedReference() throws Exception {
117+
Fixture fixture = newFixture(RequestMethod.DELETE, true, null);
118+
119+
assertNull(fixture.objectParser.parse(fixture.name, false));
120+
assertEquals(TARGET_PATH, fixture.parser.lastPath);
121+
}
122+
123+
@Test
124+
public void keepsGetNonTableSkipForUnresolvedReference() throws Exception {
125+
Fixture fixture = newFixture(RequestMethod.GET, false, null);
126+
127+
assertSame(fixture.objectParser, fixture.objectParser.parse(fixture.name, false));
128+
assertEquals(TARGET_PATH, fixture.parser.lastPath);
129+
assertFalse(fixture.objectParser.getSQLRequest().containsKey(REFERENCE_KEY));
130+
assertEquals(Boolean.TRUE, fixture.objectParser.getSQLRequest().get(TRAILING_KEY));
131+
}
132+
133+
@Test
134+
public void resolvesPostReferenceAndContinuesParsing() throws Exception {
135+
Fixture fixture = newFixture(RequestMethod.POST, true, RESOLVED_VALUE);
136+
137+
assertSame(fixture.objectParser, fixture.objectParser.parse(fixture.name, false));
138+
assertEquals(TARGET_PATH, fixture.parser.lastPath);
139+
assertFalse(fixture.objectParser.getSQLRequest().containsKey(REFERENCE_KEY));
140+
assertEquals(Long.valueOf(RESOLVED_VALUE), fixture.objectParser.getSQLRequest().get("id"));
141+
assertEquals(Boolean.TRUE, fixture.objectParser.getSQLRequest().get(TRAILING_KEY));
142+
}
143+
144+
@Test
145+
public void rejectsUnresolvedCrudReferenceWithPostDirective() throws Exception {
146+
Map<String, Object> user = new LinkedHashMap<>();
147+
user.put(REFERENCE_KEY, TARGET_PATH);
148+
user.put(TRAILING_KEY, Boolean.TRUE);
149+
150+
Map<String, Object> request = new LinkedHashMap<>();
151+
request.put("User", user);
152+
request.put("@post", "User");
153+
154+
ReferenceParser parser = new ReferenceParser(null);
155+
Map<String, Object> verifiedRequest = parser.verifyCrud(request);
156+
Map<String, Object> verifiedUser = JSON.get(verifiedRequest, "User");
157+
assertSame(RequestMethod.POST, verifiedUser.get("@method"));
158+
159+
try {
160+
parser.onObjectParse(verifiedUser, null, "User", null, false, null);
161+
fail("The effective POST method must reject an unresolved reference");
162+
}
163+
catch (Exception e) {
164+
assertUnsupportedOperation(e);
165+
}
166+
167+
assertNotNull(parser.lastObjectParser);
168+
assertSame(RequestMethod.POST, parser.lastObjectParser.getMethod());
169+
assertEquals(TARGET_PATH, parser.lastPath);
170+
assertNotNull(parser.lastObjectParser.getSQLRequest());
171+
assertFalse(parser.lastObjectParser.getSQLRequest().containsKey(TRAILING_KEY));
172+
}
173+
174+
private static void assertUnsupportedReference(Fixture fixture) throws Exception {
175+
try {
176+
fixture.objectParser.parse(fixture.name, false);
177+
fail("Unresolved POST/PUT references must be rejected");
178+
}
179+
catch (Exception e) {
180+
assertUnsupportedOperation(e);
181+
}
182+
183+
assertEquals(TARGET_PATH, fixture.parser.lastPath);
184+
assertNotNull(fixture.objectParser.getSQLRequest());
185+
assertFalse("Entries after the unresolved reference must not be parsed",
186+
fixture.objectParser.getSQLRequest().containsKey(TRAILING_KEY));
187+
}
188+
189+
private static void assertUnsupportedOperation(Exception e) {
190+
Throwable cause = e instanceof CommonException && e.getCause() != null ? e.getCause() : e;
191+
assertTrue("Expected UnsupportedOperationException but got " + cause.getClass().getName(),
192+
cause instanceof UnsupportedOperationException);
193+
}
194+
195+
private static Fixture newFixture(RequestMethod method, boolean isTable, Object target) throws Exception {
196+
Map<String, Object> request = new LinkedHashMap<>();
197+
request.put(REFERENCE_KEY, TARGET_PATH);
198+
request.put(TRAILING_KEY, Boolean.TRUE);
199+
200+
ReferenceParser parser = new ReferenceParser(target);
201+
TestObjectParser objectParser = new TestObjectParser(request, isTable);
202+
objectParser.setParser(parser);
203+
objectParser.setMethod(method);
204+
205+
return new Fixture(parser, objectParser, isTable ? "User" : "metadata");
206+
}
207+
208+
private static final class Fixture {
209+
private final ReferenceParser parser;
210+
private final TestObjectParser objectParser;
211+
private final String name;
212+
213+
private Fixture(ReferenceParser parser, TestObjectParser objectParser, String name) {
214+
this.parser = parser;
215+
this.objectParser = objectParser;
216+
this.name = name;
217+
}
218+
}
219+
220+
private static final class TestObjectParser
221+
extends AbstractObjectParser<Long, Map<String, Object>, List<Object>> {
222+
private TestObjectParser(Map<String, Object> request, boolean isTable) throws Exception {
223+
super(request, null, null, false, isTable, false);
224+
}
225+
226+
@Override
227+
public SQLConfig<Long, Map<String, Object>, List<Object>> newSQLConfig(RequestMethod method,
228+
String table, String alias, Map<String, Object> request,
229+
List<Join<Long, Map<String, Object>, List<Object>>> joinList, boolean isProcedure) {
230+
return null;
231+
}
232+
}
233+
234+
private static final class ReferenceParser
235+
extends AbstractParser<Long, Map<String, Object>, List<Object>> {
236+
private final Object target;
237+
private String lastPath;
238+
private TestObjectParser lastObjectParser;
239+
240+
private ReferenceParser(Object target) {
241+
super(RequestMethod.CRUD, false);
242+
this.target = target;
243+
}
244+
245+
private Map<String, Object> verifyCrud(Map<String, Object> request) throws Exception {
246+
return batchVerify(RequestMethod.CRUD, null, 0, null, request, 10, this);
247+
}
248+
249+
@Override
250+
public Object getValueByPath(String valuePath) {
251+
lastPath = valuePath;
252+
return target;
253+
}
254+
255+
@Override
256+
protected Map<String, Object> getRequestStructure(RequestMethod method, String tag, int version) {
257+
return new LinkedHashMap<>();
258+
}
259+
260+
@Override
261+
protected Map<String, Object> objectVerify(RequestMethod method, String tag, int version, String name,
262+
Map<String, Object> request, int maxUpdateCount,
263+
SQLCreator<Long, Map<String, Object>, List<Object>> creator, Map<String, Object> object) {
264+
return request;
265+
}
266+
267+
@Override
268+
public Object onFunctionParse(String key, String function, String parentPath, String currentName,
269+
Map<String, Object> currentObject, boolean containRaw) {
270+
return null;
271+
}
272+
273+
@Override
274+
public ObjectParser<Long, Map<String, Object>, List<Object>> createObjectParser(
275+
Map<String, Object> request, String parentPath,
276+
SQLConfig<Long, Map<String, Object>, List<Object>> arrayConfig,
277+
boolean isSubquery, boolean isTable, boolean isArrayMainTable) throws Exception {
278+
TestObjectParser objectParser = new TestObjectParser(request, isTable);
279+
objectParser.setParser(this);
280+
lastObjectParser = objectParser;
281+
return objectParser;
282+
}
283+
284+
@Override
285+
public Parser<Long, Map<String, Object>, List<Object>> createParser() {
286+
return new ReferenceParser(target);
287+
}
288+
289+
@Override
290+
public FunctionParser<Long, Map<String, Object>, List<Object>> createFunctionParser() {
291+
return null;
292+
}
293+
294+
@Override
295+
public Verifier<Long, Map<String, Object>, List<Object>> createVerifier() {
296+
return null;
297+
}
298+
299+
@Override
300+
public SQLConfig<Long, Map<String, Object>, List<Object>> createSQLConfig() {
301+
return null;
302+
}
303+
304+
@Override
305+
public SQLExecutor<Long, Map<String, Object>, List<Object>> createSQLExecutor() {
306+
return null;
307+
}
308+
}
309+
}

0 commit comments

Comments
 (0)