|
| 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